On master: provider-filter-and-dropdown-work

index on master: 0342caa chore: Bump version to 2.8.8-beta
chore: Bump version to 2.8.8-beta
2026-01-17 00:31:17 +00:00 · 2026-01-17 00:31:17 +00:00 · 2026-01-16 09:51:22 +00:00 · 2026-01-16 08:33:50 +00:00 · 2026-01-15 20:04:04 +00:00 · 2026-01-15 06:07:33 +00:00
131 changed files with 42554 additions and 6606 deletions
@@ -35,12 +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

@@ -62,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
@@ -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)
@@ -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**
@@ -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.*
@@ -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
@@ -0,0 +1,257 @@
+# Ensemble Codebase Audit Report
+
+**Date**: 2026-01-14
+**Scope**: Full codebase audit (104 Dart files, 18 screens)
+**Focus Areas**: UI Continuity, Performance, Logic/Best Practices
+
+---
+
+## Executive Summary
+
+The Ensemble codebase is a **mature, feature-rich Flutter application** with many good patterns already in place. However, the audit identified **significant architectural debt** that should be addressed:
+
+| Severity | Count | Key Themes |
+|----------|-------|------------|
+| **Critical** | 6 | God classes (5,443 & 4,209 lines), design token adoption, startup blocking |
+| **High** | 15 | Touch targets, batch DB operations, over-notification, code duplication |
+| **Medium** | 25+ | Inconsistencies, memory issues, missing error boundaries |
+| **Low** | 15+ | Minor polish items |
+
+**Top 3 Priorities:**
+1. **Split `MusicAssistantProvider` (5,443 lines)** - God object handling everything
+2. **Split `new_library_screen.dart` (4,209 lines)** - 10 scroll controllers, 15+ view modes
+3. **Fix startup performance** - Sequential blocking ops could save 1-8 seconds
+
+---
+
+## Critical Issues
+
+### 1. God Object: MusicAssistantProvider (5,443 lines)
+**File**: `lib/providers/music_assistant_provider.dart`
+- 54 `notifyListeners()` calls
+- 30+ state variables
+- 100+ public methods
+- Handles: connection, auth, players, library, search, caching, local playback, Sendspin
+- **Fix**: Split into ConnectionManager, PlayerStateManager, LibraryStateManager, SearchStateManager
+
+### 2. God Object: NewLibraryScreen (4,209 lines)
+**File**: `lib/screens/new_library_screen.dart`
+- 10 scroll controllers
+- 15+ view mode states
+- 15+ sort order states
+- Handles: Music, Books, Podcasts, Radio tabs
+- **Fix**: Extract to ArtistsTab, AlbumsTab, TracksTab, PlaylistsTab, BooksTab, PodcastsTab, RadioTab
+
+### 3. Sequential Blocking Startup (500-1500ms wasted)
+**File**: `lib/main.dart:33-66`
+```dart
+await DatabaseService.instance.initialize();
+await ProfileService.instance.migrateFromOwnerName();
+await SettingsService.migrateToSecureStorage();
+await SyncService.instance.loadFromCache();
+audioHandler = await AudioService.init(...);
+```
+- **Fix**: Parallelize with `Future.wait()`, defer AudioService to post-first-frame
+
+### 4. Design Tokens Exist But Unused
+**File**: `lib/theme/design_tokens.dart`
+- `Spacing.*` used in only ~6 of 34+ widget files
+- `Radii.*` used in only ~5 files
+- `IconSizes.*` used in only ~4 files
+- **Fix**: Systematic replacement of hardcoded values
+
+### 5. Touch Targets Too Small (32x32)
+**File**: `lib/screens/new_library_screen.dart:1805-1867`
+- Sort, favorites, view mode buttons are 32x32
+- Material Design minimum: 48x48
+- **Fix**: Increase to 48x48 or add padding for hit area
+
+### 6. No Batch Database Inserts
+**File**: `lib/services/sync_service.dart:212-273`
+- 1000 albums = 1000 separate DB transactions
+- **Fix**: Wrap in single transaction or use Drift batch insert
+
+---
+
+## High Severity Issues
+
+### Performance
+| Issue | File | Impact |
+|-------|------|--------|
+| `context.watch()` in nested tabs | new_library_screen.dart:2960 | All tabs rebuild on any provider change |
+| Consumer wrapping 800-line player | expandable_player.dart:1234 | Full rebuild on every state change |
+| Inline sorting during build | new_library_screen.dart:3647 | 5-20ms for 1000+ albums |
+| Multiple setState for author images | new_library_screen.dart:1017 | 20+ rebuilds as images load |
+| SecureStorage migration every startup | secure_storage_service.dart:103 | 100-300ms wasted |
+
+### Architecture
+| Issue | File | Impact |
+|-------|------|--------|
+| State duplication across 4 providers | providers/*.dart | Maintenance burden, sync issues |
+| 8 duplicate `_cycle*ViewMode()` methods | new_library_screen.dart:251-402 | DRY violation |
+| 60+ duplicate getter/setter pairs | settings_service.dart:500-1000 | Code bloat |
+| Global singleton NavigationProvider | navigation_provider.dart:40 | Untestable |
+| CacheService duplicated in providers | Multiple | Memory waste, inconsistency |
+
+### UI/UX
+| Issue | File | Impact |
+|-------|------|--------|
+| Hardcoded bottom spacing (140, 164, 100) | Multiple detail screens | Content obscured by player |
+| Inconsistent button sizes (44 vs 50) | Multiple screens | Visual disharmony |
+| No debounce on card taps | album_card.dart:118 | Double navigation possible |
+| Missing PopScope on AudiobookSeriesScreen | audiobook_series_screen.dart:276 | Adaptive colors not cleared |
+
+### Error Handling
+| Issue | File | Impact |
+|-------|------|--------|
+| No Flutter error boundaries | main.dart | Red error screen on build failure |
+| API returns empty list on error | music_assistant_api.dart | Can't distinguish error from empty |
+
+---
+
+## Medium Severity Issues
+
+### Performance
+- PaletteGenerator on main isolate (10-30ms blocking)
+- Multiple `SharedPreferences.getInstance()` calls (132 occurrences)
+- AppStartup polling loop with fixed 250ms delay
+- SystemThemeHelper FutureBuilder recreated on every build
+
+### UI Consistency
+- Border radius varies: 8, 12, 20, 22, 25 for same element types
+- `SizedBox(height: 8)` appears 40+ times instead of `Spacing.vGap8`
+- Hardcoded colors for status (Colors.red, Colors.green)
+- Inconsistent icon sizes across screens
+
+### State Management
+- Over-notification (multiple notifyListeners in single methods)
+- Wide Consumer scope (watch instead of select)
+- Missing dispose() in some providers
+- Inconsistent async state handling (loading/error)
+
+### Navigation
+- `isQueuePanelOpen` vs `isQueuePanelTargetOpen` inconsistency
+- `popToHome()` doesn't clear adaptive colors
+- Infinite navigation loop possible (Album → Artist → Album)
+- Orphaned Hero animations in podcast_card, radio_station_card
+
+### Data/Caching
+- Unbounded `_podcastCoverCache`
+- SyncService listener not removed on error
+- Redundant API calls between providers
+- Fire-and-forget persistence race condition
+
+### Error Handling
+- No zone error handler for async exceptions
+- `retryCritical()` retries all errors including non-recoverable
+- No user notification of offline queue status
+- DisconnectedState not used consistently
+
+---
+
+## Quick Wins (High Impact, Low Effort)
+
+| # | Task | File(s) | Effort |
+|---|------|---------|--------|
+| 1 | Replace hardcoded bottom spacing with `BottomSpacing.withMiniPlayer` | Detail screens | 30 min |
+| 2 | Add navigation debounce to card widgets | album_card, artist_card, etc. | 1 hr |
+| 3 | Fix touch targets to 48x48 minimum | new_library_screen.dart | 15 min |
+| 4 | Add migration skip flag for SecureStorage | secure_storage_service.dart | 30 min |
+| 5 | Add Flutter error boundary | main.dart | 30 min |
+| 6 | Use `context.select()` instead of `context.watch()` | global_player_overlay, etc. | 2 hr |
+| 7 | Cache `SharedPreferences.getInstance()` | settings_service.dart | 30 min |
+
+---
+
+## Refactoring Roadmap
+
+### Phase 1: Quick Wins (1-2 days)
+- Fix touch targets
+- Fix bottom spacing
+- Add navigation debounce
+- Add error boundaries
+- Cache SharedPreferences singleton
+
+### Phase 2: Performance (3-5 days)
+- Parallelize startup operations
+- Replace `context.watch()` with `context.select()`
+- Batch database inserts
+- Add SecureStorage migration skip flag
+- Fix over-notification in provider
+
+### Phase 3: Design System (1 week)
+- Systematic design token adoption
+- Standardize button sizes (44 vs 50)
+- Standardize border radius values
+- Create StatusColors semantic tokens
+- Replace all magic numbers
+
+### Phase 4: Architecture (2-3 weeks)
+- ~~Split MusicAssistantProvider into focused managers~~ **DEFERRED** - MusicAssistantProvider has evolved with Sendspin, Cast-Sendspin ID mapping, position tracker integration. Splitting would require ~1600 lines of sync work. Code is working and tested.
+- ~~Split new_library_screen into tab widgets~~ **DEFERRED** - Tabs have tight state coupling (15+ view modes, 15+ sort orders, 10 scroll controllers). Extraction would require InheritedWidget/callbacks for all shared state. Risk outweighs benefit.
+- ✅ Extract generic helpers for SettingsService - Reduced from 1,031 to 874 lines (~15%)
+- ✅ Remove/integrate unused providers - Deleted PlayerProvider (964 lines), LibraryProvider, ConnectionProvider (651 lines total)
+- ~~Split music_assistant_api.dart by domain~~ **DEFERRED** - All methods share WebSocket connection and auth state. Clean extraction would require connection manager abstraction.
+
+---
+
+## Positive Findings
+
+The codebase already demonstrates many good practices:
+
+- **Performance awareness**: `// PERF:` comments, RepaintBoundary (55 occurrences), image caching (80 memCacheWidth/Height)
+- **Caching**: Multi-tier caching with LRU eviction, proper TTLs, proper DB indexes
+- **Error handling**: DebugLogger, RetryHelper, OfflineActionQueue well-implemented
+- **Theme system**: Material You support, adaptive colors from album art
+- **Offline support**: Cache-first loading, graceful degradation
+- **Navigation**: Consistent FadeSlidePageRoute, proper Hero animations (mostly)
+
+---
+
+## Files by Priority
+
+| Priority | File | Lines | Key Issues |
+|----------|------|-------|------------|
+| 1 | music_assistant_provider.dart | 5,443 | God object, over-notification |
+| 2 | new_library_screen.dart | 4,209 | God class, performance, touch targets |
+| 3 | main.dart | 549 | Startup blocking, error boundaries |
+| 4 | music_assistant_api.dart | 3,434 | Silent failures, needs splitting |
+| 5 | settings_service.dart | 1,019 | Code duplication, no caching |
+| 6 | expandable_player.dart | ~800 | Wide Consumer scope |
+| 7 | global_player_overlay.dart | ~500 | BottomSpacing source, Consumer scope |
+| 8 | All detail screens | Various | Hardcoded bottom spacing |
+| 9 | All card widgets | Various | Navigation debounce, design tokens |
+
+---
+
+## Audit Methodology
+
+This audit was conducted using 9 parallel sub-agents analyzing:
+
+**UI Continuity (3 agents)**
+1. Navigation & Flow - back button, Hero animations, tab preservation
+2. Visual Consistency - design tokens, spacing, typography
+3. Component Placement - touch targets, bottom spacing, modals
+
+**Performance (3 agents)**
+4. Rendering Performance - ListView.builder, const, rebuilds
+5. Data & Caching - streams, invalidation, memory bounds
+6. Startup & Load Time - blocking operations, initialization order
+
+**Logic/Best Practices (3 agents)**
+7. State Management - Provider patterns, notification frequency
+8. Error Handling - try-catch, boundaries, resilience
+9. Code Quality - file size, duplication, SOLID principles
+
+---
+
+## Conclusion
+
+The Ensemble app is well-architected at the macro level but has accumulated technical debt in its largest files. The most impactful improvements would be:
+
+1. **Splitting the two 4,000+ line files** into focused components
+2. **Adopting design tokens systematically** for visual consistency
+3. **Optimizing startup sequence** for faster app launch
+4. **Using granular state management** (select vs watch) for better performance
+
+The quick wins section provides immediate value with minimal risk, while the roadmap offers a path to sustainable improvement.
@@ -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`
@@ -20,44 +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
- **Audiobooks Tab** - Browse your audiobook library with grid/list view options
- **Series Support** - View audiobooks organized by series with collage cover art
- **Author Browsing** - Browse audiobooks by author
 - **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
 - **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
@@ -67,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
@@ -85,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

@@ -104,7 +144,7 @@ Ensemble supports multiple authentication methods:

 ## Requirements

- Music Assistant server (v2.7.0 beta 20 or later)
+- Music Assistant server (v2.7.0 beta 20 or later recommended)
 - Network connectivity to your Music Assistant server
 - Android device (Android 5.0+)
 - Audiobookshelf provider configured in Music Assistant (for audiobook features)
@@ -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 |
@@ -11,6 +11,7 @@
        android:label="Ensemble"
        android:name="${applicationName}"
        android:icon="@mipmap/ic_launcher"
+        android:appCategory="audio"
        android:usesCleartextTraffic="true"
        android:networkSecurityConfig="@xml/network_security_config">
        <activity
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
+  <background android:drawable="@color/ic_launcher_background"/>
+  <foreground android:drawable="@drawable/ic_launcher_foreground"/>
+</adaptive-icon>
@@ -1,4 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
 <resources>
    <color name="launch_background_color">#1a1a1a</color>
-</resources>
+	<color name="ic_launcher_background">#1a1a1a</color>
+</resources>
@@ -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()
    }
 }
@@ -0,0 +1,5 @@
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.0-all.zip
@@ -0,0 +1,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' }
+        }
+    }
+}
@@ -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
@@ -25,4 +25,22 @@ class HeroTags {

  /// Audiobook author image hero tag prefix
  static const String authorImage = 'author_image_';
+
+  /// Podcast cover hero tag prefix
+  static const String podcastCover = 'podcast_cover_';
+
+  /// Podcast title hero tag prefix
+  static const String podcastTitle = 'podcast_title_';
+
+  /// 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_';
 }
@@ -31,6 +31,9 @@ class Timings {
  /// Search debounce delay
  static const Duration searchDebounce = Duration(milliseconds: 500);

+  /// Navigation debounce to prevent double-tap navigation
+  static const Duration navigationDebounce = Duration(milliseconds: 500);
+
  /// Delay after track change before updating state
  static const Duration trackChangeDelay = Duration(milliseconds: 500);
 }
@@ -25,6 +25,8 @@ class Profiles extends Table {
 }

 /// 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()();
@@ -55,6 +57,8 @@ class RecentlyPlayed extends Table {
 }

 /// 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()();
@@ -93,12 +97,101 @@ class SyncMetadata extends Table {
  Set<Column> get primaryKey => {syncType};
 }

-@DriftDatabase(tables: [Profiles, RecentlyPlayed, LibraryCache, SyncMetadata])
+/// 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 => 1;
+  int get schemaVersion => 5;

  @override
  MigrationStrategy get migration {
@@ -107,7 +200,32 @@ class AppDatabase extends _$AppDatabase {
        await m.createAll();
      },
      onUpgrade: (Migrator m, int from, int to) async {
-        // Future migrations will go here
+        // 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)');
+        }
      },
    );
  }
@@ -327,4 +445,209 @@ class AppDatabase extends _$AppDatabase {
    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();
+  }
 }
@@ -0,0 +1,299 @@
+{
+  "@@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",
+  "french": "Französisch",
+
+  "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"
+}
@@ -0,0 +1,495 @@
+{
+  "@@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",
+  "french": "Francés",
+  "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"
+}
@@ -0,0 +1,983 @@
+import 'package:intl/intl.dart' as intl;
+
+import 'app_localizations.dart';
+
+// ignore_for_file: type=lint
+
+/// The translations for German (`de`).
+class SDe extends S {
+  SDe([String locale = 'de']) : super(locale);
+
+  @override
+  String get appTitle => 'Ensemble';
+
+  @override
+  String get connecting => 'Verbinde...';
+
+  @override
+  String get connected => 'Verbunden';
+
+  @override
+  String get disconnected => 'Getrennt';
+
+  @override
+  String get serverAddress => 'Serveradresse';
+
+  @override
+  String get serverAddressHint => 'z.B. music.example.com oder 192.168.1.100';
+
+  @override
+  String get yourName => 'Dein Name';
+
+  @override
+  String get yourFirstName => 'Dein Vorname';
+
+  @override
+  String get portOptional => 'Port (Optional)';
+
+  @override
+  String get portHint => 'z.B. 8095 oder leer lassen';
+
+  @override
+  String get portDescription => 'Leer lassen bei Reverse Proxy oder Standardports. 8095 eingeben bei Direktverbindung.';
+
+  @override
+  String get username => 'Benutzername';
+
+  @override
+  String get password => 'Passwort';
+
+  @override
+  String get detectAndConnect => 'Erkennen & Verbinden';
+
+  @override
+  String get connect => 'Verbinden';
+
+  @override
+  String get disconnect => 'Trennen';
+
+  @override
+  String get authServerUrlOptional => 'Auth-Server URL (Optional)';
+
+  @override
+  String get authServerUrlHint => 'z.B. auth.example.com (wenn abweichend vom Server)';
+
+  @override
+  String get authServerUrlDescription => 'Leer lassen, wenn Authentifizierung auf demselben Server';
+
+  @override
+  String detectedAuthType(String authType) {
+    return 'Erkannt: $authType';
+  }
+
+  @override
+  String get serverRequiresAuth => 'Dieser Server erfordert Authentifizierung';
+
+  @override
+  String get tailscaleVpnConnection => 'Tailscale VPN-Verbindung';
+
+  @override
+  String get unencryptedConnection => 'Unverschlusselte Verbindung';
+
+  @override
+  String get usingHttpOverTailscale => 'HTTP uber Tailscale (verschlusselter Tunnel)';
+
+  @override
+  String get httpsFailedUsingHttp => 'HTTPS fehlgeschlagen, verwende HTTP';
+
+  @override
+  String get httpNotEncrypted => 'HTTP-Verbindung - Daten sind nicht verschlusselt';
+
+  @override
+  String get pleaseEnterServerAddress => 'Bitte gib deine Music Assistant Serveradresse ein';
+
+  @override
+  String get pleaseEnterName => 'Bitte gib deinen Namen ein';
+
+  @override
+  String get pleaseEnterValidPort => 'Bitte gib eine gultige Portnummer ein (1-65535)';
+
+  @override
+  String get pleaseEnterCredentials => 'Bitte gib Benutzername und Passwort ein';
+
+  @override
+  String get authFailed => 'Authentifizierung fehlgeschlagen. Bitte uberprufe deine Anmeldedaten.';
+
+  @override
+  String get maLoginFailed => 'Music Assistant Anmeldung fehlgeschlagen. Bitte uberprufe deine Anmeldedaten.';
+
+  @override
+  String get connectionFailed => 'Verbindung zum Server fehlgeschlagen. Bitte uberprufe die Adresse und versuche es erneut.';
+
+  @override
+  String get detectingAuth => 'Erkenne Authentifizierung...';
+
+  @override
+  String get cannotDetermineAuth => 'Authentifizierungsanforderungen konnten nicht ermittelt werden. Bitte uberprufe die Server-URL.';
+
+  @override
+  String get noAuthentication => 'Keine Authentifizierung';
+
+  @override
+  String get httpBasicAuth => 'HTTP Basic Auth';
+
+  @override
+  String get authelia => 'Authelia';
+
+  @override
+  String get musicAssistantLogin => 'Music Assistant Anmeldung';
+
+  @override
+  String get pressBackToMinimize => 'Erneut drucken zum Minimieren';
+
+  @override
+  String get recentlyPlayed => 'Zuletzt gespielt';
+
+  @override
+  String get discoverArtists => 'Kunstler entdecken';
+
+  @override
+  String get discoverAlbums => 'Alben entdecken';
+
+  @override
+  String get continueListening => 'Weiterhoren';
+
+  @override
+  String get discoverAudiobooks => 'Horbücher entdecken';
+
+  @override
+  String get discoverSeries => 'Serien entdecken';
+
+  @override
+  String get favoriteAlbums => 'Lieblingsalben';
+
+  @override
+  String get favoriteArtists => 'Lieblingskünstler';
+
+  @override
+  String get favoriteTracks => 'Lieblingssongs';
+
+  @override
+  String get favoritePlaylists => 'Favorite Playlists';
+
+  @override
+  String get favoriteRadioStations => 'Favorite Radio Stations';
+
+  @override
+  String get favoritePodcasts => 'Favorite Podcasts';
+
+  @override
+  String get searchMusic => 'Musik suchen...';
+
+  @override
+  String get searchForContent => 'Nach Künstlern, Alben oder Songs suchen';
+
+  @override
+  String get recentSearches => 'Recent Searches';
+
+  @override
+  String get clearSearchHistory => 'Clear Search History';
+
+  @override
+  String get searchHistoryCleared => 'Search history cleared';
+
+  @override
+  String get libraryOnly => 'Library only';
+
+  @override
+  String get retry => 'Wiederholen';
+
+  @override
+  String get all => 'Alle';
+
+  @override
+  String get artists => 'Künstler';
+
+  @override
+  String get albums => 'Alben';
+
+  @override
+  String get tracks => 'Songs';
+
+  @override
+  String get playlists => 'Wiedergabelisten';
+
+  @override
+  String get audiobooks => 'Hörbücher';
+
+  @override
+  String get music => 'Musik';
+
+  @override
+  String get radio => 'Radio';
+
+  @override
+  String get stations => 'Sender';
+
+  @override
+  String get selectLibrary => 'Bibliothek auswählen';
+
+  @override
+  String get noRadioStations => 'Keine Radiosender';
+
+  @override
+  String get addRadioStationsHint => 'Füge Radiosender in Music Assistant hinzu';
+
+  @override
+  String get searchFailed => 'Suche fehlgeschlagen. Bitte überprüfe deine Verbindung.';
+
+  @override
+  String get queue => 'Warteschlange';
+
+  @override
+  String playerQueue(String playerName) {
+    return '$playerName Warteschlange';
+  }
+
+  @override
+  String get noPlayerSelected => 'Kein Player ausgewählt';
+
+  @override
+  String get undo => 'Rückgängig';
+
+  @override
+  String removedItem(String itemName) {
+    return '$itemName entfernt';
+  }
+
+  @override
+  String get settings => 'Einstellungen';
+
+  @override
+  String get debugLogs => 'Debug-Protokolle';
+
+  @override
+  String get themeMode => 'Design';
+
+  @override
+  String get light => 'Hell';
+
+  @override
+  String get dark => 'Dunkel';
+
+  @override
+  String get system => 'System';
+
+  @override
+  String get pullToRefresh => 'Ziehe zum Aktualisieren der Bibliothek';
+
+  @override
+  String get viewDebugLogs => 'Debug-Protokolle anzeigen';
+
+  @override
+  String get viewAllPlayers => 'Alle Player anzeigen';
+
+  @override
+  String get copyLogs => 'Protokolle kopieren';
+
+  @override
+  String get clearLogs => 'Protokolle löschen';
+
+  @override
+  String get copyList => 'Liste kopieren';
+
+  @override
+  String get close => 'Schließen';
+
+  @override
+  String allPlayersCount(int count) {
+    return 'Alle Player ($count)';
+  }
+
+  @override
+  String errorLoadingPlayers(String error) {
+    return 'Fehler beim Laden der Player: $error';
+  }
+
+  @override
+  String get logsCopied => 'Protokolle in Zwischenablage kopiert';
+
+  @override
+  String get logsCleared => 'Protokolle gelöscht';
+
+  @override
+  String get playerListCopied => 'Playerliste in Zwischenablage kopiert!';
+
+  @override
+  String get noLogsYet => 'Noch keine Protokolle';
+
+  @override
+  String get infoPlus => 'Info+';
+
+  @override
+  String get warnings => 'Warnungen';
+
+  @override
+  String get errors => 'Fehler';
+
+  @override
+  String showingEntries(int filtered, int total) {
+    return 'Zeige $filtered von $total Einträgen';
+  }
+
+  @override
+  String get thisDevice => 'Dieses Gerät';
+
+  @override
+  String get ghostPlayer => 'Geist-Player (Duplikat)';
+
+  @override
+  String get unavailableCorrupt => 'Nicht verfügbar/Beschädigt';
+
+  @override
+  String playerId(String id) {
+    return 'ID: $id';
+  }
+
+  @override
+  String playerInfo(String available, String provider) {
+    return 'Verfügbar: $available | Anbieter: $provider';
+  }
+
+  @override
+  String get shareBugReport => 'Fehlerbericht teilen';
+
+  @override
+  String get moreOptions => 'Weitere Optionen';
+
+  @override
+  String failedToUpdateFavorite(String error) {
+    return 'Favorit konnte nicht aktualisiert werden: $error';
+  }
+
+  @override
+  String get noPlayersAvailable => 'Keine Player verfügbar';
+
+  @override
+  String get albumAddedToQueue => 'Album zur Warteschlange hinzugefügt';
+
+  @override
+  String get tracksAddedToQueue => 'Songs zur Warteschlange hinzugefügt';
+
+  @override
+  String get play => 'Abspielen';
+
+  @override
+  String get noPlayersFound => 'Keine Player gefunden';
+
+  @override
+  String startingRadio(String name) {
+    return 'Starte $name Radio';
+  }
+
+  @override
+  String failedToStartRadio(String error) {
+    return 'Radio konnte nicht gestartet werden: $error';
+  }
+
+  @override
+  String startingRadioOnPlayer(String name, String playerName) {
+    return 'Starte $name Radio auf $playerName';
+  }
+
+  @override
+  String addedRadioToQueue(String name) {
+    return '$name Radio zur Warteschlange hinzugefügt';
+  }
+
+  @override
+  String failedToAddToQueue(String error) {
+    return 'Konnte nicht zur Warteschlange hinzufügen: $error';
+  }
+
+  @override
+  String playingRadioStation(String name) {
+    return 'Playing $name';
+  }
+
+  @override
+  String get addedToQueue => 'Added to queue';
+
+  @override
+  String get inLibrary => 'In Bibliothek';
+
+  @override
+  String get noAlbumsFound => 'Keine Alben gefunden';
+
+  @override
+  String playing(String name) {
+    return 'Spiele $name';
+  }
+
+  @override
+  String get playingTrack => 'Spiele Song';
+
+  @override
+  String get nowPlaying => 'Wird gespielt';
+
+  @override
+  String markedAsFinished(String name) {
+    return '$name als beendet markiert';
+  }
+
+  @override
+  String failedToMarkFinished(String error) {
+    return 'Konnte nicht als beendet markieren: $error';
+  }
+
+  @override
+  String markedAsUnplayed(String name) {
+    return '$name als ungespielt markiert';
+  }
+
+  @override
+  String failedToMarkUnplayed(String error) {
+    return 'Konnte nicht als ungespielt markieren: $error';
+  }
+
+  @override
+  String failedToPlay(String error) {
+    return 'Abspielen fehlgeschlagen: $error';
+  }
+
+  @override
+  String get markAsFinished => 'Als beendet markieren';
+
+  @override
+  String get markAsUnplayed => 'Als ungespielt markieren';
+
+  @override
+  String byAuthor(String author) {
+    return 'Von $author';
+  }
+
+  @override
+  String audiobookCount(int count) {
+    return '$count Hörbuch/Hörbücher';
+  }
+
+  @override
+  String get loading => 'Laden...';
+
+  @override
+  String bookCount(int count) {
+    return '$count Buch/Bücher';
+  }
+
+  @override
+  String get books => 'Bücher';
+
+  @override
+  String get noFavoriteAudiobooks => 'Keine Lieblingshörbücher';
+
+  @override
+  String get tapHeartAudiobook => 'Tippe auf das Herz bei einem Hörbuch, um es zu Favoriten hinzuzufügen';
+
+  @override
+  String get noAudiobooks => 'Keine Hörbücher';
+
+  @override
+  String get addAudiobooksHint => 'Füge Hörbücher zu deiner Bibliothek hinzu, um sie hier zu sehen';
+
+  @override
+  String get noFavoriteArtists => 'Keine Lieblingskünstler';
+
+  @override
+  String get tapHeartArtist => 'Tippe auf das Herz bei einem Künstler, um ihn zu Favoriten hinzuzufügen';
+
+  @override
+  String get noFavoriteAlbums => 'Keine Lieblingsalben';
+
+  @override
+  String get tapHeartAlbum => 'Tippe auf das Herz bei einem Album, um es zu Favoriten hinzuzufügen';
+
+  @override
+  String get noFavoritePlaylists => 'Keine Lieblings-Wiedergabelisten';
+
+  @override
+  String get tapHeartPlaylist => 'Tippe auf das Herz bei einer Wiedergabeliste, um sie zu Favoriten hinzuzufügen';
+
+  @override
+  String get noFavoriteTracks => 'Keine Lieblingssongs';
+
+  @override
+  String get longPressTrackHint => 'Halte einen Song gedrückt und tippe auf das Herz, um ihn zu Favoriten hinzuzufügen';
+
+  @override
+  String get loadSeries => 'Serien laden';
+
+  @override
+  String get notConnected => 'Nicht mit Music Assistant verbunden';
+
+  @override
+  String get notConnectedTitle => 'Nicht verbunden';
+
+  @override
+  String get connectHint => 'Verbinde dich mit deinem Music Assistant Server, um Musik zu hören';
+
+  @override
+  String get configureServer => 'Server konfigurieren';
+
+  @override
+  String get noArtistsFound => 'Keine Künstler gefunden';
+
+  @override
+  String get noTracksFound => 'Keine Songs gefunden';
+
+  @override
+  String get noPlaylistsFound => 'Keine Wiedergabelisten gefunden';
+
+  @override
+  String get queueIsEmpty => 'Warteschlange ist leer';
+
+  @override
+  String get noResultsFound => 'Keine Ergebnisse gefunden';
+
+  @override
+  String get refresh => 'Aktualisieren';
+
+  @override
+  String get debugConsole => 'Debug-Konsole';
+
+  @override
+  String get copy => 'Kopieren';
+
+  @override
+  String get clear => 'Löschen';
+
+  @override
+  String get noLogsToCopy => 'Keine Protokolle zum Kopieren';
+
+  @override
+  String get noDebugLogsYet => 'Noch keine Debug-Protokolle. Versuche Authentifizierung zu erkennen.';
+
+  @override
+  String get showDebug => 'Debug anzeigen';
+
+  @override
+  String get hideDebug => 'Debug ausblenden';
+
+  @override
+  String get chapters => 'Kapitel';
+
+  @override
+  String get noChapters => 'Keine Kapitel';
+
+  @override
+  String get noChapterInfo => 'Dieses Hörbuch hat keine Kapitelinformationen';
+
+  @override
+  String errorSeeking(String error) {
+    return 'Fehler beim Spulen: $error';
+  }
+
+  @override
+  String error(String error) {
+    return 'Fehler: $error';
+  }
+
+  @override
+  String get home => 'Start';
+
+  @override
+  String get library => 'Bibliothek';
+
+  @override
+  String get homeScreen => 'Startbildschirm';
+
+  @override
+  String get metadataApis => 'Metadaten-APIs';
+
+  @override
+  String get theme => 'Design';
+
+  @override
+  String get materialYou => 'Material You';
+
+  @override
+  String get adaptiveTheme => 'Adaptives Design';
+
+  @override
+  String get language => 'Sprache';
+
+  @override
+  String get english => 'Englisch';
+
+  @override
+  String get german => 'Deutsch';
+
+  @override
+  String get spanish => 'Spanisch';
+
+  @override
+  String get french => 'Französisch';
+
+  @override
+  String get noTracksInPlaylist => 'Keine Songs in Wiedergabeliste';
+
+  @override
+  String get sortAlphabetically => 'Alphabetisch sortieren';
+
+  @override
+  String get sortByYear => 'Nach Jahr sortieren';
+
+  @override
+  String get sortBySeriesOrder => 'Nach Serienreihenfolge sortieren';
+
+  @override
+  String get listView => 'Listenansicht';
+
+  @override
+  String get gridView => 'Rasteransicht';
+
+  @override
+  String get noBooksInSeries => 'Keine Bücher in dieser Serie gefunden';
+
+  @override
+  String get artist => 'Künstler';
+
+  @override
+  String get showRecentlyPlayedAlbums => 'Kürzlich gespielte Alben anzeigen';
+
+  @override
+  String get showRandomArtists => 'Zufällige Künstler zum Entdecken anzeigen';
+
+  @override
+  String get showRandomAlbums => 'Zufällige Alben zum Entdecken anzeigen';
+
+  @override
+  String get showAudiobooksInProgress => 'Hörbücher in Bearbeitung anzeigen';
+
+  @override
+  String get showRandomAudiobooks => 'Zufällige Hörbücher zum Entdecken anzeigen';
+
+  @override
+  String get showRandomSeries => 'Zufällige Hörbuchserien zum Entdecken anzeigen';
+
+  @override
+  String get showFavoriteAlbums => 'Lieblingsalben anzeigen';
+
+  @override
+  String get showFavoriteArtists => 'Lieblingskünstler anzeigen';
+
+  @override
+  String get showFavoriteTracks => 'Lieblingssongs anzeigen';
+
+  @override
+  String get showFavoritePlaylists => 'Show a row of your favorite playlists';
+
+  @override
+  String get showFavoriteRadioStations => 'Show a row of your favorite radio stations';
+
+  @override
+  String get showFavoritePodcasts => 'Show a row of your favorite podcasts';
+
+  @override
+  String get extractColorsFromArtwork => 'Farben aus Album- und Künstlercover extrahieren';
+
+  @override
+  String get chooseHomeScreenRows => 'Wähle welche Zeilen auf dem Startbildschirm angezeigt werden';
+
+  @override
+  String get addedToFavorites => 'Zu Favoriten hinzugefügt';
+
+  @override
+  String get removedFromFavorites => 'Aus Favoriten entfernt';
+
+  @override
+  String get addedToLibrary => 'Added to library';
+
+  @override
+  String get removedFromLibrary => 'Removed from library';
+
+  @override
+  String get addToLibrary => 'Add to library';
+
+  @override
+  String get unknown => 'Unbekannt';
+
+  @override
+  String get noUpcomingTracks => 'Keine weiteren Songs';
+
+  @override
+  String get showAll => 'Alle anzeigen';
+
+  @override
+  String get showFavoritesOnly => 'Nur Favoriten anzeigen';
+
+  @override
+  String get changeView => 'Ansicht ändern';
+
+  @override
+  String get authors => 'Autoren';
+
+  @override
+  String get series => 'Serien';
+
+  @override
+  String get shows => 'Sendungen';
+
+  @override
+  String get podcasts => 'Podcasts';
+
+  @override
+  String get podcastSupportComingSoon => 'Podcast-Unterstützung kommt bald';
+
+  @override
+  String get noPodcasts => 'No podcasts';
+
+  @override
+  String get addPodcastsHint => 'Subscribe to podcasts in Music Assistant';
+
+  @override
+  String get episodes => 'Episodes';
+
+  @override
+  String get episode => 'Episode';
+
+  @override
+  String get playlist => 'Wiedergabeliste';
+
+  @override
+  String get connectionError => 'Verbindungsfehler';
+
+  @override
+  String get twoColumnGrid => '2-Spalten-Raster';
+
+  @override
+  String get threeColumnGrid => '3-Spalten-Raster';
+
+  @override
+  String get fromProviders => 'Von Anbietern';
+
+  @override
+  String get resume => 'Fortsetzen';
+
+  @override
+  String get about => 'Über';
+
+  @override
+  String get inProgress => 'In Bearbeitung';
+
+  @override
+  String narratedBy(String narrators) {
+    return 'Gesprochen von $narrators';
+  }
+
+  @override
+  String get unknownNarrator => 'Unbekannter Sprecher';
+
+  @override
+  String get unknownAuthor => 'Unbekannter Autor';
+
+  @override
+  String get loadingChapters => 'Lade Kapitel...';
+
+  @override
+  String get noChapterInfoAvailable => 'Keine Kapitelinformationen verfügbar';
+
+  @override
+  String percentComplete(int percent) {
+    return '$percent% abgeschlossen';
+  }
+
+  @override
+  String get theAudioDbApiKey => 'TheAudioDB API-Schlüssel';
+
+  @override
+  String get theAudioDbApiKeyHint => '\"2\" für kostenlosen Zugang oder Premium-Schlüssel';
+
+  @override
+  String get audiobookLibraries => 'Hörbuch-Bibliotheken';
+
+  @override
+  String get chooseAudiobookLibraries => 'Wähle welche Audiobookshelf-Bibliotheken einbezogen werden';
+
+  @override
+  String get unknownLibrary => 'Unbekannte Bibliothek';
+
+  @override
+  String get noSeriesFound => 'Keine Serien gefunden';
+
+  @override
+  String get ensembleBugReport => 'Ensemble Fehlerbericht';
+
+  @override
+  String byOwner(String owner) {
+    return 'Von $owner';
+  }
+
+  @override
+  String get noSeriesAvailable => 'Keine Serien in deiner Hörbuch-Bibliothek verfügbar.\nZiehe zum Aktualisieren.';
+
+  @override
+  String get pullToLoadSeries => 'Ziehe nach unten um Serien\nvon Music Assistant zu laden';
+
+  @override
+  String get search => 'Suche';
+
+  @override
+  String get metadataApisDescription => 'Künstlerbilder werden automatisch von Deezer abgerufen. Füge unten API-Schlüssel für Künstlerbiografien und Albenbeschreibungen hinzu.';
+
+  @override
+  String get lastFmApiKey => 'Last.fm API-Schlüssel';
+
+  @override
+  String get lastFmApiKeyHint => 'Kostenlosen Schlüssel auf last.fm/api holen';
+
+  @override
+  String get swipeToSwitchDevice => 'Wischen um Gerät zu wechseln';
+
+  @override
+  String chapterNumber(int number) {
+    return 'Kapitel $number';
+  }
+
+  @override
+  String get pcmAudio => 'PCM-Audio';
+
+  @override
+  String get playOn => 'Abspielen auf...';
+
+  @override
+  String get addAlbumToQueueOn => 'Album zur Warteschlange hinzufügen auf...';
+
+  @override
+  String get addToQueueOn => 'Zur Warteschlange hinzufügen auf...';
+
+  @override
+  String startRadioOn(String name) {
+    return '$name Radio starten auf...';
+  }
+
+  @override
+  String get book => 'Buch';
+
+  @override
+  String get audiobookSingular => 'Hörbuch';
+
+  @override
+  String get albumSingular => 'Album';
+
+  @override
+  String get trackSingular => 'Track';
+
+  @override
+  String get podcastSingular => 'Podcast';
+
+  @override
+  String trackCount(int count) {
+    String _temp0 = intl.Intl.pluralLogic(
+      count,
+      locale: localeName,
+      other: 'Songs',
+      one: 'Song',
+    );
+    return '$count $_temp0';
+  }
+
+  @override
+  String get materialYouDescription => 'Systemfarben verwenden (Android 12+)';
+
+  @override
+  String get accentColor => 'Akzentfarbe';
+
+  @override
+  String get players => 'Geräte';
+
+  @override
+  String get preferLocalPlayer => 'Lokales Gerät bevorzugen';
+
+  @override
+  String get preferLocalPlayerDescription => 'Dieses Gerät immer zuerst auswählen, wenn verfügbar';
+
+  @override
+  String get smartSortPlayers => 'Intelligente Sortierung';
+
+  @override
+  String get smartSortPlayersDescription => 'Nach Status sortieren (spielt, an, aus) statt alphabetisch';
+
+  @override
+  String get playerStateUnavailable => 'Nicht verfügbar';
+
+  @override
+  String get playerStateOff => 'Aus';
+
+  @override
+  String get playerStateIdle => 'Inaktiv';
+
+  @override
+  String get playerStateExternalSource => 'Externe Quelle';
+
+  @override
+  String get playerSelected => 'Ausgewählt';
+
+  @override
+  String get actionQueuedForSync => 'Wird synchronisiert wenn online';
+
+  @override
+  String pendingOfflineActions(int count) {
+    return '$count ausstehende Synchronisierung';
+  }
+
+  @override
+  String get hintsAndTips => 'Tipps & Hinweise';
+
+  @override
+  String get showHints => 'Hinweise anzeigen';
+
+  @override
+  String get showHintsDescription => 'Hilfreiche Tipps zum Entdecken von Funktionen anzeigen';
+
+  @override
+  String get pullToSelectPlayers => 'Ziehen um Geräte auszuwählen';
+
+  @override
+  String get holdToSync => 'Gedrückt halten zum Sync';
+
+  @override
+  String get swipeToAdjustVolume => 'Wischen für Lautstärke';
+
+  @override
+  String get selectPlayerHint => 'Choose a player, or dismiss by swiping down';
+
+  @override
+  String get welcomeToEnsemble => 'Welcome to Ensemble';
+
+  @override
+  String get welcomeMessage => 'By default your phone is the selected player.\nPull the mini player down to select another player.';
+
+  @override
+  String get skip => 'Skip';
+
+  @override
+  String get dismissPlayerHint => 'Swipe down, tap outside, or press back to return';
+
+  @override
+  String playingAlbum(String albumName) {
+    return 'Playing $albumName';
+  }
+
+  @override
+  String playingPlaylist(String playlistName) {
+    return 'Playing $playlistName';
+  }
+
+  @override
+  String get noTracks => 'No tracks';
+
+  @override
+  String get addTracksHint => 'Add some music to your library to see tracks here';
+
+  @override
+  String get noFavoriteRadioStations => 'No favorite radio stations';
+
+  @override
+  String get longPressRadioHint => 'Long-press a station and tap the heart to add it to favorites';
+
+  @override
+  String get noFavoritePodcasts => 'No favorite podcasts';
+
+  @override
+  String get longPressPodcastHint => 'Long-press a podcast and tap the heart to add it to favorites';
+}
@@ -0,0 +1,983 @@
+import 'package:intl/intl.dart' as intl;
+
+import 'app_localizations.dart';
+
+// ignore_for_file: type=lint
+
+/// The translations for English (`en`).
+class SEn extends S {
+  SEn([String locale = 'en']) : super(locale);
+
+  @override
+  String get appTitle => 'Ensemble';
+
+  @override
+  String get connecting => 'Connecting...';
+
+  @override
+  String get connected => 'Connected';
+
+  @override
+  String get disconnected => 'Disconnected';
+
+  @override
+  String get serverAddress => 'Server Address';
+
+  @override
+  String get serverAddressHint => 'e.g., music.example.com or 192.168.1.100';
+
+  @override
+  String get yourName => 'Your Name';
+
+  @override
+  String get yourFirstName => 'Your first name';
+
+  @override
+  String get portOptional => 'Port (Optional)';
+
+  @override
+  String get portHint => 'e.g., 8095 or leave blank';
+
+  @override
+  String get portDescription => 'Leave blank for reverse proxy or standard ports. Enter 8095 for direct connection.';
+
+  @override
+  String get username => 'Username';
+
+  @override
+  String get password => 'Password';
+
+  @override
+  String get detectAndConnect => 'Detect & Connect';
+
+  @override
+  String get connect => 'Connect';
+
+  @override
+  String get disconnect => 'Disconnect';
+
+  @override
+  String get authServerUrlOptional => 'Auth Server URL (Optional)';
+
+  @override
+  String get authServerUrlHint => 'e.g., auth.example.com (if different from server)';
+
+  @override
+  String get authServerUrlDescription => 'Leave empty if authentication is on the same server';
+
+  @override
+  String detectedAuthType(String authType) {
+    return 'Detected: $authType';
+  }
+
+  @override
+  String get serverRequiresAuth => 'This server requires authentication';
+
+  @override
+  String get tailscaleVpnConnection => 'Tailscale VPN Connection';
+
+  @override
+  String get unencryptedConnection => 'Unencrypted Connection';
+
+  @override
+  String get usingHttpOverTailscale => 'Using HTTP over Tailscale (encrypted tunnel)';
+
+  @override
+  String get httpsFailedUsingHttp => 'HTTPS failed, using HTTP fallback';
+
+  @override
+  String get httpNotEncrypted => 'HTTP connection - data is not encrypted';
+
+  @override
+  String get pleaseEnterServerAddress => 'Please enter your Music Assistant server address';
+
+  @override
+  String get pleaseEnterName => 'Please enter your name';
+
+  @override
+  String get pleaseEnterValidPort => 'Please enter a valid port number (1-65535)';
+
+  @override
+  String get pleaseEnterCredentials => 'Please enter username and password';
+
+  @override
+  String get authFailed => 'Authentication failed. Please check your credentials.';
+
+  @override
+  String get maLoginFailed => 'Music Assistant login failed. Please check your credentials.';
+
+  @override
+  String get connectionFailed => 'Could not connect to server. Please check the address and try again.';
+
+  @override
+  String get detectingAuth => 'Detecting authentication...';
+
+  @override
+  String get cannotDetermineAuth => 'Cannot determine authentication requirements. Please check server URL.';
+
+  @override
+  String get noAuthentication => 'No Authentication';
+
+  @override
+  String get httpBasicAuth => 'HTTP Basic Auth';
+
+  @override
+  String get authelia => 'Authelia';
+
+  @override
+  String get musicAssistantLogin => 'Music Assistant Login';
+
+  @override
+  String get pressBackToMinimize => 'Press back again to minimize';
+
+  @override
+  String get recentlyPlayed => 'Recently Played';
+
+  @override
+  String get discoverArtists => 'Discover Artists';
+
+  @override
+  String get discoverAlbums => 'Discover Albums';
+
+  @override
+  String get continueListening => 'Continue Listening';
+
+  @override
+  String get discoverAudiobooks => 'Discover Audiobooks';
+
+  @override
+  String get discoverSeries => 'Discover Series';
+
+  @override
+  String get favoriteAlbums => 'Favorite Albums';
+
+  @override
+  String get favoriteArtists => 'Favorite Artists';
+
+  @override
+  String get favoriteTracks => 'Favorite Tracks';
+
+  @override
+  String get favoritePlaylists => 'Favorite Playlists';
+
+  @override
+  String get favoriteRadioStations => 'Favorite Radio Stations';
+
+  @override
+  String get favoritePodcasts => 'Favorite Podcasts';
+
+  @override
+  String get searchMusic => 'Search music...';
+
+  @override
+  String get searchForContent => 'Search for artists, albums, or tracks';
+
+  @override
+  String get recentSearches => 'Recent Searches';
+
+  @override
+  String get clearSearchHistory => 'Clear Search History';
+
+  @override
+  String get searchHistoryCleared => 'Search history cleared';
+
+  @override
+  String get libraryOnly => 'Library only';
+
+  @override
+  String get retry => 'Retry';
+
+  @override
+  String get all => 'All';
+
+  @override
+  String get artists => 'Artists';
+
+  @override
+  String get albums => 'Albums';
+
+  @override
+  String get tracks => 'Tracks';
+
+  @override
+  String get playlists => 'Playlists';
+
+  @override
+  String get audiobooks => 'Audiobooks';
+
+  @override
+  String get music => 'Music';
+
+  @override
+  String get radio => 'Radio';
+
+  @override
+  String get stations => 'Stations';
+
+  @override
+  String get selectLibrary => 'Select Library';
+
+  @override
+  String get noRadioStations => 'No radio stations';
+
+  @override
+  String get addRadioStationsHint => 'Add radio stations in Music Assistant';
+
+  @override
+  String get searchFailed => 'Search failed. Please check your connection.';
+
+  @override
+  String get queue => 'Queue';
+
+  @override
+  String playerQueue(String playerName) {
+    return '$playerName Queue';
+  }
+
+  @override
+  String get noPlayerSelected => 'No player selected';
+
+  @override
+  String get undo => 'Undo';
+
+  @override
+  String removedItem(String itemName) {
+    return 'Removed $itemName';
+  }
+
+  @override
+  String get settings => 'Settings';
+
+  @override
+  String get debugLogs => 'Debug Logs';
+
+  @override
+  String get themeMode => 'Theme Mode';
+
+  @override
+  String get light => 'Light';
+
+  @override
+  String get dark => 'Dark';
+
+  @override
+  String get system => 'System';
+
+  @override
+  String get pullToRefresh => 'Pull to refresh the library to apply changes';
+
+  @override
+  String get viewDebugLogs => 'View Debug Logs';
+
+  @override
+  String get viewAllPlayers => 'View All Players';
+
+  @override
+  String get copyLogs => 'Copy Logs';
+
+  @override
+  String get clearLogs => 'Clear Logs';
+
+  @override
+  String get copyList => 'Copy List';
+
+  @override
+  String get close => 'Close';
+
+  @override
+  String allPlayersCount(int count) {
+    return 'All Players ($count)';
+  }
+
+  @override
+  String errorLoadingPlayers(String error) {
+    return 'Error loading players: $error';
+  }
+
+  @override
+  String get logsCopied => 'Logs copied to clipboard';
+
+  @override
+  String get logsCleared => 'Logs cleared';
+
+  @override
+  String get playerListCopied => 'Player list copied to clipboard!';
+
+  @override
+  String get noLogsYet => 'No logs yet';
+
+  @override
+  String get infoPlus => 'Info+';
+
+  @override
+  String get warnings => 'Warnings';
+
+  @override
+  String get errors => 'Errors';
+
+  @override
+  String showingEntries(int filtered, int total) {
+    return 'Showing $filtered of $total entries';
+  }
+
+  @override
+  String get thisDevice => 'This device';
+
+  @override
+  String get ghostPlayer => 'Ghost player (duplicate)';
+
+  @override
+  String get unavailableCorrupt => 'Unavailable/Corrupt';
+
+  @override
+  String playerId(String id) {
+    return 'ID: $id';
+  }
+
+  @override
+  String playerInfo(String available, String provider) {
+    return 'Available: $available | Provider: $provider';
+  }
+
+  @override
+  String get shareBugReport => 'Share bug report';
+
+  @override
+  String get moreOptions => 'More options';
+
+  @override
+  String failedToUpdateFavorite(String error) {
+    return 'Failed to update favorite: $error';
+  }
+
+  @override
+  String get noPlayersAvailable => 'No players available';
+
+  @override
+  String get albumAddedToQueue => 'Album added to queue';
+
+  @override
+  String get tracksAddedToQueue => 'Tracks added to queue';
+
+  @override
+  String get play => 'Play';
+
+  @override
+  String get noPlayersFound => 'No players found';
+
+  @override
+  String startingRadio(String name) {
+    return 'Starting $name radio';
+  }
+
+  @override
+  String failedToStartRadio(String error) {
+    return 'Failed to start radio: $error';
+  }
+
+  @override
+  String startingRadioOnPlayer(String name, String playerName) {
+    return 'Starting $name radio on $playerName';
+  }
+
+  @override
+  String addedRadioToQueue(String name) {
+    return 'Added $name radio to queue';
+  }
+
+  @override
+  String failedToAddToQueue(String error) {
+    return 'Failed to add to queue: $error';
+  }
+
+  @override
+  String playingRadioStation(String name) {
+    return 'Playing $name';
+  }
+
+  @override
+  String get addedToQueue => 'Added to queue';
+
+  @override
+  String get inLibrary => 'In Library';
+
+  @override
+  String get noAlbumsFound => 'No albums found';
+
+  @override
+  String playing(String name) {
+    return 'Playing $name';
+  }
+
+  @override
+  String get playingTrack => 'Playing track';
+
+  @override
+  String get nowPlaying => 'Now playing';
+
+  @override
+  String markedAsFinished(String name) {
+    return '$name marked as finished';
+  }
+
+  @override
+  String failedToMarkFinished(String error) {
+    return 'Failed to mark as finished: $error';
+  }
+
+  @override
+  String markedAsUnplayed(String name) {
+    return '$name marked as unplayed';
+  }
+
+  @override
+  String failedToMarkUnplayed(String error) {
+    return 'Failed to mark as unplayed: $error';
+  }
+
+  @override
+  String failedToPlay(String error) {
+    return 'Failed to play: $error';
+  }
+
+  @override
+  String get markAsFinished => 'Mark as Finished';
+
+  @override
+  String get markAsUnplayed => 'Mark as Unplayed';
+
+  @override
+  String byAuthor(String author) {
+    return 'By $author';
+  }
+
+  @override
+  String audiobookCount(int count) {
+    return '$count audiobook(s)';
+  }
+
+  @override
+  String get loading => 'Loading...';
+
+  @override
+  String bookCount(int count) {
+    return '$count book(s)';
+  }
+
+  @override
+  String get books => 'Books';
+
+  @override
+  String get noFavoriteAudiobooks => 'No favorite audiobooks';
+
+  @override
+  String get tapHeartAudiobook => 'Tap the heart on an audiobook to add it to favorites';
+
+  @override
+  String get noAudiobooks => 'No audiobooks';
+
+  @override
+  String get addAudiobooksHint => 'Add audiobooks to your library to see them here';
+
+  @override
+  String get noFavoriteArtists => 'No favorite artists';
+
+  @override
+  String get tapHeartArtist => 'Tap the heart on an artist to add them to favorites';
+
+  @override
+  String get noFavoriteAlbums => 'No favorite albums';
+
+  @override
+  String get tapHeartAlbum => 'Tap the heart on an album to add it to favorites';
+
+  @override
+  String get noFavoritePlaylists => 'No favorite playlists';
+
+  @override
+  String get tapHeartPlaylist => 'Tap the heart on a playlist to add it to favorites';
+
+  @override
+  String get noFavoriteTracks => 'No favorite tracks';
+
+  @override
+  String get longPressTrackHint => 'Long-press a track and tap the heart to add it to favorites';
+
+  @override
+  String get loadSeries => 'Load Series';
+
+  @override
+  String get notConnected => 'Not connected to Music Assistant';
+
+  @override
+  String get notConnectedTitle => 'Not Connected';
+
+  @override
+  String get connectHint => 'Connect to your Music Assistant server to start listening';
+
+  @override
+  String get configureServer => 'Configure Server';
+
+  @override
+  String get noArtistsFound => 'No artists found';
+
+  @override
+  String get noTracksFound => 'No tracks found';
+
+  @override
+  String get noPlaylistsFound => 'No playlists found';
+
+  @override
+  String get queueIsEmpty => 'Queue is empty';
+
+  @override
+  String get noResultsFound => 'No results found';
+
+  @override
+  String get refresh => 'Refresh';
+
+  @override
+  String get debugConsole => 'Debug Console';
+
+  @override
+  String get copy => 'Copy';
+
+  @override
+  String get clear => 'Clear';
+
+  @override
+  String get noLogsToCopy => 'No logs to copy';
+
+  @override
+  String get noDebugLogsYet => 'No debug logs yet. Try detecting auth.';
+
+  @override
+  String get showDebug => 'Show Debug';
+
+  @override
+  String get hideDebug => 'Hide Debug';
+
+  @override
+  String get chapters => 'Chapters';
+
+  @override
+  String get noChapters => 'No chapters';
+
+  @override
+  String get noChapterInfo => 'This audiobook has no chapter information';
+
+  @override
+  String errorSeeking(String error) {
+    return 'Error seeking: $error';
+  }
+
+  @override
+  String error(String error) {
+    return 'Error: $error';
+  }
+
+  @override
+  String get home => 'Home';
+
+  @override
+  String get library => 'Library';
+
+  @override
+  String get homeScreen => 'Home Screen';
+
+  @override
+  String get metadataApis => 'Metadata APIs';
+
+  @override
+  String get theme => 'Theme';
+
+  @override
+  String get materialYou => 'Material You';
+
+  @override
+  String get adaptiveTheme => 'Adaptive Theme';
+
+  @override
+  String get language => 'Language';
+
+  @override
+  String get english => 'English';
+
+  @override
+  String get german => 'German';
+
+  @override
+  String get spanish => 'Spanish';
+
+  @override
+  String get french => 'French';
+
+  @override
+  String get noTracksInPlaylist => 'No tracks in playlist';
+
+  @override
+  String get sortAlphabetically => 'Sort alphabetically';
+
+  @override
+  String get sortByYear => 'Sort by year';
+
+  @override
+  String get sortBySeriesOrder => 'Sort by series order';
+
+  @override
+  String get listView => 'List view';
+
+  @override
+  String get gridView => 'Grid view';
+
+  @override
+  String get noBooksInSeries => 'No books found in this series';
+
+  @override
+  String get artist => 'Artist';
+
+  @override
+  String get showRecentlyPlayedAlbums => 'Show recently played albums';
+
+  @override
+  String get showRandomArtists => 'Show random artists to discover';
+
+  @override
+  String get showRandomAlbums => 'Show random albums to discover';
+
+  @override
+  String get showAudiobooksInProgress => 'Show audiobooks in progress';
+
+  @override
+  String get showRandomAudiobooks => 'Show random audiobooks to discover';
+
+  @override
+  String get showRandomSeries => 'Show random audiobook series to discover';
+
+  @override
+  String get showFavoriteAlbums => 'Show a row of your favorite albums';
+
+  @override
+  String get showFavoriteArtists => 'Show a row of your favorite artists';
+
+  @override
+  String get showFavoriteTracks => 'Show a row of your favorite tracks';
+
+  @override
+  String get showFavoritePlaylists => 'Show a row of your favorite playlists';
+
+  @override
+  String get showFavoriteRadioStations => 'Show a row of your favorite radio stations';
+
+  @override
+  String get showFavoritePodcasts => 'Show a row of your favorite podcasts';
+
+  @override
+  String get extractColorsFromArtwork => 'Extract colors from album and artist artwork';
+
+  @override
+  String get chooseHomeScreenRows => 'Choose which rows to display on the home screen';
+
+  @override
+  String get addedToFavorites => 'Added to favorites';
+
+  @override
+  String get removedFromFavorites => 'Removed from favorites';
+
+  @override
+  String get addedToLibrary => 'Added to library';
+
+  @override
+  String get removedFromLibrary => 'Removed from library';
+
+  @override
+  String get addToLibrary => 'Add to library';
+
+  @override
+  String get unknown => 'Unknown';
+
+  @override
+  String get noUpcomingTracks => 'No upcoming tracks';
+
+  @override
+  String get showAll => 'Show all';
+
+  @override
+  String get showFavoritesOnly => 'Show favorites only';
+
+  @override
+  String get changeView => 'Change view';
+
+  @override
+  String get authors => 'Authors';
+
+  @override
+  String get series => 'Series';
+
+  @override
+  String get shows => 'Shows';
+
+  @override
+  String get podcasts => 'Podcasts';
+
+  @override
+  String get podcastSupportComingSoon => 'Podcast support coming soon';
+
+  @override
+  String get noPodcasts => 'No podcasts';
+
+  @override
+  String get addPodcastsHint => 'Subscribe to podcasts in Music Assistant';
+
+  @override
+  String get episodes => 'Episodes';
+
+  @override
+  String get episode => 'Episode';
+
+  @override
+  String get playlist => 'Playlist';
+
+  @override
+  String get connectionError => 'Connection Error';
+
+  @override
+  String get twoColumnGrid => '2-column grid';
+
+  @override
+  String get threeColumnGrid => '3-column grid';
+
+  @override
+  String get fromProviders => 'From Providers';
+
+  @override
+  String get resume => 'Resume';
+
+  @override
+  String get about => 'About';
+
+  @override
+  String get inProgress => 'In progress';
+
+  @override
+  String narratedBy(String narrators) {
+    return 'Narrated by $narrators';
+  }
+
+  @override
+  String get unknownNarrator => 'Unknown Narrator';
+
+  @override
+  String get unknownAuthor => 'Unknown Author';
+
+  @override
+  String get loadingChapters => 'Loading chapters...';
+
+  @override
+  String get noChapterInfoAvailable => 'No chapter information available';
+
+  @override
+  String percentComplete(int percent) {
+    return '$percent% complete';
+  }
+
+  @override
+  String get theAudioDbApiKey => 'TheAudioDB API Key';
+
+  @override
+  String get theAudioDbApiKeyHint => 'Use \"2\" for free tier or premium key';
+
+  @override
+  String get audiobookLibraries => 'Audiobook Libraries';
+
+  @override
+  String get chooseAudiobookLibraries => 'Choose which Audiobookshelf libraries to include';
+
+  @override
+  String get unknownLibrary => 'Unknown Library';
+
+  @override
+  String get noSeriesFound => 'No Series Found';
+
+  @override
+  String get ensembleBugReport => 'Ensemble Bug Report';
+
+  @override
+  String byOwner(String owner) {
+    return 'By $owner';
+  }
+
+  @override
+  String get noSeriesAvailable => 'No series available from your audiobook library.\nPull to refresh.';
+
+  @override
+  String get pullToLoadSeries => 'Pull down to load series\nfrom Music Assistant';
+
+  @override
+  String get search => 'Search';
+
+  @override
+  String get metadataApisDescription => 'Artist images are automatically fetched from Deezer. Add API keys below for artist biographies and album descriptions.';
+
+  @override
+  String get lastFmApiKey => 'Last.fm API Key';
+
+  @override
+  String get lastFmApiKeyHint => 'Get free key at last.fm/api';
+
+  @override
+  String get swipeToSwitchDevice => 'Swipe to change player';
+
+  @override
+  String chapterNumber(int number) {
+    return 'Chapter $number';
+  }
+
+  @override
+  String get pcmAudio => 'PCM Audio';
+
+  @override
+  String get playOn => 'Play on...';
+
+  @override
+  String get addAlbumToQueueOn => 'Add album to queue on...';
+
+  @override
+  String get addToQueueOn => 'Add to queue on...';
+
+  @override
+  String startRadioOn(String name) {
+    return 'Start $name radio on...';
+  }
+
+  @override
+  String get book => 'book';
+
+  @override
+  String get audiobookSingular => 'audiobook';
+
+  @override
+  String get albumSingular => 'Album';
+
+  @override
+  String get trackSingular => 'Track';
+
+  @override
+  String get podcastSingular => 'Podcast';
+
+  @override
+  String trackCount(int count) {
+    String _temp0 = intl.Intl.pluralLogic(
+      count,
+      locale: localeName,
+      other: 'tracks',
+      one: 'track',
+    );
+    return '$count $_temp0';
+  }
+
+  @override
+  String get materialYouDescription => 'Use system colors (Android 12+)';
+
+  @override
+  String get accentColor => 'Accent Color';
+
+  @override
+  String get players => 'Players';
+
+  @override
+  String get preferLocalPlayer => 'Prefer Local Player';
+
+  @override
+  String get preferLocalPlayerDescription => 'Always select this device first when available';
+
+  @override
+  String get smartSortPlayers => 'Smart Sort';
+
+  @override
+  String get smartSortPlayersDescription => 'Sort by status (playing, on, off) instead of alphabetically';
+
+  @override
+  String get playerStateUnavailable => 'Unavailable';
+
+  @override
+  String get playerStateOff => 'Off';
+
+  @override
+  String get playerStateIdle => 'Idle';
+
+  @override
+  String get playerStateExternalSource => 'External Source';
+
+  @override
+  String get playerSelected => 'Selected';
+
+  @override
+  String get actionQueuedForSync => 'Will sync when online';
+
+  @override
+  String pendingOfflineActions(int count) {
+    return '$count pending sync';
+  }
+
+  @override
+  String get hintsAndTips => 'Hints & Tips';
+
+  @override
+  String get showHints => 'Show Hints';
+
+  @override
+  String get showHintsDescription => 'Display helpful tips for discovering features';
+
+  @override
+  String get pullToSelectPlayers => 'Pull to select players';
+
+  @override
+  String get holdToSync => 'Long-press to sync';
+
+  @override
+  String get swipeToAdjustVolume => 'Swipe to adjust volume';
+
+  @override
+  String get selectPlayerHint => 'Choose a player, or dismiss by swiping down';
+
+  @override
+  String get welcomeToEnsemble => 'Welcome to Ensemble';
+
+  @override
+  String get welcomeMessage => 'By default your phone is the selected player.\nPull the mini player down to select another player.';
+
+  @override
+  String get skip => 'Skip';
+
+  @override
+  String get dismissPlayerHint => 'Swipe down, tap outside, or press back to return';
+
+  @override
+  String playingAlbum(String albumName) {
+    return 'Playing $albumName';
+  }
+
+  @override
+  String playingPlaylist(String playlistName) {
+    return 'Playing $playlistName';
+  }
+
+  @override
+  String get noTracks => 'No tracks';
+
+  @override
+  String get addTracksHint => 'Add some music to your library to see tracks here';
+
+  @override
+  String get noFavoriteRadioStations => 'No favorite radio stations';
+
+  @override
+  String get longPressRadioHint => 'Long-press a station and tap the heart to add it to favorites';
+
+  @override
+  String get noFavoritePodcasts => 'No favorite podcasts';
+
+  @override
+  String get longPressPodcastHint => 'Long-press a podcast and tap the heart to add it to favorites';
+}
@@ -0,0 +1,983 @@
+import 'package:intl/intl.dart' as intl;
+
+import 'app_localizations.dart';
+
+// ignore_for_file: type=lint
+
+/// The translations for Spanish Castilian (`es`).
+class SEs extends S {
+  SEs([String locale = 'es']) : super(locale);
+
+  @override
+  String get appTitle => 'Ensemble';
+
+  @override
+  String get connecting => 'Conectando...';
+
+  @override
+  String get connected => 'Conectado';
+
+  @override
+  String get disconnected => 'Desconectado';
+
+  @override
+  String get serverAddress => 'Dirección del servidor';
+
+  @override
+  String get serverAddressHint => 'ej., music.example.com o 192.168.1.100';
+
+  @override
+  String get yourName => 'Tu nombre';
+
+  @override
+  String get yourFirstName => 'Tu nombre de pila';
+
+  @override
+  String get portOptional => 'Puerto (Opcional)';
+
+  @override
+  String get portHint => 'ej., 8095 o dejar en blanco';
+
+  @override
+  String get portDescription => 'Dejar en blanco para proxy inverso o puertos estándar. Introduce 8095 para conexión directa.';
+
+  @override
+  String get username => 'Usuario';
+
+  @override
+  String get password => 'Contraseña';
+
+  @override
+  String get detectAndConnect => 'Detectar y conectar';
+
+  @override
+  String get connect => 'Conectar';
+
+  @override
+  String get disconnect => 'Desconectar';
+
+  @override
+  String get authServerUrlOptional => 'URL del servidor de autenticación (Opcional)';
+
+  @override
+  String get authServerUrlHint => 'ej., auth.example.com (si es diferente del servidor)';
+
+  @override
+  String get authServerUrlDescription => 'Dejar vacío si la autenticación está en el mismo servidor';
+
+  @override
+  String detectedAuthType(String authType) {
+    return 'Detectado: $authType';
+  }
+
+  @override
+  String get serverRequiresAuth => 'Este servidor requiere autenticación';
+
+  @override
+  String get tailscaleVpnConnection => 'Conexión VPN Tailscale';
+
+  @override
+  String get unencryptedConnection => 'Conexión sin cifrar';
+
+  @override
+  String get usingHttpOverTailscale => 'Usando HTTP sobre Tailscale (túnel cifrado)';
+
+  @override
+  String get httpsFailedUsingHttp => 'HTTPS falló, usando HTTP como alternativa';
+
+  @override
+  String get httpNotEncrypted => 'Conexión HTTP - los datos no están cifrados';
+
+  @override
+  String get pleaseEnterServerAddress => 'Por favor, introduce la dirección de tu servidor Music Assistant';
+
+  @override
+  String get pleaseEnterName => 'Por favor, introduce tu nombre';
+
+  @override
+  String get pleaseEnterValidPort => 'Por favor, introduce un número de puerto válido (1-65535)';
+
+  @override
+  String get pleaseEnterCredentials => 'Por favor, introduce usuario y contraseña';
+
+  @override
+  String get authFailed => 'Autenticación fallida. Por favor, verifica tus credenciales.';
+
+  @override
+  String get maLoginFailed => 'Inicio de sesión en Music Assistant fallido. Por favor, verifica tus credenciales.';
+
+  @override
+  String get connectionFailed => 'No se pudo conectar al servidor. Por favor, verifica la dirección e inténtalo de nuevo.';
+
+  @override
+  String get detectingAuth => 'Detectando autenticación...';
+
+  @override
+  String get cannotDetermineAuth => 'No se pueden determinar los requisitos de autenticación. Por favor, verifica la URL del servidor.';
+
+  @override
+  String get noAuthentication => 'Sin autenticación';
+
+  @override
+  String get httpBasicAuth => 'Autenticación HTTP Basic';
+
+  @override
+  String get authelia => 'Authelia';
+
+  @override
+  String get musicAssistantLogin => 'Inicio de sesión de Music Assistant';
+
+  @override
+  String get pressBackToMinimize => 'Presiona atrás de nuevo para minimizar';
+
+  @override
+  String get recentlyPlayed => 'Reproducido recientemente';
+
+  @override
+  String get discoverArtists => 'Descubrir artistas';
+
+  @override
+  String get discoverAlbums => 'Descubrir álbumes';
+
+  @override
+  String get continueListening => 'Continuar escuchando';
+
+  @override
+  String get discoverAudiobooks => 'Descubrir audiolibros';
+
+  @override
+  String get discoverSeries => 'Descubrir series';
+
+  @override
+  String get favoriteAlbums => 'Álbumes favoritos';
+
+  @override
+  String get favoriteArtists => 'Artistas favoritos';
+
+  @override
+  String get favoriteTracks => 'Canciones favoritas';
+
+  @override
+  String get favoritePlaylists => 'Favorite Playlists';
+
+  @override
+  String get favoriteRadioStations => 'Favorite Radio Stations';
+
+  @override
+  String get favoritePodcasts => 'Favorite Podcasts';
+
+  @override
+  String get searchMusic => 'Buscar música...';
+
+  @override
+  String get searchForContent => 'Buscar artistas, álbumes o canciones';
+
+  @override
+  String get recentSearches => 'Recent Searches';
+
+  @override
+  String get clearSearchHistory => 'Clear Search History';
+
+  @override
+  String get searchHistoryCleared => 'Search history cleared';
+
+  @override
+  String get libraryOnly => 'Library only';
+
+  @override
+  String get retry => 'Reintentar';
+
+  @override
+  String get all => 'Todo';
+
+  @override
+  String get artists => 'Artistas';
+
+  @override
+  String get albums => 'Álbumes';
+
+  @override
+  String get tracks => 'Canciones';
+
+  @override
+  String get playlists => 'Listas de reproducción';
+
+  @override
+  String get audiobooks => 'Audiolibros';
+
+  @override
+  String get music => 'Música';
+
+  @override
+  String get radio => 'Radio';
+
+  @override
+  String get stations => 'Emisoras';
+
+  @override
+  String get selectLibrary => 'Seleccionar Biblioteca';
+
+  @override
+  String get noRadioStations => 'No hay emisoras de radio';
+
+  @override
+  String get addRadioStationsHint => 'Añade emisoras de radio en Music Assistant';
+
+  @override
+  String get searchFailed => 'Búsqueda fallida. Por favor, verifica tu conexión.';
+
+  @override
+  String get queue => 'Cola';
+
+  @override
+  String playerQueue(String playerName) {
+    return 'Cola de $playerName';
+  }
+
+  @override
+  String get noPlayerSelected => 'Ningún reproductor seleccionado';
+
+  @override
+  String get undo => 'Deshacer';
+
+  @override
+  String removedItem(String itemName) {
+    return 'Eliminado $itemName';
+  }
+
+  @override
+  String get settings => 'Ajustes';
+
+  @override
+  String get debugLogs => 'Registros de depuración';
+
+  @override
+  String get themeMode => 'Modo de tema';
+
+  @override
+  String get light => 'Claro';
+
+  @override
+  String get dark => 'Oscuro';
+
+  @override
+  String get system => 'Sistema';
+
+  @override
+  String get pullToRefresh => 'Desliza hacia abajo para actualizar la biblioteca y aplicar los cambios';
+
+  @override
+  String get viewDebugLogs => 'Ver registros de depuración';
+
+  @override
+  String get viewAllPlayers => 'Ver todos los reproductores';
+
+  @override
+  String get copyLogs => 'Copiar registros';
+
+  @override
+  String get clearLogs => 'Borrar registros';
+
+  @override
+  String get copyList => 'Copiar lista';
+
+  @override
+  String get close => 'Cerrar';
+
+  @override
+  String allPlayersCount(int count) {
+    return 'Todos los reproductores ($count)';
+  }
+
+  @override
+  String errorLoadingPlayers(String error) {
+    return 'Error al cargar reproductores: $error';
+  }
+
+  @override
+  String get logsCopied => 'Registros copiados al portapapeles';
+
+  @override
+  String get logsCleared => 'Registros borrados';
+
+  @override
+  String get playerListCopied => 'Lista de reproductores copiada al portapapeles';
+
+  @override
+  String get noLogsYet => 'Aún no hay registros';
+
+  @override
+  String get infoPlus => 'Info+';
+
+  @override
+  String get warnings => 'Advertencias';
+
+  @override
+  String get errors => 'Errores';
+
+  @override
+  String showingEntries(int filtered, int total) {
+    return 'Mostrando $filtered de $total entradas';
+  }
+
+  @override
+  String get thisDevice => 'Este dispositivo';
+
+  @override
+  String get ghostPlayer => 'Reproductor fantasma (duplicado)';
+
+  @override
+  String get unavailableCorrupt => 'No disponible/Corrupto';
+
+  @override
+  String playerId(String id) {
+    return 'ID: $id';
+  }
+
+  @override
+  String playerInfo(String available, String provider) {
+    return 'Disponible: $available | Proveedor: $provider';
+  }
+
+  @override
+  String get shareBugReport => 'Compartir informe de errores';
+
+  @override
+  String get moreOptions => 'Más opciones';
+
+  @override
+  String failedToUpdateFavorite(String error) {
+    return 'Error al actualizar favorito: $error';
+  }
+
+  @override
+  String get noPlayersAvailable => 'No hay reproductores disponibles';
+
+  @override
+  String get albumAddedToQueue => 'Álbum añadido a la cola';
+
+  @override
+  String get tracksAddedToQueue => 'Canciones añadidas a la cola';
+
+  @override
+  String get play => 'Reproducir';
+
+  @override
+  String get noPlayersFound => 'No se encontraron reproductores';
+
+  @override
+  String startingRadio(String name) {
+    return 'Iniciando radio de $name';
+  }
+
+  @override
+  String failedToStartRadio(String error) {
+    return 'Error al iniciar radio: $error';
+  }
+
+  @override
+  String startingRadioOnPlayer(String name, String playerName) {
+    return 'Iniciando radio de $name en $playerName';
+  }
+
+  @override
+  String addedRadioToQueue(String name) {
+    return 'Radio de $name añadida a la cola';
+  }
+
+  @override
+  String failedToAddToQueue(String error) {
+    return 'Error al añadir a la cola: $error';
+  }
+
+  @override
+  String playingRadioStation(String name) {
+    return 'Playing $name';
+  }
+
+  @override
+  String get addedToQueue => 'Added to queue';
+
+  @override
+  String get inLibrary => 'En la biblioteca';
+
+  @override
+  String get noAlbumsFound => 'No se encontraron álbumes';
+
+  @override
+  String playing(String name) {
+    return 'Reproduciendo $name';
+  }
+
+  @override
+  String get playingTrack => 'Reproduciendo canción';
+
+  @override
+  String get nowPlaying => 'Reproduciendo ahora';
+
+  @override
+  String markedAsFinished(String name) {
+    return '$name marcado como terminado';
+  }
+
+  @override
+  String failedToMarkFinished(String error) {
+    return 'Error al marcar como terminado: $error';
+  }
+
+  @override
+  String markedAsUnplayed(String name) {
+    return '$name marcado como no reproducido';
+  }
+
+  @override
+  String failedToMarkUnplayed(String error) {
+    return 'Error al marcar como no reproducido: $error';
+  }
+
+  @override
+  String failedToPlay(String error) {
+    return 'Error al reproducir: $error';
+  }
+
+  @override
+  String get markAsFinished => 'Marcar como terminado';
+
+  @override
+  String get markAsUnplayed => 'Marcar como no reproducido';
+
+  @override
+  String byAuthor(String author) {
+    return 'Por $author';
+  }
+
+  @override
+  String audiobookCount(int count) {
+    return '$count audiolibro(s)';
+  }
+
+  @override
+  String get loading => 'Cargando...';
+
+  @override
+  String bookCount(int count) {
+    return '$count libro(s)';
+  }
+
+  @override
+  String get books => 'Libros';
+
+  @override
+  String get noFavoriteAudiobooks => 'No hay audiolibros favoritos';
+
+  @override
+  String get tapHeartAudiobook => 'Toca el corazón en un audiolibro para añadirlo a favoritos';
+
+  @override
+  String get noAudiobooks => 'No hay audiolibros';
+
+  @override
+  String get addAudiobooksHint => 'Añade audiolibros a tu biblioteca para verlos aquí';
+
+  @override
+  String get noFavoriteArtists => 'No hay artistas favoritos';
+
+  @override
+  String get tapHeartArtist => 'Toca el corazón en un artista para añadirlo a favoritos';
+
+  @override
+  String get noFavoriteAlbums => 'No hay álbumes favoritos';
+
+  @override
+  String get tapHeartAlbum => 'Toca el corazón en un álbum para añadirlo a favoritos';
+
+  @override
+  String get noFavoritePlaylists => 'No hay listas de reproducción favoritas';
+
+  @override
+  String get tapHeartPlaylist => 'Toca el corazón en una lista para añadirla a favoritos';
+
+  @override
+  String get noFavoriteTracks => 'No hay canciones favoritas';
+
+  @override
+  String get longPressTrackHint => 'Mantén presionada una canción y toca el corazón para añadirla a favoritos';
+
+  @override
+  String get loadSeries => 'Cargar series';
+
+  @override
+  String get notConnected => 'No conectado a Music Assistant';
+
+  @override
+  String get notConnectedTitle => 'No conectado';
+
+  @override
+  String get connectHint => 'Conéctate a tu servidor Music Assistant para empezar a escuchar';
+
+  @override
+  String get configureServer => 'Configurar servidor';
+
+  @override
+  String get noArtistsFound => 'No se encontraron artistas';
+
+  @override
+  String get noTracksFound => 'No se encontraron canciones';
+
+  @override
+  String get noPlaylistsFound => 'No se encontraron listas de reproducción';
+
+  @override
+  String get queueIsEmpty => 'La cola está vacía';
+
+  @override
+  String get noResultsFound => 'No se encontraron resultados';
+
+  @override
+  String get refresh => 'Actualizar';
+
+  @override
+  String get debugConsole => 'Consola de depuración';
+
+  @override
+  String get copy => 'Copiar';
+
+  @override
+  String get clear => 'Borrar';
+
+  @override
+  String get noLogsToCopy => 'No hay registros para copiar';
+
+  @override
+  String get noDebugLogsYet => 'Aún no hay registros de depuración. Intenta detectar autenticación.';
+
+  @override
+  String get showDebug => 'Mostrar depuración';
+
+  @override
+  String get hideDebug => 'Ocultar depuración';
+
+  @override
+  String get chapters => 'Capítulos';
+
+  @override
+  String get noChapters => 'Sin capítulos';
+
+  @override
+  String get noChapterInfo => 'Este audiolibro no tiene información de capítulos';
+
+  @override
+  String errorSeeking(String error) {
+    return 'Error al buscar: $error';
+  }
+
+  @override
+  String error(String error) {
+    return 'Error: $error';
+  }
+
+  @override
+  String get home => 'Inicio';
+
+  @override
+  String get library => 'Biblioteca';
+
+  @override
+  String get homeScreen => 'Pantalla de inicio';
+
+  @override
+  String get metadataApis => 'APIs de metadatos';
+
+  @override
+  String get theme => 'Tema';
+
+  @override
+  String get materialYou => 'Material You';
+
+  @override
+  String get adaptiveTheme => 'Tema adaptativo';
+
+  @override
+  String get language => 'Idioma';
+
+  @override
+  String get english => 'Inglés';
+
+  @override
+  String get german => 'Alemán';
+
+  @override
+  String get spanish => 'Español';
+
+  @override
+  String get french => 'Francés';
+
+  @override
+  String get noTracksInPlaylist => 'No hay canciones en la lista';
+
+  @override
+  String get sortAlphabetically => 'Ordenar alfabéticamente';
+
+  @override
+  String get sortByYear => 'Ordenar por año';
+
+  @override
+  String get sortBySeriesOrder => 'Ordenar por orden de serie';
+
+  @override
+  String get listView => 'Vista de lista';
+
+  @override
+  String get gridView => 'Vista de cuadrícula';
+
+  @override
+  String get noBooksInSeries => 'No se encontraron libros en esta serie';
+
+  @override
+  String get artist => 'Artista';
+
+  @override
+  String get showRecentlyPlayedAlbums => 'Mostrar álbumes reproducidos recientemente';
+
+  @override
+  String get showRandomArtists => 'Mostrar artistas aleatorios para descubrir';
+
+  @override
+  String get showRandomAlbums => 'Mostrar álbumes aleatorios para descubrir';
+
+  @override
+  String get showAudiobooksInProgress => 'Mostrar audiolibros en progreso';
+
+  @override
+  String get showRandomAudiobooks => 'Mostrar audiolibros aleatorios para descubrir';
+
+  @override
+  String get showRandomSeries => 'Mostrar series de audiolibros aleatorias para descubrir';
+
+  @override
+  String get showFavoriteAlbums => 'Mostrar una fila de tus álbumes favoritos';
+
+  @override
+  String get showFavoriteArtists => 'Mostrar una fila de tus artistas favoritos';
+
+  @override
+  String get showFavoriteTracks => 'Mostrar una fila de tus canciones favoritas';
+
+  @override
+  String get showFavoritePlaylists => 'Show a row of your favorite playlists';
+
+  @override
+  String get showFavoriteRadioStations => 'Show a row of your favorite radio stations';
+
+  @override
+  String get showFavoritePodcasts => 'Show a row of your favorite podcasts';
+
+  @override
+  String get extractColorsFromArtwork => 'Extraer colores de las portadas de álbumes y artistas';
+
+  @override
+  String get chooseHomeScreenRows => 'Elige qué filas mostrar en la pantalla de inicio';
+
+  @override
+  String get addedToFavorites => 'Añadido a favoritos';
+
+  @override
+  String get removedFromFavorites => 'Eliminado de favoritos';
+
+  @override
+  String get addedToLibrary => 'Added to library';
+
+  @override
+  String get removedFromLibrary => 'Removed from library';
+
+  @override
+  String get addToLibrary => 'Add to library';
+
+  @override
+  String get unknown => 'Desconocido';
+
+  @override
+  String get noUpcomingTracks => 'No hay canciones próximas';
+
+  @override
+  String get showAll => 'Mostrar todo';
+
+  @override
+  String get showFavoritesOnly => 'Mostrar solo favoritos';
+
+  @override
+  String get changeView => 'Cambiar vista';
+
+  @override
+  String get authors => 'Autores';
+
+  @override
+  String get series => 'Series';
+
+  @override
+  String get shows => 'Programas';
+
+  @override
+  String get podcasts => 'Podcasts';
+
+  @override
+  String get podcastSupportComingSoon => 'Soporte de podcasts próximamente';
+
+  @override
+  String get noPodcasts => 'No podcasts';
+
+  @override
+  String get addPodcastsHint => 'Subscribe to podcasts in Music Assistant';
+
+  @override
+  String get episodes => 'Episodes';
+
+  @override
+  String get episode => 'Episode';
+
+  @override
+  String get playlist => 'Lista de reproducción';
+
+  @override
+  String get connectionError => 'Error de conexión';
+
+  @override
+  String get twoColumnGrid => 'Cuadrícula de 2 columnas';
+
+  @override
+  String get threeColumnGrid => 'Cuadrícula de 3 columnas';
+
+  @override
+  String get fromProviders => 'De proveedores';
+
+  @override
+  String get resume => 'Continuar';
+
+  @override
+  String get about => 'Acerca de';
+
+  @override
+  String get inProgress => 'En progreso';
+
+  @override
+  String narratedBy(String narrators) {
+    return 'Narrado por $narrators';
+  }
+
+  @override
+  String get unknownNarrator => 'Narrador desconocido';
+
+  @override
+  String get unknownAuthor => 'Autor desconocido';
+
+  @override
+  String get loadingChapters => 'Cargando capítulos...';
+
+  @override
+  String get noChapterInfoAvailable => 'No hay información de capítulos disponible';
+
+  @override
+  String percentComplete(int percent) {
+    return '$percent% completado';
+  }
+
+  @override
+  String get theAudioDbApiKey => 'Clave API de TheAudioDB';
+
+  @override
+  String get theAudioDbApiKeyHint => 'Usa \"2\" para nivel gratuito o clave premium';
+
+  @override
+  String get audiobookLibraries => 'Bibliotecas de audiolibros';
+
+  @override
+  String get chooseAudiobookLibraries => 'Elige qué bibliotecas de Audiobookshelf incluir';
+
+  @override
+  String get unknownLibrary => 'Biblioteca desconocida';
+
+  @override
+  String get noSeriesFound => 'No se encontraron series';
+
+  @override
+  String get ensembleBugReport => 'Informe de errores de Ensemble';
+
+  @override
+  String byOwner(String owner) {
+    return 'Por $owner';
+  }
+
+  @override
+  String get noSeriesAvailable => 'No hay series disponibles en tu biblioteca de audiolibros.\nDesliza para actualizar.';
+
+  @override
+  String get pullToLoadSeries => 'Desliza hacia abajo para cargar series\ndesde Music Assistant';
+
+  @override
+  String get search => 'Buscar';
+
+  @override
+  String get 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.';
+
+  @override
+  String get lastFmApiKey => 'Clave API de Last.fm';
+
+  @override
+  String get lastFmApiKeyHint => 'Obtén una clave gratuita en last.fm/api';
+
+  @override
+  String get swipeToSwitchDevice => 'Desliza para cambiar dispositivo';
+
+  @override
+  String chapterNumber(int number) {
+    return 'Capítulo $number';
+  }
+
+  @override
+  String get pcmAudio => 'Audio PCM';
+
+  @override
+  String get playOn => 'Reproducir en...';
+
+  @override
+  String get addAlbumToQueueOn => 'Añadir álbum a la cola en...';
+
+  @override
+  String get addToQueueOn => 'Añadir a la cola en...';
+
+  @override
+  String startRadioOn(String name) {
+    return 'Iniciar radio de $name en...';
+  }
+
+  @override
+  String get book => 'libro';
+
+  @override
+  String get audiobookSingular => 'audiolibro';
+
+  @override
+  String get albumSingular => 'Album';
+
+  @override
+  String get trackSingular => 'Track';
+
+  @override
+  String get podcastSingular => 'Podcast';
+
+  @override
+  String trackCount(int count) {
+    String _temp0 = intl.Intl.pluralLogic(
+      count,
+      locale: localeName,
+      other: 'canciones',
+      one: 'canción',
+    );
+    return '$count $_temp0';
+  }
+
+  @override
+  String get materialYouDescription => 'Usar colores del sistema (Android 12+)';
+
+  @override
+  String get accentColor => 'Color de acento';
+
+  @override
+  String get players => 'Dispositivos';
+
+  @override
+  String get preferLocalPlayer => 'Preferir dispositivo local';
+
+  @override
+  String get preferLocalPlayerDescription => 'Seleccionar siempre este dispositivo primero cuando esté disponible';
+
+  @override
+  String get smartSortPlayers => 'Orden inteligente';
+
+  @override
+  String get smartSortPlayersDescription => 'Ordenar por estado (reproduciendo, encendido, apagado) en lugar de alfabéticamente';
+
+  @override
+  String get playerStateUnavailable => 'No disponible';
+
+  @override
+  String get playerStateOff => 'Apagado';
+
+  @override
+  String get playerStateIdle => 'Inactivo';
+
+  @override
+  String get playerStateExternalSource => 'Fuente Externa';
+
+  @override
+  String get playerSelected => 'Seleccionado';
+
+  @override
+  String get actionQueuedForSync => 'Se sincronizará cuando esté en línea';
+
+  @override
+  String pendingOfflineActions(int count) {
+    return '$count sincronización pendiente';
+  }
+
+  @override
+  String get hintsAndTips => 'Consejos y Sugerencias';
+
+  @override
+  String get showHints => 'Mostrar Sugerencias';
+
+  @override
+  String get showHintsDescription => 'Mostrar consejos útiles para descubrir funciones';
+
+  @override
+  String get pullToSelectPlayers => 'Desliza para seleccionar dispositivos';
+
+  @override
+  String get holdToSync => 'Mantén presionado para sync';
+
+  @override
+  String get swipeToAdjustVolume => 'Desliza para ajustar volumen';
+
+  @override
+  String get selectPlayerHint => 'Choose a player, or dismiss by swiping down';
+
+  @override
+  String get welcomeToEnsemble => 'Welcome to Ensemble';
+
+  @override
+  String get welcomeMessage => 'By default your phone is the selected player.\nPull the mini player down to select another player.';
+
+  @override
+  String get skip => 'Skip';
+
+  @override
+  String get dismissPlayerHint => 'Swipe down, tap outside, or press back to return';
+
+  @override
+  String playingAlbum(String albumName) {
+    return 'Playing $albumName';
+  }
+
+  @override
+  String playingPlaylist(String playlistName) {
+    return 'Playing $playlistName';
+  }
+
+  @override
+  String get noTracks => 'No tracks';
+
+  @override
+  String get addTracksHint => 'Add some music to your library to see tracks here';
+
+  @override
+  String get noFavoriteRadioStations => 'No favorite radio stations';
+
+  @override
+  String get longPressRadioHint => 'Long-press a station and tap the heart to add it to favorites';
+
+  @override
+  String get noFavoritePodcasts => 'No favorite podcasts';
+
+  @override
+  String get longPressPodcastHint => 'Long-press a podcast and tap the heart to add it to favorites';
+}
@@ -0,0 +1,983 @@
+import 'package:intl/intl.dart' as intl;
+
+import 'app_localizations.dart';
+
+// ignore_for_file: type=lint
+
+/// The translations for French (`fr`).
+class SFr extends S {
+  SFr([String locale = 'fr']) : super(locale);
+
+  @override
+  String get appTitle => 'Ensemble';
+
+  @override
+  String get connecting => 'Connexion...';
+
+  @override
+  String get connected => 'Connecté';
+
+  @override
+  String get disconnected => 'Déconnecté';
+
+  @override
+  String get serverAddress => 'Adresse du serveur';
+
+  @override
+  String get serverAddressHint => 'ex., music.example.com ou 192.168.1.100';
+
+  @override
+  String get yourName => 'Votre nom';
+
+  @override
+  String get yourFirstName => 'Votre prénom';
+
+  @override
+  String get portOptional => 'Port (Facultatif)';
+
+  @override
+  String get portHint => 'ex., 8095 ou laisser vide';
+
+  @override
+  String get portDescription => 'Laisser vide pour les proxys inverses ou les ports standards. Entrer 8095 pour une connexion directe.';
+
+  @override
+  String get username => 'Nom d\'utilisateur';
+
+  @override
+  String get password => 'Mot de passe';
+
+  @override
+  String get detectAndConnect => 'Détecter et connecter';
+
+  @override
+  String get connect => 'Connectér';
+
+  @override
+  String get disconnect => 'Déconnectér';
+
+  @override
+  String get authServerUrlOptional => 'URL du serveur d\'auth (Facultatif)';
+
+  @override
+  String get authServerUrlHint => 'ex., auth.example.com (si different du serveur)';
+
+  @override
+  String get authServerUrlDescription => 'Laisser vide si l\'authentification est sur le meme serveur';
+
+  @override
+  String detectedAuthType(String authType) {
+    return 'Detected: $authType';
+  }
+
+  @override
+  String get serverRequiresAuth => 'Ce serveur requiert une authentification';
+
+  @override
+  String get tailscaleVpnConnection => 'Connexion VPN Tailscale';
+
+  @override
+  String get unencryptedConnection => 'Connexion non chiffrée';
+
+  @override
+  String get usingHttpOverTailscale => 'Utilisation de HTTP via Tailscale (tunnel chiffre)';
+
+  @override
+  String get httpsFailedUsingHttp => 'HTTPS a échoué, utilisation de HTTP en repli';
+
+  @override
+  String get httpNotEncrypted => 'Connexion HTTP - les donnees ne sont pas chiffrées';
+
+  @override
+  String get pleaseEnterServerAddress => 'Veuillez entrer l\'adresse de votre serveur Music Assistant';
+
+  @override
+  String get pleaseEnterName => 'Veuillez entrer votre nom';
+
+  @override
+  String get pleaseEnterValidPort => 'Veuillez entrer un numero de port valide (1-65535)';
+
+  @override
+  String get pleaseEnterCredentials => 'Veuillez entrer le nom d\'utilisateur et le mot de passe';
+
+  @override
+  String get authFailed => 'Echec de l\'authentification. Veuillez verifier vos identifiants.';
+
+  @override
+  String get maLoginFailed => 'Echec de la connexion a Music Assistant. Veuillez verifier vos identifiants.';
+
+  @override
+  String get connectionFailed => 'Impossible de se connecter au serveur. Veuillez verifier l\'adresse et reessayer.';
+
+  @override
+  String get detectingAuth => 'Detection de l\'authentification...';
+
+  @override
+  String get cannotDetermineAuth => 'Impossible de determiner les exigences d\'authentification. Veuillez verifier l\'URL du serveur.';
+
+  @override
+  String get noAuthentication => 'Pas d\'authentification';
+
+  @override
+  String get httpBasicAuth => 'HTTP Basic Auth';
+
+  @override
+  String get authelia => 'Authelia';
+
+  @override
+  String get musicAssistantLogin => 'Connexion Music Assistant';
+
+  @override
+  String get pressBackToMinimize => 'Appuyez a nouveau sur retour pour minimiser';
+
+  @override
+  String get recentlyPlayed => 'Ecoutes recemment';
+
+  @override
+  String get discoverArtists => 'Découvrir des artistes';
+
+  @override
+  String get discoverAlbums => 'Découvrir des albums';
+
+  @override
+  String get continueListening => 'Continuer l\'écoute';
+
+  @override
+  String get discoverAudiobooks => 'Découvrir des livres audio';
+
+  @override
+  String get discoverSeries => 'Découvrir des séries';
+
+  @override
+  String get favoriteAlbums => 'Albums favoris';
+
+  @override
+  String get favoriteArtists => 'Artistes favoris';
+
+  @override
+  String get favoriteTracks => 'Pistes favorites';
+
+  @override
+  String get favoritePlaylists => 'Playlists favorites';
+
+  @override
+  String get favoriteRadioStations => 'Stations de radio favorites';
+
+  @override
+  String get favoritePodcasts => 'Podcasts favoris';
+
+  @override
+  String get searchMusic => 'Rechercher de la musique...';
+
+  @override
+  String get searchForContent => 'Rechercher des artistes, albums ou pistes';
+
+  @override
+  String get recentSearches => 'Recherches recentes';
+
+  @override
+  String get clearSearchHistory => 'Effacer l\'historique de recherche';
+
+  @override
+  String get searchHistoryCleared => 'Historique de recherche efface';
+
+  @override
+  String get libraryOnly => 'Bibliothèque uniquement';
+
+  @override
+  String get retry => 'Reessayer';
+
+  @override
+  String get all => 'Tout';
+
+  @override
+  String get artists => 'Artistes';
+
+  @override
+  String get albums => 'Albums';
+
+  @override
+  String get tracks => 'Pistes';
+
+  @override
+  String get playlists => 'Playlists';
+
+  @override
+  String get audiobooks => 'Livres audio';
+
+  @override
+  String get music => 'Musique';
+
+  @override
+  String get radio => 'Radio';
+
+  @override
+  String get stations => 'Stations';
+
+  @override
+  String get selectLibrary => 'Sélectionner la bibliothèque';
+
+  @override
+  String get noRadioStations => 'Aucune station de radio';
+
+  @override
+  String get addRadioStationsHint => 'Ajouter des stations de radio dans Music Assistant';
+
+  @override
+  String get searchFailed => 'La recherche a échoué. Veuillez verifier votre connexion.';
+
+  @override
+  String get queue => 'File d\'attente';
+
+  @override
+  String playerQueue(String playerName) {
+    return 'File d\'attente de $playerName';
+  }
+
+  @override
+  String get noPlayerSelected => 'Aucun lecteur selectionne';
+
+  @override
+  String get undo => 'Annuler';
+
+  @override
+  String removedItem(String itemName) {
+    return '$itemName supprimé';
+  }
+
+  @override
+  String get settings => 'Paramètres';
+
+  @override
+  String get debugLogs => 'Journaux de debogage';
+
+  @override
+  String get themeMode => 'Mode de theme';
+
+  @override
+  String get light => 'Clair';
+
+  @override
+  String get dark => 'Sombre';
+
+  @override
+  String get system => 'Système';
+
+  @override
+  String get pullToRefresh => 'Tirez pour rafraichir la bibliothèque et appliquer les modifications';
+
+  @override
+  String get viewDebugLogs => 'Voir les journaux de debogage';
+
+  @override
+  String get viewAllPlayers => 'Voir tous les lecteurs';
+
+  @override
+  String get copyLogs => 'Copier les journaux';
+
+  @override
+  String get clearLogs => 'Effacer les journaux';
+
+  @override
+  String get copyList => 'Copier la liste';
+
+  @override
+  String get close => 'Fermer';
+
+  @override
+  String allPlayersCount(int count) {
+    return 'Tous les lecteurs ($count)';
+  }
+
+  @override
+  String errorLoadingPlayers(String error) {
+    return 'Erreur lors du chargement des lecteurs : $error';
+  }
+
+  @override
+  String get logsCopied => 'Journaux copies dans le presse-papiers';
+
+  @override
+  String get logsCleared => 'Journaux effaces';
+
+  @override
+  String get playerListCopied => 'Liste des lecteurs copiee dans le presse-papiers !';
+
+  @override
+  String get noLogsYet => 'Pas encore de journaux';
+
+  @override
+  String get infoPlus => 'Info+';
+
+  @override
+  String get warnings => 'Avertissements';
+
+  @override
+  String get errors => 'Erreurs';
+
+  @override
+  String showingEntries(int filtered, int total) {
+    return 'Affichage de $filtered sur $total entrées';
+  }
+
+  @override
+  String get thisDevice => 'Cet appareil';
+
+  @override
+  String get ghostPlayer => 'Lecteur fantome (doublon)';
+
+  @override
+  String get unavailableCorrupt => 'Indisponible/Corrompu';
+
+  @override
+  String playerId(String id) {
+    return 'ID : $id';
+  }
+
+  @override
+  String playerInfo(String available, String provider) {
+    return 'Disponible : $available | Fournisseur : $provider';
+  }
+
+  @override
+  String get shareBugReport => 'Partager le rapport de bogue';
+
+  @override
+  String get moreOptions => 'Plus d\'options';
+
+  @override
+  String failedToUpdateFavorite(String error) {
+    return 'Echec de la mise a jour du favori : $error';
+  }
+
+  @override
+  String get noPlayersAvailable => 'Aucun lecteur disponible';
+
+  @override
+  String get albumAddedToQueue => 'Album ajouté a la file d\'attente';
+
+  @override
+  String get tracksAddedToQueue => 'Pistes ajoutées a la file d\'attente';
+
+  @override
+  String get play => 'Lire';
+
+  @override
+  String get noPlayersFound => 'Aucun lecteur trouve';
+
+  @override
+  String startingRadio(String name) {
+    return 'Demarrage de la radio $name';
+  }
+
+  @override
+  String failedToStartRadio(String error) {
+    return 'Echec du demarrage de la radio : $error';
+  }
+
+  @override
+  String startingRadioOnPlayer(String name, String playerName) {
+    return 'Demarrage de la radio $name sur $playerName';
+  }
+
+  @override
+  String addedRadioToQueue(String name) {
+    return 'Radio $name ajoutée a la file d\'attente';
+  }
+
+  @override
+  String failedToAddToQueue(String error) {
+    return 'Echec de l\'ajout a la file d\'attente : $error';
+  }
+
+  @override
+  String playingRadioStation(String name) {
+    return 'Lecture de $name';
+  }
+
+  @override
+  String get addedToQueue => 'Ajoute a la file d\'attente';
+
+  @override
+  String get inLibrary => 'Dans la bibliothèque';
+
+  @override
+  String get noAlbumsFound => 'Aucun album trouve';
+
+  @override
+  String playing(String name) {
+    return 'Lecture de $name';
+  }
+
+  @override
+  String get playingTrack => 'Lecture de la piste';
+
+  @override
+  String get nowPlaying => 'En cours de lecture';
+
+  @override
+  String markedAsFinished(String name) {
+    return '$name marque comme termine';
+  }
+
+  @override
+  String failedToMarkFinished(String error) {
+    return 'Echec du marquage comme termine : $error';
+  }
+
+  @override
+  String markedAsUnplayed(String name) {
+    return '$name marque comme non lu';
+  }
+
+  @override
+  String failedToMarkUnplayed(String error) {
+    return 'Echec du marquage comme non lu : $error';
+  }
+
+  @override
+  String failedToPlay(String error) {
+    return 'Echec de la lecture : $error';
+  }
+
+  @override
+  String get markAsFinished => 'Marquer comme termine';
+
+  @override
+  String get markAsUnplayed => 'Marquer comme non lu';
+
+  @override
+  String byAuthor(String author) {
+    return 'Par $author';
+  }
+
+  @override
+  String audiobookCount(int count) {
+    return '$count livre(s) audio';
+  }
+
+  @override
+  String get loading => 'Chargement...';
+
+  @override
+  String bookCount(int count) {
+    return '$count livre(s)';
+  }
+
+  @override
+  String get books => 'Livres';
+
+  @override
+  String get noFavoriteAudiobooks => 'Aucun livre audio favori';
+
+  @override
+  String get tapHeartAudiobook => 'Appuyez sur le coeur d\'un livre audio pour l\'ajoutér aux favoris';
+
+  @override
+  String get noAudiobooks => 'Aucun livre audio';
+
+  @override
+  String get addAudiobooksHint => 'Ajoutez des livres audio a votre bibliothèque pour les voir ici';
+
+  @override
+  String get noFavoriteArtists => 'Aucun artiste favori';
+
+  @override
+  String get tapHeartArtist => 'Appuyez sur le coeur d\'un artiste pour l\'ajoutér aux favoris';
+
+  @override
+  String get noFavoriteAlbums => 'Aucun album favori';
+
+  @override
+  String get tapHeartAlbum => 'Appuyez sur le coeur d\'un album pour l\'ajoutér aux favoris';
+
+  @override
+  String get noFavoritePlaylists => 'Aucune playlist favorite';
+
+  @override
+  String get tapHeartPlaylist => 'Appuyez sur le coeur d\'une playlist pour l\'ajoutér aux favoris';
+
+  @override
+  String get noFavoriteTracks => 'Aucune piste favorite';
+
+  @override
+  String get longPressTrackHint => 'Appuyez longuement sur une piste et touchez le coeur pour l\'ajoutér aux favoris';
+
+  @override
+  String get loadSeries => 'Charger les séries';
+
+  @override
+  String get notConnected => 'Not connected to Music Assistant';
+
+  @override
+  String get notConnectedTitle => 'Not Connected';
+
+  @override
+  String get connectHint => 'Connectéz-vous a votre serveur Music Assistant pour commencer a écouter';
+
+  @override
+  String get configureServer => 'Configurer le serveur';
+
+  @override
+  String get noArtistsFound => 'Aucun artiste trouve';
+
+  @override
+  String get noTracksFound => 'Aucune piste trouvee';
+
+  @override
+  String get noPlaylistsFound => 'Aucune playlist trouvee';
+
+  @override
+  String get queueIsEmpty => 'La file d\'attente est vide';
+
+  @override
+  String get noResultsFound => 'Aucun resultat trouve';
+
+  @override
+  String get refresh => 'Rafraichir';
+
+  @override
+  String get debugConsole => 'Console de debogage';
+
+  @override
+  String get copy => 'Copier';
+
+  @override
+  String get clear => 'Effacer';
+
+  @override
+  String get noLogsToCopy => 'Aucun journal a copier';
+
+  @override
+  String get noDebugLogsYet => 'Pas encore de journaux de debogage. Essayez de détectér l\'authentification.';
+
+  @override
+  String get showDebug => 'Afficher le debogage';
+
+  @override
+  String get hideDebug => 'Masquer le debogage';
+
+  @override
+  String get chapters => 'Chapitres';
+
+  @override
+  String get noChapters => 'Aucun chapitre';
+
+  @override
+  String get noChapterInfo => 'Ce livre audio n\'a pas d\'informations de chapitre';
+
+  @override
+  String errorSeeking(String error) {
+    return 'Erreur de positionnement : $error';
+  }
+
+  @override
+  String error(String error) {
+    return 'Erreur : $error';
+  }
+
+  @override
+  String get home => 'Accueil';
+
+  @override
+  String get library => 'Bibliothèque';
+
+  @override
+  String get homeScreen => 'Ecran d\'accueil';
+
+  @override
+  String get metadataApis => 'API de metadonnees';
+
+  @override
+  String get theme => 'Theme';
+
+  @override
+  String get materialYou => 'Material You';
+
+  @override
+  String get adaptiveTheme => 'Theme adaptatif';
+
+  @override
+  String get language => 'Langue';
+
+  @override
+  String get english => 'Anglais';
+
+  @override
+  String get german => 'Allemand';
+
+  @override
+  String get spanish => 'Espagnol';
+
+  @override
+  String get french => 'Français';
+
+  @override
+  String get noTracksInPlaylist => 'Aucune piste dans la playlist';
+
+  @override
+  String get sortAlphabetically => 'Trier alphabétiquement';
+
+  @override
+  String get sortByYear => 'Trier par année';
+
+  @override
+  String get sortBySeriesOrder => 'Trier par ordre de série';
+
+  @override
+  String get listView => 'Vue en liste';
+
+  @override
+  String get gridView => 'Vue en grille';
+
+  @override
+  String get noBooksInSeries => 'Aucun livre trouve dans cette série';
+
+  @override
+  String get artist => 'Artiste';
+
+  @override
+  String get showRecentlyPlayedAlbums => 'Afficher les albums écoutes recemment';
+
+  @override
+  String get showRandomArtists => 'Afficher des artistes aléatoires a découvrir';
+
+  @override
+  String get showRandomAlbums => 'Afficher des albums aléatoires a découvrir';
+
+  @override
+  String get showAudiobooksInProgress => 'Afficher les livres audio en cours';
+
+  @override
+  String get showRandomAudiobooks => 'Afficher des livres audio aléatoires a découvrir';
+
+  @override
+  String get showRandomSeries => 'Afficher des séries de livres audio aléatoires a découvrir';
+
+  @override
+  String get showFavoriteAlbums => 'Afficher une rangee de vos albums favoris';
+
+  @override
+  String get showFavoriteArtists => 'Afficher une rangee de vos artistes favoris';
+
+  @override
+  String get showFavoriteTracks => 'Afficher une rangee de vos pistes favorites';
+
+  @override
+  String get showFavoritePlaylists => 'Afficher une rangee de vos playlists favorites';
+
+  @override
+  String get showFavoriteRadioStations => 'Afficher une rangee de vos stations de radio favorites';
+
+  @override
+  String get showFavoritePodcasts => 'Afficher une rangee de vos podcasts favoris';
+
+  @override
+  String get extractColorsFromArtwork => 'Extraire les couleurs des pochettes d\'albums et d\'artistes';
+
+  @override
+  String get chooseHomeScreenRows => 'Choisir les rangees a afficher sur l\'ecran d\'accueil';
+
+  @override
+  String get addedToFavorites => 'Ajoute aux favoris';
+
+  @override
+  String get removedFromFavorites => 'Retire des favoris';
+
+  @override
+  String get addedToLibrary => 'Ajoute a la bibliothèque';
+
+  @override
+  String get removedFromLibrary => 'Retire de la bibliothèque';
+
+  @override
+  String get addToLibrary => 'Ajouter a la bibliothèque';
+
+  @override
+  String get unknown => 'Inconnu';
+
+  @override
+  String get noUpcomingTracks => 'Aucune piste a venir';
+
+  @override
+  String get showAll => 'Tout afficher';
+
+  @override
+  String get showFavoritesOnly => 'Afficher les favoris uniquement';
+
+  @override
+  String get changeView => 'Changer la vue';
+
+  @override
+  String get authors => 'Auteurs';
+
+  @override
+  String get series => 'Series';
+
+  @override
+  String get shows => 'Emissions';
+
+  @override
+  String get podcasts => 'Podcasts';
+
+  @override
+  String get podcastSupportComingSoon => 'Prise en charge des podcasts bientot disponible';
+
+  @override
+  String get noPodcasts => 'Aucun podcast';
+
+  @override
+  String get addPodcastsHint => 'Abonnez-vous a des podcasts dans Music Assistant';
+
+  @override
+  String get episodes => 'Episodes';
+
+  @override
+  String get episode => 'Episode';
+
+  @override
+  String get playlist => 'Playlist';
+
+  @override
+  String get connectionError => 'Erreur de connexion';
+
+  @override
+  String get twoColumnGrid => 'Grille a 2 colonnes';
+
+  @override
+  String get threeColumnGrid => 'Grille a 3 colonnes';
+
+  @override
+  String get fromProviders => 'Des fournisseurs';
+
+  @override
+  String get resume => 'Reprendre';
+
+  @override
+  String get about => 'A propos';
+
+  @override
+  String get inProgress => 'En cours';
+
+  @override
+  String narratedBy(String narrators) {
+    return 'Lu par $narrators';
+  }
+
+  @override
+  String get unknownNarrator => 'Narrateur inconnu';
+
+  @override
+  String get unknownAuthor => 'Auteur inconnu';
+
+  @override
+  String get loadingChapters => 'Chargement des chapitres...';
+
+  @override
+  String get noChapterInfoAvailable => 'Aucune information de chapitre disponible';
+
+  @override
+  String percentComplete(int percent) {
+    return '$percent% termine';
+  }
+
+  @override
+  String get theAudioDbApiKey => 'Cle API TheAudioDB';
+
+  @override
+  String get theAudioDbApiKeyHint => 'Utilisez \"2\" pour le niveau gratuit ou une cle premium';
+
+  @override
+  String get audiobookLibraries => 'Bibliothèques de livres audio';
+
+  @override
+  String get chooseAudiobookLibraries => 'Choisir quelles bibliothèques Audiobookshelf inclure';
+
+  @override
+  String get unknownLibrary => 'Bibliothèque inconnue';
+
+  @override
+  String get noSeriesFound => 'Aucune série trouvee';
+
+  @override
+  String get ensembleBugReport => 'Rapport de bogue Ensemble';
+
+  @override
+  String byOwner(String owner) {
+    return 'Par $owner';
+  }
+
+  @override
+  String get noSeriesAvailable => 'Aucune série disponible dans votre bibliothèque de livres audio.\nTirez pour rafraichir.';
+
+  @override
+  String get pullToLoadSeries => 'Tirez vers le bas pour charger les séries\ndepuis Music Assistant';
+
+  @override
+  String get search => 'Rechercher';
+
+  @override
+  String get metadataApisDescription => 'Les images d\'artistes sont automatiquement recuperees depuis Deezer. Ajoutez les cles API ci-dessous pour les biographies d\'artistes et les descriptions d\'albums.';
+
+  @override
+  String get lastFmApiKey => 'Cle API Last.fm';
+
+  @override
+  String get lastFmApiKeyHint => 'Obtenez une cle gratuite sur last.fm/api';
+
+  @override
+  String get swipeToSwitchDevice => 'Balayez pour changer de lecteur';
+
+  @override
+  String chapterNumber(int number) {
+    return 'Chapitre $number';
+  }
+
+  @override
+  String get pcmAudio => 'Audio PCM';
+
+  @override
+  String get playOn => 'Lire sur...';
+
+  @override
+  String get addAlbumToQueueOn => 'Ajouter l\'album a la file d\'attente sur...';
+
+  @override
+  String get addToQueueOn => 'Ajouter a la file d\'attente sur...';
+
+  @override
+  String startRadioOn(String name) {
+    return 'Demarrer la radio $name sur...';
+  }
+
+  @override
+  String get book => 'livre';
+
+  @override
+  String get audiobookSingular => 'livre audio';
+
+  @override
+  String get albumSingular => 'Album';
+
+  @override
+  String get trackSingular => 'Piste';
+
+  @override
+  String get podcastSingular => 'Podcast';
+
+  @override
+  String trackCount(int count) {
+    String _temp0 = intl.Intl.pluralLogic(
+      count,
+      locale: localeName,
+      other: '$count pistes',
+      one: '$count piste',
+    );
+    return '$_temp0';
+  }
+
+  @override
+  String get materialYouDescription => 'Utiliser les couleurs systeme (Android 12+)';
+
+  @override
+  String get accentColor => 'Couleur d\'accentuation';
+
+  @override
+  String get players => 'Lecteurs';
+
+  @override
+  String get preferLocalPlayer => 'Préférer le lecteur local';
+
+  @override
+  String get preferLocalPlayerDescription => 'Toujours sélectionner cet appareil en premier si disponible';
+
+  @override
+  String get smartSortPlayers => 'Tri intelligent';
+
+  @override
+  String get smartSortPlayersDescription => 'Trier par statut (en lecture, allume, eteint) au lieu d\'alphabétiquement';
+
+  @override
+  String get playerStateUnavailable => 'Indisponible';
+
+  @override
+  String get playerStateOff => 'Eteint';
+
+  @override
+  String get playerStateIdle => 'Inactif';
+
+  @override
+  String get playerStateExternalSource => 'Source externe';
+
+  @override
+  String get playerSelected => 'Selectionne';
+
+  @override
+  String get actionQueuedForSync => 'Sera synchronise une fois en ligne';
+
+  @override
+  String pendingOfflineActions(int count) {
+    return '$count en attente de synchronisation';
+  }
+
+  @override
+  String get hintsAndTips => 'Astuces et conseils';
+
+  @override
+  String get showHints => 'Afficher les astuces';
+
+  @override
+  String get showHintsDescription => 'Afficher des conseils utiles pour découvrir les fonctionnalites';
+
+  @override
+  String get pullToSelectPlayers => 'Tirez pour sélectionner les lecteurs';
+
+  @override
+  String get holdToSync => 'Appui long pour synchroniser';
+
+  @override
+  String get swipeToAdjustVolume => 'Balayez pour ajuster le volume';
+
+  @override
+  String get selectPlayerHint => 'Choisissez un lecteur ou fermez en balayant vers le bas';
+
+  @override
+  String get welcomeToEnsemble => 'Bienvenue dans Ensemble';
+
+  @override
+  String get welcomeMessage => 'Par defaut, votre telephone est le lecteur selectionne.\nTirez le mini-lecteur vers le bas pour sélectionner un autre lecteur.';
+
+  @override
+  String get skip => 'Passer';
+
+  @override
+  String get dismissPlayerHint => 'Balayez vers le bas, touchez a l\'exterieur ou appuyez sur retour pour revenir';
+
+  @override
+  String playingAlbum(String albumName) {
+    return 'Lecture de $albumName';
+  }
+
+  @override
+  String playingPlaylist(String playlistName) {
+    return 'Lecture de $playlistName';
+  }
+
+  @override
+  String get noTracks => 'No tracks';
+
+  @override
+  String get addTracksHint => 'Add some music to your library to see tracks here';
+
+  @override
+  String get noFavoriteRadioStations => 'No favorite radio stations';
+
+  @override
+  String get longPressRadioHint => 'Long-press a station and tap the heart to add it to favorites';
+
+  @override
+  String get noFavoritePodcasts => 'No favorite podcasts';
+
+  @override
+  String get longPressPodcastHint => 'Long-press a podcast and tap the heart to add it to favorites';
+}
@@ -1,8 +1,12 @@
 import 'dart:async';
+import 'dart:ui';
 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';
@@ -30,6 +34,10 @@ final _logger = DebugLogger();
 Future<void> main() async {
  WidgetsFlutterBinding.ensureInitialized();

+  // Initialize SharedPreferences cache early for performance
+  await SettingsService.initialize();
+  _logger.log('⚡ SharedPreferences cached');
+
  // Initialize local database
  await DatabaseService.instance.initialize();
  _logger.log('💾 Database initialized');
@@ -37,6 +45,10 @@ Future<void> main() async {
  // 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');
@@ -64,17 +76,42 @@ 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,
    ),
  );

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

 class MusicAssistantApp extends StatefulWidget {
@@ -87,6 +124,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;
@@ -101,6 +139,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
@@ -167,11 +206,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();
  }
@@ -197,9 +253,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()
@@ -210,14 +267,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(
@@ -228,6 +292,38 @@ 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,
+                  // Fallback to English when locale is not supported
+                  localeListResolutionCallback: (locales, supportedLocales) {
+                    // If user has set a specific locale, try to use it
+                    if (localeProvider.locale != null) {
+                      for (final supported in supportedLocales) {
+                        if (supported.languageCode == localeProvider.locale!.languageCode) {
+                          return supported;
+                        }
+                      }
+                    }
+                    // Try to match system locales
+                    if (locales != null) {
+                      for (final locale in locales) {
+                        for (final supported in supportedLocales) {
+                          if (supported.languageCode == locale.languageCode) {
+                            return supported;
+                          }
+                        }
+                      }
+                    }
+                    // Fallback to English (not German)
+                    return const Locale('en');
+                  },
                  themeMode: themeProvider.themeMode,
                  theme: AppTheme.lightTheme(colorScheme: lightColorScheme),
                  darkTheme: AppTheme.darkTheme(colorScheme: darkColorScheme),
@@ -304,8 +400,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,
        ),
      );
@@ -324,7 +420,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});

@@ -337,9 +442,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();
  }

@@ -364,14 +492,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;
@@ -398,7 +542,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(
@@ -58,6 +58,10 @@ class MediaItem {
  final bool? favorite;
  final int? position;
  final Duration? duration;
+  final DateTime? timestampAdded;
+  final DateTime? timestampModified;
+  final DateTime? lastPlayed;
+  final int? playCount;

  MediaItem({
    required this.itemId,
@@ -71,6 +75,10 @@ class MediaItem {
    this.favorite,
    this.position,
    this.duration,
+    this.timestampAdded,
+    this.timestampModified,
+    this.lastPlayed,
+    this.playCount,
  });

  factory MediaItem.fromJson(Map<String, dynamic> json) {
@@ -83,6 +91,21 @@ class MediaItem {
      );
    }

+    // Parse timestamp fields (can be int unix timestamp or ISO string)
+    DateTime? parseTimestamp(dynamic value) {
+      if (value == null) return null;
+      if (value is int) {
+        return DateTime.fromMillisecondsSinceEpoch(value * 1000);
+      }
+      if (value is double) {
+        return DateTime.fromMillisecondsSinceEpoch((value * 1000).toInt());
+      }
+      if (value is String) {
+        return DateTime.tryParse(value);
+      }
+      return null;
+    }
+
    return MediaItem(
      itemId: json['item_id']?.toString() ?? json['id']?.toString() ?? '',
      provider: json['provider'] as String? ?? 'unknown',
@@ -99,6 +122,10 @@ class MediaItem {
      duration: json['duration'] != null
          ? Duration(seconds: (json['duration'] as num).toInt())
          : null,
+      timestampAdded: parseTimestamp(json['timestamp_added']),
+      timestampModified: parseTimestamp(json['timestamp_modified']),
+      lastPlayed: parseTimestamp(json['last_played']),
+      playCount: json['play_count'] as int?,
    );
  }

@@ -110,11 +137,16 @@ 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,
      if (duration != null) 'duration': duration!.inSeconds,
+      if (timestampAdded != null) 'timestamp_added': timestampAdded!.millisecondsSinceEpoch ~/ 1000,
+      if (timestampModified != null) 'timestamp_modified': timestampModified!.millisecondsSinceEpoch ~/ 1000,
+      if (lastPlayed != null) 'last_played': lastPlayed!.millisecondsSinceEpoch ~/ 1000,
+      if (playCount != null) 'play_count': playCount,
    };
  }
 }
@@ -129,6 +161,10 @@ class Artist extends MediaItem {
    super.providerMappings,
    super.metadata,
    super.favorite,
+    super.timestampAdded,
+    super.timestampModified,
+    super.lastPlayed,
+    super.playCount,
  }) : super(mediaType: MediaType.artist);

  factory Artist.fromJson(Map<String, dynamic> json) {
@@ -142,6 +178,10 @@ class Artist extends MediaItem {
      providerMappings: item.providerMappings,
      metadata: item.metadata,
      favorite: item.favorite,
+      timestampAdded: item.timestampAdded,
+      timestampModified: item.timestampModified,
+      lastPlayed: item.lastPlayed,
+      playCount: item.playCount,
    );
  }

@@ -166,6 +206,10 @@ class Album extends MediaItem {
    super.providerMappings,
    super.metadata,
    super.favorite,
+    super.timestampAdded,
+    super.timestampModified,
+    super.lastPlayed,
+    super.playCount,
  }) : super(mediaType: MediaType.album);

  factory Album.fromJson(Map<String, dynamic> json) {
@@ -193,6 +237,10 @@ class Album extends MediaItem {
      providerMappings: item.providerMappings,
      metadata: item.metadata,
      favorite: item.favorite,
+      timestampAdded: item.timestampAdded,
+      timestampModified: item.timestampModified,
+      lastPlayed: item.lastPlayed,
+      playCount: item.playCount,
    );
  }

@@ -239,6 +287,10 @@ class Track extends MediaItem {
    super.favorite,
    super.position,
    super.duration,
+    super.timestampAdded,
+    super.timestampModified,
+    super.lastPlayed,
+    super.playCount,
  }) : super(mediaType: MediaType.track);

  factory Track.fromJson(Map<String, dynamic> json) {
@@ -260,6 +312,10 @@ class Track extends MediaItem {
      favorite: item.favorite,
      position: item.position,
      duration: item.duration,
+      timestampAdded: item.timestampAdded,
+      timestampModified: item.timestampModified,
+      lastPlayed: item.lastPlayed,
+      playCount: item.playCount,
    );
  }

@@ -294,6 +350,10 @@ class Playlist extends MediaItem {
    super.providerMappings,
    super.metadata,
    super.favorite,
+    super.timestampAdded,
+    super.timestampModified,
+    super.lastPlayed,
+    super.playCount,
  }) : super(mediaType: MediaType.playlist);

  factory Playlist.fromJson(Map<String, dynamic> json) {
@@ -310,6 +370,10 @@ class Playlist extends MediaItem {
      providerMappings: item.providerMappings,
      metadata: item.metadata,
      favorite: item.favorite,
+      timestampAdded: item.timestampAdded,
+      timestampModified: item.timestampModified,
+      lastPlayed: item.lastPlayed,
+      playCount: item.playCount,
    );
  }
 }
@@ -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,
    };
  }
 }
@@ -1,250 +0,0 @@
-import 'dart:async';
-import 'package:flutter/foundation.dart';
-import '../services/music_assistant_api.dart';
-import '../services/settings_service.dart';
-import '../services/database_service.dart';
-import '../services/profile_service.dart';
-import '../services/debug_logger.dart';
-import '../services/error_handler.dart';
-import '../services/auth/auth_manager.dart';
-import '../services/cache_service.dart';
-
-/// Provider for managing connection state to Music Assistant server
-/// Handles WebSocket connection, authentication, and reconnection
-class ConnectionProvider with ChangeNotifier {
-  MusicAssistantAPI? _api;
-  final AuthManager _authManager = AuthManager();
-  final DebugLogger _logger = DebugLogger();
-  final CacheService _cacheService = CacheService();
-
-  MAConnectionState _connectionState = MAConnectionState.disconnected;
-  String? _serverUrl;
-  String? _error;
-
-  // Callbacks for post-connection initialization
-  VoidCallback? onConnected;
-  VoidCallback? onAuthenticated;
-  VoidCallback? onDisconnected;
-
-  MAConnectionState get connectionState => _connectionState;
-  String? get serverUrl => _serverUrl;
-  String? get error => _error;
-  bool get isConnected => _connectionState == MAConnectionState.connected ||
-                          _connectionState == MAConnectionState.authenticated;
-
-  MusicAssistantAPI? get api => _api;
-  AuthManager get authManager => _authManager;
-  CacheService get cacheService => _cacheService;
-
-  ConnectionProvider() {
-    _initialize();
-  }
-
-  Future<void> _initialize() async {
-    _serverUrl = await SettingsService.getServerUrl();
-    if (_serverUrl != null && _serverUrl!.isNotEmpty) {
-      await _restoreAuthCredentials();
-      await connectToServer(_serverUrl!);
-    }
-  }
-
-  /// Restore auth credentials from persistent storage
-  Future<void> _restoreAuthCredentials() async {
-    final savedCredentials = await SettingsService.getAuthCredentials();
-    if (savedCredentials != null) {
-      _logger.log('🔐 Restoring saved auth credentials...');
-      _authManager.deserializeCredentials(savedCredentials);
-      _logger.log('🔐 Auth credentials restored: ${_authManager.currentStrategy?.name ?? "none"}');
-    } else {
-      _logger.log('🔐 No saved auth credentials found');
-    }
-  }
-
-  /// Handle Music Assistant native authentication after WebSocket connection
-  Future<bool> handleMaAuthentication() async {
-    if (_api == null) return false;
-
-    try {
-      // First, try stored MA token
-      final storedToken = await SettingsService.getMaAuthToken();
-      if (storedToken != null) {
-        _logger.log('🔐 Trying stored MA token...');
-        final success = await _api!.authenticateWithToken(storedToken);
-        if (success) {
-          _logger.log('✅ MA authentication with stored token successful');
-          await _fetchAndSetUserProfileName();
-          return true;
-        }
-        _logger.log('⚠️ Stored MA token invalid, clearing...');
-        await SettingsService.clearMaAuthToken();
-      }
-
-      // No valid token - try stored credentials
-      final username = await SettingsService.getUsername();
-      final password = await SettingsService.getPassword();
-
-      if (username != null && password != null && username.isNotEmpty && password.isNotEmpty) {
-        _logger.log('🔐 Trying stored credentials...');
-        final accessToken = await _api!.loginWithCredentials(username, password);
-
-        if (accessToken != null) {
-          _logger.log('✅ MA login with stored credentials successful');
-
-          final longLivedToken = await _api!.createLongLivedToken();
-          if (longLivedToken != null) {
-            await SettingsService.setMaAuthToken(longLivedToken);
-            _logger.log('✅ Saved new long-lived MA token');
-          } else {
-            await SettingsService.setMaAuthToken(accessToken);
-          }
-
-          await _fetchAndSetUserProfileName();
-          return true;
-        }
-      }
-
-      _logger.log('❌ MA authentication failed - no valid token or credentials');
-      return false;
-    } catch (e) {
-      _logger.log('❌ MA authentication error: $e');
-      return false;
-    }
-  }
-
-  /// Fetch user profile from MA and set owner name + create/activate local profile
-  Future<void> _fetchAndSetUserProfileName() async {
-    if (_api == null) return;
-
-    try {
-      final userInfo = await _api!.getCurrentUserInfo();
-      if (userInfo == null) {
-        _logger.log('⚠️ Could not fetch user profile');
-        return;
-      }
-
-      final displayName = userInfo['display_name'] as String?;
-      final username = userInfo['username'] as String?;
-
-      _logger.log('🔍 Profile data: display_name="$displayName", username="$username"');
-
-      final profileName = (displayName != null && displayName.isNotEmpty)
-          ? displayName
-          : username;
-
-      if (profileName != null && profileName.isNotEmpty) {
-        await SettingsService.setOwnerName(profileName);
-        _logger.log('✅ Set owner name from MA profile: $profileName');
-
-        // Create/activate profile in local database
-        if (DatabaseService.instance.isInitialized && username != null) {
-          await ProfileService.instance.onMaAuthenticated(
-            username: username,
-            displayName: displayName,
-          );
-          _logger.log('✅ Local profile activated: $username');
-        }
-      } else {
-        _logger.log('⚠️ No valid name in profile');
-      }
-    } catch (e) {
-      _logger.log('⚠️ Could not fetch user profile (non-fatal): $e');
-    }
-  }
-
-  Future<void> connectToServer(String serverUrl) async {
-    try {
-      _error = null;
-      _serverUrl = serverUrl;
-      await SettingsService.setServerUrl(serverUrl);
-
-      // Disconnect existing connection
-      await _api?.disconnect();
-
-      _api = MusicAssistantAPI(serverUrl, _authManager);
-
-      // Listen to connection state changes
-      _api!.connectionState.listen(
-        (state) async {
-          _connectionState = state;
-          notifyListeners();
-
-          if (state == MAConnectionState.connected) {
-            _logger.log('🔗 WebSocket connected to MA server');
-
-            if (_api!.authRequired && !_api!.isAuthenticated) {
-              _logger.log('🔐 MA auth required, attempting authentication...');
-              final authenticated = await handleMaAuthentication();
-              if (!authenticated) {
-                _logger.log('❌ MA authentication failed - stopping connection flow');
-                _error = 'Authentication required. Please log in again.';
-                notifyListeners();
-                return;
-              }
-              return;
-            }
-
-            // No auth required - notify connected
-            onConnected?.call();
-          } else if (state == MAConnectionState.authenticated) {
-            _logger.log('✅ MA authentication successful');
-            onAuthenticated?.call();
-          } else if (state == MAConnectionState.disconnected) {
-            _cacheService.clearAll();
-            onDisconnected?.call();
-          }
-        },
-        onError: (error) {
-          _logger.log('Connection state stream error: $error');
-          _connectionState = MAConnectionState.error;
-          notifyListeners();
-        },
-      );
-
-      await _api!.connect();
-      notifyListeners();
-    } catch (e) {
-      final errorInfo = ErrorHandler.handleError(e, context: 'Connect to server');
-      _error = errorInfo.userMessage;
-      _connectionState = MAConnectionState.error;
-      _logger.log('Connection error: ${errorInfo.technicalMessage}');
-      notifyListeners();
-      rethrow;
-    }
-  }
-
-  Future<void> disconnect() async {
-    await _api?.disconnect();
-    _connectionState = MAConnectionState.disconnected;
-    _cacheService.clearAll();
-    notifyListeners();
-  }
-
-  /// Check connection and reconnect if needed (called when app resumes)
-  Future<void> checkAndReconnect() async {
-    _logger.log('🔄 checkAndReconnect called - state: $_connectionState');
-
-    if (_serverUrl == null) {
-      _logger.log('🔄 No server URL saved, skipping reconnect');
-      return;
-    }
-
-    if (_connectionState != MAConnectionState.connected &&
-        _connectionState != MAConnectionState.authenticated) {
-      _logger.log('🔄 Not connected, attempting reconnect to $_serverUrl');
-      try {
-        await connectToServer(_serverUrl!);
-        _logger.log('🔄 Reconnection successful');
-      } catch (e) {
-        _logger.log('🔄 Reconnection failed: $e');
-      }
-    } else {
-      _logger.log('🔄 Already connected, connection verified');
-    }
-  }
-
-  @override
-  void dispose() {
-    _api?.dispose();
-    super.dispose();
-  }
-}
@@ -1,383 +0,0 @@
-import 'package:flutter/foundation.dart';
-import '../models/media_item.dart';
-import '../services/music_assistant_api.dart';
-import '../services/debug_logger.dart';
-import '../services/error_handler.dart';
-import '../services/cache_service.dart';
-import '../constants/timings.dart';
-
-/// Provider for managing library data (artists, albums, tracks, playlists)
-class LibraryProvider with ChangeNotifier {
-  final DebugLogger _logger = DebugLogger();
-  final CacheService _cacheService;
-
-  MusicAssistantAPI? _api;
-
-  List<Artist> _artists = [];
-  List<Album> _albums = [];
-  List<Track> _tracks = [];
-  bool _isLoading = false;
-  String? _error;
-
-  // Search state persistence
-  String _lastSearchQuery = '';
-  Map<String, List<MediaItem>> _lastSearchResults = {
-    'artists': [],
-    'albums': [],
-    'tracks': [],
-  };
-
-  // Getters
-  List<Artist> get artists => _artists;
-  List<Album> get albums => _albums;
-  List<Track> get tracks => _tracks;
-  bool get isLoading => _isLoading;
-  String? get error => _error;
-  String get lastSearchQuery => _lastSearchQuery;
-  Map<String, List<MediaItem>> get lastSearchResults => _lastSearchResults;
-
-  LibraryProvider(this._cacheService);
-
-  /// Initialize with API reference after connection
-  void initialize(MusicAssistantAPI api) {
-    _api = api;
-  }
-
-  void saveSearchState(String query, Map<String, List<MediaItem>> results) {
-    _lastSearchQuery = query;
-    _lastSearchResults = results;
-  }
-
-  void clearSearchState() {
-    _lastSearchQuery = '';
-    _lastSearchResults = {
-      'artists': [],
-      'albums': [],
-      'tracks': [],
-    };
-  }
-
-  // ============================================================================
-  // HOME SCREEN DATA
-  // ============================================================================
-
-  /// Get recently played albums with caching
-  Future<List<Album>> getRecentAlbumsWithCache({bool forceRefresh = false}) async {
-    if (_cacheService.isRecentAlbumsCacheValid(forceRefresh: forceRefresh)) {
-      _logger.log('📦 Using cached recent albums');
-      return _cacheService.getCachedRecentAlbums()!;
-    }
-
-    if (_api == null) return _cacheService.getCachedRecentAlbums() ?? [];
-
-    try {
-      _logger.log('🔄 Fetching fresh recent albums...');
-      final albums = await _api!.getRecentAlbums(limit: LibraryConstants.defaultRecentLimit);
-      _cacheService.setCachedRecentAlbums(albums);
-      return albums;
-    } catch (e) {
-      _logger.log('❌ Failed to fetch recent albums: $e');
-      return _cacheService.getCachedRecentAlbums() ?? [];
-    }
-  }
-
-  /// Get discover artists (random) with caching
-  Future<List<Artist>> getDiscoverArtistsWithCache({bool forceRefresh = false}) async {
-    if (_cacheService.isDiscoverArtistsCacheValid(forceRefresh: forceRefresh)) {
-      _logger.log('📦 Using cached discover artists');
-      return _cacheService.getCachedDiscoverArtists()!;
-    }
-
-    if (_api == null) return _cacheService.getCachedDiscoverArtists() ?? [];
-
-    try {
-      _logger.log('🔄 Fetching fresh discover artists...');
-      final artists = await _api!.getRandomArtists(limit: LibraryConstants.defaultRecentLimit);
-      _cacheService.setCachedDiscoverArtists(artists);
-      return artists;
-    } catch (e) {
-      _logger.log('❌ Failed to fetch discover artists: $e');
-      return _cacheService.getCachedDiscoverArtists() ?? [];
-    }
-  }
-
-  /// Get discover albums (random) with caching
-  Future<List<Album>> getDiscoverAlbumsWithCache({bool forceRefresh = false}) async {
-    if (_cacheService.isDiscoverAlbumsCacheValid(forceRefresh: forceRefresh)) {
-      _logger.log('📦 Using cached discover albums');
-      return _cacheService.getCachedDiscoverAlbums()!;
-    }
-
-    if (_api == null) return _cacheService.getCachedDiscoverAlbums() ?? [];
-
-    try {
-      _logger.log('🔄 Fetching fresh discover albums...');
-      final albums = await _api!.getRandomAlbums(limit: LibraryConstants.defaultRecentLimit);
-      _cacheService.setCachedDiscoverAlbums(albums);
-      return albums;
-    } catch (e) {
-      _logger.log('❌ Failed to fetch discover albums: $e');
-      return _cacheService.getCachedDiscoverAlbums() ?? [];
-    }
-  }
-
-  /// Invalidate home screen cache (call on pull-to-refresh)
-  void invalidateHomeCache() {
-    _cacheService.invalidateHomeCache();
-  }
-
-  // ============================================================================
-  // LIBRARY DATA
-  // ============================================================================
-
-  Future<void> loadLibrary() async {
-    if (_api == null) return;
-
-    try {
-      _isLoading = true;
-      _error = null;
-      notifyListeners();
-
-      final results = await Future.wait([
-        _api!.getArtists(limit: LibraryConstants.maxLibraryItems),
-        _api!.getAlbums(limit: LibraryConstants.maxLibraryItems),
-        _api!.getTracks(limit: LibraryConstants.maxLibraryItems),
-      ]);
-
-      _artists = results[0] as List<Artist>;
-      _albums = results[1] as List<Album>;
-      _tracks = results[2] as List<Track>;
-
-      _isLoading = false;
-      notifyListeners();
-    } catch (e) {
-      final errorInfo = ErrorHandler.handleError(e, context: 'Load library');
-      _error = errorInfo.userMessage;
-      _isLoading = false;
-      notifyListeners();
-    }
-  }
-
-  Future<void> loadArtists({int? limit, int? offset, String? search}) async {
-    if (_api == null) return;
-
-    try {
-      _isLoading = true;
-      _error = null;
-      notifyListeners();
-
-      _artists = await _api!.getArtists(
-        limit: limit ?? LibraryConstants.maxLibraryItems,
-        offset: offset,
-        search: search,
-      );
-
-      _isLoading = false;
-      notifyListeners();
-    } catch (e) {
-      final errorInfo = ErrorHandler.handleError(e, context: 'Load artists');
-      _error = errorInfo.userMessage;
-      _isLoading = false;
-      notifyListeners();
-    }
-  }
-
-  Future<void> loadAlbums({int? limit, int? offset, String? search, String? artistId}) async {
-    if (_api == null) return;
-
-    try {
-      _isLoading = true;
-      _error = null;
-      notifyListeners();
-
-      _albums = await _api!.getAlbums(
-        limit: limit ?? LibraryConstants.maxLibraryItems,
-        offset: offset,
-        search: search,
-        artistId: artistId,
-      );
-
-      _isLoading = false;
-      notifyListeners();
-    } catch (e) {
-      final errorInfo = ErrorHandler.handleError(e, context: 'Load albums');
-      _error = errorInfo.userMessage;
-      _isLoading = false;
-      notifyListeners();
-    }
-  }
-
-  // ============================================================================
-  // DETAIL SCREEN DATA
-  // ============================================================================
-
-  /// Get album tracks with caching
-  Future<List<Track>> getAlbumTracksWithCache(String provider, String itemId, {bool forceRefresh = false}) async {
-    final cacheKey = '${provider}_$itemId';
-
-    if (_cacheService.isAlbumTracksCacheValid(cacheKey, forceRefresh: forceRefresh)) {
-      _logger.log('📦 Using cached album tracks for $cacheKey');
-      return _cacheService.getCachedAlbumTracks(cacheKey)!;
-    }
-
-    if (_api == null) return _cacheService.getCachedAlbumTracks(cacheKey) ?? [];
-
-    try {
-      _logger.log('🔄 Fetching fresh album tracks for $cacheKey...');
-      final tracks = await _api!.getAlbumTracks(provider, itemId);
-      _cacheService.setCachedAlbumTracks(cacheKey, tracks);
-      return tracks;
-    } catch (e) {
-      _logger.log('❌ Failed to fetch album tracks: $e');
-      return _cacheService.getCachedAlbumTracks(cacheKey) ?? [];
-    }
-  }
-
-  /// Get playlist tracks with caching
-  Future<List<Track>> getPlaylistTracksWithCache(String provider, String itemId, {bool forceRefresh = false}) async {
-    final cacheKey = '${provider}_$itemId';
-
-    if (_cacheService.isPlaylistTracksCacheValid(cacheKey, forceRefresh: forceRefresh)) {
-      _logger.log('📦 Using cached playlist tracks for $cacheKey');
-      return _cacheService.getCachedPlaylistTracks(cacheKey)!;
-    }
-
-    if (_api == null) return _cacheService.getCachedPlaylistTracks(cacheKey) ?? [];
-
-    try {
-      _logger.log('🔄 Fetching fresh playlist tracks for $cacheKey...');
-      final tracks = await _api!.getPlaylistTracks(provider, itemId);
-      _cacheService.setCachedPlaylistTracks(cacheKey, tracks);
-      return tracks;
-    } catch (e) {
-      _logger.log('❌ Failed to fetch playlist tracks: $e');
-      return _cacheService.getCachedPlaylistTracks(cacheKey) ?? [];
-    }
-  }
-
-  /// Get artist albums with caching
-  Future<List<Album>> getArtistAlbumsWithCache(String artistName, {bool forceRefresh = false}) async {
-    final cacheKey = artistName.toLowerCase();
-
-    if (_cacheService.isArtistAlbumsCacheValid(cacheKey, forceRefresh: forceRefresh)) {
-      _logger.log('📦 Using cached artist albums for "$artistName"');
-      return _cacheService.getCachedArtistAlbums(cacheKey)!;
-    }
-
-    if (_api == null) return _cacheService.getCachedArtistAlbums(cacheKey) ?? [];
-
-    try {
-      _logger.log('🔄 Fetching albums for artist "$artistName"...');
-
-      final libraryAlbums = await _api!.getAlbums();
-      final artistAlbums = libraryAlbums.where((album) {
-        final albumArtists = album.artists;
-        if (albumArtists == null || albumArtists.isEmpty) return false;
-        return albumArtists.any((a) => a.name.toLowerCase() == artistName.toLowerCase());
-      }).toList();
-
-      final searchResults = await _api!.search(artistName);
-      final searchAlbums = searchResults['albums'] as List<MediaItem>? ?? [];
-      final providerAlbums = searchAlbums.whereType<Album>().where((album) {
-        final albumArtists = album.artists;
-        if (albumArtists == null || albumArtists.isEmpty) return false;
-        return albumArtists.any((a) => a.name.toLowerCase() == artistName.toLowerCase());
-      }).toList();
-
-      final allAlbums = <Album>[];
-      final seenNames = <String>{};
-
-      for (final album in [...artistAlbums, ...providerAlbums]) {
-        final key = album.name.toLowerCase();
-        if (!seenNames.contains(key)) {
-          seenNames.add(key);
-          allAlbums.add(album);
-        }
-      }
-
-      _cacheService.setCachedArtistAlbums(cacheKey, allAlbums);
-      return allAlbums;
-    } catch (e) {
-      _logger.log('❌ Failed to fetch artist albums: $e');
-      return _cacheService.getCachedArtistAlbums(cacheKey) ?? [];
-    }
-  }
-
-  /// Invalidate album tracks cache
-  void invalidateAlbumTracksCache(String albumId) {
-    _cacheService.invalidateAlbumTracksCache(albumId);
-  }
-
-  /// Invalidate playlist tracks cache
-  void invalidatePlaylistTracksCache(String playlistId) {
-    _cacheService.invalidatePlaylistTracksCache(playlistId);
-  }
-
-  // ============================================================================
-  // SEARCH
-  // ============================================================================
-
-  /// Search with caching
-  Future<Map<String, List<MediaItem>>> searchWithCache(String query, {bool forceRefresh = false}) async {
-    final cacheKey = query.toLowerCase().trim();
-    if (cacheKey.isEmpty) return {'artists': [], 'albums': [], 'tracks': []};
-
-    if (_cacheService.isSearchCacheValid(cacheKey, forceRefresh: forceRefresh)) {
-      _logger.log('📦 Using cached search results for "$query"');
-      return _cacheService.getCachedSearchResults(cacheKey)!;
-    }
-
-    if (_api == null) {
-      return _cacheService.getCachedSearchResults(cacheKey) ?? {'artists': [], 'albums': [], 'tracks': []};
-    }
-
-    try {
-      _logger.log('🔄 Searching for "$query"...');
-      final results = await _api!.search(query);
-
-      final cachedResults = <String, List<MediaItem>>{
-        'artists': results['artists'] ?? [],
-        'albums': results['albums'] ?? [],
-        'tracks': results['tracks'] ?? [],
-      };
-
-      _cacheService.setCachedSearchResults(cacheKey, cachedResults);
-      return cachedResults;
-    } catch (e) {
-      _logger.log('❌ Search failed: $e');
-      return _cacheService.getCachedSearchResults(cacheKey) ?? {'artists': [], 'albums': [], 'tracks': []};
-    }
-  }
-
-  Future<Map<String, List<MediaItem>>> search(String query, {bool libraryOnly = false}) async {
-    if (_api == null) return {'artists': [], 'albums': [], 'tracks': []};
-
-    try {
-      return await _api!.search(query, libraryOnly: libraryOnly);
-    } catch (e) {
-      ErrorHandler.logError('Search', e);
-      return {'artists': [], 'albums': [], 'tracks': []};
-    }
-  }
-
-  Future<List<Track>> getAlbumTracks(String provider, String itemId) async {
-    if (_api == null) return [];
-
-    try {
-      return await _api!.getAlbumTracks(provider, itemId);
-    } catch (e) {
-      ErrorHandler.logError('Get album tracks', e);
-      return [];
-    }
-  }
-
-  void clearState() {
-    _artists = [];
-    _albums = [];
-    _tracks = [];
-    _isLoading = false;
-    _error = null;
-    clearSearchState();
-    notifyListeners();
-  }
-}
@@ -0,0 +1,44 @@
+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 'es':
+        return 'Español';
+      case 'fr':
+        return 'Français';
+      case null:
+        return 'System';
+      default:
+        return languageCode;
+    }
+  }
+}
@@ -1,963 +0,0 @@
-import 'dart:async';
-import 'package:flutter/foundation.dart';
-import '../models/media_item.dart';
-import '../models/player.dart';
-import '../services/music_assistant_api.dart';
-import '../services/settings_service.dart';
-import '../services/debug_logger.dart';
-import '../services/error_handler.dart';
-import '../services/local_player_service.dart';
-import '../services/auth/auth_manager.dart';
-import '../services/device_id_service.dart';
-import '../services/cache_service.dart';
-import '../constants/timings.dart';
-import '../main.dart' show audioHandler;
-
-/// Provider for managing player state, selection, and controls
-class PlayerProvider with ChangeNotifier {
-  final DebugLogger _logger = DebugLogger();
-  late final LocalPlayerService _localPlayer;
-  final CacheService _cacheService;
-
-  // Dependencies injected from parent provider
-  MusicAssistantAPI? _api;
-  AuthManager? _authManager;
-  String? _serverUrl;
-
-  // Player selection
-  Player? _selectedPlayer;
-  List<Player> _availablePlayers = [];
-  Track? _currentTrack;
-  Timer? _playerStateTimer;
-  Timer? _adjacentPlayerCacheTimer;
-
-  // Local Playback
-  bool _isLocalPlayerPowered = true;
-  StreamSubscription? _localPlayerEventSubscription;
-  StreamSubscription? _playerUpdatedEventSubscription;
-  Timer? _localPlayerStateReportTimer;
-
-  // Pending metadata from player_updated events
-  TrackMetadata? _pendingTrackMetadata;
-  TrackMetadata? _currentNotificationMetadata;
-
-  // Registration guard
-  Completer<void>? _registrationInProgress;
-
-  // Getters
-  Player? get selectedPlayer => _selectedPlayer;
-  List<Player> get availablePlayers => _availablePlayers;
-  Track? get currentTrack => _currentTrack;
-  bool get isLocalPlayerPowered => _isLocalPlayerPowered;
-
-  /// Get cached track for a player (used for smooth swipe transitions)
-  Track? getCachedTrackForPlayer(String playerId) => _cacheService.getCachedTrackForPlayer(playerId);
-
-  PlayerProvider(this._cacheService, AuthManager authManager) {
-    _authManager = authManager;
-    _localPlayer = LocalPlayerService(authManager);
-  }
-
-  /// Initialize with API reference after connection
-  void initialize(MusicAssistantAPI api, String serverUrl) {
-    _api = api;
-    _serverUrl = serverUrl;
-  }
-
-  /// Set up event listeners after connection
-  Future<void> setupEventListeners() async {
-    if (_api == null) return;
-
-    // Listen to built-in player events
-    _localPlayerEventSubscription?.cancel();
-    _localPlayerEventSubscription = _api!.builtinPlayerEvents.listen(
-      _handleLocalPlayerEvent,
-      onError: (error) {
-        _logger.log('Builtin player event stream error: $error');
-      },
-    );
-
-    // Listen to player_updated events
-    _playerUpdatedEventSubscription?.cancel();
-    _playerUpdatedEventSubscription = _api!.playerUpdatedEvents.listen(
-      _handlePlayerUpdatedEvent,
-      onError: (error) {
-        _logger.log('Player updated event stream error: $error');
-      },
-    );
-  }
-
-  /// Initialize local playback
-  Future<void> initializeLocalPlayback() async {
-    await _localPlayer.initialize();
-    _isLocalPlayerPowered = true;
-
-    // Wire up skip button callbacks
-    audioHandler.onSkipToNext = () {
-      _logger.log('🎵 Notification: Skip to next pressed');
-      nextTrackSelectedPlayer();
-    };
-    audioHandler.onSkipToPrevious = () {
-      _logger.log('🎵 Notification: Skip to previous pressed');
-      previousTrackSelectedPlayer();
-    };
-
-    if (_api != null) {
-      await registerLocalPlayer();
-    }
-  }
-
-  /// Try to adopt an existing ghost player
-  Future<bool> tryAdoptGhostPlayer() async {
-    if (_api == null) return false;
-
-    try {
-      final isFresh = await DeviceIdService.isFreshInstallation();
-      if (!isFresh) {
-        _logger.log('👻 Not a fresh install, skipping ghost adoption');
-        return false;
-      }
-
-      final ownerName = await SettingsService.getOwnerName();
-      if (ownerName == null || ownerName.isEmpty) {
-        _logger.log('👻 No owner name set, cannot adopt ghost player');
-        return false;
-      }
-
-      _logger.log('👻 Fresh install detected, searching for adoptable ghost for "$ownerName"...');
-      final adoptableId = await _api!.findAdoptableGhostPlayer(ownerName);
-      if (adoptableId == null) {
-        _logger.log('👻 No matching ghost player found - will generate new ID');
-        return false;
-      }
-
-      _logger.log('👻 Found adoptable ghost: $adoptableId');
-      await DeviceIdService.adoptPlayerId(adoptableId);
-
-      _logger.log('✅ Successfully adopted ghost player');
-      return true;
-    } catch (e) {
-      _logger.log('⚠️ Ghost adoption failed (non-fatal): $e');
-      return false;
-    }
-  }
-
-  /// Register local player with MA server
-  Future<void> registerLocalPlayer() async {
-    if (_api == null) return;
-
-    if (_registrationInProgress != null) {
-      _logger.log('⏳ Registration already in progress, waiting...');
-      return _registrationInProgress!.future;
-    }
-
-    _registrationInProgress = Completer<void>();
-
-    try {
-      final playerId = await DeviceIdService.getOrCreateDevicePlayerId();
-      _logger.log('🆔 Using player ID: $playerId');
-
-      await SettingsService.setBuiltinPlayerId(playerId);
-      final name = await SettingsService.getLocalPlayerName();
-
-      final existingPlayers = await _api!.getPlayers();
-      final existingPlayer = existingPlayers.where((p) => p.playerId == playerId).firstOrNull;
-
-      if (existingPlayer != null && existingPlayer.available) {
-        _logger.log('✅ Player already registered and available: $playerId');
-        _startReportingLocalPlayerState();
-        if (_registrationInProgress != null && !_registrationInProgress!.isCompleted) {
-          _registrationInProgress!.complete();
-        }
-        _registrationInProgress = null;
-        return;
-      } else if (existingPlayer != null && !existingPlayer.available) {
-        _logger.log('⚠️ Player exists but unavailable (stale), re-registering: $playerId');
-      } else {
-        _logger.log('🆔 Player not found in MA, registering as new');
-      }
-
-      _logger.log('🎵 Registering player with MA: id=$playerId, name=$name');
-      await _api!.registerBuiltinPlayer(playerId, name);
-
-      _logger.log('✅ Player registration complete');
-      _startReportingLocalPlayerState();
-
-      if (_registrationInProgress != null && !_registrationInProgress!.isCompleted) {
-        _registrationInProgress!.complete();
-      }
-      _registrationInProgress = null;
-    } catch (e) {
-      _logger.log('❌ CRITICAL: Player registration failed: $e');
-      if (_registrationInProgress != null && !_registrationInProgress!.isCompleted) {
-        _registrationInProgress!.completeError(e);
-      }
-      _registrationInProgress = null;
-      rethrow;
-    }
-  }
-
-  void _startReportingLocalPlayerState() {
-    _localPlayerStateReportTimer?.cancel();
-    _localPlayerStateReportTimer = Timer.periodic(Timings.localPlayerReportInterval, (_) async {
-      try {
-        await _reportLocalPlayerState();
-      } catch (e) {
-        _logger.log('Error reporting local player state (will retry): $e');
-      }
-    });
-  }
-
-  Future<void> _reportLocalPlayerState() async {
-    if (_api == null) return;
-
-    // Don't try to report state if not authenticated - avoids spamming errors
-    if (_api!.currentConnectionState != MAConnectionState.authenticated) return;
-
-    final playerId = await SettingsService.getBuiltinPlayerId();
-    if (playerId == null) return;
-
-    final isPlaying = _localPlayer.isPlaying;
-    final position = _localPlayer.position.inSeconds;
-    final volume = (_localPlayer.volume * 100).round();
-    final isPaused = !isPlaying && position > 0;
-
-    await _api!.updateBuiltinPlayerState(
-      playerId,
-      powered: _isLocalPlayerPowered,
-      playing: isPlaying,
-      paused: isPaused,
-      position: position,
-      volume: volume,
-      muted: _localPlayer.volume == 0.0,
-    );
-  }
-
-  Future<void> _handleLocalPlayerEvent(Map<String, dynamic> event) async {
-    _logger.log('📥 Local player event received: ${event['type'] ?? event['command']}');
-
-    try {
-      final eventPlayerId = event['player_id'] as String?;
-      final myPlayerId = await SettingsService.getBuiltinPlayerId();
-
-      if (eventPlayerId != null && myPlayerId != null && eventPlayerId != myPlayerId) {
-        _logger.log('🚫 Ignoring event for different player: $eventPlayerId');
-        return;
-      }
-
-      final command = (event['type'] as String?) ?? (event['command'] as String?);
-
-      switch (command) {
-        case 'play_media':
-          final urlPath = event['media_url'] as String? ?? event['url'] as String?;
-
-          if (urlPath != null && _serverUrl != null) {
-            String fullUrl;
-            if (urlPath.startsWith('http')) {
-              fullUrl = urlPath;
-            } else {
-              var baseUrl = _serverUrl!;
-              if (!baseUrl.startsWith('http://') && !baseUrl.startsWith('https://')) {
-                baseUrl = 'https://$baseUrl';
-              }
-              baseUrl = baseUrl.endsWith('/') ? baseUrl.substring(0, baseUrl.length - 1) : baseUrl;
-              final path = urlPath.startsWith('/') ? urlPath : '/$urlPath';
-              fullUrl = '$baseUrl$path';
-            }
-
-            TrackMetadata metadata;
-            if (_pendingTrackMetadata != null) {
-              metadata = _pendingTrackMetadata!;
-            } else {
-              final trackName = event['track_name'] as String? ?? event['name'] as String? ?? 'Unknown Track';
-              final artistName = event['artist_name'] as String? ?? event['artist'] as String? ?? 'Unknown Artist';
-              final albumName = event['album_name'] as String? ?? event['album'] as String?;
-              var artworkUrl = event['image_url'] as String? ?? event['artwork_url'] as String?;
-              final durationSecs = event['duration'] as int?;
-
-              if (artworkUrl != null && artworkUrl.startsWith('http://')) {
-                artworkUrl = artworkUrl.replaceFirst('http://', 'https://');
-              }
-
-              metadata = TrackMetadata(
-                title: trackName,
-                artist: artistName,
-                album: albumName,
-                artworkUrl: artworkUrl,
-                duration: durationSecs != null ? Duration(seconds: durationSecs) : null,
-              );
-            }
-
-            _localPlayer.setCurrentTrackMetadata(metadata);
-            _currentNotificationMetadata = metadata;
-            await _localPlayer.playUrl(fullUrl);
-          }
-          break;
-
-        case 'stop':
-          await _localPlayer.stop();
-          break;
-
-        case 'pause':
-          await _localPlayer.pause();
-          break;
-
-        case 'play':
-          await _localPlayer.play();
-          break;
-
-        case 'seek':
-          final position = event['position'] as int?;
-          if (position != null) {
-            await _localPlayer.seek(Duration(seconds: position));
-          }
-          break;
-
-        case 'volume_set':
-          final volume = event['volume_level'] as int?;
-          if (volume != null) {
-            await _localPlayer.setVolume(volume / 100.0);
-          }
-          break;
-
-        case 'power_on':
-        case 'power_off':
-        case 'power':
-          bool? newPowerState;
-          if (command == 'power_on') {
-            newPowerState = true;
-          } else if (command == 'power_off') {
-            newPowerState = false;
-          } else {
-            newPowerState = event['powered'] as bool?;
-          }
-
-          if (newPowerState != null) {
-            _isLocalPlayerPowered = newPowerState;
-            if (!_isLocalPlayerPowered) {
-              await _localPlayer.stop();
-            }
-          }
-          break;
-      }
-
-      await _reportLocalPlayerState();
-    } catch (e) {
-      _logger.log('Error handling local player event: $e');
-    }
-  }
-
-  Future<void> _handlePlayerUpdatedEvent(Map<String, dynamic> event) async {
-    try {
-      final playerId = event['player_id'] as String?;
-      if (playerId == null) return;
-
-      if (_selectedPlayer != null && playerId == _selectedPlayer!.playerId) {
-        _updatePlayerState();
-      }
-
-      final currentMedia = event['current_media'] as Map<String, dynamic>?;
-      final playerName = event['name'] as String? ?? playerId;
-
-      if (currentMedia != null) {
-        final mediaType = currentMedia['media_type'] as String?;
-        if (mediaType != 'flow_stream') {
-          final durationSecs = (currentMedia['duration'] as num?)?.toInt();
-          final albumName = currentMedia['album'] as String?;
-          final imageUrl = currentMedia['image_url'] as String?;
-
-          Map<String, dynamic>? metadata;
-          if (imageUrl != null && _serverUrl != null) {
-            var finalImageUrl = imageUrl;
-            try {
-              final imgUri = Uri.parse(imageUrl);
-              final queryString = imgUri.query;
-              var baseUrl = _serverUrl!;
-              if (!baseUrl.startsWith('http://') && !baseUrl.startsWith('https://')) {
-                baseUrl = 'https://$baseUrl';
-              }
-              if (baseUrl.endsWith('/')) {
-                baseUrl = baseUrl.substring(0, baseUrl.length - 1);
-              }
-              finalImageUrl = '$baseUrl/imageproxy?$queryString';
-            } catch (e) {
-              // Use original URL
-            }
-            metadata = {
-              'images': [{'path': finalImageUrl, 'provider': 'direct'}]
-            };
-          }
-
-          final trackFromEvent = Track(
-            itemId: currentMedia['queue_item_id'] as String? ?? '',
-            provider: 'library',
-            name: currentMedia['title'] as String? ?? 'Unknown Track',
-            uri: currentMedia['uri'] as String?,
-            duration: durationSecs != null ? Duration(seconds: durationSecs) : null,
-            artists: [Artist(itemId: '', provider: 'library', name: currentMedia['artist'] as String? ?? 'Unknown Artist')],
-            album: albumName != null ? Album(itemId: '', provider: 'library', name: albumName) : null,
-            metadata: metadata,
-          );
-
-          _cacheService.setCachedTrackForPlayer(playerId, trackFromEvent);
-
-          if (_selectedPlayer != null && playerId == _selectedPlayer!.playerId) {
-            _currentTrack = trackFromEvent;
-          }
-
-          _logger.log('📋 Cached track for $playerName: ${trackFromEvent.name}');
-
-          if (imageUrl != null) {
-            final images = metadata?['images'] as List?;
-            if (images != null && images.isNotEmpty) {
-              final imagePath = images[0]['path'] as String?;
-              if (imagePath != null) {
-                _precacheImage(imagePath);
-              }
-            }
-          }
-
-          notifyListeners();
-        }
-      }
-
-      // Handle notification metadata for local player
-      final builtinPlayerId = await SettingsService.getBuiltinPlayerId();
-      if (builtinPlayerId == null || playerId != builtinPlayerId) return;
-
-      if (currentMedia == null) return;
-
-      final title = currentMedia['title'] as String? ?? 'Unknown Track';
-      final artist = currentMedia['artist'] as String? ?? 'Unknown Artist';
-      final album = currentMedia['album'] as String?;
-      var imageUrl = currentMedia['image_url'] as String?;
-      final durationSecs = (currentMedia['duration'] as num?)?.toInt();
-
-      if (imageUrl != null && _serverUrl != null) {
-        try {
-          final imgUri = Uri.parse(imageUrl);
-          final queryString = imgUri.query;
-          var baseUrl = _serverUrl!;
-          if (!baseUrl.startsWith('http://') && !baseUrl.startsWith('https://')) {
-            baseUrl = 'https://$baseUrl';
-          }
-          if (baseUrl.endsWith('/')) {
-            baseUrl = baseUrl.substring(0, baseUrl.length - 1);
-          }
-          imageUrl = '$baseUrl/imageproxy?$queryString';
-        } catch (e) {
-          if (imageUrl != null && imageUrl.startsWith('http://')) {
-            imageUrl = imageUrl.replaceFirst('http://', 'https://');
-          }
-        }
-      }
-
-      final newMetadata = TrackMetadata(
-        title: title,
-        artist: artist,
-        album: album,
-        artworkUrl: imageUrl,
-        duration: durationSecs != null ? Duration(seconds: durationSecs) : null,
-      );
-
-      final mediaType = currentMedia['media_type'] as String?;
-      if (mediaType == 'flow_stream') return;
-
-      _pendingTrackMetadata = newMetadata;
-
-      final notificationNeedsUpdate = _currentNotificationMetadata != null &&
-          (_currentNotificationMetadata!.title != title ||
-           _currentNotificationMetadata!.artist != artist);
-
-      if (_localPlayer.isPlaying && notificationNeedsUpdate) {
-        await _localPlayer.updateNotificationWhilePlaying(newMetadata);
-        _currentNotificationMetadata = newMetadata;
-      }
-    } catch (e) {
-      _logger.log('Error handling player_updated event: $e');
-    }
-  }
-
-  // ============================================================================
-  // PLAYER SELECTION
-  // ============================================================================
-
-  Future<void> loadAndSelectPlayers({bool forceRefresh = false}) async {
-    if (_api == null) return;
-
-    try {
-      if (!forceRefresh && _cacheService.isPlayersCacheValid() && _availablePlayers.isNotEmpty) {
-        return;
-      }
-
-      final allPlayers = await _api!.getPlayers();
-      final builtinPlayerId = await SettingsService.getBuiltinPlayerId();
-
-      _logger.log('🎛️ getPlayers returned ${allPlayers.length} players');
-
-      int filteredCount = 0;
-
-      _availablePlayers = allPlayers.where((player) {
-        final nameLower = player.name.toLowerCase();
-
-        if (nameLower.contains('music assistant mobile')) {
-          filteredCount++;
-          return false;
-        }
-
-        // Filter out MA Web UI's built-in player (provider is 'builtin_player' and starts with 'ma_')
-        // Note: We check BOTH conditions to avoid filtering snapcast/other players that may have 'ma_' prefix
-        if (player.provider == 'builtin_player' && player.playerId.startsWith('ma_')) {
-          filteredCount++;
-          return false;
-        }
-
-        // Also filter "This Device" named players without proper provider
-        if (nameLower == 'this device') {
-          filteredCount++;
-          return false;
-        }
-
-        if (player.playerId.startsWith('ensemble_')) {
-          if (builtinPlayerId == null || player.playerId != builtinPlayerId) {
-            filteredCount++;
-            return false;
-          }
-        }
-
-        if (!player.available) {
-          if (builtinPlayerId != null && player.playerId == builtinPlayerId) {
-            return true;
-          }
-          filteredCount++;
-          return false;
-        }
-
-        return true;
-      }).toList();
-
-      _availablePlayers.sort((a, b) => a.name.toLowerCase().compareTo(b.name.toLowerCase()));
-      _cacheService.updatePlayersLastFetched();
-
-      _logger.log('🎛️ After filtering: ${_availablePlayers.length} players available');
-
-      if (_availablePlayers.isNotEmpty) {
-        Player? playerToSelect;
-
-        if (_selectedPlayer != null) {
-          final stillAvailable = _availablePlayers.any(
-            (p) => p.playerId == _selectedPlayer!.playerId && p.available,
-          );
-          if (stillAvailable) {
-            playerToSelect = _availablePlayers.firstWhere(
-              (p) => p.playerId == _selectedPlayer!.playerId,
-            );
-          }
-        }
-
-        if (playerToSelect == null) {
-          final lastSelectedPlayerId = await SettingsService.getLastSelectedPlayerId();
-
-          if (lastSelectedPlayerId != null) {
-            try {
-              playerToSelect = _availablePlayers.firstWhere(
-                (p) => p.playerId == lastSelectedPlayerId && p.available,
-              );
-            } catch (e) {}
-          }
-
-          if (playerToSelect == null && builtinPlayerId != null) {
-            try {
-              playerToSelect = _availablePlayers.firstWhere(
-                (p) => p.playerId == builtinPlayerId && p.available,
-              );
-            } catch (e) {}
-          }
-
-          if (playerToSelect == null) {
-            try {
-              playerToSelect = _availablePlayers.firstWhere(
-                (p) => p.state == 'playing' && p.available,
-              );
-            } catch (e) {}
-          }
-
-          if (playerToSelect == null) {
-            playerToSelect = _availablePlayers.firstWhere(
-              (p) => p.available,
-              orElse: () => _availablePlayers.first,
-            );
-          }
-        }
-
-        selectPlayer(playerToSelect);
-      }
-
-      _preloadAdjacentPlayers(preloadAll: true);
-    } catch (e) {
-      ErrorHandler.logError('Load and select players', e);
-    }
-  }
-
-  void selectPlayer(Player player, {bool skipNotify = false}) {
-    _selectedPlayer = player;
-    SettingsService.setLastSelectedPlayerId(player.playerId);
-    _startPlayerStatePolling();
-    _preloadAdjacentPlayers();
-
-    if (!skipNotify) {
-      notifyListeners();
-    }
-  }
-
-  Future<void> _preloadAdjacentPlayers({bool preloadAll = false}) async {
-    if (_api == null) return;
-
-    final players = _availablePlayers.where((p) => p.available).toList();
-    if (players.isEmpty) return;
-
-    if (preloadAll) {
-      _logger.log('🖼️ Preloading track info for all ${players.length} players...');
-      await Future.wait(players.map((player) => _preloadPlayerTrack(player)));
-      _logger.log('🖼️ Preloading complete');
-      return;
-    }
-
-    if (_selectedPlayer == null || players.length <= 1) return;
-
-    final currentIndex = players.indexWhere((p) => p.playerId == _selectedPlayer!.playerId);
-    if (currentIndex == -1) return;
-
-    final prevIndex = currentIndex <= 0 ? players.length - 1 : currentIndex - 1;
-    final nextIndex = currentIndex >= players.length - 1 ? 0 : currentIndex + 1;
-
-    final playersToPreload = <Player>{};
-    if (prevIndex != currentIndex) playersToPreload.add(players[prevIndex]);
-    if (nextIndex != currentIndex) playersToPreload.add(players[nextIndex]);
-
-    for (final player in playersToPreload) {
-      _preloadPlayerTrack(player);
-    }
-  }
-
-  Future<void> _preloadPlayerTrack(Player player) async {
-    if (_api == null) return;
-
-    try {
-      if (!player.available || !player.powered) {
-        _cacheService.setCachedTrackForPlayer(player.playerId, null);
-        return;
-      }
-
-      final queue = await _api!.getQueue(player.playerId);
-
-      if (queue != null && queue.currentItem != null) {
-        final track = queue.currentItem!.track;
-        final existingTrack = _cacheService.getCachedTrackForPlayer(player.playerId);
-        final existingHasImage = existingTrack?.metadata?['images'] != null;
-        final newHasImage = track.metadata?['images'] != null;
-
-        if (!existingHasImage || newHasImage) {
-          _cacheService.setCachedTrackForPlayer(player.playerId, track);
-        }
-
-        final artworkUrl512 = _api!.getImageUrl(existingHasImage ? existingTrack! : track, size: 512);
-        if (artworkUrl512 != null) {
-          await _precacheImage(artworkUrl512);
-        }
-      } else {
-        final existingTrack = _cacheService.getCachedTrackForPlayer(player.playerId);
-        if (existingTrack?.metadata?['images'] == null) {
-          _cacheService.setCachedTrackForPlayer(player.playerId, null);
-        }
-      }
-    } catch (e) {
-      _logger.log('Error preloading player track for ${player.name}: $e');
-    }
-  }
-
-  Future<void> _precacheImage(String url) async {
-    try {
-      final imageProvider = NetworkImage(url);
-      final imageStream = imageProvider.resolve(const ImageConfiguration());
-      final completer = Completer<void>();
-      late ImageStreamListener listener;
-
-      listener = ImageStreamListener(
-        (ImageInfo info, bool synchronousCall) {
-          if (!completer.isCompleted) completer.complete();
-          imageStream.removeListener(listener);
-        },
-        onError: (exception, stackTrace) {
-          if (!completer.isCompleted) completer.completeError(exception);
-          imageStream.removeListener(listener);
-        },
-      );
-
-      imageStream.addListener(listener);
-      await completer.future.timeout(const Duration(seconds: 10), onTimeout: () {
-        imageStream.removeListener(listener);
-      });
-    } catch (e) {
-      _logger.log('Image precache failed for $url: $e');
-    }
-  }
-
-  Future<void> preloadAllPlayerTracks() async {
-    if (_api == null) return;
-    final players = _availablePlayers.where((p) => p.available).toList();
-    await Future.wait(players.map((player) => _preloadPlayerTrack(player)));
-  }
-
-  void _startPlayerStatePolling() {
-    _playerStateTimer?.cancel();
-    if (_selectedPlayer == null) return;
-
-    _playerStateTimer = Timer.periodic(Timings.playerPollingInterval, (_) async {
-      try {
-        await _updatePlayerState();
-      } catch (e) {
-        _logger.log('Error updating player state (will retry): $e');
-      }
-    });
-
-    _updatePlayerState();
-  }
-
-  Future<void> _updatePlayerState() async {
-    if (_selectedPlayer == null || _api == null) return;
-
-    try {
-      bool stateChanged = false;
-
-      final allPlayers = await _api!.getPlayers();
-      final updatedPlayer = allPlayers.firstWhere(
-        (p) => p.playerId == _selectedPlayer!.playerId,
-        orElse: () => _selectedPlayer!,
-      );
-
-      _selectedPlayer = updatedPlayer;
-      stateChanged = true;
-
-      final isPlayingOrPaused = _selectedPlayer!.state == 'playing' || _selectedPlayer!.state == 'paused';
-      final isIdleWithContent = _selectedPlayer!.state == 'idle' && _selectedPlayer!.powered;
-      final shouldShowTrack = _selectedPlayer!.available && (isPlayingOrPaused || isIdleWithContent);
-
-      if (!shouldShowTrack) {
-        if (_currentTrack != null) {
-          _currentTrack = null;
-          stateChanged = true;
-        }
-        if (stateChanged) notifyListeners();
-        return;
-      }
-
-      final queue = await _api!.getQueue(_selectedPlayer!.playerId);
-
-      if (queue != null && queue.currentItem != null) {
-        if (_currentTrack == null ||
-            _currentTrack!.uri != queue.currentItem!.track.uri ||
-            _currentTrack!.name != queue.currentItem!.track.name) {
-          _currentTrack = queue.currentItem!.track;
-          stateChanged = true;
-
-          final builtinPlayerId = await SettingsService.getBuiltinPlayerId();
-          if (builtinPlayerId != null && _selectedPlayer!.playerId == builtinPlayerId) {
-            final track = _currentTrack!;
-            final artworkUrl = _api?.getImageUrl(track, size: 512);
-            _localPlayer.updateNotification(
-              id: track.uri ?? track.itemId,
-              title: track.name,
-              artist: track.artistsString,
-              album: track.album?.name,
-              artworkUrl: artworkUrl,
-              duration: track.duration,
-            );
-          }
-        }
-      } else {
-        if (_currentTrack != null) {
-          _currentTrack = null;
-          stateChanged = true;
-        }
-      }
-
-      if (stateChanged) notifyListeners();
-    } catch (e) {
-      _logger.log('❌ Error updating player state: $e');
-    }
-  }
-
-  // ============================================================================
-  // PLAYER CONTROLS
-  // ============================================================================
-
-  Future<void> playPauseSelectedPlayer() async {
-    if (_selectedPlayer == null || _api == null) return;
-
-    if (_selectedPlayer!.isPlaying) {
-      await _api!.pausePlayer(_selectedPlayer!.playerId);
-    } else {
-      await _api!.resumePlayer(_selectedPlayer!.playerId);
-    }
-
-    await refreshPlayers();
-  }
-
-  Future<void> nextTrackSelectedPlayer() async {
-    if (_selectedPlayer == null || _api == null) return;
-    await _api!.nextTrack(_selectedPlayer!.playerId);
-    await Future.delayed(Timings.trackChangeDelay);
-    await _updatePlayerState();
-  }
-
-  Future<void> previousTrackSelectedPlayer() async {
-    if (_selectedPlayer == null || _api == null) return;
-    await _api!.previousTrack(_selectedPlayer!.playerId);
-    await Future.delayed(Timings.trackChangeDelay);
-    await _updatePlayerState();
-  }
-
-  Future<void> refreshPlayers() async {
-    final previousState = _selectedPlayer?.state;
-    final previousVolume = _selectedPlayer?.volumeLevel;
-
-    await loadAndSelectPlayers(forceRefresh: true);
-
-    bool stateChanged = false;
-    if (_selectedPlayer != null && _availablePlayers.isNotEmpty) {
-      try {
-        final updatedPlayer = _availablePlayers.firstWhere(
-          (p) => p.playerId == _selectedPlayer!.playerId,
-        );
-
-        if (updatedPlayer.state != previousState || updatedPlayer.volumeLevel != previousVolume) {
-          stateChanged = true;
-        }
-
-        _selectedPlayer = updatedPlayer;
-      } catch (e) {
-        stateChanged = true;
-      }
-    }
-
-    if (stateChanged) notifyListeners();
-  }
-
-  Future<void> togglePower(String playerId) async {
-    if (_api == null) return;
-
-    try {
-      final localPlayerId = await SettingsService.getBuiltinPlayerId();
-      final isLocalPlayer = localPlayerId != null && playerId == localPlayerId;
-
-      if (isLocalPlayer) {
-        _isLocalPlayerPowered = !_isLocalPlayerPowered;
-        if (!_isLocalPlayerPowered) {
-          await _localPlayer.stop();
-        }
-        await _reportLocalPlayerState();
-        await refreshPlayers();
-      } else {
-        final player = _availablePlayers.firstWhere(
-          (p) => p.playerId == playerId,
-          orElse: () => _selectedPlayer != null && _selectedPlayer!.playerId == playerId
-              ? _selectedPlayer!
-              : throw Exception("Player not found"),
-        );
-
-        await _api!.setPower(playerId, !player.powered);
-        await refreshPlayers();
-      }
-    } catch (e) {
-      ErrorHandler.logError('Toggle power', e);
-    }
-  }
-
-  Future<void> setVolume(String playerId, int volumeLevel) async {
-    if (_api == null) return;
-    try {
-      await _api!.setVolume(playerId, volumeLevel);
-    } catch (e) {
-      ErrorHandler.logError('Set volume', e);
-      rethrow;
-    }
-  }
-
-  Future<void> setMute(String playerId, bool muted) async {
-    if (_api == null) return;
-    try {
-      await _api!.setMute(playerId, muted);
-      await refreshPlayers();
-    } catch (e) {
-      ErrorHandler.logError('Set mute', e);
-      rethrow;
-    }
-  }
-
-  Future<void> seek(String playerId, int position) async {
-    if (_api == null) return;
-    try {
-      await _api!.seek(playerId, position);
-    } catch (e) {
-      ErrorHandler.logError('Seek', e);
-      rethrow;
-    }
-  }
-
-  Future<void> toggleShuffle(String queueId) async {
-    if (_api == null) return;
-    try {
-      await _api!.toggleShuffle(queueId);
-    } catch (e) {
-      ErrorHandler.logError('Toggle shuffle', e);
-      rethrow;
-    }
-  }
-
-  Future<void> setRepeatMode(String queueId, String mode) async {
-    if (_api == null) return;
-    try {
-      await _api!.setRepeatMode(queueId, mode);
-    } catch (e) {
-      ErrorHandler.logError('Set repeat mode', e);
-      rethrow;
-    }
-  }
-
-  Future<void> cycleRepeatMode(String queueId, String? currentMode) async {
-    String nextMode;
-    switch (currentMode) {
-      case 'off':
-      case null:
-        nextMode = 'all';
-        break;
-      case 'all':
-        nextMode = 'one';
-        break;
-      case 'one':
-        nextMode = 'off';
-        break;
-      default:
-        nextMode = 'off';
-    }
-    await setRepeatMode(queueId, nextMode);
-  }
-
-  void clearState() {
-    _playerStateTimer?.cancel();
-    _playerStateTimer = null;
-    _localPlayerStateReportTimer?.cancel();
-    _localPlayerEventSubscription?.cancel();
-    _playerUpdatedEventSubscription?.cancel();
-    _availablePlayers = [];
-    _selectedPlayer = null;
-    _currentTrack = null;
-  }
-
-  @override
-  void dispose() {
-    clearState();
-    super.dispose();
-  }
-}
@@ -10,16 +10,22 @@ 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 '../theme/design_tokens.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
@@ -31,43 +37,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;
    }

@@ -75,17 +89,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;

@@ -107,10 +124,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
@@ -126,22 +143,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,
@@ -156,33 +175,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),
          ),
        );
@@ -195,11 +320,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;
@@ -216,7 +341,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
@@ -231,44 +361,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),
          ),
        );
@@ -278,16 +418,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);
    }
  }

@@ -300,7 +470,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;
      }

@@ -326,7 +496,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;
      }

@@ -360,16 +530,16 @@ class _AlbumDetailsScreenState extends State<AlbumDetailsScreen> with SingleTick
        child: Column(
          mainAxisSize: MainAxisSize.min,
          children: [
-            const SizedBox(height: 16),
+            Spacing.vGap16,
            Text(
-              'Add album to queue on...',
+              S.of(context)!.addAlbumToQueueOn,
              style: Theme.of(context).textTheme.titleLarge,
            ),
-            const SizedBox(height: 16),
+            Spacing.vGap16,
            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(
@@ -397,9 +567,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),
                              ),
                            );
                          }
@@ -440,16 +610,16 @@ class _AlbumDetailsScreenState extends State<AlbumDetailsScreen> with SingleTick
        child: Column(
          mainAxisSize: MainAxisSize.min,
          children: [
-            const SizedBox(height: 16),
+            Spacing.vGap16,
            Text(
-              'Add to queue on...',
+              S.of(context)!.addToQueueOn,
              style: Theme.of(context).textTheme.titleLarge,
            ),
-            const SizedBox(height: 16),
+            Spacing.vGap16,
            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(
@@ -476,9 +646,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),
                              ),
                            );
                          }
@@ -491,7 +661,7 @@ class _AlbumDetailsScreenState extends State<AlbumDetailsScreen> with SingleTick
                  },
                ),
              ),
-            const SizedBox(height: 16),
+            SizedBox(height: MediaQuery.of(context).padding.bottom + 16),
          ],
        ),
      ),
@@ -594,9 +764,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,
    );
@@ -633,10 +806,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(
@@ -654,35 +833,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,
                      ),
                    ),
                  ),
@@ -692,7 +886,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: [
@@ -709,7 +903,7 @@ class _AlbumDetailsScreenState extends State<AlbumDetailsScreen> with SingleTick
                      ),
                    ),
                  ),
-                  const SizedBox(height: 8),
+                  Spacing.vGap8,
                  Hero(
                    tag: HeroTags.artistName + (widget.album.uri ?? widget.album.itemId) + _heroTagSuffix,
                    child: Material(
@@ -729,7 +923,7 @@ class _AlbumDetailsScreenState extends State<AlbumDetailsScreen> with SingleTick
                      ),
                    ),
                  ),
-                  const SizedBox(height: 16),
+                  Spacing.vGap16,
                  // Album Description
                  if (_albumDescription != null && _albumDescription!.isNotEmpty) ...[
                    InkWell(
@@ -751,7 +945,7 @@ class _AlbumDetailsScreenState extends State<AlbumDetailsScreen> with SingleTick
                        ),
                      ),
                    ),
-                    const SizedBox(height: 8),
+                    Spacing.vGap8,
                  ],
                  Row(
                    children: [
@@ -763,7 +957,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,
@@ -822,7 +1016,7 @@ class _AlbumDetailsScreenState extends State<AlbumDetailsScreen> with SingleTick
                          style: FilledButton.styleFrom(
                            padding: EdgeInsets.zero,
                            shape: RoundedRectangleBorder(
-                              borderRadius: BorderRadius.circular(25), // Circular
+                              borderRadius: BorderRadius.circular(Radii.xxl), // Circular
                            ),
                          ),
                          child: Icon(
@@ -833,17 +1027,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),
                ],
              ),
            ),
@@ -858,7 +1067,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,
@@ -985,7 +1194,7 @@ class _AlbumDetailsScreenState extends State<AlbumDetailsScreen> with SingleTick
                                        style: FilledButton.styleFrom(
                                          padding: EdgeInsets.zero,
                                          shape: RoundedRectangleBorder(
-                                            borderRadius: BorderRadius.circular(22),
+                                            borderRadius: BorderRadius.circular(Radii.xxl),
                                          ),
                                        ),
                                        child: Icon(
@@ -1008,120 +1217,73 @@ class _AlbumDetailsScreenState extends State<AlbumDetailsScreen> with SingleTick
                childCount: _tracks.length,
              ),
            ),
-          const SliverToBoxAdapter(child: SizedBox(height: 164)), // Space for bottom nav + mini player
+          SliverToBoxAdapter(child: SizedBox(height: BottomSpacing.withMiniPlayer)), // Space for bottom nav + mini player
        ],
-      ),
+      );
+          },
+        ),
      ),
    );
  }

  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();
    });
  }
@@ -12,6 +12,8 @@ import '../services/metadata_service.dart';
 import '../services/settings_service.dart';
 import '../services/debug_logger.dart';
 import '../utils/page_transitions.dart';
+import '../l10n/app_localizations.dart';
+import '../theme/design_tokens.dart';

 class ArtistDetailsScreen extends StatefulWidget {
  final Artist artist;
@@ -35,11 +37,13 @@ class _ArtistDetailsScreenState extends State<ArtistDetailsScreen> {
  List<Album> _providerAlbums = [];
  bool _isLoading = true;
  bool _isFavorite = false;
+  bool _isInLibrary = false;
  ColorScheme? _lightColorScheme;
  ColorScheme? _darkColorScheme;
  bool _isDescriptionExpanded = false;
  String? _artistDescription;
  String? _artistImageUrl;
+  MusicAssistantProvider? _maProvider;

  // View preferences
  String _sortOrder = 'alpha'; // 'alpha' or 'year'
@@ -51,6 +55,7 @@ class _ArtistDetailsScreenState extends State<ArtistDetailsScreen> {
  void initState() {
    super.initState();
    _isFavorite = widget.artist.favorite ?? false;
+    _isInLibrary = _checkIfInLibrary(widget.artist);
    // Use initial image URL immediately for smooth hero animation
    _artistImageUrl = widget.initialImageUrl;
    _loadViewPreferences();
@@ -65,11 +70,60 @@ class _ArtistDetailsScreenState extends State<ArtistDetailsScreen> {
        if (mounted) {
          _loadArtistImage();
          // Note: _extractColors is called by _loadArtistImage after image loads
+
+          // CRITICAL FIX: Delay adding provider listener until AFTER Hero animation
+          // Adding it immediately causes rebuilds during animation (jank)
+          _maProvider = context.read<MusicAssistantProvider>();
+          _maProvider?.addListener(_onProviderChanged);
        }
      });
    });
  }

+  void _onProviderChanged() {
+    if (!mounted) return;
+    // Re-check library status when provider data changes
+    final newIsInLibrary = _checkIfInLibraryFromProvider();
+    if (newIsInLibrary != _isInLibrary) {
+      setState(() {
+        _isInLibrary = newIsInLibrary;
+      });
+    }
+  }
+
+  /// Check if artist is in library using provider's artists list
+  bool _checkIfInLibraryFromProvider() {
+    if (_maProvider == null) return _checkIfInLibrary(widget.artist);
+
+    final artistName = widget.artist.name.toLowerCase();
+    final artistUri = widget.artist.uri;
+
+    // Check if this artist exists in the provider's library
+    return _maProvider!.artists.any((a) {
+      // Match by URI if available
+      if (artistUri != null && a.uri == artistUri) return true;
+      // Match by name as fallback
+      if (a.name.toLowerCase() == artistName) return true;
+      // Check provider mappings for matching URIs
+      if (widget.artist.providerMappings != null) {
+        for (final mapping in widget.artist.providerMappings!) {
+          if (a.providerMappings?.any((m) =>
+            m.providerInstance == mapping.providerInstance &&
+            m.itemId == mapping.itemId) == true) {
+            return true;
+          }
+        }
+      }
+      return false;
+    });
+  }
+
+  @override
+  void dispose() {
+    _maProvider?.removeListener(_onProviderChanged);
+    super.dispose();
+  }
+
  Future<void> _loadViewPreferences() async {
    final sortOrder = await SettingsService.getArtistAlbumsSortOrder();
    final viewMode = await SettingsService.getArtistAlbumsViewMode();
@@ -154,10 +208,10 @@ class _ArtistDetailsScreenState extends State<ArtistDetailsScreen> {

  Future<void> _toggleFavorite() async {
    final maProvider = context.read<MusicAssistantProvider>();
-    if (maProvider.api == null) return;

    try {
      final newState = !_isFavorite;
+      bool success;

      if (newState) {
        String actualProvider = widget.artist.provider;
@@ -171,12 +225,17 @@ class _ArtistDetailsScreenState extends State<ArtistDetailsScreen> {
              orElse: () => widget.artist.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 artist to favorites: provider=$actualProvider, itemId=$actualItemId');
-        await maProvider.api!.addToFavorites('artist', actualItemId, actualProvider);
+        success = await maProvider.addToFavorites(
+          mediaType: 'artist',
+          itemId: actualItemId,
+          provider: actualProvider,
+        );
      } else {
        int? libraryItemId;

@@ -197,32 +256,39 @@ class _ArtistDetailsScreenState extends State<ArtistDetailsScreen> {
          throw Exception('Could not determine library ID for this artist');
        }

-        _logger.log('Removing artist from favorites: libraryItemId=$libraryItemId');
-        await maProvider.api!.removeFromFavorites('artist', libraryItemId);
+        success = await maProvider.removeFromFavorites(
+          mediaType: 'artist',
+          libraryItemId: libraryItemId,
+        );
      }

-      setState(() {
-        _isFavorite = newState;
-      });
+      if (success) {
+        setState(() {
+          _isFavorite = newState;
+        });

-      maProvider.invalidateHomeCache();
+        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 artist 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),
          ),
        );
@@ -230,66 +296,138 @@ class _ArtistDetailsScreenState extends State<ArtistDetailsScreen> {
    }
  }

-  Future<void> _startArtistRadio() async {
-    final maProvider = context.read<MusicAssistantProvider>();
-    final selectedPlayer = maProvider.selectedPlayer;
+  /// Check if artist is in library
+  bool _checkIfInLibrary(Artist artist) {
+    if (artist.provider == 'library') return true;
+    return artist.providerMappings?.any((m) => m.providerInstance == 'library') ?? false;
+  }

-    if (selectedPlayer == null) {
-      ScaffoldMessenger.of(context).showSnackBar(
-        const SnackBar(content: Text('No player selected')),
-      );
-      return;
-    }
+  /// Toggle library status
+  Future<void> _toggleLibrary() async {
+    final maProvider = context.read<MusicAssistantProvider>();

    try {
-      await maProvider.playArtistRadio(selectedPlayer.playerId, widget.artist);
-      if (mounted) {
-        ScaffoldMessenger.of(context).showSnackBar(
-          SnackBar(
-            content: Text('Starting ${widget.artist.name} radio'),
-            duration: const Duration(seconds: 1),
-          ),
+      final newState = !_isInLibrary;
+      bool success;
+
+      if (newState) {
+        // Add to library - MUST use non-library provider
+        String? actualProvider;
+        String? actualItemId;
+
+        if (widget.artist.providerMappings != null && widget.artist.providerMappings!.isNotEmpty) {
+          // For adding to library, we MUST use a non-library provider
+          final nonLibraryMapping = widget.artist.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.artist.provider != 'library') {
+            actualProvider = widget.artist.provider;
+            actualItemId = widget.artist.itemId;
+          } else {
+            // Item is library-only, can't add
+            _logger.log('Cannot add to library: artist is library-only');
+            return;
+          }
+        }
+
+        _logger.log('Adding artist to library: provider=$actualProvider, itemId=$actualItemId');
+        success = await maProvider.addToLibrary(
+          mediaType: 'artist',
+          provider: actualProvider,
+          itemId: actualItemId,
+        );
+      } else {
+        // Remove from library
+        int? libraryItemId;
+        if (widget.artist.provider == 'library') {
+          libraryItemId = int.tryParse(widget.artist.itemId);
+        } else if (widget.artist.providerMappings != null) {
+          final libraryMapping = widget.artist.providerMappings!.firstWhere(
+            (m) => m.providerInstance == 'library',
+            orElse: () => widget.artist.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: 'artist',
+          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 starting artist radio: $e');
+      _logger.log('Error toggling artist library: $e');
      if (mounted) {
        ScaffoldMessenger.of(context).showSnackBar(
          SnackBar(
-            content: Text('Failed to start radio: $e'),
-            backgroundColor: Colors.red,
+            content: Text('Failed to update library: $e'),
+            duration: const Duration(seconds: 2),
          ),
        );
      }
    }
  }

-  void _showPlayOnMenu(BuildContext context) {
+  void _showRadioMenu(BuildContext context) {
    final maProvider = context.read<MusicAssistantProvider>();
    final players = maProvider.availablePlayers;
-    final colorScheme = Theme.of(context).colorScheme;
+
+    // Slide mini player down out of the way
+    GlobalPlayerOverlay.hidePlayer();

    showModalBottomSheet(
      context: context,
-      backgroundColor: colorScheme.surface,
-      shape: const RoundedRectangleBorder(
-        borderRadius: BorderRadius.vertical(top: Radius.circular(20)),
-      ),
-      builder: (context) => Padding(
-        padding: const EdgeInsets.all(16.0),
+      backgroundColor: Colors.transparent,
+      builder: (context) => Container(
+        decoration: BoxDecoration(
+          color: Theme.of(context).colorScheme.surface,
+          borderRadius: const BorderRadius.vertical(top: Radius.circular(20)),
+        ),
        child: Column(
          mainAxisSize: MainAxisSize.min,
-          crossAxisAlignment: CrossAxisAlignment.start,
          children: [
+            Spacing.vGap16,
            Text(
-              'Start ${widget.artist.name} radio on...',
+              S.of(context)!.startRadioOn(widget.artist.name),
              style: Theme.of(context).textTheme.titleLarge,
            ),
-            const SizedBox(height: 16),
+            Spacing.vGap16,
            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(
@@ -301,7 +439,7 @@ class _ArtistDetailsScreenState extends State<ArtistDetailsScreen> {
                    return ListTile(
                      leading: Icon(
                        Icons.speaker,
-                        color: colorScheme.onSurface,
+                        color: Theme.of(context).colorScheme.onSurface,
                      ),
                      title: Text(player.name),
                      onTap: () async {
@@ -311,7 +449,7 @@ class _ArtistDetailsScreenState extends State<ArtistDetailsScreen> {
                          if (mounted) {
                            ScaffoldMessenger.of(context).showSnackBar(
                              SnackBar(
-                                content: Text('Starting ${widget.artist.name} radio on ${player.name}'),
+                                content: Text(S.of(context)!.startingRadioOnPlayer(widget.artist.name, player.name)),
                                duration: const Duration(seconds: 1),
                              ),
                            );
@@ -321,7 +459,7 @@ class _ArtistDetailsScreenState extends State<ArtistDetailsScreen> {
                          if (mounted) {
                            ScaffoldMessenger.of(context).showSnackBar(
                              SnackBar(
-                                content: Text('Failed to start radio: $e'),
+                                content: Text(S.of(context)!.failedToStartRadio(e.toString())),
                                backgroundColor: Colors.red,
                              ),
                            );
@@ -332,46 +470,103 @@ class _ArtistDetailsScreenState extends State<ArtistDetailsScreen> {
                  },
                ),
              ),
-            const SizedBox(height: 16),
+            SizedBox(height: MediaQuery.of(context).padding.bottom + 16),
          ],
        ),
      ),
-    );
+    ).whenComplete(() {
+      // Slide mini player back up when sheet is dismissed
+      GlobalPlayerOverlay.showPlayer();
+    });
  }

-  Future<void> _addArtistRadioToQueue() async {
+  void _showAddToQueueMenu(BuildContext context) {
    final maProvider = context.read<MusicAssistantProvider>();
-    final selectedPlayer = maProvider.selectedPlayer;
+    final players = maProvider.availablePlayers;

-    if (selectedPlayer == null) {
-      ScaffoldMessenger.of(context).showSnackBar(
-        const SnackBar(content: Text('No player selected')),
-      );
-      return;
-    }
+    // Slide mini player down out of the way
+    GlobalPlayerOverlay.hidePlayer();

-    try {
-      // For adding to queue with radio mode, we use radio_mode but with 'add' option
-      await maProvider.api?.playArtistRadioToQueue(selectedPlayer.playerId, widget.artist);
-      if (mounted) {
-        ScaffoldMessenger.of(context).showSnackBar(
-          SnackBar(
-            content: Text('Added ${widget.artist.name} radio to queue'),
-            duration: const Duration(seconds: 1),
-          ),
-        );
-      }
-    } catch (e) {
-      _logger.log('Error adding artist radio to queue: $e');
-      if (mounted) {
-        ScaffoldMessenger.of(context).showSnackBar(
-          SnackBar(
-            content: Text('Failed to add to queue: $e'),
-            backgroundColor: Colors.red,
-          ),
-        );
-      }
-    }
+    showModalBottomSheet(
+      context: context,
+      backgroundColor: Colors.transparent,
+      builder: (context) => Container(
+        decoration: BoxDecoration(
+          color: Theme.of(context).colorScheme.surface,
+          borderRadius: const BorderRadius.vertical(top: Radius.circular(20)),
+        ),
+        child: Column(
+          mainAxisSize: MainAxisSize.min,
+          children: [
+            Spacing.vGap16,
+            Text(
+              S.of(context)!.addToQueueOn,
+              style: Theme.of(context).textTheme.titleLarge,
+            ),
+            Spacing.vGap16,
+            if (players.isEmpty)
+              Padding(
+                padding: const EdgeInsets.all(32.0),
+                child: Text(S.of(context)!.noPlayersAvailable),
+              )
+            else
+              Flexible(
+                child: ListView.builder(
+                  shrinkWrap: true,
+                  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: () async {
+                        Navigator.pop(context);
+                        final api = maProvider.api;
+                        if (api == null) {
+                          if (mounted) {
+                            ScaffoldMessenger.of(context).showSnackBar(
+                              SnackBar(content: Text(S.of(context)!.notConnected)),
+                            );
+                          }
+                          return;
+                        }
+                        try {
+                          await api.playArtistRadioToQueue(player.playerId, widget.artist);
+                          if (mounted) {
+                            ScaffoldMessenger.of(context).showSnackBar(
+                              SnackBar(
+                                content: Text(S.of(context)!.addedRadioToQueue(widget.artist.name)),
+                                duration: const Duration(seconds: 1),
+                              ),
+                            );
+                          }
+                        } catch (e) {
+                          _logger.log('Error adding artist radio to queue: $e');
+                          if (mounted) {
+                            ScaffoldMessenger.of(context).showSnackBar(
+                              SnackBar(
+                                content: Text(S.of(context)!.failedToAddToQueue(e.toString())),
+                                backgroundColor: Colors.red,
+                              ),
+                            );
+                          }
+                        }
+                      },
+                    );
+                  },
+                ),
+              ),
+            SizedBox(height: MediaQuery.of(context).padding.bottom + 16),
+          ],
+        ),
+      ),
+    ).whenComplete(() {
+      // Slide mini player back up when sheet is dismissed
+      GlobalPlayerOverlay.showPlayer();
+    });
  }

  Future<void> _loadArtistImage() async {
@@ -426,23 +621,54 @@ class _ArtistDetailsScreenState extends State<ArtistDetailsScreen> {
  Future<void> _loadArtistAlbums() async {
    final provider = context.read<MusicAssistantProvider>();

-    // Use cached artist albums method
-    final allAlbums = await provider.getArtistAlbumsWithCache(widget.artist.name);
+    // 1. Show cached data immediately (if available)
+    final cachedAlbums = provider.getCachedArtistAlbums(widget.artist.name);
+    if (cachedAlbums != null && cachedAlbums.isNotEmpty) {
+      final libraryAlbums = cachedAlbums.where((a) => a.inLibrary).toList();
+      final providerOnlyAlbums = cachedAlbums.where((a) => !a.inLibrary).toList();

-    if (mounted) {
-      // Separate library albums from provider-only albums
-      final libraryAlbums = allAlbums.where((a) => a.inLibrary).toList();
-      final providerOnlyAlbums = allAlbums.where((a) => !a.inLibrary).toList();
+      if (mounted) {
+        setState(() {
+          _albums = libraryAlbums;
+          _providerAlbums = providerOnlyAlbums;
+          _sortAlbums();
+          _isLoading = false;
+        });
+      }
+    }

-      setState(() {
-        _albums = libraryAlbums;
-        _providerAlbums = providerOnlyAlbums;
-        _sortAlbums(); // Apply saved sort order
-        _isLoading = false;
-      });
+    // 2. Fetch fresh data in background (silent refresh)
+    try {
+      final allAlbums = await provider.getArtistAlbumsWithCache(
+        widget.artist.name,
+        forceRefresh: cachedAlbums != null,
+      );
+
+      if (mounted && allAlbums.isNotEmpty) {
+        // Check if data actually changed
+        final albumsChanged = _albums.length != allAlbums.where((a) => a.inLibrary).length;
+
+        if (albumsChanged || _albums.isEmpty) {
+          final libraryAlbums = allAlbums.where((a) => a.inLibrary).toList();
+          final providerOnlyAlbums = allAlbums.where((a) => !a.inLibrary).toList();
+
+          setState(() {
+            _albums = libraryAlbums;
+            _providerAlbums = providerOnlyAlbums;
+            _sortAlbums();
+            _isLoading = false;
+          });
+        }
+      }
+    } catch (e) {
+      // Silent failure - keep showing cached data
+    }
+
+    if (mounted && _isLoading) {
+      setState(() => _isLoading = false);
    }
  }
-  
+
  @override
  Widget build(BuildContext context) {
    // CRITICAL FIX: Use select() instead of watch() to reduce rebuilds
@@ -482,10 +708,16 @@ class _ArtistDetailsScreenState extends State<ArtistDetailsScreen> {
      },
      child: Scaffold(
        backgroundColor: colorScheme.background,
-        body: CustomScrollView(
+        body: LayoutBuilder(
+          builder: (context, constraints) {
+            // Responsive cover size: 70% of screen width, clamped between 160-280 (smaller for circular artist image)
+            final coverSize = (constraints.maxWidth * 0.7).clamp(160.0, 280.0);
+            final expandedHeight = coverSize + 100;
+
+            return CustomScrollView(
          slivers: [
            SliverAppBar(
-              expandedHeight: 300,
+              expandedHeight: expandedHeight,
              pinned: true,
              backgroundColor: colorScheme.background,
              leading: IconButton(
@@ -505,22 +737,28 @@ class _ArtistDetailsScreenState extends State<ArtistDetailsScreen> {
                    tag: HeroTags.artistImage + (widget.artist.uri ?? widget.artist.itemId) + _heroTagSuffix,
                    child: ClipOval(
                      child: Container(
-                        width: 200,
-                        height: 200,
+                        width: coverSize,
+                        height: coverSize,
                        color: colorScheme.surfaceVariant,
                        child: imageUrl != null
-                            ? Image.network(
-                                imageUrl,
+                            ? CachedNetworkImage(
+                                imageUrl: imageUrl,
                                fit: BoxFit.cover,
-                                errorBuilder: (_, __, ___) => Icon(
+                                // Match source memCacheWidth for smooth Hero animation
+                                memCacheWidth: 256,
+                                memCacheHeight: 256,
+                                fadeInDuration: Duration.zero,
+                                fadeOutDuration: Duration.zero,
+                                placeholder: (_, __) => const SizedBox(),
+                                errorWidget: (_, __, ___) => Icon(
                                  Icons.person_rounded,
-                                  size: 100,
+                                  size: coverSize * 0.5,
                                  color: colorScheme.onSurfaceVariant,
                                ),
                              )
                            : Icon(
                                Icons.person_rounded,
-                                size: 100,
+                                size: coverSize * 0.5,
                                color: colorScheme.onSurfaceVariant,
                              ),
                      ),
@@ -549,7 +787,7 @@ class _ArtistDetailsScreenState extends State<ArtistDetailsScreen> {
                      ),
                    ),
                  ),
-                  const SizedBox(height: 16),
+                  Spacing.vGap16,
                  if (_artistDescription != null && _artistDescription!.isNotEmpty) ...[
                    InkWell(
                      onTap: () {
@@ -570,7 +808,7 @@ class _ArtistDetailsScreenState extends State<ArtistDetailsScreen> {
                        ),
                      ),
                    ),
-                    const SizedBox(height: 8),
+                    Spacing.vGap8,
                  ],
                  // Action Buttons Row
                  Row(
@@ -581,9 +819,9 @@ class _ArtistDetailsScreenState extends State<ArtistDetailsScreen> {
                        child: SizedBox(
                          height: 50,
                          child: ElevatedButton.icon(
-                            onPressed: _startArtistRadio,
+                            onPressed: () => _showRadioMenu(context),
                            icon: const Icon(Icons.radio),
-                            label: const Text('Radio'),
+                            label: Text(S.of(context)!.radio),
                            style: ElevatedButton.styleFrom(
                              backgroundColor: colorScheme.primary,
                              foregroundColor: colorScheme.onPrimary,
@@ -594,23 +832,6 @@ class _ArtistDetailsScreenState extends State<ArtistDetailsScreen> {
                          ),
                        ),
                      ),
-                      const SizedBox(width: 12),
-
-                      // "Play on..." Button (Square)
-                      SizedBox(
-                        height: 50,
-                        width: 50,
-                        child: FilledButton.tonal(
-                          onPressed: () => _showPlayOnMenu(context),
-                          style: FilledButton.styleFrom(
-                            padding: EdgeInsets.zero,
-                            shape: RoundedRectangleBorder(
-                              borderRadius: BorderRadius.circular(12),
-                            ),
-                          ),
-                          child: const Icon(Icons.speaker_group_outlined),
-                        ),
-                      ),

                      const SizedBox(width: 12),

@@ -619,7 +840,7 @@ class _ArtistDetailsScreenState extends State<ArtistDetailsScreen> {
                        height: 50,
                        width: 50,
                        child: FilledButton.tonal(
-                          onPressed: _addArtistRadioToQueue,
+                          onPressed: () => _showAddToQueueMenu(context),
                          style: FilledButton.styleFrom(
                            padding: EdgeInsets.zero,
                            shape: RoundedRectangleBorder(
@@ -641,7 +862,7 @@ class _ArtistDetailsScreenState extends State<ArtistDetailsScreen> {
                          style: FilledButton.styleFrom(
                            padding: EdgeInsets.zero,
                            shape: RoundedRectangleBorder(
-                              borderRadius: BorderRadius.circular(25),
+                              borderRadius: BorderRadius.circular(Radii.xxl),
                            ),
                          ),
                          child: Icon(
@@ -652,9 +873,32 @@ class _ArtistDetailsScreenState extends State<ArtistDetailsScreen> {
                          ),
                        ),
                      ),
+
+                      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),
+                  Spacing.vGap16,
                ],
              ),
            ),
@@ -669,7 +913,7 @@ class _ArtistDetailsScreenState extends State<ArtistDetailsScreen> {
            SliverFillRemaining(
              child: Center(
                child: Text(
-                  'No albums found',
+                  S.of(context)!.noAlbumsFound,
                  style: TextStyle(
                    color: colorScheme.onBackground.withOpacity(0.54),
                    fontSize: 16,
@@ -686,7 +930,7 @@ class _ArtistDetailsScreenState extends State<ArtistDetailsScreen> {
                  child: Row(
                    children: [
                      Text(
-                        'In Library',
+                        S.of(context)!.inLibrary,
                        style: textTheme.titleLarge?.copyWith(
                          color: colorScheme.onBackground,
                          fontWeight: FontWeight.bold,
@@ -700,11 +944,11 @@ class _ArtistDetailsScreenState extends State<ArtistDetailsScreen> {
                          color: colorScheme.primary,
                          size: 20,
                        ),
-                        tooltip: _sortOrder == 'alpha' ? 'Sort by year' : 'Sort alphabetically',
+                        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),
+                        constraints: const BoxConstraints(minWidth: 44, minHeight: 44),
                      ),
                      // View mode toggle
                      IconButton(
@@ -718,14 +962,14 @@ class _ArtistDetailsScreenState extends State<ArtistDetailsScreen> {
                          size: 20,
                        ),
                        tooltip: _viewMode == 'grid2'
-                            ? '3-column grid'
+                            ? S.of(context)!.threeColumnGrid
                            : _viewMode == 'grid3'
-                                ? 'List view'
-                                : '2-column grid',
+                                ? S.of(context)!.listView
+                                : S.of(context)!.twoColumnGrid,
                        onPressed: _cycleViewMode,
                        visualDensity: VisualDensity.compact,
                        padding: EdgeInsets.zero,
-                        constraints: const BoxConstraints(minWidth: 36, minHeight: 36),
+                        constraints: const BoxConstraints(minWidth: 44, minHeight: 44),
                      ),
                    ],
                  ),
@@ -742,7 +986,7 @@ class _ArtistDetailsScreenState extends State<ArtistDetailsScreen> {
                  child: Row(
                    children: [
                      Text(
-                        'From Providers',
+                        S.of(context)!.fromProviders,
                        style: textTheme.titleLarge?.copyWith(
                          color: colorScheme.onBackground,
                          fontWeight: FontWeight.bold,
@@ -757,11 +1001,11 @@ class _ArtistDetailsScreenState extends State<ArtistDetailsScreen> {
                            color: colorScheme.primary,
                            size: 20,
                          ),
-                          tooltip: _sortOrder == 'alpha' ? 'Sort by year' : 'Sort alphabetically',
+                          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),
+                          constraints: const BoxConstraints(minWidth: 44, minHeight: 44),
                        ),
                        IconButton(
                          icon: Icon(
@@ -774,14 +1018,14 @@ class _ArtistDetailsScreenState extends State<ArtistDetailsScreen> {
                            size: 20,
                          ),
                          tooltip: _viewMode == 'grid2'
-                              ? '3-column grid'
+                              ? S.of(context)!.threeColumnGrid
                              : _viewMode == 'grid3'
-                                  ? 'List view'
-                                  : '2-column grid',
+                                  ? S.of(context)!.listView
+                                  : S.of(context)!.twoColumnGrid,
                          onPressed: _cycleViewMode,
                          visualDensity: VisualDensity.compact,
                          padding: EdgeInsets.zero,
-                          constraints: const BoxConstraints(minWidth: 36, minHeight: 36),
+                          constraints: const BoxConstraints(minWidth: 44, minHeight: 44),
                        ),
                      ],
                    ],
@@ -789,10 +1033,12 @@ class _ArtistDetailsScreenState extends State<ArtistDetailsScreen> {
                ),
              ),
              _buildAlbumSliver(_providerAlbums),
-              const SliverToBoxAdapter(child: SizedBox(height: 140)), // Space for bottom nav + mini player
+              SliverToBoxAdapter(child: SizedBox(height: BottomSpacing.withMiniPlayer)), // Space for bottom nav + mini player
            ],
          ],
        ],
+        );
+          },
        ),
      ),
    );
@@ -816,6 +1062,7 @@ class _ArtistDetailsScreenState extends State<ArtistDetailsScreen> {
            child: AlbumDetailsScreen(
              album: album,
              heroTagSuffix: heroSuffix,
+              initialImageUrl: imageUrl,
            ),
          ),
        );
@@ -832,12 +1079,14 @@ class _ArtistDetailsScreenState extends State<ArtistDetailsScreen> {
                child: Container(
                  color: colorScheme.surfaceVariant,
                  child: imageUrl != null
-                      ? Image.network(
-                          imageUrl,
+                      ? CachedNetworkImage(
+                          imageUrl: imageUrl,
                          fit: BoxFit.cover,
                          width: double.infinity,
                          height: double.infinity,
-                          errorBuilder: (_, __, ___) => Center(
+                          fadeInDuration: Duration.zero,
+                          fadeOutDuration: Duration.zero,
+                          errorWidget: (_, __, ___) => Center(
                            child: Icon(
                              Icons.album_rounded,
                              size: 64,
@@ -856,7 +1105,7 @@ class _ArtistDetailsScreenState extends State<ArtistDetailsScreen> {
              ),
            ),
          ),
-          const SizedBox(height: 8),
+          Spacing.vGap8,
          Hero(
            tag: HeroTags.albumTitle + (album.uri ?? album.itemId) + '_$heroSuffix',
            child: Material(
@@ -939,10 +1188,12 @@ class _ArtistDetailsScreenState extends State<ArtistDetailsScreen> {
          height: 56,
          color: colorScheme.surfaceVariant,
          child: imageUrl != null
-              ? Image.network(
-                  imageUrl,
+              ? CachedNetworkImage(
+                  imageUrl: imageUrl,
                  fit: BoxFit.cover,
-                  errorBuilder: (_, __, ___) => Icon(
+                  fadeInDuration: Duration.zero,
+                  fadeOutDuration: Duration.zero,
+                  errorWidget: (_, __, ___) => Icon(
                    Icons.album_rounded,
                    color: colorScheme.onSurfaceVariant,
                  ),
@@ -978,6 +1229,7 @@ class _ArtistDetailsScreenState extends State<ArtistDetailsScreen> {
            child: AlbumDetailsScreen(
              album: album,
              heroTagSuffix: 'artist_albums',
+              initialImageUrl: imageUrl,
            ),
          ),
        );
@@ -12,18 +12,21 @@ 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
@@ -47,6 +50,8 @@ class _AudiobookAuthorScreenState extends State<AudiobookAuthorScreen> {
  void initState() {
    super.initState();
    _audiobooks = List.from(widget.audiobooks);
+    // Use initial image URL immediately for smooth hero animation
+    _authorImageUrl = widget.initialAuthorImageUrl;
    _loadViewPreferences();
    _sortAudiobooks();
    _loadAuthorImage();
@@ -145,10 +150,16 @@ class _AudiobookAuthorScreenState extends State<AudiobookAuthorScreen> {
      },
      child: Scaffold(
        backgroundColor: colorScheme.surface,
-        body: CustomScrollView(
+        body: LayoutBuilder(
+          builder: (context, constraints) {
+            // Responsive cover size: 70% of screen width, clamped between 160-280 (same as artist detail)
+            final coverSize = (constraints.maxWidth * 0.7).clamp(160.0, 280.0);
+            final expandedHeight = coverSize + 100;
+
+            return CustomScrollView(
          slivers: [
            SliverAppBar(
-              expandedHeight: 200,
+              expandedHeight: expandedHeight,
              pinned: true,
              backgroundColor: colorScheme.surface,
              leading: IconButton(
@@ -167,35 +178,41 @@ class _AudiobookAuthorScreenState extends State<AudiobookAuthorScreen> {
                    Hero(
                      tag: HeroTags.authorImage + widget.authorName + _heroTagSuffix,
                      child: Container(
-                        width: 200,
-                        height: 200,
+                        width: coverSize,
+                        height: coverSize,
                        decoration: BoxDecoration(
                          color: colorScheme.primaryContainer,
                          shape: BoxShape.circle,
                        ),
-                        child: ClipOval(
-                          child: _authorImageUrl != null
-                              ? CachedNetworkImage(
-                                  imageUrl: _authorImageUrl!,
-                                  fit: BoxFit.cover,
-                                  width: 200,
-                                  height: 200,
-                                  placeholder: (_, __) => Icon(
-                                    MdiIcons.accountOutline,
-                                    size: 100,
-                                    color: colorScheme.onPrimaryContainer,
+                        child: Stack(
+                          alignment: Alignment.center,
+                          children: [
+                            // Icon always present underneath
+                            Icon(
+                              MdiIcons.accountOutline,
+                              size: coverSize * 0.5,
+                              color: colorScheme.onPrimaryContainer,
+                            ),
+                            // Image covers icon when loaded
+                            if (_authorImageUrl != null)
+                              SizedBox(
+                                width: coverSize,
+                                height: coverSize,
+                                child: ClipOval(
+                                  child: CachedNetworkImage(
+                                    imageUrl: _authorImageUrl!,
+                                    fit: BoxFit.cover,
+                                    width: coverSize,
+                                    height: coverSize,
+                                    memCacheWidth: 256,
+                                    fadeInDuration: Duration.zero,
+                                    fadeOutDuration: Duration.zero,
+                                    placeholder: (_, __) => const SizedBox.shrink(),
+                                    errorWidget: (_, __, ___) => const SizedBox.shrink(),
                                  ),
-                                  errorWidget: (_, __, ___) => Icon(
-                                    MdiIcons.accountOutline,
-                                    size: 100,
-                                    color: colorScheme.onPrimaryContainer,
-                                  ),
-                                )
-                              : Icon(
-                                  MdiIcons.accountOutline,
-                                  size: 100,
-                                  color: colorScheme.onPrimaryContainer,
                                ),
+                              ),
+                          ],
                        ),
                      ),
                    ),
@@ -218,7 +235,7 @@ class _AudiobookAuthorScreenState extends State<AudiobookAuthorScreen> {
                    ),
                    const SizedBox(height: 8),
                    Text(
-                      '${_audiobooks.length} ${_audiobooks.length == 1 ? 'audiobook' : 'audiobooks'}',
+                      S.of(context)!.audiobookCount(_audiobooks.length),
                      style: textTheme.bodyLarge?.copyWith(
                        color: colorScheme.onSurface.withOpacity(0.7),
                      ),
@@ -234,7 +251,7 @@ class _AudiobookAuthorScreenState extends State<AudiobookAuthorScreen> {
                child: Row(
                  children: [
                    Text(
-                      'Audiobooks',
+                      S.of(context)!.audiobooks,
                      style: textTheme.titleLarge?.copyWith(
                        color: colorScheme.onSurface,
                        fontWeight: FontWeight.bold,
@@ -248,7 +265,7 @@ class _AudiobookAuthorScreenState extends State<AudiobookAuthorScreen> {
                        color: colorScheme.primary,
                        size: 20,
                      ),
-                      tooltip: _sortOrder == 'alpha' ? 'Sort by year' : 'Sort alphabetically',
+                      tooltip: _sortOrder == 'alpha' ? S.of(context)!.sortByYear : S.of(context)!.sortAlphabetically,
                      onPressed: _toggleSortOrder,
                      visualDensity: VisualDensity.compact,
                      padding: EdgeInsets.zero,
@@ -266,10 +283,10 @@ class _AudiobookAuthorScreenState extends State<AudiobookAuthorScreen> {
                        size: 20,
                      ),
                      tooltip: _viewMode == 'grid2'
-                          ? '3-column grid'
+                          ? S.of(context)!.threeColumnGrid
                          : _viewMode == 'grid3'
-                              ? 'List view'
-                              : '2-column grid',
+                              ? S.of(context)!.listView
+                              : S.of(context)!.twoColumnGrid,
                      onPressed: _cycleViewMode,
                      visualDensity: VisualDensity.compact,
                      padding: EdgeInsets.zero,
@@ -280,8 +297,10 @@ class _AudiobookAuthorScreenState extends State<AudiobookAuthorScreen> {
              ),
            ),
            _buildAudiobookSliver(),
-            const SliverToBoxAdapter(child: SizedBox(height: 140)),
+            SliverToBoxAdapter(child: SizedBox(height: BottomSpacing.withMiniPlayer)),
          ],
+            );
+          },
        ),
      ),
    );
@@ -328,7 +347,7 @@ class _AudiobookAuthorScreenState extends State<AudiobookAuthorScreen> {
    final heroSuffix = 'author${_heroTagSuffix}';

    return InkWell(
-      onTap: () => _navigateToAudiobook(book, heroTagSuffix: heroSuffix),
+      onTap: () => _navigateToAudiobook(book, heroTagSuffix: heroSuffix, initialImageUrl: imageUrl),
      child: Column(
        crossAxisAlignment: CrossAxisAlignment.start,
        children: [
@@ -348,6 +367,8 @@ class _AudiobookAuthorScreenState extends State<AudiobookAuthorScreen> {
                              fit: BoxFit.cover,
                              width: double.infinity,
                              height: double.infinity,
+                              fadeInDuration: Duration.zero,
+                              fadeOutDuration: Duration.zero,
                              placeholder: (_, __) => Center(
                                child: Icon(
                                  MdiIcons.bookOutline,
@@ -405,9 +426,9 @@ class _AudiobookAuthorScreenState extends State<AudiobookAuthorScreen> {
              ),
            ),
          ),
-          if (book.narratorsString != 'Unknown Narrator')
+          if (book.narratorsString != S.of(context)!.unknownNarrator)
            Text(
-              'Narrated by ${book.narratorsString}',
+              S.of(context)!.narratedBy(book.narratorsString),
              style: textTheme.bodySmall?.copyWith(
                color: colorScheme.onSurface.withOpacity(0.6),
              ),
@@ -442,6 +463,8 @@ class _AudiobookAuthorScreenState extends State<AudiobookAuthorScreen> {
                    ? CachedNetworkImage(
                        imageUrl: imageUrl,
                        fit: BoxFit.cover,
+                        fadeInDuration: Duration.zero,
+                        fadeOutDuration: Duration.zero,
                        placeholder: (_, __) => Icon(
                          MdiIcons.bookOutline,
                          color: colorScheme.onSurfaceVariant,
@@ -488,8 +511,8 @@ class _AudiobookAuthorScreenState extends State<AudiobookAuthorScreen> {
        ),
      ),
      subtitle: Text(
-        book.narratorsString != 'Unknown Narrator'
-            ? 'Narrated by ${book.narratorsString}'
+        book.narratorsString != S.of(context)!.unknownNarrator
+            ? S.of(context)!.narratedBy(book.narratorsString)
            : book.duration != null
                ? _formatDuration(book.duration!)
                : '',
@@ -507,17 +530,18 @@ class _AudiobookAuthorScreenState extends State<AudiobookAuthorScreen> {
              ),
            )
          : null,
-      onTap: () => _navigateToAudiobook(book, heroTagSuffix: heroSuffix),
+      onTap: () => _navigateToAudiobook(book, heroTagSuffix: heroSuffix, initialImageUrl: imageUrl),
    );
  }

-  void _navigateToAudiobook(Audiobook book, {String? heroTagSuffix}) {
+  void _navigateToAudiobook(Audiobook book, {String? heroTagSuffix, String? initialImageUrl}) {
    Navigator.push(
      context,
      FadeSlidePageRoute(
        child: AudiobookDetailScreen(
          audiobook: book,
          heroTagSuffix: heroTagSuffix,
+          initialImageUrl: initialImageUrl,
        ),
      ),
    );
@@ -5,20 +5,26 @@ 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 '../services/recently_played_service.dart';
 import '../constants/hero_tags.dart';
+import '../l10n/app_localizations.dart';
+import '../theme/design_tokens.dart';

 class AudiobookDetailScreen extends StatefulWidget {
  final Audiobook audiobook;
  final String? heroTagSuffix;
+  /// Initial image URL from the source for seamless hero animation
+  final String? initialImageUrl;

  const AudiobookDetailScreen({
    super.key,
    required this.audiobook,
    this.heroTagSuffix,
+    this.initialImageUrl,
  });

  @override
@@ -118,10 +124,10 @@ class _AudiobookDetailScreenState extends State<AudiobookDetailScreen> {

  Future<void> _toggleFavorite() async {
    final maProvider = context.read<MusicAssistantProvider>();
-    if (maProvider.api == null) return;

    try {
      final newState = !_isFavorite;
+      bool success;

      if (newState) {
        String actualProvider = widget.audiobook.provider;
@@ -135,12 +141,17 @@ class _AudiobookDetailScreenState extends State<AudiobookDetailScreen> {
              orElse: () => widget.audiobook.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 audiobook to favorites: provider=$actualProvider, itemId=$actualItemId');
-        await maProvider.api!.addToFavorites('audiobook', actualItemId, actualProvider);
+        success = await maProvider.addToFavorites(
+          mediaType: 'audiobook',
+          itemId: actualItemId,
+          provider: actualProvider,
+        );
      } else {
        int? libraryItemId;

@@ -160,30 +171,37 @@ class _AudiobookDetailScreenState extends State<AudiobookDetailScreen> {
          throw Exception('Could not determine library ID for this audiobook');
        }

-        _logger.log('Removing audiobook from favorites: libraryItemId=$libraryItemId');
-        await maProvider.api!.removeFromFavorites('audiobook', libraryItemId);
+        success = await maProvider.removeFromFavorites(
+          mediaType: 'audiobook',
+          libraryItemId: libraryItemId,
+        );
      }

-      setState(() {
-        _isFavorite = newState;
-      });
+      if (success) {
+        setState(() {
+          _isFavorite = newState;
+        });

-      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 audiobook 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),
          ),
        );
@@ -193,62 +211,22 @@ class _AudiobookDetailScreenState extends State<AudiobookDetailScreen> {

  void _showPlayOnMenu(BuildContext context) {
    final maProvider = context.read<MusicAssistantProvider>();
-    final players = maProvider.availablePlayers;

    GlobalPlayerOverlay.hidePlayer();

-    final screenHeight = MediaQuery.of(context).size.height;
-    final bottomPadding = MediaQuery.of(context).padding.bottom;
-    final sheetHeight = (screenHeight * 0.45) + bottomPadding;
-
-    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: () async {
-                            Navigator.pop(context);
-                            maProvider.selectPlayer(player);
-                            maProvider.setCurrentAudiobook(_audiobook);
-                            await maProvider.api?.playAudiobook(
-                              player.playerId,
-                              widget.audiobook,
-                            );
-                          },
-                        );
-                      },
-                    ),
-            ),
-          ],
-        ),
-      ),
+      title: S.of(context)!.playOn,
+      players: maProvider.availablePlayers,
+      selectedPlayer: maProvider.selectedPlayer,
+      onPlayerSelected: (player) async {
+        maProvider.selectPlayer(player);
+        maProvider.setCurrentAudiobook(_audiobook);
+        await maProvider.api?.playAudiobook(
+          player.playerId,
+          widget.audiobook,
+        );
+      },
    ).whenComplete(() {
      GlobalPlayerOverlay.showPlayer();
    });
@@ -287,7 +265,7 @@ class _AudiobookDetailScreenState extends State<AudiobookDetailScreen> {
      if (mounted) {
        ScaffoldMessenger.of(context).showSnackBar(
          SnackBar(
-            content: Text('${_audiobook.name} marked as finished'),
+            content: Text(S.of(context)!.markedAsFinished(_audiobook.name)),
            duration: const Duration(seconds: 2),
          ),
        );
@@ -297,7 +275,7 @@ class _AudiobookDetailScreenState extends State<AudiobookDetailScreen> {
      if (mounted) {
        ScaffoldMessenger.of(context).showSnackBar(
          SnackBar(
-            content: Text('Failed to mark as finished: $e'),
+            content: Text(S.of(context)!.failedToMarkFinished(e.toString())),
            backgroundColor: Colors.red,
          ),
        );
@@ -338,7 +316,7 @@ class _AudiobookDetailScreenState extends State<AudiobookDetailScreen> {
      if (mounted) {
        ScaffoldMessenger.of(context).showSnackBar(
          SnackBar(
-            content: Text('${_audiobook.name} marked as unplayed'),
+            content: Text(S.of(context)!.markedAsUnplayed(_audiobook.name)),
            duration: const Duration(seconds: 2),
          ),
        );
@@ -348,7 +326,7 @@ class _AudiobookDetailScreenState extends State<AudiobookDetailScreen> {
      if (mounted) {
        ScaffoldMessenger.of(context).showSnackBar(
          SnackBar(
-            content: Text('Failed to mark as unplayed: $e'),
+            content: Text(S.of(context)!.failedToMarkUnplayed(e.toString())),
            backgroundColor: Colors.red,
          ),
        );
@@ -362,7 +340,7 @@ class _AudiobookDetailScreenState extends State<AudiobookDetailScreen> {

    if (selectedPlayer == null) {
      ScaffoldMessenger.of(context).showSnackBar(
-        const SnackBar(content: Text('No player selected')),
+        SnackBar(content: Text(S.of(context)!.noPlayerSelected)),
      );
      return;
    }
@@ -392,7 +370,7 @@ class _AudiobookDetailScreenState extends State<AudiobookDetailScreen> {
      if (mounted) {
        ScaffoldMessenger.of(context).showSnackBar(
          SnackBar(
-            content: Text('Playing ${widget.audiobook.name}'),
+            content: Text(S.of(context)!.playing(widget.audiobook.name)),
            duration: const Duration(seconds: 1),
          ),
        );
@@ -402,7 +380,7 @@ class _AudiobookDetailScreenState extends State<AudiobookDetailScreen> {
      if (mounted) {
        ScaffoldMessenger.of(context).showSnackBar(
          SnackBar(
-            content: Text('Failed to play: $e'),
+            content: Text(S.of(context)!.failedToPlay(e.toString())),
            backgroundColor: Colors.red,
          ),
        );
@@ -413,7 +391,9 @@ class _AudiobookDetailScreenState extends State<AudiobookDetailScreen> {
  @override
  Widget build(BuildContext context) {
    final maProvider = context.read<MusicAssistantProvider>();
-    final imageUrl = maProvider.getImageUrl(widget.audiobook, size: 512);
+    final providerImageUrl = maProvider.getImageUrl(widget.audiobook, size: 512);
+    // Use initialImageUrl as fallback for seamless hero animation
+    final imageUrl = providerImageUrl ?? widget.initialImageUrl;

    final adaptiveTheme = context.select<ThemeProvider, bool>(
      (provider) => provider.adaptiveTheme,
@@ -448,10 +428,16 @@ class _AudiobookDetailScreenState extends State<AudiobookDetailScreen> {
      },
      child: Scaffold(
        backgroundColor: colorScheme.surface,
-        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,
+              expandedHeight: expandedHeight,
              pinned: true,
              backgroundColor: colorScheme.surface,
              leading: IconButton(
@@ -489,7 +475,7 @@ class _AudiobookDetailScreenState extends State<AudiobookDetailScreen> {
                            size: 20,
                          ),
                          const SizedBox(width: 12),
-                          const Text('Mark as Finished'),
+                          Text(S.of(context)!.markAsFinished),
                        ],
                      ),
                    ),
@@ -503,7 +489,7 @@ class _AudiobookDetailScreenState extends State<AudiobookDetailScreen> {
                            size: 20,
                          ),
                          const SizedBox(width: 12),
-                          const Text('Mark as Unplayed'),
+                          Text(S.of(context)!.markAsUnplayed),
                        ],
                      ),
                    ),
@@ -520,24 +506,29 @@ class _AudiobookDetailScreenState extends State<AudiobookDetailScreen> {
                      child: ClipRRect(
                        borderRadius: BorderRadius.circular(8),
                        child: Container(
-                          width: 280,
-                          height: 280,
+                          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.bookOutline,
-                                      size: 120,
+                                      size: coverSize * 0.43,
                                      color: colorScheme.onSurfaceVariant,
                                    ),
                                  ),
                                  errorWidget: (_, __, ___) => Center(
                                    child: Icon(
                                      MdiIcons.bookOutline,
-                                      size: 120,
+                                      size: coverSize * 0.43,
                                      color: colorScheme.onSurfaceVariant,
                                    ),
                                  ),
@@ -545,7 +536,7 @@ class _AudiobookDetailScreenState extends State<AudiobookDetailScreen> {
                              : Center(
                                  child: Icon(
                                    MdiIcons.bookOutline,
-                                    size: 120,
+                                    size: coverSize * 0.43,
                                    color: colorScheme.onSurfaceVariant,
                                  ),
                                ),
@@ -576,21 +567,21 @@ class _AudiobookDetailScreenState extends State<AudiobookDetailScreen> {
                        ),
                      ),
                    ),
-                    const SizedBox(height: 8),
+                    Spacing.vGap8,

                    // Author
                    Text(
-                      'By ${book.authorsString}',
+                      S.of(context)!.byAuthor(book.authorsString),
                      style: textTheme.titleMedium?.copyWith(
                        color: colorScheme.onSurface.withOpacity(0.8),
                      ),
                    ),

                    // Narrator
-                    if (book.narratorsString != 'Unknown Narrator') ...[
+                    if (book.narratorsString != S.of(context)!.unknownNarrator) ...[
                      const SizedBox(height: 4),
                      Text(
-                        'Narrated by ${book.narratorsString}',
+                        S.of(context)!.narratedBy(book.narratorsString),
                        style: textTheme.bodyMedium?.copyWith(
                          color: colorScheme.onSurface.withOpacity(0.6),
                        ),
@@ -598,7 +589,7 @@ class _AudiobookDetailScreenState extends State<AudiobookDetailScreen> {
                    ],

                    // Duration & Progress
-                    const SizedBox(height: 16),
+                    Spacing.vGap16,
                    Row(
                      children: [
                        if (book.duration != null) ...[
@@ -624,7 +615,7 @@ class _AudiobookDetailScreenState extends State<AudiobookDetailScreen> {
                          ),
                          const SizedBox(width: 4),
                          Text(
-                            '${(book.progress * 100).toInt()}% complete',
+                            S.of(context)!.percentComplete((book.progress * 100).toInt()),
                            style: textTheme.bodyMedium?.copyWith(
                              color: colorScheme.primary,
                            ),
@@ -662,7 +653,7 @@ class _AudiobookDetailScreenState extends State<AudiobookDetailScreen> {
                                startPositionMs: hasResumePosition ? book.resumePositionMs : null,
                              ),
                              icon: Icon(hasResumePosition ? Icons.play_arrow : Icons.play_arrow),
-                              label: Text(hasResumePosition ? 'Resume' : 'Play'),
+                              label: Text(hasResumePosition ? S.of(context)!.resume : S.of(context)!.play),
                              style: ElevatedButton.styleFrom(
                                backgroundColor: colorScheme.primary,
                                foregroundColor: colorScheme.onPrimary,
@@ -722,7 +713,7 @@ class _AudiobookDetailScreenState extends State<AudiobookDetailScreen> {
                            style: FilledButton.styleFrom(
                              padding: EdgeInsets.zero,
                              shape: RoundedRectangleBorder(
-                                borderRadius: BorderRadius.circular(25),
+                                borderRadius: BorderRadius.circular(Radii.xxl),
                              ),
                            ),
                            child: Icon(
@@ -740,13 +731,13 @@ class _AudiobookDetailScreenState extends State<AudiobookDetailScreen> {
                    if (book.description != null && book.description!.isNotEmpty) ...[
                      const SizedBox(height: 24),
                      Text(
-                        'About',
+                        S.of(context)!.about,
                        style: textTheme.titleLarge?.copyWith(
                          color: colorScheme.onSurface,
                          fontWeight: FontWeight.bold,
                        ),
                      ),
-                      const SizedBox(height: 8),
+                      Spacing.vGap8,
                      InkWell(
                        onTap: () {
                          setState(() {
@@ -771,13 +762,13 @@ class _AudiobookDetailScreenState extends State<AudiobookDetailScreen> {
                    // Chapters Header
                    const SizedBox(height: 24),
                    Text(
-                      'Chapters',
+                      S.of(context)!.chapters,
                      style: textTheme.titleLarge?.copyWith(
                        color: colorScheme.onSurface,
                        fontWeight: FontWeight.bold,
                      ),
                    ),
-                    const SizedBox(height: 8),
+                    Spacing.vGap8,
                  ],
                ),
              ),
@@ -787,8 +778,10 @@ class _AudiobookDetailScreenState extends State<AudiobookDetailScreen> {
            // Use MA chapters if available, otherwise use ABS chapters
            ..._buildChapterSection(book, colorScheme, textTheme),

-            const SliverToBoxAdapter(child: SizedBox(height: 140)),
+            SliverToBoxAdapter(child: SizedBox(height: BottomSpacing.withMiniPlayer)),
          ],
+        );
+          },
        ),
      ),
    );
@@ -815,7 +808,7 @@ class _AudiobookDetailScreenState extends State<AudiobookDetailScreen> {
                  ),
                  const SizedBox(height: 12),
                  Text(
-                    'Loading chapters...',
+                    S.of(context)!.loadingChapters,
                    style: textTheme.bodyMedium?.copyWith(
                      color: colorScheme.onSurface.withOpacity(0.6),
                    ),
@@ -853,7 +846,7 @@ class _AudiobookDetailScreenState extends State<AudiobookDetailScreen> {
          padding: const EdgeInsets.all(24.0),
          child: Center(
            child: Text(
-              'No chapter information available',
+              S.of(context)!.noChapterInfoAvailable,
              style: textTheme.bodyMedium?.copyWith(
                color: colorScheme.onSurface.withOpacity(0.6),
              ),
@@ -914,7 +907,7 @@ class _AudiobookDetailScreenState extends State<AudiobookDetailScreen> {
          ),
          subtitle: isInProgress
              ? Text(
-                  'In progress',
+                  S.of(context)!.inProgress,
                  style: textTheme.bodySmall?.copyWith(
                    color: colorScheme.primary,
                  ),
@@ -972,7 +965,7 @@ class _AudiobookDetailScreenState extends State<AudiobookDetailScreen> {
                            children: [
                              const Icon(Icons.play_arrow, size: 20),
                              const SizedBox(width: 8),
-                              Text(isInProgress ? 'Resume' : 'Play'),
+                              Text(isInProgress ? S.of(context)!.resume : S.of(context)!.play),
                            ],
                          ),
                        ),
@@ -2,6 +2,7 @@ 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;
@@ -10,15 +11,19 @@ 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
@@ -35,9 +40,21 @@ class _AudiobookSeriesScreenState extends State<AudiobookSeriesScreen> {
  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((_) {
@@ -47,6 +64,42 @@ class _AudiobookSeriesScreenState extends State<AudiobookSeriesScreen> {
    });
  }

+  /// 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();
@@ -116,7 +169,7 @@ class _AudiobookSeriesScreenState extends State<AudiobookSeriesScreen> {

      if (maProvider.api == null) {
        setState(() {
-          _error = 'Not connected to Music Assistant';
+          _error = S.of(context)!.notConnected;
          _isLoading = false;
        });
        return;
@@ -132,9 +185,22 @@ class _AudiobookSeriesScreenState extends State<AudiobookSeriesScreen> {
      }

      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
@@ -142,6 +208,9 @@ class _AudiobookSeriesScreenState extends State<AudiobookSeriesScreen> {
        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');
@@ -155,19 +224,68 @@ class _AudiobookSeriesScreenState extends State<AudiobookSeriesScreen> {
    }
  }

+  /// 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: 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: [
          // App bar with series cover collage (matches audiobook detail screen)
          SliverAppBar(
-            expandedHeight: 350,
+            expandedHeight: expandedHeight,
            pinned: true,
            backgroundColor: colorScheme.surface,
            leading: IconButton(
@@ -180,12 +298,12 @@ class _AudiobookSeriesScreenState extends State<AudiobookSeriesScreen> {
                mainAxisAlignment: MainAxisAlignment.center,
                children: [
                  const SizedBox(height: 60),
-                  // Series cover collage - same size as audiobook detail cover
+                  // Series cover collage - responsive size
                  Hero(
                    tag: widget.heroTag ?? 'series_cover_${widget.series.id}',
                    child: Container(
-                      width: 280,
-                      height: 280,
+                      width: coverSize,
+                      height: coverSize,
                      decoration: BoxDecoration(
                        color: colorScheme.surfaceContainerHighest,
                        borderRadius: BorderRadius.circular(12),
@@ -225,8 +343,8 @@ class _AudiobookSeriesScreenState extends State<AudiobookSeriesScreen> {
                  const SizedBox(height: 8),
                  Text(
                    _isLoading
-                        ? 'Loading...'
-                        : '${_audiobooks.length} ${_audiobooks.length == 1 ? 'book' : 'books'}',
+                        ? l10n.loading
+                        : l10n.bookCount(_audiobooks.length),
                    style: textTheme.bodyLarge?.copyWith(
                      color: colorScheme.onSurface.withOpacity(0.7),
                    ),
@@ -243,7 +361,7 @@ class _AudiobookSeriesScreenState extends State<AudiobookSeriesScreen> {
              child: Row(
                children: [
                  Text(
-                    'Books',
+                    l10n.books,
                    style: textTheme.titleLarge?.copyWith(
                      color: colorScheme.onSurface,
                      fontWeight: FontWeight.bold,
@@ -257,7 +375,7 @@ class _AudiobookSeriesScreenState extends State<AudiobookSeriesScreen> {
                      color: colorScheme.primary,
                      size: 20,
                    ),
-                    tooltip: _sortOrder == 'series' ? 'Sort alphabetically' : 'Sort by series order',
+                    tooltip: _sortOrder == 'series' ? S.of(context)!.sortAlphabetically : S.of(context)!.sortBySeriesOrder,
                    onPressed: _toggleSortOrder,
                    visualDensity: VisualDensity.compact,
                    padding: EdgeInsets.zero,
@@ -275,10 +393,10 @@ class _AudiobookSeriesScreenState extends State<AudiobookSeriesScreen> {
                      size: 20,
                    ),
                    tooltip: _viewMode == 'grid2'
-                        ? '3-column grid'
+                        ? S.of(context)!.threeColumnGrid
                        : _viewMode == 'grid3'
-                            ? 'List view'
-                            : '2-column grid',
+                            ? S.of(context)!.listView
+                            : S.of(context)!.twoColumnGrid,
                    onPressed: _cycleViewMode,
                    visualDensity: VisualDensity.compact,
                    padding: EdgeInsets.zero,
@@ -306,7 +424,7 @@ class _AudiobookSeriesScreenState extends State<AudiobookSeriesScreen> {
                    const SizedBox(height: 16),
                    ElevatedButton(
                      onPressed: _loadSeriesBooks,
-                      child: const Text('Retry'),
+                      child: Text(l10n.retry),
                    ),
                  ],
                ),
@@ -322,7 +440,7 @@ class _AudiobookSeriesScreenState extends State<AudiobookSeriesScreen> {
                        size: 48, color: colorScheme.onSurfaceVariant),
                    const SizedBox(height: 16),
                    Text(
-                      'No books found in this series',
+                      S.of(context)!.noBooksInSeries,
                      style: TextStyle(color: colorScheme.onSurfaceVariant),
                    ),
                  ],
@@ -333,17 +451,32 @@ class _AudiobookSeriesScreenState extends State<AudiobookSeriesScreen> {
            _buildAudiobookSliver(maProvider),

          // Bottom padding for mini player
-          const SliverToBoxAdapter(
+          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) {
-    // If still loading or no books, show placeholder
-    if (_isLoading || _audiobooks.isEmpty) {
+    // 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(
@@ -356,32 +489,23 @@ class _AudiobookSeriesScreenState extends State<AudiobookSeriesScreen> {
      );
    }

-    // Get cover URLs from loaded books
-    final covers = <String>[];
-    for (final book in _audiobooks.take(9)) {
-      final imageUrl = maProvider.getImageUrl(book);
-      if (imageUrl != null) {
-        covers.add(imageUrl);
-      }
+    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;
    }

-    if (covers.isEmpty) {
-      return Container(
-        color: colorScheme.surfaceContainerHighest,
-        child: Center(
-          child: Icon(
-            Icons.collections_bookmark_rounded,
-            size: 64,
-            color: colorScheme.onSurfaceVariant.withOpacity(0.5),
-          ),
-        ),
-      );
-    }
+    // Use series ID to pick consistent colors and nested grid patterns
+    final colorSeed = widget.series.id.hashCode;

-    // Always use 3x3 grid for series detail
-    const int gridSize = 3;
-
-    // Pad covers to fill grid, using empty strings for missing slots
+    // 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];
@@ -397,15 +521,12 @@ class _AudiobookSeriesScreenState extends State<AudiobookSeriesScreen> {
              final coverUrl = displayCovers[index];

              return Expanded(
-                child: Container(
-                  margin: EdgeInsets.only(
-                    right: col < gridSize - 1 ? 1 : 0,
-                    bottom: row < gridSize - 1 ? 1 : 0,
-                  ),
-                  child: coverUrl != null
+                child: coverUrl != null
                      ? CachedNetworkImage(
                          imageUrl: coverUrl,
                          fit: BoxFit.cover,
+                          fadeInDuration: Duration.zero,
+                          fadeOutDuration: Duration.zero,
                          placeholder: (_, __) => Container(
                            color: colorScheme.surfaceContainerHighest,
                          ),
@@ -418,10 +539,62 @@ class _AudiobookSeriesScreenState extends State<AudiobookSeriesScreen> {
                            ),
                          ),
                        )
-                      : Container(
-                          color: colorScheme.surfaceContainerHighest,
-                        ),
-                ),
+                      : _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]),
              );
            }),
          ),
@@ -470,7 +643,7 @@ class _AudiobookSeriesScreenState extends State<AudiobookSeriesScreen> {
    final heroSuffix = 'series_${widget.series.id}';

    return InkWell(
-      onTap: () => _navigateToAudiobook(book, heroTagSuffix: heroSuffix),
+      onTap: () => _navigateToAudiobook(book, heroTagSuffix: heroSuffix, initialImageUrl: imageUrl),
      child: Column(
        crossAxisAlignment: CrossAxisAlignment.start,
        children: [
@@ -490,6 +663,8 @@ class _AudiobookSeriesScreenState extends State<AudiobookSeriesScreen> {
                              fit: BoxFit.cover,
                              width: double.infinity,
                              height: double.infinity,
+                              fadeInDuration: Duration.zero,
+                              fadeOutDuration: Duration.zero,
                              placeholder: (_, __) => Center(
                                child: Icon(
                                  MdiIcons.bookOutline,
@@ -547,7 +722,7 @@ class _AudiobookSeriesScreenState extends State<AudiobookSeriesScreen> {
              ),
            ),
          ),
-          if (book.authorsString.isNotEmpty && book.authorsString != 'Unknown Author')
+          if (book.authorsString.isNotEmpty && book.authorsString != S.of(context)!.unknownAuthor)
            Text(
              book.authorsString,
              style: textTheme.bodySmall?.copyWith(
@@ -583,6 +758,8 @@ class _AudiobookSeriesScreenState extends State<AudiobookSeriesScreen> {
                    ? CachedNetworkImage(
                        imageUrl: imageUrl,
                        fit: BoxFit.cover,
+                        fadeInDuration: Duration.zero,
+                        fadeOutDuration: Duration.zero,
                        placeholder: (_, __) => Icon(
                          MdiIcons.bookOutline,
                          color: colorScheme.onSurfaceVariant,
@@ -629,7 +806,7 @@ class _AudiobookSeriesScreenState extends State<AudiobookSeriesScreen> {
        ),
      ),
      subtitle: Text(
-        book.authorsString.isNotEmpty && book.authorsString != 'Unknown Author'
+        book.authorsString.isNotEmpty && book.authorsString != S.of(context)!.unknownAuthor
            ? book.authorsString
            : book.duration != null
                ? _formatDuration(book.duration!)
@@ -648,17 +825,18 @@ class _AudiobookSeriesScreenState extends State<AudiobookSeriesScreen> {
              ),
            )
          : null,
-      onTap: () => _navigateToAudiobook(book, heroTagSuffix: heroSuffix),
+      onTap: () => _navigateToAudiobook(book, heroTagSuffix: heroSuffix, initialImageUrl: imageUrl),
    );
  }

-  void _navigateToAudiobook(Audiobook book, {String? heroTagSuffix}) {
+  void _navigateToAudiobook(Audiobook book, {String? heroTagSuffix, String? initialImageUrl}) {
    Navigator.push(
      context,
      FadeSlidePageRoute(
        child: AudiobookDetailScreen(
          audiobook: book,
          heroTagSuffix: heroTagSuffix,
+          initialImageUrl: initialImageUrl,
        ),
      ),
    );
@@ -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,
                      ),
@@ -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();
@@ -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();
      },
@@ -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();
      },
@@ -4,7 +4,12 @@ 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 '../constants/hero_tags.dart';
+import '../theme/theme_provider.dart';
+import '../utils/page_transitions.dart';
 import 'playlist_details_screen.dart';
+import '../l10n/app_localizations.dart';
+import '../theme/design_tokens.dart';

 class LibraryPlaylistsScreen extends StatefulWidget {
  const LibraryPlaylistsScreen({super.key});
@@ -29,17 +34,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 +58,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 +73,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,
@@ -107,39 +108,60 @@ class _LibraryPlaylistsScreenState extends State<LibraryPlaylistsScreen> {
    final colorScheme = Theme.of(context).colorScheme;
    final textTheme = Theme.of(context).textTheme;

+    // Unique suffix for this context to avoid hero tag conflicts
+    const heroSuffix = '_playlists';
+
    return RepaintBoundary(
      child: ListTile(
        key: ValueKey(playlist.itemId),
-        leading: Container(
-          width: 48,
-          height: 48,
-          decoration: BoxDecoration(
-            color: colorScheme.surfaceVariant,
+        leading: Hero(
+          tag: HeroTags.playlistCover + (playlist.uri ?? playlist.itemId) + heroSuffix,
+          child: ClipRRect(
            borderRadius: BorderRadius.circular(8),
-            image: imageUrl != null
-                ? DecorationImage(
-                    image: CachedNetworkImageProvider(imageUrl),
-                    fit: BoxFit.cover,
-                  )
-                : null,
+            child: Container(
+              width: 48,
+              height: 48,
+              color: colorScheme.surfaceContainerHighest,
+              child: imageUrl != null
+                  ? CachedNetworkImage(
+                      imageUrl: imageUrl,
+                      fit: BoxFit.cover,
+                      memCacheWidth: 96,
+                      memCacheHeight: 96,
+                      fadeInDuration: Duration.zero,
+                      fadeOutDuration: Duration.zero,
+                      placeholder: (_, __) => const SizedBox(),
+                      errorWidget: (_, __, ___) => Icon(
+                        Icons.playlist_play_rounded,
+                        color: colorScheme.onSurfaceVariant,
+                      ),
+                    )
+                  : Icon(
+                      Icons.playlist_play_rounded,
+                      color: colorScheme.onSurfaceVariant,
+                    ),
+            ),
          ),
-          child: imageUrl == null
-              ? Icon(Icons.playlist_play_rounded, color: colorScheme.onSurfaceVariant)
-              : null,
        ),
-        title: Text(
-          playlist.name,
-          style: textTheme.titleMedium?.copyWith(
-            color: colorScheme.onSurface,
-            fontWeight: FontWeight.w500,
+        title: Hero(
+          tag: HeroTags.playlistTitle + (playlist.uri ?? playlist.itemId) + heroSuffix,
+          child: Material(
+            color: Colors.transparent,
+            child: Text(
+              playlist.name,
+              style: textTheme.titleMedium?.copyWith(
+                color: colorScheme.onSurface,
+                fontWeight: FontWeight.w500,
+              ),
+              maxLines: 1,
+              overflow: TextOverflow.ellipsis,
+            ),
          ),
-          maxLines: 1,
-          overflow: TextOverflow.ellipsis,
        ),
        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),
          ),
@@ -147,16 +169,17 @@ class _LibraryPlaylistsScreenState extends State<LibraryPlaylistsScreen> {
          overflow: TextOverflow.ellipsis,
        ),
        trailing: playlist.favorite == true
-            ? const Icon(Icons.favorite, color: Colors.red, size: 20)
+            ? const Icon(Icons.favorite, color: StatusColors.favorite, size: 20)
            : null,
        onTap: () {
+          updateAdaptiveColorsFromImage(context, imageUrl);
          Navigator.push(
            context,
-            MaterialPageRoute(
-              builder: (context) => PlaylistDetailsScreen(
+            FadeSlidePageRoute(
+              child: PlaylistDetailsScreen(
                playlist: playlist,
-                provider: playlist.provider,
-                itemId: playlist.itemId,
+                heroTagSuffix: 'playlists',
+                initialImageUrl: imageUrl,
              ),
            ),
          );
@@ -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;
    }
@@ -7,6 +7,7 @@ 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 {
@@ -158,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;
    }
@@ -194,7 +195,7 @@ class _LoginScreenState extends State<LoginScreen> {

      if (strategy == null) {
        setState(() {
-          _error = 'Cannot determine authentication requirements. Please check server URL.';
+          _error = S.of(context)!.cannotDetermineAuth;
          _isDetectingAuth = false;
        });
        return;
@@ -230,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';
    }
@@ -260,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;
    }
@@ -270,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;
    }
@@ -292,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;
@@ -324,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;
@@ -350,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;
@@ -384,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;
@@ -408,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;
@@ -442,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
@@ -452,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;
        });
      }
@@ -500,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,
@@ -512,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),
@@ -539,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,
@@ -551,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),
@@ -574,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,
@@ -582,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,
@@ -594,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),
@@ -639,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
@@ -652,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,
@@ -698,8 +711,8 @@ class _LoginScreenState extends State<LoginScreen> {
                          children: [
                            Text(
                              _isTailscaleUrl(_serverUrlController.text)
-                                  ? 'Tailscale VPN Connection'
-                                  : 'Unencrypted Connection',
+                                  ? S.of(context)!.tailscaleVpnConnection
+                                  : S.of(context)!.unencryptedConnection,
                              style: TextStyle(
                                color: _isTailscaleUrl(_serverUrlController.text)
                                    ? colorScheme.onSecondaryContainer
@@ -712,10 +725,10 @@ class _LoginScreenState extends State<LoginScreen> {
                              padding: const EdgeInsets.only(top: 4),
                              child: Text(
                                _isTailscaleUrl(_serverUrlController.text)
-                                    ? 'Using HTTP over Tailscale (encrypted tunnel)'
+                                    ? S.of(context)!.usingHttpOverTailscale
                                    : _usedHttpFallback
-                                        ? 'HTTPS failed, using HTTP fallback'
-                                        : 'HTTP connection - data is not encrypted',
+                                        ? S.of(context)!.httpsFailedUsingHttp
+                                        : S.of(context)!.httpNotEncrypted,
                                style: TextStyle(
                                  color: (_isTailscaleUrl(_serverUrlController.text)
                                      ? colorScheme.onSecondaryContainer
@@ -736,7 +749,7 @@ class _LoginScreenState extends State<LoginScreen> {
                // 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,
@@ -744,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,
@@ -756,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),
@@ -777,7 +790,7 @@ class _LoginScreenState extends State<LoginScreen> {
                ],

                Text(
-                  'Username',
+                  S.of(context)!.username,
                  style: textTheme.titleMedium?.copyWith(
                    color: colorScheme.onBackground,
                    fontWeight: FontWeight.w500,
@@ -790,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),
@@ -810,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,
@@ -822,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),
@@ -912,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,
                            ),
@@ -931,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,
@@ -1,6 +1,7 @@
 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';
@@ -12,6 +13,9 @@ 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/podcast_row.dart';
 import '../widgets/common/disconnected_state.dart';
 import 'settings_screen.dart';
 import 'search_screen.dart';
@@ -34,31 +38,102 @@ class _NewHomeScreenState extends State<NewHomeScreen> with AutomaticKeepAliveCl
  bool _showFavoriteAlbums = false;
  bool _showFavoriteArtists = false;
  bool _showFavoriteTracks = false;
+  bool _showFavoritePlaylists = false;
+  bool _showFavoriteRadioStations = false;
+  bool _showFavoritePodcasts = false;
  // Audiobook rows (default off)
  bool _showContinueListeningAudiobooks = false;
  bool _showDiscoverAudiobooks = false;
  bool _showDiscoverSeries = false;
-  // Random order for favorites (generated once per session)
-  late List<int> _favoritesOrder;
+  // Row order (loaded from settings)
+  List<String> _homeRowOrder = List.from(SettingsService.defaultHomeRowOrder);

  @override
  bool get wantKeepAlive => true;

+  // Track if we had empty favorites on first load (to know when to refresh)
+  bool _hadEmptyFavoritesOnLoad = false;
+  SyncStatus? _lastSyncStatus;
+  int _lastArtistCount = 0;
+  MusicAssistantProvider? _providerListeningTo;
+
  @override
  void initState() {
    super.initState();
    WidgetsBinding.instance.addObserver(this);
-    // Generate random order for favorites rows (0, 1, 2 shuffled)
-    _favoritesOrder = [0, 1, 2]..shuffle();
    _loadSettings();
+    // Listen to sync completion to refresh favorite rows when data becomes available
+    SyncService.instance.addListener(_onSyncChanged);
+    _lastSyncStatus = SyncService.instance.status;
+    _checkInitialFavoriteState();
  }

  @override
  void dispose() {
+    SyncService.instance.removeListener(_onSyncChanged);
+    // Clean up provider listener if attached
+    _providerListeningTo?.removeListener(_onProviderChanged);
+    _providerListeningTo = null;
    WidgetsBinding.instance.removeObserver(this);
    super.dispose();
  }

+  /// Check if favorites are empty on initial load (so we know to refresh after sync)
+  void _checkInitialFavoriteState() {
+    // Schedule after first frame to ensure provider is accessible
+    WidgetsBinding.instance.addPostFrameCallback((_) {
+      if (!mounted) return;
+      final provider = context.read<MusicAssistantProvider>();
+      _lastArtistCount = provider.artists.length;
+      // Check if artists list is empty - favorites will also be empty
+      if (_lastArtistCount == 0) {
+        _hadEmptyFavoritesOnLoad = true;
+        _logger.log('📋 Home: favorites empty on load, will refresh after sync');
+        // Also listen to provider for when cache loads (before sync completes)
+        _providerListeningTo = provider;
+        provider.addListener(_onProviderChanged);
+      }
+    });
+  }
+
+  /// Called when MusicAssistantProvider changes (for cache load detection)
+  void _onProviderChanged() {
+    if (!mounted || !_hadEmptyFavoritesOnLoad || _providerListeningTo == null) return;
+    final currentCount = _providerListeningTo!.artists.length;
+    // If artists went from 0 to non-zero, refresh
+    if (_lastArtistCount == 0 && currentCount > 0) {
+      _logger.log('🔄 Home: artists loaded from cache ($currentCount), refreshing rows');
+      _hadEmptyFavoritesOnLoad = false;
+      _providerListeningTo!.removeListener(_onProviderChanged);
+      _providerListeningTo = null;
+      setState(() {
+        _refreshKey = UniqueKey();
+      });
+    }
+    _lastArtistCount = currentCount;
+  }
+
+  /// Called when SyncService status changes
+  void _onSyncChanged() {
+    final newStatus = SyncService.instance.status;
+    // When sync completes and we had empty favorites, refresh to show new data
+    if (_lastSyncStatus == SyncStatus.syncing &&
+        newStatus == SyncStatus.completed &&
+        _hadEmptyFavoritesOnLoad) {
+      _logger.log('🔄 Home: sync completed, refreshing favorite rows');
+      _hadEmptyFavoritesOnLoad = false;
+      // Clean up provider listener if still attached
+      _providerListeningTo?.removeListener(_onProviderChanged);
+      _providerListeningTo = null;
+      if (mounted) {
+        setState(() {
+          _refreshKey = UniqueKey();
+        });
+      }
+    }
+    _lastSyncStatus = newStatus;
+  }
+
  @override
  void didChangeAppLifecycleState(AppLifecycleState state) {
    // Reload settings when app resumes (coming back from settings)
@@ -74,9 +149,13 @@ 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 showFavPodcasts = await SettingsService.getShowFavoritePodcasts();
    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;
@@ -85,9 +164,13 @@ class _NewHomeScreenState extends State<NewHomeScreen> with AutomaticKeepAliveCl
        _showFavoriteAlbums = showFavAlbums;
        _showFavoriteArtists = showFavArtists;
        _showFavoriteTracks = showFavTracks;
+        _showFavoritePlaylists = showFavPlaylists;
+        _showFavoriteRadioStations = showFavRadio;
+        _showFavoritePodcasts = showFavPodcasts;
        _showContinueListeningAudiobooks = showContAudiobooks;
        _showDiscoverAudiobooks = showDiscAudiobooks;
        _showDiscoverSeries = showDiscSeries;
+        _homeRowOrder = rowOrder;
      });
    }
  }
@@ -179,6 +262,7 @@ class _NewHomeScreenState extends State<NewHomeScreen> with AutomaticKeepAliveCl
            // 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()),
@@ -186,43 +270,47 @@ class _NewHomeScreenState extends State<NewHomeScreen> with AutomaticKeepAliveCl
              );
            }

-            return Column(
+            return Stack(
              children: [
-                // Connecting banner when showing cached data
-                if (!isConnected && syncService.hasCache)
-                  Container(
-                    width: double.infinity,
-                    padding: const EdgeInsets.symmetric(horizontal: 16, vertical: 8),
-                    color: colorScheme.primaryContainer.withOpacity(0.5),
-                    child: Row(
-                      mainAxisAlignment: MainAxisAlignment.center,
-                      children: [
-                        SizedBox(
-                          width: 12,
-                          height: 12,
-                          child: CircularProgressIndicator(
-                            strokeWidth: 2,
-                            color: colorScheme.primary,
+                // 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(
-                          'Connecting...',
-                          style: Theme.of(context).textTheme.bodySmall?.copyWith(
-                            color: colorScheme.onPrimaryContainer,
+                          const SizedBox(width: 8),
+                          Text(
+                            S.of(context)!.connecting,
+                            style: Theme.of(context).textTheme.bodySmall?.copyWith(
+                              color: colorScheme.onPrimaryContainer,
+                            ),
                          ),
-                        ),
-                      ],
+                        ],
+                      ),
                    ),
                  ),
-                Expanded(
-                  child: RefreshIndicator(
-                    onRefresh: _onRefresh,
-                    color: colorScheme.primary,
-                    backgroundColor: colorScheme.surface,
-                    child: _buildConnectedView(context, maProvider),
-                  ),
-                ),
              ],
            );
          },
@@ -232,18 +320,50 @@ class _NewHomeScreenState extends State<NewHomeScreen> with AutomaticKeepAliveCl
  }


+  /// Count how many rows are currently enabled
+  int _countEnabledRows() {
+    int count = 0;
+    for (final rowId in _homeRowOrder) {
+      if (_isRowEnabled(rowId)) count++;
+    }
+    return count;
+  }
+
+  /// Check if a specific row is enabled
+  bool _isRowEnabled(String rowId) {
+    switch (rowId) {
+      case 'recent-albums': return _showRecentAlbums;
+      case 'discover-artists': return _showDiscoverArtists;
+      case 'discover-albums': return _showDiscoverAlbums;
+      case 'continue-listening': return _showContinueListeningAudiobooks;
+      case 'discover-audiobooks': return _showDiscoverAudiobooks;
+      case 'discover-series': return _showDiscoverSeries;
+      case 'favorite-albums': return _showFavoriteAlbums;
+      case 'favorite-artists': return _showFavoriteArtists;
+      case 'favorite-tracks': return _showFavoriteTracks;
+      case 'favorite-playlists': return _showFavoritePlaylists;
+      case 'favorite-radio-stations': return _showFavoriteRadioStations;
+      case 'favorite-podcasts': return _showFavoritePodcasts;
+      default: return false;
+    }
+  }
+
  Widget _buildConnectedView(
      BuildContext context, MusicAssistantProvider provider) {
    // 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);
+        // Account for margins between rows (2px each)
+        // Only adjust for margins when ≤3 rows (so they fit exactly without scroll)
+        // For 4+ rows, use original calculation so 4th row stays hidden (scrollable)
+        const marginSize = 2.0;
+        final enabledRows = _countEnabledRows();
+        final marginsInView = enabledRows > 1 && enabledRows <= 3 ? (enabledRows - 1) * marginSize : 0.0;
+        final rowHeight = (availableHeight - marginsInView) / 3;

        // Use Android 12+ stretch overscroll effect
        return NotificationListener<ScrollNotification>(
@@ -269,64 +389,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,
-                    ),
-
-                  // Continue Listening Audiobooks (optional)
-                  if (_showContinueListeningAudiobooks)
-                    AudiobookRow(
-                      key: const ValueKey('continue-listening-audiobooks'),
-                      title: 'Continue Listening',
-                      loadAudiobooks: () => provider.getInProgressAudiobooks(),
-                      rowHeight: rowHeight,
-                    ),
-
-                  // Discover Audiobooks (optional)
-                  if (_showDiscoverAudiobooks)
-                    AudiobookRow(
-                      key: const ValueKey('discover-audiobooks'),
-                      title: 'Discover Audiobooks',
-                      loadAudiobooks: () => provider.getDiscoverAudiobooks(),
-                      rowHeight: rowHeight,
-                    ),
-
-                  // Discover Series (optional)
-                  if (_showDiscoverSeries)
-                    SeriesRow(
-                      key: const ValueKey('discover-series'),
-                      title: 'Discover Series',
-                      loadSeries: () => provider.getDiscoverSeries(),
-                      rowHeight: rowHeight,
-                    ),
-
-                  // Favorites rows in random order
-                  ...favoritesWidgets,
-                ],
+                children: _buildOrderedRows(provider, rowHeight),
              ),
            ),
          ),
@@ -335,51 +398,135 @@ 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) {
+        // Add spacing between rows (not before first row)
+        if (rows.isNotEmpty) {
+          rows.add(const SizedBox(height: 2.0));
+        }
+        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,
+        );
+      case 'favorite-podcasts':
+        if (!_showFavoritePodcasts) return null;
+        return PodcastRow(
+          key: const ValueKey('favorite-podcasts'),
+          title: S.of(context)!.favoritePodcasts,
+          loadPodcasts: () => provider.getFavoritePodcasts(),
+          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();
  }
 }

@@ -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
+                SliverToBoxAdapter(
+                  child: SizedBox(height: BottomSpacing.withMiniPlayer),
+                ),
+              ],
+            );
+          },
+        ),
+      ),
+    );
+  }
+}
@@ -4,6 +4,8 @@ import '../providers/music_assistant_provider.dart';
 import '../models/player.dart';
 import '../services/debug_logger.dart';
 import '../widgets/common/empty_state.dart';
+import '../widgets/player_picker_sheet.dart';
+import '../l10n/app_localizations.dart';

 class QueueScreen extends StatefulWidget {
  const QueueScreen({super.key});
@@ -51,7 +53,7 @@ class _QueueScreenState extends State<QueueScreen> {
        if (mounted) {
          setState(() {
            _isLoading = false;
-            _error = 'No player selected';
+            _error = S.of(context)!.noPlayerSelected;
          });
        }
      }
@@ -66,6 +68,68 @@ class _QueueScreenState extends State<QueueScreen> {
    }
  }

+  Future<void> _handleTransferQueue(MusicAssistantProvider maProvider) async {
+    final player = maProvider.selectedPlayer;
+    if (player == null) {
+      ScaffoldMessenger.of(context).showSnackBar(
+        SnackBar(content: Text(S.of(context)!.noPlayerSelected)),
+      );
+      return;
+    }
+
+    // Get available players, excluding the current source player
+    final allPlayers = maProvider.availablePlayers;
+    final targetPlayers = allPlayers
+        .where((p) => p.playerId != player.playerId && p.available)
+        .toList();
+
+    if (targetPlayers.isEmpty) {
+      ScaffoldMessenger.of(context).showSnackBar(
+        const SnackBar(
+          content: Text('No other players available to transfer to'),
+          duration: Duration(seconds: 2),
+        ),
+      );
+      return;
+    }
+
+    // Show player picker sheet
+    await showPlayerPickerSheet(
+      context: context,
+      title: 'Transfer Queue To',
+      players: targetPlayers,
+      onPlayerSelected: (targetPlayer) async {
+        try {
+          await maProvider.api?.transferQueue(
+            sourceQueueId: player.playerId,
+            targetQueueId: targetPlayer.playerId,
+            autoPlay: true,
+          );
+
+          if (mounted) {
+            ScaffoldMessenger.of(context).showSnackBar(
+              SnackBar(
+                content: Text('Queue transferred to ${targetPlayer.name}'),
+                duration: const Duration(seconds: 2),
+              ),
+            );
+          }
+        } catch (e) {
+          _logger.log('Error transferring queue: $e');
+          if (mounted) {
+            ScaffoldMessenger.of(context).showSnackBar(
+              SnackBar(
+                content: Text('Failed to transfer queue: $e'),
+                backgroundColor: Colors.red.shade700,
+                duration: const Duration(seconds: 3),
+              ),
+            );
+          }
+        }
+      },
+    );
+  }
+
  @override
  Widget build(BuildContext context) {
    final maProvider = context.watch<MusicAssistantProvider>();
@@ -77,7 +141,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,
@@ -86,6 +150,11 @@ class _QueueScreenState extends State<QueueScreen> {
        ),
        centerTitle: true,
        actions: [
+          IconButton(
+            icon: const Icon(Icons.swap_horiz_rounded),
+            tooltip: 'Transfer queue',
+            onPressed: () => _handleTransferQueue(maProvider),
+          ),
          IconButton(
            icon: const Icon(Icons.refresh),
            onPressed: _loadQueue,
@@ -116,7 +185,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 +200,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 +209,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 +217,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 +289,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);
@@ -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();
+  }
 }
@@ -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';
@@ -86,6 +87,23 @@ class AuthManager {
    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 {
@@ -176,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}');
@@ -253,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;
      }

@@ -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');
+    }
+  }
 }
@@ -156,4 +156,159 @@ class DatabaseService {

  /// 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;
+  }
 }
@@ -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');
+  }
 }
@@ -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();
  }
 }
@@ -326,120 +326,301 @@ class MetadataService {
    return null;
  }

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

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

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

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

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

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

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

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

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

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

    // Cache the null result to avoid repeated failed lookups
@@ -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';
+}
@@ -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) {
@@ -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
@@ -25,6 +25,8 @@ class RecentlyPlayedService {
    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',
@@ -33,6 +35,7 @@ class RecentlyPlayedService {
        metadata: {
          'provider': album.provider,
          'uri': album.uri,
+          if (images != null) 'images': images,
        },
      );
      _logger.log('📝 Recorded album play: ${album.name}');
@@ -148,7 +151,16 @@ class RecentlyPlayedService {
        if (item.metadata != null) {
          try {
            metadata = jsonDecode(item.metadata!) as Map<String, dynamic>;
-          } catch (_) {}
+          } 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(
@@ -160,6 +172,7 @@ class RecentlyPlayedService {
          artists: item.artistName != null
              ? [Artist(itemId: '', provider: '', name: item.artistName!)]
              : null,
+          metadata: albumMetadata,
        ));

        if (albums.length >= limit) break;
@@ -193,7 +206,10 @@ class RecentlyPlayedService {
        if (item.metadata != null) {
          try {
            metadata = jsonDecode(item.metadata!) as Map<String, dynamic>;
-          } catch (_) {}
+          } catch (e) {
+            // Corrupted metadata JSON - log and continue with null metadata
+            _logger.log('⚠️ Error parsing audiobook metadata for ${item.mediaId}: $e');
+          }
        }

        audiobooks.add(Audiobook(
@@ -0,0 +1,211 @@
+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 {
+    try {
+      return await _storage.read(key: _keyAuthToken);
+    } catch (e) {
+      // Handle decryption errors (e.g., after keystore/signature change)
+      if (e.toString().contains('BadPaddingException') ||
+          e.toString().contains('BAD_DECRYPT')) {
+        await _storage.delete(key: _keyAuthToken);
+        return null;
+      }
+      rethrow;
+    }
+  }
+
+  static Future<void> setAuthToken(String? token) async {
+    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 {
+    try {
+      return await _storage.read(key: _keyMaAuthToken);
+    } catch (e) {
+      // Handle decryption errors (e.g., after keystore/signature change)
+      if (e.toString().contains('BadPaddingException') ||
+          e.toString().contains('BAD_DECRYPT')) {
+        await _storage.delete(key: _keyMaAuthToken);
+        return null;
+      }
+      rethrow;
+    }
+  }
+
+  static Future<void> setMaAuthToken(String? token) async {
+    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 {
+    String? json;
+    try {
+      json = await _storage.read(key: _keyAuthCredentials);
+    } catch (e) {
+      // Handle decryption errors (e.g., after keystore/signature change)
+      if (e.toString().contains('BadPaddingException') ||
+          e.toString().contains('BAD_DECRYPT')) {
+        await _storage.delete(key: _keyAuthCredentials);
+        return null;
+      }
+      rethrow;
+    }
+    if (json == null) return null;
+    try {
+      return jsonDecode(json) as Map<String, dynamic>;
+    } 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 {
+    try {
+      return await _storage.read(key: _keyPassword);
+    } catch (e) {
+      // Handle decryption errors (e.g., after keystore/signature change)
+      if (e.toString().contains('BadPaddingException') ||
+          e.toString().contains('BAD_DECRYPT')) {
+        await _storage.delete(key: _keyPassword);
+        return null;
+      }
+      rethrow;
+    }
+  }
+
+  static Future<void> setPassword(String? password) async {
+    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 {
+    try {
+      return await _storage.read(key: _keyAbsApiToken);
+    } catch (e) {
+      // Handle decryption errors (e.g., after keystore/signature change)
+      if (e.toString().contains('BadPaddingException') ||
+          e.toString().contains('BAD_DECRYPT')) {
+        await _storage.delete(key: _keyAbsApiToken);
+        return null;
+      }
+      rethrow;
+    }
+  }
+
+  static Future<void> setAbsApiToken(String? token) async {
+    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();
+  }
+
+  // Migration completed flag key
+  static const String _keyMigrationCompleted = 'secure_storage_migration_completed';
+
+  /// Migrate credentials from SharedPreferences to secure storage.
+  /// Call this once during app upgrade to migrate existing users.
+  /// Uses a flag to skip migration on subsequent runs for performance.
+  static Future<void> migrateFromSharedPreferences() async {
+    // Import SharedPreferences for migration
+    final SharedPreferences prefs = await SharedPreferences.getInstance();
+
+    // Skip if migration already completed
+    if (prefs.getBool(_keyMigrationCompleted) == true) {
+      return;
+    }
+
+    // Migrate auth token
+    final authToken = prefs.getString('auth_token');
+    if (authToken != null && authToken.isNotEmpty) {
+      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');
+    }
+
+    // Mark migration as completed to skip on future runs
+    await prefs.setBool(_keyMigrationCompleted, true);
+  }
+}
@@ -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);
  }
@@ -5,6 +5,7 @@ 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 {
@@ -118,7 +119,8 @@ class SyncService with ChangeNotifier {

  /// Sync library data from MA API in background
  /// Updates database cache and notifies listeners when complete
-  Future<void> syncFromApi(MusicAssistantAPI api, {bool force = false}) async {
+  /// If provider is specified, only fetch items from that provider (server-side filtering)
+  Future<void> syncFromApi(MusicAssistantAPI api, {bool force = false, String? provider}) async {
    if (_isSyncing) {
      _logger.log('🔄 Sync already in progress, skipping');
      return;
@@ -148,12 +150,17 @@ class SyncService with ChangeNotifier {
    notifyListeners();

    try {
-      _logger.log('🔄 Starting background library sync...');
+      _logger.log('🔄 Starting background library sync (provider=$provider)...');
+
+      // Read artist filter setting - when ON, only fetch artists that have albums
+      final showOnlyArtistsWithAlbums = await SettingsService.getShowOnlyArtistsWithAlbums();
+      _logger.log('🎨 Sync using albumArtistsOnly: $showOnlyArtistsWithAlbums, provider: $provider');

      // Fetch fresh data from MA API (in parallel for speed)
+      // If provider is specified, filter to only that provider's library items
      final results = await Future.wait([
-        api.getAlbums(limit: 1000),
-        api.getArtists(limit: 1000),
+        api.getAlbums(limit: 1000, provider: provider),
+        api.getArtists(limit: 1000, albumArtistsOnly: showOnlyArtistsWithAlbums, provider: provider),
        api.getAudiobooks(limit: 1000),
        api.getPlaylists(limit: 1000),
      ]);
@@ -166,6 +173,12 @@ class SyncService with ChangeNotifier {
      _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);
@@ -262,11 +275,12 @@ class SyncService with ChangeNotifier {
  }

  /// Force a fresh sync (for pull-to-refresh)
-  Future<void> forceSync(MusicAssistantAPI api) async {
-    await syncFromApi(api, force: true);
+  Future<void> forceSync(MusicAssistantAPI api, {String? provider}) async {
+    await syncFromApi(api, force: true, provider: provider);
  }

-  /// Clear all cached data
+  /// Clear all cached data and reset sync state
+  /// This allows a fresh sync to start even if one was in progress
  Future<void> clearCache() async {
    if (!_db.isInitialized) return;

@@ -276,9 +290,10 @@ class SyncService with ChangeNotifier {
    _cachedAudiobooks = [];
    _cachedPlaylists = [];
    _lastSyncTime = null;
+    _isSyncing = false;  // Reset so a new sync can start
    _status = SyncStatus.idle;
    notifyListeners();
-    _logger.log('🗑️ Library cache cleared');
+    _logger.log('🗑️ Library cache cleared (sync state reset)');
  }

  /// Get albums (from cache or empty if not loaded)
@@ -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}) {
@@ -124,3 +124,51 @@ class Durations {
  static const Duration normal = Duration(milliseconds: 300);
  static const Duration slow = Duration(milliseconds: 500);
 }
+
+/// Button size tokens
+class ButtonSizes {
+  ButtonSizes._();
+
+  // Touch target sizes (Material Design minimum: 48x48)
+  static const double sm = 32.0;
+  static const double md = 36.0;
+  static const double lg = 44.0;
+  static const double xl = 48.0;
+  static const double xxl = 56.0;
+
+  // Icon sizes within buttons
+  static const double iconSm = 16.0;
+  static const double iconMd = 18.0;
+  static const double iconLg = 20.0;
+  static const double iconXl = 24.0;
+}
+
+/// Semantic status colors for consistent feedback
+/// Use with Theme brightness for proper contrast
+class StatusColors {
+  StatusColors._();
+
+  // Success states
+  static const Color success = Color(0xFF4CAF50);
+  static const Color successLight = Color(0xFF81C784);
+  static const Color successDark = Color(0xFF388E3C);
+
+  // Error states
+  static const Color error = Color(0xFFF44336);
+  static const Color errorLight = Color(0xFFE57373);
+  static const Color errorDark = Color(0xFFD32F2F);
+
+  // Warning states
+  static const Color warning = Color(0xFFFF9800);
+  static const Color warningLight = Color(0xFFFFB74D);
+  static const Color warningDark = Color(0xFFF57C00);
+
+  // Info states
+  static const Color info = Color(0xFF2196F3);
+  static const Color infoLight = Color(0xFF64B5F6);
+  static const Color infoDark = Color(0xFF1976D2);
+
+  // Favorites (heart icon)
+  static const Color favorite = Color(0xFFF44336);
+  static const Color favoriteActive = Color(0xFFE53935);
+}
@@ -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();
  }
 }
@@ -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;
+  }
+}
@@ -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;
+  }
+}
@@ -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();
+}
@@ -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;
+  }
+}
@@ -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());
+  }
+}
--- a/Show More
+++ b/Show More