perf: swap SpotubeDL as primary YouTube provider, Cobalt as fallback

chore: bump app_info version to 3.6.0+77
feat: save cover art, save lyrics, re-enrich metadata with full SAF support + YouTube Cobalt provider with SpotubeDL fallback + metadata summary logging
2026-07-03 11:18:04 +02:00 · 2026-02-10 00:47:44 +07:00 · 2026-02-09 23:36:34 +07:00 · 2026-02-09 23:07:18 +07:00 · 2026-02-09 18:15:43 +07:00 · 2026-02-09 15:58:50 +07:00
155 changed files with 53386 additions and 15153 deletions
@@ -15,7 +15,7 @@ jobs:
    
    steps:
      - name: Checkout repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6
        with:
          fetch-depth: 2  # Need previous commit to compare

@@ -60,23 +60,23 @@ jobs:
          df -h

      - name: Checkout repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6

      - name: Setup Java
-        uses: actions/setup-java@v4
+        uses: actions/setup-java@v5
        with:
          distribution: "temurin"
          java-version: "17"

      - name: Setup Go
-        uses: actions/setup-go@v5
+        uses: actions/setup-go@v6
        with:
-          go-version: "1.21"
+          go-version: "1.25"
          cache-dependency-path: go_backend/go.sum

      # Cache Gradle for faster builds
      - name: Cache Gradle
-        uses: actions/cache@v4
+        uses: actions/cache@v5
        with:
          path: |
            ~/.gradle/caches
@@ -158,7 +158,7 @@ jobs:
          ls -la

      - name: Upload APK artifact
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v6
        with:
          name: android-apk
          path: build/app/outputs/flutter-apk/SpotiFLAC-*.apk
@@ -169,17 +169,17 @@ jobs:

    steps:
      - name: Checkout repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6

      - name: Setup Go
-        uses: actions/setup-go@v5
+        uses: actions/setup-go@v6
        with:
-          go-version: "1.21"
+          go-version: "1.25"
          cache-dependency-path: go_backend/go.sum

      # Cache CocoaPods
      - name: Cache CocoaPods
-        uses: actions/cache@v4
+        uses: actions/cache@v5
        with:
          path: ios/Pods
          key: pods-${{ runner.os }}-${{ hashFiles('ios/Podfile.lock') }}
@@ -194,7 +194,7 @@ jobs:
        working-directory: go_backend
        run: |
          mkdir -p ../ios/Frameworks
-          gomobile bind -target=ios -o ../ios/Frameworks/Gobackend.xcframework .
+          gomobile bind -target=ios -tags ios -o ../ios/Frameworks/Gobackend.xcframework .
        env:
          CGO_ENABLED: 1

@@ -249,23 +249,6 @@ jobs:
          channel: "stable"
          cache: true

-      # Swap pubspec for iOS build (includes ffmpeg_kit_flutter)
-      - name: Use iOS pubspec with FFmpeg plugin
-        run: |
-          cp pubspec.yaml pubspec_android_backup.yaml
-          cp pubspec_ios.yaml pubspec.yaml
-          echo "Swapped to iOS pubspec with ffmpeg_kit_flutter"
-
-      # Swap FFmpeg service for iOS
-      - name: Use iOS FFmpeg service
-        run: |
-          cp lib/services/ffmpeg_service.dart lib/services/ffmpeg_service_android.dart
-          cp build_assets/ffmpeg_service_ios.dart lib/services/ffmpeg_service.dart
-          # Update class name in the swapped file
-          sed -i '' 's/FFmpegServiceIOS/FFmpegService/g' lib/services/ffmpeg_service.dart
-          sed -i '' 's/FFmpegResultIOS/FFmpegResult/g' lib/services/ffmpeg_service.dart
-          echo "Swapped to iOS FFmpeg service"
-
      - name: Get Flutter dependencies
        run: flutter pub get

@@ -312,7 +295,7 @@ jobs:
          fi

      - name: Upload IPA artifact
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v6
        with:
          name: ios-ipa
          path: build/ios/ipa/SpotiFLAC-*.ipa
@@ -325,7 +308,7 @@ jobs:

    steps:
      - name: Checkout repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6

      - name: Extract changelog for version
        id: changelog
@@ -355,13 +338,13 @@ jobs:
          cat /tmp/changelog.txt

      - name: Download Android APK
-        uses: actions/download-artifact@v4
+        uses: actions/download-artifact@v7
        with:
          name: android-apk
          path: ./release

      - name: Download iOS IPA
-        uses: actions/download-artifact@v4
+        uses: actions/download-artifact@v7
        with:
          name: ios-ipa
          path: ./release
@@ -402,7 +385,7 @@ jobs:
          cat /tmp/release_body.txt

      - name: Create Release
-        uses: softprops/action-gh-release@v1
+        uses: softprops/action-gh-release@v2
        with:
          tag_name: ${{ needs.get-version.outputs.version }}
          name: SpotiFLAC ${{ needs.get-version.outputs.version }}
@@ -420,16 +403,16 @@ jobs:

    steps:
      - name: Checkout repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6

      - name: Download Android APK
-        uses: actions/download-artifact@v4
+        uses: actions/download-artifact@v7
        with:
          name: android-apk
          path: ./release

      - name: Download iOS IPA
-        uses: actions/download-artifact@v4
+        uses: actions/download-artifact@v7
        with:
          name: ios-ipa
          path: ./release
@@ -441,7 +424,11 @@ jobs:
          VERSION_NUM=${VERSION#v}

          # Extract changelog, limit to ~2500 chars for Telegram (4096 limit minus message overhead)
-          FULL_CHANGELOG=$(sed -n "/^## \[$VERSION_NUM\]/,/^## \[/{ /^## \[$VERSION_NUM\]/d; /^## \[/d; p; }" CHANGELOG.md | sed '/^---$/d')
+          # Use tr -d '\r' to handle CRLF line endings from Windows
+          FULL_CHANGELOG=$(cat CHANGELOG.md | tr -d '\r' | sed -n "/^## \[$VERSION_NUM\]/,/^## \[/{ /^## \[$VERSION_NUM\]/d; /^## \[/d; p; }" | sed '/^---$/d')
+          
+          echo "DEBUG: Extracted changelog length: ${#FULL_CHANGELOG}"
+          echo "DEBUG: First 200 chars: ${FULL_CHANGELOG:0:200}"
          
          if [ -z "$FULL_CHANGELOG" ]; then
            CHANGELOG="See release notes on GitHub for details."
@@ -451,7 +438,9 @@ jobs:
            # - `code` → <code>code</code>
            # - ### Header → <b>Header</b>
            # - Escape HTML special chars first
+            # - Remove > blockquote prefix
            CHANGELOG=$(echo "$FULL_CHANGELOG" | \
+              sed 's/^> //' | \
              sed 's/&/\&amp;/g' | \
              sed 's/</\&lt;/g' | \
              sed 's/>/\&gt;/g' | \
@@ -473,6 +462,8 @@ jobs:
          fi

          echo "$CHANGELOG" > /tmp/changelog.txt
+          echo "DEBUG: Final changelog:"
+          cat /tmp/changelog.txt

      - name: Send to Telegram Channel
        env:
@@ -499,11 +490,13 @@ jobs:
          MESSAGE=$(cat /tmp/telegram_message.txt)

          # Send message first (using HTML parse mode)
+          # Use --data-urlencode for proper encoding of special chars (+, &, etc.)
+          # Use || true to ensure file uploads continue even if message fails
          curl -s -X POST "https://api.telegram.org/bot${TELEGRAM_BOT_TOKEN}/sendMessage" \
-            -d chat_id="${TELEGRAM_CHANNEL_ID}" \
-            -d text="${MESSAGE}" \
-            -d parse_mode="HTML" \
-            -d disable_web_page_preview="true"
+            --data-urlencode "chat_id=${TELEGRAM_CHANNEL_ID}" \
+            --data-urlencode "text=${MESSAGE}" \
+            --data-urlencode "parse_mode=HTML" \
+            --data-urlencode "disable_web_page_preview=true" || true

          # Upload arm64 APK to channel
          if [ -f "$ARM64_APK" ]; then
@@ -72,3 +72,4 @@ flutter_*.log

 # Development tools
 tool/
+.claude/settings.local.json
@@ -1,5 +1,429 @@
 # Changelog

+## [3.6.0] - 2026-02-09
+
+### Highlights
+
+- **YouTube Provider (Lossy)**: New download option via Cobalt API for tracks not available on lossless services
+  - Opus 256kbps (recommended) or MP3 320kbps quality options
+  - Full metadata embedding: cover art, title, artist, album, track/disc number, year, ISRC
+  - Lyrics fetching from lrclib.net with embed and external .lrc support
+  - Works as fallback when Tidal/Qobuz/Amazon downloads fail
+- **Edit Metadata**: Edit embedded metadata directly from the Track Metadata screen (FLAC, MP3, Opus)
+  - Editable fields: Title, Artist, Album, Album Artist, Date, Track#, Disc#, Genre, ISRC
+  - Advanced fields: Label, Copyright, Composer, Comment
+  - FLAC: native Go writer, MP3/Opus: FFmpeg-based writer
+  - UI refreshes in-place after save without needing to re-open the screen
+  - iOS and Android support
+
+### Added
+
+- Save Cover Art: download high-quality album art as standalone .jpg from track metadata screen
+- Save Lyrics (.lrc): fetch and save lyrics as standalone .lrc file without downloading the song
+- Re-enrich Metadata: re-embed metadata, cover art, and lyrics into existing audio files without re-downloading (FLAC native, MP3/Opus via FFmpeg)
+- Re-enrich now supports local library items: searches Spotify/Deezer by track name + artist to fetch complete metadata from the internet, then embeds cover art, lyrics, genre, label, and all tags into the file
+- YouTube download provider using Cobalt API with SongLink/Odesli integration for Spotify/Deezer ID → YouTube URL conversion
+- SpotubeDL as fallback Cobalt proxy when primary API fails
+- YouTube video ID detection for YT Music extension compatibility
+- Parallel cover art and lyrics fetching during YouTube download
+- Queue progress now shows "X.X MB" instead of "0%" for streaming downloads where total size is unknown (Cobalt tunnel mode)
+- Full metadata pipeline for YouTube downloads: cover art, lyrics, title, artist, album, track#, disc#, year, ISRC
+
+### Changed
+
+- Removed Tidal HIGH (lossy AAC) quality option - use YouTube provider for lossy downloads instead
+- Simplified download service picker by removing dead lossy format code
+- Removed Amazon from download settings UI (now only used as automatic fallback)
+- Cleaned up dead disabled-chip code in download service selector
+
+### Fixed
+
+- Fixed `error.api.youtube.login` by using YouTube Music URLs instead of regular YouTube URLs for Cobalt requests
+- Fixed SongLink to prioritize `youtubeMusic` platform URL over `youtube` for Cobalt compatibility
+- Fixed YouTube metadata not being overwritten by setting `DisableMetadata: true` in Cobalt requests
+- Fixed ISRC validation in metadata enrichment flow - invalid ISRCs no longer trigger failed Deezer lookups
+- Fixed YouTube metadata enrichment to work like other providers (SongLink Deezer ID extraction, proper metadata embedding)
+- Go metadata parsers now read Composer, Comment, Label, Copyright from FLAC, MP3 (ID3v2.2/v2.3/v2.4), and Opus/OGG files
+- Added proper COMM frame parser for ID3v2 (handles language code + description prefix correctly)
+- Fixed Re-enrich Metadata failing on SAF storage files (`content://` URIs) - Kotlin now copies SAF file to temp, Go processes temp file, then writes back for FLAC or returns temp path for FFmpeg (MP3/Opus)
+- Fixed Save Cover Art and Save Lyrics crashing on SAF-stored download history items - now saves to temp then writes to SAF tree via `createSafFileFromPath`
+- Fixed `_getFileDirectory()` crash when called with `content://` URI by adding SAF guard
+- Fixed `readAudioMetadata` Kotlin handler not handling SAF URIs - now copies to temp for reading
+- Added metadata summary log in Re-enrich flow showing all fields before embedding (title, artist, album, track#, disc#, date, ISRC, genre, label)
+
+---
+
+## [3.5.3] - 2026-02-09
+
+### Added
+
+- CSV import flow now includes a new option: **Skip already downloaded songs** before enqueueing tracks
+- Added regression test suite for cross-script matching behavior in Go backend (`go_backend/matching_test.go`)
+
+### Changed
+
+- CSV import confirmation dialog now supports filtering out tracks already present in download history (matched by Spotify ID and ISRC)
+- CSV import enqueue feedback now reports added/skipped counts when duplicate downloads are skipped
+- Home search now prioritizes **Recent Access** when search field is focused with empty input, even if old search results still exist in memory
+- Search filter/result sections are now hidden while Recent Access mode is active to avoid stale-result overlap
+- Recent Access now shows a localized empty-state message when no recent items are available
+- Normalized collapsing AppBar top inset across iOS/Android so header height/animation stays visually consistent on Apple devices
+- Storage & Cache UX improved: `Clear all cache` now preserves web/runtime cache by default (optional), with explicit warnings/actions for runtime cache resets
+- Local library settings now include a display count for tracks excluded because they already exist in download history
+- Responsive layout tuning applied across key screens to reduce hardcoded-height overflow issues on smaller devices
+
+### Fixed
+
+- Fixed false-positive cross-script matching in Qobuz/Tidal where unrelated titles/artists in different scripts could be incorrectly accepted
+- Cross-script title/artist matching now requires transliteration-aware normalization and strict similarity checks instead of auto-accepting script differences
+- Qobuz metadata fallback no longer scans all results when zero title matches are found; title verification is now required
+- Qobuz metadata final validation now rejects results when title does not match expected track name
+- Fixed Home search regression where Recent Access panel could disappear after previous searches
+- Fixed Local Library card/layout crash caused by `Flex` usage under unbounded height constraints
+- Hardened FFmpeg metadata embedding temp-file naming to prevent rare collisions during parallel downloads/fallback flows (Qobuz → Tidal) that could cause missing embedded metadata
+- Fixed SAF external lyrics naming where some providers saved `.lrc` files as `.lrc.txt`; LRC export now uses neutral MIME to preserve `.lrc` extension
+
+## [3.5.2] - 2026-02-08
+
+### Performance
+
+- Home tab search result sections are now virtualized with `SliverList` (lazy item build) instead of eager `Column` rendering, reducing frame drops on large result sets
+- Home tab now narrows Riverpod subscriptions using field-level `select(...)` for search/provider state to reduce unnecessary full-tab rebuilds
+- Search provider dropdown now watches only required fields (`searchProvider`, `metadataSource`, `extensions`) instead of full provider states
+- Track row rendering in Home search now receives precomputed thumbnail sizing/local-library flags from parent to avoid repeated per-item provider watches
+- Removed thumbnail `debugPrint` calls inside track row `build()` to reduce runtime overhead during scrolling/rebuilds
+- Queue tab root subscription no longer watches full queue item list; it now watches only queue presence (`items.isNotEmpty`) to avoid full Library UI rebuilds on every progress tick
+- Queue download header/list rendering has been isolated into dedicated `Consumer` slivers; header now watches only queue length (`items.length`) while item list watches queue item updates
+- Queue filter/sort computations are now centralized and memoized per filter mode within a build pass (`all`/`albums`/`singles`), reducing repeated list transforms for chip counts and page content
+- Selection bottom bar content is now computed only when selection mode is active, removing hidden-state heavy list preparation
+- File existence checks in queue/library rows now use per-path `ValueNotifier` + `ValueListenableBuilder` updates instead of triggering global `setState`, reducing unnecessary whole-tab repaints
+
+### Changed
+
+- Replaced date range filter with sorting options in Library tab: Latest, Oldest, A-Z, Z-A
+- Sorting applies to all views: unified items, downloaded albums, and local library albums
+- Local library items now use file modification time (`fileModTime`) for sorting instead of scan time, providing more accurate chronological ordering
+- Removed redundant manual "Export Failed Downloads" button from Library UI (auto-export setting in Settings is sufficient)
+- Library filters (quality, format, source) now correctly apply to album tabs and update tab chip counts (All/Albums/Singles)
+
+### Fixed
+
+- Fixed local library scan crashing on Samsung One UI devices due to MediaStore URI mismatch in SAF tree traversal
+- Added MediaStore URI fallback in SAF file reader: when SAF permission is denied for Samsung-returned MediaStore URIs, automatically retries using READ_MEDIA_AUDIO permission
+- Hardened SAF scan with per-directory and per-file error handling: scan now skips problematic files instead of aborting entirely
+- Added visited directory tracking to prevent infinite loops from circular SAF references
+- Fixed metadata enrichment cascading failure after one queued download fails: metadata APIs (Deezer, SongLink, Spotify) now use isolated `metadataTransport` so failed download connections cannot poison metadata requests
+- Added immediate connection cleanup on every download failure path (error response and exception), not only periodic cleanup every N downloads
+- Fixed incremental SAF scan edge case where `lastModified()` failure could misclassify existing files as removed (`removedUris`)
+- Fixed tracks marked "In Library" still showing active download button - download button now shows as completed (checkmark) for local library tracks across all screens (album, playlist, artist, home/search)
+- Fixed FFmpeg M4A-to-FLAC conversion erroneously triggered on already-existing FLAC files when re-downloading duplicates via Tidal
+- Fixed SAF download creating empty artist/album folders when re-downloading duplicate tracks; directory is now only created after confirming the file does not already exist
+
+## [3.5.1] - 2026-02-08
+
+### Performance
+
+- Removed PaletteService (palette_generator) from all screens for faster navigation and reduced memory usage
+- Album, Playlist, Downloaded Album, Local Album, and Track Metadata screens now use blurred cover art as header background instead of dominant color extraction
+- Removed `palette_generator` dependency
+- App startup now renders immediately (`runApp`) while service initialization runs asynchronously in eager init
+- Main shell provider subscriptions now use field-level `select(...)` to reduce unnecessary rebuilds
+- Settings persistence now uses single-flight + queued save coalescing to avoid redundant disk writes
+- Progress polling cadence adjusted to 800ms for download queue, local library scan progress, and Go log polling
+- Android foreground download service progress updates are throttled (change-based updates + 5s heartbeat)
+- SAF history repair is now batched (`20` items per batch) and capped per launch (`60`) to reduce startup I/O spikes
+- Incremental library scan now builds final item list in-memory instead of reloading from database
+- Local cover images in queue/library use direct `Image.file` with `errorBuilder` instead of `FutureBuilder` existence check
+- CSV parser `_parseLine` rewritten: correct escaped-quote handling, no quote characters in output
+- Removed unused legacy screen files (`home_screen.dart`, `queue_screen.dart`, `settings_screen.dart`, `settings_tab.dart`)
+- Incremental local library scan now merges delta results in-memory and sorts once, avoiding full-state reload churn
+- Queue local cover rendering now uses direct `Image.file` + `errorBuilder` (removed repeated async file-exists checks)
+
+### Added
+
+- Auto-cleanup orphaned downloads on history load (files that no longer exist are automatically removed from history)
+
+### Changed
+
+- Removed legacy screen files that were no longer used after the tab/part refactor:
+  - `lib/screens/home_screen.dart`
+  - `lib/screens/queue_screen.dart`
+  - `lib/screens/settings_screen.dart`
+  - `lib/screens/settings_tab.dart`
+- Concurrent download limit increased from `3` to `5` (settings clamp + Options UI chips now support `1..5`)
+- Download queue now uses a single parallel scheduler path; `1` concurrency is handled as parallel-with-limit-1 (no separate sequential engine)
+- Download queue now listens to settings updates in real-time so concurrency/output settings stay in sync while queue is active
+
+### Fixed
+
+- CSV parser now correctly handles escaped quotes (`""`) inside quoted fields during import
+- Fixed dynamic concurrency update during active downloads: changing limit (e.g. `1 -> 3`) now schedules additional queued items without waiting current active item to finish
+- Queue scheduler now re-checks capacity/queued items on short intervals to avoid blocking on long-running single active download
+
+### Dependencies
+
+#### Flutter
+- `flutter_local_notifications` 19.x → 20.0.0 (breaking: all positional params converted to named params)
+- `connectivity_plus` 6.x → 7.0.0
+- `flutter_secure_storage` 9.x → 10.0.0
+- Removed `palette_generator` dependency
+
+#### Go
+- `go-flac/go-flac` v1.0.0 → v2.0.4
+- `go-flac/flacvorbis` v0.2.0 → v2.0.2
+- `go-flac/flacpicture` v0.3.0 → v2.0.2
+- Go toolchain 1.24 → 1.25.7
+
+#### Android
+- Android Gradle Plugin 8.x → 9.0.0
+- Kotlin 2.1.x → 2.3.10
+- `desugar_jdk_libs` → 2.1.5
+- `kotlinx-coroutines-android` → 1.10.2
+- `lifecycle-runtime-ktx` → 2.10.0
+- `activity-ktx` → 1.12.3
+
+#### CI/CD
+- `actions/cache` v4 → v5
+- `actions/checkout` v4 → v6
+- `actions/setup-go` v5 → v6
+- `actions/setup-java` v4 → v5
+- `softprops/action-gh-release` v1 → v2
+- GitHub artifact actions updated
+
+---
+
+## [3.5.0] - 2026-02-07
+
+### Highlights
+
+- **SAF Storage (Android 10+)**: Proper Storage Access Framework support for download destination (content URIs)
+  - Select download folder via SAF tree picker
+  - Downloads now write to SAF file descriptors (`/proc/self/fd/*`) instead of raw filesystem paths
+  - Works around Android 10+ scoped storage permission errors
+- **Modern Onboarding Experience**: Completely redesigned Setup and Tutorial screens
+
+### Added
+
+- Home feed disk caching via SharedPreferences for instant restore on app startup
+- SAF display path resolver in native Android layer (converts tree URIs to readable paths)
+- New settings fields for storage mode + SAF tree URI
+- SAF platform bridge methods: pick tree, stat/exists/delete, open content URI, copy to temp, write back to SAF
+- SAF library scan mode (DocumentFile traversal + metadata read)
+- Incremental library scanning for filesystem and SAF paths (only scans new/modified files and detects removed files)
+- Force Full Scan action in Library Settings to rescan all files on demand
+- Downloaded files are now excluded from Local Library scan results to prevent duplicate entries
+- Legacy library rows now support `file_mod_time` backfill before incremental scans (faster follow-up scans after upgrade)
+- Library UI toggle to show SAF-repaired history items
+- Scan cancelled banner + retry action for library scans
+- Android DocumentFile dependency for SAF operations
+- Post-processing API v2 (SAF-aware, ready to replace v1)
+- Donate page in Settings with Ko-fi and Buy Me a Coffee links
+- Per-App Language support on Android 13+ (locale_config.xml)
+- Interactive tutorial with working search bar simulation and clickable download buttons
+- Tutorial completion state is persisted after onboarding
+- Visual feedback animations for page transitions, entrance effects, and feature lists
+- New dedicated welcome step in setup wizard with improved branding
+
+### Changed
+
+- Download pipeline supports `output_path` + `output_ext` for Go backend
+- Tidal/Qobuz/Amazon/Extension downloads use SAF-aware output when enabled
+- Post-processing hooks run for SAF content URIs (via temp file bridge)
+- File operations in Library/Queue/Track screens now SAF-aware (`open`, `exists`, `delete`, `stat`)
+- Local Library scan defaults to incremental mode; full rescan is available via Force Full Scan
+- Local library database upgraded to schema v3 with `file_mod_time` tracking for incremental scan cache
+- Platform channels expanded with incremental scan APIs (`scanLibraryFolderIncremental`) on Android and iOS
+- Android platform channel adds `getSafFileModTimes` for SAF legacy cache backfill
+- Android build tooling upgraded to Gradle 9.3.1 (wrapper)
+- Android build path validated with Java 25 (Gradle/Kotlin/assemble debug)
+- SAF tree picker flow in `MainActivity` migrated to Activity Result API (`registerForActivityResult`)
+- `MainActivity` host migrated to `FlutterFragmentActivity` for SAF picker compatibility
+- Legacy `startActivityForResult` / `onActivityResult` SAF picker path removed
+- Setup screen UI polish: smaller logo, thin outline borders on text fields
+- Removed support section from About page (moved to Donate page)
+- Qobuz squid.wtf region fallback for blocked regions
+- Setup screen converted to PageView flow with animated progress bar and modern card layouts
+- Tutorial screen aligned with Setup Screen design, updated typography and softened UI shapes
+- Larger, more accessible navigation buttons for onboarding flow
+- Reduced visual noise by removing unnecessary glow effects
+
+### Fixed
+
+- Android 10+ `permission denied` when writing to `/storage/emulated/0` (now handled via SAF)
+- SAF history repair: auto-resolve missing content URIs using tree + filename
+- SAF download fallback: retry in app-private storage when SAF write fails
+- Tidal DASH manifest writing when output path is a file descriptor (no invalid `.m4a` path)
+- External LRC output in SAF mode
+- Restored old-device renderer fallback while using `FlutterFragmentActivity` by injecting shell args from a custom `FlutterFragment` (`--enable-impeller=false` on problematic devices)
+- Preserved Flutter fragment creation behavior (cached engine, engine group, new engine) while adding Impeller fallback support
+- SAF tree picker result now consistently returns `tree_uri` payload with persisted URI permission handling
+- SAF share file now copies to temp before sharing (fixes share from SAF content URI)
+- Home feed not updating after installing extension with homeFeed capability (no longer requires app restart)
+- Library scan hero card showing 0 tracks during scan (now shows scanned file count in real-time)
+- Library folder picker no longer requires MANAGE_EXTERNAL_STORAGE on Android 10+ (uses SAF tree picker)
+- One-time SAF migration prompt for users updating from pre-SAF versions
+- Fixed `fileModTime` propagation across Go/Android/Dart so incremental scan cache is stored and reused correctly
+- Fixed SAF incremental scan key mismatch (`lastModified` vs `fileModTime`) and normalized result fields (`skippedCount`, `totalFiles`)
+- Fixed incremental scan progress when all files are skipped (`scanned_files` now reaches total files)
+- Removed duplicate `"removeExtension"` branch in Android method channel handler (eliminates Kotlin duplicate-branch warning)
+
+---
+
+## [3.4.2] - 2026-02-04
+
+### Improved
+
+- **Mobile Network Reliability**: All providers (Qobuz, Tidal, Amazon, Deezer) now have retry logic with exponential backoff
+  - Increased API timeouts: 15s → 25s (Deezer, Qobuz, Tidal), 30s (Amazon)
+  - Up to 3 retry attempts per API call (500ms → 1s → 2s backoff)
+  - Retryable: timeout, connection reset/refused, EOF, HTTP 5xx, HTTP 429
+- **SongLink ID Extraction**: Extract QobuzID/TidalID directly from SongLink URLs
+  - New fields in `TrackAvailability`: `QobuzID`, `TidalID`
+  - Qobuz/Tidal now use direct Track ID from SongLink instead of re-parsing URLs
+- **Qobuz Download Flow**: New Strategy 3 - get QobuzID from SongLink before ISRC search
+  - Cache hit now uses `GetTrackByID()` directly instead of searching again
+  - Pre-warm cache tries SongLink first before direct ISRC search
+- **Tidal Download Flow**: Use `availability.TidalID` directly from SongLink struct
+
+---
+
+## [3.4.1] - 2026-02-04
+
+### Fixed
+
+- Metadata Priority order now persists after app restart
+- Download Provider Priority order now persists after app restart
+
+---
+
+## [3.4.0] - 2026-02-03
+
+### Highlights
+
+- **Local Library Scanning** ([#117](https://github.com/zarzet/SpotiFLAC-Mobile/issues/117)): Scan existing music collection to detect duplicates (FLAC, M4A, MP3, Opus, OGG)
+- **Duplicate Detection** ([#117](https://github.com/zarzet/SpotiFLAC-Mobile/issues/117)): "In Library" badge on tracks matching by ISRC or track name + artist
+- **Unified Library Tab**: History renamed to Library, shows Downloaded + Local Library tracks with source badges
+
+### Added
+
+- Local Album Screen with cover art, disc grouping, and selection mode
+- Albums tab shows local library albums with folder icon badge
+- Singles filter includes local library singles
+- Advanced library filters: Source, Quality, Format, Date
+- Cover art extraction from embedded tags (FLAC, MP3, Opus/Ogg)
+- "Already in Library" notification when downloading existing tracks
+- Spotify secrets now stored in secure storage (`flutter_secure_storage`)
+- **Multi-Service Link Support**: Share links from Deezer, Tidal, and YouTube Music (in addition to Spotify)
+  - Deezer: Full support for track, album, playlist, artist links
+  - Tidal: Track links converted via SongLink to Spotify/Deezer for metadata
+  - YouTube Music: Handled via ytmusic extension URL handler
+- Local library tracks now open metadata screen on tap
+
+### Changed
+
+- Extension HTTP sandbox enforces HTTPS and blocks private IPs
+- Extension file sandbox validates paths with boundary-safe checks
+
+### Fixed
+
+- Search filter bar now only appears after results load, not during loading
+- MP3/Ogg metadata parsing (ID3v2 extended headers, Ogg packet reassembly)
+- Library scan metadata (ISRC, disc number, release date)
+- Cover cache robustness (size + mtime cache key)
+- Local library selection and delete in list/grid views
+- Albums/Singles count includes local library items
+
+---
+
+## [3.3.6] - 2026-02-02
+
+### Added
+
+- **WiFi-Only Download Mode**: Pause downloads on mobile data, auto-resume on WiFi (Settings > Download > Download Network)
+- Added `connectivity_plus: ^6.0.3` dependency
+
+---
+
+## [3.3.5] - 2026-02-01
+
+Same as 3.3.1 but fixes crash issues caused by FFmpeg.
+
+### Added
+
+- **Export Failed Downloads**: Export failed downloads to TXT file for easy lookup on other platforms
+- **Auto-Export Setting**: Option to automatically export failed downloads when queue finishes
+
+### Fixed
+
+- **FFmpeg Crash**: Fixed crash issues during M4A to MP3/Opus conversion
+- **Service Selection Ignored**: Fixed bug where selecting Qobuz/Amazon from service picker was ignored and always used Tidal instead
+- **iOS iCloud Drive Permission Error**: Block iCloud Drive folder selection on iOS (Go backend cannot access iCloud due to sandboxing)
+
+### Changed
+
+- **Amazon Fallback Only**: Amazon Music is now grayed out in service picker and can only be used as fallback provider
+
+---
+
+## [3.3.1] - 2026-02-01
+
+### Added
+
+- **Clear All Queue Button**: Cancel all queued downloads with one tap ([#96](https://github.com/zarzet/SpotiFLAC-Mobile/issues/96))
+- **IDHS Fallback**: Fallback link resolver when SongLink fails (rate limited 8 req/min)
+- **Lossy Bitrate Options**: MP3 (320/256/192/128kbps), Opus (128/96/64kbps)
+- **Search Filters**: Filter results by type (Tracks, Artists, Albums, Playlists)
+- **Album/Playlist Search**: Deezer search now includes albums and playlists
+- **New Languages**: Turkish (Kaan, BedirhanGltkn), Japanese (Re\*Index.(ot_inc))
+- **Optional All Files Access**: Android 13+ no longer requires full storage access; enable in Settings if needed
+- **Improved VPN Compatibility**: Better HTTP/2 support for users behind VPN or restricted networks
+
+### Changed
+
+- **Amazon Download API**: Switched to AfkarXYZ API
+- **Qobuz Download API**: Added Jumo API as fallback
+- **Search Results**: Reduced artist limit from 5 to 2
+
+### Fixed
+
+- **MP3 Download Error 403**: Fixed 403 Forbidden error when downloading MP3 files ([#108](https://github.com/zarzet/SpotiFLAC-Mobile/issues/108))
+- **Opus Cover Art**: Implemented METADATA_BLOCK_PICTURE for proper cover embedding
+- **Deezer Pagination**: Fixed >25 tracks only showing first 25 ([#112](https://github.com/zarzet/SpotiFLAC-Mobile/issues/112))
+- **Duplicate Embed Lyrics Setting**: Removed from Options page ([#110](https://github.com/zarzet/SpotiFLAC-Mobile/issues/110))
+
+---
+
+## [3.2.1] - 2026-01-22
+
+### Added
+
+- **Artist/Album + Singles Folder Structure**: Singles go inside artist folder (`Artist/Album/`, `Artist/Singles/`)
+- **Embed Lyrics Button**: Manually embed online lyrics into tracks from Track Info screen (preserves synced timestamps)
+- **Pause/Resume Button**: Added pause and resume controls next to "Downloading" header in History screen
+- **Instrumental Detection**: Tracks marked as instrumental on lrclib.net now show "Instrumental track" instead of "Lyrics not available"
+
+### Fixed
+
+- **Lyrics**: Multi-artist tracks now search by primary artist first, then full string
+- **Lyrics**: Metadata tags (`[ti:...]`, `[ar:...]`, `[by:...]`) no longer shown in display
+- **Lyrics**: Embed button now correctly appears for tracks with online lyrics
+- **Lyrics**: Manual embed preserves original timestamps instead of plain text
+- **iOS**: Fixed "File not found" after 3.1.x → 3.2.0 update (container UUID migration)
+- **Home Feed**: Greeting now uses device local time
+- **Deezer**: Track position fallback to index+1 when API returns 0
+- **Localization**: Fixed 16 ICU plural syntax warnings in Spanish & Portuguese
+
+### Performance
+
+- **Home Feed**: Precomputed Quick Picks section flag and reduced per-page allocations; explore state now watched by field to cut rebuilds
+- **Home Recent**: Cached recent-access aggregation and limited list allocations for recent downloads
+- **Settings/Theme/Recent**: Cached SharedPreferences instance to avoid repeated `getInstance()` calls
+- **History/DB**: Batched iOS path migration updates to reduce write overhead
+- **Download Queue**: Reduced polling allocations and avoided double-load scheduling for history
+- **Misc**: Precompiled regex in share intent, update dialog, extensions error parsing, log analysis, and LRC cleanup; faster palette cache hits and log filtering
+
+---
+
 ## [3.2.0] - 2026-01-22

 > **Note:** Starting from v3.2.0, changelogs will be concise.
@@ -51,31 +475,26 @@
  - Perfect for players like Samsung Music that prefer external .lrc files
  - LRC files include metadata headers (title, artist, by:SpotiFLAC-Mobile)
  - Works with all download services (Tidal, Qobuz, Amazon)
-
 - **CSV Import Quality Selection**: Choose audio quality when importing CSV playlists
  - Quality picker now appears before adding CSV tracks to download queue
  - Select between FLAC qualities (Lossless, Hi-Res, Hi-Res Max) or MP3
  - Respects "Ask quality before download" setting - uses default quality if disabled
-
  - **Persistent Cover Image Cache**: Album/track cover images now cached to persistent storage instead of temporary directory
  - Cover images no longer disappear when app is closed or device restarts
  - Cache stored in `app_flutter/cover_cache/` directory (not cleared by system)
  - Maximum 1000 images cached for up to 365 days
  - Covers are cached when displayed in History, Home, Album, Artist, or any other screen
  - New `CoverCacheManager` service with `clearCache()` and `getStats()` methods for future cache management
-
 - **Extended Metadata from Deezer Enrichment**: Track downloads now include label, copyright, and genre metadata from Deezer
  - New fields in `ExtTrackMetadata`: `label`, `copyright`, `genre`
  - Metadata fetched during `enrichTrack()` via Deezer album API
  - Embedded as FLAC Vorbis comments: `GENRE`, `ORGANIZATION` (label), `COPYRIGHT`
  - Works for both extension downloads and built-in provider downloads (Tidal, Qobuz, Amazon)
-
 - **Track Metadata Screen Extended Info**: Genre, label, and copyright now displayed in track metadata screen
  - Added `genre`, `label`, `copyright` fields to `DownloadHistoryItem` model
  - Metadata is stored in download history and persists across app restarts
  - New localization strings: `trackGenre`, `trackLabel`, `trackCopyright`
-
- **`utils.randomUserAgent()` for Extensions**: New utility function for extensions to get random browser User-Agent strings
+- `**utils.randomUserAgent()` for Extensions\*\*: New utility function for extensions to get random browser User-Agent strings
  - Returns modern Chrome User-Agent format: `Chrome/{120-145}.0.{6000-7499}.{100-299}` with `Windows NT 10.0`
  - Useful for extensions that need to rotate User-Agents to avoid detection

@@ -84,7 +503,6 @@
 - **Portuguese Language Bug**: Fixed locale parsing for languages with country codes (e.g., pt_PT, es_ES)
  - App now correctly loads Portuguese and Spanish translations
  - Updated Portuguese label to "Português (Brasil)"
-
 - **VM Race Condition Panic**: Fixed `panic during execution: runtime error: index out of range [-2]` crash when switching search providers
  - Root cause: Goja VM was being accessed concurrently by multiple goroutines without synchronization
  - Added `VMMu sync.Mutex` to `LoadedExtension` struct
@@ -93,16 +511,13 @@
    - `EnrichTrack`, `CheckAvailability`, `GetDownloadURL`, `Download`
    - `CustomSearch`, `HandleURL`, `MatchTrack`, `PostProcess`
  - Prevents race conditions when rapidly switching between extension search providers
-
 - **Tidal Release Date Fallback**: Fixed missing release date in FLAC metadata when downloading from Tidal
  - Now uses Tidal API's release date when `req.ReleaseDate` is empty
  - Ensures release date is always embedded in downloaded files
-
 - **Extended Metadata for M4A→FLAC Conversion**: Fixed genre, label, and copyright not being embedded when converting Amazon M4A to FLAC
  - Flutter now extracts extended metadata from Go backend response
  - Passes `genre`, `label`, `copyright` parameters to `_embedMetadataAndCover()`
  - Tags correctly embedded during FFmpeg conversion
-
 - **Extended Metadata for MP3 Conversion**: Genre, label, and copyright now embedded in MP3 files when converting from FLAC
  - Added `genre`, `label`, `copyright` parameters to `_embedMetadataToMp3()`
  - Tags embedded as ID3v2: `GENRE`, `ORGANIZATION` (label), `COPYRIGHT`
@@ -163,7 +578,6 @@
  - `go_backend/httputil.go`: Updated `getRandomUserAgent()` to use modern Chrome versions
  - `go_backend/tidal.go`: Added release date fallback logic
  - `go_backend/exports.go`: Added `Genre`, `Label`, `Copyright` fields to `DownloadResponse`
-
 - **Flutter Changes**:
  - `lib/services/cover_cache_manager.dart`: New persistent cache manager for cover images (365 days, 1000 images max)
  - `lib/widgets/cached_cover_image.dart`: Wrapper widget for CachedNetworkImage with persistent cache
@@ -188,7 +602,6 @@
  - Spanish: Credits 125 ([@credits125](https://crowdin.com/profile/credits125))
  - Portuguese: Pedro Marcondes ([@justapedro](https://crowdin.com/profile/justapedro))
  - Russian: Владислав ([@odinokiy_kot](https://crowdin.com/profile/odinokiy_kot))
-
 - **Quick Search Provider Switcher** ([#76](https://github.com/zarzet/SpotiFLAC-Mobile/issues/76)): Dropdown menu in search bar for instant provider switching
  - Tap the search icon to reveal a dropdown menu with all available search providers
  - Shows default provider (Deezer based on metadata source setting) at the top
@@ -198,56 +611,46 @@
  - Search hint text updates immediately when switching providers
  - Re-triggers search automatically if there's existing text in the search bar
  - Eliminates need to navigate to Settings > Extensions > Search Provider
-
 - **Extension Button Setting Type** ([#74](https://github.com/zarzet/SpotiFLAC-Mobile/issues/74)): New setting type for extension actions
  - Extensions can define `button` type in manifest settings
  - Triggers JavaScript function when tapped (e.g., start OAuth flow)
  - Useful for authentication, manual sync, or any custom action
-
 - **Genre & Label Metadata** ([#75](https://github.com/zarzet/SpotiFLAC-Mobile/issues/75)): Downloaded tracks now include genre and record label information
  - Fetches genre and label from Deezer album API for each track
  - Embeds GENRE, ORGANIZATION (label), and COPYRIGHT tags into FLAC files
  - Works automatically when Deezer track ID is available (via ISRC matching)
  - Supports all download services (Tidal, Qobuz, Amazon) and extension downloads
-
 - **MP3 Quality Option** ([#69](https://github.com/zarzet/SpotiFLAC-Mobile/issues/69)): Optional MP3 download format with FLAC-to-MP3 conversion
  - New "Enable MP3 Option" toggle in Settings > Download > Audio Quality
  - When enabled, MP3 (320kbps) appears as a quality option alongside FLAC options
  - Available in both the quality picker dialog and default quality settings
  - Works with all services (Tidal, Qobuz, Amazon) and extensions
-
 - **MP3 Metadata Embedding**: Full metadata support for MP3 files
  - Cover art embedded using ID3v2 tags
  - Synced lyrics embedded (fetched from lrclib.net)
  - All metadata preserved: title, artist, album, album artist, track/disc number, date, ISRC
  - Automatic tag conversion from Vorbis comments (FLAC) to ID3v2 (MP3)
-
 - **Dominant Color Header**: Album, Playlist, Downloaded Album, and Track Metadata screens now feature dynamic header backgrounds
  - Extracts dominant color from cover art using `palette_generator`
  - Creates a gradient from dominant color to theme surface color
  - Smooth 500ms color transition animation
-
 - **Larger Cover Art**: Cover images on detail screens are now 50% of screen width (previously 140px fixed)
  - More prominent album artwork display
  - Larger shadow and rounded corners (20px radius)
  - Higher resolution cover caching
-
 - **Sticky Title**: Title appears in AppBar when scrolling past the info card
  - Smooth fade-in animation (200ms) when scrolling down
  - Title hidden when header is expanded (shows in info card instead)
  - AppBar uses theme color (surface) for clean, native look
  - Works on Album, Playlist, Downloaded Album, Track Metadata, and Artist screens
-
 - **Artist Name in Album Screen**: Album info card now displays artist name below album title
  - Extracted from first track's artist metadata
  - Styled with `onSurfaceVariant` color for visual hierarchy
-
 - **Disc Separation for Multi-Disc Albums** ([#70](https://github.com/zarzet/SpotiFLAC-Mobile/issues/70)): Downloaded albums with multiple discs now display tracks grouped by disc
  - Visual disc separator header showing "Disc 1", "Disc 2", etc.
  - Tracks sorted by disc number first, then by track number
  - Single-disc albums display normally without separators
  - Fixes confusion when albums have duplicate track numbers across discs
-
 - **Album Grouping in Recents** ([#70](https://github.com/zarzet/SpotiFLAC-Mobile/issues/70)): Downloads now show as albums instead of individual tracks in the Recent section
  - Prevents flooding the recents list when downloading full albums
  - Groups tracks by album name and artist
@@ -260,7 +663,6 @@
  - MP3 files now saved in the same folder as FLAC (no separate MP3 subfolder)
  - Original FLAC file automatically deleted after successful conversion
  - New `embedMetadataToMp3()` method for MP3-specific tag embedding
-
 - **Sticky Header Theme Integration**: AppBar background uses `colorScheme.surface` instead of dominant color when collapsed
  - Dark theme: Black background with white text
  - Light theme: White background with black text
@@ -272,12 +674,10 @@
  - MP3 files now show "320kbps" instead of FLAC's bit depth/sample rate
  - History no longer stores FLAC audio specs for converted MP3 files
  - Both File Info badges and metadata grid show correct MP3 quality
-
 - **Empty Catch Blocks**: Fixed analyzer warnings for empty catch blocks
  - `download_queue_provider.dart`: Added comments explaining why polling errors are silently ignored
  - `track_provider.dart`: Added comments explaining why availability check errors are silently ignored
  - `ffmpeg_service.dart`: Added proper error logging for temp file cleanup failures
-
 - **Russian Plural Forms**: Fixed ICU syntax warnings in Russian localization
  - Removed redundant `=1` clauses that were overriding `one` plural category
  - Affected 10 plural strings including track counts and delete confirmations
@@ -297,24 +697,20 @@
  - Thread-safe cache with automatic expiration
  - Cache key based on artist, track, and duration
  - Log indicator shows "(cached)" when lyrics are served from cache
-
 - **Lyrics Duration Matching**: Improved lyrics accuracy with duration-based matching
  - Compares track duration with lrclib.net results
  - 10-second tolerance to handle version differences (radio edit, remaster, etc.)
  - Prioritizes synced lyrics over plain text when duration matches
  - Falls back gracefully if no duration match found
-
 - **Deezer Cover Art Upgrade**: Cover art from Deezer CDN now automatically upgraded to maximum quality
  - Detects Deezer CDN URLs (`cdn-images.dzcdn.net`)
  - Upgrades cover resolution to 1800x1800 (max available)
  - Works alongside existing cover upgrade
-
 - **Live Search for Extensions**: Search-as-you-type functionality for extension search
  - 800ms debounce delay to prevent excessive API calls
  - Minimum 3 characters required before searching
  - Concurrency control to prevent race conditions in extension runtime
  - Queues pending searches if a search is already in progress
-
 - **Russian Language Support**: Added Russian (Русский) translation - 99% complete
  - Translated via Crowdin community contributions
  - Covers all UI elements, settings, and error messages
@@ -325,12 +721,10 @@
  - Added per-directory build lock using `sync.Map` and `sync.Mutex`
  - Double-check locking pattern ensures index is built only once
  - Significantly improves performance during CSV import with many tracks
-
 - **Queue Tab Scroll Exception**: Fixed Flutter rendering exception with NestedScrollView
  - Disabled Material 3 stretch overscroll indicator that caused `_StretchController` assertion
  - Wrapped NestedScrollView with ScrollConfiguration to prevent `setState during build` errors
  - Issue was especially noticeable during rapid queue updates (CSV import)
-
 - **CSV Import**: Fixed CSV export not being parsed correctly
  - Added support for `Artist Name(s)` header (with parentheses)
  - Added support for `Track URI` header for track IDs
@@ -397,4 +791,4 @@ SpotiFLAC 3.0 introduces a powerful extension system that allows third-party int

 ---

-*For older versions, see [GitHub Releases](https://github.com/zarzet/SpotiFLAC-Mobile/releases)*
+_For older versions, see [GitHub Releases_](https://github.com/zarzet/SpotiFLAC-Mobile/releases)
@@ -1,5 +1,5 @@
-[![GitHub All Releases](https://img.shields.io/github/downloads/zarzet/SpotiFLAC-Mobile/total?style=for-the-badge)](https://github.com/zarzet/SpotiFLAC-Mobile/releases)
-[![VirusTotal](https://img.shields.io/badge/VirusTotal-Safe-brightgreen?style=for-the-badge&logo=virustotal)](https://www.virustotal.com/gui/file/3257155286587a3596ad5d4380d4576a684aa3d37a5b19a615914a845fbe57f3)
+[![GitHub All Releases](https://img.shields.io/github/downloads/zarzet/SpotiFLAC-Mobile/total?style=for-the-badge&refresh=1)](https://github.com/zarzet/SpotiFLAC-Mobile/releases)
+[![VirusTotal](https://img.shields.io/badge/VirusTotal-Safe-brightgreen?style=for-the-badge&logo=virustotal)](https://www.virustotal.com/gui/file/dec9c96672ab80e6bf6b7a66786e612f5404446c341eb0311b4cc78fe10c96a1)
 [![Crowdin](https://img.shields.io/badge/HELP%20TRANSLATE%20ON-CROWDIN-%2321252b?style=for-the-badge&logo=crowdin)](https://crowdin.com/project/spotiflac-mobile)

 <div align="center">
@@ -24,15 +24,6 @@ Download music in true lossless FLAC from Tidal, Qobuz & Amazon Music — no acc
  <img src="assets/images/4.jpg?v=2" width="200" />
 </p>

-## Search Source
-
-SpotiFLAC supports multiple search sources for finding music metadata:
-
-| Source | Setup |
-|--------|-------|
-| **Deezer** (Default) | No setup required |
-| **Extensions** | Install additional search providers from the Store |
-
 ## Extensions

 Extensions allow the community to add new music sources and features without waiting for app updates. When a streaming service API changes or a new source becomes available, extensions can be updated independently.
@@ -52,19 +43,10 @@ Want to create your own extension? Check out the [Extension Development Guide](h
 ### [SpotiFLAC (Desktop)](https://github.com/afkarxyz/SpotiFLAC)
 Download music in true lossless FLAC from Tidal, Qobuz & Amazon Music for Windows, macOS & Linux

-> **Note:** Currently unavailable because the GitHub account is suspended. Alternatively, use [SpotiFLAC-Next](https://github.com/spotiverse/SpotiFLAC-Next) until the original is restored.
-
 ## Telegram

-<p align="center">
-  <a href="https://t.me/spotiflac">
-    <img src="https://img.shields.io/badge/Telegram-Channel-2CA5E0?style=for-the-badge&logo=telegram&logoColor=white" alt="Telegram Channel">
-  </a>
-
-  <a href="https://t.me/spotiflacchat">
-    <img src="https://img.shields.io/badge/Telegram-Community-2CA5E0?style=for-the-badge&logo=telegram&logoColor=white" alt="Telegram Community">
-  </a>
-</p>
+[![Telegram Channel](https://img.shields.io/badge/CHANNEL-2CA5E0?style=for-the-badge&logo=telegram&logoColor=white)](https://t.me/spotiflac)
+[![Telegram Community](https://img.shields.io/badge/COMMUNITY-2CA5E0?style=for-the-badge&logo=telegram&logoColor=white)](https://t.me/spotiflac_chat)

 ## FAQ

@@ -86,6 +68,14 @@ A: Yes, the app is open source and you can verify the code yourself. Each releas
 **Q: Why is download not working in my country?**  
 A: Some countries have restricted access to certain streaming service APIs. If downloads are failing, try using a VPN to connect through a different region.

+
+### Want to support SpotiFLAC-Mobile?
+
+_If this software is useful and brings you value, consider supporting the project by buying me a coffee. Your support helps keep development going._
+
+[![Ko-fi](https://ko-fi.com/img/githubbutton_sm.svg)](https://ko-fi.com/zarzet) <a href="https://www.buymeacoffee.com/zarzet" target="_blank"><img src="https://cdn.buymeacoffee.com/buttons/v2/default-yellow.png" alt="Buy Me A Coffee" style="height: 40px !important;width: 150px !important;" ></a>
+
+
 ## Disclaimer

 This project is for **educational and private use only**. The developer does not condone or encourage copyright infringement.
@@ -100,3 +90,18 @@ You are solely responsible for:
 3. Any legal consequences resulting from the misuse of this tool.

 The software is provided "as is", without warranty of any kind. The author assumes no liability for any bans, damages, or legal issues arising from its use.
+
+
+## API Credits
+
+- **Tidal**: [hifi-api](https://github.com/binimum/hifi-api), [music.binimum.org](https://music.binimum.org), [qqdl.site](https://qqdl.site), [squid.wtf](https://squid.wtf), [spotisaver.net](https://spotisaver.net)
+- **Qobuz**: [dabmusic.xyz](https://dabmusic.xyz), [squid.wtf](https://squid.wtf), [jumo-dl](https://jumo-dl.pages.dev)
+- **Amazon**: [AfkarXYZ](https://github.com/afkarxyz)
+- **Lyrics**: [LRCLib](https://lrclib.net)
+- **YouTube Audio**: [Cobalt](https://cobalt.tools) via [qwkuns.me](https://qwkuns.me), [SpotubeDL](https://spotubedl.com)
+- **Track Linking**: [SongLink / Odesli](https://odesli.co), [IDHS](https://github.com/sjdonado/idonthavespotify)
+
+
+> [!TIP]
+>
+> **Star Us**, You will receive all release notifications from GitHub without any delay ~
@@ -96,11 +96,13 @@ repositories {
 }

 dependencies {
-    coreLibraryDesugaring("com.android.tools:desugar_jdk_libs:2.1.4")
+    coreLibraryDesugaring("com.android.tools:desugar_jdk_libs:2.1.5")
    
    // Include all AAR and JAR files from libs folder
    implementation(fileTree(mapOf("dir" to "libs", "include" to listOf("*.jar", "*.aar"))))
    
-    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-android:1.7.3")
-    implementation("androidx.lifecycle:lifecycle-runtime-ktx:2.7.0")
+    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-android:1.10.2")
+    implementation("androidx.lifecycle:lifecycle-runtime-ktx:2.10.0")
+    implementation("androidx.documentfile:documentfile:1.1.0")
+    implementation("androidx.activity:activity-ktx:1.12.3")
 }
@@ -5,6 +5,7 @@
 -keep class io.flutter.view.** { *; }
 -keep class io.flutter.** { *; }
 -keep class io.flutter.plugins.** { *; }
+-keep class io.flutter.embedding.** { *; }

 # Ignore missing Play Core classes (not used, but referenced by Flutter)
 -dontwarn com.google.android.play.core.splitcompat.**
@@ -14,13 +15,22 @@
 # Ignore missing javax.xml.stream (not used on Android)
 -dontwarn javax.xml.stream.**

-# Go backend (gobackend.aar)
+# Go backend (gobackend.aar) - CRITICAL for release builds
 -keep class gobackend.** { *; }
 -keep class go.** { *; }
+-keep interface gobackend.** { *; }
+-keepclassmembers class gobackend.** { *; }
+
+# Go mobile binding internals
+-keep class org.golang.** { *; }
+-dontwarn org.golang.**

 # FFmpeg Kit
 -keep class com.arthenica.ffmpegkit.** { *; }
 -keep class com.arthenica.smartexception.** { *; }
+# FFmpeg Kit (new fork package)
+-keep class com.antonkarpenko.ffmpegkit.** { *; }
+-keep class com.antonkarpenko.smartexception.** { *; }

 # Apache Tika (if used by FFmpeg)
 -dontwarn org.apache.tika.**
@@ -30,15 +40,77 @@
    native <methods>;
 }

-# Kotlin coroutines
+# Kotlin coroutines - expanded rules
 -keepnames class kotlinx.coroutines.internal.MainDispatcherFactory {}
 -keepnames class kotlinx.coroutines.CoroutineExceptionHandler {}
 -keepclassmembers class kotlinx.coroutines.** {
    volatile <fields>;
 }
+-keepclassmembernames class kotlinx.** {
+    volatile <fields>;
+}
+-dontwarn kotlinx.coroutines.**
+
+# Kotlin serialization
+-keepattributes RuntimeVisibleAnnotations,AnnotationDefault
+-dontwarn kotlin.**
+-keep class kotlin.** { *; }
+-keep class kotlin.Metadata { *; }
+
+# Keep MainActivity and related classes
+-keep class com.zarz.spotiflac.** { *; }

 # Prevent R8 from removing metadata
 -keepattributes *Annotation*
 -keepattributes SourceFile,LineNumberTable
 -keepattributes Signature
 -keepattributes Exceptions
+-keepattributes InnerClasses
+-keepattributes EnclosingMethod
+
+# JSON parsing (used by Go backend responses)
+-keep class org.json.** { *; }
+
+# Shared Preferences
+-keep class androidx.datastore.** { *; }
+-dontwarn androidx.datastore.**
+
+# Flutter Plugins - CRITICAL: Prevent R8 from removing plugin implementations
+# Path Provider
+-keep class io.flutter.plugins.pathprovider.** { *; }
+-keep class dev.flutter.pigeon.** { *; }
+
+# Local Notifications
+-keep class com.dexterous.** { *; }
+-keep class com.dexterous.flutterlocalnotifications.** { *; }
+
+# Receive Sharing Intent
+-keep class com.kasem.receive_sharing_intent.** { *; }
+
+# Permission Handler
+-keep class com.baseflow.permissionhandler.** { *; }
+
+# File Picker
+-keep class com.mr.flutter.plugin.filepicker.** { *; }
+
+# URL Launcher
+-keep class io.flutter.plugins.urllauncher.** { *; }
+
+# Share Plus
+-keep class dev.fluttercommunity.plus.share.** { *; }
+
+# Device Info Plus
+-keep class dev.fluttercommunity.plus.device_info.** { *; }
+
+# Open File
+-keep class com.crazecoder.openfile.** { *; }
+
+# Sqflite
+-keep class com.tekartik.sqflite.** { *; }
+
+# Dynamic Color
+-keep class io.material.** { *; }
+
+# Keep all Flutter plugin registrants
+-keep class io.flutter.plugins.GeneratedPluginRegistrant { *; }
+-keep class ** extends io.flutter.embedding.engine.plugins.FlutterPlugin { *; }
@@ -20,9 +20,9 @@
        android:label="SpotiFLAC"
        android:name="${applicationName}"
        android:icon="@mipmap/ic_launcher"
-        android:requestLegacyExternalStorage="true"
-        android:usesCleartextTraffic="true"
-        android:enableOnBackInvokedCallback="true">
+        android:usesCleartextTraffic="false"
+        android:enableOnBackInvokedCallback="true"
+        android:localeConfig="@xml/locale_config">

        <activity
            android:name=".MainActivity"
@@ -43,7 +43,7 @@
                <category android:name="android.intent.category.LAUNCHER"/>
            </intent-filter>

-            <!-- Handle Spotify URL sharing -->
+            <!-- Handle music URL sharing (Spotify, Deezer, Tidal, YT Music) -->
            <intent-filter>
                <action android:name="android.intent.action.SEND" />
                <category android:name="android.intent.category.DEFAULT" />
@@ -57,6 +57,33 @@
                <category android:name="android.intent.category.BROWSABLE" />
                <data android:scheme="https" android:host="open.spotify.com" />
            </intent-filter>
+
+            <!-- Handle Deezer deep links -->
+            <intent-filter android:autoVerify="true">
+                <action android:name="android.intent.action.VIEW" />
+                <category android:name="android.intent.category.DEFAULT" />
+                <category android:name="android.intent.category.BROWSABLE" />
+                <data android:scheme="https" android:host="www.deezer.com" />
+                <data android:scheme="https" android:host="deezer.com" />
+                <data android:scheme="https" android:host="deezer.page.link" />
+            </intent-filter>
+
+            <!-- Handle Tidal deep links -->
+            <intent-filter android:autoVerify="true">
+                <action android:name="android.intent.action.VIEW" />
+                <category android:name="android.intent.category.DEFAULT" />
+                <category android:name="android.intent.category.BROWSABLE" />
+                <data android:scheme="https" android:host="tidal.com" />
+                <data android:scheme="https" android:host="listen.tidal.com" />
+            </intent-filter>
+
+            <!-- Handle YouTube Music deep links -->
+            <intent-filter android:autoVerify="true">
+                <action android:name="android.intent.action.VIEW" />
+                <category android:name="android.intent.category.DEFAULT" />
+                <category android:name="android.intent.category.BROWSABLE" />
+                <data android:scheme="https" android:host="music.youtube.com" />
+            </intent-filter>
        </activity>

        <!-- Download Service -->
@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="utf-8"?>
+<locale-config xmlns:android="http://schemas.android.com/apk/res/android">
+    <locale android:name="en" />
+    <locale android:name="ru" />
+    <locale android:name="es-ES" />
+    <locale android:name="id" />
+    <locale android:name="pt-PT" />
+    <locale android:name="ja" />
+    <locale android:name="tr" />
+    <locale android:name="de" />
+    <locale android:name="fr" />
+    <locale android:name="hi" />
+    <locale android:name="ko" />
+    <locale android:name="nl" />
+    <locale android:name="zh" />
+</locale-config>
@@ -22,7 +22,7 @@ subprojects {
            }
            
            // Add desugaring dependency to all Android subprojects
-            project.dependencies.add("coreLibraryDesugaring", "com.android.tools:desugar_jdk_libs:2.1.4")
+            project.dependencies.add("coreLibraryDesugaring", "com.android.tools:desugar_jdk_libs:2.1.5")
        }
        
        tasks.withType<org.jetbrains.kotlin.gradle.tasks.KotlinCompile>().configureEach {
@@ -1,2 +1,2 @@
-org.gradle.jvmargs=-Xmx8G -XX:MaxMetaspaceSize=4G -XX:ReservedCodeCacheSize=512m -XX:+HeapDumpOnOutOfMemoryError
+org.gradle.jvmargs=-Xmx4G -XX:MaxMetaspaceSize=2G -XX:ReservedCodeCacheSize=256m -XX:+HeapDumpOnOutOfMemoryError
 android.useAndroidX=true
@@ -2,4 +2,4 @@ distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.14-all.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-9.3.1-all.zip
@@ -19,8 +19,8 @@ pluginManagement {

 plugins {
    id("dev.flutter.flutter-plugin-loader") version "1.0.0"
-    id("com.android.application") version "8.11.1" apply false
-    id("org.jetbrains.kotlin.android") version "2.3.0" apply false
+    id("com.android.application") version "8.13.2" apply false
+    id("org.jetbrains.kotlin.android") version "2.2.21" apply false
 }

 include(":app")
@@ -1,335 +0,0 @@
-import 'dart:io';
-import 'package:ffmpeg_kit_flutter_new_audio/ffmpeg_kit.dart';
-import 'package:ffmpeg_kit_flutter_new_audio/return_code.dart';
-import 'package:spotiflac_android/utils/logger.dart';
-
-final _log = AppLogger('FFmpeg');
-
-/// FFmpeg service for iOS using ffmpeg_kit_flutter plugin
-class FFmpegServiceIOS {
-  /// Execute FFmpeg command and return result
-  static Future<FFmpegResultIOS> _execute(String command) async {
-    try {
-      final session = await FFmpegKit.execute(command);
-      final returnCode = await session.getReturnCode();
-      final output = await session.getOutput() ?? '';
-      return FFmpegResultIOS(
-        success: ReturnCode.isSuccess(returnCode),
-        returnCode: returnCode?.getValue() ?? -1,
-        output: output,
-      );
-    } catch (e) {
-      _log.e('FFmpeg execute error: $e');
-      return FFmpegResultIOS(success: false, returnCode: -1, output: e.toString());
-    }
-  }
-
-  /// Convert M4A (DASH segments) to FLAC
-  static Future<String?> convertM4aToFlac(String inputPath) async {
-    final outputPath = inputPath.replaceAll('.m4a', '.flac');
-    final command = '-i "$inputPath" -c:a flac -compression_level 8 "$outputPath" -y';
-    final result = await _execute(command);
-
-    if (result.success) {
-      try {
-        await File(inputPath).delete();
-      } catch (_) {}
-      return outputPath;
-    }
-
-    _log.e('M4A to FLAC conversion failed: ${result.output}');
-    return null;
-  }
-
-  /// Convert FLAC to MP3
-  /// If deleteOriginal is true, deletes the FLAC file after conversion
-  static Future<String?> convertFlacToMp3(
-    String inputPath, {
-    String bitrate = '320k',
-    bool deleteOriginal = true,
-  }) async {
-    // Convert in same folder, just change extension
-    final outputPath = inputPath.replaceAll('.flac', '.mp3');
-
-    final command = '-i "$inputPath" -codec:a libmp3lame -b:a $bitrate -map 0:a -map_metadata 0 -id3v2_version 3 "$outputPath" -y';
-    final result = await _execute(command);
-
-    if (result.success) {
-      // Delete original FLAC if requested
-      if (deleteOriginal) {
-        try {
-          await File(inputPath).delete();
-        } catch (_) {}
-      }
-      return outputPath;
-    }
-    _log.e('FLAC to MP3 conversion failed: ${result.output}');
-    return null;
-  }
-
-  /// Convert FLAC to M4A
-  static Future<String?> convertFlacToM4a(String inputPath, {String codec = 'aac', String bitrate = '256k'}) async {
-    final dir = File(inputPath).parent.path;
-    final baseName = inputPath.split(Platform.pathSeparator).last.replaceAll('.flac', '');
-    final outputDir = '$dir${Platform.pathSeparator}M4A';
-    await Directory(outputDir).create(recursive: true);
-    final outputPath = '$outputDir${Platform.pathSeparator}$baseName.m4a';
-
-    String command;
-    if (codec == 'alac') {
-      command = '-i "$inputPath" -codec:a alac -map 0:a -map_metadata 0 "$outputPath" -y';
-    } else {
-      command = '-i "$inputPath" -codec:a aac -b:a $bitrate -map 0:a -map_metadata 0 "$outputPath" -y';
-    }
-
-    final result = await _execute(command);
-    if (result.success) return outputPath;
-    _log.e('FLAC to M4A conversion failed: ${result.output}');
-    return null;
-  }
-
-  /// Embed cover art to FLAC file
-  static Future<String?> embedCover(String flacPath, String coverPath) async {
-    final tempOutput = '$flacPath.tmp';
-    final command = '-i "$flacPath" -i "$coverPath" -map 0:a -map 1:0 -c copy -metadata:s:v title="Album cover" -metadata:s:v comment="Cover (front)" -disposition:v attached_pic "$tempOutput" -y';
-
-    final result = await _execute(command);
-
-    if (result.success) {
-      try {
-        await File(flacPath).delete();
-        await File(tempOutput).rename(flacPath);
-        return flacPath;
-      } catch (e) {
-        _log.e('Failed to replace file after cover embed: $e');
-        return null;
-      }
-    }
-
-    try {
-      final tempFile = File(tempOutput);
-      if (await tempFile.exists()) await tempFile.delete();
-    } catch (_) {}
-
-    _log.e('Cover embed failed: ${result.output}');
-    return null;
-  }
-
-  /// Embed metadata and cover art to FLAC file
-  /// Returns the file path on success, null on failure
-  static Future<String?> embedMetadata({
-    required String flacPath,
-    String? coverPath,
-    Map<String, String>? metadata,
-  }) async {
-    final tempOutput = '$flacPath.tmp';
-    
-    // Construct command
-    final StringBuffer cmdBuffer = StringBuffer();
-    cmdBuffer.write('-i "$flacPath" ');
-    
-    // Add cover input if available
-    if (coverPath != null) {
-      cmdBuffer.write('-i "$coverPath" ');
-    }
-    
-    // Map audio stream
-    cmdBuffer.write('-map 0:a ');
-    
-    // Map cover stream if available
-    if (coverPath != null) {
-      cmdBuffer.write('-map 1:0 ');
-      cmdBuffer.write('-c:v copy ');
-      cmdBuffer.write('-disposition:v attached_pic ');
-      cmdBuffer.write('-metadata:s:v title="Album cover" ');
-      cmdBuffer.write('-metadata:s:v comment="Cover (front)" ');
-    }
-    
-    // Copy audio codec (don't re-encode)
-    cmdBuffer.write('-c:a copy ');
-    
-    // Add text metadata
-    if (metadata != null) {
-      metadata.forEach((key, value) {
-        // Sanitize value: escape double quotes
-        final sanitizedValue = value.replaceAll('"', '\\"');
-        cmdBuffer.write('-metadata $key="$sanitizedValue" ');
-      });
-    }
-    
-    cmdBuffer.write('"$tempOutput" -y');
-    
-    final command = cmdBuffer.toString();
-    _log.d('Executing FFmpeg command: $command');
-
-    final result = await _execute(command);
-
-    if (result.success) {
-      try {
-        await File(flacPath).delete();
-        await File(tempOutput).rename(flacPath);
-        return flacPath;
-      } catch (e) {
-        _log.e('Failed to replace file after metadata embed: $e');
-        return null;
-      }
-    }
-
-    // Clean up temp file if exists
-    try {
-      final tempFile = File(tempOutput);
-      if (await tempFile.exists()) {
-        await tempFile.delete();
-      }
-    } catch (_) {}
-
-    _log.e('Metadata/Cover embed failed: ${result.output}');
-    return null;
-  }
-
-  /// Embed metadata and cover art to MP3 file using ID3v2 tags
-  /// Returns the file path on success, null on failure
-  static Future<String?> embedMetadataToMp3({
-    required String mp3Path,
-    String? coverPath,
-    Map<String, String>? metadata,
-  }) async {
-    final tempOutput = '$mp3Path.tmp';
-    
-    final StringBuffer cmdBuffer = StringBuffer();
-    cmdBuffer.write('-i "$mp3Path" ');
-    
-    if (coverPath != null) {
-      cmdBuffer.write('-i "$coverPath" ');
-    }
-    
-    cmdBuffer.write('-map 0:a ');
-    
-    if (coverPath != null) {
-      cmdBuffer.write('-map 1:0 ');
-      cmdBuffer.write('-c:v:0 copy ');
-      cmdBuffer.write('-id3v2_version 3 ');
-      cmdBuffer.write('-metadata:s:v title="Album cover" ');
-      cmdBuffer.write('-metadata:s:v comment="Cover (front)" ');
-    }
-    
-    cmdBuffer.write('-c:a copy ');
-    
-    if (metadata != null) {
-      // Convert FLAC/Vorbis tags to ID3v2 tags for MP3
-      final id3Metadata = _convertToId3Tags(metadata);
-      id3Metadata.forEach((key, value) {
-        final sanitizedValue = value.replaceAll('"', '\\"');
-        cmdBuffer.write('-metadata $key="$sanitizedValue" ');
-      });
-    }
-    
-    cmdBuffer.write('-id3v2_version 3 "$tempOutput" -y');
-    
-    final command = cmdBuffer.toString();
-    _log.d('Executing FFmpeg MP3 embed command: $command');
-
-    final result = await _execute(command);
-
-    if (result.success) {
-      try {
-        await File(mp3Path).delete();
-        await File(tempOutput).rename(mp3Path);
-        _log.d('MP3 metadata embedded successfully');
-        return mp3Path;
-      } catch (e) {
-        _log.e('Failed to replace MP3 file after metadata embed: $e');
-        return null;
-      }
-    }
-
-    try {
-      final tempFile = File(tempOutput);
-      if (await tempFile.exists()) {
-        await tempFile.delete();
-      }
-    } catch (_) {}
-
-    _log.e('MP3 Metadata/Cover embed failed: ${result.output}');
-    return null;
-  }
-
-  /// Convert FLAC/Vorbis comment tags to ID3v2 compatible tags
-  static Map<String, String> _convertToId3Tags(Map<String, String> vorbisMetadata) {
-    final id3Map = <String, String>{};
-    
-    for (final entry in vorbisMetadata.entries) {
-      final key = entry.key.toUpperCase();
-      final value = entry.value;
-      
-      // Map Vorbis comments to ID3v2 frame names
-      switch (key) {
-        case 'TITLE':
-          id3Map['title'] = value;
-          break;
-        case 'ARTIST':
-          id3Map['artist'] = value;
-          break;
-        case 'ALBUM':
-          id3Map['album'] = value;
-          break;
-        case 'ALBUMARTIST':
-          id3Map['album_artist'] = value;
-          break;
-        case 'TRACKNUMBER':
-        case 'TRACK':
-          id3Map['track'] = value;
-          break;
-        case 'DISCNUMBER':
-        case 'DISC':
-          id3Map['disc'] = value;
-          break;
-        case 'DATE':
-        case 'YEAR':
-          id3Map['date'] = value;
-          break;
-        case 'ISRC':
-          id3Map['TSRC'] = value; // ID3v2 ISRC frame
-          break;
-        case 'LYRICS':
-        case 'UNSYNCEDLYRICS':
-          id3Map['lyrics'] = value;
-          break;
-        default:
-          // Pass through other tags as-is
-          id3Map[key.toLowerCase()] = value;
-      }
-    }
-    
-    return id3Map;
-  }
-
-  /// Check if FFmpeg is available
-  static Future<bool> isAvailable() async {
-    try {
-      final session = await FFmpegKit.execute('-version');
-      final returnCode = await session.getReturnCode();
-      return ReturnCode.isSuccess(returnCode);
-    } catch (e) {
-      return false;
-    }
-  }
-
-  /// Get FFmpeg version info
-  static Future<String?> getVersion() async {
-    try {
-      final session = await FFmpegKit.execute('-version');
-      return await session.getOutput();
-    } catch (e) {
-      return null;
-    }
-  }
-}
-
-class FFmpegResultIOS {
-  final bool success;
-  final int returnCode;
-  final String output;
-
-  FFmpegResultIOS({required this.success, required this.returnCode, required this.output});
-}
@@ -3,7 +3,6 @@ package gobackend
 import (
 	"bufio"
 	"context"
-	"encoding/base64"
 	"encoding/json"
 	"errors"
 	"fmt"
@@ -12,321 +11,147 @@ import (
 	"net/url"
 	"os"
 	"path/filepath"
+	"regexp"
 	"strings"
 	"sync"
 	"time"
 )

+// Amazon API timeout and retry configuration for mobile networks
+const (
+	amazonAPITimeoutMobile = 30 * time.Second // Longer timeout for unstable mobile networks
+	amazonMaxRetries       = 2                // Number of retry attempts
+	amazonRetryDelay       = 500 * time.Millisecond
+)
+
 type AmazonDownloader struct {
-	client           *http.Client
-	regions          []string
-	lastAPICallTime  time.Time
-	apiCallCount     int
-	apiCallResetTime time.Time
+	client *http.Client
 }

 var (
 	globalAmazonDownloader *AmazonDownloader
 	amazonDownloaderOnce   sync.Once
-	amazonRateLimitMu      sync.Mutex
 )

-// DoubleDoubleSubmitResponse is the response from DoubleDouble submit endpoint
-type DoubleDoubleSubmitResponse struct {
-	Success bool   `json:"success"`
-	ID      string `json:"id"`
-}
-
-type DoubleDoubleStatusResponse struct {
-	Status         string `json:"status"`
-	FriendlyStatus string `json:"friendlyStatus"`
-	URL            string `json:"url"`
-	Current        struct {
-		Name   string `json:"name"`
-		Artist string `json:"artist"`
-	} `json:"current"`
-}
-
-func amazonArtistsMatch(expectedArtist, foundArtist string) bool {
-	normExpected := strings.ToLower(strings.TrimSpace(expectedArtist))
-	normFound := strings.ToLower(strings.TrimSpace(foundArtist))
-
-	if normExpected == normFound {
-		return true
-	}
-
-	if strings.Contains(normExpected, normFound) || strings.Contains(normFound, normExpected) {
-		return true
-	}
-
-	expectedFirst := strings.Split(normExpected, ",")[0]
-	expectedFirst = strings.Split(expectedFirst, " feat")[0]
-	expectedFirst = strings.Split(expectedFirst, " ft.")[0]
-	expectedFirst = strings.TrimSpace(expectedFirst)
-
-	foundFirst := strings.Split(normFound, ",")[0]
-	foundFirst = strings.Split(foundFirst, " feat")[0]
-	foundFirst = strings.Split(foundFirst, " ft.")[0]
-	foundFirst = strings.TrimSpace(foundFirst)
-
-	if expectedFirst == foundFirst {
-		return true
-	}
-
-	if strings.Contains(expectedFirst, foundFirst) || strings.Contains(foundFirst, expectedFirst) {
-		return true
-	}
-
-	expectedASCII := amazonIsASCIIString(expectedArtist)
-	foundASCII := amazonIsASCIIString(foundArtist)
-	if expectedASCII != foundASCII {
-		GoLog("[Amazon] Artist names in different scripts, assuming match: '%s' vs '%s'\n", expectedArtist, foundArtist)
-		return true
-	}
-
-	return false
-}
-
-func amazonIsASCIIString(s string) bool {
-	for _, r := range s {
-		if r > 127 {
-			return false
-		}
-	}
-	return true
+// AfkarXYZResponse is the response from AfkarXYZ API
+type AfkarXYZResponse struct {
+	Success bool `json:"success"`
+	Data    struct {
+		DirectLink string `json:"direct_link"`
+		FileName   string `json:"file_name"`
+		FileSize   int64  `json:"file_size"`
+	} `json:"data"`
 }

 func NewAmazonDownloader() *AmazonDownloader {
 	amazonDownloaderOnce.Do(func() {
 		globalAmazonDownloader = &AmazonDownloader{
-			client:           NewHTTPClientWithTimeout(120 * time.Second), // 120s timeout like PC
-			regions:          []string{"us", "eu"},                        // Same regions as PC
-			apiCallResetTime: time.Now(),
+			client: NewHTTPClientWithTimeout(120 * time.Second),
 		}
 	})
 	return globalAmazonDownloader
 }

-// waitForRateLimit implements rate limiting similar to PC version
-func (a *AmazonDownloader) waitForRateLimit() {
-	amazonRateLimitMu.Lock()
-	defer amazonRateLimitMu.Unlock()
+// fetchAmazonURLWithRetry fetches from AfkarXYZ API with retry logic for mobile networks
+func (a *AmazonDownloader) fetchAmazonURLWithRetry(amazonURL string) (string, string, error) {
+	apiURL := "https://amazon.afkarxyz.fun/convert?url=" + url.QueryEscape(amazonURL)

-	now := time.Now()
-
-	if now.Sub(a.apiCallResetTime) >= time.Minute {
-		a.apiCallCount = 0
-		a.apiCallResetTime = now
-	}
-
-	if a.apiCallCount >= 9 {
-		waitTime := time.Minute - now.Sub(a.apiCallResetTime)
-		if waitTime > 0 {
-			GoLog("[Amazon] Rate limit reached, waiting %v...\n", waitTime.Round(time.Second))
-			time.Sleep(waitTime)
-			a.apiCallCount = 0
-			a.apiCallResetTime = time.Now()
+	var lastErr error
+	for attempt := 0; attempt <= amazonMaxRetries; attempt++ {
+		if attempt > 0 {
+			delay := amazonRetryDelay * time.Duration(1<<(attempt-1)) // Exponential backoff
+			GoLog("[Amazon] Retry %d/%d after %v...\n", attempt, amazonMaxRetries, delay)
+			time.Sleep(delay)
 		}
-	}

-	if !a.lastAPICallTime.IsZero() {
-		timeSinceLastCall := now.Sub(a.lastAPICallTime)
-		minDelay := 7 * time.Second
-		if timeSinceLastCall < minDelay {
-			waitTime := minDelay - timeSinceLastCall
-			GoLog("[Amazon] Rate limiting: waiting %v...\n", waitTime.Round(time.Second))
-			time.Sleep(waitTime)
+		downloadURL, fileName, err := a.doAfkarXYZRequest(apiURL)
+		if err == nil {
+			return downloadURL, fileName, nil
 		}
+
+		lastErr = err
+		errStr := err.Error()
+
+		// Check if error is retryable
+		isRetryable := strings.Contains(errStr, "timeout") ||
+			strings.Contains(errStr, "connection reset") ||
+			strings.Contains(errStr, "connection refused") ||
+			strings.Contains(errStr, "EOF") ||
+			strings.Contains(errStr, "status 5") ||
+			strings.Contains(errStr, "status 429")
+
+		if !isRetryable {
+			return "", "", err
+		}
+
+		GoLog("[Amazon] Attempt %d failed (retryable): %v\n", attempt+1, err)
 	}

-	a.lastAPICallTime = time.Now()
-	a.apiCallCount++
+	return "", "", fmt.Errorf("all %d attempts failed: %w", amazonMaxRetries+1, lastErr)
 }

-// Uses same service as PC version (doubledouble.top)
-func (a *AmazonDownloader) GetAvailableAPIs() []string {
-	// DoubleDouble service regions (same as PC)
-	// Format: https://{region}.doubledouble.top
-	var apis []string
-	for _, region := range a.regions {
-		apis = append(apis, fmt.Sprintf("https://%s.doubledouble.top", region))
-	}
-	return apis
-}
+// doAfkarXYZRequest performs a single request to AfkarXYZ API
+func (a *AmazonDownloader) doAfkarXYZRequest(apiURL string) (string, string, error) {
+	ctx, cancel := context.WithTimeout(context.Background(), amazonAPITimeoutMobile)
+	defer cancel()

-// downloadFromDoubleDoubleService downloads a track using DoubleDouble service (same as PC)
-// This uses submit → poll → download mechanism
-// Internal function - not exported to gomobile
-func (a *AmazonDownloader) downloadFromDoubleDoubleService(amazonURL, _ string) (string, string, string, error) {
-	var lastError error
-
-	for _, region := range a.regions {
-		GoLog("[Amazon] Trying region: %s...\n", region)
-
-		serviceBase, _ := base64.StdEncoding.DecodeString("aHR0cHM6Ly8=")               // https://
-		serviceDomain, _ := base64.StdEncoding.DecodeString("LmRvdWJsZWRvdWJsZS50b3A=") // .doubledouble.top
-		baseURL := fmt.Sprintf("%s%s%s", string(serviceBase), region, string(serviceDomain))
-
-		encodedURL := url.QueryEscape(amazonURL)
-		submitURL := fmt.Sprintf("%s/dl?url=%s", baseURL, encodedURL)
-
-		a.waitForRateLimit()
-
-		req, err := http.NewRequest("GET", submitURL, nil)
-		if err != nil {
-			lastError = fmt.Errorf("failed to create request: %w", err)
-			continue
-		}
-
-		req.Header.Set("User-Agent", getRandomUserAgent())
-
-		fmt.Println("[Amazon] Submitting download request...")
-
-		// Retry logic for 429 errors (like PC version: 3 retries with 15s wait)
-		var resp *http.Response
-		maxRetries := 3
-		for retry := 0; retry < maxRetries; retry++ {
-			resp, err = a.client.Do(req)
-			if err != nil {
-				lastError = fmt.Errorf("failed to submit request: %w", err)
-				break
-			}
-
-			if resp.StatusCode == 429 { // Too Many Requests
-				resp.Body.Close()
-				if retry < maxRetries-1 {
-					waitTime := 15 * time.Second
-					GoLog("[Amazon] Rate limited (429), waiting %v before retry %d/%d...\n", waitTime, retry+2, maxRetries)
-					time.Sleep(waitTime)
-					continue
-				}
-				lastError = fmt.Errorf("API rate limit exceeded after %d retries", maxRetries)
-				break
-			}
-
-			if resp.StatusCode != 200 {
-				resp.Body.Close()
-				lastError = fmt.Errorf("submit failed with status %d", resp.StatusCode)
-				break
-			}
-
-			// Success - break retry loop
-			break
-		}
-
-		if err != nil || lastError != nil {
-			if resp != nil {
-				resp.Body.Close()
-			}
-			continue
-		}
-
-		var submitResp DoubleDoubleSubmitResponse
-		if err := json.NewDecoder(resp.Body).Decode(&submitResp); err != nil {
-			resp.Body.Close()
-			lastError = fmt.Errorf("failed to decode submit response: %w", err)
-			continue
-		}
-		resp.Body.Close()
-
-		if !submitResp.Success || submitResp.ID == "" {
-			lastError = fmt.Errorf("submit request failed")
-			continue
-		}
-
-		downloadID := submitResp.ID
-		GoLog("[Amazon] Download ID: %s\n", downloadID)
-
-		// Step 2: Poll for completion
-		statusURL := fmt.Sprintf("%s/dl/%s", baseURL, downloadID)
-		fmt.Println("[Amazon] Waiting for download to complete...")
-
-		maxWait := 300 * time.Second // 5 minutes max wait
-		elapsed := time.Duration(0)
-		pollInterval := 3 * time.Second
-
-		for elapsed < maxWait {
-			time.Sleep(pollInterval)
-			elapsed += pollInterval
-
-			statusReq, err := http.NewRequest("GET", statusURL, nil)
-			if err != nil {
-				continue
-			}
-
-			statusReq.Header.Set("User-Agent", getRandomUserAgent())
-
-			statusResp, err := a.client.Do(statusReq)
-			if err != nil {
-				fmt.Printf("\r[Amazon] Status check failed, retrying...")
-				continue
-			}
-
-			if statusResp.StatusCode != 200 {
-				statusResp.Body.Close()
-				fmt.Printf("\r[Amazon] Status check failed (status %d), retrying...", statusResp.StatusCode)
-				continue
-			}
-
-			var status DoubleDoubleStatusResponse
-			if err := json.NewDecoder(statusResp.Body).Decode(&status); err != nil {
-				statusResp.Body.Close()
-				fmt.Printf("\r[Amazon] Invalid JSON response, retrying...")
-				continue
-			}
-			statusResp.Body.Close()
-
-			if status.Status == "done" {
-				fmt.Println("\n[Amazon] Download ready!")
-
-				fileURL := status.URL
-				if strings.HasPrefix(fileURL, "./") {
-					fileURL = fmt.Sprintf("%s/%s", baseURL, fileURL[2:])
-				} else if strings.HasPrefix(fileURL, "/") {
-					fileURL = fmt.Sprintf("%s%s", baseURL, fileURL)
-				}
-
-				trackName := status.Current.Name
-				artist := status.Current.Artist
-
-				GoLog("[Amazon] Downloading: %s - %s\n", artist, trackName)
-				return fileURL, trackName, artist, nil
-
-			} else if status.Status == "error" {
-				errorMsg := status.FriendlyStatus
-				if errorMsg == "" {
-					errorMsg = "Unknown error"
-				}
-				lastError = fmt.Errorf("processing failed: %s", errorMsg)
-				break
-			} else {
-				// Still processing
-				friendlyStatus := status.FriendlyStatus
-				if friendlyStatus == "" {
-					friendlyStatus = status.Status
-				}
-				fmt.Printf("\r[Amazon] %s...", friendlyStatus)
-			}
-		}
-
-		if elapsed >= maxWait {
-			lastError = fmt.Errorf("download timeout")
-			fmt.Printf("\n[Amazon] Error with %s region: %v\n", region, lastError)
-			continue
-		}
-
-		if lastError != nil {
-			fmt.Printf("\n[Amazon] Error with %s region: %v\n", region, lastError)
-		}
+	req, err := http.NewRequestWithContext(ctx, "GET", apiURL, nil)
+	if err != nil {
+		return "", "", fmt.Errorf("failed to create request: %w", err)
 	}

-	return "", "", "", fmt.Errorf("all regions failed. Last error: %v", lastError)
+	req.Header.Set("User-Agent", getRandomUserAgent())
+
+	resp, err := a.client.Do(req)
+	if err != nil {
+		return "", "", fmt.Errorf("failed to call AfkarXYZ API: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != 200 {
+		return "", "", fmt.Errorf("AfkarXYZ API returned status %d", resp.StatusCode)
+	}
+
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return "", "", fmt.Errorf("failed to read response: %w", err)
+	}
+
+	var apiResp AfkarXYZResponse
+	if err := json.Unmarshal(body, &apiResp); err != nil {
+		return "", "", fmt.Errorf("failed to decode response: %w", err)
+	}
+
+	if !apiResp.Success || apiResp.Data.DirectLink == "" {
+		return "", "", fmt.Errorf("AfkarXYZ API failed or no download link found")
+	}
+
+	fileName := apiResp.Data.FileName
+	if fileName == "" {
+		fileName = "track.flac"
+	}
+
+	reg := regexp.MustCompile(`[<>:"/\\|?*]`)
+	fileName = reg.ReplaceAllString(fileName, "")
+
+	return apiResp.Data.DirectLink, fileName, nil
 }

-func (a *AmazonDownloader) DownloadFile(downloadURL, outputPath, itemID string) error {
+func (a *AmazonDownloader) downloadFromAfkarXYZ(amazonURL string) (string, string, error) {
+	GoLog("[Amazon] Fetching from AfkarXYZ API...\n")
+
+	downloadURL, fileName, err := a.fetchAmazonURLWithRetry(amazonURL)
+	if err != nil {
+		return "", "", err
+	}
+
+	GoLog("[Amazon] AfkarXYZ returned: %s\n", fileName)
+	return downloadURL, fileName, nil
+}
+
+func (a *AmazonDownloader) DownloadFile(downloadURL, outputPath string, outputFD int, itemID string) error {
 	ctx := context.Background()

-	// Initialize item progress (required for all downloads)
 	if itemID != "" {
 		StartItemProgress(itemID)
 		defer CompleteItemProgress(itemID)
@@ -363,7 +188,7 @@ func (a *AmazonDownloader) DownloadFile(downloadURL, outputPath, itemID string)
 		SetItemBytesTotal(itemID, expectedSize)
 	}

-	out, err := os.Create(outputPath)
+	out, err := openOutputForWrite(outputPath, outputFD)
 	if err != nil {
 		return err
 	}
@@ -378,33 +203,31 @@ func (a *AmazonDownloader) DownloadFile(downloadURL, outputPath, itemID string)
 		written, err = io.Copy(bufWriter, resp.Body)
 	}

-	// Flush buffer before checking for errors
 	flushErr := bufWriter.Flush()
 	closeErr := out.Close()

 	if err != nil {
-		os.Remove(outputPath)
+		cleanupOutputOnError(outputPath, outputFD)
 		if isDownloadCancelled(itemID) {
 			return ErrDownloadCancelled
 		}
 		return fmt.Errorf("download interrupted: %w", err)
 	}
 	if flushErr != nil {
-		os.Remove(outputPath)
+		cleanupOutputOnError(outputPath, outputFD)
 		return fmt.Errorf("failed to flush buffer: %w", flushErr)
 	}
 	if closeErr != nil {
-		os.Remove(outputPath)
+		cleanupOutputOnError(outputPath, outputFD)
 		return fmt.Errorf("failed to close file: %w", closeErr)
 	}

-	// Verify file size if Content-Length was provided
 	if expectedSize > 0 && written != expectedSize {
-		os.Remove(outputPath)
+		cleanupOutputOnError(outputPath, outputFD)
 		return fmt.Errorf("incomplete download: expected %d bytes, got %d bytes", expectedSize, written)
 	}

-	fmt.Printf("\r[Amazon] Downloaded: %.2f MB (Complete)\n", float64(written)/(1024*1024))
+	GoLog("[Amazon] Downloaded: %.2f MB (Complete)\n", float64(written)/(1024*1024))
 	return nil
 }

@@ -420,59 +243,70 @@ type AmazonDownloadResult struct {
 	TrackNumber int
 	DiscNumber  int
 	ISRC        string
+	LyricsLRC   string
 }

-// Uses DoubleDouble service (same as PC version)
 func downloadFromAmazon(req DownloadRequest) (AmazonDownloadResult, error) {
 	downloader := NewAmazonDownloader()

-	if existingFile, exists := checkISRCExistsInternal(req.OutputDir, req.ISRC); exists {
-		return AmazonDownloadResult{FilePath: "EXISTS:" + existingFile}, nil
+	isSafOutput := isFDOutput(req.OutputFD) || strings.TrimSpace(req.OutputPath) != ""
+	if !isSafOutput {
+		if existingFile, exists := checkISRCExistsInternal(req.OutputDir, req.ISRC); exists {
+			return AmazonDownloadResult{FilePath: "EXISTS:" + existingFile}, nil
+		}
+	}
+
+	amazonURL := ""
+	if req.ISRC != "" {
+		if cached := GetTrackIDCache().Get(req.ISRC); cached != nil && cached.AmazonURL != "" {
+			amazonURL = cached.AmazonURL
+			GoLog("[Amazon] Cache hit! Using cached Amazon URL for ISRC %s\n", req.ISRC)
+		}
 	}

 	songlink := NewSongLinkClient()
 	var availability *TrackAvailability
 	var err error

-	if strings.HasPrefix(req.SpotifyID, "deezer:") {
-		deezerID := strings.TrimPrefix(req.SpotifyID, "deezer:")
-		GoLog("[Amazon] Using Deezer ID for SongLink lookup: %s\n", deezerID)
-		availability, err = songlink.CheckAvailabilityFromDeezer(deezerID)
-	} else if req.SpotifyID != "" {
-		availability, err = songlink.CheckTrackAvailability(req.SpotifyID, req.ISRC)
-	} else {
-		return AmazonDownloadResult{}, fmt.Errorf("no valid Spotify or Deezer ID provided for Amazon lookup")
+	if amazonURL == "" {
+		if deezerID, found := strings.CutPrefix(req.SpotifyID, "deezer:"); found {
+			GoLog("[Amazon] Using Deezer ID for SongLink lookup: %s\n", deezerID)
+			availability, err = songlink.CheckAvailabilityFromDeezer(deezerID)
+		} else if req.SpotifyID != "" {
+			availability, err = songlink.CheckTrackAvailability(req.SpotifyID, req.ISRC)
+		} else {
+			return AmazonDownloadResult{}, fmt.Errorf("no valid Spotify or Deezer ID provided for Amazon lookup")
+		}
+
+		if err != nil {
+			return AmazonDownloadResult{}, fmt.Errorf("failed to check Amazon availability via SongLink: %w", err)
+		}
+
+		if !availability.Amazon || availability.AmazonURL == "" {
+			return AmazonDownloadResult{}, fmt.Errorf("track not available on Amazon Music (SongLink returned no Amazon URL)")
+		}
+
+		amazonURL = availability.AmazonURL
+		if req.ISRC != "" {
+			GetTrackIDCache().SetAmazonURL(req.ISRC, amazonURL)
+		}
 	}

-	if err != nil {
-		return AmazonDownloadResult{}, fmt.Errorf("failed to check Amazon availability via SongLink: %w", err)
-	}
-
-	if !availability.Amazon || availability.AmazonURL == "" {
-		return AmazonDownloadResult{}, fmt.Errorf("track not available on Amazon Music (SongLink returned no Amazon URL)")
-	}
-
-	if req.OutputDir != "." {
+	if !isSafOutput && req.OutputDir != "." {
 		if err := os.MkdirAll(req.OutputDir, 0755); err != nil {
 			return AmazonDownloadResult{}, fmt.Errorf("failed to create output directory: %w", err)
 		}
 	}

-	// Download using DoubleDouble service (same as PC)
-	downloadURL, trackName, artistName, err := downloader.downloadFromDoubleDoubleService(availability.AmazonURL, req.OutputDir)
+	// Download using AfkarXYZ API
+	downloadURL, _, err := downloader.downloadFromAfkarXYZ(amazonURL)
 	if err != nil {
-		return AmazonDownloadResult{}, fmt.Errorf("failed to get download URL: %w", err)
+		return AmazonDownloadResult{}, fmt.Errorf("failed to get download URL from AfkarXYZ: %w", err)
 	}

-	// Verify artist matches
-	if artistName != "" && !amazonArtistsMatch(req.ArtistName, artistName) {
-		GoLog("[Amazon] Artist mismatch: expected '%s', got '%s'. Rejecting.\n", req.ArtistName, artistName)
-		return AmazonDownloadResult{}, fmt.Errorf("artist mismatch: expected '%s', got '%s'", req.ArtistName, artistName)
-	}
+	GoLog("[Amazon] Match found: '%s' by '%s'\n", req.TrackName, req.ArtistName)

-	GoLog("[Amazon] Match found: '%s' by '%s'\n", trackName, artistName)
-
-	filename := buildFilenameFromTemplate(req.FilenameFormat, map[string]interface{}{
+	filename := buildFilenameFromTemplate(req.FilenameFormat, map[string]any{
 		"title":  req.TrackName,
 		"artist": req.ArtistName,
 		"album":  req.AlbumName,
@@ -480,11 +314,18 @@ func downloadFromAmazon(req DownloadRequest) (AmazonDownloadResult, error) {
 		"year":   extractYear(req.ReleaseDate),
 		"disc":   req.DiscNumber,
 	})
-	filename = sanitizeFilename(filename) + ".flac"
-	outputPath := filepath.Join(req.OutputDir, filename)
-
-	if fileInfo, statErr := os.Stat(outputPath); statErr == nil && fileInfo.Size() > 0 {
-		return AmazonDownloadResult{FilePath: "EXISTS:" + outputPath}, nil
+	var outputPath string
+	if isSafOutput {
+		outputPath = strings.TrimSpace(req.OutputPath)
+		if outputPath == "" && isFDOutput(req.OutputFD) {
+			outputPath = fmt.Sprintf("/proc/self/fd/%d", req.OutputFD)
+		}
+	} else {
+		filename = sanitizeFilename(filename) + ".flac"
+		outputPath = filepath.Join(req.OutputDir, filename)
+		if fileInfo, statErr := os.Stat(outputPath); statErr == nil && fileInfo.Size() > 0 {
+			return AmazonDownloadResult{FilePath: "EXISTS:" + outputPath}, nil
+		}
 	}

 	// START PARALLEL: Fetch cover and lyrics while downloading audio
@@ -504,7 +345,7 @@ func downloadFromAmazon(req DownloadRequest) (AmazonDownloadResult, error) {
 	}()

 	// Download audio file with item ID for progress tracking
-	if err := downloader.DownloadFile(downloadURL, outputPath, req.ItemID); err != nil {
+	if err := downloader.DownloadFile(downloadURL, outputPath, req.OutputFD, req.ItemID); err != nil {
 		if errors.Is(err, ErrDownloadCancelled) {
 			return AmazonDownloadResult{}, ErrDownloadCancelled
 		}
@@ -519,14 +360,13 @@ func downloadFromAmazon(req DownloadRequest) (AmazonDownloadResult, error) {
 		SetItemFinalizing(req.ItemID)
 	}

-	// Log track info from DoubleDouble (for debugging)
-	if trackName != "" && artistName != "" {
-		GoLog("[Amazon] DoubleDouble returned: %s - %s\n", artistName, trackName)
-	}
-
 	existingMeta, metaErr := ReadMetadata(outputPath)
 	actualTrackNum := req.TrackNumber
 	actualDiscNum := req.DiscNumber
+	actualDate := req.ReleaseDate
+	actualAlbum := req.AlbumName
+	actualTitle := req.TrackName
+	actualArtist := req.ArtistName

 	if metaErr == nil && existingMeta != nil {
 		if existingMeta.TrackNumber > 0 && (req.TrackNumber == 0 || req.TrackNumber == 1) {
@@ -537,85 +377,111 @@ func downloadFromAmazon(req DownloadRequest) (AmazonDownloadResult, error) {
 			actualDiscNum = existingMeta.DiscNumber
 			GoLog("[Amazon] Using disc number from file: %d (request had: %d)\n", actualDiscNum, req.DiscNumber)
 		}
+		if existingMeta.Date != "" && req.ReleaseDate == "" {
+			actualDate = existingMeta.Date
+			GoLog("[Amazon] Using release date from file: %s\n", actualDate)
+		}
+		if existingMeta.Album != "" && req.AlbumName == "" {
+			actualAlbum = existingMeta.Album
+			GoLog("[Amazon] Using album from file: %s\n", actualAlbum)
+		}
+		GoLog("[Amazon] Existing metadata - Title: %s, Artist: %s, Album: %s, Date: %s\n",
+			existingMeta.Title, existingMeta.Artist, existingMeta.Album, existingMeta.Date)
 	}

-	// Embed metadata using Spotify data (more accurate than DoubleDouble)
-	// But preserve track/disc numbers from file if they were better
 	metadata := Metadata{
-		Title:       req.TrackName,
-		Artist:      req.ArtistName,
-		Album:       req.AlbumName,
+		Title:       actualTitle,
+		Artist:      actualArtist,
+		Album:       actualAlbum,
 		AlbumArtist: req.AlbumArtist,
-		Date:        req.ReleaseDate,
+		Date:        actualDate,
 		TrackNumber: actualTrackNum,
 		TotalTracks: req.TotalTracks,
 		DiscNumber:  actualDiscNum,
 		ISRC:        req.ISRC,
-		Genre:       req.Genre,     // From Deezer album metadata
-		Label:       req.Label,     // From Deezer album metadata
-		Copyright:   req.Copyright, // From Deezer album metadata
+		Genre:       req.Genre,
+		Label:       req.Label,
+		Copyright:   req.Copyright,
 	}

-	// Use cover data from parallel fetch
 	var coverData []byte
-	if parallelResult != nil && parallelResult.CoverData != nil {
+	if parallelResult != nil && parallelResult.CoverData != nil && len(parallelResult.CoverData) > 0 {
 		coverData = parallelResult.CoverData
 		GoLog("[Amazon] Using parallel-fetched cover (%d bytes)\n", len(coverData))
-	}
-
-	if err := EmbedMetadataWithCoverData(outputPath, metadata, coverData); err != nil {
-		fmt.Printf("Warning: failed to embed metadata: %v\n", err)
-	}
-
-	if req.EmbedLyrics && parallelResult != nil && parallelResult.LyricsLRC != "" {
-		lyricsMode := req.LyricsMode
-		if lyricsMode == "" {
-			lyricsMode = "embed" // default
-		}
-
-		if lyricsMode == "external" || lyricsMode == "both" {
-			GoLog("[Amazon] Saving external LRC file...\n")
-			if lrcPath, lrcErr := SaveLRCFile(outputPath, parallelResult.LyricsLRC); lrcErr != nil {
-				GoLog("[Amazon] Warning: failed to save LRC file: %v\n", lrcErr)
-			} else {
-				GoLog("[Amazon] LRC file saved: %s\n", lrcPath)
-			}
-		}
-
-		if lyricsMode == "embed" || lyricsMode == "both" {
-			GoLog("[Amazon] Embedding parallel-fetched lyrics (%d lines)...\n", len(parallelResult.LyricsData.Lines))
-			if embedErr := EmbedLyrics(outputPath, parallelResult.LyricsLRC); embedErr != nil {
-				GoLog("[Amazon] Warning: failed to embed lyrics: %v\n", embedErr)
-			} else {
-				fmt.Println("[Amazon] Lyrics embedded successfully")
-			}
-		}
-	} else if req.EmbedLyrics {
-		fmt.Println("[Amazon] No lyrics available from parallel fetch")
-	}
-
-	fmt.Println("[Amazon] ✓ Downloaded successfully from Amazon Music")
-
-	quality, err := GetAudioQuality(outputPath)
-	if err != nil {
-		GoLog("[Amazon] Warning: couldn't read quality from file: %v\n", err)
 	} else {
-		GoLog("[Amazon] Actual quality: %d-bit/%dHz\n", quality.BitDepth, quality.SampleRate)
+		existingCover, coverErr := ExtractCoverArt(outputPath)
+		if coverErr == nil && len(existingCover) > 0 {
+			coverData = existingCover
+			GoLog("[Amazon] Using existing cover from Amazon file (%d bytes)\n", len(coverData))
+		} else {
+			GoLog("[Amazon] No cover available (parallel fetch failed and no existing cover)\n")
+		}
 	}

-	finalMeta, metaReadErr := ReadMetadata(outputPath)
-	if metaReadErr == nil && finalMeta != nil {
-		GoLog("[Amazon] Final metadata from file - Track: %d, Disc: %d, Date: %s\n",
-			finalMeta.TrackNumber, finalMeta.DiscNumber, finalMeta.Date)
-		actualTrackNum = finalMeta.TrackNumber
-		actualDiscNum = finalMeta.DiscNumber
-		if finalMeta.Date != "" {
-			req.ReleaseDate = finalMeta.Date
+	if isSafOutput {
+		GoLog("[Amazon] SAF output detected - skipping in-backend metadata/lyrics embedding (handled in Flutter)\n")
+	} else {
+		if err := EmbedMetadataWithCoverData(outputPath, metadata, coverData); err != nil {
+			GoLog("[Amazon] Warning: failed to embed metadata: %v\n", err)
+		}
+
+		if req.EmbedLyrics && parallelResult != nil && parallelResult.LyricsLRC != "" {
+			lyricsMode := req.LyricsMode
+			if lyricsMode == "" {
+				lyricsMode = "embed"
+			}
+
+			if lyricsMode == "external" || lyricsMode == "both" {
+				GoLog("[Amazon] Saving external LRC file...\n")
+				if lrcPath, lrcErr := SaveLRCFile(outputPath, parallelResult.LyricsLRC); lrcErr != nil {
+					GoLog("[Amazon] Warning: failed to save LRC file: %v\n", lrcErr)
+				} else {
+					GoLog("[Amazon] LRC file saved: %s\n", lrcPath)
+				}
+			}
+
+			if lyricsMode == "embed" || lyricsMode == "both" {
+				GoLog("[Amazon] Embedding parallel-fetched lyrics (%d lines)...\n", len(parallelResult.LyricsData.Lines))
+				if embedErr := EmbedLyrics(outputPath, parallelResult.LyricsLRC); embedErr != nil {
+					GoLog("[Amazon] Warning: failed to embed lyrics: %v\n", embedErr)
+				} else {
+					GoLog("[Amazon] Lyrics embedded successfully\n")
+				}
+			}
+		} else if req.EmbedLyrics {
+			GoLog("[Amazon] No lyrics available from parallel fetch\n")
+		}
+	}
+
+	GoLog("[Amazon] Downloaded successfully from Amazon Music\n")
+
+	quality := AudioQuality{}
+	if isSafOutput {
+		GoLog("[Amazon] SAF output detected - skipping post-write file inspection in backend\n")
+	} else {
+		quality, err = GetAudioQuality(outputPath)
+		if err != nil {
+			GoLog("[Amazon] Warning: couldn't read quality from file: %v\n", err)
+		} else {
+			GoLog("[Amazon] Actual quality: %d-bit/%dHz\n", quality.BitDepth, quality.SampleRate)
+		}
+
+		finalMeta, metaReadErr := ReadMetadata(outputPath)
+		if metaReadErr == nil && finalMeta != nil {
+			GoLog("[Amazon] Final metadata from file - Track: %d, Disc: %d, Date: %s\n",
+				finalMeta.TrackNumber, finalMeta.DiscNumber, finalMeta.Date)
+			actualTrackNum = finalMeta.TrackNumber
+			actualDiscNum = finalMeta.DiscNumber
+			if finalMeta.Date != "" {
+				req.ReleaseDate = finalMeta.Date
+			}
 		}
 	}

 	// Add to ISRC index for fast duplicate checking
-	AddToISRCIndex(req.OutputDir, req.ISRC, outputPath)
+	if !isSafOutput {
+		AddToISRCIndex(req.OutputDir, req.ISRC, outputPath)
+	}

 	bitDepth := 0
 	sampleRate := 0
@@ -624,6 +490,11 @@ func downloadFromAmazon(req DownloadRequest) (AmazonDownloadResult, error) {
 		sampleRate = quality.SampleRate
 	}

+	lyricsLRC := ""
+	if req.EmbedLyrics && parallelResult != nil && parallelResult.LyricsLRC != "" {
+		lyricsLRC = parallelResult.LyricsLRC
+	}
+
 	return AmazonDownloadResult{
 		FilePath:    outputPath,
 		BitDepth:    bitDepth,
@@ -635,5 +506,6 @@ func downloadFromAmazon(req DownloadRequest) (AmazonDownloadResult, error) {
 		TrackNumber: actualTrackNum,
 		DiscNumber:  actualDiscNum,
 		ISRC:        req.ISRC,
+		LyricsLRC:   lyricsLRC,
 	}, nil
 }
@@ -23,6 +23,11 @@ const (
 	deezerCacheTTL = 10 * time.Minute

 	deezerMaxParallelISRC = 10
+
+	// Deezer API timeout and retry configuration for mobile networks
+	deezerAPITimeoutMobile = 25 * time.Second
+	deezerMaxRetries       = 2
+	deezerRetryDelay       = 500 * time.Millisecond
 )

 type DeezerClient struct {
@@ -42,7 +47,7 @@ var (
 func GetDeezerClient() *DeezerClient {
 	deezerClientOnce.Do(func() {
 		deezerClient = &DeezerClient{
-			httpClient:  NewHTTPClientWithTimeout(15 * time.Second),
+			httpClient:  NewMetadataHTTPClient(deezerAPITimeoutMobile),
 			searchCache: make(map[string]*cacheEntry),
 			albumCache:  make(map[string]*cacheEntry),
 			artistCache: make(map[string]*cacheEntry),
@@ -55,7 +60,7 @@ func GetDeezerClient() *DeezerClient {
 type deezerTrack struct {
 	ID            int64             `json:"id"`
 	Title         string            `json:"title"`
-	Duration      int               `json:"duration"` // in seconds
+	Duration      int               `json:"duration"`
 	TrackPosition int               `json:"track_position"`
 	DiskNumber    int               `json:"disk_number"`
 	ISRC          string            `json:"isrc"`
@@ -121,7 +126,7 @@ func (c *DeezerClient) convertTrack(track deezerTrack) TrackMetadata {
 		AlbumArtist: track.Artist.Name,
 		DurationMS:  track.Duration * 1000,
 		Images:      albumImage,
-		ReleaseDate: releaseDate, // Added this
+		ReleaseDate: releaseDate,
 		TrackNumber: track.TrackPosition,
 		DiscNumber:  track.DiskNumber,
 		ExternalURL: track.Link,
@@ -182,11 +187,38 @@ type deezerPlaylistFull struct {
 	} `json:"tracks"`
 }

-// NOTE: ISRC is NOT fetched during search for performance - use GetTrackISRC when needed for download
-func (c *DeezerClient) SearchAll(ctx context.Context, query string, trackLimit, artistLimit int) (*SearchAllResult, error) {
-	GoLog("[Deezer] SearchAll: query=%q, trackLimit=%d, artistLimit=%d\n", query, trackLimit, artistLimit)
+func (c *DeezerClient) SearchAll(ctx context.Context, query string, trackLimit, artistLimit int, filter string) (*SearchAllResult, error) {
+	GoLog("[Deezer] SearchAll: query=%q, trackLimit=%d, artistLimit=%d, filter=%q\n", query, trackLimit, artistLimit, filter)

-	cacheKey := fmt.Sprintf("deezer:all:%s:%d:%d", query, trackLimit, artistLimit)
+	albumLimit := 5
+	playlistLimit := 5
+
+	if filter != "" {
+		switch filter {
+		case "track":
+			trackLimit = 50
+			artistLimit = 0
+			albumLimit = 0
+			playlistLimit = 0
+		case "artist":
+			trackLimit = 0
+			artistLimit = 20
+			albumLimit = 0
+			playlistLimit = 0
+		case "album":
+			trackLimit = 0
+			artistLimit = 0
+			albumLimit = 20
+			playlistLimit = 0
+		case "playlist":
+			trackLimit = 0
+			artistLimit = 0
+			albumLimit = 0
+			playlistLimit = 20
+		}
+	}
+
+	cacheKey := fmt.Sprintf("deezer:all:%s:%d:%d:%d:%d:%s", query, trackLimit, artistLimit, albumLimit, playlistLimit, filter)

 	c.cacheMu.RLock()
 	if entry, ok := c.searchCache[cacheKey]; ok && !entry.isExpired() {
@@ -197,69 +229,189 @@ func (c *DeezerClient) SearchAll(ctx context.Context, query string, trackLimit,
 	c.cacheMu.RUnlock()

 	result := &SearchAllResult{
-		Tracks:  make([]TrackMetadata, 0, trackLimit),
-		Artists: make([]SearchArtistResult, 0, artistLimit),
+		Tracks:    make([]TrackMetadata, 0, trackLimit),
+		Artists:   make([]SearchArtistResult, 0, artistLimit),
+		Albums:    make([]SearchAlbumResult, 0, albumLimit),
+		Playlists: make([]SearchPlaylistResult, 0, playlistLimit),
 	}

-	// Search tracks - NO ISRC fetch for performance
-	trackURL := fmt.Sprintf("%s/track?q=%s&limit=%d", deezerSearchURL, url.QueryEscape(query), trackLimit)
-	GoLog("[Deezer] Fetching tracks from: %s\n", trackURL)
+	if trackLimit > 0 {
+		trackURL := fmt.Sprintf("%s/track?q=%s&limit=%d", deezerSearchURL, url.QueryEscape(query), trackLimit)
+		GoLog("[Deezer] Fetching tracks from: %s\n", trackURL)

-	var trackResp struct {
-		Data  []deezerTrack `json:"data"`
-		Error *struct {
-			Type    string `json:"type"`
-			Message string `json:"message"`
-			Code    int    `json:"code"`
-		} `json:"error"`
-	}
-	if err := c.getJSON(ctx, trackURL, &trackResp); err != nil {
-		GoLog("[Deezer] Track search failed: %v\n", err)
-		return nil, fmt.Errorf("deezer track search failed: %w", err)
-	}
-
-	if trackResp.Error != nil {
-		GoLog("[Deezer] API error: type=%s, code=%d, message=%s\n", trackResp.Error.Type, trackResp.Error.Code, trackResp.Error.Message)
-		return nil, fmt.Errorf("deezer API error: %s (code %d)", trackResp.Error.Message, trackResp.Error.Code)
-	}
-
-	GoLog("[Deezer] Got %d tracks from API\n", len(trackResp.Data))
-
-	for _, track := range trackResp.Data {
-		result.Tracks = append(result.Tracks, c.convertTrack(track))
-	}
-
-	artistURL := fmt.Sprintf("%s/artist?q=%s&limit=%d", deezerSearchURL, url.QueryEscape(query), artistLimit)
-	GoLog("[Deezer] Fetching artists from: %s\n", artistURL)
-
-	var artistResp struct {
-		Data  []deezerArtist `json:"data"`
-		Error *struct {
-			Type    string `json:"type"`
-			Message string `json:"message"`
-			Code    int    `json:"code"`
-		} `json:"error"`
-	}
-	if err := c.getJSON(ctx, artistURL, &artistResp); err == nil {
-		if artistResp.Error != nil {
-			GoLog("[Deezer] Artist API error: type=%s, code=%d, message=%s\n", artistResp.Error.Type, artistResp.Error.Code, artistResp.Error.Message)
-		} else {
-			GoLog("[Deezer] Got %d artists from API\n", len(artistResp.Data))
-			for _, artist := range artistResp.Data {
-				result.Artists = append(result.Artists, SearchArtistResult{
-					ID:         fmt.Sprintf("deezer:%d", artist.ID),
-					Name:       artist.Name,
-					Images:     c.getBestArtistImage(artist),
-					Followers:  artist.NbFan,
-					Popularity: 0,
-				})
-			}
+		var trackResp struct {
+			Data  []deezerTrack `json:"data"`
+			Error *struct {
+				Type    string `json:"type"`
+				Message string `json:"message"`
+				Code    int    `json:"code"`
+			} `json:"error"`
+		}
+		if err := c.getJSON(ctx, trackURL, &trackResp); err != nil {
+			GoLog("[Deezer] Track search failed: %v\n", err)
+			return nil, fmt.Errorf("deezer track search failed: %w", err)
+		}
+
+		if trackResp.Error != nil {
+			GoLog("[Deezer] API error: type=%s, code=%d, message=%s\n", trackResp.Error.Type, trackResp.Error.Code, trackResp.Error.Message)
+			return nil, fmt.Errorf("deezer API error: %s (code %d)", trackResp.Error.Message, trackResp.Error.Code)
+		}
+
+		GoLog("[Deezer] Got %d tracks from API\n", len(trackResp.Data))
+
+		for _, track := range trackResp.Data {
+			result.Tracks = append(result.Tracks, c.convertTrack(track))
 		}
-	} else {
-		GoLog("[Deezer] Artist search failed: %v\n", err)
 	}

-	GoLog("[Deezer] SearchAll complete: %d tracks, %d artists\n", len(result.Tracks), len(result.Artists))
+	if artistLimit > 0 {
+		artistURL := fmt.Sprintf("%s/artist?q=%s&limit=%d", deezerSearchURL, url.QueryEscape(query), artistLimit)
+		GoLog("[Deezer] Fetching artists from: %s\n", artistURL)
+
+		var artistResp struct {
+			Data  []deezerArtist `json:"data"`
+			Error *struct {
+				Type    string `json:"type"`
+				Message string `json:"message"`
+				Code    int    `json:"code"`
+			} `json:"error"`
+		}
+		if err := c.getJSON(ctx, artistURL, &artistResp); err == nil {
+			if artistResp.Error != nil {
+				GoLog("[Deezer] Artist API error: type=%s, code=%d, message=%s\n", artistResp.Error.Type, artistResp.Error.Code, artistResp.Error.Message)
+			} else {
+				GoLog("[Deezer] Got %d artists from API\n", len(artistResp.Data))
+				for _, artist := range artistResp.Data {
+					result.Artists = append(result.Artists, SearchArtistResult{
+						ID:         fmt.Sprintf("deezer:%d", artist.ID),
+						Name:       artist.Name,
+						Images:     c.getBestArtistImage(artist),
+						Followers:  artist.NbFan,
+						Popularity: 0,
+					})
+				}
+			}
+		} else {
+			GoLog("[Deezer] Artist search failed: %v\n", err)
+		}
+	}
+
+	if albumLimit > 0 {
+		albumURL := fmt.Sprintf("%s/album?q=%s&limit=%d", deezerSearchURL, url.QueryEscape(query), albumLimit)
+		GoLog("[Deezer] Fetching albums from: %s\n", albumURL)
+
+		var albumResp struct {
+			Data []struct {
+				ID          int64        `json:"id"`
+				Title       string       `json:"title"`
+				Cover       string       `json:"cover"`
+				CoverMedium string       `json:"cover_medium"`
+				CoverBig    string       `json:"cover_big"`
+				CoverXL     string       `json:"cover_xl"`
+				NbTracks    int          `json:"nb_tracks"`
+				ReleaseDate string       `json:"release_date"`
+				RecordType  string       `json:"record_type"`
+				Artist      deezerArtist `json:"artist"`
+			} `json:"data"`
+			Error *struct {
+				Type    string `json:"type"`
+				Message string `json:"message"`
+				Code    int    `json:"code"`
+			} `json:"error"`
+		}
+		if err := c.getJSON(ctx, albumURL, &albumResp); err == nil {
+			if albumResp.Error != nil {
+				GoLog("[Deezer] Album API error: type=%s, code=%d, message=%s\n", albumResp.Error.Type, albumResp.Error.Code, albumResp.Error.Message)
+			} else {
+				GoLog("[Deezer] Got %d albums from API\n", len(albumResp.Data))
+				for _, album := range albumResp.Data {
+					coverURL := album.CoverXL
+					if coverURL == "" {
+						coverURL = album.CoverBig
+					}
+					if coverURL == "" {
+						coverURL = album.CoverMedium
+					}
+					if coverURL == "" {
+						coverURL = album.Cover
+					}
+
+					albumType := album.RecordType
+					if albumType == "compile" {
+						albumType = "compilation"
+					}
+
+					result.Albums = append(result.Albums, SearchAlbumResult{
+						ID:          fmt.Sprintf("deezer:%d", album.ID),
+						Name:        album.Title,
+						Artists:     album.Artist.Name,
+						Images:      coverURL,
+						ReleaseDate: album.ReleaseDate,
+						TotalTracks: album.NbTracks,
+						AlbumType:   albumType,
+					})
+				}
+			}
+		} else {
+			GoLog("[Deezer] Album search failed: %v\n", err)
+		}
+	}
+
+	if playlistLimit > 0 {
+		playlistURL := fmt.Sprintf("%s/playlist?q=%s&limit=%d", deezerSearchURL, url.QueryEscape(query), playlistLimit)
+		GoLog("[Deezer] Fetching playlists from: %s\n", playlistURL)
+
+		var playlistResp struct {
+			Data []struct {
+				ID            int64  `json:"id"`
+				Title         string `json:"title"`
+				Picture       string `json:"picture"`
+				PictureMedium string `json:"picture_medium"`
+				PictureBig    string `json:"picture_big"`
+				PictureXL     string `json:"picture_xl"`
+				NbTracks      int    `json:"nb_tracks"`
+				User          struct {
+					Name string `json:"name"`
+				} `json:"user"`
+			} `json:"data"`
+			Error *struct {
+				Type    string `json:"type"`
+				Message string `json:"message"`
+				Code    int    `json:"code"`
+			} `json:"error"`
+		}
+		if err := c.getJSON(ctx, playlistURL, &playlistResp); err == nil {
+			if playlistResp.Error != nil {
+				GoLog("[Deezer] Playlist API error: type=%s, code=%d, message=%s\n", playlistResp.Error.Type, playlistResp.Error.Code, playlistResp.Error.Message)
+			} else {
+				GoLog("[Deezer] Got %d playlists from API\n", len(playlistResp.Data))
+				for _, playlist := range playlistResp.Data {
+					pictureURL := playlist.PictureXL
+					if pictureURL == "" {
+						pictureURL = playlist.PictureBig
+					}
+					if pictureURL == "" {
+						pictureURL = playlist.PictureMedium
+					}
+					if pictureURL == "" {
+						pictureURL = playlist.Picture
+					}
+
+					result.Playlists = append(result.Playlists, SearchPlaylistResult{
+						ID:          fmt.Sprintf("deezer:%d", playlist.ID),
+						Name:        playlist.Title,
+						Owner:       playlist.User.Name,
+						Images:      pictureURL,
+						TotalTracks: playlist.NbTracks,
+					})
+				}
+			}
+		} else {
+			GoLog("[Deezer] Playlist search failed: %v\n", err)
+		}
+	}
+
+	GoLog("[Deezer] SearchAll complete: %d tracks, %d artists, %d albums, %d playlists\n", len(result.Tracks), len(result.Artists), len(result.Albums), len(result.Playlists))

 	c.cacheMu.Lock()
 	c.searchCache[cacheKey] = &cacheEntry{
@@ -271,7 +423,6 @@ func (c *DeezerClient) SearchAll(ctx context.Context, query string, trackLimit,
 	return result, nil
 }

-// GetTrack fetches a single track by Deezer ID
 func (c *DeezerClient) GetTrack(ctx context.Context, trackID string) (*TrackResponse, error) {
 	trackURL := fmt.Sprintf(deezerTrackURL, trackID)

@@ -285,7 +436,6 @@ func (c *DeezerClient) GetTrack(ctx context.Context, trackID string) (*TrackResp
 	}, nil
 }

-// ISRC is fetched in parallel for better performance
 func (c *DeezerClient) GetAlbum(ctx context.Context, albumID string) (*AlbumResponsePayload, error) {
 	c.cacheMu.RLock()
 	if entry, ok := c.albumCache[albumID]; ok && !entry.isExpired() {
@@ -311,7 +461,6 @@ func (c *DeezerClient) GetAlbum(ctx context.Context, albumID string) (*AlbumResp
 		artistName = strings.Join(names, ", ")
 	}

-	// Extract genres as comma-separated string
 	var genres []string
 	for _, g := range album.Genres.Data {
 		if g.Name != "" {
@@ -327,23 +476,60 @@ func (c *DeezerClient) GetAlbum(ctx context.Context, albumID string) (*AlbumResp
 		Artists:     artistName,
 		ArtistId:    fmt.Sprintf("deezer:%d", album.Artist.ID),
 		Images:      albumImage,
-		Genre:       genreStr,    // From Deezer album
-		Label:       album.Label, // From Deezer album
+		Genre:       genreStr,
+		Label:       album.Label,
 	}

-	isrcMap := c.fetchISRCsParallel(ctx, album.Tracks.Data)
+	allTracks := album.Tracks.Data

-	tracks := make([]AlbumTrackMetadata, 0, len(album.Tracks.Data))
-	// Normalize record_type (Deezer uses "compile" instead of "compilation")
+	if album.NbTracks > len(allTracks) {
+		GoLog("[Deezer] Album has %d tracks but only got %d, fetching remaining...", album.NbTracks, len(allTracks))
+
+		tracksURL := fmt.Sprintf("%s/tracks?limit=100&index=%d", fmt.Sprintf(deezerAlbumURL, albumID), len(allTracks))
+
+		for len(allTracks) < album.NbTracks {
+			var tracksResp struct {
+				Data []deezerTrack `json:"data"`
+				Next string        `json:"next"`
+			}
+
+			if err := c.getJSON(ctx, tracksURL, &tracksResp); err != nil {
+				GoLog("[Deezer] Warning: failed to fetch album tracks page: %v", err)
+				break
+			}
+
+			if len(tracksResp.Data) == 0 {
+				break
+			}
+
+			allTracks = append(allTracks, tracksResp.Data...)
+
+			if tracksResp.Next == "" {
+				break
+			}
+			tracksURL = tracksResp.Next
+		}
+
+		GoLog("[Deezer] Fetched total %d tracks for album", len(allTracks))
+	}
+
+	isrcMap := c.fetchISRCsParallel(ctx, allTracks)
+
+	tracks := make([]AlbumTrackMetadata, 0, len(allTracks))
 	albumType := album.RecordType
 	if albumType == "compile" {
 		albumType = "compilation"
 	}

-	for _, track := range album.Tracks.Data {
+	for i, track := range allTracks {
 		trackIDStr := fmt.Sprintf("%d", track.ID)
 		isrc := isrcMap[trackIDStr]

+		trackNum := track.TrackPosition
+		if trackNum == 0 {
+			trackNum = i + 1
+		}
+
 		tracks = append(tracks, AlbumTrackMetadata{
 			SpotifyID:   fmt.Sprintf("deezer:%d", track.ID),
 			Artists:     track.Artist.Name,
@@ -353,7 +539,7 @@ func (c *DeezerClient) GetAlbum(ctx context.Context, albumID string) (*AlbumResp
 			DurationMS:  track.Duration * 1000,
 			Images:      albumImage,
 			ReleaseDate: album.ReleaseDate,
-			TrackNumber: track.TrackPosition,
+			TrackNumber: trackNum,
 			TotalTracks: album.NbTracks,
 			DiscNumber:  track.DiskNumber,
 			ExternalURL: track.Link,
@@ -386,7 +572,6 @@ func (c *DeezerClient) GetArtist(ctx context.Context, artistID string) (*ArtistR
 	}
 	c.cacheMu.RUnlock()

-	// Fetch artist info
 	artistURL := fmt.Sprintf(deezerArtistURL, artistID)
 	var artist deezerArtistFull
 	if err := c.getJSON(ctx, artistURL, &artist); err != nil {
@@ -401,7 +586,6 @@ func (c *DeezerClient) GetArtist(ctx context.Context, artistID string) (*ArtistR
 		Popularity: 0,
 	}

-	// Fetch artist albums
 	albumsURL := fmt.Sprintf("%s/albums?limit=100", fmt.Sprintf(deezerArtistURL, artistID))
 	var albumsResp struct {
 		Data []struct {
@@ -413,7 +597,7 @@ func (c *DeezerClient) GetArtist(ctx context.Context, artistID string) (*ArtistR
 			CoverMedium string `json:"cover_medium"`
 			CoverBig    string `json:"cover_big"`
 			CoverXL     string `json:"cover_xl"`
-			RecordType  string `json:"record_type"` // album, single, ep, compile
+			RecordType  string `json:"record_type"`
 		} `json:"data"`
 	}

@@ -485,10 +669,43 @@ func (c *DeezerClient) GetPlaylist(ctx context.Context, playlistID string) (*Pla
 	info.Owner.Name = playlist.Title
 	info.Owner.Images = playlistImage

-	isrcMap := c.fetchISRCsParallel(ctx, playlist.Tracks.Data)
+	allTracks := playlist.Tracks.Data

-	tracks := make([]AlbumTrackMetadata, 0, len(playlist.Tracks.Data))
-	for _, track := range playlist.Tracks.Data {
+	if playlist.NbTracks > len(allTracks) {
+		GoLog("[Deezer] Playlist has %d tracks but only got %d, fetching remaining...", playlist.NbTracks, len(allTracks))
+
+		tracksURL := fmt.Sprintf("%s/tracks?limit=100&index=%d", fmt.Sprintf(deezerPlaylistURL, playlistID), len(allTracks))
+
+		for len(allTracks) < playlist.NbTracks {
+			var tracksResp struct {
+				Data []deezerTrack `json:"data"`
+				Next string        `json:"next"`
+			}
+
+			if err := c.getJSON(ctx, tracksURL, &tracksResp); err != nil {
+				GoLog("[Deezer] Warning: failed to fetch playlist tracks page: %v", err)
+				break
+			}
+
+			if len(tracksResp.Data) == 0 {
+				break
+			}
+
+			allTracks = append(allTracks, tracksResp.Data...)
+
+			if tracksResp.Next == "" {
+				break
+			}
+			tracksURL = tracksResp.Next
+		}
+
+		GoLog("[Deezer] Fetched total %d tracks for playlist", len(allTracks))
+	}
+
+	isrcMap := c.fetchISRCsParallel(ctx, allTracks)
+
+	tracks := make([]AlbumTrackMetadata, 0, len(allTracks))
+	for _, track := range allTracks {
 		albumImage := track.Album.CoverXL
 		if albumImage == "" {
 			albumImage = track.Album.CoverBig
@@ -559,7 +776,6 @@ func (c *DeezerClient) fetchFullTrack(ctx context.Context, trackID string) (*dee
 	return &track, nil
 }

-// fetchISRCsParallel fetches ISRCs for multiple tracks in parallel with caching
 func (c *DeezerClient) fetchISRCsParallel(ctx context.Context, tracks []deezerTrack) map[string]string {
 	result := make(map[string]string, len(tracks))
 	var resultMu sync.Mutex
@@ -598,7 +814,6 @@ func (c *DeezerClient) fetchISRCsParallel(ctx context.Context, tracks []deezerTr
 		return result
 	}

-	// Use semaphore to limit concurrent requests
 	sem := make(chan struct{}, deezerMaxParallelISRC)
 	var wg sync.WaitGroup

@@ -620,7 +835,6 @@ func (c *DeezerClient) fetchISRCsParallel(ctx context.Context, tracks []deezerTr
 				return
 			}

-			// Store in result and cache
 			resultMu.Lock()
 			result[trackIDStr] = fullTrack.ISRC
 			resultMu.Unlock()
@@ -635,7 +849,6 @@ func (c *DeezerClient) fetchISRCsParallel(ctx context.Context, tracks []deezerTr
 	return result
 }

-// Use this when you need ISRC for download
 func (c *DeezerClient) GetTrackISRC(ctx context.Context, trackID string) (string, error) {
 	c.cacheMu.RLock()
 	if isrc, ok := c.isrcCache[trackID]; ok {
@@ -696,11 +909,10 @@ func (c *DeezerClient) getBestAlbumImage(album deezerAlbumFull) string {
 }

 type AlbumExtendedMetadata struct {
-	Genre string // Comma-separated list of genres
-	Label string // Record label name
+	Genre string
+	Label string
 }

-// Uses the album ID from a track to fetch extended metadata
 func (c *DeezerClient) GetAlbumExtendedMetadata(ctx context.Context, albumID string) (*AlbumExtendedMetadata, error) {
 	if albumID == "" {
 		return nil, fmt.Errorf("empty album ID")
@@ -745,7 +957,6 @@ func (c *DeezerClient) GetAlbumExtendedMetadata(ctx context.Context, albumID str
 	return result, nil
 }

-// GetTrackAlbumID fetches the album ID for a Deezer track
 func (c *DeezerClient) GetTrackAlbumID(ctx context.Context, trackID string) (string, error) {
 	trackURL := fmt.Sprintf(deezerTrackURL, trackID)

@@ -757,7 +968,6 @@ func (c *DeezerClient) GetTrackAlbumID(ctx context.Context, trackID string) (str
 	return fmt.Sprintf("%d", track.Album.ID), nil
 }

-// This is a convenience function that first gets the album ID, then fetches album metadata
 func (c *DeezerClient) GetExtendedMetadataByTrackID(ctx context.Context, trackID string) (*AlbumExtendedMetadata, error) {
 	albumID, err := c.GetTrackAlbumID(ctx, trackID)
 	if err != nil {
@@ -767,33 +977,62 @@ func (c *DeezerClient) GetExtendedMetadataByTrackID(ctx context.Context, trackID
 	return c.GetAlbumExtendedMetadata(ctx, albumID)
 }

-// GetExtendedMetadataByISRC searches for a track by ISRC and fetches extended metadata (genre, label)
 func (c *DeezerClient) GetExtendedMetadataByISRC(ctx context.Context, isrc string) (*AlbumExtendedMetadata, error) {
 	if isrc == "" {
 		return nil, fmt.Errorf("empty ISRC")
 	}

-	// First, search for track by ISRC
 	track, err := c.SearchByISRC(ctx, isrc)
 	if err != nil {
 		return nil, fmt.Errorf("failed to find track by ISRC: %w", err)
 	}

-	// SpotifyID contains "deezer:123" format, extract the ID
-	deezerID := track.SpotifyID
-	if strings.HasPrefix(deezerID, "deezer:") {
-		deezerID = strings.TrimPrefix(deezerID, "deezer:")
-	}
+	deezerID := strings.TrimPrefix(track.SpotifyID, "deezer:")

 	if deezerID == "" {
 		return nil, fmt.Errorf("track found but no Deezer ID")
 	}

-	// Then fetch extended metadata using the Deezer track ID
 	return c.GetExtendedMetadataByTrackID(ctx, deezerID)
 }

 func (c *DeezerClient) getJSON(ctx context.Context, endpoint string, dst interface{}) error {
+	var lastErr error
+
+	for attempt := 0; attempt <= deezerMaxRetries; attempt++ {
+		if attempt > 0 {
+			delay := deezerRetryDelay * time.Duration(1<<(attempt-1)) // Exponential backoff
+			GoLog("[Deezer] Retry %d/%d after %v...\n", attempt, deezerMaxRetries, delay)
+			time.Sleep(delay)
+		}
+
+		err := c.doGetJSON(ctx, endpoint, dst)
+		if err == nil {
+			return nil
+		}
+
+		lastErr = err
+		errStr := err.Error()
+
+		// Check if error is retryable
+		isRetryable := strings.Contains(errStr, "timeout") ||
+			strings.Contains(errStr, "connection reset") ||
+			strings.Contains(errStr, "connection refused") ||
+			strings.Contains(errStr, "EOF") ||
+			strings.Contains(errStr, "status 5") ||
+			strings.Contains(errStr, "status 429")
+
+		if !isRetryable {
+			return err
+		}
+
+		GoLog("[Deezer] Attempt %d failed (retryable): %v\n", attempt+1, err)
+	}
+
+	return fmt.Errorf("all %d attempts failed: %w", deezerMaxRetries+1, lastErr)
+}
+
+func (c *DeezerClient) doGetJSON(ctx context.Context, endpoint string, dst interface{}) error {
 	req, err := http.NewRequestWithContext(ctx, http.MethodGet, endpoint, nil)
 	if err != nil {
 		return err
@@ -819,7 +1058,6 @@ func (c *DeezerClient) getJSON(ctx context.Context, endpoint string, dst interfa
 	return json.Unmarshal(body, dst)
 }

-// parseDeezerURL is internal function, returns type and ID
 func parseDeezerURL(input string) (string, string, error) {
 	trimmed := strings.TrimSpace(input)
 	if trimmed == "" {
@@ -10,7 +10,6 @@ import (
 	"time"
 )

-// ISRCIndex holds a cached map of ISRC -> file path for fast duplicate checking
 type ISRCIndex struct {
 	index     map[string]string // ISRC (uppercase) -> file path
 	outputDir string
@@ -25,8 +24,6 @@ var (
 	isrcIndexTTL     = 5 * time.Minute
 )

-// GetISRCIndex returns or builds an ISRC index for the given directory
-// Uses per-directory mutex to prevent concurrent builds (race condition fix)
 func GetISRCIndex(outputDir string) *ISRCIndex {
 	// Fast path: check cache first
 	isrcIndexCacheMu.RLock()
@@ -56,7 +53,6 @@ func GetISRCIndex(outputDir string) *ISRCIndex {
 	return buildISRCIndex(outputDir)
 }

-// buildISRCIndex scans a directory and builds a map of ISRC -> file path
 func buildISRCIndex(outputDir string) *ISRCIndex {
 	idx := &ISRCIndex{
 		index:     make(map[string]string),
@@ -91,7 +87,7 @@ func buildISRCIndex(outputDir string) *ISRCIndex {
 		return nil
 	})

-	fmt.Printf("[ISRCIndex] Built index for %s: %d files in %v\n", 
+	fmt.Printf("[ISRCIndex] Built index for %s: %d files in %v\n",
 		outputDir, fileCount, time.Since(startTime).Round(time.Millisecond))

 	isrcIndexCacheMu.Lock()
@@ -113,7 +109,6 @@ func (idx *ISRCIndex) lookup(isrc string) (string, bool) {
 	return path, exists
 }

-// remove deletes an ISRC entry from the index (internal use)
 func (idx *ISRCIndex) remove(isrc string) {
 	if isrc == "" {
 		return
@@ -125,14 +120,11 @@ func (idx *ISRCIndex) remove(isrc string) {
 	delete(idx.index, strings.ToUpper(isrc))
 }

-// Lookup checks if an ISRC exists in the index (gomobile compatible)
-// Returns filepath if found, empty string if not found
 func (idx *ISRCIndex) Lookup(isrc string) (string, error) {
 	path, _ := idx.lookup(isrc)
 	return path, nil
 }

-// Add adds a new ISRC to the index (call after successful download)
 func (idx *ISRCIndex) Add(isrc, filePath string) {
 	if isrc == "" || filePath == "" {
 		return
@@ -144,15 +136,12 @@ func (idx *ISRCIndex) Add(isrc, filePath string) {
 	idx.index[strings.ToUpper(isrc)] = filePath
 }

-// InvalidateCache clears the ISRC index cache for a directory
 func InvalidateISRCCache(outputDir string) {
 	isrcIndexCacheMu.Lock()
 	delete(isrcIndexCache, outputDir)
 	isrcIndexCacheMu.Unlock()
 }

-// checkISRCExistsInternal checks if a file with the given ISRC exists (internal use)
-// Uses ISRC index for fast lookup
 func checkISRCExistsInternal(outputDir, isrc string) (string, bool) {
 	if isrc == "" || outputDir == "" {
 		return "", false
@@ -173,13 +162,11 @@ func checkISRCExistsInternal(outputDir, isrc string) (string, bool) {
 	return filePath, true
 }

-// CheckISRCExists is the exported version for gomobile (returns string, error)
 func CheckISRCExists(outputDir, isrc string) (string, error) {
 	filepath, _ := checkISRCExistsInternal(outputDir, isrc)
 	return filepath, nil
 }

-// CheckFileExists checks if a file with the given name exists
 func CheckFileExists(filePath string) bool {
 	info, err := os.Stat(filePath)
 	if err != nil {
@@ -188,7 +175,6 @@ func CheckFileExists(filePath string) bool {
 	return !info.IsDir() && info.Size() > 0
 }

-// FileExistenceResult represents the result of checking if a file exists
 type FileExistenceResult struct {
 	ISRC       string `json:"isrc"`
 	Exists     bool   `json:"exists"`
@@ -249,8 +235,6 @@ func CheckFilesExistParallel(outputDir string, tracksJSON string) (string, error
 	return string(resultJSON), nil
 }

-// PreBuildISRCIndex pre-builds the ISRC index for a directory
-// Call this when app starts or when entering album/playlist screen
 func PreBuildISRCIndex(outputDir string) error {
 	if outputDir == "" {
 		return fmt.Errorf("output directory is required")
@@ -260,7 +244,6 @@ func PreBuildISRCIndex(outputDir string) error {
 	return nil
 }

-// AddToISRCIndex adds a new file to the ISRC index after successful download
 func AddToISRCIndex(outputDir, isrc, filePath string) {
 	if outputDir == "" || isrc == "" || filePath == "" {
 		return
@@ -47,7 +47,7 @@ type LoadedExtension struct {
 	ID        string             `json:"id"`
 	Manifest  *ExtensionManifest `json:"manifest"`
 	VM        *goja.Runtime      `json:"-"`
-	VMMu      sync.Mutex         `json:"-"` // Mutex to prevent concurrent VM access
+	VMMu      sync.Mutex         `json:"-"`
 	Enabled   bool               `json:"enabled"`
 	Error     string             `json:"error,omitempty"`
 	DataDir   string             `json:"data_dir"`
@@ -55,12 +55,11 @@ type LoadedExtension struct {
 	IconPath  string             `json:"icon_path"`
 }

-// ExtensionManager manages all loaded extensions
 type ExtensionManager struct {
 	mu            sync.RWMutex
 	extensions    map[string]*LoadedExtension
-	extensionsDir string // Base directory for extensions
-	dataDir       string // Base directory for extension data
+	extensionsDir string
+	dataDir       string
 }

 var (
@@ -99,7 +98,6 @@ func (m *ExtensionManager) LoadExtensionFromFile(filePath string) (*LoadedExtens
 		return nil, fmt.Errorf("Invalid file format. Please select a .spotiflac-ext file")
 	}

-	// Open the zip file
 	zipReader, err := zip.OpenReader(filePath)
 	if err != nil {
 		return nil, fmt.Errorf("Cannot open extension file. The file may be corrupted or not a valid extension package")
@@ -222,7 +220,6 @@ func (m *ExtensionManager) LoadExtensionFromFile(filePath string) (*LoadedExtens
 		SourceDir: extDir,
 	}

-	// Initialize Goja VM
 	if err := m.initializeVM(ext); err != nil {
 		ext.Error = err.Error()
 		ext.Enabled = false
@@ -269,13 +266,11 @@ func (m *ExtensionManager) initializeVM(ext *LoadedExtension) error {
 		return goja.Undefined()
 	})

-	// Run the extension code
 	_, err = vm.RunString(string(jsCode))
 	if err != nil {
 		return fmt.Errorf("failed to execute extension code: %w", err)
 	}

-	// Verify extension was registered
 	if registeredExtension == nil || goja.IsUndefined(registeredExtension) {
 		return fmt.Errorf("extension did not call registerExtension()")
 	}
@@ -283,7 +278,6 @@ func (m *ExtensionManager) initializeVM(ext *LoadedExtension) error {
 	return nil
 }

-// UnloadExtension unloads an extension by ID
 func (m *ExtensionManager) UnloadExtension(extensionID string) error {
 	m.mu.Lock()
 	defer m.mu.Unlock()
@@ -293,9 +287,7 @@ func (m *ExtensionManager) UnloadExtension(extensionID string) error {
 		return fmt.Errorf("Extension not found")
 	}

-	// Call cleanup if VM is initialized
 	if ext.VM != nil {
-		// Try to call cleanup function
 		cleanup, err := ext.VM.RunString("typeof extension !== 'undefined' && typeof extension.cleanup === 'function' ? extension.cleanup() : null")
 		if err != nil {
 			GoLog("[Extension] Error calling cleanup for %s: %v\n", extensionID, err)
@@ -304,14 +296,12 @@ func (m *ExtensionManager) UnloadExtension(extensionID string) error {
 		}
 	}

-	// Remove from registry
 	delete(m.extensions, extensionID)
 	GoLog("[Extension] Unloaded extension: %s\n", extensionID)

 	return nil
 }

-// Returns error if extension not found (gomobile compatible)
 func (m *ExtensionManager) GetExtension(extensionID string) (*LoadedExtension, error) {
 	m.mu.RLock()
 	defer m.mu.RUnlock()
@@ -323,7 +313,6 @@ func (m *ExtensionManager) GetExtension(extensionID string) (*LoadedExtension, e
 	return ext, nil
 }

-// GetAllExtensions returns all loaded extensions
 func (m *ExtensionManager) GetAllExtensions() []*LoadedExtension {
 	m.mu.RLock()
 	defer m.mu.RUnlock()
@@ -347,7 +336,6 @@ func (m *ExtensionManager) SetExtensionEnabled(extensionID string, enabled bool)
 	ext.Enabled = enabled
 	GoLog("[Extension] %s %s\n", extensionID, map[bool]string{true: "enabled", false: "disabled"}[enabled])

-	// Persist enabled state to settings store
 	store := GetExtensionSettingsStore()
 	if err := store.Set(extensionID, "_enabled", enabled); err != nil {
 		GoLog("[Extension] Failed to persist enabled state for %s: %v\n", extensionID, err)
@@ -356,7 +344,6 @@ func (m *ExtensionManager) SetExtensionEnabled(extensionID string, enabled bool)
 	return nil
 }

-// LoadExtensionsFromDirectory scans a directory and loads all valid extensions
 func (m *ExtensionManager) LoadExtensionsFromDirectory(dirPath string) ([]string, []error) {
 	var loaded []string
 	var errors []error
@@ -443,7 +430,6 @@ func (m *ExtensionManager) loadExtensionFromDirectory(dirPath string) (*LoadedEx
 		}
 	}

-	// Initialize Goja VM
 	if err := m.initializeVM(ext); err != nil {
 		ext.Error = err.Error()
 		ext.Enabled = false
@@ -456,19 +442,16 @@ func (m *ExtensionManager) loadExtensionFromDirectory(dirPath string) (*LoadedEx
 	return ext, nil
 }

-// RemoveExtension completely removes an extension (unload + delete files)
 func (m *ExtensionManager) RemoveExtension(extensionID string) error {
 	ext, err := m.GetExtension(extensionID)
 	if err != nil {
 		return err
 	}

-	// Unload first
 	if err := m.UnloadExtension(extensionID); err != nil {
 		return err
 	}

-	// Remove source directory
 	if ext.SourceDir != "" {
 		if err := os.RemoveAll(ext.SourceDir); err != nil {
 			GoLog("[Extension] Warning: failed to remove source dir: %v\n", err)
@@ -490,7 +473,6 @@ func (m *ExtensionManager) UpgradeExtension(filePath string) (*LoadedExtension,
 		return nil, fmt.Errorf("Invalid file format. Please select a .spotiflac-ext file")
 	}

-	// Open the zip file
 	zipReader, err := zip.OpenReader(filePath)
 	if err != nil {
 		return nil, fmt.Errorf("Cannot open extension file. The file may be corrupted or not a valid extension package")
@@ -554,11 +536,9 @@ func (m *ExtensionManager) UpgradeExtension(filePath string) (*LoadedExtension,
 	extDir := existing.SourceDir
 	wasEnabled := existing.Enabled

-	// Cleanup and unload existing extension
 	m.CleanupExtension(existing.ID)
 	m.UnloadExtension(existing.ID)

-	// Remove old source files but keep data directory
 	if extDir != "" {
 		if err := os.RemoveAll(extDir); err != nil {
 			GoLog("[Extension] Warning: failed to remove old source dir: %v\n", err)
@@ -637,16 +617,14 @@ type ExtensionUpgradeInfo struct {
 	IsInstalled    bool   `json:"is_installed"`
 }

-// checkExtensionUpgradeInternal checks if a package file is an upgrade for an existing extension
-// Internal function that returns struct
 func (m *ExtensionManager) checkExtensionUpgradeInternal(filePath string) (*ExtensionUpgradeInfo, error) {
 	// Validate file extension
 	if !strings.HasSuffix(strings.ToLower(filePath), ".spotiflac-ext") {
-		return nil, fmt.Errorf("Invalid file format")
+		return nil, fmt.Errorf("Invalid file format. Please select a .spotiflac-ext file")
 	}

-	// Open the zip file
 	zipReader, err := zip.OpenReader(filePath)
+
 	if err != nil {
 		return nil, fmt.Errorf("Cannot open extension file")
 	}
@@ -714,7 +692,6 @@ func (m *ExtensionManager) CheckExtensionUpgradeJSON(filePath string) (string, e
 	return string(jsonBytes), nil
 }

-// GetInstalledExtensionsJSON returns all extensions as JSON for Flutter
 func (m *ExtensionManager) GetInstalledExtensionsJSON() (string, error) {
 	extensions := m.GetAllExtensions()

@@ -809,8 +786,6 @@ func (m *ExtensionManager) GetInstalledExtensionsJSON() (string, error) {
 	return string(jsonBytes), nil
 }

-// ==================== Extension Lifecycle ====================
-
 func (m *ExtensionManager) InitializeExtension(extensionID string, settings map[string]interface{}) error {
 	m.mu.Lock()
 	defer m.mu.Unlock()
@@ -923,7 +898,6 @@ func (m *ExtensionManager) CleanupExtension(extensionID string) error {
 	return nil
 }

-// UnloadAllExtensions unloads all extensions gracefully
 func (m *ExtensionManager) UnloadAllExtensions() {
 	m.mu.Lock()
 	extensionIDs := make([]string, 0, len(m.extensions))
@@ -940,7 +914,6 @@ func (m *ExtensionManager) UnloadAllExtensions() {
 	GoLog("[Extension] All extensions unloaded\n")
 }

-// The function is called as extension.<actionName>() and can return a result
 func (m *ExtensionManager) InvokeAction(extensionID string, actionName string) (map[string]interface{}, error) {
 	m.mu.Lock()
 	defer m.mu.Unlock()
@@ -7,7 +7,6 @@ import (
 	"strings"
 )

-// ExtensionType represents the type of extension
 type ExtensionType string

 const (
@@ -15,7 +14,6 @@ const (
 	ExtensionTypeDownloadProvider ExtensionType = "download_provider"
 )

-// SettingType represents the type of a setting field
 type SettingType string

 const (
@@ -26,14 +24,12 @@ const (
 	SettingTypeButton SettingType = "button" // Action button that calls a JS function
 )

-// ExtensionPermissions defines what resources an extension can access
 type ExtensionPermissions struct {
-	Network []string `json:"network"` // List of allowed domains
-	Storage bool     `json:"storage"` // Whether extension can use storage API
-	File    bool     `json:"file"`    // Whether extension can use file API
+	Network []string `json:"network"`
+	Storage bool     `json:"storage"`
+	File    bool     `json:"file"`
 }

-// ExtensionSetting defines a configurable setting for an extension
 type ExtensionSetting struct {
 	Key         string      `json:"key"`
 	Type        SettingType `json:"type"`
@@ -42,19 +38,17 @@ type ExtensionSetting struct {
 	Required    bool        `json:"required,omitempty"`
 	Secret      bool        `json:"secret,omitempty"`
 	Default     interface{} `json:"default,omitempty"`
-	Options     []string    `json:"options,omitempty"` // For select type
-	Action      string      `json:"action,omitempty"`  // For button type: JS function name to call (e.g., "startLogin")
+	Options     []string    `json:"options,omitempty"`
+	Action      string      `json:"action,omitempty"`
 }

-// QualityOption represents a quality option for download providers
 type QualityOption struct {
-	ID          string                   `json:"id"`                 // Unique identifier (e.g., "mp3_320", "opus_128")
-	Label       string                   `json:"label"`              // Display name (e.g., "MP3 320kbps")
-	Description string                   `json:"description"`        // Optional description (e.g., "Best quality MP3")
-	Settings    []QualitySpecificSetting `json:"settings,omitempty"` // Quality-specific settings
+	ID          string                   `json:"id"`
+	Label       string                   `json:"label"`
+	Description string                   `json:"description"`
+	Settings    []QualitySpecificSetting `json:"settings,omitempty"`
 }

-// QualitySpecificSetting represents a setting that's specific to a quality option
 type QualitySpecificSetting struct {
 	Key         string      `json:"key"`
 	Type        SettingType `json:"type"`
@@ -63,49 +57,50 @@ type QualitySpecificSetting struct {
 	Required    bool        `json:"required,omitempty"`
 	Secret      bool        `json:"secret,omitempty"`
 	Default     interface{} `json:"default,omitempty"`
-	Options     []string    `json:"options,omitempty"` // For select type
+	Options     []string    `json:"options,omitempty"`
+}
+
+type SearchFilter struct {
+	ID    string `json:"id"`
+	Label string `json:"label,omitempty"`
+	Icon  string `json:"icon,omitempty"`
 }

-// SearchBehaviorConfig defines custom search behavior for an extension
 type SearchBehaviorConfig struct {
-	Enabled         bool   `json:"enabled"`                   // Whether extension provides custom search
-	Placeholder     string `json:"placeholder,omitempty"`     // Placeholder text for search box
-	Primary         bool   `json:"primary,omitempty"`         // If true, show as primary search tab
-	Icon            string `json:"icon,omitempty"`            // Icon for search tab
-	ThumbnailRatio  string `json:"thumbnailRatio,omitempty"`  // Thumbnail aspect ratio: "square" (1:1), "wide" (16:9), "portrait" (2:3)
-	ThumbnailWidth  int    `json:"thumbnailWidth,omitempty"`  // Custom thumbnail width in pixels
-	ThumbnailHeight int    `json:"thumbnailHeight,omitempty"` // Custom thumbnail height in pixels
+	Enabled         bool           `json:"enabled"`
+	Placeholder     string         `json:"placeholder,omitempty"`
+	Primary         bool           `json:"primary,omitempty"`
+	Icon            string         `json:"icon,omitempty"`
+	ThumbnailRatio  string         `json:"thumbnailRatio,omitempty"`
+	ThumbnailWidth  int            `json:"thumbnailWidth,omitempty"`
+	ThumbnailHeight int            `json:"thumbnailHeight,omitempty"`
+	Filters         []SearchFilter `json:"filters,omitempty"`
 }

-// URLHandlerConfig defines custom URL handling for an extension
 type URLHandlerConfig struct {
-	Enabled  bool     `json:"enabled"`            // Whether extension handles URLs
-	Patterns []string `json:"patterns,omitempty"` // URL patterns to match (e.g., "music.youtube.com", "soundcloud.com")
+	Enabled  bool     `json:"enabled"`
+	Patterns []string `json:"patterns,omitempty"`
 }

-// TrackMatchingConfig defines custom track matching behavior
 type TrackMatchingConfig struct {
-	CustomMatching    bool   `json:"customMatching"`              // Whether extension handles matching
-	Strategy          string `json:"strategy,omitempty"`          // "isrc", "name", "duration", "custom"
-	DurationTolerance int    `json:"durationTolerance,omitempty"` // Tolerance in seconds for duration matching
+	CustomMatching    bool   `json:"customMatching"`
+	Strategy          string `json:"strategy,omitempty"`
+	DurationTolerance int    `json:"durationTolerance,omitempty"`
 }

-// PostProcessingHook defines a post-processing hook
 type PostProcessingHook struct {
-	ID               string   `json:"id"`                         // Unique identifier
-	Name             string   `json:"name"`                       // Display name
-	Description      string   `json:"description,omitempty"`      // Description
-	DefaultEnabled   bool     `json:"defaultEnabled,omitempty"`   // Whether enabled by default
-	SupportedFormats []string `json:"supportedFormats,omitempty"` // Supported file formats (e.g., ["flac", "mp3"])
+	ID               string   `json:"id"`
+	Name             string   `json:"name"`
+	Description      string   `json:"description,omitempty"`
+	DefaultEnabled   bool     `json:"defaultEnabled,omitempty"`
+	SupportedFormats []string `json:"supportedFormats,omitempty"`
 }

-// PostProcessingConfig defines post-processing capabilities
 type PostProcessingConfig struct {
-	Enabled bool                 `json:"enabled"`         // Whether extension provides post-processing
-	Hooks   []PostProcessingHook `json:"hooks,omitempty"` // Available hooks
+	Enabled bool                 `json:"enabled"`
+	Hooks   []PostProcessingHook `json:"hooks,omitempty"`
 }

-// ExtensionManifest represents the manifest.json of an extension
 type ExtensionManifest struct {
 	Name                   string                 `json:"name"`
 	DisplayName            string                 `json:"displayName"`
@@ -113,22 +108,21 @@ type ExtensionManifest struct {
 	Author                 string                 `json:"author"`
 	Description            string                 `json:"description"`
 	Homepage               string                 `json:"homepage,omitempty"`
-	Icon                   string                 `json:"icon,omitempty"` // Icon filename (e.g., "icon.png")
+	Icon                   string                 `json:"icon,omitempty"`
 	Types                  []ExtensionType        `json:"type"`
 	Permissions            ExtensionPermissions   `json:"permissions"`
 	Settings               []ExtensionSetting     `json:"settings,omitempty"`
-	QualityOptions         []QualityOption        `json:"qualityOptions,omitempty"` // Custom quality options for download providers
+	QualityOptions         []QualityOption        `json:"qualityOptions,omitempty"`
 	MinAppVersion          string                 `json:"minAppVersion,omitempty"`
-	SkipMetadataEnrichment bool                   `json:"skipMetadataEnrichment,omitempty"` // If true, don't enrich metadata from Deezer/Spotify
-	SkipBuiltInFallback    bool                   `json:"skipBuiltInFallback,omitempty"`    // If true, don't fallback to built-in providers (tidal/qobuz/amazon)
-	SearchBehavior         *SearchBehaviorConfig  `json:"searchBehavior,omitempty"`         // Custom search behavior
-	URLHandler             *URLHandlerConfig      `json:"urlHandler,omitempty"`             // Custom URL handling
-	TrackMatching          *TrackMatchingConfig   `json:"trackMatching,omitempty"`          // Custom track matching
-	PostProcessing         *PostProcessingConfig  `json:"postProcessing,omitempty"`         // Post-processing hooks
-	Capabilities           map[string]interface{} `json:"capabilities,omitempty"`           // Extension capabilities (homeFeed, browseCategories, etc.)
+	SkipMetadataEnrichment bool                   `json:"skipMetadataEnrichment,omitempty"`
+	SkipBuiltInFallback    bool                   `json:"skipBuiltInFallback,omitempty"`
+	SearchBehavior         *SearchBehaviorConfig  `json:"searchBehavior,omitempty"`
+	URLHandler             *URLHandlerConfig      `json:"urlHandler,omitempty"`
+	TrackMatching          *TrackMatchingConfig   `json:"trackMatching,omitempty"`
+	PostProcessing         *PostProcessingConfig  `json:"postProcessing,omitempty"`
+	Capabilities           map[string]interface{} `json:"capabilities,omitempty"`
 }

-// ManifestValidationError represents a validation error in the manifest
 type ManifestValidationError struct {
 	Field   string
 	Message string
@@ -138,7 +132,6 @@ func (e *ManifestValidationError) Error() string {
 	return fmt.Sprintf("manifest validation error: %s - %s", e.Field, e.Message)
 }

-// ParseManifest parses and validates a manifest from JSON bytes
 func ParseManifest(data []byte) (*ExtensionManifest, error) {
 	var manifest ExtensionManifest
 	if err := json.Unmarshal(data, &manifest); err != nil {
@@ -182,7 +175,6 @@ func (m *ExtensionManifest) Validate() error {
 		}
 	}

-	// Validate settings if present
 	for i, setting := range m.Settings {
 		if strings.TrimSpace(setting.Key) == "" {
 			return &ManifestValidationError{
@@ -217,7 +209,6 @@ func (m *ExtensionManifest) Validate() error {
 	return nil
 }

-// HasType checks if the extension has a specific type
 func (m *ExtensionManifest) HasType(t ExtensionType) bool {
 	for _, et := range m.Types {
 		if et == t {
@@ -227,17 +218,14 @@ func (m *ExtensionManifest) HasType(t ExtensionType) bool {
 	return false
 }

-// IsMetadataProvider returns true if extension provides metadata
 func (m *ExtensionManifest) IsMetadataProvider() bool {
 	return m.HasType(ExtensionTypeMetadataProvider)
 }

-// IsDownloadProvider returns true if extension provides downloads
 func (m *ExtensionManifest) IsDownloadProvider() bool {
 	return m.HasType(ExtensionTypeDownloadProvider)
 }

-// IsDomainAllowed checks if a domain is in the allowed network permissions
 func (m *ExtensionManifest) IsDomainAllowed(domain string) bool {
 	domain = strings.ToLower(strings.TrimSpace(domain))
 	for _, allowed := range m.Permissions.Network {
@@ -247,7 +235,7 @@ func (m *ExtensionManifest) IsDomainAllowed(domain string) bool {
 		}
 		// Support wildcard subdomains (e.g., *.example.com)
 		if strings.HasPrefix(allowed, "*.") {
-			suffix := allowed[1:] // Remove the *
+			suffix := allowed[1:]
 			if strings.HasSuffix(domain, suffix) {
 				return true
 			}
@@ -256,27 +244,22 @@ func (m *ExtensionManifest) IsDomainAllowed(domain string) bool {
 	return false
 }

-// HasCustomSearch returns true if extension provides custom search
 func (m *ExtensionManifest) HasCustomSearch() bool {
 	return m.SearchBehavior != nil && m.SearchBehavior.Enabled
 }

-// HasCustomMatching returns true if extension provides custom track matching
 func (m *ExtensionManifest) HasCustomMatching() bool {
 	return m.TrackMatching != nil && m.TrackMatching.CustomMatching
 }

-// HasPostProcessing returns true if extension provides post-processing
 func (m *ExtensionManifest) HasPostProcessing() bool {
 	return m.PostProcessing != nil && m.PostProcessing.Enabled
 }

-// HasURLHandler returns true if extension handles custom URLs
 func (m *ExtensionManifest) HasURLHandler() bool {
 	return m.URLHandler != nil && m.URLHandler.Enabled && len(m.URLHandler.Patterns) > 0
 }

-// MatchesURL checks if a URL matches any of the extension's URL patterns
 func (m *ExtensionManifest) MatchesURL(urlStr string) bool {
 	if !m.HasURLHandler() {
 		return false
@@ -285,7 +268,6 @@ func (m *ExtensionManifest) MatchesURL(urlStr string) bool {
 	urlStr = strings.ToLower(strings.TrimSpace(urlStr))
 	for _, pattern := range m.URLHandler.Patterns {
 		pattern = strings.ToLower(strings.TrimSpace(pattern))
-		// Check if URL contains the pattern (host match)
 		if strings.Contains(urlStr, pattern) {
 			return true
 		}
@@ -293,7 +275,6 @@ func (m *ExtensionManifest) MatchesURL(urlStr string) bool {
 	return false
 }

-// GetPostProcessingHooks returns all post-processing hooks
 func (m *ExtensionManifest) GetPostProcessingHooks() []PostProcessingHook {
 	if m.PostProcessing == nil {
 		return nil
@@ -301,7 +282,6 @@ func (m *ExtensionManifest) GetPostProcessingHooks() []PostProcessingHook {
 	return m.PostProcessing.Hooks
 }

-// ToJSON serializes the manifest to JSON
 func (m *ExtensionManifest) ToJSON() ([]byte, error) {
 	return json.Marshal(m)
 }
@@ -25,27 +25,26 @@ type ExtTrackMetadata struct {
 	AlbumArtist string `json:"album_artist,omitempty"`
 	DurationMS  int    `json:"duration_ms"`
 	CoverURL    string `json:"cover_url,omitempty"`
-	Images      string `json:"images,omitempty"` // Alternative field for cover URL (used by some extensions)
+	Images      string `json:"images,omitempty"`
 	ReleaseDate string `json:"release_date,omitempty"`
 	TrackNumber int    `json:"track_number,omitempty"`
 	DiscNumber  int    `json:"disc_number,omitempty"`
 	ISRC        string `json:"isrc,omitempty"`
 	ProviderID  string `json:"provider_id"`
-	ItemType    string `json:"item_type,omitempty"`  // track, album, or playlist - for extension search results
-	AlbumType   string `json:"album_type,omitempty"` // album, single, ep, compilation
-	// Enrichment fields from Odesli/song.link
+	ItemType    string `json:"item_type,omitempty"`
+	AlbumType   string `json:"album_type,omitempty"`
+
 	TidalID       string            `json:"tidal_id,omitempty"`
 	QobuzID       string            `json:"qobuz_id,omitempty"`
 	DeezerID      string            `json:"deezer_id,omitempty"`
 	SpotifyID     string            `json:"spotify_id,omitempty"`
-	ExternalLinks map[string]string `json:"external_links,omitempty"` // service -> URL mapping
-	// Extended metadata from enrichment (can come from Deezer, Spotify, etc.)
-	Label     string `json:"label,omitempty"`     // Record label
-	Copyright string `json:"copyright,omitempty"` // Copyright information
-	Genre     string `json:"genre,omitempty"`     // Music genre(s)
+	ExternalLinks map[string]string `json:"external_links,omitempty"`
+
+	Label     string `json:"label,omitempty"`
+	Copyright string `json:"copyright,omitempty"`
+	Genre     string `json:"genre,omitempty"`
 }

-// ResolvedCoverURL returns the cover URL, checking both CoverURL and Images fields
 func (t *ExtTrackMetadata) ResolvedCoverURL() string {
 	if t.CoverURL != "" {
 		return t.CoverURL
@@ -53,7 +52,6 @@ func (t *ExtTrackMetadata) ResolvedCoverURL() string {
 	return t.Images
 }

-// ExtAlbumMetadata represents album metadata from an extension
 type ExtAlbumMetadata struct {
 	ID          string             `json:"id"`
 	Name        string             `json:"name"`
@@ -67,34 +65,28 @@ type ExtAlbumMetadata struct {
 	ProviderID  string             `json:"provider_id"`
 }

-// ExtArtistMetadata represents artist metadata from an extension
 type ExtArtistMetadata struct {
 	ID          string             `json:"id"`
 	Name        string             `json:"name"`
 	ImageURL    string             `json:"image_url,omitempty"`
-	HeaderImage string             `json:"header_image,omitempty"` // Header image for artist page background
-	Listeners   int                `json:"listeners,omitempty"`    // Monthly listeners
+	HeaderImage string             `json:"header_image,omitempty"`
+	Listeners   int                `json:"listeners,omitempty"`
 	Albums      []ExtAlbumMetadata `json:"albums,omitempty"`
-	TopTracks   []ExtTrackMetadata `json:"top_tracks,omitempty"` // Popular tracks
+	TopTracks   []ExtTrackMetadata `json:"top_tracks,omitempty"`
 	ProviderID  string             `json:"provider_id"`
 }

-// ExtSearchResult represents search results from an extension
 type ExtSearchResult struct {
 	Tracks []ExtTrackMetadata `json:"tracks"`
 	Total  int                `json:"total"`
 }

-// ==================== Download Types ====================
-
-// ExtAvailabilityResult represents availability check result
 type ExtAvailabilityResult struct {
 	Available bool   `json:"available"`
 	Reason    string `json:"reason,omitempty"`
 	TrackID   string `json:"track_id,omitempty"`
 }

-// ExtDownloadURLResult represents download URL info
 type ExtDownloadURLResult struct {
 	URL        string `json:"url"`
 	Format     string `json:"format"`
@@ -102,7 +94,6 @@ type ExtDownloadURLResult struct {
 	SampleRate int    `json:"sample_rate,omitempty"`
 }

-// ExtDownloadResult represents download result from an extension
 type ExtDownloadResult struct {
 	Success      bool   `json:"success"`
 	FilePath     string `json:"file_path,omitempty"`
@@ -110,7 +101,7 @@ type ExtDownloadResult struct {
 	SampleRate   int    `json:"sample_rate,omitempty"`
 	ErrorMessage string `json:"error_message,omitempty"`
 	ErrorType    string `json:"error_type,omitempty"`
-	// Metadata returned by extension (optional - if provided, can skip enrichment)
+
 	Title       string `json:"title,omitempty"`
 	Artist      string `json:"artist,omitempty"`
 	Album       string `json:"album,omitempty"`
@@ -122,15 +113,11 @@ type ExtDownloadResult struct {
 	ISRC        string `json:"isrc,omitempty"`
 }

-// ==================== Provider Wrapper ====================
-
-// ExtensionProviderWrapper wraps an extension to call its provider methods
 type ExtensionProviderWrapper struct {
 	extension *LoadedExtension
 	vm        *goja.Runtime
 }

-// NewExtensionProviderWrapper creates a new provider wrapper
 func NewExtensionProviderWrapper(ext *LoadedExtension) *ExtensionProviderWrapper {
 	return &ExtensionProviderWrapper{
 		extension: ext,
@@ -138,9 +125,6 @@ func NewExtensionProviderWrapper(ext *LoadedExtension) *ExtensionProviderWrapper
 	}
 }

-// ==================== Metadata Provider Methods ====================
-
-// SearchTracks searches for tracks using the extension
 func (p *ExtensionProviderWrapper) SearchTracks(query string, limit int) (*ExtSearchResult, error) {
 	if !p.extension.Manifest.IsMetadataProvider() {
 		return nil, fmt.Errorf("extension '%s' is not a metadata provider", p.extension.ID)
@@ -150,11 +134,9 @@ func (p *ExtensionProviderWrapper) SearchTracks(query string, limit int) (*ExtSe
 		return nil, fmt.Errorf("extension '%s' is disabled", p.extension.ID)
 	}

-	// Lock VM to prevent concurrent access
 	p.extension.VMMu.Lock()
 	defer p.extension.VMMu.Unlock()

-	// Call extension's searchTracks function
 	script := fmt.Sprintf(`
 		(function() {
 			if (typeof extension !== 'undefined' && typeof extension.searchTracks === 'function') {
@@ -176,7 +158,6 @@ func (p *ExtensionProviderWrapper) SearchTracks(query string, limit int) (*ExtSe
 		return nil, fmt.Errorf("searchTracks returned null")
 	}

-	// Convert result to Go struct
 	exported := result.Export()
 	jsonBytes, err := json.Marshal(exported)
 	if err != nil {
@@ -185,14 +166,11 @@ func (p *ExtensionProviderWrapper) SearchTracks(query string, limit int) (*ExtSe

 	var searchResult ExtSearchResult

-	// Try to parse as ExtSearchResult object first
 	if err := json.Unmarshal(jsonBytes, &searchResult); err != nil {
-		// If that fails, try parsing as array of tracks directly
 		var tracks []ExtTrackMetadata
 		if arrErr := json.Unmarshal(jsonBytes, &tracks); arrErr != nil {
 			return nil, fmt.Errorf("failed to parse search result: %w (also tried array: %v)", err, arrErr)
 		}
-		// Wrap array in ExtSearchResult
 		searchResult = ExtSearchResult{
 			Tracks: tracks,
 			Total:  len(tracks),
@@ -206,7 +184,6 @@ func (p *ExtensionProviderWrapper) SearchTracks(query string, limit int) (*ExtSe
 	return &searchResult, nil
 }

-// GetTrack gets track details by ID
 func (p *ExtensionProviderWrapper) GetTrack(trackID string) (*ExtTrackMetadata, error) {
 	if !p.extension.Manifest.IsMetadataProvider() {
 		return nil, fmt.Errorf("extension '%s' is not a metadata provider", p.extension.ID)
@@ -216,7 +193,6 @@ func (p *ExtensionProviderWrapper) GetTrack(trackID string) (*ExtTrackMetadata,
 		return nil, fmt.Errorf("extension '%s' is disabled", p.extension.ID)
 	}

-	// Lock VM to prevent concurrent access
 	p.extension.VMMu.Lock()
 	defer p.extension.VMMu.Unlock()

@@ -256,7 +232,6 @@ func (p *ExtensionProviderWrapper) GetTrack(trackID string) (*ExtTrackMetadata,
 	return &track, nil
 }

-// GetAlbum gets album details by ID
 func (p *ExtensionProviderWrapper) GetAlbum(albumID string) (*ExtAlbumMetadata, error) {
 	if !p.extension.Manifest.IsMetadataProvider() {
 		return nil, fmt.Errorf("extension '%s' is not a metadata provider", p.extension.ID)
@@ -266,7 +241,6 @@ func (p *ExtensionProviderWrapper) GetAlbum(albumID string) (*ExtAlbumMetadata,
 		return nil, fmt.Errorf("extension '%s' is disabled", p.extension.ID)
 	}

-	// Lock VM to prevent concurrent access
 	p.extension.VMMu.Lock()
 	defer p.extension.VMMu.Unlock()

@@ -309,7 +283,6 @@ func (p *ExtensionProviderWrapper) GetAlbum(albumID string) (*ExtAlbumMetadata,
 	return &album, nil
 }

-// GetArtist gets artist details by ID
 func (p *ExtensionProviderWrapper) GetArtist(artistID string) (*ExtArtistMetadata, error) {
 	if !p.extension.Manifest.IsMetadataProvider() {
 		return nil, fmt.Errorf("extension '%s' is not a metadata provider", p.extension.ID)
@@ -319,7 +292,6 @@ func (p *ExtensionProviderWrapper) GetArtist(artistID string) (*ExtArtistMetadat
 		return nil, fmt.Errorf("extension '%s' is disabled", p.extension.ID)
 	}

-	// Lock VM to prevent concurrent access
 	p.extension.VMMu.Lock()
 	defer p.extension.VMMu.Unlock()

@@ -359,27 +331,22 @@ func (p *ExtensionProviderWrapper) GetArtist(artistID string) (*ExtArtistMetadat
 	return &artist, nil
 }

-// EnrichTrack enriches track metadata before download (e.g., fetch real ISRC)
-// This is called lazily when download starts, not when playlist/album is loaded
-// Extension should implement enrichTrack(track) function that returns enriched track
 func (p *ExtensionProviderWrapper) EnrichTrack(track *ExtTrackMetadata) (*ExtTrackMetadata, error) {
 	if !p.extension.Manifest.IsMetadataProvider() {
-		return track, nil // Not a metadata provider, return as-is
+		return track, nil
 	}

 	if !p.extension.Enabled {
-		return track, nil // Extension disabled, return as-is
+		return track, nil
 	}

-	// Lock VM to prevent concurrent access
 	p.extension.VMMu.Lock()
 	defer p.extension.VMMu.Unlock()

-	// Convert track to JSON for passing to JS
 	trackJSON, err := json.Marshal(track)
 	if err != nil {
 		GoLog("[Extension] EnrichTrack: failed to marshal track: %v\n", err)
-		return track, nil // Return original on error
+		return track, nil
 	}

 	script := fmt.Sprintf(`
@@ -399,10 +366,9 @@ func (p *ExtensionProviderWrapper) EnrichTrack(track *ExtTrackMetadata) (*ExtTra
 		} else {
 			GoLog("[Extension] EnrichTrack error for %s: %v\n", p.extension.ID, err)
 		}
-		return track, nil // Return original on error
+		return track, nil
 	}

-	// If extension doesn't implement enrichTrack or returns null, return original
 	if result == nil || goja.IsUndefined(result) || goja.IsNull(result) {
 		return track, nil
 	}
@@ -420,18 +386,11 @@ func (p *ExtensionProviderWrapper) EnrichTrack(track *ExtTrackMetadata) (*ExtTra
 		return track, nil
 	}

-	// Preserve provider ID
 	enrichedTrack.ProviderID = track.ProviderID

-	GoLog("[Extension] EnrichTrack: enriched track from %s (ISRC: %s -> %s)\n",
-		p.extension.ID, track.ISRC, enrichedTrack.ISRC)
-
 	return &enrichedTrack, nil
 }

-// ==================== Download Provider Methods ====================
-
-// CheckAvailability checks if a track is available for download
 func (p *ExtensionProviderWrapper) CheckAvailability(isrc, trackName, artistName string) (*ExtAvailabilityResult, error) {
 	if !p.extension.Manifest.IsDownloadProvider() {
 		return nil, fmt.Errorf("extension '%s' is not a download provider", p.extension.ID)
@@ -441,7 +400,6 @@ func (p *ExtensionProviderWrapper) CheckAvailability(isrc, trackName, artistName
 		return nil, fmt.Errorf("extension '%s' is disabled", p.extension.ID)
 	}

-	// Lock VM to prevent concurrent access
 	p.extension.VMMu.Lock()
 	defer p.extension.VMMu.Unlock()

@@ -480,7 +438,6 @@ func (p *ExtensionProviderWrapper) CheckAvailability(isrc, trackName, artistName
 	return &availability, nil
 }

-// GetDownloadURL gets the download URL for a track
 func (p *ExtensionProviderWrapper) GetDownloadURL(trackID, quality string) (*ExtDownloadURLResult, error) {
 	if !p.extension.Manifest.IsDownloadProvider() {
 		return nil, fmt.Errorf("extension '%s' is not a download provider", p.extension.ID)
@@ -490,7 +447,6 @@ func (p *ExtensionProviderWrapper) GetDownloadURL(trackID, quality string) (*Ext
 		return nil, fmt.Errorf("extension '%s' is disabled", p.extension.ID)
 	}

-	// Lock VM to prevent concurrent access
 	p.extension.VMMu.Lock()
 	defer p.extension.VMMu.Unlock()

@@ -529,10 +485,8 @@ func (p *ExtensionProviderWrapper) GetDownloadURL(trackID, quality string) (*Ext
 	return &urlResult, nil
 }

-// ExtDownloadTimeout is longer for extension download operations (5 minutes)
 const ExtDownloadTimeout = 5 * time.Minute

-// Download downloads a track with progress reporting
 func (p *ExtensionProviderWrapper) Download(trackID, quality, outputPath string, onProgress func(percent int)) (*ExtDownloadResult, error) {
 	if !p.extension.Manifest.IsDownloadProvider() {
 		return nil, fmt.Errorf("extension '%s' is not a download provider", p.extension.ID)
@@ -542,15 +496,12 @@ func (p *ExtensionProviderWrapper) Download(trackID, quality, outputPath string,
 		return nil, fmt.Errorf("extension '%s' is disabled", p.extension.ID)
 	}

-	// Lock VM to prevent concurrent access
 	p.extension.VMMu.Lock()
 	defer p.extension.VMMu.Unlock()

-	// Set up progress callback in VM
 	p.vm.Set("__onProgress", func(call goja.FunctionCall) goja.Value {
 		if len(call.Arguments) > 0 {
 			percent := int(call.Arguments[0].ToInteger())
-			// Clamp to 0-100
 			if percent < 0 {
 				percent = 0
 			}
@@ -573,7 +524,6 @@ func (p *ExtensionProviderWrapper) Download(trackID, quality, outputPath string,
 		})()
 	`, trackID, quality, outputPath)

-	// Use longer timeout for downloads (5 minutes)
 	result, err := RunWithTimeoutAndRecover(p.vm, script, ExtDownloadTimeout)
 	if err != nil {
 		errMsg := err.Error()
@@ -619,9 +569,6 @@ func (p *ExtensionProviderWrapper) Download(trackID, quality, outputPath string,
 	return &downloadResult, nil
 }

-// ==================== Extension Manager Provider Methods ====================
-
-// GetMetadataProviders returns all enabled metadata provider extensions
 func (m *ExtensionManager) GetMetadataProviders() []*ExtensionProviderWrapper {
 	m.mu.RLock()
 	defer m.mu.RUnlock()
@@ -635,7 +582,6 @@ func (m *ExtensionManager) GetMetadataProviders() []*ExtensionProviderWrapper {
 	return providers
 }

-// GetDownloadProviders returns all enabled download provider extensions
 func (m *ExtensionManager) GetDownloadProviders() []*ExtensionProviderWrapper {
 	m.mu.RLock()
 	defer m.mu.RUnlock()
@@ -649,7 +595,6 @@ func (m *ExtensionManager) GetDownloadProviders() []*ExtensionProviderWrapper {
 	return providers
 }

-// SearchTracksWithExtensions searches all metadata providers
 func (m *ExtensionManager) SearchTracksWithExtensions(query string, limit int) ([]ExtTrackMetadata, error) {
 	providers := m.GetMetadataProviders()
 	if len(providers) == 0 {
@@ -671,18 +616,12 @@ func (m *ExtensionManager) SearchTracksWithExtensions(query string, limit int) (
 	return allTracks, nil
 }

-// ==================== Provider Priority ====================
-
-// providerPriority stores the order of download providers
 var providerPriority []string
 var providerPriorityMu sync.RWMutex

-// metadataProviderPriority stores the order of metadata providers
 var metadataProviderPriority []string
 var metadataProviderPriorityMu sync.RWMutex

-// SetProviderPriority sets the order of download providers
-// providerIDs should include both built-in ("tidal", "qobuz", "amazon") and extension IDs
 func SetProviderPriority(providerIDs []string) {
 	providerPriorityMu.Lock()
 	defer providerPriorityMu.Unlock()
@@ -690,13 +629,11 @@ func SetProviderPriority(providerIDs []string) {
 	GoLog("[Extension] Download provider priority set: %v\n", providerIDs)
 }

-// GetProviderPriority returns the current provider priority order
 func GetProviderPriority() []string {
 	providerPriorityMu.RLock()
 	defer providerPriorityMu.RUnlock()

 	if len(providerPriority) == 0 {
-		// Default order: built-in providers first
 		return []string{"tidal", "qobuz", "amazon"}
 	}

@@ -705,8 +642,6 @@ func GetProviderPriority() []string {
 	return result
 }

-// SetMetadataProviderPriority sets the order of metadata providers
-// providerIDs should include both built-in ("spotify", "deezer") and extension IDs
 func SetMetadataProviderPriority(providerIDs []string) {
 	metadataProviderPriorityMu.Lock()
 	defer metadataProviderPriorityMu.Unlock()
@@ -714,13 +649,11 @@ func SetMetadataProviderPriority(providerIDs []string) {
 	GoLog("[Extension] Metadata provider priority set: %v\n", providerIDs)
 }

-// GetMetadataProviderPriority returns the current metadata provider priority order
 func GetMetadataProviderPriority() []string {
 	metadataProviderPriorityMu.RLock()
 	defer metadataProviderPriorityMu.RUnlock()

 	if len(metadataProviderPriority) == 0 {
-		// Default order: built-in providers first
 		return []string{"deezer", "spotify"}
 	}

@@ -729,30 +662,34 @@ func GetMetadataProviderPriority() []string {
 	return result
 }

-// isBuiltInProvider checks if a provider ID is a built-in provider
 func isBuiltInProvider(providerID string) bool {
 	switch providerID {
-	case "tidal", "qobuz", "amazon":
+	case "tidal", "qobuz", "amazon", "deezer":
 		return true
 	default:
 		return false
 	}
 }

-// ==================== Download with Fallback ====================
-
-// DownloadWithExtensionFallback tries to download from providers in priority order
-// Includes both built-in providers and extension providers
-// If req.Source is set (extension ID), that extension is tried first
 func DownloadWithExtensionFallback(req DownloadRequest) (*DownloadResponse, error) {
 	priority := GetProviderPriority()
 	extManager := GetExtensionManager()

-	var lastErr error
-	var skipBuiltIn bool // If source extension has skipBuiltInFallback, don't try built-in providers
+	if req.Service != "" && isBuiltInProvider(req.Service) {
+		GoLog("[DownloadWithExtensionFallback] User selected service: %s, prioritizing it first\n", req.Service)
+		newPriority := []string{req.Service}
+		for _, p := range priority {
+			if p != req.Service {
+				newPriority = append(newPriority, p)
+			}
+		}
+		priority = newPriority
+		GoLog("[DownloadWithExtensionFallback] New priority order: %v\n", priority)
+	}
+
+	var lastErr error
+	var skipBuiltIn bool

-	// LAZY ENRICHMENT: If track came from an extension, try to enrich metadata (e.g., get real ISRC)
-	// This is done lazily at download time, not when playlist/album is loaded
 	if req.Source != "" && !isBuiltInProvider(req.Source) {
 		ext, err := extManager.GetExtension(req.Source)
 		if err == nil && ext.Enabled && ext.Error == "" && ext.Manifest.IsMetadataProvider() {
@@ -796,7 +733,6 @@ func DownloadWithExtensionFallback(req DownloadRequest) (*DownloadResponse, erro
 				if enrichedTrack.Artists != "" {
 					req.ArtistName = enrichedTrack.Artists
 				}
-				// Copy extended metadata from enrichment (label, copyright, genre, release_date)
 				if enrichedTrack.Label != "" && req.Label == "" {
 					GoLog("[DownloadWithExtensionFallback] Label from enrichment: %s\n", enrichedTrack.Label)
 					req.Label = enrichedTrack.Label
@@ -817,7 +753,6 @@ func DownloadWithExtensionFallback(req DownloadRequest) (*DownloadResponse, erro
 		}
 	}

-	// If source extension is specified, try it first before the priority list
 	if req.Source != "" && !isBuiltInProvider(req.Source) {
 		GoLog("[DownloadWithExtensionFallback] Track source is extension '%s', trying it first\n", req.Source)

@@ -827,15 +762,12 @@ func DownloadWithExtensionFallback(req DownloadRequest) (*DownloadResponse, erro

 			provider := NewExtensionProviderWrapper(ext)

-			// For tracks from extension search, use the track ID directly (e.g., "youtube:VIDEO_ID")
-			// The extension already knows how to handle this ID
-			trackID := req.SpotifyID // This contains the extension's track ID (e.g., "youtube:xxx")
+			trackID := req.SpotifyID

 			GoLog("[DownloadWithExtensionFallback] Downloading from source extension with trackID: %s (skipBuiltInFallback: %v)\n", trackID, skipBuiltIn)

 			outputPath := buildOutputPath(req)

-			// Download directly using the track ID from the extension
 			result, err := provider.Download(trackID, req.Quality, outputPath, func(percent int) {
 				if req.ItemID != "" {
 					SetItemProgress(req.ItemID, float64(percent), 0, 0)
@@ -855,7 +787,6 @@ func DownloadWithExtensionFallback(req DownloadRequest) (*DownloadResponse, erro
 					Copyright:        req.Copyright,
 				}

-				// Embed genre and label if provided (from Deezer metadata)
 				if req.Genre != "" || req.Label != "" {
 					if err := EmbedGenreLabel(result.FilePath, req.Genre, req.Label); err != nil {
 						GoLog("[DownloadWithExtensionFallback] Warning: failed to embed genre/label: %v\n", err)
@@ -864,7 +795,6 @@ func DownloadWithExtensionFallback(req DownloadRequest) (*DownloadResponse, erro
 					}
 				}

-				// If extension has skipMetadataEnrichment, copy metadata
 				if ext.Manifest.SkipMetadataEnrichment {
 					resp.SkipMetadataEnrichment = true
 					if result.Title != "" {
@@ -914,12 +844,11 @@ func DownloadWithExtensionFallback(req DownloadRequest) (*DownloadResponse, erro
 			}
 			GoLog("[DownloadWithExtensionFallback] Source extension %s failed: %v\n", req.Source, lastErr)

-			// If skipBuiltInFallback is true, don't continue to other providers
 			if skipBuiltIn {
 				GoLog("[DownloadWithExtensionFallback] skipBuiltInFallback is true, not trying other providers\n")
 				return &DownloadResponse{
 					Success:   false,
-					Error:     fmt.Sprintf("Download failed: %v", lastErr),
+					Error:     "Download failed: " + lastErr.Error(),
 					ErrorType: "extension_error",
 					Service:   req.Source,
 				}, nil
@@ -929,14 +858,11 @@ func DownloadWithExtensionFallback(req DownloadRequest) (*DownloadResponse, erro
 		}
 	}

-	// Continue with priority list
 	for _, providerID := range priority {
-		// Skip if we already tried this as source
 		if providerID == req.Source {
 			continue
 		}

-		// Skip built-in providers if skipBuiltIn is set
 		if skipBuiltIn && isBuiltInProvider(providerID) {
 			GoLog("[DownloadWithExtensionFallback] Skipping built-in provider %s (skipBuiltInFallback)\n", providerID)
 			continue
@@ -945,7 +871,6 @@ func DownloadWithExtensionFallback(req DownloadRequest) (*DownloadResponse, erro
 		GoLog("[DownloadWithExtensionFallback] Trying provider: %s\n", providerID)

 		if isBuiltInProvider(providerID) {
-			// For built-in providers, enrich with Deezer metadata if not already present
 			if (req.Genre == "" || req.Label == "") && req.ISRC != "" {
 				GoLog("[DownloadWithExtensionFallback] Enriching extended metadata from Deezer for ISRC: %s\n", req.ISRC)
 				ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
@@ -966,11 +891,9 @@ func DownloadWithExtensionFallback(req DownloadRequest) (*DownloadResponse, erro
 				}
 			}

-			// Use built-in provider
 			result, err := tryBuiltInProvider(providerID, req)
 			if err == nil && result.Success {
 				result.Service = providerID
-				// Copy enriched metadata to response for Flutter (needed for M4A->FLAC conversion)
 				if req.Label != "" {
 					result.Label = req.Label
 				}
@@ -998,7 +921,6 @@ func DownloadWithExtensionFallback(req DownloadRequest) (*DownloadResponse, erro
 				GoLog("[DownloadWithExtensionFallback] %s failed: %v\n", providerID, err)
 			}
 		} else {
-			// Try extension provider
 			ext, err := extManager.GetExtension(providerID)
 			if err != nil || !ext.Enabled || ext.Error != "" {
 				GoLog("[DownloadWithExtensionFallback] Extension %s not available\n", providerID)
@@ -1041,7 +963,6 @@ func DownloadWithExtensionFallback(req DownloadRequest) (*DownloadResponse, erro
 					Copyright:        req.Copyright,
 				}

-				// Embed genre and label if provided (from Deezer metadata)
 				if req.Genre != "" || req.Label != "" {
 					if err := EmbedGenreLabel(result.FilePath, req.Genre, req.Label); err != nil {
 						GoLog("[DownloadWithExtensionFallback] Warning: failed to embed genre/label: %v\n", err)
@@ -1050,10 +971,8 @@ func DownloadWithExtensionFallback(req DownloadRequest) (*DownloadResponse, erro
 					}
 				}

-				// If extension has skipMetadataEnrichment and returned metadata, use it
 				if ext.Manifest.SkipMetadataEnrichment {
 					resp.SkipMetadataEnrichment = true
-					// Copy metadata from extension result if provided
 					if result.Title != "" {
 						resp.Title = result.Title
 					}
@@ -1106,7 +1025,7 @@ func DownloadWithExtensionFallback(req DownloadRequest) (*DownloadResponse, erro
 	if lastErr != nil {
 		return &DownloadResponse{
 			Success:   false,
-			Error:     fmt.Sprintf("All providers failed. Last error: %v", lastErr),
+			Error:     "All providers failed. Last error: " + lastErr.Error(),
 			ErrorType: "not_found",
 		}, nil
 	}
@@ -1118,7 +1037,6 @@ func DownloadWithExtensionFallback(req DownloadRequest) (*DownloadResponse, erro
 	}, nil
 }

-// tryBuiltInProvider attempts download from a built-in provider
 func tryBuiltInProvider(providerID string, req DownloadRequest) (*DownloadResponse, error) {
 	req.Service = providerID

@@ -1204,8 +1122,11 @@ func tryBuiltInProvider(providerID string, req DownloadRequest) (*DownloadRespon
 	}, nil
 }

-// buildOutputPath builds the output file path from request
 func buildOutputPath(req DownloadRequest) string {
+	if strings.TrimSpace(req.OutputPath) != "" {
+		return strings.TrimSpace(req.OutputPath)
+	}
+
 	metadata := map[string]interface{}{
 		"title":        req.TrackName,
 		"artist":       req.ArtistName,
@@ -1221,12 +1142,16 @@ func buildOutputPath(req DownloadRequest) string {
 		filename = sanitizeFilename(fmt.Sprintf("%s - %s", req.ArtistName, req.TrackName))
 	}

-	return fmt.Sprintf("%s/%s.flac", req.OutputDir, filename)
+	ext := strings.TrimSpace(req.OutputExt)
+	if ext == "" {
+		ext = ".flac"
+	} else if !strings.HasPrefix(ext, ".") {
+		ext = "." + ext
+	}
+
+	return fmt.Sprintf("%s/%s%s", req.OutputDir, filename, ext)
 }

-// ==================== Custom Search ====================
-
-// CustomSearch performs a custom search using an extension's search function
 func (p *ExtensionProviderWrapper) CustomSearch(query string, options map[string]interface{}) ([]ExtTrackMetadata, error) {
 	if !p.extension.Manifest.HasCustomSearch() {
 		return nil, fmt.Errorf("extension '%s' does not support custom search", p.extension.ID)
@@ -1236,11 +1161,9 @@ func (p *ExtensionProviderWrapper) CustomSearch(query string, options map[string
 		return nil, fmt.Errorf("extension '%s' is disabled", p.extension.ID)
 	}

-	// Lock VM to prevent concurrent access
 	p.extension.VMMu.Lock()
 	defer p.extension.VMMu.Unlock()

-	// Convert options to JSON
 	optionsJSON, _ := json.Marshal(options)

 	script := fmt.Sprintf(`
@@ -1261,7 +1184,6 @@ func (p *ExtensionProviderWrapper) CustomSearch(query string, options map[string
 	}

 	if result == nil || goja.IsUndefined(result) || goja.IsNull(result) {
-		// Return empty array instead of error for no results
 		return []ExtTrackMetadata{}, nil
 	}

@@ -1276,7 +1198,6 @@ func (p *ExtensionProviderWrapper) CustomSearch(query string, options map[string
 		return nil, fmt.Errorf("failed to parse search result: %w", err)
 	}

-	// Return empty array if no tracks found
 	if tracks == nil {
 		tracks = []ExtTrackMetadata{}
 	}
@@ -1288,20 +1209,16 @@ func (p *ExtensionProviderWrapper) CustomSearch(query string, options map[string
 	return tracks, nil
 }

-// ==================== Custom URL Handler ====================
-
-// ExtURLHandleResult represents the result of URL handling
 type ExtURLHandleResult struct {
-	Type     string             `json:"type"`                // "track", "album", "playlist", "artist"
-	Track    *ExtTrackMetadata  `json:"track,omitempty"`     // For single track
-	Tracks   []ExtTrackMetadata `json:"tracks,omitempty"`    // For album/playlist
-	Album    *ExtAlbumMetadata  `json:"album,omitempty"`     // Album info
-	Artist   *ExtArtistMetadata `json:"artist,omitempty"`    // Artist info
-	Name     string             `json:"name,omitempty"`      // Playlist/album name
-	CoverURL string             `json:"cover_url,omitempty"` // Cover image
+	Type     string             `json:"type"`
+	Track    *ExtTrackMetadata  `json:"track,omitempty"`
+	Tracks   []ExtTrackMetadata `json:"tracks,omitempty"`
+	Album    *ExtAlbumMetadata  `json:"album,omitempty"`
+	Artist   *ExtArtistMetadata `json:"artist,omitempty"`
+	Name     string             `json:"name,omitempty"`
+	CoverURL string             `json:"cover_url,omitempty"`
 }

-// HandleURL processes a URL using the extension's URL handler
 func (p *ExtensionProviderWrapper) HandleURL(url string) (*ExtURLHandleResult, error) {
 	if !p.extension.Manifest.HasURLHandler() {
 		return nil, fmt.Errorf("extension '%s' does not support URL handling", p.extension.ID)
@@ -1311,7 +1228,6 @@ func (p *ExtensionProviderWrapper) HandleURL(url string) (*ExtURLHandleResult, e
 		return nil, fmt.Errorf("extension '%s' is disabled", p.extension.ID)
 	}

-	// Lock VM to prevent concurrent access
 	p.extension.VMMu.Lock()
 	defer p.extension.VMMu.Unlock()

@@ -1347,7 +1263,6 @@ func (p *ExtensionProviderWrapper) HandleURL(url string) (*ExtURLHandleResult, e
 		return nil, fmt.Errorf("failed to parse URL handle result: %w", err)
 	}

-	// Set provider ID on tracks
 	if handleResult.Track != nil {
 		handleResult.Track.ProviderID = p.extension.ID
 	}
@@ -1376,9 +1291,6 @@ func (p *ExtensionProviderWrapper) HandleURL(url string) (*ExtURLHandleResult, e
 	return &handleResult, nil
 }

-// ==================== Custom Track Matching ====================
-
-// MatchTrackResult represents the result of custom track matching
 type MatchTrackResult struct {
 	Matched    bool    `json:"matched"`
 	TrackID    string  `json:"track_id,omitempty"`
@@ -1386,7 +1298,6 @@ type MatchTrackResult struct {
 	Reason     string  `json:"reason,omitempty"`
 }

-// MatchTrack uses extension's custom matching algorithm
 func (p *ExtensionProviderWrapper) MatchTrack(sourceTrack map[string]interface{}, candidates []map[string]interface{}) (*MatchTrackResult, error) {
 	if !p.extension.Manifest.HasCustomMatching() {
 		return nil, fmt.Errorf("extension '%s' does not support custom matching", p.extension.ID)
@@ -1396,7 +1307,6 @@ func (p *ExtensionProviderWrapper) MatchTrack(sourceTrack map[string]interface{}
 		return nil, fmt.Errorf("extension '%s' is disabled", p.extension.ID)
 	}

-	// Lock VM to prevent concurrent access
 	p.extension.VMMu.Lock()
 	defer p.extension.VMMu.Unlock()

@@ -1438,22 +1348,26 @@ func (p *ExtensionProviderWrapper) MatchTrack(sourceTrack map[string]interface{}
 	return &matchResult, nil
 }

-// ==================== Post-Processing ====================
-
-// PostProcessResult represents the result of post-processing
 type PostProcessResult struct {
 	Success     bool   `json:"success"`
 	NewFilePath string `json:"new_file_path,omitempty"`
+	NewFileURI  string `json:"new_file_uri,omitempty"`
 	Error       string `json:"error,omitempty"`
-	// Additional metadata that may have changed
-	BitDepth   int `json:"bit_depth,omitempty"`
-	SampleRate int `json:"sample_rate,omitempty"`
+	BitDepth    int    `json:"bit_depth,omitempty"`
+	SampleRate  int    `json:"sample_rate,omitempty"`
+}
+
+type PostProcessInput struct {
+	Path    string `json:"path,omitempty"`
+	URI     string `json:"uri,omitempty"`
+	Name    string `json:"name,omitempty"`
+	MimeType string `json:"mime_type,omitempty"`
+	Size    int64  `json:"size,omitempty"`
+	IsSAF   bool   `json:"is_saf,omitempty"`
 }

-// PostProcessTimeout is longer for post-processing (2 minutes)
 const PostProcessTimeout = 2 * time.Minute

-// PostProcess runs post-processing hooks on a downloaded file
 func (p *ExtensionProviderWrapper) PostProcess(filePath string, metadata map[string]interface{}, hookID string) (*PostProcessResult, error) {
 	if !p.extension.Manifest.HasPostProcessing() {
 		return nil, fmt.Errorf("extension '%s' does not support post-processing", p.extension.ID)
@@ -1463,7 +1377,6 @@ func (p *ExtensionProviderWrapper) PostProcess(filePath string, metadata map[str
 		return nil, fmt.Errorf("extension '%s' is disabled", p.extension.ID)
 	}

-	// Lock VM to prevent concurrent access
 	p.extension.VMMu.Lock()
 	defer p.extension.VMMu.Unlock()

@@ -1517,9 +1430,75 @@ func (p *ExtensionProviderWrapper) PostProcess(filePath string, metadata map[str
 	return &postResult, nil
 }

-// ==================== Extension Manager Advanced Methods ====================
+func (p *ExtensionProviderWrapper) PostProcessV2(input PostProcessInput, metadata map[string]interface{}, hookID string) (*PostProcessResult, error) {
+	if !p.extension.Manifest.HasPostProcessing() {
+		return nil, fmt.Errorf("extension '%s' does not support post-processing", p.extension.ID)
+	}
+
+	if !p.extension.Enabled {
+		return nil, fmt.Errorf("extension '%s' is disabled", p.extension.ID)
+	}
+
+	p.extension.VMMu.Lock()
+	defer p.extension.VMMu.Unlock()
+
+	metadataJSON, _ := json.Marshal(metadata)
+	inputJSON, _ := json.Marshal(input)
+	filePath := input.Path
+
+	script := fmt.Sprintf(`
+		(function() {
+			if (typeof extension !== 'undefined') {
+				if (typeof extension.postProcessV2 === 'function') {
+					return extension.postProcessV2(%s, %s, %q);
+				}
+				if (typeof extension.postProcess === 'function') {
+					return extension.postProcess(%q, %s, %q);
+				}
+			}
+			return null;
+		})()
+	`, string(inputJSON), string(metadataJSON), hookID, filePath, string(metadataJSON), hookID)
+
+	result, err := RunWithTimeoutAndRecover(p.vm, script, PostProcessTimeout)
+	if err != nil {
+		errMsg := err.Error()
+		if IsTimeoutError(err) {
+			errMsg = "postProcess timeout: extension took too long to complete"
+		}
+		return &PostProcessResult{
+			Success: false,
+			Error:   errMsg,
+		}, nil
+	}
+
+	if result == nil || goja.IsUndefined(result) || goja.IsNull(result) {
+		return &PostProcessResult{
+			Success: false,
+			Error:   "postProcess returned null",
+		}, nil
+	}
+
+	exported := result.Export()
+	jsonBytes, err := json.Marshal(exported)
+	if err != nil {
+		return &PostProcessResult{
+			Success: false,
+			Error:   fmt.Sprintf("failed to marshal result: %v", err),
+		}, nil
+	}
+
+	var postResult PostProcessResult
+	if err := json.Unmarshal(jsonBytes, &postResult); err != nil {
+		return &PostProcessResult{
+			Success: false,
+			Error:   fmt.Sprintf("failed to parse result: %v", err),
+		}, nil
+	}
+
+	return &postResult, nil
+}

-// GetSearchProviders returns all extensions that provide custom search
 func (m *ExtensionManager) GetSearchProviders() []*ExtensionProviderWrapper {
 	m.mu.RLock()
 	defer m.mu.RUnlock()
@@ -1533,7 +1512,6 @@ func (m *ExtensionManager) GetSearchProviders() []*ExtensionProviderWrapper {
 	return providers
 }

-// GetURLHandlers returns all extensions that handle custom URLs
 func (m *ExtensionManager) GetURLHandlers() []*ExtensionProviderWrapper {
 	m.mu.RLock()
 	defer m.mu.RUnlock()
@@ -1547,7 +1525,6 @@ func (m *ExtensionManager) GetURLHandlers() []*ExtensionProviderWrapper {
 	return providers
 }

-// FindURLHandler finds an extension that can handle the given URL
 func (m *ExtensionManager) FindURLHandler(url string) *ExtensionProviderWrapper {
 	m.mu.RLock()
 	defer m.mu.RUnlock()
@@ -1560,14 +1537,11 @@ func (m *ExtensionManager) FindURLHandler(url string) *ExtensionProviderWrapper
 	return nil
 }

-// ExtURLHandleResultWithExtID wraps ExtURLHandleResult with extension ID for gomobile compatibility
 type ExtURLHandleResultWithExtID struct {
 	Result      *ExtURLHandleResult
 	ExtensionID string
 }

-// HandleURLWithExtension tries to handle a URL with any matching extension
-// Returns result with extension ID, or error if no handler found
 func (m *ExtensionManager) HandleURLWithExtension(url string) (*ExtURLHandleResultWithExtID, error) {
 	handler := m.FindURLHandler(url)
 	if handler == nil {
@@ -1647,3 +1621,58 @@ func (m *ExtensionManager) RunPostProcessing(filePath string, metadata map[strin

 	return &PostProcessResult{Success: true, NewFilePath: currentPath}, nil
 }
+
+// RunPostProcessingV2 runs all enabled post-processing hooks on a file input.
+func (m *ExtensionManager) RunPostProcessingV2(input PostProcessInput, metadata map[string]interface{}) (*PostProcessResult, error) {
+	providers := m.GetPostProcessingProviders()
+	if len(providers) == 0 {
+		return &PostProcessResult{Success: true, NewFilePath: input.Path, NewFileURI: input.URI}, nil
+	}
+
+	currentInput := input
+	for _, provider := range providers {
+		hooks := provider.extension.Manifest.GetPostProcessingHooks()
+		for _, hook := range hooks {
+			if !hook.DefaultEnabled {
+				continue
+			}
+
+			ext := strings.ToLower(filepath.Ext(currentInput.Path))
+			if ext == "" && currentInput.Name != "" {
+				ext = strings.ToLower(filepath.Ext(currentInput.Name))
+			}
+			if len(hook.SupportedFormats) > 0 && ext != "" {
+				supported := false
+				for _, format := range hook.SupportedFormats {
+					if "."+format == ext || format == ext[1:] {
+						supported = true
+						break
+					}
+				}
+				if !supported {
+					continue
+				}
+			}
+
+			GoLog("[PostProcessV2] Running hook %s from %s on %s\n", hook.ID, provider.extension.ID, currentInput.Path)
+
+			result, err := provider.PostProcessV2(currentInput, metadata, hook.ID)
+			if err != nil {
+				GoLog("[PostProcessV2] Hook %s failed: %v\n", hook.ID, err)
+				continue
+			}
+
+			if result.Success && result.NewFilePath != "" {
+				currentInput.Path = result.NewFilePath
+				if currentInput.Name == "" {
+					currentInput.Name = filepath.Base(result.NewFilePath)
+				}
+			}
+			if result.Success && result.NewFileURI != "" {
+				currentInput.URI = result.NewFileURI
+			}
+		}
+	}
+
+	return &PostProcessResult{Success: true, NewFilePath: currentInput.Path, NewFileURI: currentInput.URI}, nil
+}
@@ -1,8 +1,11 @@
 package gobackend

 import (
+	"fmt"
+	"net"
 	"net/http"
 	"net/url"
+	"strings"
 	"sync"
 	"time"

@@ -23,9 +26,8 @@ type ExtensionAuthState struct {
 	RefreshToken    string
 	ExpiresAt       time.Time
 	IsAuthenticated bool
-	// PKCE support
-	PKCEVerifier  string
-	PKCEChallenge string
+	PKCEVerifier    string
+	PKCEChallenge   string
 }

 type PendingAuthRequest struct {
@@ -39,7 +41,6 @@ var (
 	pendingAuthRequestsMu sync.RWMutex
 )

-// GetPendingAuthRequest returns pending auth request for an extension (called from Flutter)
 func GetPendingAuthRequest(extensionID string) *PendingAuthRequest {
 	pendingAuthRequestsMu.RLock()
 	defer pendingAuthRequestsMu.RUnlock()
@@ -105,8 +106,16 @@ func NewExtensionRuntime(ext *LoadedExtension) *ExtensionRuntime {
 		Timeout: 30 * time.Second,
 		Jar:     jar,
 		CheckRedirect: func(req *http.Request, via []*http.Request) error {
-			// Validate redirect target domain against allowed domains
+			if req.URL.Scheme != "https" {
+				GoLog("[Extension:%s] Redirect blocked: non-https scheme '%s'\n", ext.ID, req.URL.Scheme)
+				return fmt.Errorf("redirect blocked: only https is allowed")
+			}
+
 			domain := req.URL.Hostname()
+			if domain == "" {
+				GoLog("[Extension:%s] Redirect blocked: missing hostname\n", ext.ID)
+				return fmt.Errorf("redirect blocked: hostname is required")
+			}
 			if !ext.Manifest.IsDomainAllowed(domain) {
 				GoLog("[Extension:%s] Redirect blocked: domain '%s' not in allowed list\n", ext.ID, domain)
 				return &RedirectBlockedError{Domain: domain}
@@ -115,7 +124,6 @@ func NewExtensionRuntime(ext *LoadedExtension) *ExtensionRuntime {
 				GoLog("[Extension:%s] Redirect blocked: private IP '%s'\n", ext.ID, domain)
 				return &RedirectBlockedError{Domain: domain, IsPrivate: true}
 			}
-			// Default redirect limit (10)
 			if len(via) >= 10 {
 				return http.ErrUseLastResponse
 			}
@@ -141,35 +149,48 @@ func (e *RedirectBlockedError) Error() string {

 // isPrivateIP checks if a hostname resolves to a private/local IP address
 func isPrivateIP(host string) bool {
-	// Block common private network patterns
-	// This is a simple check - for production, consider DNS resolution
-	privatePatterns := []string{
-		"localhost",
-		"127.",
-		"10.",
-		"172.16.", "172.17.", "172.18.", "172.19.",
-		"172.20.", "172.21.", "172.22.", "172.23.",
-		"172.24.", "172.25.", "172.26.", "172.27.",
-		"172.28.", "172.29.", "172.30.", "172.31.",
-		"192.168.",
-		"169.254.",
-		"::1",
-		"fc00:",
-		"fe80:",
+	hostLower := strings.ToLower(strings.TrimSpace(host))
+	if hostLower == "" {
+		return false
 	}

-	hostLower := host
-	for _, pattern := range privatePatterns {
-		if hostLower == pattern || len(hostLower) > len(pattern) && hostLower[:len(pattern)] == pattern {
+	if hostLower == "localhost" || strings.HasSuffix(hostLower, ".local") {
+		return true
+	}
+
+	if ip := net.ParseIP(hostLower); ip != nil {
+		return isPrivateIPAddr(ip)
+	}
+
+	ips, err := net.LookupIP(hostLower)
+	if err != nil {
+		return false
+	}
+
+	for _, ip := range ips {
+		if isPrivateIPAddr(ip) {
 			return true
 		}
 	}

-	// Also block .local domains
-	if len(host) > 6 && host[len(host)-6:] == ".local" {
+	return false
+}
+
+func isPrivateIPAddr(ip net.IP) bool {
+	if ip == nil {
+		return false
+	}
+	if ip.IsLoopback() ||
+		ip.IsPrivate() ||
+		ip.IsLinkLocalUnicast() ||
+		ip.IsLinkLocalMulticast() ||
+		ip.IsMulticast() ||
+		ip.IsUnspecified() {
+		return true
+	}
+	if !ip.IsGlobalUnicast() {
 		return true
 	}
-
 	return false
 }

@@ -201,18 +222,16 @@ func (r *ExtensionRuntime) SetSettings(settings map[string]interface{}) {
 	r.settings = settings
 }

-// RegisterAPIs registers all sandboxed APIs to the Goja VM
 func (r *ExtensionRuntime) RegisterAPIs(vm *goja.Runtime) {
 	r.vm = vm

-	// HTTP client (sandboxed to allowed domains)
 	httpObj := vm.NewObject()
 	httpObj.Set("get", r.httpGet)
 	httpObj.Set("post", r.httpPost)
 	httpObj.Set("put", r.httpPut)
 	httpObj.Set("delete", r.httpDelete)
 	httpObj.Set("patch", r.httpPatch)
-	httpObj.Set("request", r.httpRequest) // Generic HTTP request (GET, POST, PUT, DELETE, etc.)
+	httpObj.Set("request", r.httpRequest)
 	httpObj.Set("clearCookies", r.httpClearCookies)
 	vm.Set("http", httpObj)

@@ -222,7 +241,6 @@ func (r *ExtensionRuntime) RegisterAPIs(vm *goja.Runtime) {
 	storageObj.Set("remove", r.storageRemove)
 	vm.Set("storage", storageObj)

-	// Secure Credentials API (encrypted storage for sensitive data)
 	credentialsObj := vm.NewObject()
 	credentialsObj.Set("store", r.credentialsStore)
 	credentialsObj.Set("get", r.credentialsGet)
@@ -237,14 +255,12 @@ func (r *ExtensionRuntime) RegisterAPIs(vm *goja.Runtime) {
 	authObj.Set("clearAuth", r.authClear)
 	authObj.Set("isAuthenticated", r.authIsAuthenticated)
 	authObj.Set("getTokens", r.authGetTokens)
-	// PKCE support
 	authObj.Set("generatePKCE", r.authGeneratePKCE)
 	authObj.Set("getPKCE", r.authGetPKCE)
 	authObj.Set("startOAuthWithPKCE", r.authStartOAuthWithPKCE)
 	authObj.Set("exchangeCodeWithPKCE", r.authExchangeCodeWithPKCE)
 	vm.Set("auth", authObj)

-	// File operations (sandboxed)
 	fileObj := vm.NewObject()
 	fileObj.Set("download", r.fileDownload)
 	fileObj.Set("exists", r.fileExists)
@@ -262,7 +278,6 @@ func (r *ExtensionRuntime) RegisterAPIs(vm *goja.Runtime) {
 	ffmpegObj.Set("convert", r.ffmpegConvert)
 	vm.Set("ffmpeg", ffmpegObj)

-	// Track matching API
 	matchingObj := vm.NewObject()
 	matchingObj.Set("compareStrings", r.matchingCompareStrings)
 	matchingObj.Set("compareDuration", r.matchingCompareDuration)
@@ -279,14 +294,12 @@ func (r *ExtensionRuntime) RegisterAPIs(vm *goja.Runtime) {
 	utilsObj.Set("hmacSHA1", r.hmacSHA1)
 	utilsObj.Set("parseJSON", r.parseJSON)
 	utilsObj.Set("stringifyJSON", r.stringifyJSON)
-	// Crypto utilities for developers
 	utilsObj.Set("encrypt", r.cryptoEncrypt)
 	utilsObj.Set("decrypt", r.cryptoDecrypt)
 	utilsObj.Set("generateKey", r.cryptoGenerateKey)
 	utilsObj.Set("randomUserAgent", r.randomUserAgent)
 	vm.Set("utils", utilsObj)

-	// Log object (already set in extension_manager.go, but we can enhance it)
 	logObj := vm.NewObject()
 	logObj.Set("debug", r.logDebug)
 	logObj.Set("info", r.logInfo)
@@ -298,10 +311,6 @@ func (r *ExtensionRuntime) RegisterAPIs(vm *goja.Runtime) {
 	gobackendObj.Set("sanitizeFilename", r.sanitizeFilenameWrapper)
 	vm.Set("gobackend", gobackendObj)

-	// ==================== Browser-like Polyfills ====================
-	// These make porting browser/Node.js libraries easier
-
-	// Global fetch() - Promise-style HTTP API (browser-compatible)
 	vm.Set("fetch", r.fetchPolyfill)

 	vm.Set("atob", r.atobPolyfill)
@@ -70,13 +70,11 @@ func (r *ExtensionRuntime) authGetCode(call goja.FunctionCall) goja.Value {
 	return r.vm.ToValue(state.AuthCode)
 }

-// authSetCode sets auth code and tokens (can be called by extension after token exchange)
 func (r *ExtensionRuntime) authSetCode(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 1 {
 		return r.vm.ToValue(false)
 	}

-	// Can accept either just auth code or an object with tokens
 	arg := call.Arguments[0].Export()

 	extensionAuthStateMu.Lock()
@@ -123,7 +121,6 @@ func (r *ExtensionRuntime) authClear(call goja.FunctionCall) goja.Value {
 	return r.vm.ToValue(true)
 }

-// authIsAuthenticated checks if extension has valid auth
 func (r *ExtensionRuntime) authIsAuthenticated(call goja.FunctionCall) goja.Value {
 	extensionAuthStateMu.RLock()
 	defer extensionAuthStateMu.RUnlock()
@@ -196,7 +193,6 @@ func generatePKCEChallenge(verifier string) string {
 }

 func (r *ExtensionRuntime) authGeneratePKCE(call goja.FunctionCall) goja.Value {
-	// Default length is 64 characters
 	length := 64
 	if len(call.Arguments) > 0 && !goja.IsUndefined(call.Arguments[0]) {
 		if l, ok := call.Arguments[0].Export().(float64); ok && l >= 43 && l <= 128 {
@@ -249,9 +245,7 @@ func (r *ExtensionRuntime) authGetPKCE(call goja.FunctionCall) goja.Value {
 	})
 }

-// authStartOAuthWithPKCE is a high-level helper that generates PKCE and opens OAuth URL
 // config: { authUrl, clientId, redirectUri, scope, extraParams }
-// Returns: { success, authUrl, pkce: { verifier, challenge } }
 func (r *ExtensionRuntime) authStartOAuthWithPKCE(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 1 {
 		return r.vm.ToValue(map[string]interface{}{
@@ -269,7 +263,6 @@ func (r *ExtensionRuntime) authStartOAuthWithPKCE(call goja.FunctionCall) goja.V
 		})
 	}

-	// Required fields
 	authURL, _ := config["authUrl"].(string)
 	clientID, _ := config["clientId"].(string)
 	redirectURI, _ := config["redirectUri"].(string)
@@ -281,11 +274,9 @@ func (r *ExtensionRuntime) authStartOAuthWithPKCE(call goja.FunctionCall) goja.V
 		})
 	}

-	// Optional fields
 	scope, _ := config["scope"].(string)
 	extraParams, _ := config["extraParams"].(map[string]interface{})

-	// Generate PKCE
 	verifier, err := generatePKCEVerifier(64)
 	if err != nil {
 		return r.vm.ToValue(map[string]interface{}{
@@ -295,7 +286,6 @@ func (r *ExtensionRuntime) authStartOAuthWithPKCE(call goja.FunctionCall) goja.V
 	}
 	challenge := generatePKCEChallenge(verifier)

-	// Store PKCE in auth state
 	extensionAuthStateMu.Lock()
 	state, exists := extensionAuthState[r.extensionID]
 	if !exists {
@@ -304,10 +294,9 @@ func (r *ExtensionRuntime) authStartOAuthWithPKCE(call goja.FunctionCall) goja.V
 	}
 	state.PKCEVerifier = verifier
 	state.PKCEChallenge = challenge
-	state.AuthCode = "" // Clear any previous auth code
+	state.AuthCode = ""
 	extensionAuthStateMu.Unlock()

-	// Build OAuth URL with PKCE parameters
 	parsedURL, err := url.Parse(authURL)
 	if err != nil {
 		return r.vm.ToValue(map[string]interface{}{
@@ -327,7 +316,6 @@ func (r *ExtensionRuntime) authStartOAuthWithPKCE(call goja.FunctionCall) goja.V
 		query.Set("scope", scope)
 	}

-	// Add extra params
 	for k, v := range extraParams {
 		query.Set(k, fmt.Sprintf("%v", v))
 	}
@@ -335,7 +323,6 @@ func (r *ExtensionRuntime) authStartOAuthWithPKCE(call goja.FunctionCall) goja.V
 	parsedURL.RawQuery = query.Encode()
 	fullAuthURL := parsedURL.String()

-	// Store pending auth request for Flutter
 	pendingAuthRequestsMu.Lock()
 	pendingAuthRequests[r.extensionID] = &PendingAuthRequest{
 		ExtensionID: r.extensionID,
@@ -64,7 +64,6 @@ func (r *ExtensionRuntime) ffmpegExecute(call goja.FunctionCall) goja.Value {

 	command := call.Arguments[0].String()

-	// Generate unique command ID
 	ffmpegCommandsMu.Lock()
 	ffmpegCommandID++
 	cmdID := fmt.Sprintf("%s_%d", r.extensionID, ffmpegCommandID)
@@ -77,7 +76,6 @@ func (r *ExtensionRuntime) ffmpegExecute(call goja.FunctionCall) goja.Value {

 	GoLog("[Extension:%s] FFmpeg command queued: %s\n", r.extensionID, cmdID)

-	// Wait for completion (with timeout)
 	timeout := 5 * time.Minute
 	start := time.Now()
 	for {
@@ -97,7 +95,6 @@ func (r *ExtensionRuntime) ffmpegExecute(call goja.FunctionCall) goja.Value {
 			}
 			ffmpegCommandsMu.RUnlock()

-			// Cleanup
 			ClearFFmpegCommand(cmdID)
 			return r.vm.ToValue(result)
 		}
@@ -124,7 +121,6 @@ func (r *ExtensionRuntime) ffmpegGetInfo(call goja.FunctionCall) goja.Value {

 	filePath := call.Arguments[0].String()

-	// Use Go's built-in audio quality function
 	quality, err := GetAudioQuality(filePath)
 	if err != nil {
 		return r.vm.ToValue(map[string]interface{}{
@@ -153,7 +149,6 @@ func (r *ExtensionRuntime) ffmpegConvert(call goja.FunctionCall) goja.Value {
 	inputPath := call.Arguments[0].String()
 	outputPath := call.Arguments[1].String()

-	// Get options if provided
 	options := map[string]interface{}{}
 	if len(call.Arguments) > 2 && !goja.IsUndefined(call.Arguments[2]) && !goja.IsNull(call.Arguments[2]) {
 		if opts, ok := call.Arguments[2].Export().(map[string]interface{}); ok {
@@ -161,36 +156,29 @@ func (r *ExtensionRuntime) ffmpegConvert(call goja.FunctionCall) goja.Value {
 		}
 	}

-	// Build FFmpeg command
 	var cmdParts []string
 	cmdParts = append(cmdParts, "-i", fmt.Sprintf("%q", inputPath))

-	// Audio codec
 	if codec, ok := options["codec"].(string); ok {
 		cmdParts = append(cmdParts, "-c:a", codec)
 	}

-	// Bitrate
 	if bitrate, ok := options["bitrate"].(string); ok {
 		cmdParts = append(cmdParts, "-b:a", bitrate)
 	}

-	// Sample rate
 	if sampleRate, ok := options["sample_rate"].(float64); ok {
 		cmdParts = append(cmdParts, "-ar", fmt.Sprintf("%d", int(sampleRate)))
 	}

-	// Channels
 	if channels, ok := options["channels"].(float64); ok {
 		cmdParts = append(cmdParts, "-ac", fmt.Sprintf("%d", int(channels)))
 	}

-	// Overwrite output
 	cmdParts = append(cmdParts, "-y", fmt.Sprintf("%q", outputPath))

 	command := strings.Join(cmdParts, " ")

-	// Execute via ffmpegExecute
 	execCall := goja.FunctionCall{
 		Arguments: []goja.Value{r.vm.ToValue(command)},
 	}
@@ -15,7 +15,6 @@ import (

 // ==================== File API (Sandboxed) ====================

-// List of allowed directories for file operations (set by Go backend for download operations)
 var (
 	allowedDownloadDirs   []string
 	allowedDownloadDirsMu sync.RWMutex
@@ -42,18 +41,40 @@ func isPathInAllowedDirs(absPath string) bool {
 	defer allowedDownloadDirsMu.RUnlock()

 	for _, allowedDir := range allowedDownloadDirs {
-		if strings.HasPrefix(absPath, allowedDir) {
+		if isPathWithinBase(allowedDir, absPath) {
 			return true
 		}
 	}
 	return false
 }

-// validatePath checks if the path is within the extension's sandbox
-// Security: Absolute paths are BLOCKED unless they're in allowed download directories
-// Extensions should use relative paths for their own data storage
+func isPathWithinBase(baseDir, targetPath string) bool {
+	baseAbs, err := filepath.Abs(baseDir)
+	if err != nil {
+		return false
+	}
+	targetAbs, err := filepath.Abs(targetPath)
+	if err != nil {
+		return false
+	}
+
+	rel, err := filepath.Rel(baseAbs, targetAbs)
+	if err != nil {
+		return false
+	}
+	rel = filepath.Clean(rel)
+	if rel == "." {
+		return true
+	}
+
+	prefix := ".." + string(filepath.Separator)
+	if rel == ".." || strings.HasPrefix(rel, prefix) {
+		return false
+	}
+	return true
+}
+
 func (r *ExtensionRuntime) validatePath(path string) (string, error) {
-	// Check if extension has file permission
 	if !r.manifest.Permissions.File {
 		return "", fmt.Errorf("file access denied: extension does not have 'file' permission")
 	}
@@ -81,7 +102,7 @@ func (r *ExtensionRuntime) validatePath(path string) (string, error) {
 	}

 	absDataDir, _ := filepath.Abs(r.dataDir)
-	if !strings.HasPrefix(absPath, absDataDir) {
+	if !isPathWithinBase(absDataDir, absPath) {
 		return "", fmt.Errorf("file access denied: path '%s' is outside sandbox", path)
 	}

@@ -327,7 +348,6 @@ func (r *ExtensionRuntime) fileWrite(call goja.FunctionCall) goja.Value {
 		})
 	}

-	// Create directory if needed
 	dir := filepath.Dir(fullPath)
 	if err := os.MkdirAll(dir, 0755); err != nil {
 		return r.vm.ToValue(map[string]interface{}{
@@ -14,23 +14,30 @@ import (

 // ==================== HTTP API (Sandboxed) ====================

-// HTTPResponse represents the response from an HTTP request
 type HTTPResponse struct {
 	StatusCode int               `json:"statusCode"`
 	Body       string            `json:"body"`
 	Headers    map[string]string `json:"headers"`
 }

-// validateDomain checks if the domain is allowed by the extension's permissions
 func (r *ExtensionRuntime) validateDomain(urlStr string) error {
 	parsed, err := url.Parse(urlStr)
 	if err != nil {
 		return fmt.Errorf("invalid URL: %w", err)
 	}

-	domain := parsed.Hostname()
+	if parsed.Scheme == "" {
+		return fmt.Errorf("invalid URL: scheme is required")
+	}
+	if parsed.Scheme != "https" {
+		return fmt.Errorf("network access denied: only https is allowed")
+	}
+
+	domain := parsed.Hostname()
+	if domain == "" {
+		return fmt.Errorf("invalid URL: hostname is required")
+	}

-	// Block private/local network access (SSRF protection)
 	if isPrivateIP(domain) {
 		return fmt.Errorf("network access denied: private/local network '%s' not allowed", domain)
 	}
@@ -42,7 +49,6 @@ func (r *ExtensionRuntime) validateDomain(urlStr string) error {
 	return nil
 }

-// httpGet performs a GET request (sandboxed)
 func (r *ExtensionRuntime) httpGet(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 1 {
 		return r.vm.ToValue(map[string]interface{}{
@@ -76,16 +82,14 @@ func (r *ExtensionRuntime) httpGet(call goja.FunctionCall) goja.Value {
 		})
 	}

-	// Set headers - user headers first
 	for k, v := range headers {
 		req.Header.Set(k, v)
 	}
-	// Only set default User-Agent if not provided by extension
+
 	if req.Header.Get("User-Agent") == "" {
 		req.Header.Set("User-Agent", "Spotiflac-Extension/1.0")
 	}

-	// Execute request
 	resp, err := r.httpClient.Do(req)
 	if err != nil {
 		return r.vm.ToValue(map[string]interface{}{
@@ -101,26 +105,24 @@ func (r *ExtensionRuntime) httpGet(call goja.FunctionCall) goja.Value {
 		})
 	}

-	// Extract response headers - return all values as arrays for multi-value headers (cookies, etc.)
 	respHeaders := make(map[string]interface{})
 	for k, v := range resp.Header {
 		if len(v) == 1 {
 			respHeaders[k] = v[0]
 		} else {
-			respHeaders[k] = v // Return as array if multiple values
+			respHeaders[k] = v
 		}
 	}

 	return r.vm.ToValue(map[string]interface{}{
 		"statusCode": resp.StatusCode,
-		"status":     resp.StatusCode, // Alias for convenience
+		"status":     resp.StatusCode,
 		"ok":         resp.StatusCode >= 200 && resp.StatusCode < 300,
 		"body":       string(body),
 		"headers":    respHeaders,
 	})
 }

-// httpPost performs a POST request (sandboxed)
 func (r *ExtensionRuntime) httpPost(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 1 {
 		return r.vm.ToValue(map[string]interface{}{
@@ -137,7 +139,6 @@ func (r *ExtensionRuntime) httpPost(call goja.FunctionCall) goja.Value {
 		})
 	}

-	// Get body if provided - support both string and object
 	var bodyStr string
 	if len(call.Arguments) > 1 && !goja.IsUndefined(call.Arguments[1]) && !goja.IsNull(call.Arguments[1]) {
 		bodyArg := call.Arguments[1].Export()
@@ -145,7 +146,6 @@ func (r *ExtensionRuntime) httpPost(call goja.FunctionCall) goja.Value {
 		case string:
 			bodyStr = v
 		case map[string]interface{}, []interface{}:
-			// Auto-stringify objects and arrays to JSON
 			jsonBytes, err := json.Marshal(v)
 			if err != nil {
 				return r.vm.ToValue(map[string]interface{}{
@@ -154,12 +154,10 @@ func (r *ExtensionRuntime) httpPost(call goja.FunctionCall) goja.Value {
 			}
 			bodyStr = string(jsonBytes)
 		default:
-			// Fallback to string conversion
 			bodyStr = call.Arguments[1].String()
 		}
 	}

-	// Get headers if provided
 	headers := make(map[string]string)
 	if len(call.Arguments) > 2 && !goja.IsUndefined(call.Arguments[2]) && !goja.IsNull(call.Arguments[2]) {
 		headersObj := call.Arguments[2].Export()
@@ -177,11 +175,10 @@ func (r *ExtensionRuntime) httpPost(call goja.FunctionCall) goja.Value {
 		})
 	}

-	// Set headers - user headers first
 	for k, v := range headers {
 		req.Header.Set(k, v)
 	}
-	// Only set defaults if not provided by extension
+
 	if req.Header.Get("User-Agent") == "" {
 		req.Header.Set("User-Agent", "Spotiflac-Extension/1.0")
 	}
@@ -189,7 +186,6 @@ func (r *ExtensionRuntime) httpPost(call goja.FunctionCall) goja.Value {
 		req.Header.Set("Content-Type", "application/json")
 	}

-	// Execute request
 	resp, err := r.httpClient.Do(req)
 	if err != nil {
 		return r.vm.ToValue(map[string]interface{}{
@@ -205,19 +201,18 @@ func (r *ExtensionRuntime) httpPost(call goja.FunctionCall) goja.Value {
 		})
 	}

-	// Extract response headers - return all values as arrays for multi-value headers
 	respHeaders := make(map[string]interface{})
 	for k, v := range resp.Header {
 		if len(v) == 1 {
 			respHeaders[k] = v[0]
 		} else {
-			respHeaders[k] = v // Return as array if multiple values
+			respHeaders[k] = v
 		}
 	}

 	return r.vm.ToValue(map[string]interface{}{
 		"statusCode": resp.StatusCode,
-		"status":     resp.StatusCode, // Alias for convenience
+		"status":     resp.StatusCode,
 		"ok":         resp.StatusCode >= 200 && resp.StatusCode < 300,
 		"body":       string(body),
 		"headers":    respHeaders,
@@ -240,27 +235,22 @@ func (r *ExtensionRuntime) httpRequest(call goja.FunctionCall) goja.Value {
 		})
 	}

-	// Default options
 	method := "GET"
 	var bodyStr string
 	headers := make(map[string]string)

-	// Parse options if provided
 	if len(call.Arguments) > 1 && !goja.IsUndefined(call.Arguments[1]) && !goja.IsNull(call.Arguments[1]) {
 		optionsObj := call.Arguments[1].Export()
 		if opts, ok := optionsObj.(map[string]interface{}); ok {
-			// Get method
 			if m, ok := opts["method"].(string); ok {
 				method = strings.ToUpper(m)
 			}

-			// Get body - support both string and object
 			if bodyArg, ok := opts["body"]; ok && bodyArg != nil {
 				switch v := bodyArg.(type) {
 				case string:
 					bodyStr = v
 				case map[string]interface{}, []interface{}:
-					// Auto-stringify objects and arrays to JSON
 					jsonBytes, err := json.Marshal(v)
 					if err != nil {
 						return r.vm.ToValue(map[string]interface{}{
@@ -273,7 +263,6 @@ func (r *ExtensionRuntime) httpRequest(call goja.FunctionCall) goja.Value {
 				}
 			}

-			// Get headers
 			if h, ok := opts["headers"].(map[string]interface{}); ok {
 				for k, v := range h {
 					headers[k] = fmt.Sprintf("%v", v)
@@ -282,7 +271,6 @@ func (r *ExtensionRuntime) httpRequest(call goja.FunctionCall) goja.Value {
 		}
 	}

-	// Create request
 	var reqBody io.Reader
 	if bodyStr != "" {
 		reqBody = strings.NewReader(bodyStr)
@@ -295,11 +283,10 @@ func (r *ExtensionRuntime) httpRequest(call goja.FunctionCall) goja.Value {
 		})
 	}

-	// Set headers - user headers first
 	for k, v := range headers {
 		req.Header.Set(k, v)
 	}
-	// Only set defaults if not provided by extension
+
 	if req.Header.Get("User-Agent") == "" {
 		req.Header.Set("User-Agent", "Spotiflac-Extension/1.0")
 	}
@@ -307,7 +294,6 @@ func (r *ExtensionRuntime) httpRequest(call goja.FunctionCall) goja.Value {
 		req.Header.Set("Content-Type", "application/json")
 	}

-	// Execute request
 	resp, err := r.httpClient.Do(req)
 	if err != nil {
 		return r.vm.ToValue(map[string]interface{}{
@@ -323,20 +309,18 @@ func (r *ExtensionRuntime) httpRequest(call goja.FunctionCall) goja.Value {
 		})
 	}

-	// Extract response headers - return all values as arrays for multi-value headers
 	respHeaders := make(map[string]interface{})
 	for k, v := range resp.Header {
 		if len(v) == 1 {
 			respHeaders[k] = v[0]
 		} else {
-			respHeaders[k] = v // Return as array if multiple values
+			respHeaders[k] = v
 		}
 	}

-	// Return response with helper properties
 	return r.vm.ToValue(map[string]interface{}{
 		"statusCode": resp.StatusCode,
-		"status":     resp.StatusCode, // Alias for convenience
+		"status":     resp.StatusCode,
 		"ok":         resp.StatusCode >= 200 && resp.StatusCode < 300,
 		"body":       string(body),
 		"headers":    respHeaders,
@@ -347,7 +331,6 @@ func (r *ExtensionRuntime) httpPut(call goja.FunctionCall) goja.Value {
 	return r.httpMethodShortcut("PUT", call)
 }

-// httpDelete performs a DELETE request (shortcut for http.request with method: "DELETE")
 func (r *ExtensionRuntime) httpDelete(call goja.FunctionCall) goja.Value {
 	return r.httpMethodShortcut("DELETE", call)
 }
@@ -356,8 +339,6 @@ func (r *ExtensionRuntime) httpPatch(call goja.FunctionCall) goja.Value {
 	return r.httpMethodShortcut("PATCH", call)
 }

-// httpMethodShortcut is a helper for PUT/DELETE/PATCH shortcuts
-// Signature: http.put(url, body, headers) / http.delete(url, headers) / http.patch(url, body, headers)
 func (r *ExtensionRuntime) httpMethodShortcut(method string, call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 1 {
 		return r.vm.ToValue(map[string]interface{}{
@@ -377,9 +358,7 @@ func (r *ExtensionRuntime) httpMethodShortcut(method string, call goja.FunctionC
 	var bodyStr string
 	headers := make(map[string]string)

-	// For DELETE, second arg is headers; for PUT/PATCH, second arg is body
 	if method == "DELETE" {
-		// http.delete(url, headers)
 		if len(call.Arguments) > 1 && !goja.IsUndefined(call.Arguments[1]) && !goja.IsNull(call.Arguments[1]) {
 			headersObj := call.Arguments[1].Export()
 			if h, ok := headersObj.(map[string]interface{}); ok {
@@ -389,7 +368,6 @@ func (r *ExtensionRuntime) httpMethodShortcut(method string, call goja.FunctionC
 			}
 		}
 	} else {
-		// http.put(url, body, headers) / http.patch(url, body, headers)
 		if len(call.Arguments) > 1 && !goja.IsUndefined(call.Arguments[1]) && !goja.IsNull(call.Arguments[1]) {
 			bodyArg := call.Arguments[1].Export()
 			switch v := bodyArg.(type) {
@@ -418,7 +396,6 @@ func (r *ExtensionRuntime) httpMethodShortcut(method string, call goja.FunctionC
 		}
 	}

-	// Create request
 	var reqBody io.Reader
 	if bodyStr != "" {
 		reqBody = strings.NewReader(bodyStr)
@@ -431,7 +408,6 @@ func (r *ExtensionRuntime) httpMethodShortcut(method string, call goja.FunctionC
 		})
 	}

-	// Set headers - user headers first
 	for k, v := range headers {
 		req.Header.Set(k, v)
 	}
@@ -442,7 +418,6 @@ func (r *ExtensionRuntime) httpMethodShortcut(method string, call goja.FunctionC
 		req.Header.Set("Content-Type", "application/json")
 	}

-	// Execute request
 	resp, err := r.httpClient.Do(req)
 	if err != nil {
 		return r.vm.ToValue(map[string]interface{}{
@@ -458,7 +433,6 @@ func (r *ExtensionRuntime) httpMethodShortcut(method string, call goja.FunctionC
 		})
 	}

-	// Extract response headers
 	respHeaders := make(map[string]interface{})
 	for k, v := range resp.Header {
 		if len(v) == 1 {
@@ -9,7 +9,6 @@ import (

 // ==================== Track Matching API ====================

-// matchingCompareStrings compares two strings with fuzzy matching
 func (r *ExtensionRuntime) matchingCompareStrings(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 2 {
 		return r.vm.ToValue(0.0)
@@ -22,12 +21,10 @@ func (r *ExtensionRuntime) matchingCompareStrings(call goja.FunctionCall) goja.V
 		return r.vm.ToValue(1.0)
 	}

-	// Calculate Levenshtein distance-based similarity
 	similarity := calculateStringSimilarity(str1, str2)
 	return r.vm.ToValue(similarity)
 }

-// matchingCompareDuration compares two durations with tolerance
 func (r *ExtensionRuntime) matchingCompareDuration(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 2 {
 		return r.vm.ToValue(false)
@@ -36,8 +33,7 @@ func (r *ExtensionRuntime) matchingCompareDuration(call goja.FunctionCall) goja.
 	dur1 := int(call.Arguments[0].ToInteger())
 	dur2 := int(call.Arguments[1].ToInteger())

-	// Default tolerance: 3 seconds
-	tolerance := 3000 // milliseconds
+	tolerance := 3000
 	if len(call.Arguments) > 2 && !goja.IsUndefined(call.Arguments[2]) {
 		tolerance = int(call.Arguments[2].ToInteger())
 	}
@@ -50,7 +46,6 @@ func (r *ExtensionRuntime) matchingCompareDuration(call goja.FunctionCall) goja.
 	return r.vm.ToValue(diff <= tolerance)
 }

-// matchingNormalizeString normalizes a string for comparison
 func (r *ExtensionRuntime) matchingNormalizeString(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 1 {
 		return r.vm.ToValue("")
@@ -61,7 +56,6 @@ func (r *ExtensionRuntime) matchingNormalizeString(call goja.FunctionCall) goja.
 	return r.vm.ToValue(normalized)
 }

-// calculateStringSimilarity calculates similarity between two strings (0-1)
 func calculateStringSimilarity(s1, s2 string) float64 {
 	if len(s1) == 0 && len(s2) == 0 {
 		return 1.0
@@ -70,7 +64,6 @@ func calculateStringSimilarity(s1, s2 string) float64 {
 		return 0.0
 	}

-	// Use Levenshtein distance
 	distance := levenshteinDistance(s1, s2)
 	maxLen := len(s1)
 	if len(s2) > maxLen {
@@ -80,7 +73,6 @@ func calculateStringSimilarity(s1, s2 string) float64 {
 	return 1.0 - float64(distance)/float64(maxLen)
 }

-// levenshteinDistance calculates the Levenshtein distance between two strings
 func levenshteinDistance(s1, s2 string) int {
 	if len(s1) == 0 {
 		return len(s2)
@@ -89,7 +81,6 @@ func levenshteinDistance(s1, s2 string) int {
 		return len(s1)
 	}

-	// Create matrix
 	matrix := make([][]int, len(s1)+1)
 	for i := range matrix {
 		matrix[i] = make([]int, len(s2)+1)
@@ -99,7 +90,6 @@ func levenshteinDistance(s1, s2 string) int {
 		matrix[0][j] = j
 	}

-	// Fill matrix
 	for i := 1; i <= len(s1); i++ {
 		for j := 1; j <= len(s2); j++ {
 			cost := 1
@@ -107,9 +97,9 @@ func levenshteinDistance(s1, s2 string) int {
 				cost = 0
 			}
 			matrix[i][j] = min(
-				matrix[i-1][j]+1,      // deletion
-				matrix[i][j-1]+1,      // insertion
-				matrix[i-1][j-1]+cost, // substitution
+				matrix[i-1][j]+1,
+				matrix[i][j-1]+1,
+				matrix[i-1][j-1]+cost,
 			)
 		}
 	}
@@ -117,12 +107,9 @@ func levenshteinDistance(s1, s2 string) int {
 	return matrix[len(s1)][len(s2)]
 }

-// normalizeStringForMatching normalizes a string for comparison
 func normalizeStringForMatching(s string) string {
-	// Convert to lowercase
 	s = strings.ToLower(s)

-	// Remove common suffixes/prefixes
 	suffixes := []string{
 		" (remastered)", " (remaster)", " - remastered", " - remaster",
 		" (deluxe)", " (deluxe edition)", " - deluxe", " - deluxe edition",
@@ -136,7 +123,6 @@ func normalizeStringForMatching(s string) string {
 		}
 	}

-	// Remove special characters
 	var result strings.Builder
 	for _, r := range s {
 		if (r >= 'a' && r <= 'z') || (r >= '0' && r <= '9') || r == ' ' {
@@ -144,7 +130,6 @@ func normalizeStringForMatching(s string) string {
 		}
 	}

-	// Collapse multiple spaces
 	s = strings.Join(strings.Fields(result.String()), " ")

 	return strings.TrimSpace(s)
@@ -25,14 +25,11 @@ func (r *ExtensionRuntime) fetchPolyfill(call goja.FunctionCall) goja.Value {
 	}

 	urlStr := call.Arguments[0].String()
-
-	// Validate domain
 	if err := r.validateDomain(urlStr); err != nil {
 		GoLog("[Extension:%s] fetch blocked: %v\n", r.extensionID, err)
 		return r.createFetchError(err.Error())
 	}

-	// Parse options
 	method := "GET"
 	var bodyStr string
 	headers := make(map[string]string)
@@ -40,7 +37,6 @@ func (r *ExtensionRuntime) fetchPolyfill(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) > 1 && !goja.IsUndefined(call.Arguments[1]) && !goja.IsNull(call.Arguments[1]) {
 		optionsObj := call.Arguments[1].Export()
 		if opts, ok := optionsObj.(map[string]interface{}); ok {
-			// Method
 			if m, ok := opts["method"].(string); ok {
 				method = strings.ToUpper(m)
 			}
@@ -61,7 +57,6 @@ func (r *ExtensionRuntime) fetchPolyfill(call goja.FunctionCall) goja.Value {
 				}
 			}

-			// Headers
 			if h, ok := opts["headers"]; ok && h != nil {
 				switch hv := h.(type) {
 				case map[string]interface{}:
@@ -73,7 +68,6 @@ func (r *ExtensionRuntime) fetchPolyfill(call goja.FunctionCall) goja.Value {
 		}
 	}

-	// Create HTTP request
 	var reqBody io.Reader
 	if bodyStr != "" {
 		reqBody = strings.NewReader(bodyStr)
@@ -84,11 +78,9 @@ func (r *ExtensionRuntime) fetchPolyfill(call goja.FunctionCall) goja.Value {
 		return r.createFetchError(err.Error())
 	}

-	// Set headers - user headers first
 	for k, v := range headers {
 		req.Header.Set(k, v)
 	}
-	// Set defaults if not provided
 	if req.Header.Get("User-Agent") == "" {
 		req.Header.Set("User-Agent", "SpotiFLAC-Extension/1.0")
 	}
@@ -96,20 +88,17 @@ func (r *ExtensionRuntime) fetchPolyfill(call goja.FunctionCall) goja.Value {
 		req.Header.Set("Content-Type", "application/json")
 	}

-	// Execute request
 	resp, err := r.httpClient.Do(req)
 	if err != nil {
 		return r.createFetchError(err.Error())
 	}
 	defer resp.Body.Close()

-	// Read body
 	body, err := io.ReadAll(resp.Body)
 	if err != nil {
 		return r.createFetchError(err.Error())
 	}

-	// Extract response headers
 	respHeaders := make(map[string]interface{})
 	for k, v := range resp.Header {
 		if len(v) == 1 {
@@ -119,7 +108,6 @@ func (r *ExtensionRuntime) fetchPolyfill(call goja.FunctionCall) goja.Value {
 		}
 	}

-	// Create Response object (browser-compatible)
 	responseObj := r.vm.NewObject()
 	responseObj.Set("ok", resp.StatusCode >= 200 && resp.StatusCode < 300)
 	responseObj.Set("status", resp.StatusCode)
@@ -127,15 +115,12 @@ func (r *ExtensionRuntime) fetchPolyfill(call goja.FunctionCall) goja.Value {
 	responseObj.Set("headers", respHeaders)
 	responseObj.Set("url", urlStr)

-	// Store body for methods
 	bodyString := string(body)

-	// text() method - returns body as string
 	responseObj.Set("text", func(call goja.FunctionCall) goja.Value {
 		return r.vm.ToValue(bodyString)
 	})

-	// json() method - parses body as JSON
 	responseObj.Set("json", func(call goja.FunctionCall) goja.Value {
 		var result interface{}
 		if err := json.Unmarshal(body, &result); err != nil {
@@ -145,9 +130,7 @@ func (r *ExtensionRuntime) fetchPolyfill(call goja.FunctionCall) goja.Value {
 		return r.vm.ToValue(result)
 	})

-	// arrayBuffer() method - returns body as array (simplified)
 	responseObj.Set("arrayBuffer", func(call goja.FunctionCall) goja.Value {
-		// Return as array of bytes
 		byteArray := make([]interface{}, len(body))
 		for i, b := range body {
 			byteArray[i] = int(b)
@@ -182,7 +165,6 @@ func (r *ExtensionRuntime) atobPolyfill(call goja.FunctionCall) goja.Value {
 	input := call.Arguments[0].String()
 	decoded, err := base64.StdEncoding.DecodeString(input)
 	if err != nil {
-		// Try URL-safe base64
 		decoded, err = base64.URLEncoding.DecodeString(input)
 		if err != nil {
 			GoLog("[Extension:%s] atob decode error: %v\n", r.extensionID, err)
@@ -203,12 +185,10 @@ func (r *ExtensionRuntime) btoaPolyfill(call goja.FunctionCall) goja.Value {

 // registerTextEncoderDecoder registers TextEncoder and TextDecoder classes
 func (r *ExtensionRuntime) registerTextEncoderDecoder(vm *goja.Runtime) {
-	// TextEncoder constructor
 	vm.Set("TextEncoder", func(call goja.ConstructorCall) *goja.Object {
 		encoder := call.This
 		encoder.Set("encoding", "utf-8")

-		// encode() method - string to Uint8Array
 		encoder.Set("encode", func(call goja.FunctionCall) goja.Value {
 			if len(call.Arguments) < 1 {
 				return vm.ToValue([]byte{})
@@ -216,7 +196,6 @@ func (r *ExtensionRuntime) registerTextEncoderDecoder(vm *goja.Runtime) {
 			input := call.Arguments[0].String()
 			bytes := []byte(input)

-			// Return as array (Uint8Array-like)
 			result := make([]interface{}, len(bytes))
 			for i, b := range bytes {
 				result[i] = int(b)
@@ -224,7 +203,6 @@ func (r *ExtensionRuntime) registerTextEncoderDecoder(vm *goja.Runtime) {
 			return vm.ToValue(result)
 		})

-		// encodeInto() method
 		encoder.Set("encodeInto", func(call goja.FunctionCall) goja.Value {
 			// Simplified implementation
 			if len(call.Arguments) < 2 {
@@ -240,11 +218,9 @@ func (r *ExtensionRuntime) registerTextEncoderDecoder(vm *goja.Runtime) {
 		return nil
 	})

-	// TextDecoder constructor
 	vm.Set("TextDecoder", func(call goja.ConstructorCall) *goja.Object {
 		decoder := call.This

-		// Get encoding from arguments (default: utf-8)
 		encoding := "utf-8"
 		if len(call.Arguments) > 0 && !goja.IsUndefined(call.Arguments[0]) {
 			encoding = call.Arguments[0].String()
@@ -253,13 +229,11 @@ func (r *ExtensionRuntime) registerTextEncoderDecoder(vm *goja.Runtime) {
 		decoder.Set("fatal", false)
 		decoder.Set("ignoreBOM", false)

-		// decode() method - Uint8Array to string
 		decoder.Set("decode", func(call goja.FunctionCall) goja.Value {
 			if len(call.Arguments) < 1 {
 				return vm.ToValue("")
 			}

-			// Handle different input types
 			input := call.Arguments[0].Export()
 			var bytes []byte

@@ -279,7 +253,6 @@ func (r *ExtensionRuntime) registerTextEncoderDecoder(vm *goja.Runtime) {
 					}
 				}
 			case string:
-				// Already a string, just return it
 				return vm.ToValue(v)
 			default:
 				return vm.ToValue("")
@@ -292,7 +265,6 @@ func (r *ExtensionRuntime) registerTextEncoderDecoder(vm *goja.Runtime) {
 	})
 }

-// registerURLClass registers the URL class for URL parsing
 func (r *ExtensionRuntime) registerURLClass(vm *goja.Runtime) {
 	vm.Set("URL", func(call goja.ConstructorCall) *goja.Object {
 		urlObj := call.This
@@ -304,7 +276,6 @@ func (r *ExtensionRuntime) registerURLClass(vm *goja.Runtime) {

 		urlStr := call.Arguments[0].String()

-		// Handle relative URLs with base
 		if len(call.Arguments) > 1 && !goja.IsUndefined(call.Arguments[1]) {
 			baseStr := call.Arguments[1].String()
 			baseURL, err := url.Parse(baseStr)
@@ -322,7 +293,6 @@ func (r *ExtensionRuntime) registerURLClass(vm *goja.Runtime) {
 			return nil
 		}

-		// Set URL properties
 		urlObj.Set("href", parsed.String())
 		urlObj.Set("protocol", parsed.Scheme+":")
 		urlObj.Set("host", parsed.Host)
@@ -342,10 +312,9 @@ func (r *ExtensionRuntime) registerURLClass(vm *goja.Runtime) {
 		password, _ := parsed.User.Password()
 		urlObj.Set("password", password)

-		// searchParams object
-		searchParams := vm.NewObject()
 		queryValues := parsed.Query()

+		searchParams := vm.NewObject()
 		searchParams.Set("get", func(call goja.FunctionCall) goja.Value {
 			if len(call.Arguments) < 1 {
 				return goja.Null()
@@ -379,12 +348,10 @@ func (r *ExtensionRuntime) registerURLClass(vm *goja.Runtime) {

 		urlObj.Set("searchParams", searchParams)

-		// toString method
 		urlObj.Set("toString", func(call goja.FunctionCall) goja.Value {
 			return vm.ToValue(parsed.String())
 		})

-		// toJSON method
 		urlObj.Set("toJSON", func(call goja.FunctionCall) goja.Value {
 			return vm.ToValue(parsed.String())
 		})
@@ -392,17 +359,14 @@ func (r *ExtensionRuntime) registerURLClass(vm *goja.Runtime) {
 		return nil
 	})

-	// URLSearchParams constructor
 	vm.Set("URLSearchParams", func(call goja.ConstructorCall) *goja.Object {
 		paramsObj := call.This
 		values := url.Values{}

-		// Parse initial value if provided
 		if len(call.Arguments) > 0 && !goja.IsUndefined(call.Arguments[0]) {
 			init := call.Arguments[0].Export()
 			switch v := init.(type) {
 			case string:
-				// Parse query string
 				parsed, _ := url.ParseQuery(strings.TrimPrefix(v, "?"))
 				values = parsed
 			case map[string]interface{}:
@@ -468,10 +432,6 @@ func (r *ExtensionRuntime) registerURLClass(vm *goja.Runtime) {
 // registerJSONGlobal ensures JSON global is properly set up
 func (r *ExtensionRuntime) registerJSONGlobal(vm *goja.Runtime) {
 	// JSON is already built-in to Goja, but we can enhance it
-	// This ensures JSON.parse and JSON.stringify work as expected
-
-	// The built-in JSON object should already work, but let's verify
-	// and add any missing functionality if needed
 	jsonScript := `
 		if (typeof JSON === 'undefined') {
 			var JSON = {
@@ -17,12 +17,10 @@ import (

 // ==================== Storage API ====================

-// getStoragePath returns the path to the extension's storage file
 func (r *ExtensionRuntime) getStoragePath() string {
 	return filepath.Join(r.dataDir, "storage.json")
 }

-// loadStorage loads the storage data from disk
 func (r *ExtensionRuntime) loadStorage() (map[string]interface{}, error) {
 	storagePath := r.getStoragePath()
 	data, err := os.ReadFile(storagePath)
@@ -41,7 +39,6 @@ func (r *ExtensionRuntime) loadStorage() (map[string]interface{}, error) {
 	return storage, nil
 }

-// saveStorage saves the storage data to disk
 func (r *ExtensionRuntime) saveStorage(storage map[string]interface{}) error {
 	storagePath := r.getStoragePath()
 	data, err := json.MarshalIndent(storage, "", "  ")
@@ -52,7 +49,6 @@ func (r *ExtensionRuntime) saveStorage(storage map[string]interface{}) error {
 	return os.WriteFile(storagePath, data, 0644)
 }

-// storageGet retrieves a value from storage
 func (r *ExtensionRuntime) storageGet(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 1 {
 		return goja.Undefined()
@@ -68,7 +64,6 @@ func (r *ExtensionRuntime) storageGet(call goja.FunctionCall) goja.Value {

 	value, exists := storage[key]
 	if !exists {
-		// Return default value if provided
 		if len(call.Arguments) > 1 {
 			return call.Arguments[1]
 		}
@@ -78,7 +73,6 @@ func (r *ExtensionRuntime) storageGet(call goja.FunctionCall) goja.Value {
 	return r.vm.ToValue(value)
 }

-// storageSet stores a value in storage
 func (r *ExtensionRuntime) storageSet(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 2 {
 		return r.vm.ToValue(false)
@@ -103,7 +97,6 @@ func (r *ExtensionRuntime) storageSet(call goja.FunctionCall) goja.Value {
 	return r.vm.ToValue(true)
 }

-// storageRemove removes a value from storage
 func (r *ExtensionRuntime) storageRemove(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 1 {
 		return r.vm.ToValue(false)
@@ -127,19 +120,14 @@ func (r *ExtensionRuntime) storageRemove(call goja.FunctionCall) goja.Value {
 	return r.vm.ToValue(true)
 }

-// ==================== Credentials API (Encrypted Storage) ====================
-
-// getCredentialsPath returns the path to the extension's encrypted credentials file
 func (r *ExtensionRuntime) getCredentialsPath() string {
 	return filepath.Join(r.dataDir, ".credentials.enc")
 }

-// getSaltPath returns the path to the extension's encryption salt file
 func (r *ExtensionRuntime) getSaltPath() string {
 	return filepath.Join(r.dataDir, ".cred_salt")
 }

-// getOrCreateSalt gets existing salt or creates a new random one
 func (r *ExtensionRuntime) getOrCreateSalt() ([]byte, error) {
 	saltPath := r.getSaltPath()

@@ -160,22 +148,17 @@ func (r *ExtensionRuntime) getOrCreateSalt() ([]byte, error) {
 	return salt, nil
 }

-// getEncryptionKey derives an encryption key from extension ID + random salt
 func (r *ExtensionRuntime) getEncryptionKey() ([]byte, error) {
-	// Get or create per-installation random salt
 	salt, err := r.getOrCreateSalt()
 	if err != nil {
 		return nil, err
 	}

-	// Combine extension ID + random salt for key derivation
-	// This makes each installation unique, preventing mass decryption attacks
 	combined := append([]byte(r.extensionID), salt...)
 	hash := sha256.Sum256(combined)
 	return hash[:], nil
 }

-// loadCredentials loads and decrypts credentials from disk
 func (r *ExtensionRuntime) loadCredentials() (map[string]interface{}, error) {
 	credPath := r.getCredentialsPath()
 	data, err := os.ReadFile(credPath)
@@ -186,7 +169,6 @@ func (r *ExtensionRuntime) loadCredentials() (map[string]interface{}, error) {
 		return nil, err
 	}

-	// Decrypt the data
 	key, err := r.getEncryptionKey()
 	if err != nil {
 		return nil, fmt.Errorf("failed to get encryption key: %w", err)
@@ -204,7 +186,6 @@ func (r *ExtensionRuntime) loadCredentials() (map[string]interface{}, error) {
 	return creds, nil
 }

-// saveCredentials encrypts and saves credentials to disk
 func (r *ExtensionRuntime) saveCredentials(creds map[string]interface{}) error {
 	data, err := json.Marshal(creds)
 	if err != nil {
@@ -221,10 +202,9 @@ func (r *ExtensionRuntime) saveCredentials(creds map[string]interface{}) error {
 	}

 	credPath := r.getCredentialsPath()
-	return os.WriteFile(credPath, encrypted, 0600) // Restrictive permissions
+	return os.WriteFile(credPath, encrypted, 0600)
 }

-// credentialsStore stores an encrypted credential
 func (r *ExtensionRuntime) credentialsStore(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 2 {
 		return r.vm.ToValue(map[string]interface{}{
@@ -260,7 +240,6 @@ func (r *ExtensionRuntime) credentialsStore(call goja.FunctionCall) goja.Value {
 	})
 }

-// credentialsGet retrieves a decrypted credential
 func (r *ExtensionRuntime) credentialsGet(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 1 {
 		return goja.Undefined()
@@ -276,7 +255,6 @@ func (r *ExtensionRuntime) credentialsGet(call goja.FunctionCall) goja.Value {

 	value, exists := creds[key]
 	if !exists {
-		// Return default value if provided
 		if len(call.Arguments) > 1 {
 			return call.Arguments[1]
 		}
@@ -286,7 +264,6 @@ func (r *ExtensionRuntime) credentialsGet(call goja.FunctionCall) goja.Value {
 	return r.vm.ToValue(value)
 }

-// credentialsRemove removes a credential
 func (r *ExtensionRuntime) credentialsRemove(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 1 {
 		return r.vm.ToValue(false)
@@ -310,7 +287,6 @@ func (r *ExtensionRuntime) credentialsRemove(call goja.FunctionCall) goja.Value
 	return r.vm.ToValue(true)
 }

-// credentialsHas checks if a credential exists
 func (r *ExtensionRuntime) credentialsHas(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 1 {
 		return r.vm.ToValue(false)
@@ -327,9 +303,6 @@ func (r *ExtensionRuntime) credentialsHas(call goja.FunctionCall) goja.Value {
 	return r.vm.ToValue(exists)
 }

-// ==================== Crypto Utilities ====================
-
-// encryptAES encrypts data using AES-GCM
 func encryptAES(plaintext []byte, key []byte) ([]byte, error) {
 	block, err := aes.NewCipher(key)
 	if err != nil {
@@ -350,7 +323,6 @@ func encryptAES(plaintext []byte, key []byte) ([]byte, error) {
 	return ciphertext, nil
 }

-// decryptAES decrypts data using AES-GCM
 func decryptAES(ciphertext []byte, key []byte) ([]byte, error) {
 	block, err := aes.NewCipher(key)
 	if err != nil {
@@ -19,7 +19,6 @@ import (

 // ==================== Utility Functions ====================

-// base64Encode encodes a string to base64
 func (r *ExtensionRuntime) base64Encode(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 1 {
 		return r.vm.ToValue("")
@@ -28,7 +27,6 @@ func (r *ExtensionRuntime) base64Encode(call goja.FunctionCall) goja.Value {
 	return r.vm.ToValue(base64.StdEncoding.EncodeToString([]byte(input)))
 }

-// base64Decode decodes a base64 string
 func (r *ExtensionRuntime) base64Decode(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 1 {
 		return r.vm.ToValue("")
@@ -41,7 +39,6 @@ func (r *ExtensionRuntime) base64Decode(call goja.FunctionCall) goja.Value {
 	return r.vm.ToValue(string(decoded))
 }

-// md5Hash computes MD5 hash of a string
 func (r *ExtensionRuntime) md5Hash(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 1 {
 		return r.vm.ToValue("")
@@ -51,7 +48,6 @@ func (r *ExtensionRuntime) md5Hash(call goja.FunctionCall) goja.Value {
 	return r.vm.ToValue(hex.EncodeToString(hash[:]))
 }

-// sha256Hash computes SHA256 hash of a string
 func (r *ExtensionRuntime) sha256Hash(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 1 {
 		return r.vm.ToValue("")
@@ -61,7 +57,6 @@ func (r *ExtensionRuntime) sha256Hash(call goja.FunctionCall) goja.Value {
 	return r.vm.ToValue(hex.EncodeToString(hash[:]))
 }

-// hmacSHA256 computes HMAC-SHA256 of a message with a key
 func (r *ExtensionRuntime) hmacSHA256(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 2 {
 		return r.vm.ToValue("")
@@ -74,7 +69,6 @@ func (r *ExtensionRuntime) hmacSHA256(call goja.FunctionCall) goja.Value {
 	return r.vm.ToValue(hex.EncodeToString(mac.Sum(nil)))
 }

-// hmacSHA256Base64 computes HMAC-SHA256 and returns base64 encoded result
 func (r *ExtensionRuntime) hmacSHA256Base64(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 2 {
 		return r.vm.ToValue("")
@@ -87,9 +81,6 @@ func (r *ExtensionRuntime) hmacSHA256Base64(call goja.FunctionCall) goja.Value {
 	return r.vm.ToValue(base64.StdEncoding.EncodeToString(mac.Sum(nil)))
 }

-// hmacSHA1 computes HMAC-SHA1 of a message with a key (for TOTP)
-// Arguments: message (string or array of bytes), key (string or array of bytes)
-// Returns: array of bytes (for TOTP dynamic truncation)
 func (r *ExtensionRuntime) hmacSHA1(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 2 {
 		return r.vm.ToValue([]byte{})
@@ -142,7 +133,6 @@ func (r *ExtensionRuntime) hmacSHA1(call goja.FunctionCall) goja.Value {
 	return r.vm.ToValue(jsArray)
 }

-// parseJSON parses a JSON string
 func (r *ExtensionRuntime) parseJSON(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 1 {
 		return goja.Undefined()
@@ -158,7 +148,6 @@ func (r *ExtensionRuntime) parseJSON(call goja.FunctionCall) goja.Value {
 	return r.vm.ToValue(result)
 }

-// stringifyJSON converts a value to JSON string
 func (r *ExtensionRuntime) stringifyJSON(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 1 {
 		return r.vm.ToValue("")
@@ -174,9 +163,6 @@ func (r *ExtensionRuntime) stringifyJSON(call goja.FunctionCall) goja.Value {
 	return r.vm.ToValue(string(data))
 }

-// ==================== Crypto Utilities for Extensions ====================
-
-// cryptoEncrypt encrypts a string using AES-GCM (for extension use)
 func (r *ExtensionRuntime) cryptoEncrypt(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 2 {
 		return r.vm.ToValue(map[string]interface{}{
@@ -188,7 +174,6 @@ func (r *ExtensionRuntime) cryptoEncrypt(call goja.FunctionCall) goja.Value {
 	plaintext := call.Arguments[0].String()
 	keyStr := call.Arguments[1].String()

-	// Derive 32-byte key from provided key string
 	keyHash := sha256.Sum256([]byte(keyStr))

 	encrypted, err := encryptAES([]byte(plaintext), keyHash[:])
@@ -205,7 +190,6 @@ func (r *ExtensionRuntime) cryptoEncrypt(call goja.FunctionCall) goja.Value {
 	})
 }

-// cryptoDecrypt decrypts a string using AES-GCM (for extension use)
 func (r *ExtensionRuntime) cryptoDecrypt(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 2 {
 		return r.vm.ToValue(map[string]interface{}{
@@ -225,14 +209,13 @@ func (r *ExtensionRuntime) cryptoDecrypt(call goja.FunctionCall) goja.Value {
 		})
 	}

-	// Derive 32-byte key from provided key string
 	keyHash := sha256.Sum256([]byte(keyStr))

 	decrypted, err := decryptAES(ciphertext, keyHash[:])
 	if err != nil {
 		return r.vm.ToValue(map[string]interface{}{
 			"success": false,
-			"error":   err.Error(),
+			"error":   "invalid base64 ciphertext",
 		})
 	}

@@ -242,9 +225,8 @@ func (r *ExtensionRuntime) cryptoDecrypt(call goja.FunctionCall) goja.Value {
 	})
 }

-// cryptoGenerateKey generates a random encryption key
 func (r *ExtensionRuntime) cryptoGenerateKey(call goja.FunctionCall) goja.Value {
-	length := 32 // Default 256-bit key
+	length := 32
 	if len(call.Arguments) > 0 && !goja.IsUndefined(call.Arguments[0]) {
 		if l, ok := call.Arguments[0].Export().(float64); ok {
 			length = int(l)
@@ -266,13 +248,10 @@ func (r *ExtensionRuntime) cryptoGenerateKey(call goja.FunctionCall) goja.Value
 	})
 }

-// randomUserAgent returns a random Chrome User-Agent string
 func (r *ExtensionRuntime) randomUserAgent(call goja.FunctionCall) goja.Value {
 	return r.vm.ToValue(getRandomUserAgent())
 }

-// ==================== Logging Functions ====================
-
 func (r *ExtensionRuntime) logDebug(call goja.FunctionCall) goja.Value {
 	msg := r.formatLogArgs(call.Arguments)
 	GoLog("[Extension:%s:DEBUG] %s\n", r.extensionID, msg)
@@ -305,8 +284,6 @@ func (r *ExtensionRuntime) formatLogArgs(args []goja.Value) string {
 	return strings.Join(parts, " ")
 }

-// ==================== Go Backend Wrappers ====================
-
 func (r *ExtensionRuntime) sanitizeFilenameWrapper(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 1 {
 		return r.vm.ToValue("")
@@ -315,7 +292,6 @@ func (r *ExtensionRuntime) sanitizeFilenameWrapper(call goja.FunctionCall) goja.
 	return r.vm.ToValue(sanitizeFilename(input))
 }

-// RegisterGoBackendAPIs adds more Go backend functions to the VM
 func (r *ExtensionRuntime) RegisterGoBackendAPIs(vm *goja.Runtime) {
 	gobackendObj := vm.Get("gobackend")
 	if gobackendObj == nil || goja.IsUndefined(gobackendObj) {
@@ -325,7 +301,6 @@ func (r *ExtensionRuntime) RegisterGoBackendAPIs(vm *goja.Runtime) {

 	obj := gobackendObj.(*goja.Object)

-	// Expose sanitizeFilename
 	obj.Set("sanitizeFilename", func(call goja.FunctionCall) goja.Value {
 		if len(call.Arguments) < 1 {
 			return vm.ToValue("")
@@ -333,7 +308,6 @@ func (r *ExtensionRuntime) RegisterGoBackendAPIs(vm *goja.Runtime) {
 		return vm.ToValue(sanitizeFilename(call.Arguments[0].String()))
 	})

-	// Expose getAudioQuality
 	obj.Set("getAudioQuality", func(call goja.FunctionCall) goja.Value {
 		if len(call.Arguments) < 1 {
 			return vm.ToValue(map[string]interface{}{
@@ -356,7 +330,6 @@ func (r *ExtensionRuntime) RegisterGoBackendAPIs(vm *goja.Runtime) {
 		})
 	})

-	// Expose buildFilename
 	obj.Set("buildFilename", func(call goja.FunctionCall) goja.Value {
 		if len(call.Arguments) < 2 {
 			return vm.ToValue("")
@@ -373,7 +346,6 @@ func (r *ExtensionRuntime) RegisterGoBackendAPIs(vm *goja.Runtime) {
 		return vm.ToValue(buildFilenameFromTemplate(template, metadata))
 	})

-	// Expose getLocalTime - returns device local time info
 	obj.Set("getLocalTime", func(call goja.FunctionCall) goja.Value {
 		now := time.Now()
 		_, offsetSeconds := now.Zone()
@@ -9,20 +9,17 @@ import (
 	"sync"
 )

-// ExtensionSettingsStore manages settings for all extensions
 type ExtensionSettingsStore struct {
 	mu       sync.RWMutex
 	dataDir  string
 	settings map[string]map[string]interface{} // extensionID -> settings
 }

-// Global settings store
 var (
 	globalSettingsStore     *ExtensionSettingsStore
 	globalSettingsStoreOnce sync.Once
 )

-// GetExtensionSettingsStore returns the global settings store
 func GetExtensionSettingsStore() *ExtensionSettingsStore {
 	globalSettingsStoreOnce.Do(func() {
 		globalSettingsStore = &ExtensionSettingsStore{
@@ -32,7 +29,6 @@ func GetExtensionSettingsStore() *ExtensionSettingsStore {
 	return globalSettingsStore
 }

-// SetDataDir sets the data directory for settings storage
 func (s *ExtensionSettingsStore) SetDataDir(dataDir string) error {
 	s.mu.Lock()
 	defer s.mu.Unlock()
@@ -45,12 +41,10 @@ func (s *ExtensionSettingsStore) SetDataDir(dataDir string) error {
 	return s.loadAllSettings()
 }

-// getSettingsPath returns the path to an extension's settings file
 func (s *ExtensionSettingsStore) getSettingsPath(extensionID string) string {
 	return filepath.Join(s.dataDir, extensionID, "settings.json")
 }

-// loadAllSettings loads settings for all extensions from disk
 func (s *ExtensionSettingsStore) loadAllSettings() error {
 	entries, err := os.ReadDir(s.dataDir)
 	if err != nil {
@@ -75,7 +69,6 @@ func (s *ExtensionSettingsStore) loadAllSettings() error {
 	return nil
 }

-// loadSettings loads settings for a specific extension
 func (s *ExtensionSettingsStore) loadSettings(extensionID string) (map[string]interface{}, error) {
 	settingsPath := s.getSettingsPath(extensionID)
 	data, err := os.ReadFile(settingsPath)
@@ -94,7 +87,6 @@ func (s *ExtensionSettingsStore) loadSettings(extensionID string) (map[string]in
 	return settings, nil
 }

-// saveSettings saves settings for a specific extension
 func (s *ExtensionSettingsStore) saveSettings(extensionID string, settings map[string]interface{}) error {
 	settingsPath := s.getSettingsPath(extensionID)

@@ -111,8 +103,6 @@ func (s *ExtensionSettingsStore) saveSettings(extensionID string, settings map[s
 	return os.WriteFile(settingsPath, data, 0644)
 }

-// Get retrieves a setting value for an extension
-// Returns error if extension or key not found (gomobile compatible)
 func (s *ExtensionSettingsStore) Get(extensionID, key string) (interface{}, error) {
 	s.mu.RLock()
 	defer s.mu.RUnlock()
@@ -129,7 +119,6 @@ func (s *ExtensionSettingsStore) Get(extensionID, key string) (interface{}, erro
 	return value, nil
 }

-// GetAll retrieves all settings for an extension
 func (s *ExtensionSettingsStore) GetAll(extensionID string) map[string]interface{} {
 	s.mu.RLock()
 	defer s.mu.RUnlock()
@@ -139,7 +128,6 @@ func (s *ExtensionSettingsStore) GetAll(extensionID string) map[string]interface
 		return make(map[string]interface{})
 	}

-	// Return a copy
 	result := make(map[string]interface{})
 	for k, v := range extSettings {
 		result[k] = v
@@ -147,7 +135,6 @@ func (s *ExtensionSettingsStore) GetAll(extensionID string) map[string]interface
 	return result
 }

-// Set stores a setting value for an extension
 func (s *ExtensionSettingsStore) Set(extensionID, key string, value interface{}) error {
 	s.mu.Lock()
 	defer s.mu.Unlock()
@@ -161,18 +148,15 @@ func (s *ExtensionSettingsStore) Set(extensionID, key string, value interface{})
 	return s.saveSettings(extensionID, s.settings[extensionID])
 }

-// SetAll stores all settings for an extension
 func (s *ExtensionSettingsStore) SetAll(extensionID string, settings map[string]interface{}) error {
 	s.mu.Lock()
 	defer s.mu.Unlock()

 	s.settings[extensionID] = settings

-	// Persist to disk
 	return s.saveSettings(extensionID, settings)
 }

-// Remove removes a setting for an extension
 func (s *ExtensionSettingsStore) Remove(extensionID, key string) error {
 	s.mu.Lock()
 	defer s.mu.Unlock()
@@ -184,11 +168,9 @@ func (s *ExtensionSettingsStore) Remove(extensionID, key string) error {

 	delete(extSettings, key)

-	// Persist to disk
 	return s.saveSettings(extensionID, extSettings)
 }

-// RemoveAll removes all settings for an extension
 func (s *ExtensionSettingsStore) RemoveAll(extensionID string) error {
 	s.mu.Lock()
 	defer s.mu.Unlock()
@@ -203,7 +185,6 @@ func (s *ExtensionSettingsStore) RemoveAll(extensionID string) error {
 	return nil
 }

-// GetAllExtensionSettings returns settings for all extensions as JSON
 func (s *ExtensionSettingsStore) GetAllExtensionSettingsJSON() (string, error) {
 	s.mu.RLock()
 	defer s.mu.RUnlock()
@@ -5,13 +5,13 @@ import (
 	"fmt"
 	"io"
 	"net/http"
+	"net/url"
 	"os"
 	"path/filepath"
 	"sync"
 	"time"
 )

-// Extension categories
 const (
 	CategoryMetadata    = "metadata"
 	CategoryDownload    = "download"
@@ -20,28 +20,26 @@ const (
 	CategoryIntegration = "integration"
 )

-// StoreExtension represents an extension in the store
 type StoreExtension struct {
-	ID            string   `json:"id"`
-	Name          string   `json:"name"`
-	DisplayName   string   `json:"display_name,omitempty"`
-	Version       string   `json:"version"`
-	Author        string   `json:"author"`
-	Description   string   `json:"description"`
-	DownloadURL   string   `json:"download_url,omitempty"`
-	IconURL       string   `json:"icon_url,omitempty"`
-	Category      string   `json:"category"`
-	Tags          []string `json:"tags,omitempty"`
-	Downloads     int      `json:"downloads"`
-	UpdatedAt     string   `json:"updated_at"`
-	MinAppVersion string   `json:"min_app_version,omitempty"`
-	DisplayNameAlt   string `json:"displayName,omitempty"`
-	DownloadURLAlt   string `json:"downloadUrl,omitempty"`
-	IconURLAlt       string `json:"iconUrl,omitempty"`
-	MinAppVersionAlt string `json:"minAppVersion,omitempty"`
+	ID               string   `json:"id"`
+	Name             string   `json:"name"`
+	DisplayName      string   `json:"display_name,omitempty"`
+	Version          string   `json:"version"`
+	Author           string   `json:"author"`
+	Description      string   `json:"description"`
+	DownloadURL      string   `json:"download_url,omitempty"`
+	IconURL          string   `json:"icon_url,omitempty"`
+	Category         string   `json:"category"`
+	Tags             []string `json:"tags,omitempty"`
+	Downloads        int      `json:"downloads"`
+	UpdatedAt        string   `json:"updated_at"`
+	MinAppVersion    string   `json:"min_app_version,omitempty"`
+	DisplayNameAlt   string   `json:"displayName,omitempty"`
+	DownloadURLAlt   string   `json:"downloadUrl,omitempty"`
+	IconURLAlt       string   `json:"iconUrl,omitempty"`
+	MinAppVersionAlt string   `json:"minAppVersion,omitempty"`
 }

-// getDisplayName returns display name, falling back to name (private to avoid gomobile conflict)
 func (e *StoreExtension) getDisplayName() string {
 	if e.DisplayName != "" {
 		return e.DisplayName
@@ -52,7 +50,6 @@ func (e *StoreExtension) getDisplayName() string {
 	return e.Name
 }

-// getDownloadURL returns download URL from either field (private to avoid gomobile conflict)
 func (e *StoreExtension) getDownloadURL() string {
 	if e.DownloadURL != "" {
 		return e.DownloadURL
@@ -60,7 +57,6 @@ func (e *StoreExtension) getDownloadURL() string {
 	return e.DownloadURLAlt
 }

-// getIconURL returns icon URL from either field (private to avoid gomobile conflict)
 func (e *StoreExtension) getIconURL() string {
 	if e.IconURL != "" {
 		return e.IconURL
@@ -68,7 +64,6 @@ func (e *StoreExtension) getIconURL() string {
 	return e.IconURLAlt
 }

-// getMinAppVersion returns min app version from either field (private to avoid gomobile conflict)
 func (e *StoreExtension) getMinAppVersion() string {
 	if e.MinAppVersion != "" {
 		return e.MinAppVersion
@@ -76,7 +71,6 @@ func (e *StoreExtension) getMinAppVersion() string {
 	return e.MinAppVersionAlt
 }

-// StoreRegistry represents the extension registry
 type StoreRegistry struct {
 	Version    int              `json:"version"`
 	UpdatedAt  string           `json:"updated_at"`
@@ -103,7 +97,6 @@ type StoreExtensionResponse struct {
 	HasUpdate        bool     `json:"has_update"`
 }

-// ToResponse converts StoreExtension to normalized response
 func (e *StoreExtension) ToResponse() StoreExtensionResponse {
 	return StoreExtensionResponse{
 		ID:            e.ID,
@@ -122,7 +115,6 @@ func (e *StoreExtension) ToResponse() StoreExtensionResponse {
 	}
 }

-// ExtensionStore manages the extension store
 type ExtensionStore struct {
 	registryURL string
 	cacheDir    string
@@ -143,7 +135,6 @@ const (
 	cacheFileName      = "store_cache.json"
 )

-// InitExtensionStore initializes the extension store
 func InitExtensionStore(cacheDir string) *ExtensionStore {
 	extensionStoreMu.Lock()
 	defer extensionStoreMu.Unlock()
@@ -154,20 +145,17 @@ func InitExtensionStore(cacheDir string) *ExtensionStore {
 			cacheDir:    cacheDir,
 			cacheTTL:    cacheTTL,
 		}
-		// Try to load from disk cache
 		extensionStore.loadDiskCache()
 	}
 	return extensionStore
 }

-// GetExtensionStore returns the singleton store instance
 func GetExtensionStore() *ExtensionStore {
 	extensionStoreMu.Lock()
 	defer extensionStoreMu.Unlock()
 	return extensionStore
 }

-// loadDiskCache loads cached registry from disk
 func (s *ExtensionStore) loadDiskCache() {
 	if s.cacheDir == "" {
 		return
@@ -193,7 +181,6 @@ func (s *ExtensionStore) loadDiskCache() {
 	LogDebug("ExtensionStore", "Loaded %d extensions from disk cache", len(s.cache.Extensions))
 }

-// saveDiskCache saves registry to disk cache
 func (s *ExtensionStore) saveDiskCache() {
 	if s.cacheDir == "" || s.cache == nil {
 		return
@@ -216,23 +203,24 @@ func (s *ExtensionStore) saveDiskCache() {
 	os.WriteFile(cachePath, data, 0644)
 }

-// FetchRegistry fetches the extension registry from GitHub
 func (s *ExtensionStore) FetchRegistry(forceRefresh bool) (*StoreRegistry, error) {
 	s.cacheMu.Lock()
 	defer s.cacheMu.Unlock()

-	// Return cached if valid and not forcing refresh
 	if !forceRefresh && s.cache != nil && time.Since(s.cacheTime) < s.cacheTTL {
 		LogDebug("ExtensionStore", "Using cached registry (%d extensions)", len(s.cache.Extensions))
 		return s.cache, nil
 	}

+	if err := requireHTTPSURL(s.registryURL, "registry"); err != nil {
+		return nil, err
+	}
+
 	LogInfo("ExtensionStore", "Fetching registry from %s", s.registryURL)

 	client := &http.Client{Timeout: 30 * time.Second}
 	resp, err := client.Get(s.registryURL)
 	if err != nil {
-		// Return cached data if available on network error
 		if s.cache != nil {
 			LogWarn("ExtensionStore", "Network error, using cached registry: %v", err)
 			return s.cache, nil
@@ -267,7 +255,6 @@ func (s *ExtensionStore) FetchRegistry(forceRefresh bool) (*StoreRegistry, error
 	return &registry, nil
 }

-// GetExtensionsWithStatus returns extensions with installation status
 func (s *ExtensionStore) GetExtensionsWithStatus() ([]StoreExtensionResponse, error) {
 	registry, err := s.FetchRegistry(false)
 	if err != nil {
@@ -299,7 +286,6 @@ func (s *ExtensionStore) GetExtensionsWithStatus() ([]StoreExtensionResponse, er
 	return result, nil
 }

-// DownloadExtension downloads an extension package to the specified path
 func (s *ExtensionStore) DownloadExtension(extensionID string, destPath string) error {
 	registry, err := s.FetchRegistry(false)
 	if err != nil {
@@ -318,6 +304,10 @@ func (s *ExtensionStore) DownloadExtension(extensionID string, destPath string)
 		return fmt.Errorf("extension %s not found in store", extensionID)
 	}

+	if err := requireHTTPSURL(ext.getDownloadURL(), "extension download"); err != nil {
+		return err
+	}
+
 	LogInfo("ExtensionStore", "Downloading %s from %s", ext.getDisplayName(), ext.getDownloadURL())

 	client := &http.Client{Timeout: 5 * time.Minute}
@@ -347,7 +337,20 @@ func (s *ExtensionStore) DownloadExtension(extensionID string, destPath string)
 	return nil
 }

-// GetCategories returns all available categories
+func requireHTTPSURL(rawURL string, context string) error {
+	if rawURL == "" {
+		return fmt.Errorf("%s URL is empty", context)
+	}
+	parsed, err := url.Parse(rawURL)
+	if err != nil || parsed.Host == "" {
+		return fmt.Errorf("%s URL is invalid: %s", context, rawURL)
+	}
+	if parsed.Scheme != "https" {
+		return fmt.Errorf("%s URL must use https: %s", context, rawURL)
+	}
+	return nil
+}
+
 func (s *ExtensionStore) GetCategories() []string {
 	return []string{
 		CategoryMetadata,
@@ -358,7 +361,6 @@ func (s *ExtensionStore) GetCategories() []string {
 	}
 }

-// SearchExtensions searches extensions by query
 func (s *ExtensionStore) SearchExtensions(query string, category string) ([]StoreExtensionResponse, error) {
 	extensions, err := s.GetExtensionsWithStatus()
 	if err != nil {
@@ -404,7 +406,6 @@ func (s *ExtensionStore) SearchExtensions(query string, category string) ([]Stor
 	return result, nil
 }

-// ClearCache clears the in-memory and disk cache
 func (s *ExtensionStore) ClearCache() {
 	s.cacheMu.Lock()
 	defer s.cacheMu.Unlock()
@@ -112,7 +112,6 @@ func TestExtensionRuntime_NetworkSandbox(t *testing.T) {

 	runtime := NewExtensionRuntime(ext)

-	// Test allowed domains
 	if err := runtime.validateDomain("https://api.allowed.com/path"); err != nil {
 		t.Errorf("Expected api.allowed.com to be allowed, got error: %v", err)
 	}
@@ -121,7 +120,6 @@ func TestExtensionRuntime_NetworkSandbox(t *testing.T) {
 		t.Errorf("Expected sub.wildcard.com to be allowed (wildcard), got error: %v", err)
 	}

-	// Test blocked domains
 	if err := runtime.validateDomain("https://blocked.com/path"); err == nil {
 		t.Error("Expected blocked.com to be denied")
 	}
@@ -139,7 +137,7 @@ func TestExtensionRuntime_FileSandbox(t *testing.T) {
 		Manifest: &ExtensionManifest{
 			Name: "test-ext",
 			Permissions: ExtensionPermissions{
-				File: true, // Enable file permission for test
+				File: true,
 			},
 		},
 		DataDir: tempDir,
@@ -147,7 +145,6 @@ func TestExtensionRuntime_FileSandbox(t *testing.T) {

 	runtime := NewExtensionRuntime(ext)

-	// Test valid path within sandbox
 	validPath, err := runtime.validatePath("test.txt")
 	if err != nil {
 		t.Errorf("Expected relative path to be valid, got error: %v", err)
@@ -156,13 +153,11 @@ func TestExtensionRuntime_FileSandbox(t *testing.T) {
 		t.Error("Expected non-empty path")
 	}

-	// Test path traversal attack
 	_, err = runtime.validatePath("../../../etc/passwd")
 	if err == nil {
 		t.Error("Expected path traversal to be blocked")
 	}

-	// Test nested path within sandbox (should be allowed)
 	nestedPath, err := runtime.validatePath("subdir/file.txt")
 	if err != nil {
 		t.Errorf("Expected nested path to be valid, got error: %v", err)
@@ -171,26 +166,23 @@ func TestExtensionRuntime_FileSandbox(t *testing.T) {
 		t.Error("Expected non-empty nested path")
 	}

-	// Test absolute path should be blocked (security fix)
-	// Use platform-appropriate absolute path
 	var absPath string
 	if filepath.IsAbs("C:\\Windows\\System32") {
-		absPath = "C:\\Windows\\System32\\test.txt" // Windows
+		absPath = "C:\\Windows\\System32\\test.txt"
 	} else {
-		absPath = "/etc/passwd" // Unix
+		absPath = "/etc/passwd"
 	}
 	_, err = runtime.validatePath(absPath)
 	if err == nil {
 		t.Error("Expected absolute path to be blocked")
 	}

-	// Test that extension without file permission is blocked
 	extNoFile := &LoadedExtension{
 		ID: "test-ext-no-file",
 		Manifest: &ExtensionManifest{
 			Name: "test-ext-no-file",
 			Permissions: ExtensionPermissions{
-				File: false, // No file permission
+				File: false,
 			},
 		},
 		DataDir: tempDir,
@@ -215,7 +207,6 @@ func TestExtensionRuntime_UtilityFunctions(t *testing.T) {
 	vm := goja.New()
 	runtime.RegisterAPIs(vm)

-	// Test base64 encode/decode
 	result, err := vm.RunString(`utils.base64Encode("hello")`)
 	if err != nil {
 		t.Fatalf("base64Encode failed: %v", err)
@@ -232,7 +223,6 @@ func TestExtensionRuntime_UtilityFunctions(t *testing.T) {
 		t.Errorf("Expected 'hello', got '%s'", result.String())
 	}

-	// Test MD5
 	result, err = vm.RunString(`utils.md5("hello")`)
 	if err != nil {
 		t.Fatalf("md5 failed: %v", err)
@@ -241,7 +231,6 @@ func TestExtensionRuntime_UtilityFunctions(t *testing.T) {
 		t.Errorf("Expected '5d41402abc4b2a76b9719d911017c592', got '%s'", result.String())
 	}

-	// Test JSON parse/stringify
 	result, err = vm.RunString(`utils.stringifyJSON({name: "test", value: 123})`)
 	if err != nil {
 		t.Fatalf("stringifyJSON failed: %v", err)
@@ -267,7 +256,6 @@ func TestExtensionRuntime_SSRFProtection(t *testing.T) {

 	runtime := NewExtensionRuntime(ext)

-	// Test that private IPs are blocked (SSRF protection)
 	privateIPs := []string{
 		"http://localhost/admin",
 		"http://127.0.0.1/admin",
@@ -285,7 +273,6 @@ func TestExtensionRuntime_SSRFProtection(t *testing.T) {
 		}
 	}

-	// Test that allowed public domain still works
 	if err := runtime.validateDomain("https://api.example.com/path"); err != nil {
 		t.Errorf("Expected api.example.com to be allowed, got error: %v", err)
 	}
@@ -296,7 +283,6 @@ func TestIsPrivateIP(t *testing.T) {
 		host     string
 		expected bool
 	}{
-		// Private IPs should be blocked
 		{"localhost", true},
 		{"127.0.0.1", true},
 		{"127.0.0.2", true},
@@ -306,18 +292,17 @@ func TestIsPrivateIP(t *testing.T) {
 		{"172.31.255.255", true},
 		{"192.168.0.1", true},
 		{"192.168.255.255", true},
-		{"169.254.169.254", true}, // AWS metadata
+		{"169.254.169.254", true},
 		{"router.local", true},
 		{"mydevice.local", true},

-		// Public IPs should be allowed
 		{"8.8.8.8", false},
 		{"1.1.1.1", false},
 		{"api.example.com", false},
 		{"google.com", false},
-		{"172.15.0.1", false},  // Just outside 172.16-31 range
-		{"172.32.0.1", false},  // Just outside 172.16-31 range
-		{"192.167.0.1", false}, // Not 192.168.x.x
+		{"172.15.0.1", false},
+		{"172.32.0.1", false},
+		{"192.167.0.1", false},
 	}

 	for _, tt := range tests {
@@ -10,7 +10,6 @@ import (
 	"github.com/dop251/goja"
 )

-// JSExecutionError represents an error during JS execution
 type JSExecutionError struct {
 	Message   string
 	IsTimeout bool
@@ -20,8 +19,6 @@ func (e *JSExecutionError) Error() string {
 	return e.Message
 }

-// RunWithTimeout executes JavaScript code with a timeout
-// Returns the result value and any error (including timeout)
 func RunWithTimeout(vm *goja.Runtime, script string, timeout time.Duration) (goja.Value, error) {
 	if timeout <= 0 {
 		timeout = DefaultJSTimeout
@@ -30,22 +27,18 @@ func RunWithTimeout(vm *goja.Runtime, script string, timeout time.Duration) (goj
 	ctx, cancel := context.WithTimeout(context.Background(), timeout)
 	defer cancel()

-	// Channel to receive result
 	type result struct {
 		value goja.Value
 		err   error
 	}
 	resultCh := make(chan result, 1)

-	// Track if we've interrupted
 	var interrupted bool
 	var interruptMu sync.Mutex

-	// Run script in goroutine
 	go func() {
 		defer func() {
 			if r := recover(); r != nil {
-				// Check if this was our interrupt
 				interruptMu.Lock()
 				wasInterrupted := interrupted
 				interruptMu.Unlock()
@@ -65,22 +58,18 @@ func RunWithTimeout(vm *goja.Runtime, script string, timeout time.Duration) (goj
 		resultCh <- result{val, err}
 	}()

-	// Wait for result or timeout
 	select {
 	case res := <-resultCh:
 		return res.value, res.err
 	case <-ctx.Done():
-		// Timeout - interrupt the VM
 		interruptMu.Lock()
 		interrupted = true
 		interruptMu.Unlock()

 		vm.Interrupt("execution timeout")

-		// Wait a bit for the goroutine to finish
 		select {
 		case res := <-resultCh:
-			// If we got a result after interrupt, it might be the timeout error
 			if res.err != nil {
 				return nil, res.err
 			}
@@ -89,7 +78,6 @@ func RunWithTimeout(vm *goja.Runtime, script string, timeout time.Duration) (goj
 				IsTimeout: true,
 			}
 		case <-time.After(1 * time.Second):
-			// Force return timeout error
 			return nil, &JSExecutionError{
 				Message:   "execution timeout exceeded (force)",
 				IsTimeout: true,
@@ -109,7 +97,6 @@ func RunWithTimeoutAndRecover(vm *goja.Runtime, script string, timeout time.Dura
 	return result, err
 }

-// IsTimeoutError checks if an error is a timeout error
 func IsTimeoutError(err error) bool {
 	if jsErr, ok := err.(*JSExecutionError); ok {
 		return jsErr.IsTimeout
@@ -1,23 +1,29 @@
 module github.com/zarz/spotiflac_android/go_backend

-go 1.24.0
+go 1.25.0

-toolchain go1.24.5
+toolchain go1.25.7

 require (
 	github.com/dop251/goja v0.0.0-20260106131823-651366fbe6e3
-	github.com/go-flac/flacpicture v0.3.0
-	github.com/go-flac/flacvorbis v0.2.0
-	github.com/go-flac/go-flac v1.0.0
+	github.com/go-flac/flacpicture/v2 v2.0.2
+	github.com/go-flac/flacvorbis/v2 v2.0.2
+	github.com/go-flac/go-flac/v2 v2.0.4
+	github.com/refraction-networking/utls v1.8.2
+	golang.org/x/mobile v0.0.0-20260204172633-1dceadbbeea3
+	golang.org/x/net v0.49.0
 )

 require (
+	github.com/andybalholm/brotli v1.0.6 // indirect
 	github.com/dlclark/regexp2 v1.11.4 // indirect
 	github.com/go-sourcemap/sourcemap v2.1.3+incompatible // indirect
 	github.com/google/pprof v0.0.0-20230207041349-798e818bf904 // indirect
-	golang.org/x/mobile v0.0.0-20251209145715-2553ed8ce294 // indirect
-	golang.org/x/mod v0.31.0 // indirect
+	github.com/klauspost/compress v1.17.4 // indirect
+	golang.org/x/crypto v0.47.0 // indirect
+	golang.org/x/mod v0.32.0 // indirect
 	golang.org/x/sync v0.19.0 // indirect
-	golang.org/x/text v0.3.8 // indirect
-	golang.org/x/tools v0.40.0 // indirect
+	golang.org/x/sys v0.40.0 // indirect
+	golang.org/x/text v0.33.0 // indirect
+	golang.org/x/tools v0.41.0 // indirect
 )
@@ -1,28 +1,50 @@
 github.com/Masterminds/semver/v3 v3.2.1 h1:RN9w6+7QoMeJVGyfmbcgs28Br8cvmnucEXnY0rYXWg0=
 github.com/Masterminds/semver/v3 v3.2.1/go.mod h1:qvl/7zhW3nngYb5+80sSMF+FG2BjYrf8m9wsX0PNOMQ=
+github.com/andybalholm/brotli v1.0.6 h1:Yf9fFpf49Zrxb9NlQaluyE92/+X7UVHlhMNJN2sxfOI=
+github.com/andybalholm/brotli v1.0.6/go.mod h1:fO7iG3H7G2nSZ7m0zPUDn85XEX2GTukHGRSepvi9Eig=
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/dlclark/regexp2 v1.11.4 h1:rPYF9/LECdNymJufQKmri9gV604RvvABwgOA8un7yAo=
 github.com/dlclark/regexp2 v1.11.4/go.mod h1:DHkYz0B9wPfa6wondMfaivmHpzrQ3v9q8cnmRbL6yW8=
 github.com/dop251/goja v0.0.0-20260106131823-651366fbe6e3 h1:bVp3yUzvSAJzu9GqID+Z96P+eu5TKnIMJSV4QaZMauM=
 github.com/dop251/goja v0.0.0-20260106131823-651366fbe6e3/go.mod h1:MxLav0peU43GgvwVgNbLAj1s/bSGboKkhuULvq/7hx4=
-github.com/go-flac/flacpicture v0.3.0 h1:LkmTxzFLIynwfhHiZsX0s8xcr3/u33MzvV89u+zOT8I=
-github.com/go-flac/flacpicture v0.3.0/go.mod h1:DPbrzVYQ3fJcvSgLFp9HXIrEQEdfdk/+m0nQCzwodZI=
-github.com/go-flac/flacvorbis v0.2.0 h1:KH0xjpkNTXFER4cszH4zeJxYcrHbUobz/RticWGOESs=
-github.com/go-flac/flacvorbis v0.2.0/go.mod h1:uIysHOtuU7OLGoCRG92bvnkg7QEqHx19qKRV6K1pBrI=
-github.com/go-flac/go-flac v1.0.0 h1:6qI9XOVLcO50xpzm3nXvO31BgDgHhnr/p/rER/K/doY=
-github.com/go-flac/go-flac v1.0.0/go.mod h1:WnZhcpmq4u1UdZMNn9LYSoASpWOCMOoxXxcWEHSzkW8=
+github.com/go-flac/flacpicture/v2 v2.0.2 h1:HCaJIVZpxnpdWs6G3ECEVRelzqS5xOi1Ba1AGmtXbzE=
+github.com/go-flac/flacpicture/v2 v2.0.2/go.mod h1:DMZBPWPAmdLqNhqFSy5ZBs9wyBzOekXutGfP7/TFCuo=
+github.com/go-flac/flacvorbis/v2 v2.0.2 h1:xCL3OhxrxWkHrbWUBvGNe+6FQ03yLmBbz0v5z4V2PoQ=
+github.com/go-flac/flacvorbis/v2 v2.0.2/go.mod h1:SwTB5gs13VaM/N7rstwPoUsPibiMKklgwybYP9dYo2g=
+github.com/go-flac/go-flac/v2 v2.0.4 h1:atf/kFa8U9idtkA//NO22XGr+MzQLeXZecnmP9sYBf0=
+github.com/go-flac/go-flac/v2 v2.0.4/go.mod h1:sYOlTKxutMW0RDYF+KlD6Zn+VOCZlIFQG/r/usPveCs=
 github.com/go-sourcemap/sourcemap v2.1.3+incompatible h1:W1iEw64niKVGogNgBN3ePyLFfuisuzeidWPMPWmECqU=
 github.com/go-sourcemap/sourcemap v2.1.3+incompatible/go.mod h1:F8jJfvm2KbVjc5NqelyYJmf/v5J0dwNLS2mL4sNA1Jg=
+github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
+github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
 github.com/google/pprof v0.0.0-20230207041349-798e818bf904 h1:4/hN5RUoecvl+RmJRE2YxKWtnnQls6rQjjW5oV7qg2U=
 github.com/google/pprof v0.0.0-20230207041349-798e818bf904/go.mod h1:uglQLonpP8qtYCYyzA+8c/9qtqgA3qsXGYqCPKARAFg=
-golang.org/x/mobile v0.0.0-20251209145715-2553ed8ce294 h1:Cr6kbEvA6nqvdHynE4CtVKlqpZB9dS1Jva/6IsHA19g=
-golang.org/x/mobile v0.0.0-20251209145715-2553ed8ce294/go.mod h1:RdZ+3sb4CVgpCFnzv+I4haEpwqFfsfzlLHs3L7ok+e0=
-golang.org/x/mod v0.31.0 h1:HaW9xtz0+kOcWKwli0ZXy79Ix+UW/vOfmWI5QVd2tgI=
-golang.org/x/mod v0.31.0/go.mod h1:43JraMp9cGx1Rx3AqioxrbrhNsLl2l/iNAvuBkrezpg=
+github.com/klauspost/compress v1.17.4 h1:Ej5ixsIri7BrIjBkRZLTo6ghwrEtHFk7ijlczPW4fZ4=
+github.com/klauspost/compress v1.17.4/go.mod h1:/dCuZOvVtNoHsyb+cuJD3itjs3NbnF6KH9zAO4BDxPM=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/refraction-networking/utls v1.8.2 h1:j4Q1gJj0xngdeH+Ox/qND11aEfhpgoEvV+S9iJ2IdQo=
+github.com/refraction-networking/utls v1.8.2/go.mod h1:jkSOEkLqn+S/jtpEHPOsVv/4V4EVnelwbMQl4vCWXAM=
+github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
+github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+golang.org/x/crypto v0.47.0 h1:V6e3FRj+n4dbpw86FJ8Fv7XVOql7TEwpHapKoMJ/GO8=
+golang.org/x/crypto v0.47.0/go.mod h1:ff3Y9VzzKbwSSEzWqJsJVBnWmRwRSHt/6Op5n9bQc4A=
+golang.org/x/mobile v0.0.0-20260204172633-1dceadbbeea3 h1:NiJtT7g4ncNFVjVZMAYNBrPSNhIjFYPj8UKA8MEw2A4=
+golang.org/x/mobile v0.0.0-20260204172633-1dceadbbeea3/go.mod h1:wReH3Q1agKmmLapipWFnd4NSs8KPz3fK6mSEZjXLkrg=
+golang.org/x/mod v0.32.0 h1:9F4d3PHLljb6x//jOyokMv3eX+YDeepZSEo3mFJy93c=
+golang.org/x/mod v0.32.0/go.mod h1:SgipZ/3h2Ci89DlEtEXWUk/HteuRin+HHhN+WbNhguU=
+golang.org/x/net v0.49.0 h1:eeHFmOGUTtaaPSGNmjBKpbng9MulQsJURQUAfUwY++o=
+golang.org/x/net v0.49.0/go.mod h1:/ysNB2EvaqvesRkuLAyjI1ycPZlQHM3q01F02UY/MV8=
 golang.org/x/sync v0.19.0 h1:vV+1eWNmZ5geRlYjzm2adRgW2/mcpevXNg50YZtPCE4=
 golang.org/x/sync v0.19.0/go.mod h1:9KTHXmSnoGruLpwFjVSX0lNNA75CykiMECbovNTZqGI=
-golang.org/x/text v0.3.8 h1:nAL+RVCQ9uMn3vJZbV+MRnydTJFPf8qqY42YiA6MrqY=
-golang.org/x/text v0.3.8/go.mod h1:E6s5w1FMmriuDzIBO73fBruAKo1PCIq6d2Q6DHfQ8WQ=
-golang.org/x/tools v0.40.0 h1:yLkxfA+Qnul4cs9QA3KnlFu0lVmd8JJfoq+E41uSutA=
-golang.org/x/tools v0.40.0/go.mod h1:Ik/tzLRlbscWpqqMRjyWYDisX8bG13FrdXp3o4Sr9lc=
+golang.org/x/sys v0.40.0 h1:DBZZqJ2Rkml6QMQsZywtnjnnGvHza6BTfYFWY9kjEWQ=
+golang.org/x/sys v0.40.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
+golang.org/x/text v0.33.0 h1:B3njUFyqtHDUI5jMn1YIr5B0IE2U0qck04r6d4KPAxE=
+golang.org/x/text v0.33.0/go.mod h1:LuMebE6+rBincTi9+xWTY8TztLzKHc/9C1uBCG27+q8=
+golang.org/x/tools v0.41.0 h1:a9b8iMweWG+S0OBnlU36rzLp20z1Rp10w+IY2czHTQc=
+golang.org/x/tools v0.41.0/go.mod h1:XSY6eDqxVNiYgezAVqqCeihT4j1U2CCsqvH3WhQpnlg=
 gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY=
 gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
@@ -15,11 +15,7 @@ import (
 	"time"
 )

-// getRandomUserAgent generates a random Windows Chrome User-Agent string
-// Uses modern Chrome format with build and patch numbers
-// Windows 11 still reports as "Windows NT 10.0" for compatibility
 func getRandomUserAgent() string {
-	// Chrome version 120-145 (modern range)
 	chromeVersion := rand.Intn(26) + 120
 	chromeBuild := rand.Intn(1500) + 6000
 	chromePatch := rand.Intn(200) + 100
@@ -38,9 +34,9 @@ const (
 	SongLinkTimeout   = 30 * time.Second
 	DefaultMaxRetries = 3
 	DefaultRetryDelay = 1 * time.Second
+	Second            = time.Second
 )

-// Shared transport with connection pooling to prevent TCP exhaustion
 var sharedTransport = &http.Transport{
 	DialContext: (&net.Dialer{
 		Timeout:   30 * time.Second,
@@ -59,6 +55,27 @@ var sharedTransport = &http.Transport{
 	DisableCompression:    true,
 }

+// metadataTransport is a separate transport for metadata API calls (Deezer, Spotify, SongLink).
+// Isolated from download traffic so that download failures cannot poison
+// the connection pool used by metadata enrichment.
+var metadataTransport = &http.Transport{
+	DialContext: (&net.Dialer{
+		Timeout:   30 * time.Second,
+		KeepAlive: 30 * time.Second,
+	}).DialContext,
+	MaxIdleConns:          30,
+	MaxIdleConnsPerHost:   5,
+	MaxConnsPerHost:       10,
+	IdleConnTimeout:       90 * time.Second,
+	TLSHandshakeTimeout:   10 * time.Second,
+	ExpectContinueTimeout: 1 * time.Second,
+	DisableKeepAlives:     false,
+	ForceAttemptHTTP2:     true,
+	WriteBufferSize:       32 * 1024,
+	ReadBufferSize:        32 * 1024,
+	DisableCompression:    true,
+}
+
 var sharedClient = &http.Client{
 	Transport: sharedTransport,
 	Timeout:   DefaultTimeout,
@@ -76,6 +93,15 @@ func NewHTTPClientWithTimeout(timeout time.Duration) *http.Client {
 	}
 }

+// NewMetadataHTTPClient creates an HTTP client using the isolated metadata transport.
+// Use this for API calls that should not be affected by download traffic.
+func NewMetadataHTTPClient(timeout time.Duration) *http.Client {
+	return &http.Client{
+		Transport: metadataTransport,
+		Timeout:   timeout,
+	}
+}
+
 func GetSharedClient() *http.Client {
 	return sharedClient
 }
@@ -84,9 +110,9 @@ func GetDownloadClient() *http.Client {
 	return downloadClient
 }

-// CloseIdleConnections closes idle connections in the shared transport
 func CloseIdleConnections() {
 	sharedTransport.CloseIdleConnections()
+	metadataTransport.CloseIdleConnections()
 }

 // Also checks for ISP blocking on errors
@@ -116,16 +142,12 @@ func DefaultRetryConfig() RetryConfig {
 	}
 }

-// DoRequestWithRetry executes an HTTP request with retry logic and exponential backoff
-// Handles 429 (Too Many Requests) responses with Retry-After header
-// Also detects and logs ISP blocking
 func DoRequestWithRetry(client *http.Client, req *http.Request, config RetryConfig) (*http.Response, error) {
 	var lastErr error
 	delay := config.InitialDelay
 	requestURL := req.URL.String()

 	for attempt := 0; attempt <= config.MaxRetries; attempt++ {
-		// Clone request for retry (body needs to be re-readable)
 		reqCopy := req.Clone(req.Context())
 		reqCopy.Header.Set("User-Agent", getRandomUserAgent())

@@ -133,9 +155,7 @@ func DoRequestWithRetry(client *http.Client, req *http.Request, config RetryConf
 		if err != nil {
 			lastErr = err

-			// Check for ISP blocking on network errors
 			if CheckAndLogISPBlocking(err, requestURL, "HTTP") {
-				// Don't retry if ISP blocking is detected - it won't help
 				return nil, WrapErrorWithISPCheck(err, requestURL, "HTTP")
 			}

@@ -148,12 +168,10 @@ func DoRequestWithRetry(client *http.Client, req *http.Request, config RetryConf
 			continue
 		}

-		// Success
 		if resp.StatusCode >= 200 && resp.StatusCode < 300 {
 			return resp, nil
 		}

-		// Handle rate limiting (429)
 		if resp.StatusCode == 429 {
 			resp.Body.Close()
 			retryAfter := getRetryAfterDuration(resp)
@@ -193,7 +211,6 @@ func DoRequestWithRetry(client *http.Client, req *http.Request, config RetryConf
 			}
 		}

-		// Server errors (5xx) - retry
 		if resp.StatusCode >= 500 {
 			resp.Body.Close()
 			lastErr = fmt.Errorf("server error: HTTP %d", resp.StatusCode)
@@ -205,7 +222,6 @@ func DoRequestWithRetry(client *http.Client, req *http.Request, config RetryConf
 			continue
 		}

-		// Client errors (4xx except 429) - don't retry
 		return resp, nil
 	}

@@ -224,12 +240,10 @@ func getRetryAfterDuration(resp *http.Response) time.Duration {
 		return 60 * time.Second // Default wait time
 	}

-	// Try parsing as seconds
 	if seconds, err := strconv.Atoi(retryAfter); err == nil {
 		return time.Duration(seconds) * time.Second
 	}

-	// Try parsing as HTTP date
 	if t, err := http.ParseTime(retryAfter); err == nil {
 		duration := time.Until(t)
 		if duration > 0 {
@@ -240,8 +254,6 @@ func getRetryAfterDuration(resp *http.Response) time.Duration {
 	return 60 * time.Second // Default
 }

-// ReadResponseBody reads and returns the response body
-// Returns error if body is empty
 func ReadResponseBody(resp *http.Response) ([]byte, error) {
 	if resp == nil {
 		return nil, fmt.Errorf("response is nil")
@@ -271,14 +283,12 @@ func ValidateResponse(resp *http.Response) error {
 	return nil
 }

-// BuildErrorMessage creates a detailed error message for API failures
 func BuildErrorMessage(apiURL string, statusCode int, responsePreview string) string {
 	msg := fmt.Sprintf("API %s failed", apiURL)
 	if statusCode > 0 {
 		msg += fmt.Sprintf(" (HTTP %d)", statusCode)
 	}
 	if responsePreview != "" {
-		// Truncate preview if too long
 		if len(responsePreview) > 100 {
 			responsePreview = responsePreview[:100] + "..."
 		}
@@ -297,18 +307,14 @@ func (e *ISPBlockingError) Error() string {
 	return fmt.Sprintf("ISP blocking detected for %s: %s", e.Domain, e.Reason)
 }

-// IsISPBlocking checks if an error is likely caused by ISP blocking
-// Returns the ISPBlockingError if detected, nil otherwise
 func IsISPBlocking(err error, requestURL string) *ISPBlockingError {
 	if err == nil {
 		return nil
 	}

-	// Extract domain from URL
 	domain := extractDomain(requestURL)
 	errStr := strings.ToLower(err.Error())

-	// Check for DNS resolution failure (common ISP blocking method)
 	var dnsErr *net.DNSError
 	if errors.As(err, &dnsErr) {
 		if dnsErr.IsNotFound || dnsErr.IsTemporary {
@@ -320,11 +326,9 @@ func IsISPBlocking(err error, requestURL string) *ISPBlockingError {
 		}
 	}

-	// Check for connection refused (ISP firewall blocking)
 	var opErr *net.OpError
 	if errors.As(err, &opErr) {
 		if opErr.Op == "dial" {
-			// Check for specific syscall errors
 			var syscallErr syscall.Errno
 			if errors.As(opErr.Err, &syscallErr) {
 				switch syscallErr {
@@ -363,7 +367,6 @@ func IsISPBlocking(err error, requestURL string) *ISPBlockingError {
 		}
 	}

-	// Check for TLS handshake failure (ISP MITM or blocking HTTPS)
 	var tlsErr *tls.RecordHeaderError
 	if errors.As(err, &tlsErr) {
 		return &ISPBlockingError{
@@ -424,7 +427,6 @@ func extractDomain(rawURL string) string {

 	parsed, err := url.Parse(rawURL)
 	if err != nil {
-		// Try to extract domain manually
 		rawURL = strings.TrimPrefix(rawURL, "https://")
 		rawURL = strings.TrimPrefix(rawURL, "http://")
 		if idx := strings.Index(rawURL, "/"); idx > 0 {
@@ -0,0 +1,27 @@
+//go:build ios
+
+package gobackend
+
+import (
+	"net/http"
+)
+
+// iOS version: uTLS is not supported on iOS due to cgo DNS resolver issues
+// Fall back to standard HTTP client
+
+// GetCloudflareBypassClient returns the standard HTTP client on iOS
+// uTLS is not available on iOS due to cgo DNS resolver compatibility issues
+func GetCloudflareBypassClient() *http.Client {
+	return sharedClient
+}
+
+// DoRequestWithCloudflareBypass on iOS just uses the standard client
+// uTLS Chrome fingerprint bypass is not available on iOS
+func DoRequestWithCloudflareBypass(req *http.Request) (*http.Response, error) {
+	req.Header.Set("User-Agent", getRandomUserAgent())
+	resp, err := sharedClient.Do(req)
+	if err != nil {
+		CheckAndLogISPBlocking(err, req.URL.String(), "HTTP")
+	}
+	return resp, err
+}
@@ -0,0 +1,181 @@
+//go:build !ios
+
+package gobackend
+
+import (
+	"context"
+	"crypto/tls"
+	"io"
+	"net"
+	"net/http"
+	"net/url"
+	"strings"
+	"sync"
+
+	utls "github.com/refraction-networking/utls"
+	"golang.org/x/net/http2"
+)
+
+// uTLS transport that mimics Chrome's TLS fingerprint to bypass Cloudflare
+// Uses HTTP/2 for optimal performance as uTLS works best with HTTP/2
+type utlsTransport struct {
+	dialer       *net.Dialer
+	mu           sync.Mutex
+	h2Transports map[string]*http2.Transport
+}
+
+func newUTLSTransport() *utlsTransport {
+	return &utlsTransport{
+		dialer: &net.Dialer{
+			Timeout:   30 * Second,
+			KeepAlive: 30 * Second,
+		},
+		h2Transports: make(map[string]*http2.Transport),
+	}
+}
+
+func (t *utlsTransport) RoundTrip(req *http.Request) (*http.Response, error) {
+	if req.URL.Scheme != "https" {
+		return sharedTransport.RoundTrip(req)
+	}
+
+	host := req.URL.Hostname()
+	port := t.getPort(req.URL)
+	addr := net.JoinHostPort(host, port)
+
+	conn, err := t.dialer.DialContext(req.Context(), "tcp", addr)
+	if err != nil {
+		return nil, err
+	}
+
+	tlsConn := utls.UClient(conn, &utls.Config{
+		ServerName: host,
+		NextProtos: []string{"h2", "http/1.1"},
+	}, utls.HelloChrome_Auto)
+
+	if err := tlsConn.Handshake(); err != nil {
+		conn.Close()
+		return nil, err
+	}
+
+	negotiatedProto := tlsConn.ConnectionState().NegotiatedProtocol
+
+	if negotiatedProto == "h2" {
+		h2Transport := &http2.Transport{
+			DialTLSContext: func(ctx context.Context, network, addr string, cfg *tls.Config) (net.Conn, error) {
+				return tlsConn, nil
+			},
+			AllowHTTP:          false,
+			DisableCompression: false,
+		}
+		return h2Transport.RoundTrip(req)
+	}
+
+	transport := &http.Transport{
+		DialTLSContext: func(ctx context.Context, network, addr string) (net.Conn, error) {
+			return tlsConn, nil
+		},
+		DisableKeepAlives: true,
+	}
+
+	return transport.RoundTrip(req)
+}
+
+func (t *utlsTransport) getPort(u *url.URL) string {
+	if u.Port() != "" {
+		return u.Port()
+	}
+	if u.Scheme == "https" {
+		return "443"
+	}
+	return "80"
+}
+
+// Cloudflare bypass client using uTLS Chrome fingerprint
+var cloudflareBypassTransport = newUTLSTransport()
+
+var cloudflareBypassClient = &http.Client{
+	Transport: cloudflareBypassTransport,
+	Timeout:   DefaultTimeout,
+}
+
+// GetCloudflareBypassClient returns an HTTP client that mimics Chrome's TLS fingerprint
+// Use this when requests are blocked by Cloudflare (common when using VPN)
+func GetCloudflareBypassClient() *http.Client {
+	return cloudflareBypassClient
+}
+
+// DoRequestWithCloudflareBypass attempts request with standard client first,
+// then retries with uTLS Chrome fingerprint if Cloudflare blocks it.
+// This is useful when using VPN as Cloudflare detects Go's default TLS fingerprint.
+func DoRequestWithCloudflareBypass(req *http.Request) (*http.Response, error) {
+	req.Header.Set("User-Agent", getRandomUserAgent())
+
+	// Try with standard client first
+	resp, err := sharedClient.Do(req)
+	if err == nil {
+		// Check for Cloudflare challenge page (403 with specific markers)
+		if resp.StatusCode == 403 || resp.StatusCode == 503 {
+			body, readErr := io.ReadAll(resp.Body)
+			resp.Body.Close()
+
+			if readErr == nil {
+				bodyStr := strings.ToLower(string(body))
+				cloudflareMarkers := []string{
+					"cloudflare", "cf-ray", "checking your browser",
+					"please wait", "ddos protection", "ray id",
+					"enable javascript", "challenge-platform",
+				}
+
+				isCloudflare := false
+				for _, marker := range cloudflareMarkers {
+					if strings.Contains(bodyStr, marker) {
+						isCloudflare = true
+						break
+					}
+				}
+
+				if isCloudflare {
+					LogDebug("HTTP", "Cloudflare detected, retrying with Chrome TLS fingerprint...")
+
+					// Clone request for retry
+					reqCopy := req.Clone(req.Context())
+					reqCopy.Header.Set("User-Agent", getRandomUserAgent())
+
+					// Retry with uTLS Chrome fingerprint
+					return cloudflareBypassClient.Do(reqCopy)
+				}
+			}
+
+			// Not Cloudflare, return original response (recreate body)
+			return &http.Response{
+				Status:     resp.Status,
+				StatusCode: resp.StatusCode,
+				Header:     resp.Header,
+				Body:       io.NopCloser(strings.NewReader(string(body))),
+			}, nil
+		}
+		return resp, nil
+	}
+
+	// Check if error might be TLS-related (Cloudflare blocking)
+	errStr := strings.ToLower(err.Error())
+	tlsRelated := strings.Contains(errStr, "tls") ||
+		strings.Contains(errStr, "handshake") ||
+		strings.Contains(errStr, "certificate") ||
+		strings.Contains(errStr, "connection reset")
+
+	if tlsRelated {
+		LogDebug("HTTP", "TLS error detected, retrying with Chrome TLS fingerprint: %v", err)
+
+		// Clone request for retry
+		reqCopy := req.Clone(req.Context())
+		reqCopy.Header.Set("User-Agent", getRandomUserAgent())
+
+		// Retry with uTLS Chrome fingerprint
+		return cloudflareBypassClient.Do(reqCopy)
+	}
+
+	CheckAndLogISPBlocking(err, req.URL.String(), "HTTP")
+	return nil, err
+}
@@ -0,0 +1,189 @@
+package gobackend
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"strings"
+	"sync"
+	"time"
+)
+
+// IDHSClient is a client for I Don't Have Spotify API
+// Used as fallback when SongLink fails or is rate limited
+type IDHSClient struct {
+	client *http.Client
+}
+
+var (
+	globalIDHSClient *IDHSClient
+	idhsClientOnce   sync.Once
+	idhsRateLimiter  = NewRateLimiter(8, time.Minute) // 8 req/min (below 10 limit)
+)
+
+// IDHSSearchRequest represents the request body for IDHS API
+type IDHSSearchRequest struct {
+	Link     string   `json:"link"`
+	Adapters []string `json:"adapters,omitempty"`
+}
+
+// IDHSSearchResponse represents the response from IDHS API
+type IDHSSearchResponse struct {
+	ID            string     `json:"id"`
+	Type          string     `json:"type"` // song, album, artist, podcast, show
+	Title         string     `json:"title"`
+	Description   string     `json:"description"`
+	Image         string     `json:"image,omitempty"`
+	Audio         string     `json:"audio,omitempty"`
+	Source        string     `json:"source"`
+	UniversalLink string     `json:"universalLink"`
+	Links         []IDHSLink `json:"links"`
+}
+
+// IDHSLink represents a link to a streaming platform
+type IDHSLink struct {
+	Type         string `json:"type"` // spotify, youTube, appleMusic, deezer, soundCloud, tidal
+	URL          string `json:"url"`
+	IsVerified   bool   `json:"isVerified,omitempty"`
+	NotAvailable bool   `json:"notAvailable,omitempty"`
+}
+
+// NewIDHSClient creates a new IDHS client
+func NewIDHSClient() *IDHSClient {
+	idhsClientOnce.Do(func() {
+		globalIDHSClient = &IDHSClient{
+			client: NewHTTPClientWithTimeout(15 * time.Second),
+		}
+	})
+	return globalIDHSClient
+}
+
+// Search converts a music link to links on other platforms
+func (c *IDHSClient) Search(link string, adapters []string) (*IDHSSearchResponse, error) {
+	idhsRateLimiter.WaitForSlot()
+
+	reqBody := IDHSSearchRequest{
+		Link:     link,
+		Adapters: adapters,
+	}
+
+	jsonBody, err := json.Marshal(reqBody)
+	if err != nil {
+		return nil, fmt.Errorf("failed to marshal request: %w", err)
+	}
+
+	req, err := http.NewRequest("POST", "https://idonthavespotify.sjdonado.com/api/search?v=1", bytes.NewBuffer(jsonBody))
+	if err != nil {
+		return nil, fmt.Errorf("failed to create request: %w", err)
+	}
+
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("User-Agent", getRandomUserAgent())
+
+	resp, err := c.client.Do(req)
+	if err != nil {
+		return nil, fmt.Errorf("request failed: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode == 400 {
+		return nil, fmt.Errorf("invalid link or missing parameters")
+	}
+	if resp.StatusCode == 429 {
+		return nil, fmt.Errorf("IDHS rate limit exceeded")
+	}
+	if resp.StatusCode == 500 {
+		return nil, fmt.Errorf("IDHS processing failed")
+	}
+	if resp.StatusCode != 200 {
+		return nil, fmt.Errorf("IDHS API returned status %d", resp.StatusCode)
+	}
+
+	body, err := ReadResponseBody(resp)
+	if err != nil {
+		return nil, fmt.Errorf("failed to read response: %w", err)
+	}
+
+	var result IDHSSearchResponse
+	if err := json.Unmarshal(body, &result); err != nil {
+		return nil, fmt.Errorf("failed to decode response: %w", err)
+	}
+
+	return &result, nil
+}
+
+// GetAvailabilityFromSpotify checks track availability using IDHS as fallback
+func (c *IDHSClient) GetAvailabilityFromSpotify(spotifyTrackID string) (*TrackAvailability, error) {
+	spotifyURL := fmt.Sprintf("https://open.spotify.com/track/%s", spotifyTrackID)
+
+	// Request only the platforms we need
+	adapters := []string{"tidal", "deezer"}
+
+	result, err := c.Search(spotifyURL, adapters)
+	if err != nil {
+		return nil, err
+	}
+
+	availability := &TrackAvailability{
+		SpotifyID: spotifyTrackID,
+	}
+
+	for _, link := range result.Links {
+		if link.NotAvailable {
+			continue
+		}
+
+		switch strings.ToLower(link.Type) {
+		case "tidal":
+			availability.Tidal = true
+			availability.TidalURL = link.URL
+		case "deezer":
+			availability.Deezer = true
+			availability.DeezerURL = link.URL
+			availability.DeezerID = extractDeezerIDFromURL(link.URL)
+		}
+	}
+
+	LogDebug("IDHS", "Availability from Spotify %s: Tidal=%v, Deezer=%v",
+		spotifyTrackID, availability.Tidal, availability.Deezer)
+
+	return availability, nil
+}
+
+// GetAvailabilityFromDeezer checks track availability using IDHS
+func (c *IDHSClient) GetAvailabilityFromDeezer(deezerTrackID string) (*TrackAvailability, error) {
+	deezerURL := fmt.Sprintf("https://www.deezer.com/track/%s", deezerTrackID)
+
+	// Request only the platforms we need
+	adapters := []string{"spotify", "tidal"}
+
+	result, err := c.Search(deezerURL, adapters)
+	if err != nil {
+		return nil, err
+	}
+
+	availability := &TrackAvailability{
+		Deezer:   true,
+		DeezerID: deezerTrackID,
+	}
+
+	for _, link := range result.Links {
+		if link.NotAvailable {
+			continue
+		}
+
+		switch strings.ToLower(link.Type) {
+		case "spotify":
+			availability.SpotifyID = extractSpotifyIDFromURL(link.URL)
+		case "tidal":
+			availability.Tidal = true
+			availability.TidalURL = link.URL
+		}
+	}
+
+	LogDebug("IDHS", "Availability from Deezer %s: Spotify=%s, Tidal=%v",
+		deezerTrackID, availability.SpotifyID, availability.Tidal)
+
+	return availability, nil
+}
@@ -0,0 +1,609 @@
+package gobackend
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+	"sync"
+	"time"
+)
+
+// LibraryScanResult represents metadata from a scanned audio file
+type LibraryScanResult struct {
+	ID          string `json:"id"`
+	TrackName   string `json:"trackName"`
+	ArtistName  string `json:"artistName"`
+	AlbumName   string `json:"albumName"`
+	AlbumArtist string `json:"albumArtist,omitempty"`
+	FilePath    string `json:"filePath"`
+	CoverPath   string `json:"coverPath,omitempty"`
+	ScannedAt   string `json:"scannedAt"`
+	FileModTime int64  `json:"fileModTime,omitempty"` // Unix timestamp in milliseconds
+	ISRC        string `json:"isrc,omitempty"`
+	TrackNumber int    `json:"trackNumber,omitempty"`
+	DiscNumber  int    `json:"discNumber,omitempty"`
+	Duration    int    `json:"duration,omitempty"`
+	ReleaseDate string `json:"releaseDate,omitempty"`
+	BitDepth    int    `json:"bitDepth,omitempty"`
+	SampleRate  int    `json:"sampleRate,omitempty"`
+	Genre       string `json:"genre,omitempty"`
+	Format      string `json:"format,omitempty"`
+}
+
+type LibraryScanProgress struct {
+	TotalFiles   int     `json:"total_files"`
+	ScannedFiles int     `json:"scanned_files"`
+	CurrentFile  string  `json:"current_file"`
+	ErrorCount   int     `json:"error_count"`
+	ProgressPct  float64 `json:"progress_pct"`
+	IsComplete   bool    `json:"is_complete"`
+}
+
+// IncrementalScanResult contains results of an incremental library scan
+type IncrementalScanResult struct {
+	Scanned      []LibraryScanResult `json:"scanned"`      // New or updated files
+	DeletedPaths []string            `json:"deletedPaths"` // Files that no longer exist
+	SkippedCount int                 `json:"skippedCount"` // Files that were unchanged
+	TotalFiles   int                 `json:"totalFiles"`   // Total files in folder
+}
+
+var (
+	libraryScanProgress   LibraryScanProgress
+	libraryScanProgressMu sync.RWMutex
+	libraryScanCancel     chan struct{}
+	libraryScanCancelMu   sync.Mutex
+	libraryCoverCacheDir  string
+	libraryCoverCacheMu   sync.RWMutex
+)
+
+var supportedAudioFormats = map[string]bool{
+	".flac": true,
+	".m4a":  true,
+	".mp3":  true,
+	".opus": true,
+	".ogg":  true,
+}
+
+func SetLibraryCoverCacheDir(cacheDir string) {
+	libraryCoverCacheMu.Lock()
+	libraryCoverCacheDir = cacheDir
+	libraryCoverCacheMu.Unlock()
+}
+
+func ScanLibraryFolder(folderPath string) (string, error) {
+	if folderPath == "" {
+		return "[]", fmt.Errorf("folder path is empty")
+	}
+
+	info, err := os.Stat(folderPath)
+	if err != nil {
+		return "[]", fmt.Errorf("folder not found: %w", err)
+	}
+	if !info.IsDir() {
+		return "[]", fmt.Errorf("path is not a folder: %s", folderPath)
+	}
+
+	libraryScanProgressMu.Lock()
+	libraryScanProgress = LibraryScanProgress{}
+	libraryScanProgressMu.Unlock()
+
+	libraryScanCancelMu.Lock()
+	if libraryScanCancel != nil {
+		close(libraryScanCancel)
+	}
+	libraryScanCancel = make(chan struct{})
+	cancelCh := libraryScanCancel
+	libraryScanCancelMu.Unlock()
+
+	var audioFiles []string
+	err = filepath.Walk(folderPath, func(path string, info os.FileInfo, err error) error {
+		if err != nil {
+			return nil
+		}
+
+		select {
+		case <-cancelCh:
+			return fmt.Errorf("scan cancelled")
+		default:
+		}
+
+		if !info.IsDir() {
+			ext := strings.ToLower(filepath.Ext(path))
+			if supportedAudioFormats[ext] {
+				audioFiles = append(audioFiles, path)
+			}
+		}
+		return nil
+	})
+
+	if err != nil {
+		return "[]", err
+	}
+
+	totalFiles := len(audioFiles)
+	libraryScanProgressMu.Lock()
+	libraryScanProgress.TotalFiles = totalFiles
+	libraryScanProgressMu.Unlock()
+
+	if totalFiles == 0 {
+		libraryScanProgressMu.Lock()
+		libraryScanProgress.IsComplete = true
+		libraryScanProgressMu.Unlock()
+		return "[]", nil
+	}
+
+	GoLog("[LibraryScan] Found %d audio files to scan\n", totalFiles)
+
+	results := make([]LibraryScanResult, 0, totalFiles)
+	scanTime := time.Now().UTC().Format(time.RFC3339)
+	errorCount := 0
+
+	for i, filePath := range audioFiles {
+		select {
+		case <-cancelCh:
+			return "[]", fmt.Errorf("scan cancelled")
+		default:
+		}
+
+		libraryScanProgressMu.Lock()
+		libraryScanProgress.ScannedFiles = i + 1
+		libraryScanProgress.CurrentFile = filepath.Base(filePath)
+		libraryScanProgress.ProgressPct = float64(i+1) / float64(totalFiles) * 100
+		libraryScanProgressMu.Unlock()
+
+		result, err := scanAudioFile(filePath, scanTime)
+		if err != nil {
+			errorCount++
+			GoLog("[LibraryScan] Error scanning %s: %v\n", filePath, err)
+			continue
+		}
+
+		results = append(results, *result)
+	}
+
+	libraryScanProgressMu.Lock()
+	libraryScanProgress.ErrorCount = errorCount
+	libraryScanProgress.IsComplete = true
+	libraryScanProgressMu.Unlock()
+
+	GoLog("[LibraryScan] Scan complete: %d tracks found, %d errors\n", len(results), errorCount)
+
+	jsonBytes, err := json.Marshal(results)
+	if err != nil {
+		return "[]", fmt.Errorf("failed to marshal results: %w", err)
+	}
+
+	return string(jsonBytes), nil
+}
+
+func scanAudioFile(filePath, scanTime string) (*LibraryScanResult, error) {
+	ext := strings.ToLower(filepath.Ext(filePath))
+
+	result := &LibraryScanResult{
+		ID:        generateLibraryID(filePath),
+		FilePath:  filePath,
+		ScannedAt: scanTime,
+		Format:    strings.TrimPrefix(ext, "."),
+	}
+
+	// Get file modification time
+	if info, err := os.Stat(filePath); err == nil {
+		result.FileModTime = info.ModTime().UnixMilli()
+	}
+
+	libraryCoverCacheMu.RLock()
+	coverCacheDir := libraryCoverCacheDir
+	libraryCoverCacheMu.RUnlock()
+	if coverCacheDir != "" && ext != ".m4a" {
+		coverPath, err := SaveCoverToCache(filePath, coverCacheDir)
+		if err == nil && coverPath != "" {
+			result.CoverPath = coverPath
+		}
+	}
+
+	switch ext {
+	case ".flac":
+		return scanFLACFile(filePath, result)
+	case ".m4a":
+		return scanM4AFile(filePath, result)
+	case ".mp3":
+		return scanMP3File(filePath, result)
+	case ".opus", ".ogg":
+		return scanOggFile(filePath, result)
+	default:
+		return scanFromFilename(filePath, result)
+	}
+}
+
+func scanFLACFile(filePath string, result *LibraryScanResult) (*LibraryScanResult, error) {
+	metadata, err := ReadMetadata(filePath)
+	if err != nil {
+		return scanFromFilename(filePath, result)
+	}
+
+	result.TrackName = metadata.Title
+	result.ArtistName = metadata.Artist
+	result.AlbumName = metadata.Album
+	result.AlbumArtist = metadata.AlbumArtist
+	result.ISRC = metadata.ISRC
+	result.TrackNumber = metadata.TrackNumber
+	result.DiscNumber = metadata.DiscNumber
+	result.ReleaseDate = metadata.Date
+	result.Genre = metadata.Genre
+
+	quality, err := GetAudioQuality(filePath)
+	if err == nil {
+		result.BitDepth = quality.BitDepth
+		result.SampleRate = quality.SampleRate
+		if quality.SampleRate > 0 && quality.TotalSamples > 0 {
+			result.Duration = int(quality.TotalSamples / int64(quality.SampleRate))
+		}
+	}
+
+	if result.TrackName == "" {
+		result.TrackName = strings.TrimSuffix(filepath.Base(filePath), filepath.Ext(filePath))
+	}
+	if result.ArtistName == "" {
+		result.ArtistName = "Unknown Artist"
+	}
+	if result.AlbumName == "" {
+		result.AlbumName = "Unknown Album"
+	}
+
+	return result, nil
+}
+
+func scanM4AFile(filePath string, result *LibraryScanResult) (*LibraryScanResult, error) {
+	quality, err := GetM4AQuality(filePath)
+	if err == nil {
+		result.BitDepth = quality.BitDepth
+		result.SampleRate = quality.SampleRate
+	}
+
+	return scanFromFilename(filePath, result)
+}
+
+func scanMP3File(filePath string, result *LibraryScanResult) (*LibraryScanResult, error) {
+	metadata, err := ReadID3Tags(filePath)
+	if err != nil {
+		GoLog("[LibraryScan] ID3 read error for %s: %v\n", filePath, err)
+		return scanFromFilename(filePath, result)
+	}
+
+	result.TrackName = metadata.Title
+	result.ArtistName = metadata.Artist
+	result.AlbumName = metadata.Album
+	result.AlbumArtist = metadata.AlbumArtist
+	result.TrackNumber = metadata.TrackNumber
+	result.DiscNumber = metadata.DiscNumber
+	result.Genre = metadata.Genre
+	if metadata.Date != "" {
+		result.ReleaseDate = metadata.Date
+	} else {
+		result.ReleaseDate = metadata.Year
+	}
+	result.ISRC = metadata.ISRC
+
+	quality, err := GetMP3Quality(filePath)
+	if err == nil {
+		result.SampleRate = quality.SampleRate
+		result.BitDepth = quality.BitDepth
+		result.Duration = quality.Duration
+	}
+
+	if result.TrackName == "" {
+		result.TrackName = strings.TrimSuffix(filepath.Base(filePath), filepath.Ext(filePath))
+	}
+	if result.ArtistName == "" {
+		result.ArtistName = "Unknown Artist"
+	}
+	if result.AlbumName == "" {
+		result.AlbumName = "Unknown Album"
+	}
+
+	return result, nil
+}
+
+func scanOggFile(filePath string, result *LibraryScanResult) (*LibraryScanResult, error) {
+	metadata, err := ReadOggVorbisComments(filePath)
+	if err != nil {
+		GoLog("[LibraryScan] Ogg/Opus read error for %s: %v\n", filePath, err)
+		return scanFromFilename(filePath, result)
+	}
+
+	result.TrackName = metadata.Title
+	result.ArtistName = metadata.Artist
+	result.AlbumName = metadata.Album
+	result.AlbumArtist = metadata.AlbumArtist
+	result.ISRC = metadata.ISRC
+	result.TrackNumber = metadata.TrackNumber
+	result.DiscNumber = metadata.DiscNumber
+	result.Genre = metadata.Genre
+	result.ReleaseDate = metadata.Date
+
+	quality, err := GetOggQuality(filePath)
+	if err == nil {
+		result.SampleRate = quality.SampleRate
+		result.BitDepth = quality.BitDepth
+		result.Duration = quality.Duration
+	}
+
+	if result.TrackName == "" {
+		result.TrackName = strings.TrimSuffix(filepath.Base(filePath), filepath.Ext(filePath))
+	}
+	if result.ArtistName == "" {
+		result.ArtistName = "Unknown Artist"
+	}
+	if result.AlbumName == "" {
+		result.AlbumName = "Unknown Album"
+	}
+
+	return result, nil
+}
+
+func scanFromFilename(filePath string, result *LibraryScanResult) (*LibraryScanResult, error) {
+	filename := strings.TrimSuffix(filepath.Base(filePath), filepath.Ext(filePath))
+
+	parts := strings.SplitN(filename, " - ", 2)
+	if len(parts) == 2 {
+		if len(parts[0]) <= 3 && isNumeric(parts[0]) {
+			result.TrackName = parts[1]
+			result.ArtistName = "Unknown Artist"
+		} else {
+			result.ArtistName = parts[0]
+			result.TrackName = parts[1]
+		}
+	} else {
+		if len(filename) > 3 && isNumeric(filename[:2]) {
+			title := strings.TrimLeft(filename[2:], " .-")
+			result.TrackName = title
+		} else {
+			result.TrackName = filename
+		}
+		result.ArtistName = "Unknown Artist"
+	}
+
+	dir := filepath.Dir(filePath)
+	result.AlbumName = filepath.Base(dir)
+	if result.AlbumName == "." || result.AlbumName == "" {
+		result.AlbumName = "Unknown Album"
+	}
+
+	return result, nil
+}
+
+func isNumeric(s string) bool {
+	for _, c := range s {
+		if c < '0' || c > '9' {
+			return false
+		}
+	}
+	return len(s) > 0
+}
+
+func generateLibraryID(filePath string) string {
+	return fmt.Sprintf("lib_%x", hashString(filePath))
+}
+
+func hashString(s string) uint32 {
+	var hash uint32 = 5381
+	for _, c := range s {
+		hash = ((hash << 5) + hash) + uint32(c)
+	}
+	return hash
+}
+
+func GetLibraryScanProgress() string {
+	libraryScanProgressMu.RLock()
+	defer libraryScanProgressMu.RUnlock()
+
+	jsonBytes, _ := json.Marshal(libraryScanProgress)
+	return string(jsonBytes)
+}
+
+func CancelLibraryScan() {
+	libraryScanCancelMu.Lock()
+	defer libraryScanCancelMu.Unlock()
+
+	if libraryScanCancel != nil {
+		close(libraryScanCancel)
+		libraryScanCancel = nil
+	}
+}
+
+func ReadAudioMetadata(filePath string) (string, error) {
+	scanTime := time.Now().UTC().Format(time.RFC3339)
+	result, err := scanAudioFile(filePath, scanTime)
+	if err != nil {
+		return "", err
+	}
+
+	jsonBytes, err := json.Marshal(result)
+	if err != nil {
+		return "", fmt.Errorf("failed to marshal result: %w", err)
+	}
+
+	return string(jsonBytes), nil
+}
+
+// ScanLibraryFolderIncremental performs an incremental scan of the library folder
+// existingFilesJSON is a JSON object mapping filePath -> modTime (unix millis)
+// Only files that are new or have changed modification time will be scanned
+func ScanLibraryFolderIncremental(folderPath, existingFilesJSON string) (string, error) {
+	if folderPath == "" {
+		return "{}", fmt.Errorf("folder path is empty")
+	}
+
+	info, err := os.Stat(folderPath)
+	if err != nil {
+		return "{}", fmt.Errorf("folder not found: %w", err)
+	}
+	if !info.IsDir() {
+		return "{}", fmt.Errorf("path is not a folder: %s", folderPath)
+	}
+
+	// Parse existing files map
+	existingFiles := make(map[string]int64)
+	if existingFilesJSON != "" && existingFilesJSON != "{}" {
+		if err := json.Unmarshal([]byte(existingFilesJSON), &existingFiles); err != nil {
+			GoLog("[LibraryScan] Warning: failed to parse existing files JSON: %v\n", err)
+		}
+	}
+
+	GoLog("[LibraryScan] Incremental scan starting, %d existing files in database\n", len(existingFiles))
+
+	// Reset progress
+	libraryScanProgressMu.Lock()
+	libraryScanProgress = LibraryScanProgress{}
+	libraryScanProgressMu.Unlock()
+
+	// Setup cancellation
+	libraryScanCancelMu.Lock()
+	if libraryScanCancel != nil {
+		close(libraryScanCancel)
+	}
+	libraryScanCancel = make(chan struct{})
+	cancelCh := libraryScanCancel
+	libraryScanCancelMu.Unlock()
+
+	// Collect all audio files with their mod times
+	type fileInfo struct {
+		path    string
+		modTime int64
+	}
+	var currentFiles []fileInfo
+	currentPathSet := make(map[string]bool)
+
+	err = filepath.Walk(folderPath, func(path string, info os.FileInfo, err error) error {
+		if err != nil {
+			return nil
+		}
+
+		select {
+		case <-cancelCh:
+			return fmt.Errorf("scan cancelled")
+		default:
+		}
+
+		if !info.IsDir() {
+			ext := strings.ToLower(filepath.Ext(path))
+			if supportedAudioFormats[ext] {
+				currentFiles = append(currentFiles, fileInfo{
+					path:    path,
+					modTime: info.ModTime().UnixMilli(),
+				})
+				currentPathSet[path] = true
+			}
+		}
+		return nil
+	})
+
+	if err != nil {
+		return "{}", err
+	}
+
+	totalFiles := len(currentFiles)
+	libraryScanProgressMu.Lock()
+	libraryScanProgress.TotalFiles = totalFiles
+	libraryScanProgressMu.Unlock()
+
+	// Find files to scan (new or modified)
+	var filesToScan []fileInfo
+	skippedCount := 0
+
+	for _, f := range currentFiles {
+		existingModTime, exists := existingFiles[f.path]
+		if !exists {
+			// New file
+			filesToScan = append(filesToScan, f)
+		} else if f.modTime != existingModTime {
+			// Modified file
+			filesToScan = append(filesToScan, f)
+		} else {
+			// Unchanged file - skip
+			skippedCount++
+		}
+	}
+
+	// Find deleted files
+	var deletedPaths []string
+	for existingPath := range existingFiles {
+		if !currentPathSet[existingPath] {
+			deletedPaths = append(deletedPaths, existingPath)
+		}
+	}
+
+	GoLog("[LibraryScan] Incremental: %d to scan, %d skipped, %d deleted\n",
+		len(filesToScan), skippedCount, len(deletedPaths))
+
+	if len(filesToScan) == 0 {
+		libraryScanProgressMu.Lock()
+		libraryScanProgress.ScannedFiles = totalFiles
+		libraryScanProgress.IsComplete = true
+		libraryScanProgress.ProgressPct = 100
+		libraryScanProgressMu.Unlock()
+
+		result := IncrementalScanResult{
+			Scanned:      []LibraryScanResult{},
+			DeletedPaths: deletedPaths,
+			SkippedCount: skippedCount,
+			TotalFiles:   totalFiles,
+		}
+		jsonBytes, _ := json.Marshal(result)
+		return string(jsonBytes), nil
+	}
+
+	// Scan the files that need scanning
+	results := make([]LibraryScanResult, 0, len(filesToScan))
+	scanTime := time.Now().UTC().Format(time.RFC3339)
+	errorCount := 0
+
+	for i, f := range filesToScan {
+		select {
+		case <-cancelCh:
+			return "{}", fmt.Errorf("scan cancelled")
+		default:
+		}
+
+		libraryScanProgressMu.Lock()
+		libraryScanProgress.ScannedFiles = skippedCount + i + 1
+		libraryScanProgress.CurrentFile = filepath.Base(f.path)
+		libraryScanProgress.ProgressPct = float64(skippedCount+i+1) / float64(totalFiles) * 100
+		libraryScanProgressMu.Unlock()
+
+		result, err := scanAudioFile(f.path, scanTime)
+		if err != nil {
+			errorCount++
+			GoLog("[LibraryScan] Error scanning %s: %v\n", f.path, err)
+			continue
+		}
+
+		results = append(results, *result)
+	}
+
+	libraryScanProgressMu.Lock()
+	libraryScanProgress.ErrorCount = errorCount
+	libraryScanProgress.IsComplete = true
+	libraryScanProgress.ScannedFiles = totalFiles
+	libraryScanProgress.ProgressPct = 100
+	libraryScanProgressMu.Unlock()
+
+	GoLog("[LibraryScan] Incremental scan complete: %d scanned, %d skipped, %d deleted, %d errors\n",
+		len(results), skippedCount, len(deletedPaths), errorCount)
+
+	scanResult := IncrementalScanResult{
+		Scanned:      results,
+		DeletedPaths: deletedPaths,
+		SkippedCount: skippedCount,
+		TotalFiles:   totalFiles,
+	}
+
+	jsonBytes, err := json.Marshal(scanResult)
+	if err != nil {
+		return "{}", fmt.Errorf("failed to marshal results: %w", err)
+	}
+
+	return string(jsonBytes), nil
+}
@@ -22,30 +22,41 @@ type LogBuffer struct {
 	loggingEnabled bool
 }

+const (
+	defaultLogBufferSize = 500
+	maxLogMessageLength  = 500
+)
+
 var (
 	globalLogBuffer *LogBuffer
 	logBufferOnce   sync.Once
 )

-// GetLogBuffer returns the singleton log buffer instance
 func GetLogBuffer() *LogBuffer {
 	logBufferOnce.Do(func() {
 		globalLogBuffer = &LogBuffer{
-			entries:        make([]LogEntry, 0, 1000),
-			maxSize:        1000,
+			entries:        make([]LogEntry, 0, defaultLogBufferSize),
+			maxSize:        defaultLogBufferSize,
 			loggingEnabled: false, // Default: disabled for performance (user can enable in settings)
 		}
 	})
 	return globalLogBuffer
 }

+func truncateLogMessage(message string) string {
+	runes := []rune(message)
+	if len(runes) <= maxLogMessageLength {
+		return message
+	}
+	return string(runes[:maxLogMessageLength]) + "...[truncated]"
+}
+
 func (lb *LogBuffer) SetLoggingEnabled(enabled bool) {
 	lb.mu.Lock()
 	defer lb.mu.Unlock()
 	lb.loggingEnabled = enabled
 }

-// IsLoggingEnabled returns whether logging is enabled
 func (lb *LogBuffer) IsLoggingEnabled() bool {
 	lb.mu.RLock()
 	defer lb.mu.RUnlock()
@@ -60,6 +71,8 @@ func (lb *LogBuffer) Add(level, tag, message string) {
 		return
 	}

+	message = truncateLogMessage(message)
+
 	entry := LogEntry{
 		Timestamp: time.Now().Format("15:04:05.000"),
 		Level:     level,
@@ -75,7 +88,6 @@ func (lb *LogBuffer) Add(level, tag, message string) {
 	fmt.Printf("[%s] %s\n", tag, message)
 }

-// GetAll returns all log entries as JSON
 func (lb *LogBuffer) GetAll() string {
 	lb.mu.RLock()
 	defer lb.mu.RUnlock()
@@ -99,21 +111,18 @@ func (lb *LogBuffer) getSince(index int) ([]LogEntry, int) {
 	return entries, len(lb.entries)
 }

-// Clear clears all log entries
 func (lb *LogBuffer) Clear() {
 	lb.mu.Lock()
 	defer lb.mu.Unlock()
 	lb.entries = lb.entries[:0]
 }

-// Count returns the number of log entries
 func (lb *LogBuffer) Count() int {
 	lb.mu.RLock()
 	defer lb.mu.RUnlock()
 	return len(lb.entries)
 }

-// Helper functions for logging with different levels
 func LogDebug(tag, format string, args ...interface{}) {
 	GetLogBuffer().Add("DEBUG", tag, fmt.Sprintf(format, args...))
 }
@@ -150,11 +159,11 @@ func GoLog(format string, args ...interface{}) {

 	// Determine level from message content
 	msgLower := strings.ToLower(message)
-	if strings.Contains(msgLower, "error") || strings.Contains(msgLower, "failed") || strings.HasPrefix(message, "✗") {
+	if strings.Contains(msgLower, "error") || strings.Contains(msgLower, "failed") {
 		level = "ERROR"
 	} else if strings.Contains(msgLower, "warning") || strings.Contains(msgLower, "warn") {
 		level = "WARN"
-	} else if strings.HasPrefix(message, "✓") || strings.Contains(msgLower, "success") || strings.Contains(msgLower, "match found") {
+	} else if strings.Contains(msgLower, "success") || strings.Contains(msgLower, "match found") {
 		level = "INFO"
 	} else if strings.Contains(msgLower, "searching") || strings.Contains(msgLower, "trying") || strings.Contains(msgLower, "found") {
 		level = "DEBUG"
@@ -163,15 +172,10 @@ func GoLog(format string, args ...interface{}) {
 	GetLogBuffer().Add(level, tag, message)
 }

-// Exported functions for Flutter
-
-// GetLogs returns all logs as JSON array
 func GetLogs() string {
 	return GetLogBuffer().GetAll()
 }

-// GetLogsSince returns logs since the given index
-// Returns JSON: {"logs": [...], "next_index": N}
 func GetLogsSince(index int) string {
 	entries, nextIndex := GetLogBuffer().getSince(index)
 	logsJson, _ := json.Marshal(entries)
@@ -179,17 +183,14 @@ func GetLogsSince(index int) string {
 	return result
 }

-// ClearLogs clears all logs
 func ClearLogs() {
 	GetLogBuffer().Clear()
 }

-// GetLogCount returns the number of log entries
 func GetLogCount() int {
 	return GetLogBuffer().Count()
 }

-// SetLoggingEnabled enables or disables logging from Flutter
 func SetLoggingEnabled(enabled bool) {
 	GetLogBuffer().SetLoggingEnabled(enabled)
 }
@@ -238,9 +238,9 @@ func (c *LyricsClient) durationMatches(lrcDuration, targetDuration float64) bool
 	return diff <= durationToleranceSec
 }

-// durationSec: track duration in seconds for matching, use 0 to skip duration matching
 func (c *LyricsClient) FetchLyricsAllSources(spotifyID, trackName, artistName string, durationSec float64) (*LyricsResponse, error) {
-	// Check cache first
+	primaryArtist := normalizeArtistName(artistName)
+
 	if cached, found := globalLyricsCache.Get(artistName, trackName, durationSec); found {
 		fmt.Printf("[Lyrics] Cache hit for: %s - %s\n", artistName, trackName)
 		cachedCopy := *cached
@@ -251,39 +251,48 @@ func (c *LyricsClient) FetchLyricsAllSources(spotifyID, trackName, artistName st
 	var lyrics *LyricsResponse
 	var err error

-	// Try exact match first
-	lyrics, err = c.FetchLyricsWithMetadata(artistName, trackName)
-	if err == nil && lyrics != nil && len(lyrics.Lines) > 0 {
+	isValidResult := func(l *LyricsResponse) bool {
+		return l != nil && (len(l.Lines) > 0 || l.Instrumental)
+	}
+
+	lyrics, err = c.FetchLyricsWithMetadata(primaryArtist, trackName)
+	if err == nil && isValidResult(lyrics) {
 		lyrics.Source = "LRCLIB"
 		globalLyricsCache.Set(artistName, trackName, durationSec, lyrics)
 		return lyrics, nil
 	}

-	// Try with simplified track name
+	if primaryArtist != artistName {
+		lyrics, err = c.FetchLyricsWithMetadata(artistName, trackName)
+		if err == nil && isValidResult(lyrics) {
+			lyrics.Source = "LRCLIB"
+			globalLyricsCache.Set(artistName, trackName, durationSec, lyrics)
+			return lyrics, nil
+		}
+	}
+
 	simplifiedTrack := simplifyTrackName(trackName)
 	if simplifiedTrack != trackName {
-		lyrics, err = c.FetchLyricsWithMetadata(artistName, simplifiedTrack)
-		if err == nil && lyrics != nil && len(lyrics.Lines) > 0 {
+		lyrics, err = c.FetchLyricsWithMetadata(primaryArtist, simplifiedTrack)
+		if err == nil && isValidResult(lyrics) {
 			lyrics.Source = "LRCLIB (simplified)"
 			globalLyricsCache.Set(artistName, trackName, durationSec, lyrics)
 			return lyrics, nil
 		}
 	}

-	// Search with duration matching
-	query := artistName + " " + trackName
+	query := primaryArtist + " " + trackName
 	lyrics, err = c.FetchLyricsFromLRCLibSearch(query, durationSec)
-	if err == nil && lyrics != nil && len(lyrics.Lines) > 0 {
+	if err == nil && isValidResult(lyrics) {
 		lyrics.Source = "LRCLIB Search"
 		globalLyricsCache.Set(artistName, trackName, durationSec, lyrics)
 		return lyrics, nil
 	}

-	// Search with simplified name and duration matching
 	if simplifiedTrack != trackName {
-		query = artistName + " " + simplifiedTrack
+		query = primaryArtist + " " + simplifiedTrack
 		lyrics, err = c.FetchLyricsFromLRCLibSearch(query, durationSec)
-		if err == nil && lyrics != nil && len(lyrics.Lines) > 0 {
+		if err == nil && isValidResult(lyrics) {
 			lyrics.Source = "LRCLIB Search (simplified)"
 			globalLyricsCache.Set(artistName, trackName, durationSec, lyrics)
 			return lyrics, nil
@@ -375,32 +384,6 @@ func msToLRCTimestamp(ms int64) string {
 	return fmt.Sprintf("[%02d:%02d.%02d]", minutes, seconds, centiseconds)
 }

-// Use convertToLRCWithMetadata for full LRC with headers
-// Kept for potential future use
-// func convertToLRC(lyrics *LyricsResponse) string {
-// 	if lyrics == nil || len(lyrics.Lines) == 0 {
-// 		return ""
-// 	}
-//
-// 	var builder strings.Builder
-//
-// 	if lyrics.SyncType == "LINE_SYNCED" {
-// 		for _, line := range lyrics.Lines {
-// 			timestamp := msToLRCTimestamp(line.StartTimeMs)
-// 			builder.WriteString(timestamp)
-// 			builder.WriteString(line.Words)
-// 			builder.WriteString("\n")
-// 		}
-// 	} else {
-// 		for _, line := range lyrics.Lines {
-// 			builder.WriteString(line.Words)
-// 			builder.WriteString("\n")
-// 		}
-// 	}
-//
-// 	return builder.String()
-// }
-
 func convertToLRCWithMetadata(lyrics *LyricsResponse, trackName, artistName string) string {
 	if lyrics == nil || len(lyrics.Lines) == 0 {
 		return ""
@@ -462,6 +445,20 @@ func simplifyTrackName(name string) string {
 	return strings.TrimSpace(result)
 }

+func normalizeArtistName(name string) string {
+	separators := []string{", ", "; ", " & ", " feat. ", " ft. ", " featuring ", " with "}
+
+	result := name
+	for _, sep := range separators {
+		if idx := strings.Index(strings.ToLower(result), strings.ToLower(sep)); idx > 0 {
+			result = result[:idx]
+			break
+		}
+	}
+
+	return strings.TrimSpace(result)
+}
+
 func SaveLRCFile(audioFilePath, lrcContent string) (string, error) {
 	if lrcContent == "" {
 		return "", fmt.Errorf("empty LRC content")
@@ -9,9 +9,9 @@ import (
 	"strconv"
 	"strings"

-	"github.com/go-flac/flacpicture"
-	"github.com/go-flac/flacvorbis"
-	"github.com/go-flac/go-flac"
+	"github.com/go-flac/flacpicture/v2"
+	"github.com/go-flac/flacvorbis/v2"
+	"github.com/go-flac/go-flac/v2"
 )

 type Metadata struct {
@@ -29,6 +29,8 @@ type Metadata struct {
 	Genre       string
 	Label       string
 	Copyright   string
+	Composer    string
+	Comment     string
 }

 func EmbedMetadata(filePath string, metadata Metadata, coverPath string) error {
@@ -98,6 +100,14 @@ func EmbedMetadata(filePath string, metadata Metadata, coverPath string) error {
 		setComment(cmt, "COPYRIGHT", metadata.Copyright)
 	}

+	if metadata.Composer != "" {
+		setComment(cmt, "COMPOSER", metadata.Composer)
+	}
+
+	if metadata.Comment != "" {
+		setComment(cmt, "COMMENT", metadata.Comment)
+	}
+
 	cmtBlock := cmt.Marshal()
 	if cmtIdx >= 0 {
 		f.Meta[cmtIdx] = &cmtBlock
@@ -206,6 +216,14 @@ func EmbedMetadataWithCoverData(filePath string, metadata Metadata, coverData []
 		setComment(cmt, "COPYRIGHT", metadata.Copyright)
 	}

+	if metadata.Composer != "" {
+		setComment(cmt, "COMPOSER", metadata.Composer)
+	}
+
+	if metadata.Comment != "" {
+		setComment(cmt, "COMMENT", metadata.Comment)
+	}
+
 	cmtBlock := cmt.Marshal()
 	if cmtIdx >= 0 {
 		f.Meta[cmtIdx] = &cmtBlock
@@ -238,7 +256,6 @@ func EmbedMetadataWithCoverData(filePath string, metadata Metadata, coverData []
 	return f.Save(filePath)
 }

-// ReadMetadata reads metadata from a FLAC file
 func ReadMetadata(filePath string) (*Metadata, error) {
 	f, err := flac.ParseFile(filePath)
 	if err != nil {
@@ -293,6 +310,12 @@ func ReadMetadata(filePath string) (*Metadata, error) {
 				metadata.Date = getComment(cmt, "YEAR")
 			}

+			metadata.Genre = getComment(cmt, "GENRE")
+			metadata.Label = getComment(cmt, "ORGANIZATION")
+			metadata.Copyright = getComment(cmt, "COPYRIGHT")
+			metadata.Composer = getComment(cmt, "COMPOSER")
+			metadata.Comment = getComment(cmt, "COMMENT")
+
 			break
 		}
 	}
@@ -336,6 +359,39 @@ func fileExists(path string) bool {
 	return err == nil
 }

+func ExtractCoverArt(filePath string) ([]byte, error) {
+	f, err := flac.ParseFile(filePath)
+	if err != nil {
+		return nil, fmt.Errorf("failed to parse FLAC file: %w", err)
+	}
+
+	for _, meta := range f.Meta {
+		if meta.Type == flac.Picture {
+			pic, err := flacpicture.ParseFromMetaDataBlock(*meta)
+			if err != nil {
+				continue
+			}
+			if pic.PictureType == flacpicture.PictureTypeFrontCover && len(pic.ImageData) > 0 {
+				return pic.ImageData, nil
+			}
+		}
+	}
+
+	for _, meta := range f.Meta {
+		if meta.Type == flac.Picture {
+			pic, err := flacpicture.ParseFromMetaDataBlock(*meta)
+			if err != nil {
+				continue
+			}
+			if len(pic.ImageData) > 0 {
+				return pic.ImageData, nil
+			}
+		}
+	}
+
+	return nil, fmt.Errorf("no cover art found in file")
+}
+
 func EmbedLyrics(filePath string, lyrics string) error {
 	f, err := flac.ParseFile(filePath)
 	if err != nil {
@@ -418,7 +474,6 @@ func EmbedGenreLabel(filePath string, genre, label string) error {
 	return f.Save(filePath)
 }

-// ExtractLyrics extracts embedded lyrics from a FLAC file
 func ExtractLyrics(filePath string) (string, error) {
 	f, err := flac.ParseFile(filePath)
 	if err != nil {
@@ -512,371 +567,6 @@ func GetAudioQuality(filePath string) (AudioQuality, error) {
 	return AudioQuality{}, fmt.Errorf("unsupported file format (not FLAC or M4A)")
 }

-// ========================================
-// M4A (MP4/AAC) Metadata Embedding
-// ========================================
-
-// EmbedM4AMetadata embeds metadata into an M4A file using iTunes-style atoms
-func EmbedM4AMetadata(filePath string, metadata Metadata, coverData []byte) error {
-	input, err := os.Open(filePath)
-	if err != nil {
-		return fmt.Errorf("failed to open M4A file: %w", err)
-	}
-	defer input.Close()
-
-	info, err := input.Stat()
-	if err != nil {
-		return fmt.Errorf("failed to stat M4A file: %w", err)
-	}
-	fileSize := info.Size()
-
-	moovHeader, moovFound, err := findAtomInRange(input, 0, fileSize, "moov", fileSize)
-	if err != nil {
-		return fmt.Errorf("failed to find moov atom: %w", err)
-	}
-	if !moovFound {
-		return fmt.Errorf("moov atom not found in M4A file")
-	}
-
-	moovContentStart := moovHeader.offset + moovHeader.headerSize
-	moovContentSize := moovHeader.size - moovHeader.headerSize
-
-	udtaHeader, udtaFound, err := findAtomInRange(input, moovContentStart, moovContentSize, "udta", fileSize)
-	if err != nil {
-		return fmt.Errorf("failed to locate udta atom: %w", err)
-	}
-
-	var metaHeader atomHeader
-	metaFound := false
-	if udtaFound {
-		udtaContentStart := udtaHeader.offset + udtaHeader.headerSize
-		udtaContentSize := udtaHeader.size - udtaHeader.headerSize
-		metaHeader, metaFound, err = findAtomInRange(input, udtaContentStart, udtaContentSize, "meta", fileSize)
-		if err != nil {
-			return fmt.Errorf("failed to locate meta atom: %w", err)
-		}
-	}
-
-	metaAtom := buildMetaAtom(metadata, coverData)
-	metaSize := int64(len(metaAtom))
-
-	var delta int64
-	var newUdtaSize int64
-	switch {
-	case udtaFound && metaFound:
-		delta = metaSize - metaHeader.size
-		newUdtaSize = udtaHeader.size + delta
-	case udtaFound && !metaFound:
-		delta = metaSize
-		newUdtaSize = udtaHeader.size + delta
-	case !udtaFound:
-		newUdtaSize = int64(8 + len(metaAtom))
-		delta = newUdtaSize
-	}
-
-	newMoovSize := moovHeader.size + delta
-	if moovHeader.headerSize == 8 && newMoovSize > int64(^uint32(0)) {
-		return fmt.Errorf("moov atom exceeds 32-bit size after update")
-	}
-	if udtaFound && udtaHeader.headerSize == 8 && newUdtaSize > int64(^uint32(0)) {
-		return fmt.Errorf("udta atom exceeds 32-bit size after update")
-	}
-	if !udtaFound && newUdtaSize > int64(^uint32(0)) {
-		return fmt.Errorf("udta atom exceeds 32-bit size after update")
-	}
-
-	tempPath := filePath + ".tmp"
-	output, err := os.OpenFile(tempPath, os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0644)
-	if err != nil {
-		return fmt.Errorf("failed to create temp file: %w", err)
-	}
-	cleanupTemp := true
-	defer func() {
-		_ = output.Close()
-		if cleanupTemp {
-			_ = os.Remove(tempPath)
-		}
-	}()
-
-	switch {
-	case udtaFound && metaFound:
-		if err := copyRange(output, input, 0, moovHeader.offset); err != nil {
-			return err
-		}
-		if err := writeAtomHeader(output, "moov", newMoovSize, moovHeader.headerSize); err != nil {
-			return err
-		}
-		if err := copyRange(output, input, moovHeader.offset+moovHeader.headerSize, udtaHeader.offset-(moovHeader.offset+moovHeader.headerSize)); err != nil {
-			return err
-		}
-		if err := writeAtomHeader(output, "udta", newUdtaSize, udtaHeader.headerSize); err != nil {
-			return err
-		}
-		if err := copyRange(output, input, udtaHeader.offset+udtaHeader.headerSize, metaHeader.offset-(udtaHeader.offset+udtaHeader.headerSize)); err != nil {
-			return err
-		}
-		if _, err := output.Write(metaAtom); err != nil {
-			return fmt.Errorf("failed to write meta atom: %w", err)
-		}
-		metaEnd := metaHeader.offset + metaHeader.size
-		if err := copyRange(output, input, metaEnd, fileSize-metaEnd); err != nil {
-			return err
-		}
-	case udtaFound && !metaFound:
-		if err := copyRange(output, input, 0, moovHeader.offset); err != nil {
-			return err
-		}
-		if err := writeAtomHeader(output, "moov", newMoovSize, moovHeader.headerSize); err != nil {
-			return err
-		}
-		if err := copyRange(output, input, moovHeader.offset+moovHeader.headerSize, udtaHeader.offset-(moovHeader.offset+moovHeader.headerSize)); err != nil {
-			return err
-		}
-		if err := writeAtomHeader(output, "udta", newUdtaSize, udtaHeader.headerSize); err != nil {
-			return err
-		}
-		insertPos := udtaHeader.offset + udtaHeader.size
-		if err := copyRange(output, input, udtaHeader.offset+udtaHeader.headerSize, insertPos-(udtaHeader.offset+udtaHeader.headerSize)); err != nil {
-			return err
-		}
-		if _, err := output.Write(metaAtom); err != nil {
-			return fmt.Errorf("failed to write meta atom: %w", err)
-		}
-		if err := copyRange(output, input, insertPos, fileSize-insertPos); err != nil {
-			return err
-		}
-	case !udtaFound:
-		newUdtaAtom := buildUdtaAtom(metaAtom)
-		if err := copyRange(output, input, 0, moovHeader.offset); err != nil {
-			return err
-		}
-		if err := writeAtomHeader(output, "moov", newMoovSize, moovHeader.headerSize); err != nil {
-			return err
-		}
-		moovEnd := moovHeader.offset + moovHeader.size
-		if err := copyRange(output, input, moovHeader.offset+moovHeader.headerSize, moovEnd-(moovHeader.offset+moovHeader.headerSize)); err != nil {
-			return err
-		}
-		if _, err := output.Write(newUdtaAtom); err != nil {
-			return fmt.Errorf("failed to write udta atom: %w", err)
-		}
-		if err := copyRange(output, input, moovEnd, fileSize-moovEnd); err != nil {
-			return err
-		}
-	}
-
-	if err := output.Close(); err != nil {
-		return fmt.Errorf("failed to close temp file: %w", err)
-	}
-
-	_ = input.Close()
-	if err := os.Remove(filePath); err != nil {
-		return fmt.Errorf("failed to replace original file: %w", err)
-	}
-	if err := os.Rename(tempPath, filePath); err != nil {
-		return fmt.Errorf("failed to move temp file: %w", err)
-	}
-	cleanupTemp = false
-
-	fmt.Printf("[M4A] Metadata embedded successfully\n")
-	return nil
-}
-
-func findAtom(data []byte, name string, offset int) int {
-	for i := offset; i < len(data)-8; {
-		size := int(uint32(data[i])<<24 | uint32(data[i+1])<<16 | uint32(data[i+2])<<8 | uint32(data[i+3]))
-		if size < 8 {
-			break
-		}
-		atomName := string(data[i+4 : i+8])
-		if atomName == name {
-			return i
-		}
-		i += size
-	}
-	return -1
-}
-
-// buildMetaAtom builds a complete meta atom with ilst containing metadata
-func buildMetaAtom(metadata Metadata, coverData []byte) []byte {
-	var ilst []byte
-
-	if metadata.Title != "" {
-		ilst = append(ilst, buildTextAtom("©nam", metadata.Title)...)
-	}
-
-	if metadata.Artist != "" {
-		ilst = append(ilst, buildTextAtom("©ART", metadata.Artist)...)
-	}
-
-	if metadata.Album != "" {
-		ilst = append(ilst, buildTextAtom("©alb", metadata.Album)...)
-	}
-
-	if metadata.AlbumArtist != "" {
-		ilst = append(ilst, buildTextAtom("aART", metadata.AlbumArtist)...)
-	}
-
-	if metadata.Date != "" {
-		ilst = append(ilst, buildTextAtom("©day", metadata.Date)...)
-	}
-
-	if metadata.TrackNumber > 0 {
-		ilst = append(ilst, buildTrackNumberAtom(metadata.TrackNumber, metadata.TotalTracks)...)
-	}
-
-	if metadata.DiscNumber > 0 {
-		ilst = append(ilst, buildDiscNumberAtom(metadata.DiscNumber, 0)...)
-	}
-
-	if metadata.Lyrics != "" {
-		ilst = append(ilst, buildTextAtom("©lyr", metadata.Lyrics)...)
-	}
-
-	if len(coverData) > 0 {
-		ilst = append(ilst, buildCoverAtom(coverData)...)
-	}
-
-	ilstSize := 8 + len(ilst)
-	ilstAtom := make([]byte, 4)
-	ilstAtom[0] = byte(ilstSize >> 24)
-	ilstAtom[1] = byte(ilstSize >> 16)
-	ilstAtom[2] = byte(ilstSize >> 8)
-	ilstAtom[3] = byte(ilstSize)
-	ilstAtom = append(ilstAtom, []byte("ilst")...)
-	ilstAtom = append(ilstAtom, ilst...)
-
-	hdlr := []byte{
-		0, 0, 0, 33, // size = 33
-		'h', 'd', 'l', 'r',
-		0, 0, 0, 0, // version + flags
-		0, 0, 0, 0, // predefined
-		'm', 'd', 'i', 'r', // handler type
-		'a', 'p', 'p', 'l', // manufacturer
-		0, 0, 0, 0, // component flags
-		0, 0, 0, 0, // component flags mask
-		0, // null terminator
-	}
-
-	metaContent := append([]byte{0, 0, 0, 0}, hdlr...) // version + flags + hdlr
-	metaContent = append(metaContent, ilstAtom...)
-
-	metaSize := 8 + len(metaContent)
-	metaAtom := make([]byte, 4)
-	metaAtom[0] = byte(metaSize >> 24)
-	metaAtom[1] = byte(metaSize >> 16)
-	metaAtom[2] = byte(metaSize >> 8)
-	metaAtom[3] = byte(metaSize)
-	metaAtom = append(metaAtom, []byte("meta")...)
-	metaAtom = append(metaAtom, metaContent...)
-
-	return metaAtom
-}
-
-func buildTextAtom(name, value string) []byte {
-	valueBytes := []byte(value)
-
-	dataSize := 16 + len(valueBytes)
-	dataAtom := make([]byte, 4)
-	dataAtom[0] = byte(dataSize >> 24)
-	dataAtom[1] = byte(dataSize >> 16)
-	dataAtom[2] = byte(dataSize >> 8)
-	dataAtom[3] = byte(dataSize)
-	dataAtom = append(dataAtom, []byte("data")...)
-	dataAtom = append(dataAtom, 0, 0, 0, 1) // type = UTF-8
-	dataAtom = append(dataAtom, 0, 0, 0, 0) // locale
-	dataAtom = append(dataAtom, valueBytes...)
-
-	atomSize := 8 + len(dataAtom)
-	atom := make([]byte, 4)
-	atom[0] = byte(atomSize >> 24)
-	atom[1] = byte(atomSize >> 16)
-	atom[2] = byte(atomSize >> 8)
-	atom[3] = byte(atomSize)
-	atom = append(atom, []byte(name)...)
-	atom = append(atom, dataAtom...)
-
-	return atom
-}
-
-// buildTrackNumberAtom builds trkn atom
-func buildTrackNumberAtom(track, total int) []byte {
-	dataAtom := []byte{
-		0, 0, 0, 24, // size
-		'd', 'a', 't', 'a',
-		0, 0, 0, 0, // type = implicit
-		0, 0, 0, 0, // locale
-		0, 0, // padding
-		byte(track >> 8), byte(track), // track number
-		byte(total >> 8), byte(total), // total tracks
-		0, 0, // padding
-	}
-
-	atomSize := 8 + len(dataAtom)
-	atom := make([]byte, 4)
-	atom[0] = byte(atomSize >> 24)
-	atom[1] = byte(atomSize >> 16)
-	atom[2] = byte(atomSize >> 8)
-	atom[3] = byte(atomSize)
-	atom = append(atom, []byte("trkn")...)
-	atom = append(atom, dataAtom...)
-
-	return atom
-}
-
-func buildDiscNumberAtom(disc, total int) []byte {
-	dataAtom := []byte{
-		0, 0, 0, 22, // size
-		'd', 'a', 't', 'a',
-		0, 0, 0, 0, // type = implicit
-		0, 0, 0, 0, // locale
-		0, 0, // padding
-		byte(disc >> 8), byte(disc), // disc number
-		byte(total >> 8), byte(total), // total discs
-	}
-
-	atomSize := 8 + len(dataAtom)
-	atom := make([]byte, 4)
-	atom[0] = byte(atomSize >> 24)
-	atom[1] = byte(atomSize >> 16)
-	atom[2] = byte(atomSize >> 8)
-	atom[3] = byte(atomSize)
-	atom = append(atom, []byte("disk")...)
-	atom = append(atom, dataAtom...)
-
-	return atom
-}
-
-// buildCoverAtom builds covr atom with image data
-func buildCoverAtom(coverData []byte) []byte {
-	imageType := byte(13)
-	if len(coverData) > 8 && coverData[0] == 0x89 && coverData[1] == 'P' && coverData[2] == 'N' && coverData[3] == 'G' {
-		imageType = 14
-	}
-
-	dataSize := 16 + len(coverData)
-	dataAtom := make([]byte, 4)
-	dataAtom[0] = byte(dataSize >> 24)
-	dataAtom[1] = byte(dataSize >> 16)
-	dataAtom[2] = byte(dataSize >> 8)
-	dataAtom[3] = byte(dataSize)
-	dataAtom = append(dataAtom, []byte("data")...)
-	dataAtom = append(dataAtom, 0, 0, 0, imageType)
-	dataAtom = append(dataAtom, 0, 0, 0, 0)
-	dataAtom = append(dataAtom, coverData...)
-
-	atomSize := 8 + len(dataAtom)
-	atom := make([]byte, 4)
-	atom[0] = byte(atomSize >> 24)
-	atom[1] = byte(atomSize >> 16)
-	atom[2] = byte(atomSize >> 8)
-	atom[3] = byte(atomSize)
-	atom = append(atom, []byte("covr")...)
-	atom = append(atom, dataAtom...)
-
-	return atom
-}
-
 func GetM4AQuality(filePath string) (AudioQuality, error) {
 	f, err := os.Open(filePath)
 	if err != nil {
@@ -989,52 +679,6 @@ func findAtomInRange(f *os.File, start, size int64, target string, fileSize int6
 	return atomHeader{}, false, nil
 }

-func writeAtomHeader(w io.Writer, typ string, size int64, headerSize int64) error {
-	if len(typ) != 4 {
-		return fmt.Errorf("invalid atom type: %s", typ)
-	}
-
-	if headerSize == 16 {
-		header := make([]byte, 16)
-		binary.BigEndian.PutUint32(header[0:4], 1)
-		copy(header[4:8], []byte(typ))
-		binary.BigEndian.PutUint64(header[8:16], uint64(size))
-		_, err := w.Write(header)
-		return err
-	}
-
-	if size > int64(^uint32(0)) {
-		return fmt.Errorf("atom size exceeds 32-bit for %s", typ)
-	}
-
-	header := make([]byte, 8)
-	binary.BigEndian.PutUint32(header[0:4], uint32(size))
-	copy(header[4:8], []byte(typ))
-	_, err := w.Write(header)
-	return err
-}
-
-func copyRange(dst io.Writer, src *os.File, offset, length int64) error {
-	if length <= 0 {
-		return nil
-	}
-	if _, err := src.Seek(offset, io.SeekStart); err != nil {
-		return fmt.Errorf("failed to seek source: %w", err)
-	}
-	if _, err := io.CopyN(dst, src, length); err != nil {
-		return fmt.Errorf("failed to copy data: %w", err)
-	}
-	return nil
-}
-
-func buildUdtaAtom(metaAtom []byte) []byte {
-	size := 8 + len(metaAtom)
-	header := make([]byte, 8)
-	binary.BigEndian.PutUint32(header[0:4], uint32(size))
-	copy(header[4:8], []byte("udta"))
-	return append(header, metaAtom...)
-}
-
 func findAudioSampleEntry(f *os.File, start, end, fileSize int64) (int64, string, error) {
 	const chunkSize = 64 * 1024
 	patternMP4A := []byte("mp4a")
@@ -0,0 +1,10 @@
+// mobile_deps.go
+// This file ensures gomobile dependencies are not removed by go mod tidy.
+// These packages are required by gomobile bind but not directly imported in code.
+
+package gobackend
+
+import (
+	// Required for gomobile bind to work
+	_ "golang.org/x/mobile/bind"
+)
@@ -0,0 +1,31 @@
+package gobackend
+
+import (
+	"fmt"
+	"os"
+	"strings"
+)
+
+func isFDOutput(outputFD int) bool {
+	return outputFD > 0
+}
+
+func openOutputForWrite(outputPath string, outputFD int) (*os.File, error) {
+	if isFDOutput(outputFD) {
+		return os.NewFile(uintptr(outputFD), fmt.Sprintf("saf_fd_%d", outputFD)), nil
+	}
+	return os.Create(outputPath)
+}
+
+func cleanupOutputOnError(outputPath string, outputFD int) {
+	if isFDOutput(outputFD) {
+		return
+	}
+
+	path := strings.TrimSpace(outputPath)
+	if path == "" || strings.HasPrefix(path, "/proc/self/fd/") {
+		return
+	}
+
+	_ = os.Remove(path)
+}
@@ -1,6 +1,7 @@
 package gobackend

 import (
+	"encoding/json"
 	"fmt"
 	"sync"
 	"time"
@@ -9,14 +10,16 @@ import (
 type TrackIDCacheEntry struct {
 	TidalTrackID  int64
 	QobuzTrackID  int64
-	AmazonTrackID string
+	AmazonURL     string
 	ExpiresAt     time.Time
 }

 type TrackIDCache struct {
-	cache map[string]*TrackIDCacheEntry
-	mu    sync.RWMutex
-	ttl   time.Duration
+	cache           map[string]*TrackIDCacheEntry
+	mu              sync.RWMutex
+	ttl             time.Duration
+	lastCleanup     time.Time
+	cleanupInterval time.Duration
 }

 var (
@@ -27,8 +30,9 @@ var (
 func GetTrackIDCache() *TrackIDCache {
 	trackIDCacheOnce.Do(func() {
 		globalTrackIDCache = &TrackIDCache{
-			cache: make(map[string]*TrackIDCacheEntry),
-			ttl:   30 * time.Minute,
+			cache:           make(map[string]*TrackIDCacheEntry),
+			ttl:             30 * time.Minute,
+			cleanupInterval: 5 * time.Minute,
 		}
 	})
 	return globalTrackIDCache
@@ -36,13 +40,33 @@ func GetTrackIDCache() *TrackIDCache {

 func (c *TrackIDCache) Get(isrc string) *TrackIDCacheEntry {
 	c.mu.RLock()
-	defer c.mu.RUnlock()
-
 	entry, exists := c.cache[isrc]
-	if !exists || time.Now().After(entry.ExpiresAt) {
+	if !exists {
+		c.mu.RUnlock()
 		return nil
 	}
-	return entry
+	expired := time.Now().After(entry.ExpiresAt)
+	c.mu.RUnlock()
+
+	if !expired {
+		return entry
+	}
+
+	c.mu.Lock()
+	entry, exists = c.cache[isrc]
+	if exists && time.Now().After(entry.ExpiresAt) {
+		delete(c.cache, isrc)
+	}
+	c.mu.Unlock()
+	return nil
+}
+
+func (c *TrackIDCache) pruneExpiredLocked(now time.Time) {
+	for key, entry := range c.cache {
+		if now.After(entry.ExpiresAt) {
+			delete(c.cache, key)
+		}
+	}
 }

 func (c *TrackIDCache) SetTidal(isrc string, trackID int64) {
@@ -55,7 +79,13 @@ func (c *TrackIDCache) SetTidal(isrc string, trackID int64) {
 		c.cache[isrc] = entry
 	}
 	entry.TidalTrackID = trackID
-	entry.ExpiresAt = time.Now().Add(c.ttl)
+	now := time.Now()
+	entry.ExpiresAt = now.Add(c.ttl)
+
+	if c.cleanupInterval > 0 && (c.lastCleanup.IsZero() || now.Sub(c.lastCleanup) >= c.cleanupInterval) {
+		c.pruneExpiredLocked(now)
+		c.lastCleanup = now
+	}
 }

 func (c *TrackIDCache) SetQobuz(isrc string, trackID int64) {
@@ -68,10 +98,16 @@ func (c *TrackIDCache) SetQobuz(isrc string, trackID int64) {
 		c.cache[isrc] = entry
 	}
 	entry.QobuzTrackID = trackID
-	entry.ExpiresAt = time.Now().Add(c.ttl)
+	now := time.Now()
+	entry.ExpiresAt = now.Add(c.ttl)
+
+	if c.cleanupInterval > 0 && (c.lastCleanup.IsZero() || now.Sub(c.lastCleanup) >= c.cleanupInterval) {
+		c.pruneExpiredLocked(now)
+		c.lastCleanup = now
+	}
 }

-func (c *TrackIDCache) SetAmazon(isrc string, trackID string) {
+func (c *TrackIDCache) SetAmazonURL(isrc string, amazonURL string) {
 	c.mu.Lock()
 	defer c.mu.Unlock()

@@ -80,8 +116,14 @@ func (c *TrackIDCache) SetAmazon(isrc string, trackID string) {
 		entry = &TrackIDCacheEntry{}
 		c.cache[isrc] = entry
 	}
-	entry.AmazonTrackID = trackID
-	entry.ExpiresAt = time.Now().Add(c.ttl)
+	entry.AmazonURL = amazonURL
+	now := time.Now()
+	entry.ExpiresAt = now.Add(c.ttl)
+
+	if c.cleanupInterval > 0 && (c.lastCleanup.IsZero() || now.Sub(c.lastCleanup) >= c.cleanupInterval) {
+		c.pruneExpiredLocked(now)
+		c.lastCleanup = now
+	}
 }

 func (c *TrackIDCache) Clear() {
@@ -96,7 +138,6 @@ func (c *TrackIDCache) Size() int {
 	return len(c.cache)
 }

-// ParallelDownloadResult holds results from parallel operations
 type ParallelDownloadResult struct {
 	CoverData  []byte
 	LyricsData *LyricsResponse
@@ -116,20 +157,20 @@ func FetchCoverAndLyricsParallel(
 ) *ParallelDownloadResult {
 	result := &ParallelDownloadResult{}
 	var wg sync.WaitGroup
+	var resultMu sync.Mutex

 	if coverURL != "" {
 		wg.Add(1)
 		go func() {
 			defer wg.Done()
-			fmt.Println("[Parallel] Starting cover download...")
 			data, err := downloadCoverToMemory(coverURL, maxQualityCover)
+			resultMu.Lock()
 			if err != nil {
 				result.CoverErr = err
-				fmt.Printf("[Parallel] Cover download failed: %v\n", err)
 			} else {
 				result.CoverData = data
-				fmt.Printf("[Parallel] Cover downloaded: %d bytes\n", len(data))
 			}
+			resultMu.Unlock()
 		}()
 	}

@@ -137,21 +178,19 @@ func FetchCoverAndLyricsParallel(
 		wg.Add(1)
 		go func() {
 			defer wg.Done()
-			fmt.Println("[Parallel] Starting lyrics fetch...")
 			client := NewLyricsClient()
 			durationSec := float64(durationMs) / 1000.0
 			lyrics, err := client.FetchLyricsAllSources(spotifyID, trackName, artistName, durationSec)
+			resultMu.Lock()
 			if err != nil {
 				result.LyricsErr = err
-				fmt.Printf("[Parallel] Lyrics fetch failed: %v\n", err)
 			} else if lyrics != nil && len(lyrics.Lines) > 0 {
 				result.LyricsData = lyrics
 				result.LyricsLRC = convertToLRCWithMetadata(lyrics, trackName, artistName)
-				fmt.Printf("[Parallel] Lyrics fetched: %d lines\n", len(lyrics.Lines))
 			} else {
 				result.LyricsErr = fmt.Errorf("no lyrics found")
-				fmt.Println("[Parallel] No lyrics found")
 			}
+			resultMu.Unlock()
 		}()
 	}

@@ -163,8 +202,8 @@ type PreWarmCacheRequest struct {
 	ISRC       string
 	TrackName  string
 	ArtistName string
-	SpotifyID  string // Needed for Amazon (SongLink lookup)
-	Service    string // "tidal", "qobuz", "amazon"
+	SpotifyID  string
+	Service    string
 }

 func PreWarmTrackCache(requests []PreWarmCacheRequest) {
@@ -172,13 +211,15 @@ func PreWarmTrackCache(requests []PreWarmCacheRequest) {
 		return
 	}

-	fmt.Printf("[Cache] Pre-warming cache for %d tracks...\n", len(requests))
 	cache := GetTrackIDCache()

 	semaphore := make(chan struct{}, 3)
 	var wg sync.WaitGroup

 	for _, req := range requests {
+		if req.ISRC == "" {
+			continue
+		}
 		if cached := cache.Get(req.ISRC); cached != nil {
 			continue
 		}
@@ -193,7 +234,7 @@ func PreWarmTrackCache(requests []PreWarmCacheRequest) {
 			case "tidal":
 				preWarmTidalCache(r.ISRC, r.TrackName, r.ArtistName)
 			case "qobuz":
-				preWarmQobuzCache(r.ISRC)
+				preWarmQobuzCache(r.ISRC, r.SpotifyID)
 			case "amazon":
 				preWarmAmazonCache(r.ISRC, r.SpotifyID)
 			}
@@ -201,7 +242,6 @@ func PreWarmTrackCache(requests []PreWarmCacheRequest) {
 	}

 	wg.Wait()
-	fmt.Printf("[Cache] Pre-warm complete. Cache size: %d\n", cache.Size())
 }

 func preWarmTidalCache(isrc, _, _ string) {
@@ -209,30 +249,68 @@ func preWarmTidalCache(isrc, _, _ string) {
 	track, err := downloader.SearchTrackByISRC(isrc)
 	if err == nil && track != nil {
 		GetTrackIDCache().SetTidal(isrc, track.ID)
-		fmt.Printf("[Cache] Cached Tidal ID for ISRC %s: %d\n", isrc, track.ID)
 	}
 }

-func preWarmQobuzCache(isrc string) {
+// preWarmQobuzCache tries to get Qobuz Track ID in the following order:
+// 1. From SongLink (fast, no Qobuz API call needed)
+// 2. Direct ISRC search on Qobuz API (slower, may fail if ISRC not in Qobuz database)
+func preWarmQobuzCache(isrc, spotifyID string) {
+	// First, try to get QobuzID from SongLink - this is faster and more reliable
+	if spotifyID != "" {
+		client := NewSongLinkClient()
+		availability, err := client.CheckTrackAvailability(spotifyID, isrc)
+		if err == nil && availability != nil && availability.QobuzID != "" {
+			// Parse QobuzID to int64
+			var trackID int64
+			if _, parseErr := fmt.Sscanf(availability.QobuzID, "%d", &trackID); parseErr == nil && trackID > 0 {
+				GoLog("[Qobuz] Pre-warm cache: Got Qobuz ID %d from SongLink for ISRC %s\n", trackID, isrc)
+				GetTrackIDCache().SetQobuz(isrc, trackID)
+				return
+			}
+		}
+	}
+
+	// Fallback: Direct ISRC search on Qobuz API
 	downloader := NewQobuzDownloader()
 	track, err := downloader.SearchTrackByISRC(isrc)
 	if err == nil && track != nil {
+		GoLog("[Qobuz] Pre-warm cache: Got Qobuz ID %d from direct ISRC search for %s\n", track.ID, isrc)
 		GetTrackIDCache().SetQobuz(isrc, track.ID)
-		fmt.Printf("[Cache] Cached Qobuz ID for ISRC %s: %d\n", isrc, track.ID)
 	}
 }

 func preWarmAmazonCache(isrc, spotifyID string) {
 	client := NewSongLinkClient()
 	availability, err := client.CheckTrackAvailability(spotifyID, isrc)
-	if err == nil && availability != nil && availability.Amazon {
-		GetTrackIDCache().SetAmazon(isrc, availability.AmazonURL)
-		fmt.Printf("[Cache] Cached Amazon URL for ISRC %s\n", isrc)
+	if err == nil && availability != nil && availability.AmazonURL != "" {
+		GetTrackIDCache().SetAmazonURL(isrc, availability.AmazonURL)
 	}
 }

 func PreWarmCache(tracksJSON string) error {
-	var requests []PreWarmCacheRequest
+	var tracks []struct {
+		ISRC       string `json:"isrc"`
+		TrackName  string `json:"track_name"`
+		ArtistName string `json:"artist_name"`
+		SpotifyID  string `json:"spotify_id"`
+		Service    string `json:"service"`
+	}
+
+	if err := json.Unmarshal([]byte(tracksJSON), &tracks); err != nil {
+		return fmt.Errorf("failed to parse tracks JSON: %w", err)
+	}
+
+	requests := make([]PreWarmCacheRequest, len(tracks))
+	for i, t := range tracks {
+		requests[i] = PreWarmCacheRequest{
+			ISRC:       t.ISRC,
+			TrackName:  t.TrackName,
+			ArtistName: t.ArtistName,
+			SpotifyID:  t.SpotifyID,
+			Service:    t.Service,
+		}
+	}

 	go PreWarmTrackCache(requests)
 	return nil
@@ -240,7 +318,6 @@ func PreWarmCache(tracksJSON string) error {

 func ClearTrackCache() {
 	GetTrackIDCache().Clear()
-	fmt.Println("[Cache] Track ID cache cleared")
 }

 func GetCacheSize() int {
@@ -78,7 +78,6 @@ func GetItemProgress(itemID string) string {
 	return "{}"
 }

-// StartItemProgress initializes progress tracking for an item
 func StartItemProgress(itemID string) {
 	multiMu.Lock()
 	defer multiMu.Unlock()
@@ -93,7 +92,6 @@ func StartItemProgress(itemID string) {
 	}
 }

-// SetItemBytesTotal sets total bytes for an item
 func SetItemBytesTotal(itemID string, total int64) {
 	multiMu.Lock()
 	defer multiMu.Unlock()
@@ -103,7 +101,6 @@ func SetItemBytesTotal(itemID string, total int64) {
 	}
 }

-// SetItemBytesReceived sets bytes received for an item
 func SetItemBytesReceived(itemID string, received int64) {
 	multiMu.Lock()
 	defer multiMu.Unlock()
@@ -116,7 +113,6 @@ func SetItemBytesReceived(itemID string, received int64) {
 	}
 }

-// SetItemBytesReceivedWithSpeed sets bytes received and speed for an item
 func SetItemBytesReceivedWithSpeed(itemID string, received int64, speedMBps float64) {
 	multiMu.Lock()
 	defer multiMu.Unlock()
@@ -130,7 +126,6 @@ func SetItemBytesReceivedWithSpeed(itemID string, received int64, speedMBps floa
 	}
 }

-// CompleteItemProgress marks an item as complete
 func CompleteItemProgress(itemID string) {
 	multiMu.Lock()
 	defer multiMu.Unlock()
@@ -142,7 +137,6 @@ func CompleteItemProgress(itemID string) {
 	}
 }

-// SetItemProgress sets progress for an item directly
 func SetItemProgress(itemID string, progress float64, bytesReceived, bytesTotal int64) {
 	multiMu.Lock()
 	defer multiMu.Unlock()
@@ -158,7 +152,6 @@ func SetItemProgress(itemID string, progress float64, bytesReceived, bytesTotal
 	}
 }

-// SetItemFinalizing marks an item as finalizing (embedding metadata)
 func SetItemFinalizing(itemID string) {
 	multiMu.Lock()
 	defer multiMu.Unlock()
@@ -169,7 +162,6 @@ func SetItemFinalizing(itemID string) {
 	}
 }

-// RemoveItemProgress removes progress tracking for an item
 func RemoveItemProgress(itemID string) {
 	multiMu.Lock()
 	defer multiMu.Unlock()
@@ -177,7 +169,6 @@ func RemoveItemProgress(itemID string) {
 	delete(multiProgress.Items, itemID)
 }

-// ClearAllItemProgress clears all item progress
 func ClearAllItemProgress() {
 	multiMu.Lock()
 	defer multiMu.Unlock()
@@ -185,7 +176,6 @@ func ClearAllItemProgress() {
 	multiProgress.Items = make(map[string]*ItemProgress)
 }

-// setDownloadDir sets the default download directory
 func setDownloadDir(path string) error {
 	downloadDirMu.Lock()
 	defer downloadDirMu.Unlock()
@@ -193,20 +183,18 @@ func setDownloadDir(path string) error {
 	return nil
 }

-// ItemProgressWriter wraps io.Writer to track download progress for a specific item
 type ItemProgressWriter struct {
 	writer       interface{ Write([]byte) (int, error) }
 	itemID       string
 	current      int64
-	lastReported int64     // Track last reported bytes for threshold-based updates
-	startTime    time.Time // Track start time for speed calculation
-	lastTime     time.Time // Track last update time for speed calculation
-	lastBytes    int64     // Track bytes at last speed calculation
+	lastReported int64
+	startTime    time.Time
+	lastTime     time.Time
+	lastBytes    int64
 }

-const progressUpdateThreshold = 64 * 1024 // Update progress every 64KB
+const progressUpdateThreshold = 64 * 1024

-// NewItemProgressWriter creates a new progress writer for a specific item
 func NewItemProgressWriter(w interface{ Write([]byte) (int, error) }, itemID string) *ItemProgressWriter {
 	now := time.Now()
 	return &ItemProgressWriter{
@@ -220,7 +208,6 @@ func NewItemProgressWriter(w interface{ Write([]byte) (int, error) }, itemID str
 	}
 }

-// Write implements io.Writer with threshold-based progress updates and speed tracking
 func (pw *ItemProgressWriter) Write(p []byte) (int, error) {
 	if pw.itemID != "" && isDownloadCancelled(pw.itemID) {
 		return 0, ErrDownloadCancelled
@@ -52,12 +52,10 @@ func qobuzArtistsMatch(expectedArtist, foundArtist string) bool {
 	normExpected := strings.ToLower(strings.TrimSpace(expectedArtist))
 	normFound := strings.ToLower(strings.TrimSpace(foundArtist))

-	// Exact match
 	if normExpected == normFound {
 		return true
 	}

-	// Check if one contains the other
 	if strings.Contains(normExpected, normFound) || strings.Contains(normFound, normExpected) {
 		return true
 	}
@@ -112,24 +110,19 @@ func qobuzSplitArtists(artists string) []string {
 	return result
 }

-// qobuzSameWordsUnordered checks if two strings have the same words regardless of order
-// Useful for Japanese names: "Sawano Hiroyuki" vs "Hiroyuki Sawano"
 func qobuzSameWordsUnordered(a, b string) bool {
 	wordsA := strings.Fields(a)
 	wordsB := strings.Fields(b)

-	// Must have same number of words
 	if len(wordsA) != len(wordsB) || len(wordsA) == 0 {
 		return false
 	}

-	// Sort and compare
 	sortedA := make([]string, len(wordsA))
 	sortedB := make([]string, len(wordsB))
 	copy(sortedA, wordsA)
 	copy(sortedB, wordsB)

-	// Simple bubble sort (usually just 2-3 words)
 	for i := 0; i < len(sortedA)-1; i++ {
 		for j := i + 1; j < len(sortedA); j++ {
 			if sortedA[i] > sortedA[j] {
@@ -153,7 +146,6 @@ func qobuzTitlesMatch(expectedTitle, foundTitle string) bool {
 	normExpected := strings.ToLower(strings.TrimSpace(expectedTitle))
 	normFound := strings.ToLower(strings.TrimSpace(foundTitle))

-	// Exact match
 	if normExpected == normFound {
 		return true
 	}
@@ -182,8 +174,6 @@ func qobuzTitlesMatch(expectedTitle, foundTitle string) bool {
 		return true
 	}

-	// If scripts are TRULY different (Latin vs CJK/Arabic/Cyrillic), assume match (transliteration)
-	// Don't treat Latin Extended (Polish, French, etc.) as different script
 	expectedLatin := qobuzIsLatinScript(expectedTitle)
 	foundLatin := qobuzIsLatinScript(foundTitle)
 	if expectedLatin != foundLatin {
@@ -194,9 +184,7 @@ func qobuzTitlesMatch(expectedTitle, foundTitle string) bool {
 	return false
 }

-// qobuzExtractCoreTitle extracts the main title before any parentheses or brackets
 func qobuzExtractCoreTitle(title string) string {
-	// Find first occurrence of ( or [
 	parenIdx := strings.Index(title, "(")
 	bracketIdx := strings.Index(title, "[")
 	dashIdx := strings.Index(title, " - ")
@@ -281,49 +269,28 @@ func qobuzCleanTitle(title string) string {
 	return strings.TrimSpace(cleaned)
 }

-// qobuzIsLatinScript checks if a string is primarily Latin script
-// Returns true for ASCII and Latin Extended characters (European languages)
-// Returns false for CJK, Arabic, Cyrillic, etc.
 func qobuzIsLatinScript(s string) bool {
 	for _, r := range s {
-		// Skip common punctuation and numbers
 		if r < 128 {
 			continue
 		}
-		// Latin Extended-A: U+0100 to U+017F (Polish, Czech, etc.)
-		// Latin Extended-B: U+0180 to U+024F
-		// Latin Extended Additional: U+1E00 to U+1EFF
-		// Latin Extended-C/D/E: various ranges
-		if (r >= 0x0100 && r <= 0x024F) || // Latin Extended A & B
-			(r >= 0x1E00 && r <= 0x1EFF) || // Latin Extended Additional
-			(r >= 0x00C0 && r <= 0x00FF) { // Latin-1 Supplement (accented chars)
+		if (r >= 0x0100 && r <= 0x024F) ||
+			(r >= 0x1E00 && r <= 0x1EFF) ||
+			(r >= 0x00C0 && r <= 0x00FF) {
 			continue
 		}
-		// CJK ranges - definitely different script
-		if (r >= 0x4E00 && r <= 0x9FFF) || // CJK Unified Ideographs
-			(r >= 0x3040 && r <= 0x309F) || // Hiragana
-			(r >= 0x30A0 && r <= 0x30FF) || // Katakana
-			(r >= 0xAC00 && r <= 0xD7AF) || // Hangul (Korean)
-			(r >= 0x0600 && r <= 0x06FF) || // Arabic
-			(r >= 0x0400 && r <= 0x04FF) { // Cyrillic
+		if (r >= 0x4E00 && r <= 0x9FFF) ||
+			(r >= 0x3040 && r <= 0x309F) ||
+			(r >= 0x30A0 && r <= 0x30FF) ||
+			(r >= 0xAC00 && r <= 0xD7AF) ||
+			(r >= 0x0600 && r <= 0x06FF) ||
+			(r >= 0x0400 && r <= 0x04FF) {
 			return false
 		}
 	}
 	return true
 }

-// qobuzIsASCIIString checks if a string contains only ASCII characters
-// Kept for potential future use
-// func qobuzIsASCIIString(s string) bool {
-// 	for _, r := range s {
-// 		if r > 127 {
-// 			return false
-// 		}
-// 	}
-// 	return true
-// }
-
-// containsQueryQobuz checks if a query already exists in the list
 func containsQueryQobuz(queries []string, query string) bool {
 	for _, q := range queries {
 		if q == query {
@@ -336,7 +303,7 @@ func containsQueryQobuz(queries []string, query string) bool {
 func NewQobuzDownloader() *QobuzDownloader {
 	qobuzDownloaderOnce.Do(func() {
 		globalQobuzDownloader = &QobuzDownloader{
-			client: NewHTTPClientWithTimeout(DefaultTimeout), // 60s timeout
+			client: NewHTTPClientWithTimeout(DefaultTimeout),
 			appID:  "798273057",
 		}
 	})
@@ -344,7 +311,6 @@ func NewQobuzDownloader() *QobuzDownloader {
 }

 func (q *QobuzDownloader) GetTrackByID(trackID int64) (*QobuzTrack, error) {
-	// Qobuz API: /track/get?track_id=XXX
 	apiBase, _ := base64.StdEncoding.DecodeString("aHR0cHM6Ly93d3cucW9idXouY29tL2FwaS5qc29uLzAuMi90cmFjay9nZXQ/dHJhY2tfaWQ9")
 	trackURL := fmt.Sprintf("%s%d&app_id=%s", string(apiBase), trackID, q.appID)

@@ -371,14 +337,11 @@ func (q *QobuzDownloader) GetTrackByID(trackID int64) (*QobuzTrack, error) {
 	return &track, nil
 }

-// GetAvailableAPIs returns list of available Qobuz APIs
-// Uses same APIs as PC version for compatibility
 func (q *QobuzDownloader) GetAvailableAPIs() []string {
-	// Same APIs as PC version (referensi/backend/qobuz.go)
-	// Primary: dab.yeet.su, Fallback: dabmusic.xyz
 	encodedAPIs := []string{
-		"ZGFiLnllZXQuc3UvYXBpL3N0cmVhbT90cmFja0lkPQ==", // dab.yeet.su/api/stream?trackId= (PRIMARY - same as PC)
-		"ZGFibXVzaWMueHl6L2FwaS9zdHJlYW0/dHJhY2tJZD0=", // dabmusic.xyz/api/stream?trackId= (FALLBACK - same as PC)
+		"ZGFiLnllZXQuc3UvYXBpL3N0cmVhbT90cmFja0lkPQ==",
+		"ZGFibXVzaWMueHl6L2FwaS9zdHJlYW0/dHJhY2tJZD0=",
+		"cW9idXouc3F1aWQud3RmL2FwaS9kb3dubG9hZC1tdXNpYz90cmFja19pZD0=",
 	}

 	var apis []string
@@ -393,6 +356,122 @@ func (q *QobuzDownloader) GetAvailableAPIs() []string {
 	return apis
 }

+func mapJumoQuality(quality string) int {
+	switch quality {
+	case "6":
+		return 6
+	case "7":
+		return 7
+	case "27":
+		return 27
+	default:
+		return 6
+	}
+}
+
+func decodeXOR(data []byte) string {
+	text := string(data)
+	runes := []rune(text)
+	result := make([]rune, len(runes))
+	for i, char := range runes {
+		key := rune((i * 17) % 128)
+		result[i] = char ^ 253 ^ key
+	}
+	return string(result)
+}
+
+func extractQobuzDownloadURLFromBody(body []byte) (string, error) {
+	var raw map[string]any
+	if err := json.Unmarshal(body, &raw); err != nil {
+		return "", fmt.Errorf("invalid JSON: %v", err)
+	}
+
+	if errMsg, ok := raw["error"].(string); ok && strings.TrimSpace(errMsg) != "" {
+		return "", fmt.Errorf("%s", errMsg)
+	}
+
+	if success, ok := raw["success"].(bool); ok && !success {
+		if msg, ok := raw["message"].(string); ok && strings.TrimSpace(msg) != "" {
+			return "", fmt.Errorf("%s", msg)
+		}
+		return "", fmt.Errorf("api returned success=false")
+	}
+
+	if urlVal, ok := raw["url"].(string); ok && strings.TrimSpace(urlVal) != "" {
+		return strings.TrimSpace(urlVal), nil
+	}
+	if linkVal, ok := raw["link"].(string); ok && strings.TrimSpace(linkVal) != "" {
+		return strings.TrimSpace(linkVal), nil
+	}
+
+	if data, ok := raw["data"].(map[string]any); ok {
+		if urlVal, ok := data["url"].(string); ok && strings.TrimSpace(urlVal) != "" {
+			return strings.TrimSpace(urlVal), nil
+		}
+		if linkVal, ok := data["link"].(string); ok && strings.TrimSpace(linkVal) != "" {
+			return strings.TrimSpace(linkVal), nil
+		}
+	}
+
+	return "", fmt.Errorf("no download URL in response")
+}
+
+func (q *QobuzDownloader) downloadFromJumo(trackID int64, quality string) (string, error) {
+	formatID := mapJumoQuality(quality)
+	region := "US"
+	jumoURL := fmt.Sprintf("https://jumo-dl.pages.dev/file?track_id=%d&format_id=%d&region=%s", trackID, formatID, region)
+
+	GoLog("[Qobuz] Trying Jumo API fallback...\n")
+
+	client := NewHTTPClientWithTimeout(30 * time.Second)
+	req, err := http.NewRequest("GET", jumoURL, nil)
+	if err != nil {
+		return "", err
+	}
+
+	resp, err := client.Do(req)
+	if err != nil {
+		return "", err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != 200 {
+		return "", fmt.Errorf("Jumo API returned HTTP %d", resp.StatusCode)
+	}
+
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return "", err
+	}
+
+	var result map[string]any
+	if err := json.Unmarshal(body, &result); err != nil {
+		decoded := decodeXOR(body)
+		if err := json.Unmarshal([]byte(decoded), &result); err != nil {
+			return "", fmt.Errorf("failed to parse Jumo response (plain or XOR): %w", err)
+		}
+	}
+
+	if urlVal, ok := result["url"].(string); ok && urlVal != "" {
+		GoLog("[Qobuz] Jumo API returned URL successfully\n")
+		return urlVal, nil
+	}
+
+	if data, ok := result["data"].(map[string]any); ok {
+		if urlVal, ok := data["url"].(string); ok && urlVal != "" {
+			GoLog("[Qobuz] Jumo API returned URL successfully (from data)\n")
+			return urlVal, nil
+		}
+	}
+
+	if linkVal, ok := result["link"].(string); ok && linkVal != "" {
+		GoLog("[Qobuz] Jumo API returned URL successfully (from link)\n")
+		return linkVal, nil
+	}
+
+	return "", fmt.Errorf("URL not found in Jumo response")
+}
+
 func (q *QobuzDownloader) SearchTrackByISRC(isrc string) (*QobuzTrack, error) {
 	apiBase, _ := base64.StdEncoding.DecodeString("aHR0cHM6Ly93d3cucW9idXouY29tL2FwaS5qc29uLzAuMi90cmFjay9zZWFyY2g/cXVlcnk9")
 	searchURL := fmt.Sprintf("%s%s&limit=50&app_id=%s", string(apiBase), url.QueryEscape(isrc), q.appID)
@@ -421,7 +500,6 @@ func (q *QobuzDownloader) SearchTrackByISRC(isrc string) (*QobuzTrack, error) {
 		return nil, err
 	}

-	// Find exact ISRC match
 	for i := range result.Tracks.Items {
 		if result.Tracks.Items[i].ISRC == isrc {
 			return &result.Tracks.Items[i], nil
@@ -435,7 +513,6 @@ func (q *QobuzDownloader) SearchTrackByISRC(isrc string) (*QobuzTrack, error) {
 	return nil, fmt.Errorf("no exact ISRC match found for: %s", isrc)
 }

-// expectedDurationSec is the expected duration in seconds (0 to skip verification)
 func (q *QobuzDownloader) SearchTrackByISRCWithDuration(isrc string, expectedDurationSec int) (*QobuzTrack, error) {
 	GoLog("[Qobuz] Searching by ISRC: %s\n", isrc)

@@ -468,7 +545,6 @@ func (q *QobuzDownloader) SearchTrackByISRCWithDuration(isrc string, expectedDur

 	GoLog("[Qobuz] ISRC search returned %d results\n", len(result.Tracks.Items))

-	// Find ISRC matches
 	var isrcMatches []*QobuzTrack
 	for i := range result.Tracks.Items {
 		if result.Tracks.Items[i].ISRC == isrc {
@@ -522,35 +598,26 @@ func (q *QobuzDownloader) SearchTrackByMetadata(trackName, artistName string) (*
 	return q.SearchTrackByMetadataWithDuration(trackName, artistName, 0)
 }

-// Now includes romaji conversion for Japanese text (same as Tidal)
-// Also includes title verification to prevent wrong song downloads
 func (q *QobuzDownloader) SearchTrackByMetadataWithDuration(trackName, artistName string, expectedDurationSec int) (*QobuzTrack, error) {
 	apiBase, _ := base64.StdEncoding.DecodeString("aHR0cHM6Ly93d3cucW9idXouY29tL2FwaS5qc29uLzAuMi90cmFjay9zZWFyY2g/cXVlcnk9")

-	// Try multiple search strategies (same as Tidal/PC version)
 	queries := []string{}

-	// Strategy 1: Artist + Track name
 	if artistName != "" && trackName != "" {
 		queries = append(queries, artistName+" "+trackName)
 	}

-	// Strategy 2: Track name only
 	if trackName != "" {
 		queries = append(queries, trackName)
 	}

-	// Strategy 3: Romaji versions if Japanese detected
 	if ContainsJapanese(trackName) || ContainsJapanese(artistName) {
-		// Convert to romaji (hiragana/katakana only, kanji stays)
 		romajiTrack := JapaneseToRomaji(trackName)
 		romajiArtist := JapaneseToRomaji(artistName)

-		// Clean and remove ALL non-ASCII characters (including kanji)
 		cleanRomajiTrack := CleanToASCII(romajiTrack)
 		cleanRomajiArtist := CleanToASCII(romajiArtist)

-		// Artist + Track romaji (cleaned to ASCII only)
 		if cleanRomajiArtist != "" && cleanRomajiTrack != "" {
 			romajiQuery := cleanRomajiArtist + " " + cleanRomajiTrack
 			if !containsQueryQobuz(queries, romajiQuery) {
@@ -559,7 +626,6 @@ func (q *QobuzDownloader) SearchTrackByMetadataWithDuration(trackName, artistNam
 			}
 		}

-		// Track romaji only (cleaned)
 		if cleanRomajiTrack != "" && cleanRomajiTrack != trackName {
 			if !containsQueryQobuz(queries, cleanRomajiTrack) {
 				queries = append(queries, cleanRomajiTrack)
@@ -567,7 +633,6 @@ func (q *QobuzDownloader) SearchTrackByMetadataWithDuration(trackName, artistNam
 		}
 	}

-	// Strategy 4: Artist only as last resort
 	if artistName != "" {
 		artistOnly := CleanToASCII(JapaneseToRomaji(artistName))
 		if artistOnly != "" && !containsQueryQobuz(queries, artistOnly) {
@@ -626,7 +691,6 @@ func (q *QobuzDownloader) SearchTrackByMetadataWithDuration(trackName, artistNam
 		return nil, fmt.Errorf("no tracks found for: %s - %s", artistName, trackName)
 	}

-	// Filter by title match first (NEW - like Tidal)
 	var titleMatches []*QobuzTrack
 	for i := range allTracks {
 		track := &allTracks[i]
@@ -637,7 +701,6 @@ func (q *QobuzDownloader) SearchTrackByMetadataWithDuration(trackName, artistNam

 	GoLog("[Qobuz] Title matches: %d out of %d results\n", len(titleMatches), len(allTracks))

-	// If no title matches, log warning but continue with all tracks
 	tracksToCheck := titleMatches
 	if len(titleMatches) == 0 {
 		GoLog("[Qobuz] WARNING: No title matches for '%s', checking all %d results\n", trackName, len(allTracks))
@@ -646,7 +709,6 @@ func (q *QobuzDownloader) SearchTrackByMetadataWithDuration(trackName, artistNam
 		}
 	}

-	// If duration verification is requested
 	if expectedDurationSec > 0 {
 		var durationMatches []*QobuzTrack
 		for _, track := range tracksToCheck {
@@ -662,12 +724,12 @@ func (q *QobuzDownloader) SearchTrackByMetadataWithDuration(trackName, artistNam
 		if len(durationMatches) > 0 {
 			for _, track := range durationMatches {
 				if track.MaximumBitDepth >= 24 {
-					GoLog("[Qobuz] ✓ Match found: '%s' by '%s' (title+duration verified, hi-res)\n",
+					GoLog("[Qobuz] Match found: '%s' by '%s' (title+duration verified, hi-res)\n",
 						track.Title, track.Performer.Name)
 					return track, nil
 				}
 			}
-			GoLog("[Qobuz] ✓ Match found: '%s' by '%s' (title+duration verified)\n",
+			GoLog("[Qobuz] Match found: '%s' by '%s' (title+duration verified)\n",
 				durationMatches[0].Title, durationMatches[0].Performer.Name)
 			return durationMatches[0], nil
 		}
@@ -675,17 +737,16 @@ func (q *QobuzDownloader) SearchTrackByMetadataWithDuration(trackName, artistNam
 		return nil, fmt.Errorf("no tracks found with matching title and duration (expected '%s', %ds)", trackName, expectedDurationSec)
 	}

-	// No duration verification, return best quality from title matches
 	for _, track := range tracksToCheck {
 		if track.MaximumBitDepth >= 24 {
-			GoLog("[Qobuz] ✓ Match found: '%s' by '%s' (title verified, hi-res)\n",
+			GoLog("[Qobuz] Match found: '%s' by '%s' (title verified, hi-res)\n",
 				track.Title, track.Performer.Name)
 			return track, nil
 		}
 	}

 	if len(tracksToCheck) > 0 {
-		GoLog("[Qobuz] ✓ Match found: '%s' by '%s' (title verified)\n",
+		GoLog("[Qobuz] Match found: '%s' by '%s' (title verified)\n",
 			tracksToCheck[0].Title, tracksToCheck[0].Performer.Name)
 		return tracksToCheck[0], nil
 	}
@@ -693,7 +754,6 @@ func (q *QobuzDownloader) SearchTrackByMetadataWithDuration(trackName, artistNam
 	return nil, fmt.Errorf("no matching track found for: %s - %s", artistName, trackName)
 }

-// qobuzAPIResult holds the result from a parallel API request
 type qobuzAPIResult struct {
 	apiURL      string
 	downloadURL string
@@ -701,90 +761,161 @@ type qobuzAPIResult struct {
 	duration    time.Duration
 }

+// Qobuz API timeout configuration
+// Mobile networks are more unstable, so we use longer timeouts
+const (
+	qobuzAPITimeoutMobile = 25 * time.Second
+	qobuzMaxRetries       = 2 // Number of retries per API
+	qobuzRetryDelay       = 500 * time.Millisecond
+)
+
+// getQobuzAPITimeout returns appropriate timeout based on platform
+// For mobile (gomobile builds), we use longer timeouts
+func getQobuzAPITimeout() time.Duration {
+	// Since this runs in gomobile context, we always use mobile timeout
+	// The Go backend is only used on mobile (Android/iOS)
+	return qobuzAPITimeoutMobile
+}
+
+// qobuzSquidCountries defines the region fallback order for squid.wtf API
+var qobuzSquidCountries = []string{"US", "FR"}
+
+// fetchQobuzURLWithRetry fetches download URL from a single Qobuz API with retry logic
+// For squid.wtf APIs, it tries US region first, then falls back to FR
+func fetchQobuzURLWithRetry(api string, trackID int64, quality string, timeout time.Duration) (string, error) {
+	isSquid := strings.Contains(api, "squid.wtf")
+
+	if isSquid {
+		for _, country := range qobuzSquidCountries {
+			GoLog("[Qobuz] Trying squid.wtf with country=%s\n", country)
+			result, err := fetchQobuzURLSingleAttempt(api, trackID, quality, timeout, country)
+			if err == nil {
+				return result, nil
+			}
+			GoLog("[Qobuz] squid.wtf country=%s failed: %v\n", country, err)
+		}
+		return "", fmt.Errorf("squid.wtf failed for all regions (US, FR)")
+	}
+
+	return fetchQobuzURLSingleAttempt(api, trackID, quality, timeout, "")
+}
+
+// fetchQobuzURLSingleAttempt fetches download URL with retry logic for a single API+country combination
+func fetchQobuzURLSingleAttempt(api string, trackID int64, quality string, timeout time.Duration, country string) (string, error) {
+	var lastErr error
+	retryDelay := qobuzRetryDelay
+
+	for attempt := 0; attempt <= qobuzMaxRetries; attempt++ {
+		if attempt > 0 {
+			GoLog("[Qobuz] Retry %d/%d for %s after %v\n", attempt, qobuzMaxRetries, api, retryDelay)
+			time.Sleep(retryDelay)
+			retryDelay *= 2 // Exponential backoff
+		}
+
+		client := NewHTTPClientWithTimeout(timeout)
+		reqURL := fmt.Sprintf("%s%d&quality=%s", api, trackID, quality)
+		if country != "" {
+			reqURL += "&country=" + country
+		}
+
+		req, err := http.NewRequest("GET", reqURL, nil)
+		if err != nil {
+			lastErr = err
+			continue
+		}
+
+		resp, err := client.Do(req)
+		if err != nil {
+			lastErr = err
+			// Check for retryable errors (timeout, connection reset)
+			errStr := strings.ToLower(err.Error())
+			if strings.Contains(errStr, "timeout") ||
+				strings.Contains(errStr, "reset") ||
+				strings.Contains(errStr, "connection refused") ||
+				strings.Contains(errStr, "eof") {
+				continue // Retry
+			}
+			break // Non-retryable error
+		}
+		// Server errors are retryable
+		if resp.StatusCode >= 500 {
+			io.Copy(io.Discard, resp.Body)
+			resp.Body.Close()
+			lastErr = fmt.Errorf("HTTP %d", resp.StatusCode)
+			continue
+		}
+
+		// 429 rate limit - wait and retry
+		if resp.StatusCode == 429 {
+			io.Copy(io.Discard, resp.Body)
+			resp.Body.Close()
+			lastErr = fmt.Errorf("rate limited")
+			retryDelay = 2 * time.Second // Wait longer for rate limit
+			continue
+		}
+
+		if resp.StatusCode != 200 {
+			io.Copy(io.Discard, resp.Body)
+			resp.Body.Close()
+			return "", fmt.Errorf("HTTP %d", resp.StatusCode)
+		}
+
+		body, err := io.ReadAll(resp.Body)
+		resp.Body.Close()
+		if err != nil {
+			lastErr = err
+			continue
+		}
+
+		if len(body) > 0 && body[0] == '<' {
+			return "", fmt.Errorf("received HTML instead of JSON")
+		}
+
+		urlVal, parseErr := extractQobuzDownloadURLFromBody(body)
+		if parseErr == nil {
+			return urlVal, nil
+		}
+		lastErr = parseErr
+		continue
+	}
+
+	if lastErr != nil {
+		return "", lastErr
+	}
+	return "", fmt.Errorf("all retries failed")
+}
+
 func getQobuzDownloadURLParallel(apis []string, trackID int64, quality string) (string, string, error) {
 	if len(apis) == 0 {
 		return "", "", fmt.Errorf("no APIs available")
 	}

-	GoLog("[Qobuz] Requesting download URL from %d APIs in parallel...\n", len(apis))
+	GoLog("[Qobuz] Requesting download URL from %d APIs in parallel (with retry)...\n", len(apis))

 	resultChan := make(chan qobuzAPIResult, len(apis))
 	startTime := time.Now()
+	timeout := getQobuzAPITimeout()

-	// Start all requests in parallel
 	for _, apiURL := range apis {
 		go func(api string) {
 			reqStart := time.Now()
-
-			client := NewHTTPClientWithTimeout(15 * time.Second)
-
-			reqURL := fmt.Sprintf("%s%d&quality=%s", api, trackID, quality)
-
-			req, err := http.NewRequest("GET", reqURL, nil)
-			if err != nil {
-				resultChan <- qobuzAPIResult{apiURL: api, err: err, duration: time.Since(reqStart)}
-				return
+			downloadURL, err := fetchQobuzURLWithRetry(api, trackID, quality, timeout)
+			resultChan <- qobuzAPIResult{
+				apiURL:      api,
+				downloadURL: downloadURL,
+				err:         err,
+				duration:    time.Since(reqStart),
 			}
-
-			resp, err := client.Do(req)
-			if err != nil {
-				resultChan <- qobuzAPIResult{apiURL: api, err: err, duration: time.Since(reqStart)}
-				return
-			}
-			defer resp.Body.Close()
-
-			if resp.StatusCode != 200 {
-				resultChan <- qobuzAPIResult{apiURL: api, err: fmt.Errorf("HTTP %d", resp.StatusCode), duration: time.Since(reqStart)}
-				return
-			}
-
-			body, err := io.ReadAll(resp.Body)
-			if err != nil {
-				resultChan <- qobuzAPIResult{apiURL: api, err: err, duration: time.Since(reqStart)}
-				return
-			}
-
-			// Check if response is HTML (error page)
-			if len(body) > 0 && body[0] == '<' {
-				resultChan <- qobuzAPIResult{apiURL: api, err: fmt.Errorf("received HTML instead of JSON"), duration: time.Since(reqStart)}
-				return
-			}
-
-			// Check for error in JSON response
-			var errorResp struct {
-				Error string `json:"error"`
-			}
-			if json.Unmarshal(body, &errorResp) == nil && errorResp.Error != "" {
-				resultChan <- qobuzAPIResult{apiURL: api, err: fmt.Errorf("%s", errorResp.Error), duration: time.Since(reqStart)}
-				return
-			}
-
-			var result struct {
-				URL string `json:"url"`
-			}
-			if err := json.Unmarshal(body, &result); err != nil {
-				resultChan <- qobuzAPIResult{apiURL: api, err: fmt.Errorf("invalid JSON: %v", err), duration: time.Since(reqStart)}
-				return
-			}
-
-			if result.URL != "" {
-				resultChan <- qobuzAPIResult{apiURL: api, downloadURL: result.URL, err: nil, duration: time.Since(reqStart)}
-				return
-			}
-
-			resultChan <- qobuzAPIResult{apiURL: api, err: fmt.Errorf("no download URL in response"), duration: time.Since(reqStart)}
 		}(apiURL)
 	}

-	// Collect results - return first success
 	var errors []string

 	for i := 0; i < len(apis); i++ {
 		result := <-resultChan
 		if result.err == nil {
-			GoLog("[Qobuz] [Parallel] ✓ Got response from %s in %v\n", result.apiURL, result.duration)
+			GoLog("[Qobuz] [Parallel] Got response from %s in %v\n", result.apiURL, result.duration)

-			// Drain remaining results to avoid goroutine leaks
 			go func(remaining int) {
 				for j := 0; j < remaining; j++ {
 					<-resultChan
@@ -812,18 +943,38 @@ func (q *QobuzDownloader) GetDownloadURL(trackID int64, quality string) (string,
 	}

 	_, downloadURL, err := getQobuzDownloadURLParallel(apis, trackID, quality)
-	if err != nil {
-		return "", err
+	if err == nil {
+		return downloadURL, nil
 	}

-	return downloadURL, nil
+	GoLog("[Qobuz] Standard APIs failed, trying Jumo fallback...\n")
+	jumoURL, jumoErr := q.downloadFromJumo(trackID, quality)
+	if jumoErr == nil {
+		return jumoURL, nil
+	}
+
+	if quality == "27" {
+		GoLog("[Qobuz] Hi-res (27) failed, trying 24-bit (7)...\n")
+		jumoURL, jumoErr = q.downloadFromJumo(trackID, "7")
+		if jumoErr == nil {
+			return jumoURL, nil
+		}
+	}
+
+	if quality == "27" || quality == "7" {
+		GoLog("[Qobuz] 24-bit failed, trying 16-bit (6)...\n")
+		jumoURL, jumoErr = q.downloadFromJumo(trackID, "6")
+		if jumoErr == nil {
+			return jumoURL, nil
+		}
+	}
+
+	return "", fmt.Errorf("all Qobuz APIs and Jumo fallback failed: %w", err)
 }

-// DownloadFile downloads a file from URL with User-Agent and progress tracking
-func (q *QobuzDownloader) DownloadFile(downloadURL, outputPath, itemID string) error {
+func (q *QobuzDownloader) DownloadFile(downloadURL, outputPath string, outputFD int, itemID string) error {
 	ctx := context.Background()

-	// Initialize item progress (required for all downloads)
 	if itemID != "" {
 		StartItemProgress(itemID)
 		defer CompleteItemProgress(itemID)
@@ -858,7 +1009,7 @@ func (q *QobuzDownloader) DownloadFile(downloadURL, outputPath, itemID string) e
 		SetItemBytesTotal(itemID, expectedSize)
 	}

-	out, err := os.Create(outputPath)
+	out, err := openOutputForWrite(outputPath, outputFD)
 	if err != nil {
 		return err
 	}
@@ -873,29 +1024,27 @@ func (q *QobuzDownloader) DownloadFile(downloadURL, outputPath, itemID string) e
 		written, err = io.Copy(bufWriter, resp.Body)
 	}

-	// Flush buffer before checking for errors
 	flushErr := bufWriter.Flush()
 	closeErr := out.Close()

 	if err != nil {
-		os.Remove(outputPath)
+		cleanupOutputOnError(outputPath, outputFD)
 		if isDownloadCancelled(itemID) {
 			return ErrDownloadCancelled
 		}
 		return fmt.Errorf("download interrupted: %w", err)
 	}
 	if flushErr != nil {
-		os.Remove(outputPath)
+		cleanupOutputOnError(outputPath, outputFD)
 		return fmt.Errorf("failed to flush buffer: %w", flushErr)
 	}
 	if closeErr != nil {
-		os.Remove(outputPath)
+		cleanupOutputOnError(outputPath, outputFD)
 		return fmt.Errorf("failed to close file: %w", closeErr)
 	}

-	// Verify file size if Content-Length was provided
 	if expectedSize > 0 && written != expectedSize {
-		os.Remove(outputPath)
+		cleanupOutputOnError(outputPath, outputFD)
 		return fmt.Errorf("incomplete download: expected %d bytes, got %d bytes", expectedSize, written)
 	}

@@ -913,13 +1062,17 @@ type QobuzDownloadResult struct {
 	TrackNumber int
 	DiscNumber  int
 	ISRC        string
+	LyricsLRC   string
 }

 func downloadFromQobuz(req DownloadRequest) (QobuzDownloadResult, error) {
 	downloader := NewQobuzDownloader()

-	if existingFile, exists := checkISRCExistsInternal(req.OutputDir, req.ISRC); exists {
-		return QobuzDownloadResult{FilePath: "EXISTS:" + existingFile}, nil
+	isSafOutput := isFDOutput(req.OutputFD) || strings.TrimSpace(req.OutputPath) != ""
+	if !isSafOutput {
+		if existingFile, exists := checkISRCExistsInternal(req.OutputDir, req.ISRC); exists {
+			return QobuzDownloadResult{FilePath: "EXISTS:" + existingFile}, nil
+		}
 	}

 	expectedDurationSec := req.DurationMS / 1000
@@ -927,6 +1080,7 @@ func downloadFromQobuz(req DownloadRequest) (QobuzDownloadResult, error) {
 	var track *QobuzTrack
 	var err error

+	// Strategy 1: Use Qobuz ID from Odesli enrichment (fastest, most accurate)
 	if req.QobuzID != "" {
 		GoLog("[Qobuz] Using Qobuz ID from Odesli enrichment: %s\n", req.QobuzID)
 		var trackID int64
@@ -941,24 +1095,46 @@ func downloadFromQobuz(req DownloadRequest) (QobuzDownloadResult, error) {
 		}
 	}

-	// OPTIMIZATION: Check cache first for track ID
+	// Strategy 2: Use cached Qobuz Track ID (fast, no search needed)
 	if track == nil && req.ISRC != "" {
 		if cached := GetTrackIDCache().Get(req.ISRC); cached != nil && cached.QobuzTrackID > 0 {
 			GoLog("[Qobuz] Cache hit! Using cached track ID: %d\n", cached.QobuzTrackID)
-			// For Qobuz we need to search again to get full track info, but we can use the ID
-			track, err = downloader.SearchTrackByISRC(req.ISRC)
+			track, err = downloader.GetTrackByID(cached.QobuzTrackID)
 			if err != nil {
-				GoLog("[Qobuz] Cache hit but search failed: %v\n", err)
+				GoLog("[Qobuz] Cache hit but GetTrackByID failed: %v\n", err)
 				track = nil
 			}
 		}
 	}

-	// Strategy 1: Search by ISRC with duration verification
+	// Strategy 3: Try to get QobuzID from SongLink if we have SpotifyID
+	if track == nil && req.SpotifyID != "" && req.QobuzID == "" {
+		GoLog("[Qobuz] Trying to get Qobuz ID from SongLink for Spotify ID: %s\n", req.SpotifyID)
+		songLinkClient := NewSongLinkClient()
+		availability, slErr := songLinkClient.CheckTrackAvailability(req.SpotifyID, req.ISRC)
+		if slErr == nil && availability != nil && availability.QobuzID != "" {
+			var trackID int64
+			if _, parseErr := fmt.Sscanf(availability.QobuzID, "%d", &trackID); parseErr == nil && trackID > 0 {
+				GoLog("[Qobuz] Got Qobuz ID %d from SongLink\n", trackID)
+				track, err = downloader.GetTrackByID(trackID)
+				if err != nil {
+					GoLog("[Qobuz] Failed to get track by SongLink ID %d: %v\n", trackID, err)
+					track = nil
+				} else if track != nil {
+					GoLog("[Qobuz] Successfully found track via SongLink ID: '%s' by '%s'\n", track.Title, track.Performer.Name)
+					// Cache for future use
+					if req.ISRC != "" {
+						GetTrackIDCache().SetQobuz(req.ISRC, track.ID)
+					}
+				}
+			}
+		}
+	}
+
+	// Strategy 4: ISRC search with duration verification
 	if track == nil && req.ISRC != "" {
 		GoLog("[Qobuz] Trying ISRC search: %s\n", req.ISRC)
 		track, err = downloader.SearchTrackByISRCWithDuration(req.ISRC, expectedDurationSec)
-		// Verify artist AND title
 		if track != nil {
 			if !qobuzArtistsMatch(req.ArtistName, track.Performer.Name) {
 				GoLog("[Qobuz] Artist mismatch from ISRC search: expected '%s', got '%s'. Rejecting.\n",
@@ -972,10 +1148,10 @@ func downloadFromQobuz(req DownloadRequest) (QobuzDownloadResult, error) {
 		}
 	}

-	// Strategy 2: Search by metadata with duration verification (includes title verification)
+	// Strategy 5: Metadata search with strict matching (duration tolerance: 10 seconds)
 	if track == nil {
+		GoLog("[Qobuz] Trying metadata search: '%s' by '%s'\n", req.TrackName, req.ArtistName)
 		track, err = downloader.SearchTrackByMetadataWithDuration(req.TrackName, req.ArtistName, expectedDurationSec)
-		// Verify artist (title already verified in SearchTrackByMetadataWithDuration)
 		if track != nil && !qobuzArtistsMatch(req.ArtistName, track.Performer.Name) {
 			GoLog("[Qobuz] Artist mismatch from metadata search: expected '%s', got '%s'. Rejecting.\n",
 				req.ArtistName, track.Performer.Name)
@@ -991,7 +1167,6 @@ func downloadFromQobuz(req DownloadRequest) (QobuzDownloadResult, error) {
 		return QobuzDownloadResult{}, fmt.Errorf("qobuz search failed: %s", errMsg)
 	}

-	// Log match found and cache the track ID
 	GoLog("[Qobuz] Match found: '%s' by '%s' (duration: %ds)\n", track.Title, track.Performer.Name, track.Duration)
 	if req.ISRC != "" {
 		GetTrackIDCache().SetQobuz(req.ISRC, track.ID)
@@ -1005,29 +1180,33 @@ func downloadFromQobuz(req DownloadRequest) (QobuzDownloadResult, error) {
 		"year":   extractYear(req.ReleaseDate),
 		"disc":   req.DiscNumber,
 	})
-	filename = sanitizeFilename(filename) + ".flac"
-	outputPath := filepath.Join(req.OutputDir, filename)
-
-	if fileInfo, statErr := os.Stat(outputPath); statErr == nil && fileInfo.Size() > 0 {
-		return QobuzDownloadResult{FilePath: "EXISTS:" + outputPath}, nil
+	var outputPath string
+	if isSafOutput {
+		outputPath = strings.TrimSpace(req.OutputPath)
+		if outputPath == "" && isFDOutput(req.OutputFD) {
+			outputPath = fmt.Sprintf("/proc/self/fd/%d", req.OutputFD)
+		}
+	} else {
+		filename = sanitizeFilename(filename) + ".flac"
+		outputPath = filepath.Join(req.OutputDir, filename)
+		if fileInfo, statErr := os.Stat(outputPath); statErr == nil && fileInfo.Size() > 0 {
+			return QobuzDownloadResult{FilePath: "EXISTS:" + outputPath}, nil
+		}
 	}

-	// Map quality from Tidal format to Qobuz format
-	// Tidal: LOSSLESS (16-bit), HI_RES (24-bit), HI_RES_LOSSLESS (24-bit hi-res)
-	// Qobuz: 5 (MP3 320), 6 (16-bit), 7 (24-bit 96kHz), 27 (24-bit 192kHz)
-	qobuzQuality := "27" // Default to highest quality
+	qobuzQuality := "27"
 	switch req.Quality {
 	case "LOSSLESS":
-		qobuzQuality = "6" // 16-bit FLAC
+		qobuzQuality = "6"
 	case "HI_RES":
-		qobuzQuality = "7" // 24-bit 96kHz
+		qobuzQuality = "7"
 	case "HI_RES_LOSSLESS":
-		qobuzQuality = "27" // 24-bit 192kHz
+		qobuzQuality = "27"
 	}
 	GoLog("[Qobuz] Using quality: %s (mapped from %s)\n", qobuzQuality, req.Quality)

 	actualBitDepth := track.MaximumBitDepth
-	actualSampleRate := int(track.MaximumSamplingRate * 1000) // Convert kHz to Hz
+	actualSampleRate := int(track.MaximumSamplingRate * 1000)
 	GoLog("[Qobuz] Actual quality: %d-bit/%.1fkHz\n", actualBitDepth, track.MaximumSamplingRate)

 	downloadURL, err := downloader.GetDownloadURL(track.ID, qobuzQuality)
@@ -1035,7 +1214,6 @@ func downloadFromQobuz(req DownloadRequest) (QobuzDownloadResult, error) {
 		return QobuzDownloadResult{}, fmt.Errorf("failed to get download URL: %w", err)
 	}

-	// START PARALLEL: Fetch cover and lyrics while downloading audio
 	var parallelResult *ParallelDownloadResult
 	parallelDone := make(chan struct{})
 	go func() {
@@ -1051,15 +1229,13 @@ func downloadFromQobuz(req DownloadRequest) (QobuzDownloadResult, error) {
 		)
 	}()

-	// Download audio file with item ID for progress tracking
-	if err := downloader.DownloadFile(downloadURL, outputPath, req.ItemID); err != nil {
+	if err := downloader.DownloadFile(downloadURL, outputPath, req.OutputFD, req.ItemID); err != nil {
 		if errors.Is(err, ErrDownloadCancelled) {
 			return QobuzDownloadResult{}, ErrDownloadCancelled
 		}
 		return QobuzDownloadResult{}, fmt.Errorf("download failed: %w", err)
 	}

-	// Wait for parallel operations to complete
 	<-parallelDone

 	if req.ItemID != "" {
@@ -1072,7 +1248,6 @@ func downloadFromQobuz(req DownloadRequest) (QobuzDownloadResult, error) {
 		albumName = req.AlbumName
 	}

-	// Use track number from request if available, otherwise from Qobuz API
 	actualTrackNumber := req.TrackNumber
 	if actualTrackNumber == 0 {
 		actualTrackNumber = track.TrackNumber
@@ -1082,15 +1257,15 @@ func downloadFromQobuz(req DownloadRequest) (QobuzDownloadResult, error) {
 		Title:       track.Title,
 		Artist:      track.Performer.Name,
 		Album:       albumName,
-		AlbumArtist: req.AlbumArtist, // Qobuz track struct might not have this handy, keep req or check album struct
+		AlbumArtist: req.AlbumArtist,
 		Date:        track.Album.ReleaseDate,
 		TrackNumber: actualTrackNumber,
 		TotalTracks: req.TotalTracks,
-		DiscNumber:  req.DiscNumber, // QobuzTrack struct usually doesn't have disc info in simple search result
+		DiscNumber:  req.DiscNumber,
 		ISRC:        track.ISRC,
-		Genre:       req.Genre,     // From Deezer album metadata
-		Label:       req.Label,     // From Deezer album metadata
-		Copyright:   req.Copyright, // From Deezer album metadata
+		Genre:       req.Genre,
+		Label:       req.Label,
+		Copyright:   req.Copyright,
 	}

 	var coverData []byte
@@ -1099,40 +1274,50 @@ func downloadFromQobuz(req DownloadRequest) (QobuzDownloadResult, error) {
 		GoLog("[Qobuz] Using parallel-fetched cover (%d bytes)\n", len(coverData))
 	}

-	if err := EmbedMetadataWithCoverData(outputPath, metadata, coverData); err != nil {
-		fmt.Printf("Warning: failed to embed metadata: %v\n", err)
+	if isSafOutput {
+		GoLog("[Qobuz] SAF output detected - skipping in-backend metadata/lyrics embedding (handled in Flutter)\n")
+	} else {
+		if err := EmbedMetadataWithCoverData(outputPath, metadata, coverData); err != nil {
+			fmt.Printf("Warning: failed to embed metadata: %v\n", err)
+		}
+
+		if req.EmbedLyrics && parallelResult != nil && parallelResult.LyricsLRC != "" {
+			lyricsMode := req.LyricsMode
+			if lyricsMode == "" {
+				lyricsMode = "embed"
+			}
+
+			if lyricsMode == "external" || lyricsMode == "both" {
+				GoLog("[Qobuz] Saving external LRC file...\n")
+				if lrcPath, lrcErr := SaveLRCFile(outputPath, parallelResult.LyricsLRC); lrcErr != nil {
+					GoLog("[Qobuz] Warning: failed to save LRC file: %v\n", lrcErr)
+				} else {
+					GoLog("[Qobuz] LRC file saved: %s\n", lrcPath)
+				}
+			}
+
+			if lyricsMode == "embed" || lyricsMode == "both" {
+				GoLog("[Qobuz] Embedding parallel-fetched lyrics (%d lines)...\n", len(parallelResult.LyricsData.Lines))
+				if embedErr := EmbedLyrics(outputPath, parallelResult.LyricsLRC); embedErr != nil {
+					GoLog("[Qobuz] Warning: failed to embed lyrics: %v\n", embedErr)
+				} else {
+					fmt.Println("[Qobuz] Lyrics embedded successfully")
+				}
+			}
+		} else if req.EmbedLyrics {
+			fmt.Println("[Qobuz] No lyrics available from parallel fetch")
+		}
 	}

+	if !isSafOutput {
+		AddToISRCIndex(req.OutputDir, req.ISRC, outputPath)
+	}
+
+	lyricsLRC := ""
 	if req.EmbedLyrics && parallelResult != nil && parallelResult.LyricsLRC != "" {
-		lyricsMode := req.LyricsMode
-		if lyricsMode == "" {
-			lyricsMode = "embed"
-		}
-
-		if lyricsMode == "external" || lyricsMode == "both" {
-			GoLog("[Qobuz] Saving external LRC file...\n")
-			if lrcPath, lrcErr := SaveLRCFile(outputPath, parallelResult.LyricsLRC); lrcErr != nil {
-				GoLog("[Qobuz] Warning: failed to save LRC file: %v\n", lrcErr)
-			} else {
-				GoLog("[Qobuz] LRC file saved: %s\n", lrcPath)
-			}
-		}
-
-		if lyricsMode == "embed" || lyricsMode == "both" {
-			GoLog("[Qobuz] Embedding parallel-fetched lyrics (%d lines)...\n", len(parallelResult.LyricsData.Lines))
-			if embedErr := EmbedLyrics(outputPath, parallelResult.LyricsLRC); embedErr != nil {
-				GoLog("[Qobuz] Warning: failed to embed lyrics: %v\n", embedErr)
-			} else {
-				fmt.Println("[Qobuz] Lyrics embedded successfully")
-			}
-		}
-	} else if req.EmbedLyrics {
-		fmt.Println("[Qobuz] No lyrics available from parallel fetch")
+		lyricsLRC = parallelResult.LyricsLRC
 	}

-	// Add to ISRC index for fast duplicate checking
-	AddToISRCIndex(req.OutputDir, req.ISRC, outputPath)
-
 	return QobuzDownloadResult{
 		FilePath:    outputPath,
 		BitDepth:    actualBitDepth,
@@ -1142,7 +1327,8 @@ func downloadFromQobuz(req DownloadRequest) (QobuzDownloadResult, error) {
 		Album:       track.Album.Title,
 		ReleaseDate: track.Album.ReleaseDate,
 		TrackNumber: actualTrackNumber,
-		DiscNumber:  req.DiscNumber, // Qobuz track struct limitations
+		DiscNumber:  req.DiscNumber,
 		ISRC:        track.ISRC,
+		LyricsLRC:   lyricsLRC,
 	}, nil
 }
@@ -0,0 +1,47 @@
+package gobackend
+
+import "testing"
+
+func TestExtractQobuzDownloadURLFromBody(t *testing.T) {
+	t.Run("reads nested data.url", func(t *testing.T) {
+		body := []byte(`{"success":true,"data":{"url":"https://example.test/audio.flac"}}`)
+
+		got, err := extractQobuzDownloadURLFromBody(body)
+		if err != nil {
+			t.Fatalf("expected no error, got %v", err)
+		}
+		if got != "https://example.test/audio.flac" {
+			t.Fatalf("unexpected URL: %q", got)
+		}
+	})
+
+	t.Run("reads top-level url", func(t *testing.T) {
+		body := []byte(`{"url":"https://example.test/top.flac"}`)
+
+		got, err := extractQobuzDownloadURLFromBody(body)
+		if err != nil {
+			t.Fatalf("expected no error, got %v", err)
+		}
+		if got != "https://example.test/top.flac" {
+			t.Fatalf("unexpected URL: %q", got)
+		}
+	})
+
+	t.Run("returns API error", func(t *testing.T) {
+		body := []byte(`{"error":"track not found"}`)
+
+		_, err := extractQobuzDownloadURLFromBody(body)
+		if err == nil || err.Error() != "track not found" {
+			t.Fatalf("expected track-not-found error, got %v", err)
+		}
+	})
+
+	t.Run("returns message when success false", func(t *testing.T) {
+		body := []byte(`{"success":false,"message":"blocked"}`)
+
+		_, err := extractQobuzDownloadURLFromBody(body)
+		if err == nil || err.Error() != "blocked" {
+			t.Fatalf("expected blocked error, got %v", err)
+		}
+	})
+}
@@ -8,7 +8,6 @@ import (
 	"net/url"
 	"strings"
 	"sync"
-	"time"
 )

 type SongLinkClient struct {
@@ -16,16 +15,21 @@ type SongLinkClient struct {
 }

 type TrackAvailability struct {
-	SpotifyID string `json:"spotify_id"`
-	Tidal     bool   `json:"tidal"`
-	Amazon    bool   `json:"amazon"`
-	Qobuz     bool   `json:"qobuz"`
-	Deezer    bool   `json:"deezer"`
-	TidalURL  string `json:"tidal_url,omitempty"`
-	AmazonURL string `json:"amazon_url,omitempty"`
-	QobuzURL  string `json:"qobuz_url,omitempty"`
-	DeezerURL string `json:"deezer_url,omitempty"`
-	DeezerID  string `json:"deezer_id,omitempty"`
+	SpotifyID  string `json:"spotify_id"`
+	Tidal      bool   `json:"tidal"`
+	Amazon     bool   `json:"amazon"`
+	Qobuz      bool   `json:"qobuz"`
+	Deezer     bool   `json:"deezer"`
+	YouTube    bool   `json:"youtube"`
+	TidalURL   string `json:"tidal_url,omitempty"`
+	AmazonURL  string `json:"amazon_url,omitempty"`
+	QobuzURL   string `json:"qobuz_url,omitempty"`
+	DeezerURL  string `json:"deezer_url,omitempty"`
+	YouTubeURL string `json:"youtube_url,omitempty"`
+	DeezerID   string `json:"deezer_id,omitempty"`
+	QobuzID    string `json:"qobuz_id,omitempty"`
+	TidalID    string `json:"tidal_id,omitempty"`
+	YouTubeID  string `json:"youtube_id,omitempty"`
 }

 var (
@@ -36,17 +40,13 @@ var (
 func NewSongLinkClient() *SongLinkClient {
 	songLinkClientOnce.Do(func() {
 		globalSongLinkClient = &SongLinkClient{
-			client: NewHTTPClientWithTimeout(SongLinkTimeout),
+			client: NewMetadataHTTPClient(SongLinkTimeout),
 		}
 	})
 	return globalSongLinkClient
 }

 func (s *SongLinkClient) CheckTrackAvailability(spotifyTrackID string, isrc string) (*TrackAvailability, error) {
-	if spotifyTrackID == "" {
-		return nil, fmt.Errorf("spotify track ID is empty")
-	}
-	
 	songLinkRateLimiter.WaitForSlot()

 	spotifyBase, _ := base64.StdEncoding.DecodeString("aHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLw==")
@@ -102,6 +102,7 @@ func (s *SongLinkClient) CheckTrackAvailability(spotifyTrackID string, isrc stri
 	if tidalLink, ok := songLinkResp.LinksByPlatform["tidal"]; ok && tidalLink.URL != "" {
 		availability.Tidal = true
 		availability.TidalURL = tidalLink.URL
+		availability.TidalID = extractTidalIDFromURL(tidalLink.URL)
 	}

 	if amazonLink, ok := songLinkResp.LinksByPlatform["amazonMusic"]; ok && amazonLink.URL != "" {
@@ -115,8 +116,26 @@ func (s *SongLinkClient) CheckTrackAvailability(spotifyTrackID string, isrc stri
 		availability.DeezerID = extractDeezerIDFromURL(deezerLink.URL)
 	}

-	if isrc != "" {
-		availability.Qobuz = checkQobuzAvailability(isrc)
+	if qobuzLink, ok := songLinkResp.LinksByPlatform["qobuz"]; ok && qobuzLink.URL != "" {
+		availability.Qobuz = true
+		availability.QobuzURL = qobuzLink.URL
+		availability.QobuzID = extractQobuzIDFromURL(qobuzLink.URL)
+	}
+
+	// Prefer youtubeMusic URLs — they bypass Cobalt login requirements
+	if ytMusicLink, ok := songLinkResp.LinksByPlatform["youtubeMusic"]; ok && ytMusicLink.URL != "" {
+		availability.YouTube = true
+		availability.YouTubeURL = ytMusicLink.URL
+		availability.YouTubeID = extractYouTubeIDFromURL(ytMusicLink.URL)
+	}
+
+	// Fallback to regular youtube if youtubeMusic not available
+	if !availability.YouTube {
+		if youtubeLink, ok := songLinkResp.LinksByPlatform["youtube"]; ok && youtubeLink.URL != "" {
+			availability.YouTube = true
+			availability.YouTubeURL = youtubeLink.URL
+			availability.YouTubeID = extractYouTubeIDFromURL(youtubeLink.URL)
+		}
 	}

 	return availability, nil
@@ -139,40 +158,6 @@ func (s *SongLinkClient) GetStreamingURLs(spotifyTrackID string) (map[string]str
 	return urls, nil
 }

-func checkQobuzAvailability(isrc string) bool {
-	client := NewHTTPClientWithTimeout(10 * time.Second)
-	appID := "798273057"
-
-	apiBase, _ := base64.StdEncoding.DecodeString("aHR0cHM6Ly93d3cucW9idXouY29tL2FwaS5qc29uLzAuMi90cmFjay9zZWFyY2g/cXVlcnk9")
-	searchURL := fmt.Sprintf("%s%s&limit=1&app_id=%s", string(apiBase), isrc, appID)
-
-	req, err := http.NewRequest("GET", searchURL, nil)
-	if err != nil {
-		return false
-	}
-
-	resp, err := DoRequestWithUserAgent(client, req)
-	if err != nil {
-		return false
-	}
-	defer resp.Body.Close()
-
-	if resp.StatusCode != 200 {
-		return false
-	}
-
-	var searchResp struct {
-		Tracks struct {
-			Total int `json:"total"`
-		} `json:"tracks"`
-	}
-	if err := json.NewDecoder(resp.Body).Decode(&searchResp); err != nil {
-		return false
-	}
-
-	return searchResp.Tracks.Total > 0
-}
-
 // extractDeezerIDFromURL extracts Deezer track/album/artist ID from URL
 func extractDeezerIDFromURL(deezerURL string) string {
 	parts := strings.Split(deezerURL, "/")
@@ -186,19 +171,175 @@ func extractDeezerIDFromURL(deezerURL string) string {
 	return ""
 }

+// extractQobuzIDFromURL extracts Qobuz track ID from URL
+// URL formats:
+//   - https://www.qobuz.com/us-en/album/.../12345678 (album page with track highlight)
+//   - https://open.qobuz.com/track/12345678
+//   - https://www.qobuz.com/track/12345678
+//   - https://play.qobuz.com/track/12345678
+func extractQobuzIDFromURL(qobuzURL string) string {
+	if qobuzURL == "" {
+		return ""
+	}
+
+	// Try to find /track/ID pattern first
+	if strings.Contains(qobuzURL, "/track/") {
+		parts := strings.Split(qobuzURL, "/track/")
+		if len(parts) > 1 {
+			idPart := parts[1]
+			// Remove query parameters
+			if idx := strings.Index(idPart, "?"); idx > 0 {
+				idPart = idPart[:idx]
+			}
+			// Remove trailing slash or path
+			if idx := strings.Index(idPart, "/"); idx > 0 {
+				idPart = idPart[:idx]
+			}
+			idPart = strings.TrimSpace(idPart)
+			// Validate it's a number
+			if idPart != "" && isNumeric(idPart) {
+				return idPart
+			}
+		}
+	}
+
+	// Try to extract from album URL with track highlight
+	// Format: /album/albumname/trackid or ?trackId=12345678
+	if strings.Contains(qobuzURL, "trackId=") {
+		parts := strings.Split(qobuzURL, "trackId=")
+		if len(parts) > 1 {
+			idPart := parts[1]
+			if idx := strings.Index(idPart, "&"); idx > 0 {
+				idPart = idPart[:idx]
+			}
+			idPart = strings.TrimSpace(idPart)
+			if idPart != "" && isNumeric(idPart) {
+				return idPart
+			}
+		}
+	}
+
+	// Last resort: get last numeric segment from URL
+	parts := strings.Split(qobuzURL, "/")
+	for i := len(parts) - 1; i >= 0; i-- {
+		part := parts[i]
+		// Remove query parameters
+		if idx := strings.Index(part, "?"); idx > 0 {
+			part = part[:idx]
+		}
+		part = strings.TrimSpace(part)
+		if part != "" && isNumeric(part) {
+			return part
+		}
+	}
+
+	return ""
+}
+
+// extractTidalIDFromURL extracts Tidal track ID from URL
+// URL formats:
+//   - https://tidal.com/browse/track/12345678
+//   - https://listen.tidal.com/track/12345678
+func extractTidalIDFromURL(tidalURL string) string {
+	if tidalURL == "" {
+		return ""
+	}
+
+	if strings.Contains(tidalURL, "/track/") {
+		parts := strings.Split(tidalURL, "/track/")
+		if len(parts) > 1 {
+			idPart := parts[1]
+			if idx := strings.Index(idPart, "?"); idx > 0 {
+				idPart = idPart[:idx]
+			}
+			if idx := strings.Index(idPart, "/"); idx > 0 {
+				idPart = idPart[:idx]
+			}
+			idPart = strings.TrimSpace(idPart)
+			if idPart != "" && isNumeric(idPart) {
+				return idPart
+			}
+		}
+	}
+
+	return ""
+}
+
+// extractYouTubeIDFromURL extracts YouTube video ID from URL
+// URL formats:
+//   - https://www.youtube.com/watch?v=VIDEO_ID
+//   - https://youtu.be/VIDEO_ID
+//   - https://music.youtube.com/watch?v=VIDEO_ID
+func extractYouTubeIDFromURL(youtubeURL string) string {
+	if youtubeURL == "" {
+		return ""
+	}
+
+	// Handle youtu.be short URLs
+	if strings.Contains(youtubeURL, "youtu.be/") {
+		parts := strings.Split(youtubeURL, "youtu.be/")
+		if len(parts) >= 2 {
+			idPart := parts[1]
+			if idx := strings.Index(idPart, "?"); idx > 0 {
+				idPart = idPart[:idx]
+			}
+			if idx := strings.Index(idPart, "&"); idx > 0 {
+				idPart = idPart[:idx]
+			}
+			return strings.TrimSpace(idPart)
+		}
+	}
+
+	// Handle youtube.com URLs with ?v= parameter
+	parsed, err := url.Parse(youtubeURL)
+	if err != nil {
+		return ""
+	}
+
+	if v := parsed.Query().Get("v"); v != "" {
+		return v
+	}
+
+	// Handle /embed/ format
+	if strings.Contains(parsed.Path, "/embed/") {
+		parts := strings.Split(parsed.Path, "/embed/")
+		if len(parts) >= 2 {
+			return strings.Split(parts[1], "/")[0]
+		}
+	}
+
+	return ""
+}
+
+// isNumeric is defined in library_scan.go
+
 func (s *SongLinkClient) GetDeezerIDFromSpotify(spotifyTrackID string) (string, error) {
 	availability, err := s.CheckTrackAvailability(spotifyTrackID, "")
 	if err != nil {
 		return "", err
 	}
-	
+
 	if !availability.Deezer || availability.DeezerID == "" {
 		return "", fmt.Errorf("track not found on Deezer")
 	}
-	
+
 	return availability.DeezerID, nil
 }

+// GetYouTubeURLFromSpotify converts a Spotify track ID to YouTube URL using SongLink
+func (s *SongLinkClient) GetYouTubeURLFromSpotify(spotifyTrackID string) (string, error) {
+	availability, err := s.CheckTrackAvailability(spotifyTrackID, "")
+	if err != nil {
+		return "", err
+	}
+
+	if !availability.YouTube || availability.YouTubeURL == "" {
+		return "", fmt.Errorf("track not found on YouTube")
+	}
+
+	return availability.YouTubeURL, nil
+}
+
 // AlbumAvailability represents album availability on different platforms
 type AlbumAvailability struct {
 	SpotifyID string `json:"spotify_id"`
@@ -208,10 +349,8 @@ type AlbumAvailability struct {
 }

 func (s *SongLinkClient) CheckAlbumAvailability(spotifyAlbumID string) (*AlbumAvailability, error) {
-	// Use global rate limiter
 	songLinkRateLimiter.WaitForSlot()

-	// Build API URL for album
 	spotifyBase, _ := base64.StdEncoding.DecodeString("aHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLw==")
 	spotifyURL := fmt.Sprintf("%s%s", string(spotifyBase), spotifyAlbumID)

@@ -268,11 +407,11 @@ func (s *SongLinkClient) GetDeezerAlbumIDFromSpotify(spotifyAlbumID string) (str
 	if err != nil {
 		return "", err
 	}
-	
+
 	if !availability.Deezer || availability.DeezerID == "" {
 		return "", fmt.Errorf("album not found on Deezer")
 	}
-	
+
 	return availability.DeezerID, nil
 }

@@ -281,7 +420,23 @@ func (s *SongLinkClient) CheckAvailabilityFromDeezer(deezerTrackID string) (*Tra
 	if deezerTrackID == "" {
 		return nil, fmt.Errorf("deezer track ID is empty")
 	}
-	
+
+	availability, err := s.checkAvailabilityFromDeezerSongLink(deezerTrackID)
+	if err != nil {
+		LogWarn("SongLink", "SongLink failed for Deezer, trying IDHS fallback: %v", err)
+		idhsClient := NewIDHSClient()
+		availability, err = idhsClient.GetAvailabilityFromDeezer(deezerTrackID)
+		if err != nil {
+			return nil, fmt.Errorf("both SongLink and IDHS failed: %w", err)
+		}
+		LogInfo("SongLink", "IDHS fallback successful for Deezer %s", deezerTrackID)
+	}
+
+	return availability, nil
+}
+
+// checkAvailabilityFromDeezerSongLink is the original SongLink implementation for Deezer
+func (s *SongLinkClient) checkAvailabilityFromDeezerSongLink(deezerTrackID string) (*TrackAvailability, error) {
 	songLinkRateLimiter.WaitForSlot()

 	deezerURL := fmt.Sprintf("https://www.deezer.com/track/%s", deezerTrackID)
@@ -301,7 +456,6 @@ func (s *SongLinkClient) CheckAvailabilityFromDeezer(deezerTrackID string) (*Tra
 	}
 	defer resp.Body.Close()

-	// Handle specific error codes
 	if resp.StatusCode == 400 {
 		return nil, fmt.Errorf("track not found on SongLink (invalid Deezer ID)")
 	}
@@ -348,6 +502,7 @@ func (s *SongLinkClient) CheckAvailabilityFromDeezer(deezerTrackID string) (*Tra
 	if tidalLink, ok := songLinkResp.LinksByPlatform["tidal"]; ok && tidalLink.URL != "" {
 		availability.Tidal = true
 		availability.TidalURL = tidalLink.URL
+		availability.TidalID = extractTidalIDFromURL(tidalLink.URL)
 	}

 	if amazonLink, ok := songLinkResp.LinksByPlatform["amazonMusic"]; ok && amazonLink.URL != "" {
@@ -355,10 +510,29 @@ func (s *SongLinkClient) CheckAvailabilityFromDeezer(deezerTrackID string) (*Tra
 		availability.AmazonURL = amazonLink.URL
 	}

+	if qobuzLink, ok := songLinkResp.LinksByPlatform["qobuz"]; ok && qobuzLink.URL != "" {
+		availability.Qobuz = true
+		availability.QobuzURL = qobuzLink.URL
+		availability.QobuzID = extractQobuzIDFromURL(qobuzLink.URL)
+	}
+
 	if deezerLink, ok := songLinkResp.LinksByPlatform["deezer"]; ok && deezerLink.URL != "" {
 		availability.DeezerURL = deezerLink.URL
 	}

+	if youtubeLink, ok := songLinkResp.LinksByPlatform["youtube"]; ok && youtubeLink.URL != "" {
+		availability.YouTube = true
+		availability.YouTubeURL = youtubeLink.URL
+		availability.YouTubeID = extractYouTubeIDFromURL(youtubeLink.URL)
+	}
+	if !availability.YouTube {
+		if ytMusicLink, ok := songLinkResp.LinksByPlatform["youtubeMusic"]; ok && ytMusicLink.URL != "" {
+			availability.YouTube = true
+			availability.YouTubeURL = ytMusicLink.URL
+			availability.YouTubeID = extractYouTubeIDFromURL(ytMusicLink.URL)
+		}
+	}
+
 	return availability, nil
 }

@@ -369,12 +543,9 @@ func (s *SongLinkClient) CheckAvailabilityByPlatform(platform, entityType, entit
 	if entityID == "" {
 		return nil, fmt.Errorf("%s ID is empty", platform)
 	}
-	
-	// Use global rate limiter
+
 	songLinkRateLimiter.WaitForSlot()

-	// Build API URL using platform, type, and id parameters (as per API docs)
-	// https://api.song.link/v1-alpha.1/links?platform=deezer&type=song&id=123456
 	apiURL := fmt.Sprintf("https://api.song.link/v1-alpha.1/links?platform=%s&type=%s&id=%s&userCountry=US",
 		url.QueryEscape(platform),
 		url.QueryEscape(entityType),
@@ -392,7 +563,6 @@ func (s *SongLinkClient) CheckAvailabilityByPlatform(platform, entityType, entit
 	}
 	defer resp.Body.Close()

-	// Handle specific error codes
 	if resp.StatusCode == 400 {
 		return nil, fmt.Errorf("track not found on SongLink (invalid %s ID)", platform)
 	}
@@ -430,6 +600,7 @@ func (s *SongLinkClient) CheckAvailabilityByPlatform(platform, entityType, entit
 	if tidalLink, ok := songLinkResp.LinksByPlatform["tidal"]; ok && tidalLink.URL != "" {
 		availability.Tidal = true
 		availability.TidalURL = tidalLink.URL
+		availability.TidalID = extractTidalIDFromURL(tidalLink.URL)
 	}

 	if amazonLink, ok := songLinkResp.LinksByPlatform["amazonMusic"]; ok && amazonLink.URL != "" {
@@ -437,12 +608,31 @@ func (s *SongLinkClient) CheckAvailabilityByPlatform(platform, entityType, entit
 		availability.AmazonURL = amazonLink.URL
 	}

+	if qobuzLink, ok := songLinkResp.LinksByPlatform["qobuz"]; ok && qobuzLink.URL != "" {
+		availability.Qobuz = true
+		availability.QobuzURL = qobuzLink.URL
+		availability.QobuzID = extractQobuzIDFromURL(qobuzLink.URL)
+	}
+
 	if deezerLink, ok := songLinkResp.LinksByPlatform["deezer"]; ok && deezerLink.URL != "" {
 		availability.Deezer = true
 		availability.DeezerURL = deezerLink.URL
 		availability.DeezerID = extractDeezerIDFromURL(deezerLink.URL)
 	}

+	if youtubeLink, ok := songLinkResp.LinksByPlatform["youtube"]; ok && youtubeLink.URL != "" {
+		availability.YouTube = true
+		availability.YouTubeURL = youtubeLink.URL
+		availability.YouTubeID = extractYouTubeIDFromURL(youtubeLink.URL)
+	}
+	if !availability.YouTube {
+		if ytMusicLink, ok := songLinkResp.LinksByPlatform["youtubeMusic"]; ok && ytMusicLink.URL != "" {
+			availability.YouTube = true
+			availability.YouTubeURL = ytMusicLink.URL
+			availability.YouTubeID = extractYouTubeIDFromURL(ytMusicLink.URL)
+		}
+	}
+
 	return availability, nil
 }

@@ -464,11 +654,11 @@ func (s *SongLinkClient) GetSpotifyIDFromDeezer(deezerTrackID string) (string, e
 	if err != nil {
 		return "", err
 	}
-	
+
 	if availability.SpotifyID == "" {
 		return "", fmt.Errorf("track not found on Spotify")
 	}
-	
+
 	return availability.SpotifyID, nil
 }

@@ -478,11 +668,11 @@ func (s *SongLinkClient) GetTidalURLFromDeezer(deezerTrackID string) (string, er
 	if err != nil {
 		return "", err
 	}
-	
+
 	if !availability.Tidal || availability.TidalURL == "" {
 		return "", fmt.Errorf("track not found on Tidal")
 	}
-	
+
 	return availability.TidalURL, nil
 }

@@ -491,10 +681,108 @@ func (s *SongLinkClient) GetAmazonURLFromDeezer(deezerTrackID string) (string, e
 	if err != nil {
 		return "", err
 	}
-	
+
 	if !availability.Amazon || availability.AmazonURL == "" {
 		return "", fmt.Errorf("track not found on Amazon Music")
 	}
-	
+
 	return availability.AmazonURL, nil
 }
+
+// GetYouTubeURLFromDeezer converts a Deezer track ID to YouTube URL using SongLink
+func (s *SongLinkClient) GetYouTubeURLFromDeezer(deezerTrackID string) (string, error) {
+	availability, err := s.CheckAvailabilityFromDeezer(deezerTrackID)
+	if err != nil {
+		return "", err
+	}
+
+	if !availability.YouTube || availability.YouTubeURL == "" {
+		return "", fmt.Errorf("track not found on YouTube")
+	}
+
+	return availability.YouTubeURL, nil
+}
+
+func (s *SongLinkClient) CheckAvailabilityFromURL(inputURL string) (*TrackAvailability, error) {
+	songLinkRateLimiter.WaitForSlot()
+
+	apiBase, _ := base64.StdEncoding.DecodeString("aHR0cHM6Ly9hcGkuc29uZy5saW5rL3YxLWFscGhhLjEvbGlua3M/dXJsPQ==")
+	apiURL := fmt.Sprintf("%s%s", string(apiBase), url.QueryEscape(inputURL))
+
+	req, err := http.NewRequest("GET", apiURL, nil)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create request: %w", err)
+	}
+
+	retryConfig := DefaultRetryConfig()
+	resp, err := DoRequestWithRetry(s.client, req, retryConfig)
+	if err != nil {
+		return nil, fmt.Errorf("failed to check availability: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode == 400 || resp.StatusCode == 404 {
+		return nil, fmt.Errorf("track not found on SongLink")
+	}
+	if resp.StatusCode == 429 {
+		return nil, fmt.Errorf("SongLink rate limit exceeded")
+	}
+	if resp.StatusCode != 200 {
+		return nil, fmt.Errorf("SongLink API returned status %d", resp.StatusCode)
+	}
+
+	body, err := ReadResponseBody(resp)
+	if err != nil {
+		return nil, fmt.Errorf("failed to read response: %w", err)
+	}
+
+	var songLinkResp struct {
+		LinksByPlatform map[string]struct {
+			URL      string `json:"url"`
+			EntityID string `json:"entityUniqueId"`
+		} `json:"linksByPlatform"`
+	}
+
+	if err := json.Unmarshal(body, &songLinkResp); err != nil {
+		return nil, fmt.Errorf("failed to decode response: %w", err)
+	}
+
+	availability := &TrackAvailability{}
+
+	if spotifyLink, ok := songLinkResp.LinksByPlatform["spotify"]; ok && spotifyLink.URL != "" {
+		availability.SpotifyID = extractSpotifyIDFromURL(spotifyLink.URL)
+	}
+	if tidalLink, ok := songLinkResp.LinksByPlatform["tidal"]; ok && tidalLink.URL != "" {
+		availability.Tidal = true
+		availability.TidalURL = tidalLink.URL
+		availability.TidalID = extractTidalIDFromURL(tidalLink.URL)
+	}
+	if amazonLink, ok := songLinkResp.LinksByPlatform["amazonMusic"]; ok && amazonLink.URL != "" {
+		availability.Amazon = true
+		availability.AmazonURL = amazonLink.URL
+	}
+	if qobuzLink, ok := songLinkResp.LinksByPlatform["qobuz"]; ok && qobuzLink.URL != "" {
+		availability.Qobuz = true
+		availability.QobuzURL = qobuzLink.URL
+		availability.QobuzID = extractQobuzIDFromURL(qobuzLink.URL)
+	}
+	if deezerLink, ok := songLinkResp.LinksByPlatform["deezer"]; ok && deezerLink.URL != "" {
+		availability.Deezer = true
+		availability.DeezerURL = deezerLink.URL
+		availability.DeezerID = extractDeezerIDFromURL(deezerLink.URL)
+	}
+	if youtubeLink, ok := songLinkResp.LinksByPlatform["youtube"]; ok && youtubeLink.URL != "" {
+		availability.YouTube = true
+		availability.YouTubeURL = youtubeLink.URL
+		availability.YouTubeID = extractYouTubeIDFromURL(youtubeLink.URL)
+	}
+	if !availability.YouTube {
+		if ytMusicLink, ok := songLinkResp.LinksByPlatform["youtubeMusic"]; ok && ytMusicLink.URL != "" {
+			availability.YouTube = true
+			availability.YouTubeURL = ytMusicLink.URL
+			availability.YouTubeID = extractYouTubeIDFromURL(ytMusicLink.URL)
+		}
+	}
+
+	return availability, nil
+}
@@ -63,10 +63,8 @@ var (
 	credentialsMu      sync.RWMutex
 )

-// ErrNoSpotifyCredentials is returned when Spotify credentials are not configured
 var ErrNoSpotifyCredentials = errors.New("Spotify credentials not configured. Please set your own Client ID and Secret in Settings, or use Deezer as metadata source (free, no credentials required)")

-// SetSpotifyCredentials sets custom Spotify API credentials
 func SetSpotifyCredentials(clientID, clientSecret string) {
 	credentialsMu.Lock()
 	defer credentialsMu.Unlock()
@@ -89,7 +87,6 @@ func HasSpotifyCredentials() bool {
 	return false
 }

-// getCredentials returns the current credentials or error if not configured
 func getCredentials() (string, string, error) {
 	credentialsMu.RLock()
 	defer credentialsMu.RUnlock()
@@ -117,7 +114,7 @@ func NewSpotifyMetadataClient() (*SpotifyMetadataClient, error) {
 	src := rand.NewSource(time.Now().UnixNano())

 	c := &SpotifyMetadataClient{
-		httpClient:   NewHTTPClientWithTimeout(15 * time.Second),
+		httpClient:   NewMetadataHTTPClient(15 * time.Second),
 		clientID:     clientID,
 		clientSecret: clientSecret,
 		rng:          rand.New(src),
@@ -143,7 +140,7 @@ type TrackMetadata struct {
 	DiscNumber  int    `json:"disc_number,omitempty"`
 	ExternalURL string `json:"external_urls"`
 	ISRC        string `json:"isrc"`
-	AlbumType   string `json:"album_type,omitempty"` // album, single, ep, compilation
+	AlbumType   string `json:"album_type,omitempty"`
 }

 type AlbumTrackMetadata struct {
@@ -212,7 +209,7 @@ type ArtistAlbumMetadata struct {
 	ReleaseDate string `json:"release_date"`
 	TotalTracks int    `json:"total_tracks"`
 	Images      string `json:"images"`
-	AlbumType   string `json:"album_type"` // album, single, compilation
+	AlbumType   string `json:"album_type"`
 	Artists     string `json:"artists"`
 }

@@ -238,9 +235,29 @@ type SearchArtistResult struct {
 	Popularity int    `json:"popularity"`
 }

+type SearchAlbumResult struct {
+	ID          string `json:"id"`
+	Name        string `json:"name"`
+	Artists     string `json:"artists"`
+	Images      string `json:"images"`
+	ReleaseDate string `json:"release_date"`
+	TotalTracks int    `json:"total_tracks"`
+	AlbumType   string `json:"album_type"`
+}
+
+type SearchPlaylistResult struct {
+	ID          string `json:"id"`
+	Name        string `json:"name"`
+	Owner       string `json:"owner"`
+	Images      string `json:"images"`
+	TotalTracks int    `json:"total_tracks"`
+}
+
 type SearchAllResult struct {
-	Tracks  []TrackMetadata      `json:"tracks"`
-	Artists []SearchArtistResult `json:"artists"`
+	Tracks    []TrackMetadata        `json:"tracks"`
+	Artists   []SearchArtistResult   `json:"artists"`
+	Albums    []SearchAlbumResult    `json:"albums"`
+	Playlists []SearchPlaylistResult `json:"playlists"`
 }

 type spotifyURI struct {
@@ -514,7 +531,6 @@ func (c *SpotifyMetadataClient) fetchAlbum(ctx context.Context, albumID, token s

 	albumImage := firstImageURL(data.Images)

-	// Get first artist ID
 	var firstArtistId string
 	if len(data.Artists) > 0 {
 		firstArtistId = data.Artists[0].ID
@@ -547,7 +563,6 @@ func (c *SpotifyMetadataClient) fetchAlbum(ctx context.Context, albumID, token s

 	fmt.Printf("[Spotify] Album has %d tracks (total: %d)\n", len(allTrackItems), data.TotalTracks)

-	// Collect track IDs for parallel ISRC fetching
 	trackIDs := make([]string, len(allTrackItems))
 	for i, item := range allTrackItems {
 		trackIDs[i] = item.ID
@@ -919,14 +934,14 @@ func (c *SpotifyMetadataClient) randomUserAgent() string {
 	defer c.rngMu.Unlock()

 	macMajor := c.rng.Intn(4) + 11
-	macMinor := c.rng.Intn(5) + 4          // 4-8
-	webkitMajor := c.rng.Intn(7) + 530     // 530-536
-	webkitMinor := c.rng.Intn(7) + 30      // 30-36
-	chromeMajor := c.rng.Intn(25) + 80     // 80-104
-	chromeBuild := c.rng.Intn(1500) + 3000 // 3000-4499
-	chromePatch := c.rng.Intn(65) + 60     // 60-124
-	safariMajor := c.rng.Intn(7) + 530     // 530-536
-	safariMinor := c.rng.Intn(6) + 30      // 30-35
+	macMinor := c.rng.Intn(5) + 4
+	webkitMajor := c.rng.Intn(7) + 530
+	webkitMinor := c.rng.Intn(7) + 30
+	chromeMajor := c.rng.Intn(25) + 80
+	chromeBuild := c.rng.Intn(1500) + 3000
+	chromePatch := c.rng.Intn(65) + 60
+	safariMajor := c.rng.Intn(7) + 530
+	safariMinor := c.rng.Intn(6) + 30

 	return fmt.Sprintf(
 		"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_%d_%d) AppleWebKit/%d.%d (KHTML, like Gecko) Chrome/%d.0.%d.%d Safari/%d.%d",
@@ -119,17 +119,18 @@ func NewTidalDownloader() *TidalDownloader {
 	return globalTidalDownloader
 }

-// GetAvailableAPIs returns list of available Tidal APIs
 func (t *TidalDownloader) GetAvailableAPIs() []string {
 	encodedAPIs := []string{
-		"dGlkYWwua2lub3BsdXMub25saW5l",
-		"dGlkYWwtYXBpLmJpbmltdW0ub3Jn",
-		"dHJpdG9uLnNxdWlkLnd0Zg==",
-		"dm9nZWwucXFkbC5zaXRl",
-		"bWF1cy5xcWRsLnNpdGU=",
-		"aHVuZC5xcWRsLnNpdGU=",
-		"a2F0emUucXFkbC5zaXRl",
-		"d29sZi5xcWRsLnNpdGU=",
+		"dGlkYWwtYXBpLmJpbmltdW0ub3Jn",     // tidal-api.binimum.org (priority)
+		"dGlkYWwua2lub3BsdXMub25saW5l",     // tidal.kinoplus.online
+		"dHJpdG9uLnNxdWlkLnd0Zg==",         // triton.squid.wtf
+		"dm9nZWwucXFkbC5zaXRl",             // vogel.qqdl.site
+		"bWF1cy5xcWRsLnNpdGU=",             // maus.qqdl.site
+		"aHVuZC5xcWRsLnNpdGU=",             // hund.qqdl.site
+		"a2F0emUucXFkbC5zaXRl",             // katze.qqdl.site
+		"d29sZi5xcWRsLnNpdGU=",             // wolf.qqdl.site
+		"aGlmaS1vbmUuc3BvdGlzYXZlci5uZXQ=", // hifi-one.spotisaver.net
+		"aGlmaS10d28uc3BvdGlzYXZlci5uZXQ=", // hifi-two.spotisaver.net
 	}

 	var apis []string
@@ -249,7 +250,6 @@ func (t *TidalDownloader) GetTrackIDFromURL(tidalURL string) (int64, error) {
 	return trackID, nil
 }

-// GetTrackInfoByID gets track info by Tidal track ID
 func (t *TidalDownloader) GetTrackInfoByID(trackID int64) (*TidalTrack, error) {
 	token, err := t.GetAccessToken()
 	if err != nil {
@@ -317,7 +317,6 @@ func (t *TidalDownloader) SearchTrackByISRC(isrc string) (*TidalTrack, error) {
 		return nil, err
 	}

-	// Find exact ISRC match
 	for i := range result.Items {
 		if result.Items[i].ISRC == isrc {
 			return &result.Items[i], nil
@@ -341,7 +340,6 @@ func (t *TidalDownloader) SearchTrackByMetadataWithISRC(trackName, artistName, s
 	// Build search queries - multiple strategies (same as PC version)
 	queries := []string{}

-	// Strategy 1: Artist + Track name (original)
 	if artistName != "" && trackName != "" {
 		queries = append(queries, artistName+" "+trackName)
 	}
@@ -442,13 +440,13 @@ func (t *TidalDownloader) SearchTrackByMetadataWithISRC(trackName, artistName, s
 								durationDiff = -durationDiff
 							}
 							if durationDiff <= 3 {
-								GoLog("[Tidal] ✓ ISRC match: '%s' (duration verified)\n", track.Title)
+								GoLog("[Tidal] ISRC match: '%s' (duration verified)\n", track.Title)
 								return track, nil
 							}
 							GoLog("[Tidal] ISRC match but duration mismatch (expected %ds, got %ds), continuing...\n",
 								expectedDuration, track.Duration)
 						} else {
-							GoLog("[Tidal] ✓ ISRC match: '%s'\n", track.Title)
+							GoLog("[Tidal] ISRC match: '%s'\n", track.Title)
 							return track, nil
 						}
 					}
@@ -487,7 +485,7 @@ func (t *TidalDownloader) SearchTrackByMetadataWithISRC(trackName, artistName, s
 				}

 				if len(durationVerifiedMatches) > 0 {
-					GoLog("[Tidal] ✓ ISRC match with duration verification: '%s' (expected %ds, found %ds)\n",
+					GoLog("[Tidal] ISRC match with duration verification: '%s' (expected %ds, found %ds)\n",
 						durationVerifiedMatches[0].Title, expectedDuration, durationVerifiedMatches[0].Duration)
 					return durationVerifiedMatches[0], nil
 				}
@@ -498,11 +496,11 @@ func (t *TidalDownloader) SearchTrackByMetadataWithISRC(trackName, artistName, s
 					expectedDuration, isrcMatches[0].Duration)
 			}

-			GoLog("[Tidal] ✓ ISRC match (no duration verification): '%s'\n", isrcMatches[0].Title)
+			GoLog("[Tidal] ISRC match (no duration verification): '%s'\n", isrcMatches[0].Title)
 			return isrcMatches[0], nil
 		}

-		GoLog("[Tidal] ✗ No ISRC match found for: %s\n", spotifyISRC)
+		GoLog("[Tidal] No ISRC match found for: %s\n", spotifyISRC)
 		return nil, fmt.Errorf("ISRC mismatch: no track found with ISRC %s on Tidal", spotifyISRC)
 	}

@@ -584,13 +582,123 @@ type tidalAPIResult struct {
 	duration time.Duration
 }

-// Returns the first successful result (supports both v1 and v2 API formats)
+// Tidal API timeout configuration
+// Mobile networks are more unstable, so we use longer timeouts
+const (
+	tidalAPITimeoutMobile = 25 * time.Second
+	tidalMaxRetries       = 2 // Number of retries per API
+	tidalRetryDelay       = 500 * time.Millisecond
+)
+
+// fetchTidalURLWithRetry fetches download URL from a single Tidal API with retry logic
+func fetchTidalURLWithRetry(api string, trackID int64, quality string, timeout time.Duration) (TidalDownloadInfo, error) {
+	var lastErr error
+	retryDelay := tidalRetryDelay
+
+	for attempt := 0; attempt <= tidalMaxRetries; attempt++ {
+		if attempt > 0 {
+			GoLog("[Tidal] Retry %d/%d for %s after %v\n", attempt, tidalMaxRetries, api, retryDelay)
+			time.Sleep(retryDelay)
+			retryDelay *= 2 // Exponential backoff
+		}
+
+		client := NewHTTPClientWithTimeout(timeout)
+		reqURL := fmt.Sprintf("%s/track/?id=%d&quality=%s", api, trackID, quality)
+
+		req, err := http.NewRequest("GET", reqURL, nil)
+		if err != nil {
+			lastErr = err
+			continue
+		}
+
+		resp, err := client.Do(req)
+		if err != nil {
+			lastErr = err
+			// Check for retryable errors (timeout, connection reset)
+			errStr := strings.ToLower(err.Error())
+			if strings.Contains(errStr, "timeout") ||
+				strings.Contains(errStr, "reset") ||
+				strings.Contains(errStr, "connection refused") ||
+				strings.Contains(errStr, "eof") {
+				continue // Retry
+			}
+			break // Non-retryable error
+		}
+		// Server errors are retryable
+		if resp.StatusCode >= 500 {
+			io.Copy(io.Discard, resp.Body)
+			resp.Body.Close()
+			lastErr = fmt.Errorf("HTTP %d", resp.StatusCode)
+			continue
+		}
+
+		// 429 rate limit - wait and retry
+		if resp.StatusCode == 429 {
+			io.Copy(io.Discard, resp.Body)
+			resp.Body.Close()
+			lastErr = fmt.Errorf("rate limited")
+			retryDelay = 2 * time.Second // Wait longer for rate limit
+			continue
+		}
+
+		if resp.StatusCode != 200 {
+			io.Copy(io.Discard, resp.Body)
+			resp.Body.Close()
+			return TidalDownloadInfo{}, fmt.Errorf("HTTP %d", resp.StatusCode)
+		}
+
+		body, err := io.ReadAll(resp.Body)
+		resp.Body.Close()
+		if err != nil {
+			lastErr = err
+			continue
+		}
+
+		// Try V2 response format (with manifest)
+		var v2Response TidalAPIResponseV2
+		if err := json.Unmarshal(body, &v2Response); err == nil && v2Response.Data.Manifest != "" {
+			if v2Response.Data.AssetPresentation == "PREVIEW" {
+				return TidalDownloadInfo{}, fmt.Errorf("returned PREVIEW instead of FULL")
+			}
+
+			return TidalDownloadInfo{
+				URL:        "MANIFEST:" + v2Response.Data.Manifest,
+				BitDepth:   v2Response.Data.BitDepth,
+				SampleRate: v2Response.Data.SampleRate,
+			}, nil
+		}
+
+		// Try V1 response format
+		var v1Responses []struct {
+			OriginalTrackURL string `json:"OriginalTrackUrl"`
+		}
+		if err := json.Unmarshal(body, &v1Responses); err == nil {
+			for _, item := range v1Responses {
+				if item.OriginalTrackURL != "" {
+					return TidalDownloadInfo{
+						URL:        item.OriginalTrackURL,
+						BitDepth:   16,
+						SampleRate: 44100,
+					}, nil
+				}
+			}
+		}
+
+		return TidalDownloadInfo{}, fmt.Errorf("no download URL or manifest in response")
+	}
+
+	if lastErr != nil {
+		return TidalDownloadInfo{}, lastErr
+	}
+	return TidalDownloadInfo{}, fmt.Errorf("all retries failed")
+}
+
 func getDownloadURLParallel(apis []string, trackID int64, quality string) (string, TidalDownloadInfo, error) {
 	if len(apis) == 0 {
 		return "", TidalDownloadInfo{}, fmt.Errorf("no APIs available")
 	}

-	GoLog("[Tidal] Requesting download URL from %d APIs in parallel...\n", len(apis))
+	GoLog("[Tidal] Requesting download URL from %d APIs in parallel (with retry)...\n", len(apis))

 	resultChan := make(chan tidalAPIResult, len(apis))
 	startTime := time.Now()
@@ -598,69 +706,13 @@ func getDownloadURLParallel(apis []string, trackID int64, quality string) (strin
 	for _, apiURL := range apis {
 		go func(api string) {
 			reqStart := time.Now()
-
-			client := NewHTTPClientWithTimeout(15 * time.Second)
-
-			reqURL := fmt.Sprintf("%s/track/?id=%d&quality=%s", api, trackID, quality)
-
-			req, err := http.NewRequest("GET", reqURL, nil)
-			if err != nil {
-				resultChan <- tidalAPIResult{apiURL: api, err: err, duration: time.Since(reqStart)}
-				return
+			info, err := fetchTidalURLWithRetry(api, trackID, quality, tidalAPITimeoutMobile)
+			resultChan <- tidalAPIResult{
+				apiURL:   api,
+				info:     info,
+				err:      err,
+				duration: time.Since(reqStart),
 			}
-
-			resp, err := client.Do(req)
-			if err != nil {
-				resultChan <- tidalAPIResult{apiURL: api, err: err, duration: time.Since(reqStart)}
-				return
-			}
-			defer resp.Body.Close()
-
-			if resp.StatusCode != 200 {
-				resultChan <- tidalAPIResult{apiURL: api, err: fmt.Errorf("HTTP %d", resp.StatusCode), duration: time.Since(reqStart)}
-				return
-			}
-
-			body, err := io.ReadAll(resp.Body)
-			if err != nil {
-				resultChan <- tidalAPIResult{apiURL: api, err: err, duration: time.Since(reqStart)}
-				return
-			}
-
-			var v2Response TidalAPIResponseV2
-			if err := json.Unmarshal(body, &v2Response); err == nil && v2Response.Data.Manifest != "" {
-				if v2Response.Data.AssetPresentation == "PREVIEW" {
-					resultChan <- tidalAPIResult{apiURL: api, err: fmt.Errorf("returned PREVIEW instead of FULL"), duration: time.Since(reqStart)}
-					return
-				}
-
-				info := TidalDownloadInfo{
-					URL:        "MANIFEST:" + v2Response.Data.Manifest,
-					BitDepth:   v2Response.Data.BitDepth,
-					SampleRate: v2Response.Data.SampleRate,
-				}
-				resultChan <- tidalAPIResult{apiURL: api, info: info, err: nil, duration: time.Since(reqStart)}
-				return
-			}
-
-			var v1Responses []struct {
-				OriginalTrackURL string `json:"OriginalTrackUrl"`
-			}
-			if err := json.Unmarshal(body, &v1Responses); err == nil {
-				for _, item := range v1Responses {
-					if item.OriginalTrackURL != "" {
-						info := TidalDownloadInfo{
-							URL:        item.OriginalTrackURL,
-							BitDepth:   16,
-							SampleRate: 44100,
-						}
-						resultChan <- tidalAPIResult{apiURL: api, info: info, err: nil, duration: time.Since(reqStart)}
-						return
-					}
-				}
-			}
-
-			resultChan <- tidalAPIResult{apiURL: api, err: fmt.Errorf("no download URL or manifest in response"), duration: time.Since(reqStart)}
 		}(apiURL)
 	}

@@ -669,7 +721,7 @@ func getDownloadURLParallel(apis []string, trackID int64, quality string) (strin
 	for i := 0; i < len(apis); i++ {
 		result := <-resultChan
 		if result.err == nil {
-			GoLog("[Tidal] [Parallel] ✓ Got response from %s (%d-bit/%dHz) in %v\n",
+			GoLog("[Tidal] [Parallel] Got response from %s (%d-bit/%dHz) in %v\n",
 				result.apiURL, result.info.BitDepth, result.info.SampleRate, result.duration)

 			go func(remaining int) {
@@ -787,6 +839,10 @@ func parseManifest(manifestB64 string) (directURL string, initURL string, mediaU
 		GoLog("[Tidal] Total segments from regex: %d\n", segmentCount)
 	}

+	if segmentCount == 0 {
+		return "", "", nil, fmt.Errorf("no segments found in manifest")
+	}
+
 	for i := 1; i <= segmentCount; i++ {
 		mediaURL := strings.ReplaceAll(mediaTemplate, "$Number$", fmt.Sprintf("%d", i))
 		mediaURLs = append(mediaURLs, mediaURL)
@@ -795,8 +851,7 @@ func parseManifest(manifestB64 string) (directURL string, initURL string, mediaU
 	return "", initURL, mediaURLs, nil
 }

-// DownloadFile downloads a file from URL with progress tracking
-func (t *TidalDownloader) DownloadFile(downloadURL, outputPath, itemID string) error {
+func (t *TidalDownloader) DownloadFile(downloadURL, outputPath string, outputFD int, itemID string) error {
 	ctx := context.Background()

 	if strings.HasPrefix(downloadURL, "MANIFEST:") {
@@ -809,7 +864,7 @@ func (t *TidalDownloader) DownloadFile(downloadURL, outputPath, itemID string) e
 		if isDownloadCancelled(itemID) {
 			return ErrDownloadCancelled
 		}
-		return t.downloadFromManifest(ctx, strings.TrimPrefix(downloadURL, "MANIFEST:"), outputPath, itemID)
+		return t.downloadFromManifest(ctx, strings.TrimPrefix(downloadURL, "MANIFEST:"), outputPath, outputFD, itemID)
 	}

 	if itemID != "" {
@@ -846,7 +901,7 @@ func (t *TidalDownloader) DownloadFile(downloadURL, outputPath, itemID string) e
 		SetItemBytesTotal(itemID, expectedSize)
 	}

-	out, err := os.Create(outputPath)
+	out, err := openOutputForWrite(outputPath, outputFD)
 	if err != nil {
 		return err
 	}
@@ -865,30 +920,30 @@ func (t *TidalDownloader) DownloadFile(downloadURL, outputPath, itemID string) e
 	closeErr := out.Close()

 	if err != nil {
-		os.Remove(outputPath)
+		cleanupOutputOnError(outputPath, outputFD)
 		if isDownloadCancelled(itemID) {
 			return ErrDownloadCancelled
 		}
 		return fmt.Errorf("download interrupted: %w", err)
 	}
 	if flushErr != nil {
-		os.Remove(outputPath)
+		cleanupOutputOnError(outputPath, outputFD)
 		return fmt.Errorf("failed to flush buffer: %w", flushErr)
 	}
 	if closeErr != nil {
-		os.Remove(outputPath)
+		cleanupOutputOnError(outputPath, outputFD)
 		return fmt.Errorf("failed to close file: %w", closeErr)
 	}

 	if expectedSize > 0 && written != expectedSize {
-		os.Remove(outputPath)
+		cleanupOutputOnError(outputPath, outputFD)
 		return fmt.Errorf("incomplete download: expected %d bytes, got %d bytes", expectedSize, written)
 	}

 	return nil
 }

-func (t *TidalDownloader) downloadFromManifest(ctx context.Context, manifestB64, outputPath, itemID string) error {
+func (t *TidalDownloader) downloadFromManifest(ctx context.Context, manifestB64, outputPath string, outputFD int, itemID string) error {
 	fmt.Println("[Tidal] Parsing manifest...")
 	directURL, initURL, mediaURLs, err := parseManifest(manifestB64)
 	if err != nil {
@@ -933,7 +988,7 @@ func (t *TidalDownloader) downloadFromManifest(ctx context.Context, manifestB64,
 			SetItemBytesTotal(itemID, expectedSize)
 		}

-		out, err := os.Create(outputPath)
+		out, err := openOutputForWrite(outputPath, outputFD)
 		if err != nil {
 			return fmt.Errorf("failed to create file: %w", err)
 		}
@@ -949,29 +1004,40 @@ func (t *TidalDownloader) downloadFromManifest(ctx context.Context, manifestB64,
 		closeErr := out.Close()

 		if err != nil {
-			os.Remove(outputPath)
+			cleanupOutputOnError(outputPath, outputFD)
 			if isDownloadCancelled(itemID) {
 				return ErrDownloadCancelled
 			}
 			return fmt.Errorf("download interrupted: %w", err)
 		}
 		if closeErr != nil {
-			os.Remove(outputPath)
+			cleanupOutputOnError(outputPath, outputFD)
 			return fmt.Errorf("failed to close file: %w", closeErr)
 		}

 		if expectedSize > 0 && written != expectedSize {
-			os.Remove(outputPath)
+			cleanupOutputOnError(outputPath, outputFD)
 			return fmt.Errorf("incomplete download: expected %d bytes, got %d bytes", expectedSize, written)
 		}

 		return nil
 	}

-	m4aPath := strings.TrimSuffix(outputPath, ".flac") + ".m4a"
+	// For DASH format, determine correct M4A path
+	// If outputPath already ends with .m4a, use it directly.
+	// If outputPath ends with .flac, convert .flac to .m4a.
+	// Otherwise (e.g., SAF /proc/self/fd/*), use outputPath as-is.
+	var m4aPath string
+	if strings.HasSuffix(outputPath, ".m4a") {
+		m4aPath = outputPath
+	} else if strings.HasSuffix(outputPath, ".flac") {
+		m4aPath = strings.TrimSuffix(outputPath, ".flac") + ".m4a"
+	} else {
+		m4aPath = outputPath
+	}
 	GoLog("[Tidal] DASH format - downloading %d segments directly to: %s\n", len(mediaURLs), m4aPath)

-	out, err := os.Create(m4aPath)
+	out, err := openOutputForWrite(m4aPath, outputFD)
 	if err != nil {
 		GoLog("[Tidal] Failed to create M4A file: %v\n", err)
 		return fmt.Errorf("failed to create M4A file: %w", err)
@@ -980,20 +1046,20 @@ func (t *TidalDownloader) downloadFromManifest(ctx context.Context, manifestB64,
 	GoLog("[Tidal] Downloading init segment...\n")
 	if isDownloadCancelled(itemID) {
 		out.Close()
-		os.Remove(m4aPath)
+		cleanupOutputOnError(m4aPath, outputFD)
 		return ErrDownloadCancelled
 	}
 	req, err := http.NewRequestWithContext(ctx, "GET", initURL, nil)
 	if err != nil {
 		out.Close()
-		os.Remove(m4aPath)
+		cleanupOutputOnError(m4aPath, outputFD)
 		GoLog("[Tidal] Init segment request failed: %v\n", err)
 		return fmt.Errorf("failed to create init segment request: %w", err)
 	}
 	resp, err := client.Do(req)
 	if err != nil {
 		out.Close()
-		os.Remove(m4aPath)
+		cleanupOutputOnError(m4aPath, outputFD)
 		if isDownloadCancelled(itemID) {
 			return ErrDownloadCancelled
 		}
@@ -1003,7 +1069,7 @@ func (t *TidalDownloader) downloadFromManifest(ctx context.Context, manifestB64,
 	if resp.StatusCode != 200 {
 		resp.Body.Close()
 		out.Close()
-		os.Remove(m4aPath)
+		cleanupOutputOnError(m4aPath, outputFD)
 		GoLog("[Tidal] Init segment HTTP error: %d\n", resp.StatusCode)
 		return fmt.Errorf("init segment download failed with status %d", resp.StatusCode)
 	}
@@ -1011,7 +1077,7 @@ func (t *TidalDownloader) downloadFromManifest(ctx context.Context, manifestB64,
 	resp.Body.Close()
 	if err != nil {
 		out.Close()
-		os.Remove(m4aPath)
+		cleanupOutputOnError(m4aPath, outputFD)
 		if isDownloadCancelled(itemID) {
 			return ErrDownloadCancelled
 		}
@@ -1023,7 +1089,7 @@ func (t *TidalDownloader) downloadFromManifest(ctx context.Context, manifestB64,
 	for i, mediaURL := range mediaURLs {
 		if isDownloadCancelled(itemID) {
 			out.Close()
-			os.Remove(m4aPath)
+			cleanupOutputOnError(m4aPath, outputFD)
 			return ErrDownloadCancelled
 		}

@@ -1039,14 +1105,14 @@ func (t *TidalDownloader) downloadFromManifest(ctx context.Context, manifestB64,
 		req, err := http.NewRequestWithContext(ctx, "GET", mediaURL, nil)
 		if err != nil {
 			out.Close()
-			os.Remove(m4aPath)
+			cleanupOutputOnError(m4aPath, outputFD)
 			GoLog("[Tidal] Segment %d request failed: %v\n", i+1, err)
 			return fmt.Errorf("failed to create segment %d request: %w", i+1, err)
 		}
 		resp, err := client.Do(req)
 		if err != nil {
 			out.Close()
-			os.Remove(m4aPath)
+			cleanupOutputOnError(m4aPath, outputFD)
 			if isDownloadCancelled(itemID) {
 				return ErrDownloadCancelled
 			}
@@ -1056,7 +1122,7 @@ func (t *TidalDownloader) downloadFromManifest(ctx context.Context, manifestB64,
 		if resp.StatusCode != 200 {
 			resp.Body.Close()
 			out.Close()
-			os.Remove(m4aPath)
+			cleanupOutputOnError(m4aPath, outputFD)
 			GoLog("[Tidal] Segment %d HTTP error: %d\n", i+1, resp.StatusCode)
 			return fmt.Errorf("segment %d download failed with status %d", i+1, resp.StatusCode)
 		}
@@ -1064,7 +1130,7 @@ func (t *TidalDownloader) downloadFromManifest(ctx context.Context, manifestB64,
 		resp.Body.Close()
 		if err != nil {
 			out.Close()
-			os.Remove(m4aPath)
+			cleanupOutputOnError(m4aPath, outputFD)
 			if isDownloadCancelled(itemID) {
 				return ErrDownloadCancelled
 			}
@@ -1074,7 +1140,7 @@ func (t *TidalDownloader) downloadFromManifest(ctx context.Context, manifestB64,
 	}

 	if err := out.Close(); err != nil {
-		os.Remove(m4aPath)
+		cleanupOutputOnError(m4aPath, outputFD)
 		GoLog("[Tidal] Failed to close M4A file: %v\n", err)
 		return fmt.Errorf("failed to close M4A file: %w", err)
 	}
@@ -1094,6 +1160,7 @@ type TidalDownloadResult struct {
 	TrackNumber int
 	DiscNumber  int
 	ISRC        string
+	LyricsLRC   string // LRC content for embedding in converted files
 }

 func artistsMatch(spotifyArtist, tidalArtist string) bool {
@@ -1104,7 +1171,6 @@ func artistsMatch(spotifyArtist, tidalArtist string) bool {
 		return true
 	}

-	// Check if one contains the other (for cases like "Artist" vs "Artist feat. Someone")
 	if strings.Contains(normSpotify, normTidal) || strings.Contains(normTidal, normSpotify) {
 		return true
 	}
@@ -1163,7 +1229,6 @@ func sameWordsUnordered(a, b string) bool {
 	wordsA := strings.Fields(a)
 	wordsB := strings.Fields(b)

-	// Must have same number of words
 	if len(wordsA) != len(wordsB) || len(wordsA) == 0 {
 		return false
 	}
@@ -1196,7 +1261,6 @@ func titlesMatch(expectedTitle, foundTitle string) bool {
 	normExpected := strings.ToLower(strings.TrimSpace(expectedTitle))
 	normFound := strings.ToLower(strings.TrimSpace(foundTitle))

-	// Exact match
 	if normExpected == normFound {
 		return true
 	}
@@ -1205,7 +1269,6 @@ func titlesMatch(expectedTitle, foundTitle string) bool {
 		return true
 	}

-	// Clean both titles and compare
 	cleanExpected := cleanTitle(normExpected)
 	cleanFound := cleanTitle(normFound)

@@ -1219,7 +1282,6 @@ func titlesMatch(expectedTitle, foundTitle string) bool {
 		}
 	}

-	// Extract core title (before any parentheses/brackets)
 	coreExpected := extractCoreTitle(normExpected)
 	coreFound := extractCoreTitle(normFound)

@@ -1227,7 +1289,6 @@ func titlesMatch(expectedTitle, foundTitle string) bool {
 		return true
 	}

-	// Don't treat Latin Extended (Polish, French, etc.) as different script
 	expectedLatin := isLatinScript(expectedTitle)
 	foundLatin := isLatinScript(foundTitle)
 	if expectedLatin != foundLatin {
@@ -1348,8 +1409,11 @@ func isLatinScript(s string) bool {
 func downloadFromTidal(req DownloadRequest) (TidalDownloadResult, error) {
 	downloader := NewTidalDownloader()

-	if existingFile, exists := checkISRCExistsInternal(req.OutputDir, req.ISRC); exists {
-		return TidalDownloadResult{FilePath: "EXISTS:" + existingFile}, nil
+	isSafOutput := isFDOutput(req.OutputFD) || strings.TrimSpace(req.OutputPath) != ""
+	if !isSafOutput {
+		if existingFile, exists := checkISRCExistsInternal(req.OutputDir, req.ISRC); exists {
+			return TidalDownloadResult{FilePath: "EXISTS:" + existingFile}, nil
+		}
 	}

 	expectedDurationSec := req.DurationMS / 1000
@@ -1405,49 +1469,83 @@ func downloadFromTidal(req DownloadRequest) (TidalDownloadResult, error) {

 	if track == nil && req.SpotifyID != "" {
 		GoLog("[Tidal] ISRC search failed, trying SongLink...\n")
-		var tidalURL string
-		var slErr error
+
+		var trackID int64
+		var gotTidalID bool

 		if strings.HasPrefix(req.SpotifyID, "deezer:") {
 			deezerID := strings.TrimPrefix(req.SpotifyID, "deezer:")
 			GoLog("[Tidal] Using Deezer ID for SongLink lookup: %s\n", deezerID)
 			songlink := NewSongLinkClient()
-			tidalURL, slErr = songlink.GetTidalURLFromDeezer(deezerID)
+			availability, slErr := songlink.CheckAvailabilityFromDeezer(deezerID)
+			if slErr == nil && availability != nil && availability.TidalID != "" {
+				if _, parseErr := fmt.Sscanf(availability.TidalID, "%d", &trackID); parseErr == nil && trackID > 0 {
+					GoLog("[Tidal] Got Tidal ID %d directly from SongLink\n", trackID)
+					gotTidalID = true
+				}
+			}
+			// Fallback to URL parsing if TidalID not in struct
+			if !gotTidalID && availability != nil && availability.TidalURL != "" {
+				var idErr error
+				trackID, idErr = downloader.GetTrackIDFromURL(availability.TidalURL)
+				if idErr == nil && trackID > 0 {
+					GoLog("[Tidal] Got Tidal ID %d from URL parsing\n", trackID)
+					gotTidalID = true
+				}
+			}
 		} else {
-			tidalURL, slErr = downloader.GetTidalURLFromSpotify(req.SpotifyID)
+			songlink := NewSongLinkClient()
+			availability, slErr := songlink.CheckTrackAvailability(req.SpotifyID, req.ISRC)
+			if slErr == nil && availability != nil && availability.TidalID != "" {
+				if _, parseErr := fmt.Sscanf(availability.TidalID, "%d", &trackID); parseErr == nil && trackID > 0 {
+					GoLog("[Tidal] Got Tidal ID %d directly from SongLink\n", trackID)
+					gotTidalID = true
+				}
+			}
+			// Fallback to URL parsing if TidalID not in struct
+			if !gotTidalID && availability != nil && availability.TidalURL != "" {
+				var idErr error
+				trackID, idErr = downloader.GetTrackIDFromURL(availability.TidalURL)
+				if idErr == nil && trackID > 0 {
+					GoLog("[Tidal] Got Tidal ID %d from URL parsing\n", trackID)
+					gotTidalID = true
+				}
+			}
 		}

-		if slErr == nil && tidalURL != "" {
-			trackID, idErr := downloader.GetTrackIDFromURL(tidalURL)
-			if idErr == nil {
-				track, err = downloader.GetTrackInfoByID(trackID)
-				if track != nil {
-					tidalArtist := track.Artist.Name
-					if len(track.Artists) > 0 {
-						var artistNames []string
-						for _, a := range track.Artists {
-							artistNames = append(artistNames, a.Name)
-						}
-						tidalArtist = strings.Join(artistNames, ", ")
+		if gotTidalID && trackID > 0 {
+			track, err = downloader.GetTrackInfoByID(trackID)
+			if track != nil {
+				tidalArtist := track.Artist.Name
+				if len(track.Artists) > 0 {
+					var artistNames []string
+					for _, a := range track.Artists {
+						artistNames = append(artistNames, a.Name)
 					}
+					tidalArtist = strings.Join(artistNames, ", ")
+				}

-					if !artistsMatch(req.ArtistName, tidalArtist) {
-						GoLog("[Tidal] Artist mismatch from SongLink: expected '%s', got '%s'. Rejecting.\n",
-							req.ArtistName, tidalArtist)
-						track = nil
-					}
+				if !artistsMatch(req.ArtistName, tidalArtist) {
+					GoLog("[Tidal] Artist mismatch from SongLink: expected '%s', got '%s'. Rejecting.\n",
+						req.ArtistName, tidalArtist)
+					track = nil
+				}

-					if track != nil && expectedDurationSec > 0 {
-						durationDiff := track.Duration - expectedDurationSec
-						if durationDiff < 0 {
-							durationDiff = -durationDiff
-						}
-						if durationDiff > 3 {
-							GoLog("[Tidal] Duration mismatch from SongLink: expected %ds, got %ds. Rejecting.\n",
-								expectedDurationSec, track.Duration)
-							track = nil // Reject this match
-						}
+				if track != nil && expectedDurationSec > 0 {
+					durationDiff := track.Duration - expectedDurationSec
+					if durationDiff < 0 {
+						durationDiff = -durationDiff
 					}
+					if durationDiff > 3 {
+						GoLog("[Tidal] Duration mismatch from SongLink: expected %ds, got %ds. Rejecting.\n",
+							expectedDurationSec, track.Duration)
+						track = nil // Reject this match
+					}
+				}
+
+				// Cache for future use
+				if track != nil && req.ISRC != "" {
+					GetTrackIDCache().SetTidal(req.ISRC, track.ID)
 				}
 			}
 		}
@@ -1500,6 +1598,11 @@ func downloadFromTidal(req DownloadRequest) (TidalDownloadResult, error) {
 		GetTrackIDCache().SetTidal(req.ISRC, track.ID)
 	}

+	quality := req.Quality
+	if quality == "" {
+		quality = "LOSSLESS"
+	}
+
 	filename := buildFilenameFromTemplate(req.FilenameFormat, map[string]interface{}{
 		"title":  req.TrackName,
 		"artist": req.ArtistName,
@@ -1508,27 +1611,55 @@ func downloadFromTidal(req DownloadRequest) (TidalDownloadResult, error) {
 		"year":   extractYear(req.ReleaseDate),
 		"disc":   req.DiscNumber,
 	})
-	filename = sanitizeFilename(filename) + ".flac"
-	outputPath := filepath.Join(req.OutputDir, filename)

-	if fileInfo, statErr := os.Stat(outputPath); statErr == nil && fileInfo.Size() > 0 {
-		return TidalDownloadResult{FilePath: "EXISTS:" + outputPath}, nil
-	}
-	m4aPath := strings.TrimSuffix(outputPath, ".flac") + ".m4a"
-	if fileInfo, statErr := os.Stat(m4aPath); statErr == nil && fileInfo.Size() > 0 {
-		return TidalDownloadResult{FilePath: "EXISTS:" + m4aPath}, nil
+	outputExt := strings.TrimSpace(req.OutputExt)
+	if outputExt == "" {
+		if quality == "HIGH" {
+			outputExt = ".m4a"
+		} else {
+			outputExt = ".flac"
+		}
+	} else if !strings.HasPrefix(outputExt, ".") {
+		outputExt = "." + outputExt
 	}

-	tmpPath := outputPath + ".m4a.tmp"
-	if _, err := os.Stat(tmpPath); err == nil {
-		GoLog("[Tidal] Cleaning up leftover temp file: %s\n", tmpPath)
-		os.Remove(tmpPath)
+	var outputPath string
+	var m4aPath string
+	if isSafOutput {
+		outputPath = strings.TrimSpace(req.OutputPath)
+		if outputPath == "" && isFDOutput(req.OutputFD) {
+			outputPath = fmt.Sprintf("/proc/self/fd/%d", req.OutputFD)
+		}
+		m4aPath = outputPath
+	} else {
+		if outputExt == ".m4a" || quality == "HIGH" {
+			filename = sanitizeFilename(filename) + ".m4a"
+			outputPath = filepath.Join(req.OutputDir, filename)
+			m4aPath = outputPath
+		} else {
+			filename = sanitizeFilename(filename) + ".flac"
+			outputPath = filepath.Join(req.OutputDir, filename)
+			m4aPath = strings.TrimSuffix(outputPath, ".flac") + ".m4a"
+		}
+
+		if fileInfo, statErr := os.Stat(outputPath); statErr == nil && fileInfo.Size() > 0 {
+			return TidalDownloadResult{FilePath: "EXISTS:" + outputPath}, nil
+		}
+		if quality != "HIGH" {
+			if fileInfo, statErr := os.Stat(m4aPath); statErr == nil && fileInfo.Size() > 0 {
+				return TidalDownloadResult{FilePath: "EXISTS:" + m4aPath}, nil
+			}
+		}
 	}

-	quality := req.Quality
-	if quality == "" {
-		quality = "LOSSLESS"
+	if !isSafOutput {
+		tmpPath := outputPath + ".m4a.tmp"
+		if _, err := os.Stat(tmpPath); err == nil {
+			GoLog("[Tidal] Cleaning up leftover temp file: %s\n", tmpPath)
+			os.Remove(tmpPath)
+		}
 	}
+
 	GoLog("[Tidal] Using quality: %s\n", quality)

 	downloadInfo, err := downloader.GetDownloadURL(track.ID, quality)
@@ -1561,7 +1692,7 @@ func downloadFromTidal(req DownloadRequest) (TidalDownloadResult, error) {
 		return "Direct URL"
 	}())

-	if err := downloader.DownloadFile(downloadInfo.URL, outputPath, req.ItemID); err != nil {
+	if err := downloader.DownloadFile(downloadInfo.URL, outputPath, req.OutputFD, req.ItemID); err != nil {
 		if errors.Is(err, ErrDownloadCancelled) {
 			return TidalDownloadResult{}, ErrDownloadCancelled
 		}
@@ -1578,11 +1709,13 @@ func downloadFromTidal(req DownloadRequest) (TidalDownloadResult, error) {
 	}

 	actualOutputPath := outputPath
-	if _, err := os.Stat(m4aPath); err == nil {
-		actualOutputPath = m4aPath
-		GoLog("[Tidal] File saved as M4A (DASH stream): %s\n", actualOutputPath)
-	} else if _, err := os.Stat(outputPath); err != nil {
-		return TidalDownloadResult{}, fmt.Errorf("download completed but file not found at %s or %s", outputPath, m4aPath)
+	if !isSafOutput {
+		if _, err := os.Stat(m4aPath); err == nil {
+			actualOutputPath = m4aPath
+			GoLog("[Tidal] File saved as M4A (DASH stream): %s\n", actualOutputPath)
+		} else if _, err := os.Stat(outputPath); err != nil {
+			return TidalDownloadResult{}, fmt.Errorf("download completed but file not found at %s or %s", outputPath, m4aPath)
+		}
 	}

 	releaseDate := req.ReleaseDate
@@ -1591,7 +1724,6 @@ func downloadFromTidal(req DownloadRequest) (TidalDownloadResult, error) {
 		GoLog("[Tidal] Using release date from Tidal API: %s\n", releaseDate)
 	}

-	// Use track number from request if available, otherwise from Tidal API
 	actualTrackNumber := req.TrackNumber
 	actualDiscNumber := req.DiscNumber
 	if actualTrackNumber == 0 {
@@ -1622,7 +1754,15 @@ func downloadFromTidal(req DownloadRequest) (TidalDownloadResult, error) {
 		GoLog("[Tidal] Using parallel-fetched cover (%d bytes)\n", len(coverData))
 	}

-	if strings.HasSuffix(actualOutputPath, ".flac") {
+	actualExt := outputExt
+	if strings.HasPrefix(downloadInfo.URL, "MANIFEST:") {
+		actualExt = ".m4a"
+	}
+	if actualExt == "" && !isSafOutput {
+		actualExt = strings.ToLower(filepath.Ext(actualOutputPath))
+	}
+
+	if (isSafOutput && actualExt == ".flac") || (!isSafOutput && strings.HasSuffix(actualOutputPath, ".flac")) {
 		if err := EmbedMetadataWithCoverData(actualOutputPath, metadata, coverData); err != nil {
 			fmt.Printf("Warning: failed to embed metadata: %v\n", err)
 		}
@@ -1633,7 +1773,7 @@ func downloadFromTidal(req DownloadRequest) (TidalDownloadResult, error) {
 				lyricsMode = "embed"
 			}

-			if lyricsMode == "external" || lyricsMode == "both" {
+			if !isSafOutput && (lyricsMode == "external" || lyricsMode == "both") {
 				GoLog("[Tidal] Saving external LRC file...\n")
 				if lrcPath, lrcErr := SaveLRCFile(actualOutputPath, parallelResult.LyricsLRC); lrcErr != nil {
 					GoLog("[Tidal] Warning: failed to save LRC file: %v\n", lrcErr)
@@ -1653,16 +1793,49 @@ func downloadFromTidal(req DownloadRequest) (TidalDownloadResult, error) {
 		} else if req.EmbedLyrics {
 			fmt.Println("[Tidal] No lyrics available from parallel fetch")
 		}
-	} else if strings.HasSuffix(actualOutputPath, ".m4a") {
-		fmt.Println("[Tidal] Skipping metadata embedding for M4A file (will be handled after FFmpeg conversion)")
+	} else if (isSafOutput && actualExt == ".m4a") || (!isSafOutput && strings.HasSuffix(actualOutputPath, ".m4a")) {
+		if quality == "HIGH" {
+			GoLog("[Tidal] HIGH quality M4A - skipping metadata embedding (file from server is already valid)\n")
+
+			if req.EmbedLyrics && parallelResult != nil && parallelResult.LyricsLRC != "" {
+				lyricsMode := req.LyricsMode
+				if lyricsMode == "" {
+					lyricsMode = "embed"
+				}
+
+				if !isSafOutput && (lyricsMode == "external" || lyricsMode == "both") {
+					GoLog("[Tidal] Saving external LRC file for M4A (mode: %s)...\n", lyricsMode)
+					if lrcPath, lrcErr := SaveLRCFile(actualOutputPath, parallelResult.LyricsLRC); lrcErr != nil {
+						GoLog("[Tidal] Warning: failed to save LRC file: %v\n", lrcErr)
+					} else {
+						GoLog("[Tidal] LRC file saved: %s\n", lrcPath)
+					}
+				}
+			}
+		} else {
+			fmt.Println("[Tidal] Skipping metadata embedding for M4A file (will be handled after FFmpeg conversion)")
+		}
 	}

-	AddToISRCIndex(req.OutputDir, req.ISRC, actualOutputPath)
+	if !isSafOutput {
+		AddToISRCIndex(req.OutputDir, req.ISRC, actualOutputPath)
+	}
+
+	bitDepth := downloadInfo.BitDepth
+	sampleRate := downloadInfo.SampleRate
+	lyricsLRC := ""
+	if quality == "HIGH" {
+		bitDepth = 0
+		sampleRate = 44100
+	}
+	if req.EmbedLyrics && parallelResult != nil && parallelResult.LyricsLRC != "" {
+		lyricsLRC = parallelResult.LyricsLRC
+	}

 	return TidalDownloadResult{
 		FilePath:    actualOutputPath,
-		BitDepth:    downloadInfo.BitDepth,
-		SampleRate:  downloadInfo.SampleRate,
+		BitDepth:    bitDepth,
+		SampleRate:  sampleRate,
 		Title:       track.Title,
 		Artist:      track.Artist.Name,
 		Album:       track.Album.Title,
@@ -1670,5 +1843,43 @@ func downloadFromTidal(req DownloadRequest) (TidalDownloadResult, error) {
 		TrackNumber: actualTrackNumber,
 		DiscNumber:  actualDiscNumber,
 		ISRC:        track.ISRC,
+		LyricsLRC:   lyricsLRC,
 	}, nil
 }
+
+func parseTidalURL(input string) (string, string, error) {
+	trimmed := strings.TrimSpace(input)
+	if trimmed == "" {
+		return "", "", fmt.Errorf("empty URL")
+	}
+
+	parsed, err := url.Parse(trimmed)
+	if err != nil {
+		return "", "", err
+	}
+
+	if parsed.Host != "tidal.com" && parsed.Host != "listen.tidal.com" && parsed.Host != "www.tidal.com" {
+		return "", "", fmt.Errorf("not a Tidal URL")
+	}
+
+	parts := strings.Split(strings.Trim(parsed.Path, "/"), "/")
+
+	// Handle /browse/track/123 format
+	if len(parts) > 0 && parts[0] == "browse" {
+		parts = parts[1:]
+	}
+
+	if len(parts) < 2 {
+		return "", "", fmt.Errorf("invalid Tidal URL format")
+	}
+
+	resourceType := parts[0]
+	resourceID := parts[1]
+
+	switch resourceType {
+	case "track", "album", "artist", "playlist":
+		return resourceType, resourceID, nil
+	default:
+		return "", "", fmt.Errorf("unsupported Tidal resource type: %s", resourceType)
+	}
+}
@@ -0,0 +1,566 @@
+// Package gobackend - YouTube download via Cobalt API (lossy-only provider)
+package gobackend
+
+import (
+	"bufio"
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"strings"
+	"sync"
+	"time"
+)
+
+type YouTubeDownloader struct {
+	client *http.Client
+	apiURL string
+	mu     sync.Mutex
+}
+
+var (
+	globalYouTubeDownloader *YouTubeDownloader
+	youtubeDownloaderOnce   sync.Once
+)
+
+type YouTubeQuality string
+
+const (
+	YouTubeQualityOpus256 YouTubeQuality = "opus_256"
+	YouTubeQualityMP3320  YouTubeQuality = "mp3_320"
+)
+
+type CobaltRequest struct {
+	URL             string `json:"url"`
+	AudioBitrate    string `json:"audioBitrate,omitempty"`
+	AudioFormat     string `json:"audioFormat,omitempty"`
+	DownloadMode    string `json:"downloadMode,omitempty"`
+	FilenameStyle   string `json:"filenameStyle,omitempty"`
+	DisableMetadata bool   `json:"disableMetadata,omitempty"`
+}
+
+type CobaltResponse struct {
+	Status   string `json:"status"`
+	URL      string `json:"url,omitempty"`
+	Filename string `json:"filename,omitempty"`
+	Error    *struct {
+		Code    string `json:"code"`
+		Context *struct {
+			Service string `json:"service,omitempty"`
+			Limit   int    `json:"limit,omitempty"`
+		} `json:"context,omitempty"`
+	} `json:"error,omitempty"`
+}
+
+type YouTubeDownloadResult struct {
+	FilePath    string
+	Title       string
+	Artist      string
+	Album       string
+	ReleaseDate string
+	TrackNumber int
+	DiscNumber  int
+	ISRC        string
+	Format      string // "opus" or "mp3"
+	Bitrate     int
+	LyricsLRC   string
+	CoverData   []byte
+}
+
+func NewYouTubeDownloader() *YouTubeDownloader {
+	youtubeDownloaderOnce.Do(func() {
+		globalYouTubeDownloader = &YouTubeDownloader{
+			client: NewHTTPClientWithTimeout(120 * time.Second),
+			apiURL: "https://api.qwkuns.me",
+		}
+	})
+	return globalYouTubeDownloader
+}
+
+// SearchYouTube returns a YouTube Music search URL for the given track
+func (y *YouTubeDownloader) SearchYouTube(trackName, artistName string) (string, error) {
+	query := fmt.Sprintf("%s %s", artistName, trackName)
+	searchQuery := url.QueryEscape(query)
+
+	GoLog("[YouTube] Search query: %s\n", query)
+
+	youtubeMusicURL := fmt.Sprintf("https://music.youtube.com/search?q=%s", searchQuery)
+
+	return youtubeMusicURL, nil
+}
+
+func (y *YouTubeDownloader) GetDownloadURL(youtubeURL string, quality YouTubeQuality) (*CobaltResponse, error) {
+	y.mu.Lock()
+	defer y.mu.Unlock()
+
+	var audioFormat string
+	var audioBitrate string
+
+	switch quality {
+	case YouTubeQualityOpus256:
+		audioFormat = "opus"
+		audioBitrate = "256"
+	case YouTubeQualityMP3320:
+		audioFormat = "mp3"
+		audioBitrate = "320"
+	default:
+		audioFormat = "mp3"
+		audioBitrate = "320"
+	}
+
+	// Try SpotubeDL first (primary)
+	videoID, extractErr := ExtractYouTubeVideoID(youtubeURL)
+	if extractErr == nil {
+		GoLog("[YouTube] Requesting from SpotubeDL: videoID=%s (format: %s, bitrate: %s)\n",
+			videoID, audioFormat, audioBitrate)
+
+		resp, err := y.requestSpotubeDL(videoID, audioFormat, audioBitrate)
+		if err == nil {
+			return resp, nil
+		}
+		GoLog("[YouTube] SpotubeDL failed: %v, trying Cobalt fallback...\n", err)
+	} else {
+		GoLog("[YouTube] Could not extract video ID: %v, skipping SpotubeDL\n", extractErr)
+	}
+
+	// Fallback: direct Cobalt API (api.qwkuns.me)
+	cobaltURL := toYouTubeMusicURL(youtubeURL)
+	GoLog("[YouTube] Requesting from Cobalt API: %s (format: %s, bitrate: %s)\n",
+		cobaltURL, audioFormat, audioBitrate)
+
+	resp, err := y.requestCobaltDirect(cobaltURL, audioFormat, audioBitrate)
+	if err != nil {
+		return nil, fmt.Errorf("all download methods failed: spotubedl: extractErr=%v, cobalt: %v", extractErr, err)
+	}
+
+	return resp, nil
+}
+
+// requestCobaltDirect sends a download request to the primary Cobalt API.
+func (y *YouTubeDownloader) requestCobaltDirect(videoURL, audioFormat, audioBitrate string) (*CobaltResponse, error) {
+	reqBody := CobaltRequest{
+		URL:             videoURL,
+		AudioFormat:     audioFormat,
+		AudioBitrate:    audioBitrate,
+		DownloadMode:    "audio",
+		FilenameStyle:   "basic",
+		DisableMetadata: true,
+	}
+
+	jsonData, err := json.Marshal(reqBody)
+	if err != nil {
+		return nil, fmt.Errorf("failed to marshal request: %w", err)
+	}
+
+	req, err := http.NewRequest("POST", y.apiURL, strings.NewReader(string(jsonData)))
+	if err != nil {
+		return nil, fmt.Errorf("failed to create request: %w", err)
+	}
+
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("Accept", "application/json")
+
+	resp, err := DoRequestWithUserAgent(y.client, req)
+	if err != nil {
+		return nil, fmt.Errorf("cobalt API request failed: %w", err)
+	}
+	defer resp.Body.Close()
+
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return nil, fmt.Errorf("failed to read response: %w", err)
+	}
+
+	GoLog("[YouTube] Cobalt API response status: %d\n", resp.StatusCode)
+
+	if resp.StatusCode != 200 {
+		return nil, fmt.Errorf("cobalt API returned status %d: %s", resp.StatusCode, string(body))
+	}
+
+	var cobaltResp CobaltResponse
+	if err := json.Unmarshal(body, &cobaltResp); err != nil {
+		return nil, fmt.Errorf("failed to parse response: %w", err)
+	}
+
+	if cobaltResp.Status == "error" && cobaltResp.Error != nil {
+		return nil, fmt.Errorf("cobalt error: %s", cobaltResp.Error.Code)
+	}
+
+	if cobaltResp.Status != "tunnel" && cobaltResp.Status != "redirect" {
+		return nil, fmt.Errorf("unexpected cobalt status: %s", cobaltResp.Status)
+	}
+
+	if cobaltResp.URL == "" {
+		return nil, fmt.Errorf("no download URL in response")
+	}
+
+	GoLog("[YouTube] Got download URL from Cobalt (status: %s)\n", cobaltResp.Status)
+	return &cobaltResp, nil
+}
+
+// requestSpotubeDL uses SpotubeDL as a Cobalt proxy (they handle auth to yt-dl.click instances).
+func (y *YouTubeDownloader) requestSpotubeDL(videoID, audioFormat, audioBitrate string) (*CobaltResponse, error) {
+	apiURL := fmt.Sprintf("https://spotubedl.com/api/download/%s?engine=v1&format=%s&quality=%s",
+		videoID, audioFormat, audioBitrate)
+
+	GoLog("[YouTube] Requesting from SpotubeDL: %s\n", apiURL)
+
+	req, err := http.NewRequest("GET", apiURL, nil)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create request: %w", err)
+	}
+
+	req.Header.Set("Accept", "application/json")
+
+	resp, err := DoRequestWithUserAgent(y.client, req)
+	if err != nil {
+		return nil, fmt.Errorf("spotubedl request failed: %w", err)
+	}
+	defer resp.Body.Close()
+
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return nil, fmt.Errorf("failed to read response: %w", err)
+	}
+
+	GoLog("[YouTube] SpotubeDL response status: %d\n", resp.StatusCode)
+
+	if resp.StatusCode != 200 {
+		return nil, fmt.Errorf("spotubedl returned status %d: %s", resp.StatusCode, string(body))
+	}
+
+	var result struct {
+		URL string `json:"url"`
+	}
+	if err := json.Unmarshal(body, &result); err != nil {
+		return nil, fmt.Errorf("failed to parse spotubedl response: %w", err)
+	}
+
+	if result.URL == "" {
+		return nil, fmt.Errorf("no download URL from spotubedl")
+	}
+
+	GoLog("[YouTube] Got download URL from SpotubeDL\n")
+	return &CobaltResponse{
+		Status: "tunnel",
+		URL:    result.URL,
+	}, nil
+}
+
+func (y *YouTubeDownloader) DownloadFile(downloadURL, outputPath string, outputFD int, itemID string) error {
+	ctx := context.Background()
+
+	if itemID != "" {
+		StartItemProgress(itemID)
+		defer CompleteItemProgress(itemID)
+		ctx = initDownloadCancel(itemID)
+		defer clearDownloadCancel(itemID)
+	}
+
+	if isDownloadCancelled(itemID) {
+		return ErrDownloadCancelled
+	}
+
+	req, err := http.NewRequestWithContext(ctx, "GET", downloadURL, nil)
+	if err != nil {
+		return fmt.Errorf("failed to create request: %w", err)
+	}
+
+	resp, err := DoRequestWithUserAgent(y.client, req)
+	if err != nil {
+		if isDownloadCancelled(itemID) {
+			return ErrDownloadCancelled
+		}
+		return fmt.Errorf("download request failed: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != 200 {
+		return fmt.Errorf("download failed: HTTP %d", resp.StatusCode)
+	}
+
+	expectedSize := resp.ContentLength
+	if expectedSize > 0 && itemID != "" {
+		SetItemBytesTotal(itemID, expectedSize)
+	}
+
+	out, err := openOutputForWrite(outputPath, outputFD)
+	if err != nil {
+		return fmt.Errorf("failed to create output file: %w", err)
+	}
+
+	bufWriter := bufio.NewWriterSize(out, 256*1024)
+
+	var written int64
+	if itemID != "" {
+		progressWriter := NewItemProgressWriter(bufWriter, itemID)
+		written, err = io.Copy(progressWriter, resp.Body)
+	} else {
+		written, err = io.Copy(bufWriter, resp.Body)
+	}
+
+	flushErr := bufWriter.Flush()
+	closeErr := out.Close()
+
+	if err != nil {
+		cleanupOutputOnError(outputPath, outputFD)
+		if isDownloadCancelled(itemID) {
+			return ErrDownloadCancelled
+		}
+		return fmt.Errorf("download interrupted: %w", err)
+	}
+	if flushErr != nil {
+		cleanupOutputOnError(outputPath, outputFD)
+		return fmt.Errorf("failed to flush buffer: %w", flushErr)
+	}
+	if closeErr != nil {
+		cleanupOutputOnError(outputPath, outputFD)
+		return fmt.Errorf("failed to close file: %w", closeErr)
+	}
+
+	if expectedSize > 0 && written != expectedSize {
+		cleanupOutputOnError(outputPath, outputFD)
+		return fmt.Errorf("incomplete download: expected %d bytes, got %d bytes", expectedSize, written)
+	}
+
+	GoLog("[YouTube] Download completed: %d bytes written\n", written)
+
+	return nil
+}
+
+func BuildYouTubeSearchURL(trackName, artistName string) string {
+	query := fmt.Sprintf("%s %s official audio", artistName, trackName)
+	return fmt.Sprintf("https://music.youtube.com/search?q=%s", url.QueryEscape(query))
+}
+
+func BuildYouTubeWatchURL(videoID string) string {
+	return fmt.Sprintf("https://music.youtube.com/watch?v=%s", videoID)
+}
+
+// isYouTubeVideoID checks if s is an 11-char YouTube video ID
+func isYouTubeVideoID(s string) bool {
+	if len(s) != 11 {
+		return false
+	}
+	for _, c := range s {
+		if !((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') || c == '-' || c == '_') {
+			return false
+		}
+	}
+	return true
+}
+
+func IsYouTubeURL(urlStr string) bool {
+	lower := strings.ToLower(urlStr)
+	return strings.Contains(lower, "youtube.com") ||
+		strings.Contains(lower, "youtu.be") ||
+		strings.Contains(lower, "music.youtube.com")
+}
+
+// toYouTubeMusicURL converts any YouTube URL to music.youtube.com format.
+// YouTube Music URLs bypass the login requirement that affects regular YouTube videos on Cobalt.
+func toYouTubeMusicURL(rawURL string) string {
+	videoID, err := ExtractYouTubeVideoID(rawURL)
+	if err != nil {
+		return rawURL
+	}
+	return fmt.Sprintf("https://music.youtube.com/watch?v=%s", videoID)
+}
+
+func ExtractYouTubeVideoID(urlStr string) (string, error) {
+	if strings.Contains(urlStr, "youtu.be/") {
+		parts := strings.Split(urlStr, "youtu.be/")
+		if len(parts) >= 2 {
+			videoID := strings.Split(parts[1], "?")[0]
+			videoID = strings.Split(videoID, "&")[0]
+			return strings.TrimSpace(videoID), nil
+		}
+	}
+
+	parsed, err := url.Parse(urlStr)
+	if err != nil {
+		return "", fmt.Errorf("invalid URL: %w", err)
+	}
+
+	// /watch?v=
+	if v := parsed.Query().Get("v"); v != "" {
+		return v, nil
+	}
+
+	// /embed/
+	if strings.Contains(parsed.Path, "/embed/") {
+		parts := strings.Split(parsed.Path, "/embed/")
+		if len(parts) >= 2 {
+			return strings.Split(parts[1], "/")[0], nil
+		}
+	}
+
+	// /v/
+	if strings.Contains(parsed.Path, "/v/") {
+		parts := strings.Split(parsed.Path, "/v/")
+		if len(parts) >= 2 {
+			return strings.Split(parts[1], "/")[0], nil
+		}
+	}
+
+	return "", fmt.Errorf("could not extract video ID from URL")
+}
+
+func downloadFromYouTube(req DownloadRequest) (YouTubeDownloadResult, error) {
+	downloader := NewYouTubeDownloader()
+
+	var quality YouTubeQuality
+	switch strings.ToLower(req.Quality) {
+	case "opus_256", "opus256", "opus":
+		quality = YouTubeQualityOpus256
+	case "mp3_320", "mp3320", "mp3":
+		quality = YouTubeQualityMP3320
+	default:
+		quality = YouTubeQualityMP3320 // Default to MP3 320kbps
+	}
+
+	// URL lookup priority: YouTube video ID > Spotify ID > Deezer ID > ISRC
+	var youtubeURL string
+	var lookupErr error
+
+	// SpotifyID might actually be a YouTube video ID (from YT Music extension)
+	if req.SpotifyID != "" && isYouTubeVideoID(req.SpotifyID) {
+		youtubeURL = BuildYouTubeWatchURL(req.SpotifyID)
+		GoLog("[YouTube] SpotifyID appears to be YouTube video ID, using directly: %s\n", youtubeURL)
+	}
+
+	// Try Spotify ID via SongLink
+	if youtubeURL == "" && req.SpotifyID != "" && !isYouTubeVideoID(req.SpotifyID) {
+		GoLog("[YouTube] Looking up YouTube URL via SongLink for Spotify ID: %s\n", req.SpotifyID)
+		songlink := NewSongLinkClient()
+		youtubeURL, lookupErr = songlink.GetYouTubeURLFromSpotify(req.SpotifyID)
+		if lookupErr != nil {
+			GoLog("[YouTube] SongLink Spotify lookup failed: %v\n", lookupErr)
+		} else {
+			GoLog("[YouTube] Found YouTube URL via SongLink (Spotify): %s\n", youtubeURL)
+		}
+	}
+
+	// Try Deezer ID via SongLink
+	if youtubeURL == "" && req.DeezerID != "" {
+		GoLog("[YouTube] Looking up YouTube URL via SongLink for Deezer ID: %s\n", req.DeezerID)
+		songlink := NewSongLinkClient()
+		youtubeURL, lookupErr = songlink.GetYouTubeURLFromDeezer(req.DeezerID)
+		if lookupErr != nil {
+			GoLog("[YouTube] SongLink Deezer lookup failed: %v\n", lookupErr)
+		} else {
+			GoLog("[YouTube] Found YouTube URL via SongLink (Deezer): %s\n", youtubeURL)
+		}
+	}
+
+	// Try ISRC via SongLink
+	if youtubeURL == "" && req.ISRC != "" {
+		GoLog("[YouTube] Looking up YouTube URL via SongLink for ISRC: %s\n", req.ISRC)
+		songlink := NewSongLinkClient()
+		availability, isrcErr := songlink.CheckTrackAvailability("", req.ISRC)
+		if isrcErr == nil && availability.YouTube && availability.YouTubeURL != "" {
+			youtubeURL = availability.YouTubeURL
+			GoLog("[YouTube] Found YouTube URL via SongLink (ISRC): %s\n", youtubeURL)
+		} else if isrcErr != nil {
+			GoLog("[YouTube] SongLink ISRC lookup failed: %v\n", isrcErr)
+		}
+	}
+
+	// Cobalt requires direct video URLs, not search URLs
+	if youtubeURL == "" {
+		return YouTubeDownloadResult{}, fmt.Errorf("could not find YouTube URL for track: %s - %s (no Spotify/Deezer ID available or track not on YouTube)", req.ArtistName, req.TrackName)
+	}
+
+	GoLog("[YouTube] Requesting download from Cobalt for: %s\n", youtubeURL)
+
+	cobaltResp, err := downloader.GetDownloadURL(youtubeURL, quality)
+	if err != nil {
+		return YouTubeDownloadResult{}, fmt.Errorf("failed to get download URL: %w", err)
+	}
+
+	var ext string
+	var format string
+	var bitrate int
+	switch quality {
+	case YouTubeQualityOpus256:
+		ext = ".opus"
+		format = "opus"
+		bitrate = 256
+	case YouTubeQualityMP3320:
+		ext = ".mp3"
+		format = "mp3"
+		bitrate = 320
+	}
+
+	filename := buildFilenameFromTemplate(req.FilenameFormat, map[string]any{
+		"title":  req.TrackName,
+		"artist": req.ArtistName,
+		"album":  req.AlbumName,
+		"track":  req.TrackNumber,
+		"year":   extractYear(req.ReleaseDate),
+		"disc":   req.DiscNumber,
+	})
+	filename = sanitizeFilename(filename) + ext
+
+	var outputPath string
+	isSafOutput := isFDOutput(req.OutputFD) || strings.TrimSpace(req.OutputPath) != ""
+	if isSafOutput {
+		outputPath = strings.TrimSpace(req.OutputPath)
+		if outputPath == "" && isFDOutput(req.OutputFD) {
+			outputPath = fmt.Sprintf("/proc/self/fd/%d", req.OutputFD)
+		}
+	} else {
+		outputPath = req.OutputDir + "/" + filename
+	}
+
+	GoLog("[YouTube] Downloading to: %s\n", outputPath)
+
+	// Parallel fetch cover art + lyrics
+	var parallelResult *ParallelDownloadResult
+	if req.EmbedLyrics || req.CoverURL != "" {
+		GoLog("[YouTube] Starting parallel fetch for cover and lyrics...\n")
+		parallelResult = FetchCoverAndLyricsParallel(
+			req.CoverURL,
+			req.EmbedMaxQualityCover,
+			req.SpotifyID,
+			req.TrackName,
+			req.ArtistName,
+			req.EmbedLyrics,
+			int64(req.DurationMS),
+		)
+	}
+
+	if err := downloader.DownloadFile(cobaltResp.URL, outputPath, req.OutputFD, req.ItemID); err != nil {
+		return YouTubeDownloadResult{}, fmt.Errorf("download failed: %w", err)
+	}
+
+	lyricsLRC := ""
+	var coverData []byte
+	if parallelResult != nil {
+		if parallelResult.LyricsLRC != "" {
+			lyricsLRC = parallelResult.LyricsLRC
+			GoLog("[YouTube] Got lyrics from lrclib (%d lines)\n", len(parallelResult.LyricsData.Lines))
+		}
+		if parallelResult.CoverData != nil {
+			coverData = parallelResult.CoverData
+			GoLog("[YouTube] Got cover art (%d bytes)\n", len(coverData))
+		}
+	}
+
+	return YouTubeDownloadResult{
+		FilePath:    outputPath,
+		Title:       req.TrackName,
+		Artist:      req.ArtistName,
+		Album:       req.AlbumName,
+		ReleaseDate: req.ReleaseDate,
+		TrackNumber: req.TrackNumber,
+		DiscNumber:  req.DiscNumber,
+		ISRC:        req.ISRC,
+		Format:      format,
+		Bitrate:     bitrate,
+		LyricsLRC:   lyricsLRC,
+		CoverData:   coverData,
+	}, nil
+}
@@ -217,12 +217,21 @@ import Gobackend  // Import Go framework
            if let error = error { throw error }
            return response
            
+        case "editFileMetadata":
+            let args = call.arguments as! [String: Any]
+            let filePath = args["file_path"] as! String
+            let metadataJson = args["metadata_json"] as? String ?? "{}"
+            let response = GobackendEditFileMetadata(filePath, metadataJson, &error)
+            if let error = error { throw error }
+            return response
+            
        case "searchDeezerAll":
            let args = call.arguments as! [String: Any]
            let query = args["query"] as! String
            let trackLimit = args["track_limit"] as? Int ?? 15
            let artistLimit = args["artist_limit"] as? Int ?? 3
-            let response = GobackendSearchDeezerAll(query, Int(trackLimit), Int(artistLimit), &error)
+            let filter = args["filter"] as? String ?? ""
+            let response = GobackendSearchDeezerAll(query, Int(trackLimit), Int(artistLimit), filter, &error)
            if let error = error { throw error }
            return response

@@ -241,6 +250,20 @@ import Gobackend  // Import Go framework
            if let error = error { throw error }
            return response

+        case "parseTidalUrl":
+            let args = call.arguments as! [String: Any]
+            let url = args["url"] as! String
+            let response = GobackendParseTidalURLExport(url, &error)
+            if let error = error { throw error }
+            return response
+
+        case "convertTidalToSpotifyDeezer":
+            let args = call.arguments as! [String: Any]
+            let url = args["url"] as! String
+            let response = GobackendConvertTidalToSpotifyDeezer(url, &error)
+            if let error = error { throw error }
+            return response
+
        case "searchDeezerByISRC":
            let args = call.arguments as! [String: Any]
            let isrc = args["isrc"] as! String
@@ -624,6 +647,14 @@ import Gobackend  // Import Go framework
            let response = GobackendRunPostProcessingJSON(filePath, metadataJson, &error)
            if let error = error { throw error }
            return response
+
+        case "runPostProcessingV2":
+            let args = call.arguments as! [String: Any]
+            let inputJson = args["input"] as? String ?? ""
+            let metadataJson = args["metadata"] as? String ?? ""
+            let response = GobackendRunPostProcessingV2JSON(inputJson, metadataJson, &error)
+            if let error = error { throw error }
+            return response
            
        case "getPostProcessingProviders":
            let response = GobackendGetPostProcessingProvidersJSON(&error)
@@ -686,6 +717,43 @@ import Gobackend  // Import Go framework
            if let error = error { throw error }
            return response
            
+        // Local Library Scanning
+        case "setLibraryCoverCacheDir":
+            let args = call.arguments as! [String: Any]
+            let cacheDir = args["cache_dir"] as! String
+            GobackendSetLibraryCoverCacheDirJSON(cacheDir)
+            return nil
+            
+        case "scanLibraryFolder":
+            let args = call.arguments as! [String: Any]
+            let folderPath = args["folder_path"] as! String
+            let response = GobackendScanLibraryFolderJSON(folderPath, &error)
+            if let error = error { throw error }
+            return response
+            
+        case "scanLibraryFolderIncremental":
+            let args = call.arguments as! [String: Any]
+            let folderPath = args["folder_path"] as! String
+            let existingFiles = args["existing_files"] as? String ?? "{}"
+            let response = GobackendScanLibraryFolderIncrementalJSON(folderPath, existingFiles, &error)
+            if let error = error { throw error }
+            return response
+            
+        case "getLibraryScanProgress":
+            let response = GobackendGetLibraryScanProgressJSON()
+            return response
+            
+        case "cancelLibraryScan":
+            GobackendCancelLibraryScanJSON()
+            return nil
+            
+        case "readAudioMetadata":
+            let args = call.arguments as! [String: Any]
+            let filePath = args["file_path"] as! String
+            let response = GobackendReadAudioMetadataJSON(filePath, &error)
+            if let error = error { throw error }
+            return response
+            
        default:
            throw NSError(
                domain: "SpotiFLAC",
@@ -67,7 +67,7 @@
 	<key>NSAppTransportSecurity</key>
 	<dict>
 		<key>NSAllowsArbitraryLoads</key>
-		<true/>
+		<false/>
 	</dict>
 	
 	<!-- File Sharing - Allow access via Files app -->
@@ -81,5 +81,29 @@
 	<!-- Photo Library (for cover art if needed) -->
 	<key>NSPhotoLibraryUsageDescription</key>
 	<string>SpotiFLAC needs access to save album artwork</string>
+	
+	<!-- URL Schemes for deep linking -->
+	<key>CFBundleURLTypes</key>
+	<array>
+		<dict>
+			<key>CFBundleTypeRole</key>
+			<string>Viewer</string>
+			<key>CFBundleURLName</key>
+			<string>com.zarz.spotiflac</string>
+			<key>CFBundleURLSchemes</key>
+			<array>
+				<string>spotiflac</string>
+			</array>
+		</dict>
+	</array>
+	
+	<!-- Associated Domains for Universal Links -->
+	<key>LSApplicationQueriesSchemes</key>
+	<array>
+		<string>spotify</string>
+		<string>deezer</string>
+		<string>tidal</string>
+		<string>youtube-music</string>
+	</array>
 </dict>
 </plist>
@@ -4,15 +4,27 @@ import 'package:flutter_localizations/flutter_localizations.dart';
 import 'package:go_router/go_router.dart';
 import 'package:spotiflac_android/screens/main_shell.dart';
 import 'package:spotiflac_android/screens/setup_screen.dart';
+import 'package:spotiflac_android/screens/tutorial_screen.dart';
 import 'package:spotiflac_android/providers/settings_provider.dart';
 import 'package:spotiflac_android/theme/dynamic_color_wrapper.dart';
 import 'package:spotiflac_android/l10n/app_localizations.dart';

 final _routerProvider = Provider<GoRouter>((ref) {
  final isFirstLaunch = ref.watch(settingsProvider.select((s) => s.isFirstLaunch));
+  final hasCompletedTutorial = ref.watch(settingsProvider.select((s) => s.hasCompletedTutorial));
+  
+  // Determine initial location based on app state
+  String initialLocation;
+  if (isFirstLaunch) {
+    initialLocation = '/setup';
+  } else if (!hasCompletedTutorial) {
+    initialLocation = '/tutorial';
+  } else {
+    initialLocation = '/';
+  }
  
  return GoRouter(
-    initialLocation: isFirstLaunch ? '/setup' : '/',
+    initialLocation: initialLocation,
    routes: [
      GoRoute(
        path: '/',
@@ -22,6 +34,10 @@ final _routerProvider = Provider<GoRouter>((ref) {
        path: '/setup',
        builder: (context, state) => const SetupScreen(),
      ),
+      GoRoute(
+        path: '/tutorial',
+        builder: (context, state) => const TutorialScreen(),
+      ),
    ],
  );
 });
@@ -1,8 +1,8 @@
 /// App version and info constants
 /// Update version here only - all other files will reference this
 class AppInfo {
-static const String version = '3.2.0';
-  static const String buildNumber = '63';
+  static const String version = '3.6.0';
+  static const String buildNumber = '77';
  static const String fullVersion = '$version+$buildNumber';
  
  
@@ -17,4 +17,6 @@ static const String version = '3.2.0';
  static const String originalGithubUrl = 'https://github.com/afkarxyz/SpotiFLAC';
  
  static const String kofiUrl = 'https://ko-fi.com/zarzet';
+  static const String bmacUrl = 'https://buymeacoffee.com/zarzet';
+  static const String githubSponsorsUrl = 'https://github.com/sponsors/zarzet/';
 }
@@ -18,6 +18,9 @@ class AppLocalizationsEn extends AppLocalizations {
  @override
  String get navHome => 'Home';

+  @override
+  String get navLibrary => 'Library';
+
  @override
  String get navHistory => 'History';

@@ -340,6 +343,10 @@ class AppLocalizationsEn extends AppLocalizations {
  String get optionsSpotifyWarning =>
      'Spotify requires your own API credentials. Get them free from developer.spotify.com';

+  @override
+  String get optionsSpotifyDeprecationWarning =>
+      'Spotify search will be deprecated on March 3, 2026 due to Spotify API changes. Please switch to Deezer.';
+
  @override
  String get extensionsTitle => 'Extensions';

@@ -470,6 +477,10 @@ class AppLocalizationsEn extends AppLocalizations {
  String get aboutSachinsenalDesc =>
      'The original HiFi project creator. The foundation of Tidal integration!';

+  @override
+  String get aboutSjdonadoDesc =>
+      'Creator of I Don\'t Have Spotify (IDHS). The fallback link resolver that saves the day!';
+
  @override
  String get aboutDoubleDouble => 'DoubleDouble';

@@ -484,6 +495,13 @@ class AppLocalizationsEn extends AppLocalizations {
  String get aboutDabMusicDesc =>
      'The best Qobuz streaming API. Hi-Res downloads wouldn\'t be possible without this!';

+  @override
+  String get aboutSpotiSaver => 'SpotiSaver';
+
+  @override
+  String get aboutSpotiSaverDesc =>
+      'Tidal Hi-Res FLAC streaming endpoints. A key piece of the lossless puzzle!';
+
  @override
  String get aboutAppDescription =>
      'Download Spotify tracks in lossless quality from Tidal, Qobuz, and Amazon Music.';
@@ -680,6 +698,10 @@ class AppLocalizationsEn extends AppLocalizations {
  String get setupIosEmptyFolderWarning =>
      'iOS limitation: Empty folders cannot be selected. Choose a folder with at least one file.';

+  @override
+  String get setupIcloudNotSupported =>
+      'iCloud Drive is not supported. Please use the app Documents folder.';
+
  @override
  String get setupDownloadInFlac => 'Download Spotify tracks in FLAC';

@@ -935,6 +957,11 @@ class AppLocalizationsEn extends AppLocalizations {
    return '\"$trackName\" already downloaded';
  }

+  @override
+  String snackbarAlreadyInLibrary(String trackName) {
+    return '\"$trackName\" already exists in your library';
+  }
+
  @override
  String get snackbarHistoryCleared => 'History cleared';

@@ -1618,6 +1645,15 @@ class AppLocalizationsEn extends AppLocalizations {
  @override
  String get trackLyricsLoadFailed => 'Failed to load lyrics';

+  @override
+  String get trackEmbedLyrics => 'Embed Lyrics';
+
+  @override
+  String get trackLyricsEmbedded => 'Lyrics embedded successfully';
+
+  @override
+  String get trackInstrumental => 'Instrumental track';
+
  @override
  String get trackCopiedToClipboard => 'Copied to clipboard';

@@ -1847,25 +1883,45 @@ class AppLocalizationsEn extends AppLocalizations {
  String get qualityHiResFlacMaxSubtitle => '24-bit / up to 192kHz';

  @override
-  String get qualityMp3 => 'MP3';
+  String get qualityLossy => 'Lossy';

  @override
-  String get qualityMp3Subtitle => '320kbps (converted from FLAC)';
+  String get qualityLossyMp3Subtitle => 'MP3 320kbps (converted from FLAC)';

  @override
-  String get enableMp3Option => 'Enable MP3 Option';
+  String get qualityLossyOpusSubtitle => 'Opus 128kbps (converted from FLAC)';

  @override
-  String get enableMp3OptionSubtitleOn => 'MP3 quality option is available';
+  String get enableLossyOption => 'Enable Lossy Option';

  @override
-  String get enableMp3OptionSubtitleOff =>
-      'Downloads FLAC then converts to 320kbps MP3';
+  String get enableLossyOptionSubtitleOn => 'Lossy quality option is available';
+
+  @override
+  String get enableLossyOptionSubtitleOff =>
+      'Downloads FLAC then converts to lossy format';
+
+  @override
+  String get lossyFormat => 'Lossy Format';
+
+  @override
+  String get lossyFormatDescription => 'Choose the lossy format for conversion';
+
+  @override
+  String get lossyFormatMp3Subtitle => '320kbps, best compatibility';
+
+  @override
+  String get lossyFormatOpusSubtitle =>
+      '128kbps, better quality at smaller size';

  @override
  String get qualityNote =>
      'Actual quality depends on track availability from the service';

+  @override
+  String get youtubeQualityNote =>
+      'YouTube provides lossy audio only. Not part of lossless fallback.';
+
  @override
  String get downloadAskBeforeDownload => 'Ask Before Download';

@@ -1878,6 +1934,17 @@ class AppLocalizationsEn extends AppLocalizations {
  @override
  String get downloadAlbumFolderStructure => 'Album Folder Structure';

+  @override
+  String get downloadUseAlbumArtistForFolders => 'Use Album Artist for folders';
+
+  @override
+  String get downloadUseAlbumArtistForFoldersAlbumSubtitle =>
+      'Artist folders use Album Artist when available';
+
+  @override
+  String get downloadUseAlbumArtistForFoldersTrackSubtitle =>
+      'Artist folders use Track Artist only';
+
  @override
  String get downloadSaveFormat => 'Save Format';

@@ -1957,6 +2024,39 @@ class AppLocalizationsEn extends AppLocalizations {
  String get queueClearAllMessage =>
      'Are you sure you want to clear all downloads?';

+  @override
+  String get queueExportFailed => 'Export';
+
+  @override
+  String get queueExportFailedSuccess =>
+      'Failed downloads exported to TXT file';
+
+  @override
+  String get queueExportFailedClear => 'Clear Failed';
+
+  @override
+  String get queueExportFailedError => 'Failed to export downloads';
+
+  @override
+  String get settingsAutoExportFailed => 'Auto-export failed downloads';
+
+  @override
+  String get settingsAutoExportFailedSubtitle =>
+      'Save failed downloads to TXT file automatically';
+
+  @override
+  String get settingsDownloadNetwork => 'Download Network';
+
+  @override
+  String get settingsDownloadNetworkAny => 'WiFi + Mobile Data';
+
+  @override
+  String get settingsDownloadNetworkWifiOnly => 'WiFi Only';
+
+  @override
+  String get settingsDownloadNetworkSubtitle =>
+      'Choose which network to use for downloads. When set to WiFi Only, downloads will pause on mobile data.';
+
  @override
  String get queueEmpty => 'No downloads in queue';

@@ -2006,6 +2106,13 @@ class AppLocalizationsEn extends AppLocalizations {
  @override
  String get albumFolderYearAlbumSubtitle => 'Albums/[2005] Album Name/';

+  @override
+  String get albumFolderArtistAlbumSingles => 'Artist / Album + Singles';
+
+  @override
+  String get albumFolderArtistAlbumSinglesSubtitle =>
+      'Artist/Album/ and Artist/Singles/';
+
  @override
  String get downloadedAlbumDeleteSelected => 'Delete Selected';

@@ -2073,6 +2180,12 @@ class AppLocalizationsEn extends AppLocalizations {
  @override
  String get recentTypePlaylist => 'Playlist';

+  @override
+  String get recentEmpty => 'No recent items yet';
+
+  @override
+  String get recentShowAllDownloads => 'Show All Downloads';
+
  @override
  String recentPlaylistInfo(String name) {
    return 'Playlist: $name';
@@ -2148,4 +2261,632 @@ class AppLocalizationsEn extends AppLocalizations {

  @override
  String get discographyFailedToFetch => 'Failed to fetch some albums';
+
+  @override
+  String get sectionStorageAccess => 'Storage Access';
+
+  @override
+  String get allFilesAccess => 'All Files Access';
+
+  @override
+  String get allFilesAccessEnabledSubtitle => 'Can write to any folder';
+
+  @override
+  String get allFilesAccessDisabledSubtitle => 'Limited to media folders only';
+
+  @override
+  String get allFilesAccessDescription =>
+      'Enable this if you encounter write errors when saving to custom folders. Android 13+ restricts access to certain directories by default.';
+
+  @override
+  String get allFilesAccessDeniedMessage =>
+      'Permission was denied. Please enable \'All files access\' manually in system settings.';
+
+  @override
+  String get allFilesAccessDisabledMessage =>
+      'All Files Access disabled. The app will use limited storage access.';
+
+  @override
+  String get settingsLocalLibrary => 'Local Library';
+
+  @override
+  String get settingsLocalLibrarySubtitle => 'Scan music & detect duplicates';
+
+  @override
+  String get settingsCache => 'Storage & Cache';
+
+  @override
+  String get settingsCacheSubtitle => 'View size and clear cached data';
+
+  @override
+  String get libraryTitle => 'Local Library';
+
+  @override
+  String get libraryStatus => 'Library Status';
+
+  @override
+  String get libraryScanSettings => 'Scan Settings';
+
+  @override
+  String get libraryEnableLocalLibrary => 'Enable Local Library';
+
+  @override
+  String get libraryEnableLocalLibrarySubtitle =>
+      'Scan and track your existing music';
+
+  @override
+  String get libraryFolder => 'Library Folder';
+
+  @override
+  String get libraryFolderHint => 'Tap to select folder';
+
+  @override
+  String get libraryShowDuplicateIndicator => 'Show Duplicate Indicator';
+
+  @override
+  String get libraryShowDuplicateIndicatorSubtitle =>
+      'Show when searching for existing tracks';
+
+  @override
+  String get libraryActions => 'Actions';
+
+  @override
+  String get libraryScan => 'Scan Library';
+
+  @override
+  String get libraryScanSubtitle => 'Scan for audio files';
+
+  @override
+  String get libraryScanSelectFolderFirst => 'Select a folder first';
+
+  @override
+  String get libraryCleanupMissingFiles => 'Cleanup Missing Files';
+
+  @override
+  String get libraryCleanupMissingFilesSubtitle =>
+      'Remove entries for files that no longer exist';
+
+  @override
+  String get libraryClear => 'Clear Library';
+
+  @override
+  String get libraryClearSubtitle => 'Remove all scanned tracks';
+
+  @override
+  String get libraryClearConfirmTitle => 'Clear Library';
+
+  @override
+  String get libraryClearConfirmMessage =>
+      'This will remove all scanned tracks from your library. Your actual music files will not be deleted.';
+
+  @override
+  String get libraryAbout => 'About Local Library';
+
+  @override
+  String get libraryAboutDescription =>
+      'Scans your existing music collection to detect duplicates when downloading. Supports FLAC, M4A, MP3, Opus, and OGG formats. Metadata is read from file tags when available.';
+
+  @override
+  String libraryTracksCount(int count) {
+    return '$count tracks';
+  }
+
+  @override
+  String libraryLastScanned(String time) {
+    return 'Last scanned: $time';
+  }
+
+  @override
+  String get libraryLastScannedNever => 'Never';
+
+  @override
+  String get libraryScanning => 'Scanning...';
+
+  @override
+  String libraryScanProgress(String progress, int total) {
+    return '$progress% of $total files';
+  }
+
+  @override
+  String get libraryInLibrary => 'In Library';
+
+  @override
+  String libraryRemovedMissingFiles(int count) {
+    return 'Removed $count missing files from library';
+  }
+
+  @override
+  String get libraryCleared => 'Library cleared';
+
+  @override
+  String get libraryStorageAccessRequired => 'Storage Access Required';
+
+  @override
+  String get libraryStorageAccessMessage =>
+      'SpotiFLAC needs storage access to scan your music library. Please grant permission in settings.';
+
+  @override
+  String get libraryFolderNotExist => 'Selected folder does not exist';
+
+  @override
+  String get librarySourceDownloaded => 'Downloaded';
+
+  @override
+  String get librarySourceLocal => 'Local';
+
+  @override
+  String get libraryFilterAll => 'All';
+
+  @override
+  String get libraryFilterDownloaded => 'Downloaded';
+
+  @override
+  String get libraryFilterLocal => 'Local';
+
+  @override
+  String get libraryFilterTitle => 'Filters';
+
+  @override
+  String get libraryFilterReset => 'Reset';
+
+  @override
+  String get libraryFilterApply => 'Apply';
+
+  @override
+  String get libraryFilterSource => 'Source';
+
+  @override
+  String get libraryFilterQuality => 'Quality';
+
+  @override
+  String get libraryFilterQualityHiRes => 'Hi-Res (24bit)';
+
+  @override
+  String get libraryFilterQualityCD => 'CD (16bit)';
+
+  @override
+  String get libraryFilterQualityLossy => 'Lossy';
+
+  @override
+  String get libraryFilterFormat => 'Format';
+
+  @override
+  String get libraryFilterDate => 'Date Added';
+
+  @override
+  String get libraryFilterDateToday => 'Today';
+
+  @override
+  String get libraryFilterDateWeek => 'This Week';
+
+  @override
+  String get libraryFilterDateMonth => 'This Month';
+
+  @override
+  String get libraryFilterDateYear => 'This Year';
+
+  @override
+  String get libraryFilterSort => 'Sort';
+
+  @override
+  String get libraryFilterSortLatest => 'Latest';
+
+  @override
+  String get libraryFilterSortOldest => 'Oldest';
+
+  @override
+  String libraryFilterActive(int count) {
+    return '$count filter(s) active';
+  }
+
+  @override
+  String get timeJustNow => 'Just now';
+
+  @override
+  String timeMinutesAgo(int count) {
+    String _temp0 = intl.Intl.pluralLogic(
+      count,
+      locale: localeName,
+      other: '$count minutes ago',
+      one: '1 minute ago',
+    );
+    return '$_temp0';
+  }
+
+  @override
+  String timeHoursAgo(int count) {
+    String _temp0 = intl.Intl.pluralLogic(
+      count,
+      locale: localeName,
+      other: '$count hours ago',
+      one: '1 hour ago',
+    );
+    return '$_temp0';
+  }
+
+  @override
+  String get storageSwitchTitle => 'Switch Storage Mode';
+
+  @override
+  String get storageSwitchToSafTitle => 'Switch to SAF Storage?';
+
+  @override
+  String get storageSwitchToAppTitle => 'Switch to App Storage?';
+
+  @override
+  String get storageSwitchToSafMessage =>
+      'Your existing downloads will remain in the current location and stay accessible.\n\nNew downloads will be saved to your selected SAF folder.';
+
+  @override
+  String get storageSwitchToAppMessage =>
+      'Your existing downloads will remain in the current SAF location and stay accessible.\n\nNew downloads will be saved to Music/SpotiFLAC folder.';
+
+  @override
+  String get storageSwitchExistingDownloads => 'Existing Downloads';
+
+  @override
+  String storageSwitchExistingDownloadsInfo(int count, String mode) {
+    return '$count tracks in $mode storage';
+  }
+
+  @override
+  String get storageSwitchNewDownloads => 'New Downloads';
+
+  @override
+  String storageSwitchNewDownloadsLocation(String location) {
+    return 'Will be saved to: $location';
+  }
+
+  @override
+  String get storageSwitchContinue => 'Continue';
+
+  @override
+  String get storageSwitchSelectFolder => 'Select SAF Folder';
+
+  @override
+  String get storageAppStorage => 'App Storage';
+
+  @override
+  String get storageSafStorage => 'SAF Storage';
+
+  @override
+  String storageModeBadge(String mode) {
+    return 'Storage: $mode';
+  }
+
+  @override
+  String get storageStatsTitle => 'Storage Statistics';
+
+  @override
+  String storageStatsAppCount(int count) {
+    return '$count tracks in App Storage';
+  }
+
+  @override
+  String storageStatsSafCount(int count) {
+    return '$count tracks in SAF Storage';
+  }
+
+  @override
+  String get storageModeInfo => 'Your files are stored in multiple locations';
+
+  @override
+  String get tutorialWelcomeTitle => 'Welcome to SpotiFLAC!';
+
+  @override
+  String get tutorialWelcomeDesc =>
+      'Let\'s learn how to download your favorite music in lossless quality. This quick tutorial will show you the basics.';
+
+  @override
+  String get tutorialWelcomeTip1 =>
+      'Download music from Spotify, Deezer, or paste any supported URL';
+
+  @override
+  String get tutorialWelcomeTip2 =>
+      'Get FLAC quality audio from Tidal, Qobuz, or Amazon Music';
+
+  @override
+  String get tutorialWelcomeTip3 =>
+      'Automatic metadata, cover art, and lyrics embedding';
+
+  @override
+  String get tutorialSearchTitle => 'Finding Music';
+
+  @override
+  String get tutorialSearchDesc =>
+      'There are two easy ways to find music you want to download.';
+
+  @override
+  String get tutorialSearchTip1 =>
+      'Paste a Spotify or Deezer URL directly in the search box';
+
+  @override
+  String get tutorialSearchTip2 =>
+      'Or type the song name, artist, or album to search';
+
+  @override
+  String get tutorialSearchTip3 =>
+      'Supports tracks, albums, playlists, and artist pages';
+
+  @override
+  String get tutorialDownloadTitle => 'Downloading Music';
+
+  @override
+  String get tutorialDownloadDesc =>
+      'Downloading music is simple and fast. Here\'s how it works.';
+
+  @override
+  String get tutorialDownloadTip1 =>
+      'Tap the download button next to any track to start downloading';
+
+  @override
+  String get tutorialDownloadTip2 =>
+      'Choose your preferred quality (FLAC, Hi-Res, or MP3)';
+
+  @override
+  String get tutorialDownloadTip3 =>
+      'Download entire albums or playlists with one tap';
+
+  @override
+  String get tutorialLibraryTitle => 'Your Library';
+
+  @override
+  String get tutorialLibraryDesc =>
+      'All your downloaded music is organized in the Library tab.';
+
+  @override
+  String get tutorialLibraryTip1 =>
+      'View download progress and queue in the Library tab';
+
+  @override
+  String get tutorialLibraryTip2 =>
+      'Tap any track to play it with your music player';
+
+  @override
+  String get tutorialLibraryTip3 =>
+      'Switch between list and grid view for better browsing';
+
+  @override
+  String get tutorialExtensionsTitle => 'Extensions';
+
+  @override
+  String get tutorialExtensionsDesc =>
+      'Extend the app\'s capabilities with community extensions.';
+
+  @override
+  String get tutorialExtensionsTip1 =>
+      'Browse the Store tab to discover useful extensions';
+
+  @override
+  String get tutorialExtensionsTip2 =>
+      'Add new download providers or search sources';
+
+  @override
+  String get tutorialExtensionsTip3 =>
+      'Get lyrics, enhanced metadata, and more features';
+
+  @override
+  String get tutorialSettingsTitle => 'Customize Your Experience';
+
+  @override
+  String get tutorialSettingsDesc =>
+      'Personalize the app in Settings to match your preferences.';
+
+  @override
+  String get tutorialSettingsTip1 =>
+      'Change download location and folder organization';
+
+  @override
+  String get tutorialSettingsTip2 =>
+      'Set default audio quality and format preferences';
+
+  @override
+  String get tutorialSettingsTip3 => 'Customize app theme and appearance';
+
+  @override
+  String get tutorialReadyMessage =>
+      'You\'re all set! Start downloading your favorite music now.';
+
+  @override
+  String get tutorialExample => 'EXAMPLE';
+
+  @override
+  String get libraryForceFullScan => 'Force Full Scan';
+
+  @override
+  String get libraryForceFullScanSubtitle => 'Rescan all files, ignoring cache';
+
+  @override
+  String get cleanupOrphanedDownloads => 'Cleanup Orphaned Downloads';
+
+  @override
+  String get cleanupOrphanedDownloadsSubtitle =>
+      'Remove history entries for files that no longer exist';
+
+  @override
+  String cleanupOrphanedDownloadsResult(int count) {
+    return 'Removed $count orphaned entries from history';
+  }
+
+  @override
+  String get cleanupOrphanedDownloadsNone => 'No orphaned entries found';
+
+  @override
+  String get cacheTitle => 'Storage & Cache';
+
+  @override
+  String get cacheSummaryTitle => 'Cache overview';
+
+  @override
+  String get cacheSummarySubtitle =>
+      'Clearing cache will not remove downloaded music files.';
+
+  @override
+  String cacheEstimatedTotal(String size) {
+    return 'Estimated cache usage: $size';
+  }
+
+  @override
+  String get cacheSectionStorage => 'Cached Data';
+
+  @override
+  String get cacheSectionMaintenance => 'Maintenance';
+
+  @override
+  String get cacheAppDirectory => 'App cache directory';
+
+  @override
+  String get cacheAppDirectoryDesc =>
+      'HTTP responses, WebView data, and other temporary app data.';
+
+  @override
+  String get cacheTempDirectory => 'Temporary directory';
+
+  @override
+  String get cacheTempDirectoryDesc =>
+      'Temporary files from downloads and audio conversion.';
+
+  @override
+  String get cacheCoverImage => 'Cover image cache';
+
+  @override
+  String get cacheCoverImageDesc =>
+      'Downloaded album and track cover art. Will re-download when viewed.';
+
+  @override
+  String get cacheLibraryCover => 'Library cover cache';
+
+  @override
+  String get cacheLibraryCoverDesc =>
+      'Cover art extracted from local music files. Will re-extract on next scan.';
+
+  @override
+  String get cacheExploreFeed => 'Explore feed cache';
+
+  @override
+  String get cacheExploreFeedDesc =>
+      'Explore tab content (new releases, trending). Will refresh on next visit.';
+
+  @override
+  String get cacheTrackLookup => 'Track lookup cache';
+
+  @override
+  String get cacheTrackLookupDesc =>
+      'Spotify/Deezer track ID lookups. Clearing may slow next few searches.';
+
+  @override
+  String get cacheCleanupUnusedDesc =>
+      'Remove orphaned download history and library entries for missing files.';
+
+  @override
+  String get cacheNoData => 'No cached data';
+
+  @override
+  String cacheSizeWithFiles(String size, int count) {
+    return '$size in $count files';
+  }
+
+  @override
+  String cacheSizeOnly(String size) {
+    return '$size';
+  }
+
+  @override
+  String cacheEntries(int count) {
+    return '$count entries';
+  }
+
+  @override
+  String cacheClearSuccess(String target) {
+    return 'Cleared: $target';
+  }
+
+  @override
+  String get cacheClearConfirmTitle => 'Clear cache?';
+
+  @override
+  String cacheClearConfirmMessage(String target) {
+    return 'This will clear cached data for $target. Downloaded music files will not be deleted.';
+  }
+
+  @override
+  String get cacheClearAllConfirmTitle => 'Clear all cache?';
+
+  @override
+  String get cacheClearAllConfirmMessage =>
+      'This will clear all cache categories on this page. Downloaded music files will not be deleted.';
+
+  @override
+  String get cacheClearAll => 'Clear all cache';
+
+  @override
+  String get cacheCleanupUnused => 'Cleanup unused data';
+
+  @override
+  String get cacheCleanupUnusedSubtitle =>
+      'Remove orphaned download history and missing library entries';
+
+  @override
+  String cacheCleanupResult(int downloadCount, int libraryCount) {
+    return 'Cleanup completed: $downloadCount orphaned downloads, $libraryCount missing library entries';
+  }
+
+  @override
+  String get cacheRefreshStats => 'Refresh stats';
+
+  @override
+  String get trackSaveCoverArt => 'Save Cover Art';
+
+  @override
+  String get trackSaveCoverArtSubtitle => 'Save album art as .jpg file';
+
+  @override
+  String get trackSaveLyrics => 'Save Lyrics (.lrc)';
+
+  @override
+  String get trackSaveLyricsSubtitle => 'Fetch and save lyrics as .lrc file';
+
+  @override
+  String get trackReEnrich => 'Re-enrich Metadata';
+
+  @override
+  String get trackReEnrichSubtitle =>
+      'Re-embed metadata without re-downloading';
+
+  @override
+  String get trackReEnrichOnlineSubtitle =>
+      'Search metadata online and embed into file';
+
+  @override
+  String get trackEditMetadata => 'Edit Metadata';
+
+  @override
+  String trackCoverSaved(String fileName) {
+    return 'Cover art saved to $fileName';
+  }
+
+  @override
+  String get trackCoverNoSource => 'No cover art source available';
+
+  @override
+  String trackLyricsSaved(String fileName) {
+    return 'Lyrics saved to $fileName';
+  }
+
+  @override
+  String get trackReEnrichProgress => 'Re-enriching metadata...';
+
+  @override
+  String get trackReEnrichSearching => 'Searching metadata online...';
+
+  @override
+  String get trackReEnrichSuccess => 'Metadata re-enriched successfully';
+
+  @override
+  String get trackReEnrichFfmpegFailed => 'FFmpeg metadata embed failed';
+
+  @override
+  String trackSaveFailed(String error) {
+    return 'Failed: $error';
+  }
 }
@@ -18,6 +18,9 @@ class AppLocalizationsEs extends AppLocalizations {
  @override
  String get navHome => 'Home';

+  @override
+  String get navLibrary => 'Library';
+
  @override
  String get navHistory => 'History';

@@ -340,6 +343,10 @@ class AppLocalizationsEs extends AppLocalizations {
  String get optionsSpotifyWarning =>
      'Spotify requires your own API credentials. Get them free from developer.spotify.com';

+  @override
+  String get optionsSpotifyDeprecationWarning =>
+      'Spotify search will be deprecated on March 3, 2026 due to Spotify API changes. Please switch to Deezer.';
+
  @override
  String get extensionsTitle => 'Extensions';

@@ -470,6 +477,10 @@ class AppLocalizationsEs extends AppLocalizations {
  String get aboutSachinsenalDesc =>
      'The original HiFi project creator. The foundation of Tidal integration!';

+  @override
+  String get aboutSjdonadoDesc =>
+      'Creator of I Don\'t Have Spotify (IDHS). The fallback link resolver that saves the day!';
+
  @override
  String get aboutDoubleDouble => 'DoubleDouble';

@@ -484,6 +495,13 @@ class AppLocalizationsEs extends AppLocalizations {
  String get aboutDabMusicDesc =>
      'The best Qobuz streaming API. Hi-Res downloads wouldn\'t be possible without this!';

+  @override
+  String get aboutSpotiSaver => 'SpotiSaver';
+
+  @override
+  String get aboutSpotiSaverDesc =>
+      'Tidal Hi-Res FLAC streaming endpoints. A key piece of the lossless puzzle!';
+
  @override
  String get aboutAppDescription =>
      'Download Spotify tracks in lossless quality from Tidal, Qobuz, and Amazon Music.';
@@ -680,6 +698,10 @@ class AppLocalizationsEs extends AppLocalizations {
  String get setupIosEmptyFolderWarning =>
      'iOS limitation: Empty folders cannot be selected. Choose a folder with at least one file.';

+  @override
+  String get setupIcloudNotSupported =>
+      'iCloud Drive is not supported. Please use the app Documents folder.';
+
  @override
  String get setupDownloadInFlac => 'Download Spotify tracks in FLAC';

@@ -935,6 +957,11 @@ class AppLocalizationsEs extends AppLocalizations {
    return '\"$trackName\" already downloaded';
  }

+  @override
+  String snackbarAlreadyInLibrary(String trackName) {
+    return '\"$trackName\" already exists in your library';
+  }
+
  @override
  String get snackbarHistoryCleared => 'History cleared';

@@ -1618,6 +1645,15 @@ class AppLocalizationsEs extends AppLocalizations {
  @override
  String get trackLyricsLoadFailed => 'Failed to load lyrics';

+  @override
+  String get trackEmbedLyrics => 'Embed Lyrics';
+
+  @override
+  String get trackLyricsEmbedded => 'Lyrics embedded successfully';
+
+  @override
+  String get trackInstrumental => 'Instrumental track';
+
  @override
  String get trackCopiedToClipboard => 'Copied to clipboard';

@@ -1847,25 +1883,45 @@ class AppLocalizationsEs extends AppLocalizations {
  String get qualityHiResFlacMaxSubtitle => '24-bit / up to 192kHz';

  @override
-  String get qualityMp3 => 'MP3';
+  String get qualityLossy => 'Lossy';

  @override
-  String get qualityMp3Subtitle => '320kbps (converted from FLAC)';
+  String get qualityLossyMp3Subtitle => 'MP3 320kbps (converted from FLAC)';

  @override
-  String get enableMp3Option => 'Enable MP3 Option';
+  String get qualityLossyOpusSubtitle => 'Opus 128kbps (converted from FLAC)';

  @override
-  String get enableMp3OptionSubtitleOn => 'MP3 quality option is available';
+  String get enableLossyOption => 'Enable Lossy Option';

  @override
-  String get enableMp3OptionSubtitleOff =>
-      'Downloads FLAC then converts to 320kbps MP3';
+  String get enableLossyOptionSubtitleOn => 'Lossy quality option is available';
+
+  @override
+  String get enableLossyOptionSubtitleOff =>
+      'Downloads FLAC then converts to lossy format';
+
+  @override
+  String get lossyFormat => 'Lossy Format';
+
+  @override
+  String get lossyFormatDescription => 'Choose the lossy format for conversion';
+
+  @override
+  String get lossyFormatMp3Subtitle => '320kbps, best compatibility';
+
+  @override
+  String get lossyFormatOpusSubtitle =>
+      '128kbps, better quality at smaller size';

  @override
  String get qualityNote =>
      'Actual quality depends on track availability from the service';

+  @override
+  String get youtubeQualityNote =>
+      'YouTube provides lossy audio only. Not part of lossless fallback.';
+
  @override
  String get downloadAskBeforeDownload => 'Ask Before Download';

@@ -1878,6 +1934,17 @@ class AppLocalizationsEs extends AppLocalizations {
  @override
  String get downloadAlbumFolderStructure => 'Album Folder Structure';

+  @override
+  String get downloadUseAlbumArtistForFolders => 'Use Album Artist for folders';
+
+  @override
+  String get downloadUseAlbumArtistForFoldersAlbumSubtitle =>
+      'Artist folders use Album Artist when available';
+
+  @override
+  String get downloadUseAlbumArtistForFoldersTrackSubtitle =>
+      'Artist folders use Track Artist only';
+
  @override
  String get downloadSaveFormat => 'Save Format';

@@ -1957,6 +2024,39 @@ class AppLocalizationsEs extends AppLocalizations {
  String get queueClearAllMessage =>
      'Are you sure you want to clear all downloads?';

+  @override
+  String get queueExportFailed => 'Export';
+
+  @override
+  String get queueExportFailedSuccess =>
+      'Failed downloads exported to TXT file';
+
+  @override
+  String get queueExportFailedClear => 'Clear Failed';
+
+  @override
+  String get queueExportFailedError => 'Failed to export downloads';
+
+  @override
+  String get settingsAutoExportFailed => 'Auto-export failed downloads';
+
+  @override
+  String get settingsAutoExportFailedSubtitle =>
+      'Save failed downloads to TXT file automatically';
+
+  @override
+  String get settingsDownloadNetwork => 'Download Network';
+
+  @override
+  String get settingsDownloadNetworkAny => 'WiFi + Mobile Data';
+
+  @override
+  String get settingsDownloadNetworkWifiOnly => 'WiFi Only';
+
+  @override
+  String get settingsDownloadNetworkSubtitle =>
+      'Choose which network to use for downloads. When set to WiFi Only, downloads will pause on mobile data.';
+
  @override
  String get queueEmpty => 'No downloads in queue';

@@ -2006,6 +2106,13 @@ class AppLocalizationsEs extends AppLocalizations {
  @override
  String get albumFolderYearAlbumSubtitle => 'Albums/[2005] Album Name/';

+  @override
+  String get albumFolderArtistAlbumSingles => 'Artist / Album + Singles';
+
+  @override
+  String get albumFolderArtistAlbumSinglesSubtitle =>
+      'Artist/Album/ and Artist/Singles/';
+
  @override
  String get downloadedAlbumDeleteSelected => 'Delete Selected';

@@ -2073,6 +2180,12 @@ class AppLocalizationsEs extends AppLocalizations {
  @override
  String get recentTypePlaylist => 'Playlist';

+  @override
+  String get recentEmpty => 'No recent items yet';
+
+  @override
+  String get recentShowAllDownloads => 'Show All Downloads';
+
  @override
  String recentPlaylistInfo(String name) {
    return 'Playlist: $name';
@@ -2148,6 +2261,634 @@ class AppLocalizationsEs extends AppLocalizations {

  @override
  String get discographyFailedToFetch => 'Failed to fetch some albums';
+
+  @override
+  String get sectionStorageAccess => 'Storage Access';
+
+  @override
+  String get allFilesAccess => 'All Files Access';
+
+  @override
+  String get allFilesAccessEnabledSubtitle => 'Can write to any folder';
+
+  @override
+  String get allFilesAccessDisabledSubtitle => 'Limited to media folders only';
+
+  @override
+  String get allFilesAccessDescription =>
+      'Enable this if you encounter write errors when saving to custom folders. Android 13+ restricts access to certain directories by default.';
+
+  @override
+  String get allFilesAccessDeniedMessage =>
+      'Permission was denied. Please enable \'All files access\' manually in system settings.';
+
+  @override
+  String get allFilesAccessDisabledMessage =>
+      'All Files Access disabled. The app will use limited storage access.';
+
+  @override
+  String get settingsLocalLibrary => 'Local Library';
+
+  @override
+  String get settingsLocalLibrarySubtitle => 'Scan music & detect duplicates';
+
+  @override
+  String get settingsCache => 'Storage & Cache';
+
+  @override
+  String get settingsCacheSubtitle => 'View size and clear cached data';
+
+  @override
+  String get libraryTitle => 'Local Library';
+
+  @override
+  String get libraryStatus => 'Library Status';
+
+  @override
+  String get libraryScanSettings => 'Scan Settings';
+
+  @override
+  String get libraryEnableLocalLibrary => 'Enable Local Library';
+
+  @override
+  String get libraryEnableLocalLibrarySubtitle =>
+      'Scan and track your existing music';
+
+  @override
+  String get libraryFolder => 'Library Folder';
+
+  @override
+  String get libraryFolderHint => 'Tap to select folder';
+
+  @override
+  String get libraryShowDuplicateIndicator => 'Show Duplicate Indicator';
+
+  @override
+  String get libraryShowDuplicateIndicatorSubtitle =>
+      'Show when searching for existing tracks';
+
+  @override
+  String get libraryActions => 'Actions';
+
+  @override
+  String get libraryScan => 'Scan Library';
+
+  @override
+  String get libraryScanSubtitle => 'Scan for audio files';
+
+  @override
+  String get libraryScanSelectFolderFirst => 'Select a folder first';
+
+  @override
+  String get libraryCleanupMissingFiles => 'Cleanup Missing Files';
+
+  @override
+  String get libraryCleanupMissingFilesSubtitle =>
+      'Remove entries for files that no longer exist';
+
+  @override
+  String get libraryClear => 'Clear Library';
+
+  @override
+  String get libraryClearSubtitle => 'Remove all scanned tracks';
+
+  @override
+  String get libraryClearConfirmTitle => 'Clear Library';
+
+  @override
+  String get libraryClearConfirmMessage =>
+      'This will remove all scanned tracks from your library. Your actual music files will not be deleted.';
+
+  @override
+  String get libraryAbout => 'About Local Library';
+
+  @override
+  String get libraryAboutDescription =>
+      'Scans your existing music collection to detect duplicates when downloading. Supports FLAC, M4A, MP3, Opus, and OGG formats. Metadata is read from file tags when available.';
+
+  @override
+  String libraryTracksCount(int count) {
+    return '$count tracks';
+  }
+
+  @override
+  String libraryLastScanned(String time) {
+    return 'Last scanned: $time';
+  }
+
+  @override
+  String get libraryLastScannedNever => 'Never';
+
+  @override
+  String get libraryScanning => 'Scanning...';
+
+  @override
+  String libraryScanProgress(String progress, int total) {
+    return '$progress% of $total files';
+  }
+
+  @override
+  String get libraryInLibrary => 'In Library';
+
+  @override
+  String libraryRemovedMissingFiles(int count) {
+    return 'Removed $count missing files from library';
+  }
+
+  @override
+  String get libraryCleared => 'Library cleared';
+
+  @override
+  String get libraryStorageAccessRequired => 'Storage Access Required';
+
+  @override
+  String get libraryStorageAccessMessage =>
+      'SpotiFLAC needs storage access to scan your music library. Please grant permission in settings.';
+
+  @override
+  String get libraryFolderNotExist => 'Selected folder does not exist';
+
+  @override
+  String get librarySourceDownloaded => 'Downloaded';
+
+  @override
+  String get librarySourceLocal => 'Local';
+
+  @override
+  String get libraryFilterAll => 'All';
+
+  @override
+  String get libraryFilterDownloaded => 'Downloaded';
+
+  @override
+  String get libraryFilterLocal => 'Local';
+
+  @override
+  String get libraryFilterTitle => 'Filters';
+
+  @override
+  String get libraryFilterReset => 'Reset';
+
+  @override
+  String get libraryFilterApply => 'Apply';
+
+  @override
+  String get libraryFilterSource => 'Source';
+
+  @override
+  String get libraryFilterQuality => 'Quality';
+
+  @override
+  String get libraryFilterQualityHiRes => 'Hi-Res (24bit)';
+
+  @override
+  String get libraryFilterQualityCD => 'CD (16bit)';
+
+  @override
+  String get libraryFilterQualityLossy => 'Lossy';
+
+  @override
+  String get libraryFilterFormat => 'Format';
+
+  @override
+  String get libraryFilterDate => 'Date Added';
+
+  @override
+  String get libraryFilterDateToday => 'Today';
+
+  @override
+  String get libraryFilterDateWeek => 'This Week';
+
+  @override
+  String get libraryFilterDateMonth => 'This Month';
+
+  @override
+  String get libraryFilterDateYear => 'This Year';
+
+  @override
+  String get libraryFilterSort => 'Sort';
+
+  @override
+  String get libraryFilterSortLatest => 'Latest';
+
+  @override
+  String get libraryFilterSortOldest => 'Oldest';
+
+  @override
+  String libraryFilterActive(int count) {
+    return '$count filter(s) active';
+  }
+
+  @override
+  String get timeJustNow => 'Just now';
+
+  @override
+  String timeMinutesAgo(int count) {
+    String _temp0 = intl.Intl.pluralLogic(
+      count,
+      locale: localeName,
+      other: '$count minutes ago',
+      one: '1 minute ago',
+    );
+    return '$_temp0';
+  }
+
+  @override
+  String timeHoursAgo(int count) {
+    String _temp0 = intl.Intl.pluralLogic(
+      count,
+      locale: localeName,
+      other: '$count hours ago',
+      one: '1 hour ago',
+    );
+    return '$_temp0';
+  }
+
+  @override
+  String get storageSwitchTitle => 'Switch Storage Mode';
+
+  @override
+  String get storageSwitchToSafTitle => 'Switch to SAF Storage?';
+
+  @override
+  String get storageSwitchToAppTitle => 'Switch to App Storage?';
+
+  @override
+  String get storageSwitchToSafMessage =>
+      'Your existing downloads will remain in the current location and stay accessible.\n\nNew downloads will be saved to your selected SAF folder.';
+
+  @override
+  String get storageSwitchToAppMessage =>
+      'Your existing downloads will remain in the current SAF location and stay accessible.\n\nNew downloads will be saved to Music/SpotiFLAC folder.';
+
+  @override
+  String get storageSwitchExistingDownloads => 'Existing Downloads';
+
+  @override
+  String storageSwitchExistingDownloadsInfo(int count, String mode) {
+    return '$count tracks in $mode storage';
+  }
+
+  @override
+  String get storageSwitchNewDownloads => 'New Downloads';
+
+  @override
+  String storageSwitchNewDownloadsLocation(String location) {
+    return 'Will be saved to: $location';
+  }
+
+  @override
+  String get storageSwitchContinue => 'Continue';
+
+  @override
+  String get storageSwitchSelectFolder => 'Select SAF Folder';
+
+  @override
+  String get storageAppStorage => 'App Storage';
+
+  @override
+  String get storageSafStorage => 'SAF Storage';
+
+  @override
+  String storageModeBadge(String mode) {
+    return 'Storage: $mode';
+  }
+
+  @override
+  String get storageStatsTitle => 'Storage Statistics';
+
+  @override
+  String storageStatsAppCount(int count) {
+    return '$count tracks in App Storage';
+  }
+
+  @override
+  String storageStatsSafCount(int count) {
+    return '$count tracks in SAF Storage';
+  }
+
+  @override
+  String get storageModeInfo => 'Your files are stored in multiple locations';
+
+  @override
+  String get tutorialWelcomeTitle => 'Welcome to SpotiFLAC!';
+
+  @override
+  String get tutorialWelcomeDesc =>
+      'Let\'s learn how to download your favorite music in lossless quality. This quick tutorial will show you the basics.';
+
+  @override
+  String get tutorialWelcomeTip1 =>
+      'Download music from Spotify, Deezer, or paste any supported URL';
+
+  @override
+  String get tutorialWelcomeTip2 =>
+      'Get FLAC quality audio from Tidal, Qobuz, or Amazon Music';
+
+  @override
+  String get tutorialWelcomeTip3 =>
+      'Automatic metadata, cover art, and lyrics embedding';
+
+  @override
+  String get tutorialSearchTitle => 'Finding Music';
+
+  @override
+  String get tutorialSearchDesc =>
+      'There are two easy ways to find music you want to download.';
+
+  @override
+  String get tutorialSearchTip1 =>
+      'Paste a Spotify or Deezer URL directly in the search box';
+
+  @override
+  String get tutorialSearchTip2 =>
+      'Or type the song name, artist, or album to search';
+
+  @override
+  String get tutorialSearchTip3 =>
+      'Supports tracks, albums, playlists, and artist pages';
+
+  @override
+  String get tutorialDownloadTitle => 'Downloading Music';
+
+  @override
+  String get tutorialDownloadDesc =>
+      'Downloading music is simple and fast. Here\'s how it works.';
+
+  @override
+  String get tutorialDownloadTip1 =>
+      'Tap the download button next to any track to start downloading';
+
+  @override
+  String get tutorialDownloadTip2 =>
+      'Choose your preferred quality (FLAC, Hi-Res, or MP3)';
+
+  @override
+  String get tutorialDownloadTip3 =>
+      'Download entire albums or playlists with one tap';
+
+  @override
+  String get tutorialLibraryTitle => 'Your Library';
+
+  @override
+  String get tutorialLibraryDesc =>
+      'All your downloaded music is organized in the Library tab.';
+
+  @override
+  String get tutorialLibraryTip1 =>
+      'View download progress and queue in the Library tab';
+
+  @override
+  String get tutorialLibraryTip2 =>
+      'Tap any track to play it with your music player';
+
+  @override
+  String get tutorialLibraryTip3 =>
+      'Switch between list and grid view for better browsing';
+
+  @override
+  String get tutorialExtensionsTitle => 'Extensions';
+
+  @override
+  String get tutorialExtensionsDesc =>
+      'Extend the app\'s capabilities with community extensions.';
+
+  @override
+  String get tutorialExtensionsTip1 =>
+      'Browse the Store tab to discover useful extensions';
+
+  @override
+  String get tutorialExtensionsTip2 =>
+      'Add new download providers or search sources';
+
+  @override
+  String get tutorialExtensionsTip3 =>
+      'Get lyrics, enhanced metadata, and more features';
+
+  @override
+  String get tutorialSettingsTitle => 'Customize Your Experience';
+
+  @override
+  String get tutorialSettingsDesc =>
+      'Personalize the app in Settings to match your preferences.';
+
+  @override
+  String get tutorialSettingsTip1 =>
+      'Change download location and folder organization';
+
+  @override
+  String get tutorialSettingsTip2 =>
+      'Set default audio quality and format preferences';
+
+  @override
+  String get tutorialSettingsTip3 => 'Customize app theme and appearance';
+
+  @override
+  String get tutorialReadyMessage =>
+      'You\'re all set! Start downloading your favorite music now.';
+
+  @override
+  String get tutorialExample => 'EXAMPLE';
+
+  @override
+  String get libraryForceFullScan => 'Force Full Scan';
+
+  @override
+  String get libraryForceFullScanSubtitle => 'Rescan all files, ignoring cache';
+
+  @override
+  String get cleanupOrphanedDownloads => 'Cleanup Orphaned Downloads';
+
+  @override
+  String get cleanupOrphanedDownloadsSubtitle =>
+      'Remove history entries for files that no longer exist';
+
+  @override
+  String cleanupOrphanedDownloadsResult(int count) {
+    return 'Removed $count orphaned entries from history';
+  }
+
+  @override
+  String get cleanupOrphanedDownloadsNone => 'No orphaned entries found';
+
+  @override
+  String get cacheTitle => 'Storage & Cache';
+
+  @override
+  String get cacheSummaryTitle => 'Cache overview';
+
+  @override
+  String get cacheSummarySubtitle =>
+      'Clearing cache will not remove downloaded music files.';
+
+  @override
+  String cacheEstimatedTotal(String size) {
+    return 'Estimated cache usage: $size';
+  }
+
+  @override
+  String get cacheSectionStorage => 'Cached Data';
+
+  @override
+  String get cacheSectionMaintenance => 'Maintenance';
+
+  @override
+  String get cacheAppDirectory => 'App cache directory';
+
+  @override
+  String get cacheAppDirectoryDesc =>
+      'HTTP responses, WebView data, and other temporary app data.';
+
+  @override
+  String get cacheTempDirectory => 'Temporary directory';
+
+  @override
+  String get cacheTempDirectoryDesc =>
+      'Temporary files from downloads and audio conversion.';
+
+  @override
+  String get cacheCoverImage => 'Cover image cache';
+
+  @override
+  String get cacheCoverImageDesc =>
+      'Downloaded album and track cover art. Will re-download when viewed.';
+
+  @override
+  String get cacheLibraryCover => 'Library cover cache';
+
+  @override
+  String get cacheLibraryCoverDesc =>
+      'Cover art extracted from local music files. Will re-extract on next scan.';
+
+  @override
+  String get cacheExploreFeed => 'Explore feed cache';
+
+  @override
+  String get cacheExploreFeedDesc =>
+      'Explore tab content (new releases, trending). Will refresh on next visit.';
+
+  @override
+  String get cacheTrackLookup => 'Track lookup cache';
+
+  @override
+  String get cacheTrackLookupDesc =>
+      'Spotify/Deezer track ID lookups. Clearing may slow next few searches.';
+
+  @override
+  String get cacheCleanupUnusedDesc =>
+      'Remove orphaned download history and library entries for missing files.';
+
+  @override
+  String get cacheNoData => 'No cached data';
+
+  @override
+  String cacheSizeWithFiles(String size, int count) {
+    return '$size in $count files';
+  }
+
+  @override
+  String cacheSizeOnly(String size) {
+    return '$size';
+  }
+
+  @override
+  String cacheEntries(int count) {
+    return '$count entries';
+  }
+
+  @override
+  String cacheClearSuccess(String target) {
+    return 'Cleared: $target';
+  }
+
+  @override
+  String get cacheClearConfirmTitle => 'Clear cache?';
+
+  @override
+  String cacheClearConfirmMessage(String target) {
+    return 'This will clear cached data for $target. Downloaded music files will not be deleted.';
+  }
+
+  @override
+  String get cacheClearAllConfirmTitle => 'Clear all cache?';
+
+  @override
+  String get cacheClearAllConfirmMessage =>
+      'This will clear all cache categories on this page. Downloaded music files will not be deleted.';
+
+  @override
+  String get cacheClearAll => 'Clear all cache';
+
+  @override
+  String get cacheCleanupUnused => 'Cleanup unused data';
+
+  @override
+  String get cacheCleanupUnusedSubtitle =>
+      'Remove orphaned download history and missing library entries';
+
+  @override
+  String cacheCleanupResult(int downloadCount, int libraryCount) {
+    return 'Cleanup completed: $downloadCount orphaned downloads, $libraryCount missing library entries';
+  }
+
+  @override
+  String get cacheRefreshStats => 'Refresh stats';
+
+  @override
+  String get trackSaveCoverArt => 'Save Cover Art';
+
+  @override
+  String get trackSaveCoverArtSubtitle => 'Save album art as .jpg file';
+
+  @override
+  String get trackSaveLyrics => 'Save Lyrics (.lrc)';
+
+  @override
+  String get trackSaveLyricsSubtitle => 'Fetch and save lyrics as .lrc file';
+
+  @override
+  String get trackReEnrich => 'Re-enrich Metadata';
+
+  @override
+  String get trackReEnrichSubtitle =>
+      'Re-embed metadata without re-downloading';
+
+  @override
+  String get trackReEnrichOnlineSubtitle =>
+      'Search metadata online and embed into file';
+
+  @override
+  String get trackEditMetadata => 'Edit Metadata';
+
+  @override
+  String trackCoverSaved(String fileName) {
+    return 'Cover art saved to $fileName';
+  }
+
+  @override
+  String get trackCoverNoSource => 'No cover art source available';
+
+  @override
+  String trackLyricsSaved(String fileName) {
+    return 'Lyrics saved to $fileName';
+  }
+
+  @override
+  String get trackReEnrichProgress => 'Re-enriching metadata...';
+
+  @override
+  String get trackReEnrichSearching => 'Searching metadata online...';
+
+  @override
+  String get trackReEnrichSuccess => 'Metadata re-enriched successfully';
+
+  @override
+  String get trackReEnrichFfmpegFailed => 'FFmpeg metadata embed failed';
+
+  @override
+  String trackSaveFailed(String error) {
+    return 'Failed: $error';
+  }
 }

 /// The translations for Spanish Castilian, as used in Spain (`es_ES`).
@@ -18,6 +18,9 @@ class AppLocalizationsFr extends AppLocalizations {
  @override
  String get navHome => 'Home';

+  @override
+  String get navLibrary => 'Library';
+
  @override
  String get navHistory => 'History';

@@ -340,6 +343,10 @@ class AppLocalizationsFr extends AppLocalizations {
  String get optionsSpotifyWarning =>
      'Spotify requires your own API credentials. Get them free from developer.spotify.com';

+  @override
+  String get optionsSpotifyDeprecationWarning =>
+      'Spotify search will be deprecated on March 3, 2026 due to Spotify API changes. Please switch to Deezer.';
+
  @override
  String get extensionsTitle => 'Extensions';

@@ -470,6 +477,10 @@ class AppLocalizationsFr extends AppLocalizations {
  String get aboutSachinsenalDesc =>
      'The original HiFi project creator. The foundation of Tidal integration!';

+  @override
+  String get aboutSjdonadoDesc =>
+      'Creator of I Don\'t Have Spotify (IDHS). The fallback link resolver that saves the day!';
+
  @override
  String get aboutDoubleDouble => 'DoubleDouble';

@@ -484,6 +495,13 @@ class AppLocalizationsFr extends AppLocalizations {
  String get aboutDabMusicDesc =>
      'The best Qobuz streaming API. Hi-Res downloads wouldn\'t be possible without this!';

+  @override
+  String get aboutSpotiSaver => 'SpotiSaver';
+
+  @override
+  String get aboutSpotiSaverDesc =>
+      'Tidal Hi-Res FLAC streaming endpoints. A key piece of the lossless puzzle!';
+
  @override
  String get aboutAppDescription =>
      'Download Spotify tracks in lossless quality from Tidal, Qobuz, and Amazon Music.';
@@ -680,6 +698,10 @@ class AppLocalizationsFr extends AppLocalizations {
  String get setupIosEmptyFolderWarning =>
      'iOS limitation: Empty folders cannot be selected. Choose a folder with at least one file.';

+  @override
+  String get setupIcloudNotSupported =>
+      'iCloud Drive is not supported. Please use the app Documents folder.';
+
  @override
  String get setupDownloadInFlac => 'Download Spotify tracks in FLAC';

@@ -935,6 +957,11 @@ class AppLocalizationsFr extends AppLocalizations {
    return '\"$trackName\" already downloaded';
  }

+  @override
+  String snackbarAlreadyInLibrary(String trackName) {
+    return '\"$trackName\" already exists in your library';
+  }
+
  @override
  String get snackbarHistoryCleared => 'History cleared';

@@ -1618,6 +1645,15 @@ class AppLocalizationsFr extends AppLocalizations {
  @override
  String get trackLyricsLoadFailed => 'Failed to load lyrics';

+  @override
+  String get trackEmbedLyrics => 'Embed Lyrics';
+
+  @override
+  String get trackLyricsEmbedded => 'Lyrics embedded successfully';
+
+  @override
+  String get trackInstrumental => 'Instrumental track';
+
  @override
  String get trackCopiedToClipboard => 'Copied to clipboard';

@@ -1847,25 +1883,45 @@ class AppLocalizationsFr extends AppLocalizations {
  String get qualityHiResFlacMaxSubtitle => '24-bit / up to 192kHz';

  @override
-  String get qualityMp3 => 'MP3';
+  String get qualityLossy => 'Lossy';

  @override
-  String get qualityMp3Subtitle => '320kbps (converted from FLAC)';
+  String get qualityLossyMp3Subtitle => 'MP3 320kbps (converted from FLAC)';

  @override
-  String get enableMp3Option => 'Enable MP3 Option';
+  String get qualityLossyOpusSubtitle => 'Opus 128kbps (converted from FLAC)';

  @override
-  String get enableMp3OptionSubtitleOn => 'MP3 quality option is available';
+  String get enableLossyOption => 'Enable Lossy Option';

  @override
-  String get enableMp3OptionSubtitleOff =>
-      'Downloads FLAC then converts to 320kbps MP3';
+  String get enableLossyOptionSubtitleOn => 'Lossy quality option is available';
+
+  @override
+  String get enableLossyOptionSubtitleOff =>
+      'Downloads FLAC then converts to lossy format';
+
+  @override
+  String get lossyFormat => 'Lossy Format';
+
+  @override
+  String get lossyFormatDescription => 'Choose the lossy format for conversion';
+
+  @override
+  String get lossyFormatMp3Subtitle => '320kbps, best compatibility';
+
+  @override
+  String get lossyFormatOpusSubtitle =>
+      '128kbps, better quality at smaller size';

  @override
  String get qualityNote =>
      'Actual quality depends on track availability from the service';

+  @override
+  String get youtubeQualityNote =>
+      'YouTube provides lossy audio only. Not part of lossless fallback.';
+
  @override
  String get downloadAskBeforeDownload => 'Ask Before Download';

@@ -1878,6 +1934,17 @@ class AppLocalizationsFr extends AppLocalizations {
  @override
  String get downloadAlbumFolderStructure => 'Album Folder Structure';

+  @override
+  String get downloadUseAlbumArtistForFolders => 'Use Album Artist for folders';
+
+  @override
+  String get downloadUseAlbumArtistForFoldersAlbumSubtitle =>
+      'Artist folders use Album Artist when available';
+
+  @override
+  String get downloadUseAlbumArtistForFoldersTrackSubtitle =>
+      'Artist folders use Track Artist only';
+
  @override
  String get downloadSaveFormat => 'Save Format';

@@ -1957,6 +2024,39 @@ class AppLocalizationsFr extends AppLocalizations {
  String get queueClearAllMessage =>
      'Are you sure you want to clear all downloads?';

+  @override
+  String get queueExportFailed => 'Export';
+
+  @override
+  String get queueExportFailedSuccess =>
+      'Failed downloads exported to TXT file';
+
+  @override
+  String get queueExportFailedClear => 'Clear Failed';
+
+  @override
+  String get queueExportFailedError => 'Failed to export downloads';
+
+  @override
+  String get settingsAutoExportFailed => 'Auto-export failed downloads';
+
+  @override
+  String get settingsAutoExportFailedSubtitle =>
+      'Save failed downloads to TXT file automatically';
+
+  @override
+  String get settingsDownloadNetwork => 'Download Network';
+
+  @override
+  String get settingsDownloadNetworkAny => 'WiFi + Mobile Data';
+
+  @override
+  String get settingsDownloadNetworkWifiOnly => 'WiFi Only';
+
+  @override
+  String get settingsDownloadNetworkSubtitle =>
+      'Choose which network to use for downloads. When set to WiFi Only, downloads will pause on mobile data.';
+
  @override
  String get queueEmpty => 'No downloads in queue';

@@ -2006,6 +2106,13 @@ class AppLocalizationsFr extends AppLocalizations {
  @override
  String get albumFolderYearAlbumSubtitle => 'Albums/[2005] Album Name/';

+  @override
+  String get albumFolderArtistAlbumSingles => 'Artist / Album + Singles';
+
+  @override
+  String get albumFolderArtistAlbumSinglesSubtitle =>
+      'Artist/Album/ and Artist/Singles/';
+
  @override
  String get downloadedAlbumDeleteSelected => 'Delete Selected';

@@ -2073,6 +2180,12 @@ class AppLocalizationsFr extends AppLocalizations {
  @override
  String get recentTypePlaylist => 'Playlist';

+  @override
+  String get recentEmpty => 'No recent items yet';
+
+  @override
+  String get recentShowAllDownloads => 'Show All Downloads';
+
  @override
  String recentPlaylistInfo(String name) {
    return 'Playlist: $name';
@@ -2148,4 +2261,632 @@ class AppLocalizationsFr extends AppLocalizations {

  @override
  String get discographyFailedToFetch => 'Failed to fetch some albums';
+
+  @override
+  String get sectionStorageAccess => 'Storage Access';
+
+  @override
+  String get allFilesAccess => 'All Files Access';
+
+  @override
+  String get allFilesAccessEnabledSubtitle => 'Can write to any folder';
+
+  @override
+  String get allFilesAccessDisabledSubtitle => 'Limited to media folders only';
+
+  @override
+  String get allFilesAccessDescription =>
+      'Enable this if you encounter write errors when saving to custom folders. Android 13+ restricts access to certain directories by default.';
+
+  @override
+  String get allFilesAccessDeniedMessage =>
+      'Permission was denied. Please enable \'All files access\' manually in system settings.';
+
+  @override
+  String get allFilesAccessDisabledMessage =>
+      'All Files Access disabled. The app will use limited storage access.';
+
+  @override
+  String get settingsLocalLibrary => 'Local Library';
+
+  @override
+  String get settingsLocalLibrarySubtitle => 'Scan music & detect duplicates';
+
+  @override
+  String get settingsCache => 'Storage & Cache';
+
+  @override
+  String get settingsCacheSubtitle => 'View size and clear cached data';
+
+  @override
+  String get libraryTitle => 'Local Library';
+
+  @override
+  String get libraryStatus => 'Library Status';
+
+  @override
+  String get libraryScanSettings => 'Scan Settings';
+
+  @override
+  String get libraryEnableLocalLibrary => 'Enable Local Library';
+
+  @override
+  String get libraryEnableLocalLibrarySubtitle =>
+      'Scan and track your existing music';
+
+  @override
+  String get libraryFolder => 'Library Folder';
+
+  @override
+  String get libraryFolderHint => 'Tap to select folder';
+
+  @override
+  String get libraryShowDuplicateIndicator => 'Show Duplicate Indicator';
+
+  @override
+  String get libraryShowDuplicateIndicatorSubtitle =>
+      'Show when searching for existing tracks';
+
+  @override
+  String get libraryActions => 'Actions';
+
+  @override
+  String get libraryScan => 'Scan Library';
+
+  @override
+  String get libraryScanSubtitle => 'Scan for audio files';
+
+  @override
+  String get libraryScanSelectFolderFirst => 'Select a folder first';
+
+  @override
+  String get libraryCleanupMissingFiles => 'Cleanup Missing Files';
+
+  @override
+  String get libraryCleanupMissingFilesSubtitle =>
+      'Remove entries for files that no longer exist';
+
+  @override
+  String get libraryClear => 'Clear Library';
+
+  @override
+  String get libraryClearSubtitle => 'Remove all scanned tracks';
+
+  @override
+  String get libraryClearConfirmTitle => 'Clear Library';
+
+  @override
+  String get libraryClearConfirmMessage =>
+      'This will remove all scanned tracks from your library. Your actual music files will not be deleted.';
+
+  @override
+  String get libraryAbout => 'About Local Library';
+
+  @override
+  String get libraryAboutDescription =>
+      'Scans your existing music collection to detect duplicates when downloading. Supports FLAC, M4A, MP3, Opus, and OGG formats. Metadata is read from file tags when available.';
+
+  @override
+  String libraryTracksCount(int count) {
+    return '$count tracks';
+  }
+
+  @override
+  String libraryLastScanned(String time) {
+    return 'Last scanned: $time';
+  }
+
+  @override
+  String get libraryLastScannedNever => 'Never';
+
+  @override
+  String get libraryScanning => 'Scanning...';
+
+  @override
+  String libraryScanProgress(String progress, int total) {
+    return '$progress% of $total files';
+  }
+
+  @override
+  String get libraryInLibrary => 'In Library';
+
+  @override
+  String libraryRemovedMissingFiles(int count) {
+    return 'Removed $count missing files from library';
+  }
+
+  @override
+  String get libraryCleared => 'Library cleared';
+
+  @override
+  String get libraryStorageAccessRequired => 'Storage Access Required';
+
+  @override
+  String get libraryStorageAccessMessage =>
+      'SpotiFLAC needs storage access to scan your music library. Please grant permission in settings.';
+
+  @override
+  String get libraryFolderNotExist => 'Selected folder does not exist';
+
+  @override
+  String get librarySourceDownloaded => 'Downloaded';
+
+  @override
+  String get librarySourceLocal => 'Local';
+
+  @override
+  String get libraryFilterAll => 'All';
+
+  @override
+  String get libraryFilterDownloaded => 'Downloaded';
+
+  @override
+  String get libraryFilterLocal => 'Local';
+
+  @override
+  String get libraryFilterTitle => 'Filters';
+
+  @override
+  String get libraryFilterReset => 'Reset';
+
+  @override
+  String get libraryFilterApply => 'Apply';
+
+  @override
+  String get libraryFilterSource => 'Source';
+
+  @override
+  String get libraryFilterQuality => 'Quality';
+
+  @override
+  String get libraryFilterQualityHiRes => 'Hi-Res (24bit)';
+
+  @override
+  String get libraryFilterQualityCD => 'CD (16bit)';
+
+  @override
+  String get libraryFilterQualityLossy => 'Lossy';
+
+  @override
+  String get libraryFilterFormat => 'Format';
+
+  @override
+  String get libraryFilterDate => 'Date Added';
+
+  @override
+  String get libraryFilterDateToday => 'Today';
+
+  @override
+  String get libraryFilterDateWeek => 'This Week';
+
+  @override
+  String get libraryFilterDateMonth => 'This Month';
+
+  @override
+  String get libraryFilterDateYear => 'This Year';
+
+  @override
+  String get libraryFilterSort => 'Sort';
+
+  @override
+  String get libraryFilterSortLatest => 'Latest';
+
+  @override
+  String get libraryFilterSortOldest => 'Oldest';
+
+  @override
+  String libraryFilterActive(int count) {
+    return '$count filter(s) active';
+  }
+
+  @override
+  String get timeJustNow => 'Just now';
+
+  @override
+  String timeMinutesAgo(int count) {
+    String _temp0 = intl.Intl.pluralLogic(
+      count,
+      locale: localeName,
+      other: '$count minutes ago',
+      one: '1 minute ago',
+    );
+    return '$_temp0';
+  }
+
+  @override
+  String timeHoursAgo(int count) {
+    String _temp0 = intl.Intl.pluralLogic(
+      count,
+      locale: localeName,
+      other: '$count hours ago',
+      one: '1 hour ago',
+    );
+    return '$_temp0';
+  }
+
+  @override
+  String get storageSwitchTitle => 'Switch Storage Mode';
+
+  @override
+  String get storageSwitchToSafTitle => 'Switch to SAF Storage?';
+
+  @override
+  String get storageSwitchToAppTitle => 'Switch to App Storage?';
+
+  @override
+  String get storageSwitchToSafMessage =>
+      'Your existing downloads will remain in the current location and stay accessible.\n\nNew downloads will be saved to your selected SAF folder.';
+
+  @override
+  String get storageSwitchToAppMessage =>
+      'Your existing downloads will remain in the current SAF location and stay accessible.\n\nNew downloads will be saved to Music/SpotiFLAC folder.';
+
+  @override
+  String get storageSwitchExistingDownloads => 'Existing Downloads';
+
+  @override
+  String storageSwitchExistingDownloadsInfo(int count, String mode) {
+    return '$count tracks in $mode storage';
+  }
+
+  @override
+  String get storageSwitchNewDownloads => 'New Downloads';
+
+  @override
+  String storageSwitchNewDownloadsLocation(String location) {
+    return 'Will be saved to: $location';
+  }
+
+  @override
+  String get storageSwitchContinue => 'Continue';
+
+  @override
+  String get storageSwitchSelectFolder => 'Select SAF Folder';
+
+  @override
+  String get storageAppStorage => 'App Storage';
+
+  @override
+  String get storageSafStorage => 'SAF Storage';
+
+  @override
+  String storageModeBadge(String mode) {
+    return 'Storage: $mode';
+  }
+
+  @override
+  String get storageStatsTitle => 'Storage Statistics';
+
+  @override
+  String storageStatsAppCount(int count) {
+    return '$count tracks in App Storage';
+  }
+
+  @override
+  String storageStatsSafCount(int count) {
+    return '$count tracks in SAF Storage';
+  }
+
+  @override
+  String get storageModeInfo => 'Your files are stored in multiple locations';
+
+  @override
+  String get tutorialWelcomeTitle => 'Welcome to SpotiFLAC!';
+
+  @override
+  String get tutorialWelcomeDesc =>
+      'Let\'s learn how to download your favorite music in lossless quality. This quick tutorial will show you the basics.';
+
+  @override
+  String get tutorialWelcomeTip1 =>
+      'Download music from Spotify, Deezer, or paste any supported URL';
+
+  @override
+  String get tutorialWelcomeTip2 =>
+      'Get FLAC quality audio from Tidal, Qobuz, or Amazon Music';
+
+  @override
+  String get tutorialWelcomeTip3 =>
+      'Automatic metadata, cover art, and lyrics embedding';
+
+  @override
+  String get tutorialSearchTitle => 'Finding Music';
+
+  @override
+  String get tutorialSearchDesc =>
+      'There are two easy ways to find music you want to download.';
+
+  @override
+  String get tutorialSearchTip1 =>
+      'Paste a Spotify or Deezer URL directly in the search box';
+
+  @override
+  String get tutorialSearchTip2 =>
+      'Or type the song name, artist, or album to search';
+
+  @override
+  String get tutorialSearchTip3 =>
+      'Supports tracks, albums, playlists, and artist pages';
+
+  @override
+  String get tutorialDownloadTitle => 'Downloading Music';
+
+  @override
+  String get tutorialDownloadDesc =>
+      'Downloading music is simple and fast. Here\'s how it works.';
+
+  @override
+  String get tutorialDownloadTip1 =>
+      'Tap the download button next to any track to start downloading';
+
+  @override
+  String get tutorialDownloadTip2 =>
+      'Choose your preferred quality (FLAC, Hi-Res, or MP3)';
+
+  @override
+  String get tutorialDownloadTip3 =>
+      'Download entire albums or playlists with one tap';
+
+  @override
+  String get tutorialLibraryTitle => 'Your Library';
+
+  @override
+  String get tutorialLibraryDesc =>
+      'All your downloaded music is organized in the Library tab.';
+
+  @override
+  String get tutorialLibraryTip1 =>
+      'View download progress and queue in the Library tab';
+
+  @override
+  String get tutorialLibraryTip2 =>
+      'Tap any track to play it with your music player';
+
+  @override
+  String get tutorialLibraryTip3 =>
+      'Switch between list and grid view for better browsing';
+
+  @override
+  String get tutorialExtensionsTitle => 'Extensions';
+
+  @override
+  String get tutorialExtensionsDesc =>
+      'Extend the app\'s capabilities with community extensions.';
+
+  @override
+  String get tutorialExtensionsTip1 =>
+      'Browse the Store tab to discover useful extensions';
+
+  @override
+  String get tutorialExtensionsTip2 =>
+      'Add new download providers or search sources';
+
+  @override
+  String get tutorialExtensionsTip3 =>
+      'Get lyrics, enhanced metadata, and more features';
+
+  @override
+  String get tutorialSettingsTitle => 'Customize Your Experience';
+
+  @override
+  String get tutorialSettingsDesc =>
+      'Personalize the app in Settings to match your preferences.';
+
+  @override
+  String get tutorialSettingsTip1 =>
+      'Change download location and folder organization';
+
+  @override
+  String get tutorialSettingsTip2 =>
+      'Set default audio quality and format preferences';
+
+  @override
+  String get tutorialSettingsTip3 => 'Customize app theme and appearance';
+
+  @override
+  String get tutorialReadyMessage =>
+      'You\'re all set! Start downloading your favorite music now.';
+
+  @override
+  String get tutorialExample => 'EXAMPLE';
+
+  @override
+  String get libraryForceFullScan => 'Force Full Scan';
+
+  @override
+  String get libraryForceFullScanSubtitle => 'Rescan all files, ignoring cache';
+
+  @override
+  String get cleanupOrphanedDownloads => 'Cleanup Orphaned Downloads';
+
+  @override
+  String get cleanupOrphanedDownloadsSubtitle =>
+      'Remove history entries for files that no longer exist';
+
+  @override
+  String cleanupOrphanedDownloadsResult(int count) {
+    return 'Removed $count orphaned entries from history';
+  }
+
+  @override
+  String get cleanupOrphanedDownloadsNone => 'No orphaned entries found';
+
+  @override
+  String get cacheTitle => 'Storage & Cache';
+
+  @override
+  String get cacheSummaryTitle => 'Cache overview';
+
+  @override
+  String get cacheSummarySubtitle =>
+      'Clearing cache will not remove downloaded music files.';
+
+  @override
+  String cacheEstimatedTotal(String size) {
+    return 'Estimated cache usage: $size';
+  }
+
+  @override
+  String get cacheSectionStorage => 'Cached Data';
+
+  @override
+  String get cacheSectionMaintenance => 'Maintenance';
+
+  @override
+  String get cacheAppDirectory => 'App cache directory';
+
+  @override
+  String get cacheAppDirectoryDesc =>
+      'HTTP responses, WebView data, and other temporary app data.';
+
+  @override
+  String get cacheTempDirectory => 'Temporary directory';
+
+  @override
+  String get cacheTempDirectoryDesc =>
+      'Temporary files from downloads and audio conversion.';
+
+  @override
+  String get cacheCoverImage => 'Cover image cache';
+
+  @override
+  String get cacheCoverImageDesc =>
+      'Downloaded album and track cover art. Will re-download when viewed.';
+
+  @override
+  String get cacheLibraryCover => 'Library cover cache';
+
+  @override
+  String get cacheLibraryCoverDesc =>
+      'Cover art extracted from local music files. Will re-extract on next scan.';
+
+  @override
+  String get cacheExploreFeed => 'Explore feed cache';
+
+  @override
+  String get cacheExploreFeedDesc =>
+      'Explore tab content (new releases, trending). Will refresh on next visit.';
+
+  @override
+  String get cacheTrackLookup => 'Track lookup cache';
+
+  @override
+  String get cacheTrackLookupDesc =>
+      'Spotify/Deezer track ID lookups. Clearing may slow next few searches.';
+
+  @override
+  String get cacheCleanupUnusedDesc =>
+      'Remove orphaned download history and library entries for missing files.';
+
+  @override
+  String get cacheNoData => 'No cached data';
+
+  @override
+  String cacheSizeWithFiles(String size, int count) {
+    return '$size in $count files';
+  }
+
+  @override
+  String cacheSizeOnly(String size) {
+    return '$size';
+  }
+
+  @override
+  String cacheEntries(int count) {
+    return '$count entries';
+  }
+
+  @override
+  String cacheClearSuccess(String target) {
+    return 'Cleared: $target';
+  }
+
+  @override
+  String get cacheClearConfirmTitle => 'Clear cache?';
+
+  @override
+  String cacheClearConfirmMessage(String target) {
+    return 'This will clear cached data for $target. Downloaded music files will not be deleted.';
+  }
+
+  @override
+  String get cacheClearAllConfirmTitle => 'Clear all cache?';
+
+  @override
+  String get cacheClearAllConfirmMessage =>
+      'This will clear all cache categories on this page. Downloaded music files will not be deleted.';
+
+  @override
+  String get cacheClearAll => 'Clear all cache';
+
+  @override
+  String get cacheCleanupUnused => 'Cleanup unused data';
+
+  @override
+  String get cacheCleanupUnusedSubtitle =>
+      'Remove orphaned download history and missing library entries';
+
+  @override
+  String cacheCleanupResult(int downloadCount, int libraryCount) {
+    return 'Cleanup completed: $downloadCount orphaned downloads, $libraryCount missing library entries';
+  }
+
+  @override
+  String get cacheRefreshStats => 'Refresh stats';
+
+  @override
+  String get trackSaveCoverArt => 'Save Cover Art';
+
+  @override
+  String get trackSaveCoverArtSubtitle => 'Save album art as .jpg file';
+
+  @override
+  String get trackSaveLyrics => 'Save Lyrics (.lrc)';
+
+  @override
+  String get trackSaveLyricsSubtitle => 'Fetch and save lyrics as .lrc file';
+
+  @override
+  String get trackReEnrich => 'Re-enrich Metadata';
+
+  @override
+  String get trackReEnrichSubtitle =>
+      'Re-embed metadata without re-downloading';
+
+  @override
+  String get trackReEnrichOnlineSubtitle =>
+      'Search metadata online and embed into file';
+
+  @override
+  String get trackEditMetadata => 'Edit Metadata';
+
+  @override
+  String trackCoverSaved(String fileName) {
+    return 'Cover art saved to $fileName';
+  }
+
+  @override
+  String get trackCoverNoSource => 'No cover art source available';
+
+  @override
+  String trackLyricsSaved(String fileName) {
+    return 'Lyrics saved to $fileName';
+  }
+
+  @override
+  String get trackReEnrichProgress => 'Re-enriching metadata...';
+
+  @override
+  String get trackReEnrichSearching => 'Searching metadata online...';
+
+  @override
+  String get trackReEnrichSuccess => 'Metadata re-enriched successfully';
+
+  @override
+  String get trackReEnrichFfmpegFailed => 'FFmpeg metadata embed failed';
+
+  @override
+  String trackSaveFailed(String error) {
+    return 'Failed: $error';
+  }
 }
@@ -9,20 +9,23 @@ class AppLocalizationsHi extends AppLocalizations {
  AppLocalizationsHi([String locale = 'hi']) : super(locale);

  @override
-  String get appName => 'SpotiFLAC';
+  String get appName => 'SpotiFlac';

  @override
  String get appDescription =>
-      'Download Spotify tracks in lossless quality from Tidal, Qobuz, and Amazon Music.';
+      'स्पॉटीफाई ट्रैक डाउनलोड करें टाइडल, क्वाबज एवं एवं अमेजन म्यूजिक से उच्चतम क्वालिटी में।';

  @override
-  String get navHome => 'Home';
+  String get navHome => 'होम';

  @override
-  String get navHistory => 'History';
+  String get navLibrary => 'Library';

  @override
-  String get navSettings => 'Settings';
+  String get navHistory => 'इतिहास';
+
+  @override
+  String get navSettings => 'विकल्प';

  @override
  String get navStore => 'Store';
@@ -184,7 +187,7 @@ class AppLocalizationsHi extends AppLocalizations {
  String get quality128 => '128 kbps';

  @override
-  String get appearanceTitle => 'Appearance';
+  String get appearanceTitle => 'दिखावट';

  @override
  String get appearanceTheme => 'Theme';
@@ -199,10 +202,10 @@ class AppLocalizationsHi extends AppLocalizations {
  String get appearanceThemeDark => 'Dark';

  @override
-  String get appearanceDynamicColor => 'Dynamic Color';
+  String get appearanceDynamicColor => 'डायनेमिक रंग';

  @override
-  String get appearanceDynamicColorSubtitle => 'Use colors from your wallpaper';
+  String get appearanceDynamicColorSubtitle => 'वॉलपेपर से रंग इस्तेमाल करें';

  @override
  String get appearanceAccentColor => 'Accent Color';
@@ -340,6 +343,10 @@ class AppLocalizationsHi extends AppLocalizations {
  String get optionsSpotifyWarning =>
      'Spotify requires your own API credentials. Get them free from developer.spotify.com';

+  @override
+  String get optionsSpotifyDeprecationWarning =>
+      'Spotify search will be deprecated on March 3, 2026 due to Spotify API changes. Please switch to Deezer.';
+
  @override
  String get extensionsTitle => 'Extensions';

@@ -470,6 +477,10 @@ class AppLocalizationsHi extends AppLocalizations {
  String get aboutSachinsenalDesc =>
      'The original HiFi project creator. The foundation of Tidal integration!';

+  @override
+  String get aboutSjdonadoDesc =>
+      'Creator of I Don\'t Have Spotify (IDHS). The fallback link resolver that saves the day!';
+
  @override
  String get aboutDoubleDouble => 'DoubleDouble';

@@ -484,6 +495,13 @@ class AppLocalizationsHi extends AppLocalizations {
  String get aboutDabMusicDesc =>
      'The best Qobuz streaming API. Hi-Res downloads wouldn\'t be possible without this!';

+  @override
+  String get aboutSpotiSaver => 'SpotiSaver';
+
+  @override
+  String get aboutSpotiSaverDesc =>
+      'Tidal Hi-Res FLAC streaming endpoints. A key piece of the lossless puzzle!';
+
  @override
  String get aboutAppDescription =>
      'Download Spotify tracks in lossless quality from Tidal, Qobuz, and Amazon Music.';
@@ -680,6 +698,10 @@ class AppLocalizationsHi extends AppLocalizations {
  String get setupIosEmptyFolderWarning =>
      'iOS limitation: Empty folders cannot be selected. Choose a folder with at least one file.';

+  @override
+  String get setupIcloudNotSupported =>
+      'iCloud Drive is not supported. Please use the app Documents folder.';
+
  @override
  String get setupDownloadInFlac => 'Download Spotify tracks in FLAC';

@@ -935,6 +957,11 @@ class AppLocalizationsHi extends AppLocalizations {
    return '\"$trackName\" already downloaded';
  }

+  @override
+  String snackbarAlreadyInLibrary(String trackName) {
+    return '\"$trackName\" already exists in your library';
+  }
+
  @override
  String get snackbarHistoryCleared => 'History cleared';

@@ -1618,6 +1645,15 @@ class AppLocalizationsHi extends AppLocalizations {
  @override
  String get trackLyricsLoadFailed => 'Failed to load lyrics';

+  @override
+  String get trackEmbedLyrics => 'Embed Lyrics';
+
+  @override
+  String get trackLyricsEmbedded => 'Lyrics embedded successfully';
+
+  @override
+  String get trackInstrumental => 'Instrumental track';
+
  @override
  String get trackCopiedToClipboard => 'Copied to clipboard';

@@ -1847,25 +1883,45 @@ class AppLocalizationsHi extends AppLocalizations {
  String get qualityHiResFlacMaxSubtitle => '24-bit / up to 192kHz';

  @override
-  String get qualityMp3 => 'MP3';
+  String get qualityLossy => 'Lossy';

  @override
-  String get qualityMp3Subtitle => '320kbps (converted from FLAC)';
+  String get qualityLossyMp3Subtitle => 'MP3 320kbps (converted from FLAC)';

  @override
-  String get enableMp3Option => 'Enable MP3 Option';
+  String get qualityLossyOpusSubtitle => 'Opus 128kbps (converted from FLAC)';

  @override
-  String get enableMp3OptionSubtitleOn => 'MP3 quality option is available';
+  String get enableLossyOption => 'Enable Lossy Option';

  @override
-  String get enableMp3OptionSubtitleOff =>
-      'Downloads FLAC then converts to 320kbps MP3';
+  String get enableLossyOptionSubtitleOn => 'Lossy quality option is available';
+
+  @override
+  String get enableLossyOptionSubtitleOff =>
+      'Downloads FLAC then converts to lossy format';
+
+  @override
+  String get lossyFormat => 'Lossy Format';
+
+  @override
+  String get lossyFormatDescription => 'Choose the lossy format for conversion';
+
+  @override
+  String get lossyFormatMp3Subtitle => '320kbps, best compatibility';
+
+  @override
+  String get lossyFormatOpusSubtitle =>
+      '128kbps, better quality at smaller size';

  @override
  String get qualityNote =>
      'Actual quality depends on track availability from the service';

+  @override
+  String get youtubeQualityNote =>
+      'YouTube provides lossy audio only. Not part of lossless fallback.';
+
  @override
  String get downloadAskBeforeDownload => 'Ask Before Download';

@@ -1878,6 +1934,17 @@ class AppLocalizationsHi extends AppLocalizations {
  @override
  String get downloadAlbumFolderStructure => 'Album Folder Structure';

+  @override
+  String get downloadUseAlbumArtistForFolders => 'Use Album Artist for folders';
+
+  @override
+  String get downloadUseAlbumArtistForFoldersAlbumSubtitle =>
+      'Artist folders use Album Artist when available';
+
+  @override
+  String get downloadUseAlbumArtistForFoldersTrackSubtitle =>
+      'Artist folders use Track Artist only';
+
  @override
  String get downloadSaveFormat => 'Save Format';

@@ -1957,6 +2024,39 @@ class AppLocalizationsHi extends AppLocalizations {
  String get queueClearAllMessage =>
      'Are you sure you want to clear all downloads?';

+  @override
+  String get queueExportFailed => 'Export';
+
+  @override
+  String get queueExportFailedSuccess =>
+      'Failed downloads exported to TXT file';
+
+  @override
+  String get queueExportFailedClear => 'Clear Failed';
+
+  @override
+  String get queueExportFailedError => 'Failed to export downloads';
+
+  @override
+  String get settingsAutoExportFailed => 'Auto-export failed downloads';
+
+  @override
+  String get settingsAutoExportFailedSubtitle =>
+      'Save failed downloads to TXT file automatically';
+
+  @override
+  String get settingsDownloadNetwork => 'Download Network';
+
+  @override
+  String get settingsDownloadNetworkAny => 'WiFi + Mobile Data';
+
+  @override
+  String get settingsDownloadNetworkWifiOnly => 'WiFi Only';
+
+  @override
+  String get settingsDownloadNetworkSubtitle =>
+      'Choose which network to use for downloads. When set to WiFi Only, downloads will pause on mobile data.';
+
  @override
  String get queueEmpty => 'No downloads in queue';

@@ -2006,6 +2106,13 @@ class AppLocalizationsHi extends AppLocalizations {
  @override
  String get albumFolderYearAlbumSubtitle => 'Albums/[2005] Album Name/';

+  @override
+  String get albumFolderArtistAlbumSingles => 'Artist / Album + Singles';
+
+  @override
+  String get albumFolderArtistAlbumSinglesSubtitle =>
+      'Artist/Album/ and Artist/Singles/';
+
  @override
  String get downloadedAlbumDeleteSelected => 'Delete Selected';

@@ -2073,6 +2180,12 @@ class AppLocalizationsHi extends AppLocalizations {
  @override
  String get recentTypePlaylist => 'Playlist';

+  @override
+  String get recentEmpty => 'No recent items yet';
+
+  @override
+  String get recentShowAllDownloads => 'Show All Downloads';
+
  @override
  String recentPlaylistInfo(String name) {
    return 'Playlist: $name';
@@ -2148,4 +2261,632 @@ class AppLocalizationsHi extends AppLocalizations {

  @override
  String get discographyFailedToFetch => 'Failed to fetch some albums';
+
+  @override
+  String get sectionStorageAccess => 'Storage Access';
+
+  @override
+  String get allFilesAccess => 'All Files Access';
+
+  @override
+  String get allFilesAccessEnabledSubtitle => 'Can write to any folder';
+
+  @override
+  String get allFilesAccessDisabledSubtitle => 'Limited to media folders only';
+
+  @override
+  String get allFilesAccessDescription =>
+      'Enable this if you encounter write errors when saving to custom folders. Android 13+ restricts access to certain directories by default.';
+
+  @override
+  String get allFilesAccessDeniedMessage =>
+      'Permission was denied. Please enable \'All files access\' manually in system settings.';
+
+  @override
+  String get allFilesAccessDisabledMessage =>
+      'All Files Access disabled. The app will use limited storage access.';
+
+  @override
+  String get settingsLocalLibrary => 'Local Library';
+
+  @override
+  String get settingsLocalLibrarySubtitle => 'Scan music & detect duplicates';
+
+  @override
+  String get settingsCache => 'Storage & Cache';
+
+  @override
+  String get settingsCacheSubtitle => 'View size and clear cached data';
+
+  @override
+  String get libraryTitle => 'Local Library';
+
+  @override
+  String get libraryStatus => 'Library Status';
+
+  @override
+  String get libraryScanSettings => 'Scan Settings';
+
+  @override
+  String get libraryEnableLocalLibrary => 'Enable Local Library';
+
+  @override
+  String get libraryEnableLocalLibrarySubtitle =>
+      'Scan and track your existing music';
+
+  @override
+  String get libraryFolder => 'Library Folder';
+
+  @override
+  String get libraryFolderHint => 'Tap to select folder';
+
+  @override
+  String get libraryShowDuplicateIndicator => 'Show Duplicate Indicator';
+
+  @override
+  String get libraryShowDuplicateIndicatorSubtitle =>
+      'Show when searching for existing tracks';
+
+  @override
+  String get libraryActions => 'Actions';
+
+  @override
+  String get libraryScan => 'Scan Library';
+
+  @override
+  String get libraryScanSubtitle => 'Scan for audio files';
+
+  @override
+  String get libraryScanSelectFolderFirst => 'Select a folder first';
+
+  @override
+  String get libraryCleanupMissingFiles => 'Cleanup Missing Files';
+
+  @override
+  String get libraryCleanupMissingFilesSubtitle =>
+      'Remove entries for files that no longer exist';
+
+  @override
+  String get libraryClear => 'Clear Library';
+
+  @override
+  String get libraryClearSubtitle => 'Remove all scanned tracks';
+
+  @override
+  String get libraryClearConfirmTitle => 'Clear Library';
+
+  @override
+  String get libraryClearConfirmMessage =>
+      'This will remove all scanned tracks from your library. Your actual music files will not be deleted.';
+
+  @override
+  String get libraryAbout => 'About Local Library';
+
+  @override
+  String get libraryAboutDescription =>
+      'Scans your existing music collection to detect duplicates when downloading. Supports FLAC, M4A, MP3, Opus, and OGG formats. Metadata is read from file tags when available.';
+
+  @override
+  String libraryTracksCount(int count) {
+    return '$count tracks';
+  }
+
+  @override
+  String libraryLastScanned(String time) {
+    return 'Last scanned: $time';
+  }
+
+  @override
+  String get libraryLastScannedNever => 'Never';
+
+  @override
+  String get libraryScanning => 'Scanning...';
+
+  @override
+  String libraryScanProgress(String progress, int total) {
+    return '$progress% of $total files';
+  }
+
+  @override
+  String get libraryInLibrary => 'In Library';
+
+  @override
+  String libraryRemovedMissingFiles(int count) {
+    return 'Removed $count missing files from library';
+  }
+
+  @override
+  String get libraryCleared => 'Library cleared';
+
+  @override
+  String get libraryStorageAccessRequired => 'Storage Access Required';
+
+  @override
+  String get libraryStorageAccessMessage =>
+      'SpotiFLAC needs storage access to scan your music library. Please grant permission in settings.';
+
+  @override
+  String get libraryFolderNotExist => 'Selected folder does not exist';
+
+  @override
+  String get librarySourceDownloaded => 'Downloaded';
+
+  @override
+  String get librarySourceLocal => 'Local';
+
+  @override
+  String get libraryFilterAll => 'All';
+
+  @override
+  String get libraryFilterDownloaded => 'Downloaded';
+
+  @override
+  String get libraryFilterLocal => 'Local';
+
+  @override
+  String get libraryFilterTitle => 'Filters';
+
+  @override
+  String get libraryFilterReset => 'Reset';
+
+  @override
+  String get libraryFilterApply => 'Apply';
+
+  @override
+  String get libraryFilterSource => 'Source';
+
+  @override
+  String get libraryFilterQuality => 'Quality';
+
+  @override
+  String get libraryFilterQualityHiRes => 'Hi-Res (24bit)';
+
+  @override
+  String get libraryFilterQualityCD => 'CD (16bit)';
+
+  @override
+  String get libraryFilterQualityLossy => 'Lossy';
+
+  @override
+  String get libraryFilterFormat => 'Format';
+
+  @override
+  String get libraryFilterDate => 'Date Added';
+
+  @override
+  String get libraryFilterDateToday => 'Today';
+
+  @override
+  String get libraryFilterDateWeek => 'This Week';
+
+  @override
+  String get libraryFilterDateMonth => 'This Month';
+
+  @override
+  String get libraryFilterDateYear => 'This Year';
+
+  @override
+  String get libraryFilterSort => 'Sort';
+
+  @override
+  String get libraryFilterSortLatest => 'Latest';
+
+  @override
+  String get libraryFilterSortOldest => 'Oldest';
+
+  @override
+  String libraryFilterActive(int count) {
+    return '$count filter(s) active';
+  }
+
+  @override
+  String get timeJustNow => 'Just now';
+
+  @override
+  String timeMinutesAgo(int count) {
+    String _temp0 = intl.Intl.pluralLogic(
+      count,
+      locale: localeName,
+      other: '$count minutes ago',
+      one: '1 minute ago',
+    );
+    return '$_temp0';
+  }
+
+  @override
+  String timeHoursAgo(int count) {
+    String _temp0 = intl.Intl.pluralLogic(
+      count,
+      locale: localeName,
+      other: '$count hours ago',
+      one: '1 hour ago',
+    );
+    return '$_temp0';
+  }
+
+  @override
+  String get storageSwitchTitle => 'Switch Storage Mode';
+
+  @override
+  String get storageSwitchToSafTitle => 'Switch to SAF Storage?';
+
+  @override
+  String get storageSwitchToAppTitle => 'Switch to App Storage?';
+
+  @override
+  String get storageSwitchToSafMessage =>
+      'Your existing downloads will remain in the current location and stay accessible.\n\nNew downloads will be saved to your selected SAF folder.';
+
+  @override
+  String get storageSwitchToAppMessage =>
+      'Your existing downloads will remain in the current SAF location and stay accessible.\n\nNew downloads will be saved to Music/SpotiFLAC folder.';
+
+  @override
+  String get storageSwitchExistingDownloads => 'Existing Downloads';
+
+  @override
+  String storageSwitchExistingDownloadsInfo(int count, String mode) {
+    return '$count tracks in $mode storage';
+  }
+
+  @override
+  String get storageSwitchNewDownloads => 'New Downloads';
+
+  @override
+  String storageSwitchNewDownloadsLocation(String location) {
+    return 'Will be saved to: $location';
+  }
+
+  @override
+  String get storageSwitchContinue => 'Continue';
+
+  @override
+  String get storageSwitchSelectFolder => 'Select SAF Folder';
+
+  @override
+  String get storageAppStorage => 'App Storage';
+
+  @override
+  String get storageSafStorage => 'SAF Storage';
+
+  @override
+  String storageModeBadge(String mode) {
+    return 'Storage: $mode';
+  }
+
+  @override
+  String get storageStatsTitle => 'Storage Statistics';
+
+  @override
+  String storageStatsAppCount(int count) {
+    return '$count tracks in App Storage';
+  }
+
+  @override
+  String storageStatsSafCount(int count) {
+    return '$count tracks in SAF Storage';
+  }
+
+  @override
+  String get storageModeInfo => 'Your files are stored in multiple locations';
+
+  @override
+  String get tutorialWelcomeTitle => 'Welcome to SpotiFLAC!';
+
+  @override
+  String get tutorialWelcomeDesc =>
+      'Let\'s learn how to download your favorite music in lossless quality. This quick tutorial will show you the basics.';
+
+  @override
+  String get tutorialWelcomeTip1 =>
+      'Download music from Spotify, Deezer, or paste any supported URL';
+
+  @override
+  String get tutorialWelcomeTip2 =>
+      'Get FLAC quality audio from Tidal, Qobuz, or Amazon Music';
+
+  @override
+  String get tutorialWelcomeTip3 =>
+      'Automatic metadata, cover art, and lyrics embedding';
+
+  @override
+  String get tutorialSearchTitle => 'Finding Music';
+
+  @override
+  String get tutorialSearchDesc =>
+      'There are two easy ways to find music you want to download.';
+
+  @override
+  String get tutorialSearchTip1 =>
+      'Paste a Spotify or Deezer URL directly in the search box';
+
+  @override
+  String get tutorialSearchTip2 =>
+      'Or type the song name, artist, or album to search';
+
+  @override
+  String get tutorialSearchTip3 =>
+      'Supports tracks, albums, playlists, and artist pages';
+
+  @override
+  String get tutorialDownloadTitle => 'Downloading Music';
+
+  @override
+  String get tutorialDownloadDesc =>
+      'Downloading music is simple and fast. Here\'s how it works.';
+
+  @override
+  String get tutorialDownloadTip1 =>
+      'Tap the download button next to any track to start downloading';
+
+  @override
+  String get tutorialDownloadTip2 =>
+      'Choose your preferred quality (FLAC, Hi-Res, or MP3)';
+
+  @override
+  String get tutorialDownloadTip3 =>
+      'Download entire albums or playlists with one tap';
+
+  @override
+  String get tutorialLibraryTitle => 'Your Library';
+
+  @override
+  String get tutorialLibraryDesc =>
+      'All your downloaded music is organized in the Library tab.';
+
+  @override
+  String get tutorialLibraryTip1 =>
+      'View download progress and queue in the Library tab';
+
+  @override
+  String get tutorialLibraryTip2 =>
+      'Tap any track to play it with your music player';
+
+  @override
+  String get tutorialLibraryTip3 =>
+      'Switch between list and grid view for better browsing';
+
+  @override
+  String get tutorialExtensionsTitle => 'Extensions';
+
+  @override
+  String get tutorialExtensionsDesc =>
+      'Extend the app\'s capabilities with community extensions.';
+
+  @override
+  String get tutorialExtensionsTip1 =>
+      'Browse the Store tab to discover useful extensions';
+
+  @override
+  String get tutorialExtensionsTip2 =>
+      'Add new download providers or search sources';
+
+  @override
+  String get tutorialExtensionsTip3 =>
+      'Get lyrics, enhanced metadata, and more features';
+
+  @override
+  String get tutorialSettingsTitle => 'Customize Your Experience';
+
+  @override
+  String get tutorialSettingsDesc =>
+      'Personalize the app in Settings to match your preferences.';
+
+  @override
+  String get tutorialSettingsTip1 =>
+      'Change download location and folder organization';
+
+  @override
+  String get tutorialSettingsTip2 =>
+      'Set default audio quality and format preferences';
+
+  @override
+  String get tutorialSettingsTip3 => 'Customize app theme and appearance';
+
+  @override
+  String get tutorialReadyMessage =>
+      'You\'re all set! Start downloading your favorite music now.';
+
+  @override
+  String get tutorialExample => 'EXAMPLE';
+
+  @override
+  String get libraryForceFullScan => 'Force Full Scan';
+
+  @override
+  String get libraryForceFullScanSubtitle => 'Rescan all files, ignoring cache';
+
+  @override
+  String get cleanupOrphanedDownloads => 'Cleanup Orphaned Downloads';
+
+  @override
+  String get cleanupOrphanedDownloadsSubtitle =>
+      'Remove history entries for files that no longer exist';
+
+  @override
+  String cleanupOrphanedDownloadsResult(int count) {
+    return 'Removed $count orphaned entries from history';
+  }
+
+  @override
+  String get cleanupOrphanedDownloadsNone => 'No orphaned entries found';
+
+  @override
+  String get cacheTitle => 'Storage & Cache';
+
+  @override
+  String get cacheSummaryTitle => 'Cache overview';
+
+  @override
+  String get cacheSummarySubtitle =>
+      'Clearing cache will not remove downloaded music files.';
+
+  @override
+  String cacheEstimatedTotal(String size) {
+    return 'Estimated cache usage: $size';
+  }
+
+  @override
+  String get cacheSectionStorage => 'Cached Data';
+
+  @override
+  String get cacheSectionMaintenance => 'Maintenance';
+
+  @override
+  String get cacheAppDirectory => 'App cache directory';
+
+  @override
+  String get cacheAppDirectoryDesc =>
+      'HTTP responses, WebView data, and other temporary app data.';
+
+  @override
+  String get cacheTempDirectory => 'Temporary directory';
+
+  @override
+  String get cacheTempDirectoryDesc =>
+      'Temporary files from downloads and audio conversion.';
+
+  @override
+  String get cacheCoverImage => 'Cover image cache';
+
+  @override
+  String get cacheCoverImageDesc =>
+      'Downloaded album and track cover art. Will re-download when viewed.';
+
+  @override
+  String get cacheLibraryCover => 'Library cover cache';
+
+  @override
+  String get cacheLibraryCoverDesc =>
+      'Cover art extracted from local music files. Will re-extract on next scan.';
+
+  @override
+  String get cacheExploreFeed => 'Explore feed cache';
+
+  @override
+  String get cacheExploreFeedDesc =>
+      'Explore tab content (new releases, trending). Will refresh on next visit.';
+
+  @override
+  String get cacheTrackLookup => 'Track lookup cache';
+
+  @override
+  String get cacheTrackLookupDesc =>
+      'Spotify/Deezer track ID lookups. Clearing may slow next few searches.';
+
+  @override
+  String get cacheCleanupUnusedDesc =>
+      'Remove orphaned download history and library entries for missing files.';
+
+  @override
+  String get cacheNoData => 'No cached data';
+
+  @override
+  String cacheSizeWithFiles(String size, int count) {
+    return '$size in $count files';
+  }
+
+  @override
+  String cacheSizeOnly(String size) {
+    return '$size';
+  }
+
+  @override
+  String cacheEntries(int count) {
+    return '$count entries';
+  }
+
+  @override
+  String cacheClearSuccess(String target) {
+    return 'Cleared: $target';
+  }
+
+  @override
+  String get cacheClearConfirmTitle => 'Clear cache?';
+
+  @override
+  String cacheClearConfirmMessage(String target) {
+    return 'This will clear cached data for $target. Downloaded music files will not be deleted.';
+  }
+
+  @override
+  String get cacheClearAllConfirmTitle => 'Clear all cache?';
+
+  @override
+  String get cacheClearAllConfirmMessage =>
+      'This will clear all cache categories on this page. Downloaded music files will not be deleted.';
+
+  @override
+  String get cacheClearAll => 'Clear all cache';
+
+  @override
+  String get cacheCleanupUnused => 'Cleanup unused data';
+
+  @override
+  String get cacheCleanupUnusedSubtitle =>
+      'Remove orphaned download history and missing library entries';
+
+  @override
+  String cacheCleanupResult(int downloadCount, int libraryCount) {
+    return 'Cleanup completed: $downloadCount orphaned downloads, $libraryCount missing library entries';
+  }
+
+  @override
+  String get cacheRefreshStats => 'Refresh stats';
+
+  @override
+  String get trackSaveCoverArt => 'Save Cover Art';
+
+  @override
+  String get trackSaveCoverArtSubtitle => 'Save album art as .jpg file';
+
+  @override
+  String get trackSaveLyrics => 'Save Lyrics (.lrc)';
+
+  @override
+  String get trackSaveLyricsSubtitle => 'Fetch and save lyrics as .lrc file';
+
+  @override
+  String get trackReEnrich => 'Re-enrich Metadata';
+
+  @override
+  String get trackReEnrichSubtitle =>
+      'Re-embed metadata without re-downloading';
+
+  @override
+  String get trackReEnrichOnlineSubtitle =>
+      'Search metadata online and embed into file';
+
+  @override
+  String get trackEditMetadata => 'Edit Metadata';
+
+  @override
+  String trackCoverSaved(String fileName) {
+    return 'Cover art saved to $fileName';
+  }
+
+  @override
+  String get trackCoverNoSource => 'No cover art source available';
+
+  @override
+  String trackLyricsSaved(String fileName) {
+    return 'Lyrics saved to $fileName';
+  }
+
+  @override
+  String get trackReEnrichProgress => 'Re-enriching metadata...';
+
+  @override
+  String get trackReEnrichSearching => 'Searching metadata online...';
+
+  @override
+  String get trackReEnrichSuccess => 'Metadata re-enriched successfully';
+
+  @override
+  String get trackReEnrichFfmpegFailed => 'FFmpeg metadata embed failed';
+
+  @override
+  String trackSaveFailed(String error) {
+    return 'Failed: $error';
+  }
 }
@@ -18,6 +18,9 @@ class AppLocalizationsId extends AppLocalizations {
  @override
  String get navHome => 'Beranda';

+  @override
+  String get navLibrary => 'Library';
+
  @override
  String get navHistory => 'Riwayat';

@@ -344,6 +347,10 @@ class AppLocalizationsId extends AppLocalizations {
  String get optionsSpotifyWarning =>
      'Spotify memerlukan kredensial API Anda sendiri. Dapatkan gratis dari developer.spotify.com';

+  @override
+  String get optionsSpotifyDeprecationWarning =>
+      'Pencarian Spotify akan dihentikan pada 3 Maret 2026 karena perubahan API Spotify. Silakan beralih ke Deezer.';
+
  @override
  String get extensionsTitle => 'Ekstensi';

@@ -475,6 +482,10 @@ class AppLocalizationsId extends AppLocalizations {
  String get aboutSachinsenalDesc =>
      'Pembuat proyek HiFi asli. Fondasi dari integrasi Tidal!';

+  @override
+  String get aboutSjdonadoDesc =>
+      'Creator of I Don\'t Have Spotify (IDHS). The fallback link resolver that saves the day!';
+
  @override
  String get aboutDoubleDouble => 'DoubleDouble';

@@ -489,6 +500,13 @@ class AppLocalizationsId extends AppLocalizations {
  String get aboutDabMusicDesc =>
      'API streaming Qobuz terbaik. Unduhan Hi-Res tidak akan mungkin tanpa ini!';

+  @override
+  String get aboutSpotiSaver => 'SpotiSaver';
+
+  @override
+  String get aboutSpotiSaverDesc =>
+      'Tidal Hi-Res FLAC streaming endpoints. A key piece of the lossless puzzle!';
+
  @override
  String get aboutAppDescription =>
      'Unduh lagu Spotify dalam kualitas lossless dari Tidal, Qobuz, dan Amazon Music.';
@@ -685,6 +703,10 @@ class AppLocalizationsId extends AppLocalizations {
  String get setupIosEmptyFolderWarning =>
      'Batasan iOS: Folder kosong tidak dapat dipilih. Pilih folder dengan minimal satu file.';

+  @override
+  String get setupIcloudNotSupported =>
+      'iCloud Drive is not supported. Please use the app Documents folder.';
+
  @override
  String get setupDownloadInFlac => 'Unduh lagu Spotify dalam format FLAC';

@@ -941,6 +963,11 @@ class AppLocalizationsId extends AppLocalizations {
    return '\"$trackName\" sudah diunduh';
  }

+  @override
+  String snackbarAlreadyInLibrary(String trackName) {
+    return '\"$trackName\" already exists in your library';
+  }
+
  @override
  String get snackbarHistoryCleared => 'Riwayat dihapus';

@@ -1628,6 +1655,15 @@ class AppLocalizationsId extends AppLocalizations {
  @override
  String get trackLyricsLoadFailed => 'Gagal memuat lirik';

+  @override
+  String get trackEmbedLyrics => 'Embed Lyrics';
+
+  @override
+  String get trackLyricsEmbedded => 'Lyrics embedded successfully';
+
+  @override
+  String get trackInstrumental => 'Instrumental track';
+
  @override
  String get trackCopiedToClipboard => 'Disalin ke clipboard';

@@ -1859,25 +1895,45 @@ class AppLocalizationsId extends AppLocalizations {
  String get qualityHiResFlacMaxSubtitle => '24-bit / hingga 192kHz';

  @override
-  String get qualityMp3 => 'MP3';
+  String get qualityLossy => 'Lossy';

  @override
-  String get qualityMp3Subtitle => '320kbps (konversi dari FLAC)';
+  String get qualityLossyMp3Subtitle => 'MP3 320kbps (converted from FLAC)';

  @override
-  String get enableMp3Option => 'Aktifkan Opsi MP3';
+  String get qualityLossyOpusSubtitle => 'Opus 128kbps (converted from FLAC)';

  @override
-  String get enableMp3OptionSubtitleOn => 'Opsi kualitas MP3 tersedia';
+  String get enableLossyOption => 'Enable Lossy Option';

  @override
-  String get enableMp3OptionSubtitleOff =>
-      'Unduh FLAC lalu konversi ke MP3 320kbps';
+  String get enableLossyOptionSubtitleOn => 'Lossy quality option is available';
+
+  @override
+  String get enableLossyOptionSubtitleOff =>
+      'Downloads FLAC then converts to lossy format';
+
+  @override
+  String get lossyFormat => 'Lossy Format';
+
+  @override
+  String get lossyFormatDescription => 'Choose the lossy format for conversion';
+
+  @override
+  String get lossyFormatMp3Subtitle => '320kbps, best compatibility';
+
+  @override
+  String get lossyFormatOpusSubtitle =>
+      '128kbps, better quality at smaller size';

  @override
  String get qualityNote =>
      'Kualitas sebenarnya tergantung ketersediaan lagu dari layanan';

+  @override
+  String get youtubeQualityNote =>
+      'YouTube provides lossy audio only. Not part of lossless fallback.';
+
  @override
  String get downloadAskBeforeDownload => 'Tanya Sebelum Unduh';

@@ -1890,6 +1946,18 @@ class AppLocalizationsId extends AppLocalizations {
  @override
  String get downloadAlbumFolderStructure => 'Struktur Folder Album';

+  @override
+  String get downloadUseAlbumArtistForFolders =>
+      'Gunakan Album Artist untuk folder';
+
+  @override
+  String get downloadUseAlbumArtistForFoldersAlbumSubtitle =>
+      'Folder artis memakai Album Artist jika tersedia';
+
+  @override
+  String get downloadUseAlbumArtistForFoldersTrackSubtitle =>
+      'Folder artis hanya memakai Track Artist';
+
  @override
  String get downloadSaveFormat => 'Simpan Format';

@@ -1970,6 +2038,39 @@ class AppLocalizationsId extends AppLocalizations {
  String get queueClearAllMessage =>
      'Apakah Anda yakin ingin menghapus semua unduhan?';

+  @override
+  String get queueExportFailed => 'Export';
+
+  @override
+  String get queueExportFailedSuccess =>
+      'Failed downloads exported to TXT file';
+
+  @override
+  String get queueExportFailedClear => 'Clear Failed';
+
+  @override
+  String get queueExportFailedError => 'Failed to export downloads';
+
+  @override
+  String get settingsAutoExportFailed => 'Auto-export failed downloads';
+
+  @override
+  String get settingsAutoExportFailedSubtitle =>
+      'Save failed downloads to TXT file automatically';
+
+  @override
+  String get settingsDownloadNetwork => 'Download Network';
+
+  @override
+  String get settingsDownloadNetworkAny => 'WiFi + Mobile Data';
+
+  @override
+  String get settingsDownloadNetworkWifiOnly => 'WiFi Only';
+
+  @override
+  String get settingsDownloadNetworkSubtitle =>
+      'Choose which network to use for downloads. When set to WiFi Only, downloads will pause on mobile data.';
+
  @override
  String get queueEmpty => 'Tidak ada unduhan dalam antrian';

@@ -2019,6 +2120,13 @@ class AppLocalizationsId extends AppLocalizations {
  @override
  String get albumFolderYearAlbumSubtitle => 'Albums/[2005] Nama Album/';

+  @override
+  String get albumFolderArtistAlbumSingles => 'Artist / Album + Singles';
+
+  @override
+  String get albumFolderArtistAlbumSinglesSubtitle =>
+      'Artist/Album/ and Artist/Singles/';
+
  @override
  String get downloadedAlbumDeleteSelected => 'Hapus yang Dipilih';

@@ -2086,6 +2194,12 @@ class AppLocalizationsId extends AppLocalizations {
  @override
  String get recentTypePlaylist => 'Playlist';

+  @override
+  String get recentEmpty => 'Belum ada item terbaru';
+
+  @override
+  String get recentShowAllDownloads => 'Tampilkan Semua Download';
+
  @override
  String recentPlaylistInfo(String name) {
    return 'Playlist: $name';
@@ -2097,68 +2211,701 @@ class AppLocalizationsId extends AppLocalizations {
  }

  @override
-  String get discographyDownload => 'Unduh Diskografi';
+  String get discographyDownload => 'Download Discography';

  @override
  String get discographyDownloadAll => 'Unduh Semua';

  @override
  String discographyDownloadAllSubtitle(int count, int albumCount) {
-    return '$count lagu dari $albumCount rilis';
+    return '$count tracks from $albumCount releases';
  }

  @override
-  String get discographyAlbumsOnly => 'Album Saja';
+  String get discographyAlbumsOnly => 'Albums Only';

  @override
  String discographyAlbumsOnlySubtitle(int count, int albumCount) {
-    return '$count lagu dari $albumCount album';
+    return '$count tracks from $albumCount albums';
  }

  @override
-  String get discographySinglesOnly => 'Single & EP Saja';
+  String get discographySinglesOnly => 'Singles & EPs Only';

  @override
  String discographySinglesOnlySubtitle(int count, int albumCount) {
-    return '$count lagu dari $albumCount single';
+    return '$count tracks from $albumCount singles';
  }

  @override
-  String get discographySelectAlbums => 'Pilih Album...';
+  String get discographySelectAlbums => 'Select Albums...';

  @override
  String get discographySelectAlbumsSubtitle =>
-      'Pilih album atau single tertentu';
+      'Choose specific albums or singles';

  @override
-  String get discographyFetchingTracks => 'Mengambil lagu...';
+  String get discographyFetchingTracks => 'Fetching tracks...';

  @override
  String discographyFetchingAlbum(int current, int total) {
-    return 'Mengambil $current dari $total...';
+    return 'Fetching $current of $total...';
  }

  @override
  String discographySelectedCount(int count) {
-    return '$count dipilih';
+    return '$count selected';
  }

  @override
-  String get discographyDownloadSelected => 'Unduh yang Dipilih';
+  String get discographyDownloadSelected => 'Download Selected';

  @override
  String discographyAddedToQueue(int count) {
-    return 'Menambahkan $count lagu ke antrian';
+    return 'Added $count tracks to queue';
  }

  @override
  String discographySkippedDownloaded(int added, int skipped) {
-    return '$added ditambahkan, $skipped sudah diunduh';
+    return '$added added, $skipped already downloaded';
  }

  @override
-  String get discographyNoAlbums => 'Tidak ada album tersedia';
+  String get discographyNoAlbums => 'No albums available';

  @override
-  String get discographyFailedToFetch => 'Gagal mengambil beberapa album';
+  String get discographyFailedToFetch => 'Failed to fetch some albums';
+
+  @override
+  String get sectionStorageAccess => 'Storage Access';
+
+  @override
+  String get allFilesAccess => 'All Files Access';
+
+  @override
+  String get allFilesAccessEnabledSubtitle => 'Can write to any folder';
+
+  @override
+  String get allFilesAccessDisabledSubtitle => 'Limited to media folders only';
+
+  @override
+  String get allFilesAccessDescription =>
+      'Enable this if you encounter write errors when saving to custom folders. Android 13+ restricts access to certain directories by default.';
+
+  @override
+  String get allFilesAccessDeniedMessage =>
+      'Permission was denied. Please enable \'All files access\' manually in system settings.';
+
+  @override
+  String get allFilesAccessDisabledMessage =>
+      'All Files Access disabled. The app will use limited storage access.';
+
+  @override
+  String get settingsLocalLibrary => 'Local Library';
+
+  @override
+  String get settingsLocalLibrarySubtitle => 'Scan music & detect duplicates';
+
+  @override
+  String get settingsCache => 'Penyimpanan & Cache';
+
+  @override
+  String get settingsCacheSubtitle => 'Lihat ukuran dan bersihkan data cache';
+
+  @override
+  String get libraryTitle => 'Local Library';
+
+  @override
+  String get libraryStatus => 'Library Status';
+
+  @override
+  String get libraryScanSettings => 'Scan Settings';
+
+  @override
+  String get libraryEnableLocalLibrary => 'Enable Local Library';
+
+  @override
+  String get libraryEnableLocalLibrarySubtitle =>
+      'Scan and track your existing music';
+
+  @override
+  String get libraryFolder => 'Library Folder';
+
+  @override
+  String get libraryFolderHint => 'Tap to select folder';
+
+  @override
+  String get libraryShowDuplicateIndicator => 'Show Duplicate Indicator';
+
+  @override
+  String get libraryShowDuplicateIndicatorSubtitle =>
+      'Show when searching for existing tracks';
+
+  @override
+  String get libraryActions => 'Actions';
+
+  @override
+  String get libraryScan => 'Scan Library';
+
+  @override
+  String get libraryScanSubtitle => 'Scan for audio files';
+
+  @override
+  String get libraryScanSelectFolderFirst => 'Select a folder first';
+
+  @override
+  String get libraryCleanupMissingFiles => 'Cleanup Missing Files';
+
+  @override
+  String get libraryCleanupMissingFilesSubtitle =>
+      'Remove entries for files that no longer exist';
+
+  @override
+  String get libraryClear => 'Clear Library';
+
+  @override
+  String get libraryClearSubtitle => 'Remove all scanned tracks';
+
+  @override
+  String get libraryClearConfirmTitle => 'Clear Library';
+
+  @override
+  String get libraryClearConfirmMessage =>
+      'This will remove all scanned tracks from your library. Your actual music files will not be deleted.';
+
+  @override
+  String get libraryAbout => 'About Local Library';
+
+  @override
+  String get libraryAboutDescription =>
+      'Scans your existing music collection to detect duplicates when downloading. Supports FLAC, M4A, MP3, Opus, and OGG formats. Metadata is read from file tags when available.';
+
+  @override
+  String libraryTracksCount(int count) {
+    return '$count tracks';
+  }
+
+  @override
+  String libraryLastScanned(String time) {
+    return 'Last scanned: $time';
+  }
+
+  @override
+  String get libraryLastScannedNever => 'Never';
+
+  @override
+  String get libraryScanning => 'Scanning...';
+
+  @override
+  String libraryScanProgress(String progress, int total) {
+    return '$progress% of $total files';
+  }
+
+  @override
+  String get libraryInLibrary => 'In Library';
+
+  @override
+  String libraryRemovedMissingFiles(int count) {
+    return 'Removed $count missing files from library';
+  }
+
+  @override
+  String get libraryCleared => 'Library cleared';
+
+  @override
+  String get libraryStorageAccessRequired => 'Storage Access Required';
+
+  @override
+  String get libraryStorageAccessMessage =>
+      'SpotiFLAC needs storage access to scan your music library. Please grant permission in settings.';
+
+  @override
+  String get libraryFolderNotExist => 'Selected folder does not exist';
+
+  @override
+  String get librarySourceDownloaded => 'Downloaded';
+
+  @override
+  String get librarySourceLocal => 'Local';
+
+  @override
+  String get libraryFilterAll => 'All';
+
+  @override
+  String get libraryFilterDownloaded => 'Downloaded';
+
+  @override
+  String get libraryFilterLocal => 'Local';
+
+  @override
+  String get libraryFilterTitle => 'Filters';
+
+  @override
+  String get libraryFilterReset => 'Reset';
+
+  @override
+  String get libraryFilterApply => 'Apply';
+
+  @override
+  String get libraryFilterSource => 'Source';
+
+  @override
+  String get libraryFilterQuality => 'Quality';
+
+  @override
+  String get libraryFilterQualityHiRes => 'Hi-Res (24bit)';
+
+  @override
+  String get libraryFilterQualityCD => 'CD (16bit)';
+
+  @override
+  String get libraryFilterQualityLossy => 'Lossy';
+
+  @override
+  String get libraryFilterFormat => 'Format';
+
+  @override
+  String get libraryFilterDate => 'Date Added';
+
+  @override
+  String get libraryFilterDateToday => 'Today';
+
+  @override
+  String get libraryFilterDateWeek => 'This Week';
+
+  @override
+  String get libraryFilterDateMonth => 'This Month';
+
+  @override
+  String get libraryFilterDateYear => 'This Year';
+
+  @override
+  String get libraryFilterSort => 'Sort';
+
+  @override
+  String get libraryFilterSortLatest => 'Latest';
+
+  @override
+  String get libraryFilterSortOldest => 'Oldest';
+
+  @override
+  String libraryFilterActive(int count) {
+    return '$count filter(s) active';
+  }
+
+  @override
+  String get timeJustNow => 'Just now';
+
+  @override
+  String timeMinutesAgo(int count) {
+    String _temp0 = intl.Intl.pluralLogic(
+      count,
+      locale: localeName,
+      other: '$count minutes ago',
+      one: '1 minute ago',
+    );
+    return '$_temp0';
+  }
+
+  @override
+  String timeHoursAgo(int count) {
+    String _temp0 = intl.Intl.pluralLogic(
+      count,
+      locale: localeName,
+      other: '$count hours ago',
+      one: '1 hour ago',
+    );
+    return '$_temp0';
+  }
+
+  @override
+  String get storageSwitchTitle => 'Switch Storage Mode';
+
+  @override
+  String get storageSwitchToSafTitle => 'Switch to SAF Storage?';
+
+  @override
+  String get storageSwitchToAppTitle => 'Switch to App Storage?';
+
+  @override
+  String get storageSwitchToSafMessage =>
+      'Your existing downloads will remain in the current location and stay accessible.\n\nNew downloads will be saved to your selected SAF folder.';
+
+  @override
+  String get storageSwitchToAppMessage =>
+      'Your existing downloads will remain in the current SAF location and stay accessible.\n\nNew downloads will be saved to Music/SpotiFLAC folder.';
+
+  @override
+  String get storageSwitchExistingDownloads => 'Existing Downloads';
+
+  @override
+  String storageSwitchExistingDownloadsInfo(int count, String mode) {
+    return '$count tracks in $mode storage';
+  }
+
+  @override
+  String get storageSwitchNewDownloads => 'New Downloads';
+
+  @override
+  String storageSwitchNewDownloadsLocation(String location) {
+    return 'Will be saved to: $location';
+  }
+
+  @override
+  String get storageSwitchContinue => 'Continue';
+
+  @override
+  String get storageSwitchSelectFolder => 'Select SAF Folder';
+
+  @override
+  String get storageAppStorage => 'App Storage';
+
+  @override
+  String get storageSafStorage => 'SAF Storage';
+
+  @override
+  String storageModeBadge(String mode) {
+    return 'Storage: $mode';
+  }
+
+  @override
+  String get storageStatsTitle => 'Storage Statistics';
+
+  @override
+  String storageStatsAppCount(int count) {
+    return '$count tracks in App Storage';
+  }
+
+  @override
+  String storageStatsSafCount(int count) {
+    return '$count tracks in SAF Storage';
+  }
+
+  @override
+  String get storageModeInfo => 'Your files are stored in multiple locations';
+
+  @override
+  String get tutorialWelcomeTitle => 'Selamat Datang di SpotiFLAC!';
+
+  @override
+  String get tutorialWelcomeDesc =>
+      'Mari pelajari cara mengunduh musik favorit Anda dalam kualitas lossless. Tutorial singkat ini akan menunjukkan dasar-dasarnya.';
+
+  @override
+  String get tutorialWelcomeTip1 =>
+      'Unduh musik dari Spotify, Deezer, atau tempel URL yang didukung';
+
+  @override
+  String get tutorialWelcomeTip2 =>
+      'Dapatkan audio kualitas FLAC dari Tidal, Qobuz, atau Amazon Music';
+
+  @override
+  String get tutorialWelcomeTip3 =>
+      'Metadata, cover art, dan lirik otomatis tertanam';
+
+  @override
+  String get tutorialSearchTitle => 'Mencari Musik';
+
+  @override
+  String get tutorialSearchDesc =>
+      'Ada dua cara mudah untuk menemukan musik yang ingin Anda unduh.';
+
+  @override
+  String get tutorialSearchTip1 =>
+      'Tempel URL Spotify atau Deezer langsung di kotak pencarian';
+
+  @override
+  String get tutorialSearchTip2 =>
+      'Atau ketik nama lagu, artis, atau album untuk mencari';
+
+  @override
+  String get tutorialSearchTip3 =>
+      'Mendukung lagu, album, playlist, dan halaman artis';
+
+  @override
+  String get tutorialDownloadTitle => 'Mengunduh Musik';
+
+  @override
+  String get tutorialDownloadDesc =>
+      'Mengunduh musik itu mudah dan cepat. Begini caranya.';
+
+  @override
+  String get tutorialDownloadTip1 =>
+      'Ketuk tombol unduh di samping lagu mana pun untuk mulai mengunduh';
+
+  @override
+  String get tutorialDownloadTip2 =>
+      'Pilih kualitas yang Anda inginkan (FLAC, Hi-Res, atau MP3)';
+
+  @override
+  String get tutorialDownloadTip3 =>
+      'Unduh seluruh album atau playlist dengan satu ketukan';
+
+  @override
+  String get tutorialLibraryTitle => 'Perpustakaan Anda';
+
+  @override
+  String get tutorialLibraryDesc =>
+      'Semua musik yang Anda unduh terorganisir di tab Perpustakaan.';
+
+  @override
+  String get tutorialLibraryTip1 =>
+      'Lihat progres unduhan dan antrian di tab Perpustakaan';
+
+  @override
+  String get tutorialLibraryTip2 =>
+      'Ketuk lagu mana pun untuk memutarnya dengan pemutar musik';
+
+  @override
+  String get tutorialLibraryTip3 =>
+      'Beralih antara tampilan daftar dan grid untuk penjelajahan lebih baik';
+
+  @override
+  String get tutorialExtensionsTitle => 'Ekstensi';
+
+  @override
+  String get tutorialExtensionsDesc =>
+      'Tingkatkan kemampuan aplikasi dengan ekstensi komunitas.';
+
+  @override
+  String get tutorialExtensionsTip1 =>
+      'Jelajahi tab Toko untuk menemukan ekstensi berguna';
+
+  @override
+  String get tutorialExtensionsTip2 =>
+      'Tambahkan provider unduhan atau sumber pencarian baru';
+
+  @override
+  String get tutorialExtensionsTip3 =>
+      'Dapatkan lirik, metadata lebih baik, dan fitur lainnya';
+
+  @override
+  String get tutorialSettingsTitle => 'Sesuaikan Pengalaman Anda';
+
+  @override
+  String get tutorialSettingsDesc =>
+      'Personalisasi aplikasi di Pengaturan sesuai preferensi Anda.';
+
+  @override
+  String get tutorialSettingsTip1 =>
+      'Ubah lokasi unduhan dan organisasi folder';
+
+  @override
+  String get tutorialSettingsTip2 =>
+      'Atur kualitas audio dan preferensi format default';
+
+  @override
+  String get tutorialSettingsTip3 => 'Sesuaikan tema dan tampilan aplikasi';
+
+  @override
+  String get tutorialReadyMessage =>
+      'Anda siap! Mulai unduh musik favorit Anda sekarang.';
+
+  @override
+  String get tutorialExample => 'CONTOH';
+
+  @override
+  String get libraryForceFullScan => 'Pindai Ulang Penuh';
+
+  @override
+  String get libraryForceFullScanSubtitle =>
+      'Pindai ulang semua file, abaikan cache';
+
+  @override
+  String get cleanupOrphanedDownloads => 'Bersihkan Entri Unduhan Tidak Valid';
+
+  @override
+  String get cleanupOrphanedDownloadsSubtitle =>
+      'Hapus entri riwayat untuk file yang tidak ada lagi';
+
+  @override
+  String cleanupOrphanedDownloadsResult(int count) {
+    return 'Menghapus $count entri unduhan tidak valid dari riwayat';
+  }
+
+  @override
+  String get cleanupOrphanedDownloadsNone =>
+      'Tidak ada entri unduhan tidak valid';
+
+  @override
+  String get cacheTitle => 'Penyimpanan & Cache';
+
+  @override
+  String get cacheSummaryTitle => 'Ringkasan cache';
+
+  @override
+  String get cacheSummarySubtitle =>
+      'Membersihkan cache tidak akan menghapus file musik yang sudah diunduh.';
+
+  @override
+  String cacheEstimatedTotal(String size) {
+    return 'Estimasi penggunaan cache: $size';
+  }
+
+  @override
+  String get cacheSectionStorage => 'Data Cache';
+
+  @override
+  String get cacheSectionMaintenance => 'Perawatan';
+
+  @override
+  String get cacheAppDirectory => 'Direktori cache aplikasi';
+
+  @override
+  String get cacheAppDirectoryDesc =>
+      'Respons HTTP, data WebView, dan data sementara aplikasi.';
+
+  @override
+  String get cacheTempDirectory => 'Direktori sementara';
+
+  @override
+  String get cacheTempDirectoryDesc =>
+      'File sementara dari proses download dan konversi audio.';
+
+  @override
+  String get cacheCoverImage => 'Cache gambar cover';
+
+  @override
+  String get cacheCoverImageDesc =>
+      'Gambar cover album dan lagu yang diunduh. Akan diunduh ulang saat dilihat.';
+
+  @override
+  String get cacheLibraryCover => 'Cache cover library';
+
+  @override
+  String get cacheLibraryCoverDesc =>
+      'Cover dari file musik lokal. Akan diekstrak ulang saat scan berikutnya.';
+
+  @override
+  String get cacheExploreFeed => 'Cache feed Explore';
+
+  @override
+  String get cacheExploreFeedDesc =>
+      'Konten tab Explore (rilis baru, trending). Akan dimuat ulang saat dikunjungi.';
+
+  @override
+  String get cacheTrackLookup => 'Cache pencocokan lagu';
+
+  @override
+  String get cacheTrackLookupDesc =>
+      'Cache pencarian ID lagu Spotify/Deezer. Menghapus mungkin memperlambat beberapa pencarian.';
+
+  @override
+  String get cacheCleanupUnusedDesc =>
+      'Hapus entri riwayat download dan library yang filenya sudah tidak ada.';
+
+  @override
+  String get cacheNoData => 'Tidak ada data cache';
+
+  @override
+  String cacheSizeWithFiles(String size, int count) {
+    return '$size dalam $count file';
+  }
+
+  @override
+  String cacheSizeOnly(String size) {
+    return '$size';
+  }
+
+  @override
+  String cacheEntries(int count) {
+    return '$count entri';
+  }
+
+  @override
+  String cacheClearSuccess(String target) {
+    return 'Berhasil dibersihkan: $target';
+  }
+
+  @override
+  String get cacheClearConfirmTitle => 'Bersihkan cache?';
+
+  @override
+  String cacheClearConfirmMessage(String target) {
+    return 'Ini akan membersihkan data cache untuk $target. File musik yang sudah diunduh tidak akan dihapus.';
+  }
+
+  @override
+  String get cacheClearAllConfirmTitle => 'Bersihkan semua cache?';
+
+  @override
+  String get cacheClearAllConfirmMessage =>
+      'Ini akan membersihkan semua kategori cache di halaman ini. File musik yang sudah diunduh tidak akan dihapus.';
+
+  @override
+  String get cacheClearAll => 'Bersihkan semua cache';
+
+  @override
+  String get cacheCleanupUnused => 'Bersihkan data tidak terpakai';
+
+  @override
+  String get cacheCleanupUnusedSubtitle =>
+      'Hapus riwayat unduhan yatim dan entri library yang file-nya hilang';
+
+  @override
+  String cacheCleanupResult(int downloadCount, int libraryCount) {
+    return 'Pembersihan selesai: $downloadCount unduhan yatim, $libraryCount entri library hilang';
+  }
+
+  @override
+  String get cacheRefreshStats => 'Segarkan statistik';
+
+  @override
+  String get trackSaveCoverArt => 'Simpan Cover Art';
+
+  @override
+  String get trackSaveCoverArtSubtitle =>
+      'Simpan cover album sebagai file .jpg';
+
+  @override
+  String get trackSaveLyrics => 'Simpan Lirik (.lrc)';
+
+  @override
+  String get trackSaveLyricsSubtitle =>
+      'Ambil dan simpan lirik sebagai file .lrc';
+
+  @override
+  String get trackReEnrich => 'Perkaya Ulang Metadata';
+
+  @override
+  String get trackReEnrichSubtitle =>
+      'Tanamkan ulang metadata tanpa mengunduh ulang';
+
+  @override
+  String get trackReEnrichOnlineSubtitle =>
+      'Cari metadata dari internet dan tanamkan ke file';
+
+  @override
+  String get trackEditMetadata => 'Edit Metadata';
+
+  @override
+  String trackCoverSaved(String fileName) {
+    return 'Cover art disimpan ke $fileName';
+  }
+
+  @override
+  String get trackCoverNoSource => 'Tidak ada sumber cover art';
+
+  @override
+  String trackLyricsSaved(String fileName) {
+    return 'Lirik disimpan ke $fileName';
+  }
+
+  @override
+  String get trackReEnrichProgress => 'Memperkaya ulang metadata...';
+
+  @override
+  String get trackReEnrichSearching => 'Mencari metadata dari internet...';
+
+  @override
+  String get trackReEnrichSuccess => 'Metadata berhasil diperkaya ulang';
+
+  @override
+  String get trackReEnrichFfmpegFailed =>
+      'Gagal menanamkan metadata via FFmpeg';
+
+  @override
+  String trackSaveFailed(String error) {
+    return 'Gagal: $error';
+  }
 }
@@ -18,6 +18,9 @@ class AppLocalizationsKo extends AppLocalizations {
  @override
  String get navHome => 'Home';

+  @override
+  String get navLibrary => 'Library';
+
  @override
  String get navHistory => 'History';

@@ -340,6 +343,10 @@ class AppLocalizationsKo extends AppLocalizations {
  String get optionsSpotifyWarning =>
      'Spotify requires your own API credentials. Get them free from developer.spotify.com';

+  @override
+  String get optionsSpotifyDeprecationWarning =>
+      'Spotify search will be deprecated on March 3, 2026 due to Spotify API changes. Please switch to Deezer.';
+
  @override
  String get extensionsTitle => 'Extensions';

@@ -470,6 +477,10 @@ class AppLocalizationsKo extends AppLocalizations {
  String get aboutSachinsenalDesc =>
      'The original HiFi project creator. The foundation of Tidal integration!';

+  @override
+  String get aboutSjdonadoDesc =>
+      'Creator of I Don\'t Have Spotify (IDHS). The fallback link resolver that saves the day!';
+
  @override
  String get aboutDoubleDouble => 'DoubleDouble';

@@ -484,6 +495,13 @@ class AppLocalizationsKo extends AppLocalizations {
  String get aboutDabMusicDesc =>
      'The best Qobuz streaming API. Hi-Res downloads wouldn\'t be possible without this!';

+  @override
+  String get aboutSpotiSaver => 'SpotiSaver';
+
+  @override
+  String get aboutSpotiSaverDesc =>
+      'Tidal Hi-Res FLAC streaming endpoints. A key piece of the lossless puzzle!';
+
  @override
  String get aboutAppDescription =>
      'Download Spotify tracks in lossless quality from Tidal, Qobuz, and Amazon Music.';
@@ -680,6 +698,10 @@ class AppLocalizationsKo extends AppLocalizations {
  String get setupIosEmptyFolderWarning =>
      'iOS limitation: Empty folders cannot be selected. Choose a folder with at least one file.';

+  @override
+  String get setupIcloudNotSupported =>
+      'iCloud Drive is not supported. Please use the app Documents folder.';
+
  @override
  String get setupDownloadInFlac => 'Download Spotify tracks in FLAC';

@@ -935,6 +957,11 @@ class AppLocalizationsKo extends AppLocalizations {
    return '\"$trackName\" already downloaded';
  }

+  @override
+  String snackbarAlreadyInLibrary(String trackName) {
+    return '\"$trackName\" already exists in your library';
+  }
+
  @override
  String get snackbarHistoryCleared => 'History cleared';

@@ -1618,6 +1645,15 @@ class AppLocalizationsKo extends AppLocalizations {
  @override
  String get trackLyricsLoadFailed => 'Failed to load lyrics';

+  @override
+  String get trackEmbedLyrics => 'Embed Lyrics';
+
+  @override
+  String get trackLyricsEmbedded => 'Lyrics embedded successfully';
+
+  @override
+  String get trackInstrumental => 'Instrumental track';
+
  @override
  String get trackCopiedToClipboard => 'Copied to clipboard';

@@ -1847,25 +1883,45 @@ class AppLocalizationsKo extends AppLocalizations {
  String get qualityHiResFlacMaxSubtitle => '24-bit / up to 192kHz';

  @override
-  String get qualityMp3 => 'MP3';
+  String get qualityLossy => 'Lossy';

  @override
-  String get qualityMp3Subtitle => '320kbps (converted from FLAC)';
+  String get qualityLossyMp3Subtitle => 'MP3 320kbps (converted from FLAC)';

  @override
-  String get enableMp3Option => 'Enable MP3 Option';
+  String get qualityLossyOpusSubtitle => 'Opus 128kbps (converted from FLAC)';

  @override
-  String get enableMp3OptionSubtitleOn => 'MP3 quality option is available';
+  String get enableLossyOption => 'Enable Lossy Option';

  @override
-  String get enableMp3OptionSubtitleOff =>
-      'Downloads FLAC then converts to 320kbps MP3';
+  String get enableLossyOptionSubtitleOn => 'Lossy quality option is available';
+
+  @override
+  String get enableLossyOptionSubtitleOff =>
+      'Downloads FLAC then converts to lossy format';
+
+  @override
+  String get lossyFormat => 'Lossy Format';
+
+  @override
+  String get lossyFormatDescription => 'Choose the lossy format for conversion';
+
+  @override
+  String get lossyFormatMp3Subtitle => '320kbps, best compatibility';
+
+  @override
+  String get lossyFormatOpusSubtitle =>
+      '128kbps, better quality at smaller size';

  @override
  String get qualityNote =>
      'Actual quality depends on track availability from the service';

+  @override
+  String get youtubeQualityNote =>
+      'YouTube provides lossy audio only. Not part of lossless fallback.';
+
  @override
  String get downloadAskBeforeDownload => 'Ask Before Download';

@@ -1878,6 +1934,17 @@ class AppLocalizationsKo extends AppLocalizations {
  @override
  String get downloadAlbumFolderStructure => 'Album Folder Structure';

+  @override
+  String get downloadUseAlbumArtistForFolders => 'Use Album Artist for folders';
+
+  @override
+  String get downloadUseAlbumArtistForFoldersAlbumSubtitle =>
+      'Artist folders use Album Artist when available';
+
+  @override
+  String get downloadUseAlbumArtistForFoldersTrackSubtitle =>
+      'Artist folders use Track Artist only';
+
  @override
  String get downloadSaveFormat => 'Save Format';

@@ -1957,6 +2024,39 @@ class AppLocalizationsKo extends AppLocalizations {
  String get queueClearAllMessage =>
      'Are you sure you want to clear all downloads?';

+  @override
+  String get queueExportFailed => 'Export';
+
+  @override
+  String get queueExportFailedSuccess =>
+      'Failed downloads exported to TXT file';
+
+  @override
+  String get queueExportFailedClear => 'Clear Failed';
+
+  @override
+  String get queueExportFailedError => 'Failed to export downloads';
+
+  @override
+  String get settingsAutoExportFailed => 'Auto-export failed downloads';
+
+  @override
+  String get settingsAutoExportFailedSubtitle =>
+      'Save failed downloads to TXT file automatically';
+
+  @override
+  String get settingsDownloadNetwork => 'Download Network';
+
+  @override
+  String get settingsDownloadNetworkAny => 'WiFi + Mobile Data';
+
+  @override
+  String get settingsDownloadNetworkWifiOnly => 'WiFi Only';
+
+  @override
+  String get settingsDownloadNetworkSubtitle =>
+      'Choose which network to use for downloads. When set to WiFi Only, downloads will pause on mobile data.';
+
  @override
  String get queueEmpty => 'No downloads in queue';

@@ -2006,6 +2106,13 @@ class AppLocalizationsKo extends AppLocalizations {
  @override
  String get albumFolderYearAlbumSubtitle => 'Albums/[2005] Album Name/';

+  @override
+  String get albumFolderArtistAlbumSingles => 'Artist / Album + Singles';
+
+  @override
+  String get albumFolderArtistAlbumSinglesSubtitle =>
+      'Artist/Album/ and Artist/Singles/';
+
  @override
  String get downloadedAlbumDeleteSelected => 'Delete Selected';

@@ -2073,6 +2180,12 @@ class AppLocalizationsKo extends AppLocalizations {
  @override
  String get recentTypePlaylist => 'Playlist';

+  @override
+  String get recentEmpty => 'No recent items yet';
+
+  @override
+  String get recentShowAllDownloads => 'Show All Downloads';
+
  @override
  String recentPlaylistInfo(String name) {
    return 'Playlist: $name';
@@ -2148,4 +2261,632 @@ class AppLocalizationsKo extends AppLocalizations {

  @override
  String get discographyFailedToFetch => 'Failed to fetch some albums';
+
+  @override
+  String get sectionStorageAccess => 'Storage Access';
+
+  @override
+  String get allFilesAccess => 'All Files Access';
+
+  @override
+  String get allFilesAccessEnabledSubtitle => 'Can write to any folder';
+
+  @override
+  String get allFilesAccessDisabledSubtitle => 'Limited to media folders only';
+
+  @override
+  String get allFilesAccessDescription =>
+      'Enable this if you encounter write errors when saving to custom folders. Android 13+ restricts access to certain directories by default.';
+
+  @override
+  String get allFilesAccessDeniedMessage =>
+      'Permission was denied. Please enable \'All files access\' manually in system settings.';
+
+  @override
+  String get allFilesAccessDisabledMessage =>
+      'All Files Access disabled. The app will use limited storage access.';
+
+  @override
+  String get settingsLocalLibrary => 'Local Library';
+
+  @override
+  String get settingsLocalLibrarySubtitle => 'Scan music & detect duplicates';
+
+  @override
+  String get settingsCache => 'Storage & Cache';
+
+  @override
+  String get settingsCacheSubtitle => 'View size and clear cached data';
+
+  @override
+  String get libraryTitle => 'Local Library';
+
+  @override
+  String get libraryStatus => 'Library Status';
+
+  @override
+  String get libraryScanSettings => 'Scan Settings';
+
+  @override
+  String get libraryEnableLocalLibrary => 'Enable Local Library';
+
+  @override
+  String get libraryEnableLocalLibrarySubtitle =>
+      'Scan and track your existing music';
+
+  @override
+  String get libraryFolder => 'Library Folder';
+
+  @override
+  String get libraryFolderHint => 'Tap to select folder';
+
+  @override
+  String get libraryShowDuplicateIndicator => 'Show Duplicate Indicator';
+
+  @override
+  String get libraryShowDuplicateIndicatorSubtitle =>
+      'Show when searching for existing tracks';
+
+  @override
+  String get libraryActions => 'Actions';
+
+  @override
+  String get libraryScan => 'Scan Library';
+
+  @override
+  String get libraryScanSubtitle => 'Scan for audio files';
+
+  @override
+  String get libraryScanSelectFolderFirst => 'Select a folder first';
+
+  @override
+  String get libraryCleanupMissingFiles => 'Cleanup Missing Files';
+
+  @override
+  String get libraryCleanupMissingFilesSubtitle =>
+      'Remove entries for files that no longer exist';
+
+  @override
+  String get libraryClear => 'Clear Library';
+
+  @override
+  String get libraryClearSubtitle => 'Remove all scanned tracks';
+
+  @override
+  String get libraryClearConfirmTitle => 'Clear Library';
+
+  @override
+  String get libraryClearConfirmMessage =>
+      'This will remove all scanned tracks from your library. Your actual music files will not be deleted.';
+
+  @override
+  String get libraryAbout => 'About Local Library';
+
+  @override
+  String get libraryAboutDescription =>
+      'Scans your existing music collection to detect duplicates when downloading. Supports FLAC, M4A, MP3, Opus, and OGG formats. Metadata is read from file tags when available.';
+
+  @override
+  String libraryTracksCount(int count) {
+    return '$count tracks';
+  }
+
+  @override
+  String libraryLastScanned(String time) {
+    return 'Last scanned: $time';
+  }
+
+  @override
+  String get libraryLastScannedNever => 'Never';
+
+  @override
+  String get libraryScanning => 'Scanning...';
+
+  @override
+  String libraryScanProgress(String progress, int total) {
+    return '$progress% of $total files';
+  }
+
+  @override
+  String get libraryInLibrary => 'In Library';
+
+  @override
+  String libraryRemovedMissingFiles(int count) {
+    return 'Removed $count missing files from library';
+  }
+
+  @override
+  String get libraryCleared => 'Library cleared';
+
+  @override
+  String get libraryStorageAccessRequired => 'Storage Access Required';
+
+  @override
+  String get libraryStorageAccessMessage =>
+      'SpotiFLAC needs storage access to scan your music library. Please grant permission in settings.';
+
+  @override
+  String get libraryFolderNotExist => 'Selected folder does not exist';
+
+  @override
+  String get librarySourceDownloaded => 'Downloaded';
+
+  @override
+  String get librarySourceLocal => 'Local';
+
+  @override
+  String get libraryFilterAll => 'All';
+
+  @override
+  String get libraryFilterDownloaded => 'Downloaded';
+
+  @override
+  String get libraryFilterLocal => 'Local';
+
+  @override
+  String get libraryFilterTitle => 'Filters';
+
+  @override
+  String get libraryFilterReset => 'Reset';
+
+  @override
+  String get libraryFilterApply => 'Apply';
+
+  @override
+  String get libraryFilterSource => 'Source';
+
+  @override
+  String get libraryFilterQuality => 'Quality';
+
+  @override
+  String get libraryFilterQualityHiRes => 'Hi-Res (24bit)';
+
+  @override
+  String get libraryFilterQualityCD => 'CD (16bit)';
+
+  @override
+  String get libraryFilterQualityLossy => 'Lossy';
+
+  @override
+  String get libraryFilterFormat => 'Format';
+
+  @override
+  String get libraryFilterDate => 'Date Added';
+
+  @override
+  String get libraryFilterDateToday => 'Today';
+
+  @override
+  String get libraryFilterDateWeek => 'This Week';
+
+  @override
+  String get libraryFilterDateMonth => 'This Month';
+
+  @override
+  String get libraryFilterDateYear => 'This Year';
+
+  @override
+  String get libraryFilterSort => 'Sort';
+
+  @override
+  String get libraryFilterSortLatest => 'Latest';
+
+  @override
+  String get libraryFilterSortOldest => 'Oldest';
+
+  @override
+  String libraryFilterActive(int count) {
+    return '$count filter(s) active';
+  }
+
+  @override
+  String get timeJustNow => 'Just now';
+
+  @override
+  String timeMinutesAgo(int count) {
+    String _temp0 = intl.Intl.pluralLogic(
+      count,
+      locale: localeName,
+      other: '$count minutes ago',
+      one: '1 minute ago',
+    );
+    return '$_temp0';
+  }
+
+  @override
+  String timeHoursAgo(int count) {
+    String _temp0 = intl.Intl.pluralLogic(
+      count,
+      locale: localeName,
+      other: '$count hours ago',
+      one: '1 hour ago',
+    );
+    return '$_temp0';
+  }
+
+  @override
+  String get storageSwitchTitle => 'Switch Storage Mode';
+
+  @override
+  String get storageSwitchToSafTitle => 'Switch to SAF Storage?';
+
+  @override
+  String get storageSwitchToAppTitle => 'Switch to App Storage?';
+
+  @override
+  String get storageSwitchToSafMessage =>
+      'Your existing downloads will remain in the current location and stay accessible.\n\nNew downloads will be saved to your selected SAF folder.';
+
+  @override
+  String get storageSwitchToAppMessage =>
+      'Your existing downloads will remain in the current SAF location and stay accessible.\n\nNew downloads will be saved to Music/SpotiFLAC folder.';
+
+  @override
+  String get storageSwitchExistingDownloads => 'Existing Downloads';
+
+  @override
+  String storageSwitchExistingDownloadsInfo(int count, String mode) {
+    return '$count tracks in $mode storage';
+  }
+
+  @override
+  String get storageSwitchNewDownloads => 'New Downloads';
+
+  @override
+  String storageSwitchNewDownloadsLocation(String location) {
+    return 'Will be saved to: $location';
+  }
+
+  @override
+  String get storageSwitchContinue => 'Continue';
+
+  @override
+  String get storageSwitchSelectFolder => 'Select SAF Folder';
+
+  @override
+  String get storageAppStorage => 'App Storage';
+
+  @override
+  String get storageSafStorage => 'SAF Storage';
+
+  @override
+  String storageModeBadge(String mode) {
+    return 'Storage: $mode';
+  }
+
+  @override
+  String get storageStatsTitle => 'Storage Statistics';
+
+  @override
+  String storageStatsAppCount(int count) {
+    return '$count tracks in App Storage';
+  }
+
+  @override
+  String storageStatsSafCount(int count) {
+    return '$count tracks in SAF Storage';
+  }
+
+  @override
+  String get storageModeInfo => 'Your files are stored in multiple locations';
+
+  @override
+  String get tutorialWelcomeTitle => 'Welcome to SpotiFLAC!';
+
+  @override
+  String get tutorialWelcomeDesc =>
+      'Let\'s learn how to download your favorite music in lossless quality. This quick tutorial will show you the basics.';
+
+  @override
+  String get tutorialWelcomeTip1 =>
+      'Download music from Spotify, Deezer, or paste any supported URL';
+
+  @override
+  String get tutorialWelcomeTip2 =>
+      'Get FLAC quality audio from Tidal, Qobuz, or Amazon Music';
+
+  @override
+  String get tutorialWelcomeTip3 =>
+      'Automatic metadata, cover art, and lyrics embedding';
+
+  @override
+  String get tutorialSearchTitle => 'Finding Music';
+
+  @override
+  String get tutorialSearchDesc =>
+      'There are two easy ways to find music you want to download.';
+
+  @override
+  String get tutorialSearchTip1 =>
+      'Paste a Spotify or Deezer URL directly in the search box';
+
+  @override
+  String get tutorialSearchTip2 =>
+      'Or type the song name, artist, or album to search';
+
+  @override
+  String get tutorialSearchTip3 =>
+      'Supports tracks, albums, playlists, and artist pages';
+
+  @override
+  String get tutorialDownloadTitle => 'Downloading Music';
+
+  @override
+  String get tutorialDownloadDesc =>
+      'Downloading music is simple and fast. Here\'s how it works.';
+
+  @override
+  String get tutorialDownloadTip1 =>
+      'Tap the download button next to any track to start downloading';
+
+  @override
+  String get tutorialDownloadTip2 =>
+      'Choose your preferred quality (FLAC, Hi-Res, or MP3)';
+
+  @override
+  String get tutorialDownloadTip3 =>
+      'Download entire albums or playlists with one tap';
+
+  @override
+  String get tutorialLibraryTitle => 'Your Library';
+
+  @override
+  String get tutorialLibraryDesc =>
+      'All your downloaded music is organized in the Library tab.';
+
+  @override
+  String get tutorialLibraryTip1 =>
+      'View download progress and queue in the Library tab';
+
+  @override
+  String get tutorialLibraryTip2 =>
+      'Tap any track to play it with your music player';
+
+  @override
+  String get tutorialLibraryTip3 =>
+      'Switch between list and grid view for better browsing';
+
+  @override
+  String get tutorialExtensionsTitle => 'Extensions';
+
+  @override
+  String get tutorialExtensionsDesc =>
+      'Extend the app\'s capabilities with community extensions.';
+
+  @override
+  String get tutorialExtensionsTip1 =>
+      'Browse the Store tab to discover useful extensions';
+
+  @override
+  String get tutorialExtensionsTip2 =>
+      'Add new download providers or search sources';
+
+  @override
+  String get tutorialExtensionsTip3 =>
+      'Get lyrics, enhanced metadata, and more features';
+
+  @override
+  String get tutorialSettingsTitle => 'Customize Your Experience';
+
+  @override
+  String get tutorialSettingsDesc =>
+      'Personalize the app in Settings to match your preferences.';
+
+  @override
+  String get tutorialSettingsTip1 =>
+      'Change download location and folder organization';
+
+  @override
+  String get tutorialSettingsTip2 =>
+      'Set default audio quality and format preferences';
+
+  @override
+  String get tutorialSettingsTip3 => 'Customize app theme and appearance';
+
+  @override
+  String get tutorialReadyMessage =>
+      'You\'re all set! Start downloading your favorite music now.';
+
+  @override
+  String get tutorialExample => 'EXAMPLE';
+
+  @override
+  String get libraryForceFullScan => 'Force Full Scan';
+
+  @override
+  String get libraryForceFullScanSubtitle => 'Rescan all files, ignoring cache';
+
+  @override
+  String get cleanupOrphanedDownloads => 'Cleanup Orphaned Downloads';
+
+  @override
+  String get cleanupOrphanedDownloadsSubtitle =>
+      'Remove history entries for files that no longer exist';
+
+  @override
+  String cleanupOrphanedDownloadsResult(int count) {
+    return 'Removed $count orphaned entries from history';
+  }
+
+  @override
+  String get cleanupOrphanedDownloadsNone => 'No orphaned entries found';
+
+  @override
+  String get cacheTitle => 'Storage & Cache';
+
+  @override
+  String get cacheSummaryTitle => 'Cache overview';
+
+  @override
+  String get cacheSummarySubtitle =>
+      'Clearing cache will not remove downloaded music files.';
+
+  @override
+  String cacheEstimatedTotal(String size) {
+    return 'Estimated cache usage: $size';
+  }
+
+  @override
+  String get cacheSectionStorage => 'Cached Data';
+
+  @override
+  String get cacheSectionMaintenance => 'Maintenance';
+
+  @override
+  String get cacheAppDirectory => 'App cache directory';
+
+  @override
+  String get cacheAppDirectoryDesc =>
+      'HTTP responses, WebView data, and other temporary app data.';
+
+  @override
+  String get cacheTempDirectory => 'Temporary directory';
+
+  @override
+  String get cacheTempDirectoryDesc =>
+      'Temporary files from downloads and audio conversion.';
+
+  @override
+  String get cacheCoverImage => 'Cover image cache';
+
+  @override
+  String get cacheCoverImageDesc =>
+      'Downloaded album and track cover art. Will re-download when viewed.';
+
+  @override
+  String get cacheLibraryCover => 'Library cover cache';
+
+  @override
+  String get cacheLibraryCoverDesc =>
+      'Cover art extracted from local music files. Will re-extract on next scan.';
+
+  @override
+  String get cacheExploreFeed => 'Explore feed cache';
+
+  @override
+  String get cacheExploreFeedDesc =>
+      'Explore tab content (new releases, trending). Will refresh on next visit.';
+
+  @override
+  String get cacheTrackLookup => 'Track lookup cache';
+
+  @override
+  String get cacheTrackLookupDesc =>
+      'Spotify/Deezer track ID lookups. Clearing may slow next few searches.';
+
+  @override
+  String get cacheCleanupUnusedDesc =>
+      'Remove orphaned download history and library entries for missing files.';
+
+  @override
+  String get cacheNoData => 'No cached data';
+
+  @override
+  String cacheSizeWithFiles(String size, int count) {
+    return '$size in $count files';
+  }
+
+  @override
+  String cacheSizeOnly(String size) {
+    return '$size';
+  }
+
+  @override
+  String cacheEntries(int count) {
+    return '$count entries';
+  }
+
+  @override
+  String cacheClearSuccess(String target) {
+    return 'Cleared: $target';
+  }
+
+  @override
+  String get cacheClearConfirmTitle => 'Clear cache?';
+
+  @override
+  String cacheClearConfirmMessage(String target) {
+    return 'This will clear cached data for $target. Downloaded music files will not be deleted.';
+  }
+
+  @override
+  String get cacheClearAllConfirmTitle => 'Clear all cache?';
+
+  @override
+  String get cacheClearAllConfirmMessage =>
+      'This will clear all cache categories on this page. Downloaded music files will not be deleted.';
+
+  @override
+  String get cacheClearAll => 'Clear all cache';
+
+  @override
+  String get cacheCleanupUnused => 'Cleanup unused data';
+
+  @override
+  String get cacheCleanupUnusedSubtitle =>
+      'Remove orphaned download history and missing library entries';
+
+  @override
+  String cacheCleanupResult(int downloadCount, int libraryCount) {
+    return 'Cleanup completed: $downloadCount orphaned downloads, $libraryCount missing library entries';
+  }
+
+  @override
+  String get cacheRefreshStats => 'Refresh stats';
+
+  @override
+  String get trackSaveCoverArt => 'Save Cover Art';
+
+  @override
+  String get trackSaveCoverArtSubtitle => 'Save album art as .jpg file';
+
+  @override
+  String get trackSaveLyrics => 'Save Lyrics (.lrc)';
+
+  @override
+  String get trackSaveLyricsSubtitle => 'Fetch and save lyrics as .lrc file';
+
+  @override
+  String get trackReEnrich => 'Re-enrich Metadata';
+
+  @override
+  String get trackReEnrichSubtitle =>
+      'Re-embed metadata without re-downloading';
+
+  @override
+  String get trackReEnrichOnlineSubtitle =>
+      'Search metadata online and embed into file';
+
+  @override
+  String get trackEditMetadata => 'Edit Metadata';
+
+  @override
+  String trackCoverSaved(String fileName) {
+    return 'Cover art saved to $fileName';
+  }
+
+  @override
+  String get trackCoverNoSource => 'No cover art source available';
+
+  @override
+  String trackLyricsSaved(String fileName) {
+    return 'Lyrics saved to $fileName';
+  }
+
+  @override
+  String get trackReEnrichProgress => 'Re-enriching metadata...';
+
+  @override
+  String get trackReEnrichSearching => 'Searching metadata online...';
+
+  @override
+  String get trackReEnrichSuccess => 'Metadata re-enriched successfully';
+
+  @override
+  String get trackReEnrichFfmpegFailed => 'FFmpeg metadata embed failed';
+
+  @override
+  String trackSaveFailed(String error) {
+    return 'Failed: $error';
+  }
 }
@@ -18,6 +18,9 @@ class AppLocalizationsNl extends AppLocalizations {
  @override
  String get navHome => 'Home';

+  @override
+  String get navLibrary => 'Library';
+
  @override
  String get navHistory => 'History';

@@ -340,6 +343,10 @@ class AppLocalizationsNl extends AppLocalizations {
  String get optionsSpotifyWarning =>
      'Spotify requires your own API credentials. Get them free from developer.spotify.com';

+  @override
+  String get optionsSpotifyDeprecationWarning =>
+      'Spotify search will be deprecated on March 3, 2026 due to Spotify API changes. Please switch to Deezer.';
+
  @override
  String get extensionsTitle => 'Extensions';

@@ -470,6 +477,10 @@ class AppLocalizationsNl extends AppLocalizations {
  String get aboutSachinsenalDesc =>
      'The original HiFi project creator. The foundation of Tidal integration!';

+  @override
+  String get aboutSjdonadoDesc =>
+      'Creator of I Don\'t Have Spotify (IDHS). The fallback link resolver that saves the day!';
+
  @override
  String get aboutDoubleDouble => 'DoubleDouble';

@@ -484,6 +495,13 @@ class AppLocalizationsNl extends AppLocalizations {
  String get aboutDabMusicDesc =>
      'The best Qobuz streaming API. Hi-Res downloads wouldn\'t be possible without this!';

+  @override
+  String get aboutSpotiSaver => 'SpotiSaver';
+
+  @override
+  String get aboutSpotiSaverDesc =>
+      'Tidal Hi-Res FLAC streaming endpoints. A key piece of the lossless puzzle!';
+
  @override
  String get aboutAppDescription =>
      'Download Spotify tracks in lossless quality from Tidal, Qobuz, and Amazon Music.';
@@ -680,6 +698,10 @@ class AppLocalizationsNl extends AppLocalizations {
  String get setupIosEmptyFolderWarning =>
      'iOS limitation: Empty folders cannot be selected. Choose a folder with at least one file.';

+  @override
+  String get setupIcloudNotSupported =>
+      'iCloud Drive is not supported. Please use the app Documents folder.';
+
  @override
  String get setupDownloadInFlac => 'Download Spotify tracks in FLAC';

@@ -935,6 +957,11 @@ class AppLocalizationsNl extends AppLocalizations {
    return '\"$trackName\" already downloaded';
  }

+  @override
+  String snackbarAlreadyInLibrary(String trackName) {
+    return '\"$trackName\" already exists in your library';
+  }
+
  @override
  String get snackbarHistoryCleared => 'History cleared';

@@ -1618,6 +1645,15 @@ class AppLocalizationsNl extends AppLocalizations {
  @override
  String get trackLyricsLoadFailed => 'Failed to load lyrics';

+  @override
+  String get trackEmbedLyrics => 'Embed Lyrics';
+
+  @override
+  String get trackLyricsEmbedded => 'Lyrics embedded successfully';
+
+  @override
+  String get trackInstrumental => 'Instrumental track';
+
  @override
  String get trackCopiedToClipboard => 'Copied to clipboard';

@@ -1847,25 +1883,45 @@ class AppLocalizationsNl extends AppLocalizations {
  String get qualityHiResFlacMaxSubtitle => '24-bit / up to 192kHz';

  @override
-  String get qualityMp3 => 'MP3';
+  String get qualityLossy => 'Lossy';

  @override
-  String get qualityMp3Subtitle => '320kbps (converted from FLAC)';
+  String get qualityLossyMp3Subtitle => 'MP3 320kbps (converted from FLAC)';

  @override
-  String get enableMp3Option => 'Enable MP3 Option';
+  String get qualityLossyOpusSubtitle => 'Opus 128kbps (converted from FLAC)';

  @override
-  String get enableMp3OptionSubtitleOn => 'MP3 quality option is available';
+  String get enableLossyOption => 'Enable Lossy Option';

  @override
-  String get enableMp3OptionSubtitleOff =>
-      'Downloads FLAC then converts to 320kbps MP3';
+  String get enableLossyOptionSubtitleOn => 'Lossy quality option is available';
+
+  @override
+  String get enableLossyOptionSubtitleOff =>
+      'Downloads FLAC then converts to lossy format';
+
+  @override
+  String get lossyFormat => 'Lossy Format';
+
+  @override
+  String get lossyFormatDescription => 'Choose the lossy format for conversion';
+
+  @override
+  String get lossyFormatMp3Subtitle => '320kbps, best compatibility';
+
+  @override
+  String get lossyFormatOpusSubtitle =>
+      '128kbps, better quality at smaller size';

  @override
  String get qualityNote =>
      'Actual quality depends on track availability from the service';

+  @override
+  String get youtubeQualityNote =>
+      'YouTube provides lossy audio only. Not part of lossless fallback.';
+
  @override
  String get downloadAskBeforeDownload => 'Ask Before Download';

@@ -1878,6 +1934,17 @@ class AppLocalizationsNl extends AppLocalizations {
  @override
  String get downloadAlbumFolderStructure => 'Album Folder Structure';

+  @override
+  String get downloadUseAlbumArtistForFolders => 'Use Album Artist for folders';
+
+  @override
+  String get downloadUseAlbumArtistForFoldersAlbumSubtitle =>
+      'Artist folders use Album Artist when available';
+
+  @override
+  String get downloadUseAlbumArtistForFoldersTrackSubtitle =>
+      'Artist folders use Track Artist only';
+
  @override
  String get downloadSaveFormat => 'Save Format';

@@ -1957,6 +2024,39 @@ class AppLocalizationsNl extends AppLocalizations {
  String get queueClearAllMessage =>
      'Are you sure you want to clear all downloads?';

+  @override
+  String get queueExportFailed => 'Export';
+
+  @override
+  String get queueExportFailedSuccess =>
+      'Failed downloads exported to TXT file';
+
+  @override
+  String get queueExportFailedClear => 'Clear Failed';
+
+  @override
+  String get queueExportFailedError => 'Failed to export downloads';
+
+  @override
+  String get settingsAutoExportFailed => 'Auto-export failed downloads';
+
+  @override
+  String get settingsAutoExportFailedSubtitle =>
+      'Save failed downloads to TXT file automatically';
+
+  @override
+  String get settingsDownloadNetwork => 'Download Network';
+
+  @override
+  String get settingsDownloadNetworkAny => 'WiFi + Mobile Data';
+
+  @override
+  String get settingsDownloadNetworkWifiOnly => 'WiFi Only';
+
+  @override
+  String get settingsDownloadNetworkSubtitle =>
+      'Choose which network to use for downloads. When set to WiFi Only, downloads will pause on mobile data.';
+
  @override
  String get queueEmpty => 'No downloads in queue';

@@ -2006,6 +2106,13 @@ class AppLocalizationsNl extends AppLocalizations {
  @override
  String get albumFolderYearAlbumSubtitle => 'Albums/[2005] Album Name/';

+  @override
+  String get albumFolderArtistAlbumSingles => 'Artist / Album + Singles';
+
+  @override
+  String get albumFolderArtistAlbumSinglesSubtitle =>
+      'Artist/Album/ and Artist/Singles/';
+
  @override
  String get downloadedAlbumDeleteSelected => 'Delete Selected';

@@ -2073,6 +2180,12 @@ class AppLocalizationsNl extends AppLocalizations {
  @override
  String get recentTypePlaylist => 'Playlist';

+  @override
+  String get recentEmpty => 'No recent items yet';
+
+  @override
+  String get recentShowAllDownloads => 'Show All Downloads';
+
  @override
  String recentPlaylistInfo(String name) {
    return 'Playlist: $name';
@@ -2148,4 +2261,632 @@ class AppLocalizationsNl extends AppLocalizations {

  @override
  String get discographyFailedToFetch => 'Failed to fetch some albums';
+
+  @override
+  String get sectionStorageAccess => 'Storage Access';
+
+  @override
+  String get allFilesAccess => 'All Files Access';
+
+  @override
+  String get allFilesAccessEnabledSubtitle => 'Can write to any folder';
+
+  @override
+  String get allFilesAccessDisabledSubtitle => 'Limited to media folders only';
+
+  @override
+  String get allFilesAccessDescription =>
+      'Enable this if you encounter write errors when saving to custom folders. Android 13+ restricts access to certain directories by default.';
+
+  @override
+  String get allFilesAccessDeniedMessage =>
+      'Permission was denied. Please enable \'All files access\' manually in system settings.';
+
+  @override
+  String get allFilesAccessDisabledMessage =>
+      'All Files Access disabled. The app will use limited storage access.';
+
+  @override
+  String get settingsLocalLibrary => 'Local Library';
+
+  @override
+  String get settingsLocalLibrarySubtitle => 'Scan music & detect duplicates';
+
+  @override
+  String get settingsCache => 'Storage & Cache';
+
+  @override
+  String get settingsCacheSubtitle => 'View size and clear cached data';
+
+  @override
+  String get libraryTitle => 'Local Library';
+
+  @override
+  String get libraryStatus => 'Library Status';
+
+  @override
+  String get libraryScanSettings => 'Scan Settings';
+
+  @override
+  String get libraryEnableLocalLibrary => 'Enable Local Library';
+
+  @override
+  String get libraryEnableLocalLibrarySubtitle =>
+      'Scan and track your existing music';
+
+  @override
+  String get libraryFolder => 'Library Folder';
+
+  @override
+  String get libraryFolderHint => 'Tap to select folder';
+
+  @override
+  String get libraryShowDuplicateIndicator => 'Show Duplicate Indicator';
+
+  @override
+  String get libraryShowDuplicateIndicatorSubtitle =>
+      'Show when searching for existing tracks';
+
+  @override
+  String get libraryActions => 'Actions';
+
+  @override
+  String get libraryScan => 'Scan Library';
+
+  @override
+  String get libraryScanSubtitle => 'Scan for audio files';
+
+  @override
+  String get libraryScanSelectFolderFirst => 'Select a folder first';
+
+  @override
+  String get libraryCleanupMissingFiles => 'Cleanup Missing Files';
+
+  @override
+  String get libraryCleanupMissingFilesSubtitle =>
+      'Remove entries for files that no longer exist';
+
+  @override
+  String get libraryClear => 'Clear Library';
+
+  @override
+  String get libraryClearSubtitle => 'Remove all scanned tracks';
+
+  @override
+  String get libraryClearConfirmTitle => 'Clear Library';
+
+  @override
+  String get libraryClearConfirmMessage =>
+      'This will remove all scanned tracks from your library. Your actual music files will not be deleted.';
+
+  @override
+  String get libraryAbout => 'About Local Library';
+
+  @override
+  String get libraryAboutDescription =>
+      'Scans your existing music collection to detect duplicates when downloading. Supports FLAC, M4A, MP3, Opus, and OGG formats. Metadata is read from file tags when available.';
+
+  @override
+  String libraryTracksCount(int count) {
+    return '$count tracks';
+  }
+
+  @override
+  String libraryLastScanned(String time) {
+    return 'Last scanned: $time';
+  }
+
+  @override
+  String get libraryLastScannedNever => 'Never';
+
+  @override
+  String get libraryScanning => 'Scanning...';
+
+  @override
+  String libraryScanProgress(String progress, int total) {
+    return '$progress% of $total files';
+  }
+
+  @override
+  String get libraryInLibrary => 'In Library';
+
+  @override
+  String libraryRemovedMissingFiles(int count) {
+    return 'Removed $count missing files from library';
+  }
+
+  @override
+  String get libraryCleared => 'Library cleared';
+
+  @override
+  String get libraryStorageAccessRequired => 'Storage Access Required';
+
+  @override
+  String get libraryStorageAccessMessage =>
+      'SpotiFLAC needs storage access to scan your music library. Please grant permission in settings.';
+
+  @override
+  String get libraryFolderNotExist => 'Selected folder does not exist';
+
+  @override
+  String get librarySourceDownloaded => 'Downloaded';
+
+  @override
+  String get librarySourceLocal => 'Local';
+
+  @override
+  String get libraryFilterAll => 'All';
+
+  @override
+  String get libraryFilterDownloaded => 'Downloaded';
+
+  @override
+  String get libraryFilterLocal => 'Local';
+
+  @override
+  String get libraryFilterTitle => 'Filters';
+
+  @override
+  String get libraryFilterReset => 'Reset';
+
+  @override
+  String get libraryFilterApply => 'Apply';
+
+  @override
+  String get libraryFilterSource => 'Source';
+
+  @override
+  String get libraryFilterQuality => 'Quality';
+
+  @override
+  String get libraryFilterQualityHiRes => 'Hi-Res (24bit)';
+
+  @override
+  String get libraryFilterQualityCD => 'CD (16bit)';
+
+  @override
+  String get libraryFilterQualityLossy => 'Lossy';
+
+  @override
+  String get libraryFilterFormat => 'Format';
+
+  @override
+  String get libraryFilterDate => 'Date Added';
+
+  @override
+  String get libraryFilterDateToday => 'Today';
+
+  @override
+  String get libraryFilterDateWeek => 'This Week';
+
+  @override
+  String get libraryFilterDateMonth => 'This Month';
+
+  @override
+  String get libraryFilterDateYear => 'This Year';
+
+  @override
+  String get libraryFilterSort => 'Sort';
+
+  @override
+  String get libraryFilterSortLatest => 'Latest';
+
+  @override
+  String get libraryFilterSortOldest => 'Oldest';
+
+  @override
+  String libraryFilterActive(int count) {
+    return '$count filter(s) active';
+  }
+
+  @override
+  String get timeJustNow => 'Just now';
+
+  @override
+  String timeMinutesAgo(int count) {
+    String _temp0 = intl.Intl.pluralLogic(
+      count,
+      locale: localeName,
+      other: '$count minutes ago',
+      one: '1 minute ago',
+    );
+    return '$_temp0';
+  }
+
+  @override
+  String timeHoursAgo(int count) {
+    String _temp0 = intl.Intl.pluralLogic(
+      count,
+      locale: localeName,
+      other: '$count hours ago',
+      one: '1 hour ago',
+    );
+    return '$_temp0';
+  }
+
+  @override
+  String get storageSwitchTitle => 'Switch Storage Mode';
+
+  @override
+  String get storageSwitchToSafTitle => 'Switch to SAF Storage?';
+
+  @override
+  String get storageSwitchToAppTitle => 'Switch to App Storage?';
+
+  @override
+  String get storageSwitchToSafMessage =>
+      'Your existing downloads will remain in the current location and stay accessible.\n\nNew downloads will be saved to your selected SAF folder.';
+
+  @override
+  String get storageSwitchToAppMessage =>
+      'Your existing downloads will remain in the current SAF location and stay accessible.\n\nNew downloads will be saved to Music/SpotiFLAC folder.';
+
+  @override
+  String get storageSwitchExistingDownloads => 'Existing Downloads';
+
+  @override
+  String storageSwitchExistingDownloadsInfo(int count, String mode) {
+    return '$count tracks in $mode storage';
+  }
+
+  @override
+  String get storageSwitchNewDownloads => 'New Downloads';
+
+  @override
+  String storageSwitchNewDownloadsLocation(String location) {
+    return 'Will be saved to: $location';
+  }
+
+  @override
+  String get storageSwitchContinue => 'Continue';
+
+  @override
+  String get storageSwitchSelectFolder => 'Select SAF Folder';
+
+  @override
+  String get storageAppStorage => 'App Storage';
+
+  @override
+  String get storageSafStorage => 'SAF Storage';
+
+  @override
+  String storageModeBadge(String mode) {
+    return 'Storage: $mode';
+  }
+
+  @override
+  String get storageStatsTitle => 'Storage Statistics';
+
+  @override
+  String storageStatsAppCount(int count) {
+    return '$count tracks in App Storage';
+  }
+
+  @override
+  String storageStatsSafCount(int count) {
+    return '$count tracks in SAF Storage';
+  }
+
+  @override
+  String get storageModeInfo => 'Your files are stored in multiple locations';
+
+  @override
+  String get tutorialWelcomeTitle => 'Welcome to SpotiFLAC!';
+
+  @override
+  String get tutorialWelcomeDesc =>
+      'Let\'s learn how to download your favorite music in lossless quality. This quick tutorial will show you the basics.';
+
+  @override
+  String get tutorialWelcomeTip1 =>
+      'Download music from Spotify, Deezer, or paste any supported URL';
+
+  @override
+  String get tutorialWelcomeTip2 =>
+      'Get FLAC quality audio from Tidal, Qobuz, or Amazon Music';
+
+  @override
+  String get tutorialWelcomeTip3 =>
+      'Automatic metadata, cover art, and lyrics embedding';
+
+  @override
+  String get tutorialSearchTitle => 'Finding Music';
+
+  @override
+  String get tutorialSearchDesc =>
+      'There are two easy ways to find music you want to download.';
+
+  @override
+  String get tutorialSearchTip1 =>
+      'Paste a Spotify or Deezer URL directly in the search box';
+
+  @override
+  String get tutorialSearchTip2 =>
+      'Or type the song name, artist, or album to search';
+
+  @override
+  String get tutorialSearchTip3 =>
+      'Supports tracks, albums, playlists, and artist pages';
+
+  @override
+  String get tutorialDownloadTitle => 'Downloading Music';
+
+  @override
+  String get tutorialDownloadDesc =>
+      'Downloading music is simple and fast. Here\'s how it works.';
+
+  @override
+  String get tutorialDownloadTip1 =>
+      'Tap the download button next to any track to start downloading';
+
+  @override
+  String get tutorialDownloadTip2 =>
+      'Choose your preferred quality (FLAC, Hi-Res, or MP3)';
+
+  @override
+  String get tutorialDownloadTip3 =>
+      'Download entire albums or playlists with one tap';
+
+  @override
+  String get tutorialLibraryTitle => 'Your Library';
+
+  @override
+  String get tutorialLibraryDesc =>
+      'All your downloaded music is organized in the Library tab.';
+
+  @override
+  String get tutorialLibraryTip1 =>
+      'View download progress and queue in the Library tab';
+
+  @override
+  String get tutorialLibraryTip2 =>
+      'Tap any track to play it with your music player';
+
+  @override
+  String get tutorialLibraryTip3 =>
+      'Switch between list and grid view for better browsing';
+
+  @override
+  String get tutorialExtensionsTitle => 'Extensions';
+
+  @override
+  String get tutorialExtensionsDesc =>
+      'Extend the app\'s capabilities with community extensions.';
+
+  @override
+  String get tutorialExtensionsTip1 =>
+      'Browse the Store tab to discover useful extensions';
+
+  @override
+  String get tutorialExtensionsTip2 =>
+      'Add new download providers or search sources';
+
+  @override
+  String get tutorialExtensionsTip3 =>
+      'Get lyrics, enhanced metadata, and more features';
+
+  @override
+  String get tutorialSettingsTitle => 'Customize Your Experience';
+
+  @override
+  String get tutorialSettingsDesc =>
+      'Personalize the app in Settings to match your preferences.';
+
+  @override
+  String get tutorialSettingsTip1 =>
+      'Change download location and folder organization';
+
+  @override
+  String get tutorialSettingsTip2 =>
+      'Set default audio quality and format preferences';
+
+  @override
+  String get tutorialSettingsTip3 => 'Customize app theme and appearance';
+
+  @override
+  String get tutorialReadyMessage =>
+      'You\'re all set! Start downloading your favorite music now.';
+
+  @override
+  String get tutorialExample => 'EXAMPLE';
+
+  @override
+  String get libraryForceFullScan => 'Force Full Scan';
+
+  @override
+  String get libraryForceFullScanSubtitle => 'Rescan all files, ignoring cache';
+
+  @override
+  String get cleanupOrphanedDownloads => 'Cleanup Orphaned Downloads';
+
+  @override
+  String get cleanupOrphanedDownloadsSubtitle =>
+      'Remove history entries for files that no longer exist';
+
+  @override
+  String cleanupOrphanedDownloadsResult(int count) {
+    return 'Removed $count orphaned entries from history';
+  }
+
+  @override
+  String get cleanupOrphanedDownloadsNone => 'No orphaned entries found';
+
+  @override
+  String get cacheTitle => 'Storage & Cache';
+
+  @override
+  String get cacheSummaryTitle => 'Cache overview';
+
+  @override
+  String get cacheSummarySubtitle =>
+      'Clearing cache will not remove downloaded music files.';
+
+  @override
+  String cacheEstimatedTotal(String size) {
+    return 'Estimated cache usage: $size';
+  }
+
+  @override
+  String get cacheSectionStorage => 'Cached Data';
+
+  @override
+  String get cacheSectionMaintenance => 'Maintenance';
+
+  @override
+  String get cacheAppDirectory => 'App cache directory';
+
+  @override
+  String get cacheAppDirectoryDesc =>
+      'HTTP responses, WebView data, and other temporary app data.';
+
+  @override
+  String get cacheTempDirectory => 'Temporary directory';
+
+  @override
+  String get cacheTempDirectoryDesc =>
+      'Temporary files from downloads and audio conversion.';
+
+  @override
+  String get cacheCoverImage => 'Cover image cache';
+
+  @override
+  String get cacheCoverImageDesc =>
+      'Downloaded album and track cover art. Will re-download when viewed.';
+
+  @override
+  String get cacheLibraryCover => 'Library cover cache';
+
+  @override
+  String get cacheLibraryCoverDesc =>
+      'Cover art extracted from local music files. Will re-extract on next scan.';
+
+  @override
+  String get cacheExploreFeed => 'Explore feed cache';
+
+  @override
+  String get cacheExploreFeedDesc =>
+      'Explore tab content (new releases, trending). Will refresh on next visit.';
+
+  @override
+  String get cacheTrackLookup => 'Track lookup cache';
+
+  @override
+  String get cacheTrackLookupDesc =>
+      'Spotify/Deezer track ID lookups. Clearing may slow next few searches.';
+
+  @override
+  String get cacheCleanupUnusedDesc =>
+      'Remove orphaned download history and library entries for missing files.';
+
+  @override
+  String get cacheNoData => 'No cached data';
+
+  @override
+  String cacheSizeWithFiles(String size, int count) {
+    return '$size in $count files';
+  }
+
+  @override
+  String cacheSizeOnly(String size) {
+    return '$size';
+  }
+
+  @override
+  String cacheEntries(int count) {
+    return '$count entries';
+  }
+
+  @override
+  String cacheClearSuccess(String target) {
+    return 'Cleared: $target';
+  }
+
+  @override
+  String get cacheClearConfirmTitle => 'Clear cache?';
+
+  @override
+  String cacheClearConfirmMessage(String target) {
+    return 'This will clear cached data for $target. Downloaded music files will not be deleted.';
+  }
+
+  @override
+  String get cacheClearAllConfirmTitle => 'Clear all cache?';
+
+  @override
+  String get cacheClearAllConfirmMessage =>
+      'This will clear all cache categories on this page. Downloaded music files will not be deleted.';
+
+  @override
+  String get cacheClearAll => 'Clear all cache';
+
+  @override
+  String get cacheCleanupUnused => 'Cleanup unused data';
+
+  @override
+  String get cacheCleanupUnusedSubtitle =>
+      'Remove orphaned download history and missing library entries';
+
+  @override
+  String cacheCleanupResult(int downloadCount, int libraryCount) {
+    return 'Cleanup completed: $downloadCount orphaned downloads, $libraryCount missing library entries';
+  }
+
+  @override
+  String get cacheRefreshStats => 'Refresh stats';
+
+  @override
+  String get trackSaveCoverArt => 'Save Cover Art';
+
+  @override
+  String get trackSaveCoverArtSubtitle => 'Save album art as .jpg file';
+
+  @override
+  String get trackSaveLyrics => 'Save Lyrics (.lrc)';
+
+  @override
+  String get trackSaveLyricsSubtitle => 'Fetch and save lyrics as .lrc file';
+
+  @override
+  String get trackReEnrich => 'Re-enrich Metadata';
+
+  @override
+  String get trackReEnrichSubtitle =>
+      'Re-embed metadata without re-downloading';
+
+  @override
+  String get trackReEnrichOnlineSubtitle =>
+      'Search metadata online and embed into file';
+
+  @override
+  String get trackEditMetadata => 'Edit Metadata';
+
+  @override
+  String trackCoverSaved(String fileName) {
+    return 'Cover art saved to $fileName';
+  }
+
+  @override
+  String get trackCoverNoSource => 'No cover art source available';
+
+  @override
+  String trackLyricsSaved(String fileName) {
+    return 'Lyrics saved to $fileName';
+  }
+
+  @override
+  String get trackReEnrichProgress => 'Re-enriching metadata...';
+
+  @override
+  String get trackReEnrichSearching => 'Searching metadata online...';
+
+  @override
+  String get trackReEnrichSuccess => 'Metadata re-enriched successfully';
+
+  @override
+  String get trackReEnrichFfmpegFailed => 'FFmpeg metadata embed failed';
+
+  @override
+  String trackSaveFailed(String error) {
+    return 'Failed: $error';
+  }
 }
@@ -127,6 +127,10 @@
  "@historyNoSinglesSubtitle": {
    "description": "Empty state subtitle for singles filter"
  },
+  "historySearchHint": "Suchverlauf...",
+  "@historySearchHint": {
+    "description": "Search bar placeholder in history"
+  },
  "settingsTitle": "Einstellungen",
  "@settingsTitle": {
    "description": "Settings screen title"
@@ -512,6 +516,10 @@
  "@aboutLogoArtist": {
    "description": "Role description for logo artist"
  },
+  "aboutTranslators": "Übersetzer",
+  "@aboutTranslators": {
+    "description": "Section for translators"
+  },
  "aboutSpecialThanks": "Besonderer Dank",
  "@aboutSpecialThanks": {
    "description": "Section for special thanks"
@@ -544,6 +552,26 @@
  "@aboutFeatureRequestSubtitle": {
    "description": "Subtitle for feature request"
  },
+  "aboutTelegramChannel": "Telegram Kanal",
+  "@aboutTelegramChannel": {
+    "description": "Link to Telegram channel"
+  },
+  "aboutTelegramChannelSubtitle": "Ankündigungen und Updates",
+  "@aboutTelegramChannelSubtitle": {
+    "description": "Subtitle for Telegram channel"
+  },
+  "aboutTelegramChat": "Telegram Community",
+  "@aboutTelegramChat": {
+    "description": "Link to Telegram chat group"
+  },
+  "aboutTelegramChatSubtitle": "Mit anderen Nutzern chatten",
+  "@aboutTelegramChatSubtitle": {
+    "description": "Subtitle for Telegram chat"
+  },
+  "aboutSocial": "Sozial",
+  "@aboutSocial": {
+    "description": "Section for social links"
+  },
  "aboutSupport": "Support",
  "@aboutSupport": {
    "description": "Section for support/donation links"
@@ -588,7 +616,7 @@
  "@aboutDabMusicDesc": {
    "description": "Credit for DAB Music API"
  },
-  "aboutAppDescription": "Download Spotify tracks in lossless quality from Tidal, Qobuz, and Amazon Music.",
+  "aboutAppDescription": "Lade Spotify-Titel in verlustfreier Qualität von Tidal, Qobuz und Amazon Music herunter.",
  "@aboutAppDescription": {
    "description": "App description in header card"
  },
@@ -596,7 +624,7 @@
  "@albumTitle": {
    "description": "Album screen title"
  },
-  "albumTracks": "{count, plural, =1{1 track} other{{count} tracks}}",
+  "albumTracks": "{count, plural,=1{1 Song} other{{count} Songs}}",
  "@albumTracks": {
    "description": "Album track count",
    "placeholders": {
@@ -605,11 +633,11 @@
      }
    }
  },
-  "albumDownloadAll": "Download All",
+  "albumDownloadAll": "Alle Herunterladen",
  "@albumDownloadAll": {
    "description": "Button to download all tracks"
  },
-  "albumDownloadRemaining": "Download Remaining",
+  "albumDownloadRemaining": "Downloads verbleibend",
  "@albumDownloadRemaining": {
    "description": "Button to download remaining tracks"
  },
@@ -617,11 +645,11 @@
  "@playlistTitle": {
    "description": "Playlist screen title"
  },
-  "artistTitle": "Artist",
+  "artistTitle": "Künstler",
  "@artistTitle": {
    "description": "Artist screen title"
  },
-  "artistAlbums": "Albums",
+  "artistAlbums": "Alben",
  "@artistAlbums": {
    "description": "Section header for artist albums"
  },
@@ -629,11 +657,11 @@
  "@artistSingles": {
    "description": "Section header for singles/EPs"
  },
-  "artistCompilations": "Compilations",
+  "artistCompilations": "Zusammenstellungen",
  "@artistCompilations": {
    "description": "Section header for compilations"
  },
-  "artistReleases": "{count, plural, =1{1 release} other{{count} releases}}",
+  "artistReleases": "{count, plural,=1{1 Veröffentlichung} other{{count} Veröffentlichungen}}",
  "@artistReleases": {
    "description": "Artist release count",
    "placeholders": {
@@ -642,11 +670,11 @@
      }
    }
  },
-  "artistPopular": "Popular",
+  "artistPopular": "Beliebt",
  "@artistPopular": {
    "description": "Section header for popular/top tracks"
  },
-  "artistMonthlyListeners": "{count} monthly listeners",
+  "artistMonthlyListeners": "{count} monatliche Hörer",
  "@artistMonthlyListeners": {
    "description": "Monthly listener count display",
    "placeholders": {
@@ -656,11 +684,11 @@
      }
    }
  },
-  "trackMetadataTitle": "Track Info",
+  "trackMetadataTitle": "Titel Info",
  "@trackMetadataTitle": {
    "description": "Track metadata screen title"
  },
-  "trackMetadataArtist": "Artist",
+  "trackMetadataArtist": "Künstler",
  "@trackMetadataArtist": {
    "description": "Metadata field - artist name"
  },
@@ -668,111 +696,111 @@
  "@trackMetadataAlbum": {
    "description": "Metadata field - album name"
  },
-  "trackMetadataDuration": "Duration",
+  "trackMetadataDuration": "Länge",
  "@trackMetadataDuration": {
    "description": "Metadata field - track length"
  },
-  "trackMetadataQuality": "Quality",
+  "trackMetadataQuality": "Qualität",
  "@trackMetadataQuality": {
    "description": "Metadata field - audio quality"
  },
-  "trackMetadataPath": "File Path",
+  "trackMetadataPath": "Dateipfad",
  "@trackMetadataPath": {
    "description": "Metadata field - file location"
  },
-  "trackMetadataDownloadedAt": "Downloaded",
+  "trackMetadataDownloadedAt": "Heruntergeladen",
  "@trackMetadataDownloadedAt": {
    "description": "Metadata field - download date"
  },
-  "trackMetadataService": "Service",
+  "trackMetadataService": "Anbieter",
  "@trackMetadataService": {
    "description": "Metadata field - download service used"
  },
-  "trackMetadataPlay": "Play",
+  "trackMetadataPlay": "Abspielen",
  "@trackMetadataPlay": {
    "description": "Action button - play track"
  },
-  "trackMetadataShare": "Share",
+  "trackMetadataShare": "Teilen",
  "@trackMetadataShare": {
    "description": "Action button - share track"
  },
-  "trackMetadataDelete": "Delete",
+  "trackMetadataDelete": "Löschen",
  "@trackMetadataDelete": {
    "description": "Action button - delete track"
  },
-  "trackMetadataRedownload": "Re-download",
+  "trackMetadataRedownload": "Erneut herunterladen",
  "@trackMetadataRedownload": {
    "description": "Action button - download again"
  },
-  "trackMetadataOpenFolder": "Open Folder",
+  "trackMetadataOpenFolder": "Ordner öffnen",
  "@trackMetadataOpenFolder": {
    "description": "Action button - open containing folder"
  },
-  "setupTitle": "Welcome to SpotiFLAC",
+  "setupTitle": "Willkommen bei SpotiFLAC",
  "@setupTitle": {
    "description": "Setup wizard title"
  },
-  "setupSubtitle": "Let's get you started",
+  "setupSubtitle": "Los geht's",
  "@setupSubtitle": {
    "description": "Setup wizard subtitle"
  },
-  "setupStoragePermission": "Storage Permission",
+  "setupStoragePermission": "Speicherberechtigung",
  "@setupStoragePermission": {
    "description": "Storage permission step title"
  },
-  "setupStoragePermissionSubtitle": "Required to save downloaded files",
+  "setupStoragePermissionSubtitle": "Benötigt um heruntergeladene Dateien zu Speichern",
  "@setupStoragePermissionSubtitle": {
    "description": "Explanation for storage permission"
  },
-  "setupStoragePermissionGranted": "Permission granted",
+  "setupStoragePermissionGranted": "Berechtigung erteilt",
  "@setupStoragePermissionGranted": {
    "description": "Status when permission granted"
  },
-  "setupStoragePermissionDenied": "Permission denied",
+  "setupStoragePermissionDenied": "Berechtigung verweigert",
  "@setupStoragePermissionDenied": {
    "description": "Status when permission denied"
  },
-  "setupGrantPermission": "Grant Permission",
+  "setupGrantPermission": "Berechtigung erlauben",
  "@setupGrantPermission": {
    "description": "Button to request permission"
  },
-  "setupDownloadLocation": "Download Location",
+  "setupDownloadLocation": "Speicherort",
  "@setupDownloadLocation": {
    "description": "Download folder step title"
  },
-  "setupChooseFolder": "Choose Folder",
+  "setupChooseFolder": "Ordner wählen",
  "@setupChooseFolder": {
    "description": "Button to pick folder"
  },
-  "setupContinue": "Continue",
+  "setupContinue": "Fortfahren",
  "@setupContinue": {
    "description": "Continue to next step button"
  },
-  "setupSkip": "Skip for now",
+  "setupSkip": "Vorerst überspringen",
  "@setupSkip": {
    "description": "Skip current step button"
  },
-  "setupStorageAccessRequired": "Storage Access Required",
+  "setupStorageAccessRequired": "Speicherzugriff erforderlich",
  "@setupStorageAccessRequired": {
    "description": "Title when storage access needed"
  },
-  "setupStorageAccessMessage": "SpotiFLAC needs \"All files access\" permission to save music files to your chosen folder.",
+  "setupStorageAccessMessage": "SpotiFLAC benötigt die Berechtigung \"Auf alle Dateien zugreifen\", um Musikdateien in deinen gewählten Ordner zu speichern.",
  "@setupStorageAccessMessage": {
    "description": "Explanation for storage access"
  },
-  "setupStorageAccessMessageAndroid11": "Android 11+ requires \"All files access\" permission to save files to your chosen download folder.",
+  "setupStorageAccessMessageAndroid11": "Android 11+ benötigt die Berechtigung „Auf alle Dateien“, um Dateien im ausgewählten Download-Ordner zu speichern.",
  "@setupStorageAccessMessageAndroid11": {
    "description": "Android 11+ specific explanation"
  },
-  "setupOpenSettings": "Open Settings",
+  "setupOpenSettings": "Einstellungen öffnen",
  "@setupOpenSettings": {
    "description": "Button to open system settings"
  },
-  "setupPermissionDeniedMessage": "Permission denied. Please grant all permissions to continue.",
+  "setupPermissionDeniedMessage": "Berechtigung verweigert. Bitte erteilen Sie alle Berechtigungen um fortzufahren.",
  "@setupPermissionDeniedMessage": {
    "description": "Error when permission denied"
  },
-  "setupPermissionRequired": "{permissionType} Permission Required",
+  "setupPermissionRequired": "{permissionType} Zugriff verweigert",
  "@setupPermissionRequired": {
    "description": "Generic permission required title",
    "placeholders": {
@@ -782,7 +810,7 @@
      }
    }
  },
-  "setupPermissionRequiredMessage": "{permissionType} permission is required for the best experience. You can change this later in Settings.",
+  "setupPermissionRequiredMessage": "{permissionType} Berechtigung ist erforderlich für\ndie beste Benutzererfahrung. Für kannst dies später in den Einstellungen ändern.",
  "@setupPermissionRequiredMessage": {
    "description": "Generic permission required message",
    "placeholders": {
@@ -791,63 +819,63 @@
      }
    }
  },
-  "setupSelectDownloadFolder": "Select Download Folder",
+  "setupSelectDownloadFolder": "Wähle Download-Ordner aus",
  "@setupSelectDownloadFolder": {
    "description": "Folder selection step title"
  },
-  "setupUseDefaultFolder": "Use Default Folder?",
+  "setupUseDefaultFolder": "Als Standardordner verwenden?",
  "@setupUseDefaultFolder": {
    "description": "Dialog title for default folder"
  },
-  "setupNoFolderSelected": "No folder selected. Would you like to use the default Music folder?",
+  "setupNoFolderSelected": "Kein Ordner ausgewählt. Soll der Standard-Musikordner verwendet werden?",
  "@setupNoFolderSelected": {
    "description": "Prompt when no folder selected"
  },
-  "setupUseDefault": "Use Default",
+  "setupUseDefault": "Standart benutzen",
  "@setupUseDefault": {
    "description": "Button to use default folder"
  },
-  "setupDownloadLocationTitle": "Download Location",
+  "setupDownloadLocationTitle": "Speicherort",
  "@setupDownloadLocationTitle": {
    "description": "Download location dialog title"
  },
-  "setupDownloadLocationIosMessage": "On iOS, downloads are saved to the app's Documents folder. You can access them via the Files app.",
+  "setupDownloadLocationIosMessage": "Auf iOS werden Downloads im Dokumentenverzeichnis der App gespeichert. Sie können sie über die Datei-App aufrufen.",
  "@setupDownloadLocationIosMessage": {
    "description": "iOS-specific folder info"
  },
-  "setupAppDocumentsFolder": "App Documents Folder",
+  "setupAppDocumentsFolder": "App-Dokumentenordner",
  "@setupAppDocumentsFolder": {
    "description": "iOS documents folder option"
  },
-  "setupAppDocumentsFolderSubtitle": "Recommended - accessible via Files app",
+  "setupAppDocumentsFolderSubtitle": "Empfohlen - zugänglich über die Datei-App",
  "@setupAppDocumentsFolderSubtitle": {
    "description": "Subtitle for documents folder"
  },
-  "setupChooseFromFiles": "Choose from Files",
+  "setupChooseFromFiles": "Aus Dateien auswählen",
  "@setupChooseFromFiles": {
    "description": "iOS file picker option"
  },
-  "setupChooseFromFilesSubtitle": "Select iCloud or other location",
+  "setupChooseFromFilesSubtitle": "Wählen Sie iCloud oder einen anderen Ort",
  "@setupChooseFromFilesSubtitle": {
    "description": "Subtitle for file picker"
  },
-  "setupIosEmptyFolderWarning": "iOS limitation: Empty folders cannot be selected. Choose a folder with at least one file.",
+  "setupIosEmptyFolderWarning": "iOS-Einschränkung: Leere Ordner können nicht ausgewählt werden. Wählen Sie einen Ordner mit mindestens einer Datei.",
  "@setupIosEmptyFolderWarning": {
    "description": "iOS folder selection warning"
  },
-  "setupDownloadInFlac": "Download Spotify tracks in FLAC",
+  "setupDownloadInFlac": "Spotify Titel in FLAC herunterladen",
  "@setupDownloadInFlac": {
    "description": "App tagline in setup"
  },
-  "setupStepStorage": "Storage",
+  "setupStepStorage": "Speicherort",
  "@setupStepStorage": {
    "description": "Setup step indicator - storage"
  },
-  "setupStepNotification": "Notification",
+  "setupStepNotification": "Benachrichtigung",
  "@setupStepNotification": {
    "description": "Setup step indicator - notification"
  },
-  "setupStepFolder": "Folder",
+  "setupStepFolder": "Ordner",
  "@setupStepFolder": {
    "description": "Setup step indicator - folder"
  },
@@ -855,55 +883,55 @@
  "@setupStepSpotify": {
    "description": "Setup step indicator - Spotify API"
  },
-  "setupStepPermission": "Permission",
+  "setupStepPermission": "Berechtigung",
  "@setupStepPermission": {
    "description": "Setup step indicator - permission"
  },
-  "setupStorageGranted": "Storage Permission Granted!",
+  "setupStorageGranted": "Speicherberechtigung erlaubt!",
  "@setupStorageGranted": {
    "description": "Success message for storage permission"
  },
-  "setupStorageRequired": "Storage Permission Required",
+  "setupStorageRequired": "Speicherzugriff erforderlich",
  "@setupStorageRequired": {
    "description": "Title when storage permission needed"
  },
-  "setupStorageDescription": "SpotiFLAC needs storage permission to save your downloaded music files.",
+  "setupStorageDescription": "SpotiFLAC benötigt Speicherrechte, um die heruntergeladenen Musikdateien zu speichern.",
  "@setupStorageDescription": {
    "description": "Explanation for storage permission"
  },
-  "setupNotificationGranted": "Notification Permission Granted!",
+  "setupNotificationGranted": "Benachrichtigungs-Berechtigung erteilt",
  "@setupNotificationGranted": {
    "description": "Success message for notification permission"
  },
-  "setupNotificationEnable": "Enable Notifications",
+  "setupNotificationEnable": "Benachrichtigungen aktivieren",
  "@setupNotificationEnable": {
    "description": "Button to enable notifications"
  },
-  "setupNotificationDescription": "Get notified when downloads complete or require attention.",
+  "setupNotificationDescription": "Benachrichtigt werden, wenn Downloads abgeschlossen sind.",
  "@setupNotificationDescription": {
    "description": "Explanation for notifications"
  },
-  "setupFolderSelected": "Download Folder Selected!",
+  "setupFolderSelected": "Download Ordner ausgewählt!",
  "@setupFolderSelected": {
    "description": "Success message for folder selection"
  },
-  "setupFolderChoose": "Choose Download Folder",
+  "setupFolderChoose": "Speicherort auwählen",
  "@setupFolderChoose": {
    "description": "Button to choose folder"
  },
-  "setupFolderDescription": "Select a folder where your downloaded music will be saved.",
+  "setupFolderDescription": "Wählen Sie einen Ordner, in dem Ihre heruntergeladene Musik gespeichert wird.",
  "@setupFolderDescription": {
    "description": "Explanation for folder selection"
  },
-  "setupChangeFolder": "Change Folder",
+  "setupChangeFolder": "Ordner ändern",
  "@setupChangeFolder": {
    "description": "Button to change selected folder"
  },
-  "setupSelectFolder": "Select Folder",
+  "setupSelectFolder": "Ordner wählen",
  "@setupSelectFolder": {
    "description": "Button to select folder"
  },
-  "setupSpotifyApiOptional": "Spotify API (Optional)",
+  "setupSpotifyApiOptional": "Spotify-API (optional)",
  "@setupSpotifyApiOptional": {
    "description": "Spotify API step title"
  },
@@ -1122,6 +1150,15 @@
    "description": "Dialog title - import CSV playlist"
  },
  "dialogImportPlaylistMessage": "Found {count} tracks in CSV. Add them to download queue?",
+  "csvImportTracks": "{count} tracks from CSV",
+  "@csvImportTracks": {
+    "description": "Label shown in quality picker for CSV import",
+    "placeholders": {
+      "count": {
+        "type": "int"
+      }
+    }
+  },
  "@dialogImportPlaylistMessage": {
    "description": "Dialog message - import playlist confirmation",
    "placeholders": {
@@ -1851,6 +1888,42 @@
  "@sectionFileSettings": {
    "description": "Settings section header"
  },
+  "sectionLyrics": "Lyrics",
+  "@sectionLyrics": {
+    "description": "Settings section header"
+  },
+  "lyricsMode": "Lyrics Mode",
+  "@lyricsMode": {
+    "description": "Setting - how to save lyrics"
+  },
+  "lyricsModeDescription": "Choose how lyrics are saved with your downloads",
+  "@lyricsModeDescription": {
+    "description": "Lyrics mode picker description"
+  },
+  "lyricsModeEmbed": "Embed in file",
+  "@lyricsModeEmbed": {
+    "description": "Lyrics mode option - embed in audio file"
+  },
+  "lyricsModeEmbedSubtitle": "Lyrics stored inside FLAC metadata",
+  "@lyricsModeEmbedSubtitle": {
+    "description": "Subtitle for embed option"
+  },
+  "lyricsModeExternal": "External .lrc file",
+  "@lyricsModeExternal": {
+    "description": "Lyrics mode option - separate LRC file"
+  },
+  "lyricsModeExternalSubtitle": "Separate .lrc file for players like Samsung Music",
+  "@lyricsModeExternalSubtitle": {
+    "description": "Subtitle for external option"
+  },
+  "lyricsModeBoth": "Both",
+  "@lyricsModeBoth": {
+    "description": "Lyrics mode option - embed and external"
+  },
+  "lyricsModeBothSubtitle": "Embed and save .lrc file",
+  "@lyricsModeBothSubtitle": {
+    "description": "Subtitle for both option"
+  },
  "sectionColor": "Color",
  "@sectionColor": {
    "description": "Settings section header"
@@ -1997,6 +2070,18 @@
  "@trackReleaseDate": {
    "description": "Metadata label - release date"
  },
+  "trackGenre": "Genre",
+  "@trackGenre": {
+    "description": "Metadata label - music genre"
+  },
+  "trackLabel": "Label",
+  "@trackLabel": {
+    "description": "Metadata label - record label"
+  },
+  "trackCopyright": "Copyright",
+  "@trackCopyright": {
+    "description": "Metadata label - copyright information"
+  },
  "trackDownloaded": "Downloaded",
  "@trackDownloaded": {
    "description": "Metadata label - download date"
@@ -2017,6 +2102,18 @@
  "@trackLyricsLoadFailed": {
    "description": "Message when lyrics loading fails"
  },
+  "trackEmbedLyrics": "Embed Lyrics",
+  "@trackEmbedLyrics": {
+    "description": "Action - embed lyrics into audio file"
+  },
+  "trackLyricsEmbedded": "Lyrics embedded successfully",
+  "@trackLyricsEmbedded": {
+    "description": "Snackbar - lyrics saved to file"
+  },
+  "trackInstrumental": "Instrumental track",
+  "@trackInstrumental": {
+    "description": "Message when track is instrumental (no lyrics)"
+  },
  "trackCopiedToClipboard": "Copied to clipboard",
  "@trackCopiedToClipboard": {
    "description": "Snackbar - content copied"
@@ -2328,6 +2425,26 @@
  "@qualityHiResFlacMaxSubtitle": {
    "description": "Technical spec for hi-res max"
  },
+  "qualityMp3": "MP3",
+  "@qualityMp3": {
+    "description": "Quality option - MP3 lossy format"
+  },
+  "qualityMp3Subtitle": "320kbps (converted from FLAC)",
+  "@qualityMp3Subtitle": {
+    "description": "Technical spec for MP3"
+  },
+  "enableMp3Option": "Enable MP3 Option",
+  "@enableMp3Option": {
+    "description": "Setting - enable MP3 quality option"
+  },
+  "enableMp3OptionSubtitleOn": "MP3 quality option is available",
+  "@enableMp3OptionSubtitleOn": {
+    "description": "Subtitle when MP3 is enabled"
+  },
+  "enableMp3OptionSubtitleOff": "Downloads FLAC then converts to 320kbps MP3",
+  "@enableMp3OptionSubtitleOff": {
+    "description": "Subtitle when MP3 is disabled"
+  },
  "qualityNote": "Actual quality depends on track availability from the service",
  "@qualityNote": {
    "description": "Note about quality availability"
@@ -2516,6 +2633,14 @@
  "@albumFolderYearAlbumSubtitle": {
    "description": "Folder structure example"
  },
+  "albumFolderArtistAlbumSingles": "Artist / Album + Singles",
+  "@albumFolderArtistAlbumSingles": {
+    "description": "Album folder option with singles inside artist"
+  },
+  "albumFolderArtistAlbumSinglesSubtitle": "Artist/Album/ and Artist/Singles/",
+  "@albumFolderArtistAlbumSinglesSubtitle": {
+    "description": "Folder structure example"
+  },
  "downloadedAlbumDeleteSelected": "Delete Selected",
  "@downloadedAlbumDeleteSelected": {
    "description": "Button - delete selected tracks"
@@ -2572,6 +2697,16 @@
  "@downloadedAlbumSelectToDelete": {
    "description": "Placeholder when nothing selected"
  },
+  "downloadedAlbumDiscHeader": "Disc {discNumber}",
+  "@downloadedAlbumDiscHeader": {
+    "description": "Header for disc separator in multi-disc albums",
+    "placeholders": {
+      "discNumber": {
+        "type": "int",
+        "example": "1"
+      }
+    }
+  },
  "utilityFunctions": "Utility Functions",
  "@utilityFunctions": {
    "description": "Extension capability - utility functions"
@@ -2611,5 +2746,123 @@
        "description": "Error message"
      }
    }
+  },
+  "discographyDownload": "Download Discography",
+  "@discographyDownload": {
+    "description": "Button - download artist discography"
+  },
+  "discographyDownloadAll": "Download All",
+  "@discographyDownloadAll": {
+    "description": "Option - download entire discography"
+  },
+  "discographyDownloadAllSubtitle": "{count} tracks from {albumCount} releases",
+  "@discographyDownloadAllSubtitle": {
+    "description": "Subtitle showing total tracks and albums",
+    "placeholders": {
+      "count": {
+        "type": "int"
+      },
+      "albumCount": {
+        "type": "int"
+      }
+    }
+  },
+  "discographyAlbumsOnly": "Albums Only",
+  "@discographyAlbumsOnly": {
+    "description": "Option - download only albums"
+  },
+  "discographyAlbumsOnlySubtitle": "{count} tracks from {albumCount} albums",
+  "@discographyAlbumsOnlySubtitle": {
+    "description": "Subtitle showing album tracks count",
+    "placeholders": {
+      "count": {
+        "type": "int"
+      },
+      "albumCount": {
+        "type": "int"
+      }
+    }
+  },
+  "discographySinglesOnly": "Singles & EPs Only",
+  "@discographySinglesOnly": {
+    "description": "Option - download only singles"
+  },
+  "discographySinglesOnlySubtitle": "{count} tracks from {albumCount} singles",
+  "@discographySinglesOnlySubtitle": {
+    "description": "Subtitle showing singles tracks count",
+    "placeholders": {
+      "count": {
+        "type": "int"
+      },
+      "albumCount": {
+        "type": "int"
+      }
+    }
+  },
+  "discographySelectAlbums": "Select Albums...",
+  "@discographySelectAlbums": {
+    "description": "Option - manually select albums to download"
+  },
+  "discographySelectAlbumsSubtitle": "Choose specific albums or singles",
+  "@discographySelectAlbumsSubtitle": {
+    "description": "Subtitle for select albums option"
+  },
+  "discographyFetchingTracks": "Fetching tracks...",
+  "@discographyFetchingTracks": {
+    "description": "Progress - fetching album tracks"
+  },
+  "discographyFetchingAlbum": "Fetching {current} of {total}...",
+  "@discographyFetchingAlbum": {
+    "description": "Progress - fetching specific album",
+    "placeholders": {
+      "current": {
+        "type": "int"
+      },
+      "total": {
+        "type": "int"
+      }
+    }
+  },
+  "discographySelectedCount": "{count} selected",
+  "@discographySelectedCount": {
+    "description": "Selection count badge",
+    "placeholders": {
+      "count": {
+        "type": "int"
+      }
+    }
+  },
+  "discographyDownloadSelected": "Download Selected",
+  "@discographyDownloadSelected": {
+    "description": "Button - download selected albums"
+  },
+  "discographyAddedToQueue": "Added {count} tracks to queue",
+  "@discographyAddedToQueue": {
+    "description": "Snackbar - tracks added from discography",
+    "placeholders": {
+      "count": {
+        "type": "int"
+      }
+    }
+  },
+  "discographySkippedDownloaded": "{added} added, {skipped} already downloaded",
+  "@discographySkippedDownloaded": {
+    "description": "Snackbar - with skipped tracks count",
+    "placeholders": {
+      "added": {
+        "type": "int"
+      },
+      "skipped": {
+        "type": "int"
+      }
+    }
+  },
+  "discographyNoAlbums": "No albums available",
+  "@discographyNoAlbums": {
+    "description": "Error - no albums found for artist"
+  },
+  "discographyFailedToFetch": "Failed to fetch some albums",
+  "@discographyFailedToFetch": {
+    "description": "Error - some albums failed to load"
  }
 }
@@ -9,8 +9,10 @@

  "navHome": "Home",
  "@navHome": {"description": "Bottom navigation - Home tab"},
+  "navLibrary": "Library",
+  "@navLibrary": {"description": "Bottom navigation - Library tab"},
  "navHistory": "History",
-  "@navHistory": {"description": "Bottom navigation - History tab"},
+  "@navHistory": {"description": "Bottom navigation - History tab (legacy)"},
  "navSettings": "Settings",
  "@navSettings": {"description": "Bottom navigation - Settings tab"},
  "navStore": "Store",
@@ -239,6 +241,8 @@
  "@optionsSpotifyCredentialsRequired": {"description": "Prompt to set up credentials"},
  "optionsSpotifyWarning": "Spotify requires your own API credentials. Get them free from developer.spotify.com",
  "@optionsSpotifyWarning": {"description": "Info about Spotify API requirement"},
+  "optionsSpotifyDeprecationWarning": "Spotify search will be deprecated on March 3, 2026 due to Spotify API changes. Please switch to Deezer.",
+  "@optionsSpotifyDeprecationWarning": {"description": "Warning about Spotify API deprecation"},

  "extensionsTitle": "Extensions",
  "@extensionsTitle": {"description": "Extensions page title"},
@@ -334,6 +338,8 @@
  "@aboutBinimumDesc": {"description": "Credit description for binimum"},
  "aboutSachinsenalDesc": "The original HiFi project creator. The foundation of Tidal integration!",
  "@aboutSachinsenalDesc": {"description": "Credit description for sachinsenal0x64"},
+  "aboutSjdonadoDesc": "Creator of I Don't Have Spotify (IDHS). The fallback link resolver that saves the day!",
+  "@aboutSjdonadoDesc": {"description": "Credit description for sjdonado"},
  "aboutDoubleDouble": "DoubleDouble",
  "@aboutDoubleDouble": {"description": "Name of Amazon API service - DO NOT TRANSLATE"},
  "aboutDoubleDoubleDesc": "Amazing API for Amazon Music downloads. Thank you for making it free!",
@@ -342,6 +348,10 @@
  "@aboutDabMusic": {"description": "Name of Qobuz API service - DO NOT TRANSLATE"},
  "aboutDabMusicDesc": "The best Qobuz streaming API. Hi-Res downloads wouldn't be possible without this!",
  "@aboutDabMusicDesc": {"description": "Credit for DAB Music API"},
+  "aboutSpotiSaver": "SpotiSaver",
+  "@aboutSpotiSaver": {"description": "Name of SpotiSaver API service - DO NOT TRANSLATE"},
+  "aboutSpotiSaverDesc": "Tidal Hi-Res FLAC streaming endpoints. A key piece of the lossless puzzle!",
+  "@aboutSpotiSaverDesc": {"description": "Credit for SpotiSaver API"},
  "aboutAppDescription": "Download Spotify tracks in lossless quality from Tidal, Qobuz, and Amazon Music.",
  "@aboutAppDescription": {"description": "App description in header card"},

@@ -479,8 +489,10 @@
  "@setupChooseFromFiles": {"description": "iOS file picker option"},
  "setupChooseFromFilesSubtitle": "Select iCloud or other location",
  "@setupChooseFromFilesSubtitle": {"description": "Subtitle for file picker"},
-  "setupIosEmptyFolderWarning": "iOS limitation: Empty folders cannot be selected. Choose a folder with at least one file.",
+"setupIosEmptyFolderWarning": "iOS limitation: Empty folders cannot be selected. Choose a folder with at least one file.",
  "@setupIosEmptyFolderWarning": {"description": "iOS folder selection warning"},
+  "setupIcloudNotSupported": "iCloud Drive is not supported. Please use the app Documents folder.",
+  "@setupIcloudNotSupported": {"description": "Error when user selects iCloud Drive on iOS"},
  "setupDownloadInFlac": "Download Spotify tracks in FLAC",
  "@setupDownloadInFlac": {"description": "App tagline in setup"},
  "setupStepStorage": "Storage",
@@ -666,6 +678,13 @@
      "trackName": {"type": "String"}
    }
  },
+  "snackbarAlreadyInLibrary": "\"{trackName}\" already exists in your library",
+  "@snackbarAlreadyInLibrary": {
+    "description": "Snackbar - track already exists in local library",
+    "placeholders": {
+      "trackName": {"type": "String"}
+    }
+  },
  "snackbarHistoryCleared": "History cleared",
  "@snackbarHistoryCleared": {"description": "Snackbar - history deleted"},
  "snackbarCredentialsSaved": "Credentials saved",
@@ -1188,6 +1207,12 @@
  "@trackLyricsTimeout": {"description": "Message when lyrics request times out"},
  "trackLyricsLoadFailed": "Failed to load lyrics",
  "@trackLyricsLoadFailed": {"description": "Message when lyrics loading fails"},
+  "trackEmbedLyrics": "Embed Lyrics",
+  "@trackEmbedLyrics": {"description": "Action - embed lyrics into audio file"},
+  "trackLyricsEmbedded": "Lyrics embedded successfully",
+  "@trackLyricsEmbedded": {"description": "Snackbar - lyrics saved to file"},
+  "trackInstrumental": "Instrumental track",
+  "@trackInstrumental": {"description": "Message when track is instrumental (no lyrics)"},
  "trackCopiedToClipboard": "Copied to clipboard",
  "@trackCopiedToClipboard": {"description": "Snackbar - content copied"},
  "trackDeleteConfirmTitle": "Remove from device?",
@@ -1367,18 +1392,30 @@
  "@qualityHiResFlacMax": {"description": "Quality option - maximum resolution FLAC"},
  "qualityHiResFlacMaxSubtitle": "24-bit / up to 192kHz",
  "@qualityHiResFlacMaxSubtitle": {"description": "Technical spec for hi-res max"},
-  "qualityMp3": "MP3",
-  "@qualityMp3": {"description": "Quality option - MP3 lossy format"},
-  "qualityMp3Subtitle": "320kbps (converted from FLAC)",
-  "@qualityMp3Subtitle": {"description": "Technical spec for MP3"},
-  "enableMp3Option": "Enable MP3 Option",
-  "@enableMp3Option": {"description": "Setting - enable MP3 quality option"},
-  "enableMp3OptionSubtitleOn": "MP3 quality option is available",
-  "@enableMp3OptionSubtitleOn": {"description": "Subtitle when MP3 is enabled"},
-  "enableMp3OptionSubtitleOff": "Downloads FLAC then converts to 320kbps MP3",
-  "@enableMp3OptionSubtitleOff": {"description": "Subtitle when MP3 is disabled"},
+  "qualityLossy": "Lossy",
+  "@qualityLossy": {"description": "Quality option - lossy format (MP3/Opus)"},
+  "qualityLossyMp3Subtitle": "MP3 320kbps (converted from FLAC)",
+  "@qualityLossyMp3Subtitle": {"description": "Technical spec for lossy MP3"},
+  "qualityLossyOpusSubtitle": "Opus 128kbps (converted from FLAC)",
+  "@qualityLossyOpusSubtitle": {"description": "Technical spec for lossy Opus"},
+  "enableLossyOption": "Enable Lossy Option",
+  "@enableLossyOption": {"description": "Setting - enable lossy quality option"},
+  "enableLossyOptionSubtitleOn": "Lossy quality option is available",
+  "@enableLossyOptionSubtitleOn": {"description": "Subtitle when lossy is enabled"},
+  "enableLossyOptionSubtitleOff": "Downloads FLAC then converts to lossy format",
+  "@enableLossyOptionSubtitleOff": {"description": "Subtitle when lossy is disabled"},
+  "lossyFormat": "Lossy Format",
+  "@lossyFormat": {"description": "Setting - choose lossy format"},
+  "lossyFormatDescription": "Choose the lossy format for conversion",
+  "@lossyFormatDescription": {"description": "Description for lossy format picker"},
+  "lossyFormatMp3Subtitle": "320kbps, best compatibility",
+  "@lossyFormatMp3Subtitle": {"description": "MP3 format description"},
+  "lossyFormatOpusSubtitle": "128kbps, better quality at smaller size",
+  "@lossyFormatOpusSubtitle": {"description": "Opus format description"},
  "qualityNote": "Actual quality depends on track availability from the service",
  "@qualityNote": {"description": "Note about quality availability"},
+  "youtubeQualityNote": "YouTube provides lossy audio only. Not part of lossless fallback.",
+  "@youtubeQualityNote": {"description": "Note for YouTube service explaining lossy-only quality"},

  "downloadAskBeforeDownload": "Ask Before Download",
  "@downloadAskBeforeDownload": {"description": "Setting - show quality picker"},
@@ -1388,6 +1425,12 @@
  "@downloadSeparateSinglesFolder": {"description": "Setting - separate folder for singles"},
  "downloadAlbumFolderStructure": "Album Folder Structure",
  "@downloadAlbumFolderStructure": {"description": "Setting - album folder organization"},
+  "downloadUseAlbumArtistForFolders": "Use Album Artist for folders",
+  "@downloadUseAlbumArtistForFolders": {"description": "Setting - choose whether artist folders use Album Artist or Track Artist"},
+  "downloadUseAlbumArtistForFoldersAlbumSubtitle": "Artist folders use Album Artist when available",
+  "@downloadUseAlbumArtistForFoldersAlbumSubtitle": {"description": "Subtitle when Album Artist is used for folder naming"},
+  "downloadUseAlbumArtistForFoldersTrackSubtitle": "Artist folders use Track Artist only",
+  "@downloadUseAlbumArtistForFoldersTrackSubtitle": {"description": "Subtitle when Track Artist is used for folder naming"},
  "downloadSaveFormat": "Save Format",
  "@downloadSaveFormat": {"description": "Setting - output file format"},
  "downloadSelectService": "Select Service",
@@ -1440,10 +1483,32 @@

  "queueTitle": "Download Queue",
  "@queueTitle": {"description": "Queue screen title"},
-  "queueClearAll": "Clear All",
+"queueClearAll": "Clear All",
  "@queueClearAll": {"description": "Button - clear all queue items"},
  "queueClearAllMessage": "Are you sure you want to clear all downloads?",
  "@queueClearAllMessage": {"description": "Clear queue confirmation"},
+  "queueExportFailed": "Export",
+  "@queueExportFailed": {"description": "Button - export failed downloads to TXT"},
+  "queueExportFailedSuccess": "Failed downloads exported to TXT file",
+  "@queueExportFailedSuccess": {"description": "Success message after exporting failed downloads"},
+  "queueExportFailedClear": "Clear Failed",
+  "@queueExportFailedClear": {"description": "Action to clear failed downloads after export"},
+  "queueExportFailedError": "Failed to export downloads",
+  "@queueExportFailedError": {"description": "Error message when export fails"},
+  "settingsAutoExportFailed": "Auto-export failed downloads",
+  "@settingsAutoExportFailed": {"description": "Setting toggle for auto-export"},
+  "settingsAutoExportFailedSubtitle": "Save failed downloads to TXT file automatically",
+  "@settingsAutoExportFailedSubtitle": {"description": "Subtitle for auto-export setting"},
+
+  "settingsDownloadNetwork": "Download Network",
+  "@settingsDownloadNetwork": {"description": "Setting for network type preference"},
+  "settingsDownloadNetworkAny": "WiFi + Mobile Data",
+  "@settingsDownloadNetworkAny": {"description": "Network option - use any connection"},
+  "settingsDownloadNetworkWifiOnly": "WiFi Only",
+  "@settingsDownloadNetworkWifiOnly": {"description": "Network option - only use WiFi"},
+  "settingsDownloadNetworkSubtitle": "Choose which network to use for downloads. When set to WiFi Only, downloads will pause on mobile data.",
+  "@settingsDownloadNetworkSubtitle": {"description": "Subtitle explaining network preference"},
+
  "queueEmpty": "No downloads in queue",
  "@queueEmpty": {"description": "Empty queue state title"},
  "queueEmptySubtitle": "Add tracks from the home screen",
@@ -1477,6 +1542,10 @@
  "@albumFolderYearAlbum": {"description": "Album folder option with year"},
  "albumFolderYearAlbumSubtitle": "Albums/[2005] Album Name/",
  "@albumFolderYearAlbumSubtitle": {"description": "Folder structure example"},
+  "albumFolderArtistAlbumSingles": "Artist / Album + Singles",
+  "@albumFolderArtistAlbumSingles": {"description": "Album folder option with singles inside artist"},
+  "albumFolderArtistAlbumSinglesSubtitle": "Artist/Album/ and Artist/Singles/",
+  "@albumFolderArtistAlbumSinglesSubtitle": {"description": "Folder structure example"},

  "downloadedAlbumDeleteSelected": "Delete Selected",
  "@downloadedAlbumDeleteSelected": {"description": "Button - delete selected tracks"},
@@ -1535,6 +1604,12 @@
  "@recentTypeSong": {"description": "Recent access item type - song/track"},
  "recentTypePlaylist": "Playlist",
  "@recentTypePlaylist": {"description": "Recent access item type - playlist"},
+  "recentEmpty": "No recent items yet",
+  "@recentEmpty": {"description": "Empty state text for recent access list"},
+  "recentShowAllDownloads": "Show All Downloads",
+  "@recentShowAllDownloads": {
+    "description": "Button label to unhide hidden downloads in recent access"
+  },

  "recentPlaylistInfo": "Playlist: {name}",
  "@recentPlaylistInfo": {
@@ -1624,5 +1699,488 @@
  "discographyNoAlbums": "No albums available",
  "@discographyNoAlbums": {"description": "Error - no albums found for artist"},
  "discographyFailedToFetch": "Failed to fetch some albums",
-  "@discographyFailedToFetch": {"description": "Error - some albums failed to load"}
+  "@discographyFailedToFetch": {"description": "Error - some albums failed to load"},
+
+  "sectionStorageAccess": "Storage Access",
+  "@sectionStorageAccess": {"description": "Section header for storage access settings"},
+  "allFilesAccess": "All Files Access",
+  "@allFilesAccess": {"description": "Toggle for MANAGE_EXTERNAL_STORAGE permission"},
+  "allFilesAccessEnabledSubtitle": "Can write to any folder",
+  "@allFilesAccessEnabledSubtitle": {"description": "Subtitle when all files access is enabled"},
+  "allFilesAccessDisabledSubtitle": "Limited to media folders only",
+  "@allFilesAccessDisabledSubtitle": {"description": "Subtitle when all files access is disabled"},
+  "allFilesAccessDescription": "Enable this if you encounter write errors when saving to custom folders. Android 13+ restricts access to certain directories by default.",
+  "@allFilesAccessDescription": {"description": "Description explaining when to enable all files access"},
+  "allFilesAccessDeniedMessage": "Permission was denied. Please enable 'All files access' manually in system settings.",
+  "@allFilesAccessDeniedMessage": {"description": "Message when permission is permanently denied"},
+  "allFilesAccessDisabledMessage": "All Files Access disabled. The app will use limited storage access.",
+  "@allFilesAccessDisabledMessage": {"description": "Snackbar message when user disables all files access"},
+
+  "settingsLocalLibrary": "Local Library",
+  "@settingsLocalLibrary": {"description": "Settings menu item - local library"},
+  "settingsLocalLibrarySubtitle": "Scan music & detect duplicates",
+  "@settingsLocalLibrarySubtitle": {"description": "Subtitle for local library settings"},
+  "settingsCache": "Storage & Cache",
+  "@settingsCache": {"description": "Settings menu item - cache management"},
+  "settingsCacheSubtitle": "View size and clear cached data",
+  "@settingsCacheSubtitle": {"description": "Subtitle for cache management menu"},
+  "libraryTitle": "Local Library",
+  "@libraryTitle": {"description": "Library settings page title"},
+  "libraryStatus": "Library Status",
+  "@libraryStatus": {"description": "Section header for library status"},
+  "libraryScanSettings": "Scan Settings",
+  "@libraryScanSettings": {"description": "Section header for scan settings"},
+  "libraryEnableLocalLibrary": "Enable Local Library",
+  "@libraryEnableLocalLibrary": {"description": "Toggle to enable library scanning"},
+  "libraryEnableLocalLibrarySubtitle": "Scan and track your existing music",
+  "@libraryEnableLocalLibrarySubtitle": {"description": "Subtitle for enable toggle"},
+  "libraryFolder": "Library Folder",
+  "@libraryFolder": {"description": "Folder selection setting"},
+  "libraryFolderHint": "Tap to select folder",
+  "@libraryFolderHint": {"description": "Placeholder when no folder selected"},
+  "libraryShowDuplicateIndicator": "Show Duplicate Indicator",
+  "@libraryShowDuplicateIndicator": {"description": "Toggle for duplicate indicator in search"},
+  "libraryShowDuplicateIndicatorSubtitle": "Show when searching for existing tracks",
+  "@libraryShowDuplicateIndicatorSubtitle": {"description": "Subtitle for duplicate indicator toggle"},
+  "libraryActions": "Actions",
+  "@libraryActions": {"description": "Section header for library actions"},
+  "libraryScan": "Scan Library",
+  "@libraryScan": {"description": "Button to start library scan"},
+  "libraryScanSubtitle": "Scan for audio files",
+  "@libraryScanSubtitle": {"description": "Subtitle for scan button"},
+  "libraryScanSelectFolderFirst": "Select a folder first",
+  "@libraryScanSelectFolderFirst": {"description": "Message when trying to scan without folder"},
+  "libraryCleanupMissingFiles": "Cleanup Missing Files",
+  "@libraryCleanupMissingFiles": {"description": "Button to remove entries for missing files"},
+  "libraryCleanupMissingFilesSubtitle": "Remove entries for files that no longer exist",
+  "@libraryCleanupMissingFilesSubtitle": {"description": "Subtitle for cleanup button"},
+  "libraryClear": "Clear Library",
+  "@libraryClear": {"description": "Button to clear all library entries"},
+  "libraryClearSubtitle": "Remove all scanned tracks",
+  "@libraryClearSubtitle": {"description": "Subtitle for clear button"},
+  "libraryClearConfirmTitle": "Clear Library",
+  "@libraryClearConfirmTitle": {"description": "Dialog title for clear confirmation"},
+  "libraryClearConfirmMessage": "This will remove all scanned tracks from your library. Your actual music files will not be deleted.",
+  "@libraryClearConfirmMessage": {"description": "Dialog message for clear confirmation"},
+  "libraryAbout": "About Local Library",
+  "@libraryAbout": {"description": "Section header for about info"},
+  "libraryAboutDescription": "Scans your existing music collection to detect duplicates when downloading. Supports FLAC, M4A, MP3, Opus, and OGG formats. Metadata is read from file tags when available.",
+  "@libraryAboutDescription": {"description": "Description of local library feature"},
+  "libraryTracksCount": "{count} tracks",
+  "@libraryTracksCount": {
+    "description": "Track count in library",
+    "placeholders": {
+      "count": {"type": "int"}
+    }
+  },
+  "libraryLastScanned": "Last scanned: {time}",
+  "@libraryLastScanned": {
+    "description": "Last scan time display",
+    "placeholders": {
+      "time": {"type": "String"}
+    }
+  },
+  "libraryLastScannedNever": "Never",
+  "@libraryLastScannedNever": {"description": "Shown when library has never been scanned"},
+  "libraryScanning": "Scanning...",
+  "@libraryScanning": {"description": "Status during scan"},
+  "libraryScanProgress": "{progress}% of {total} files",
+  "@libraryScanProgress": {
+    "description": "Scan progress display",
+    "placeholders": {
+      "progress": {"type": "String"},
+      "total": {"type": "int"}
+    }
+  },
+  "libraryInLibrary": "In Library",
+  "@libraryInLibrary": {"description": "Badge shown on tracks that exist in local library"},
+  "libraryRemovedMissingFiles": "Removed {count} missing files from library",
+  "@libraryRemovedMissingFiles": {
+    "description": "Snackbar after cleanup",
+    "placeholders": {
+      "count": {"type": "int"}
+    }
+  },
+  "libraryCleared": "Library cleared",
+  "@libraryCleared": {"description": "Snackbar after clearing library"},
+  "libraryStorageAccessRequired": "Storage Access Required",
+  "@libraryStorageAccessRequired": {"description": "Dialog title for storage permission"},
+  "libraryStorageAccessMessage": "SpotiFLAC needs storage access to scan your music library. Please grant permission in settings.",
+  "@libraryStorageAccessMessage": {"description": "Dialog message for storage permission"},
+  "libraryFolderNotExist": "Selected folder does not exist",
+  "@libraryFolderNotExist": {"description": "Error when folder doesn't exist"},
+  "librarySourceDownloaded": "Downloaded",
+  "@librarySourceDownloaded": {"description": "Badge for tracks downloaded via SpotiFLAC"},
+  "librarySourceLocal": "Local",
+  "@librarySourceLocal": {"description": "Badge for tracks from local library scan"},
+  "libraryFilterAll": "All",
+  "@libraryFilterAll": {"description": "Filter chip - show all library items"},
+  "libraryFilterDownloaded": "Downloaded",
+  "@libraryFilterDownloaded": {"description": "Filter chip - show only downloaded items"},
+  "libraryFilterLocal": "Local",
+  "@libraryFilterLocal": {"description": "Filter chip - show only local library items"},
+
+  "libraryFilterTitle": "Filters",
+  "@libraryFilterTitle": {"description": "Filter bottom sheet title"},
+  "libraryFilterReset": "Reset",
+  "@libraryFilterReset": {"description": "Reset all filters button"},
+  "libraryFilterApply": "Apply",
+  "@libraryFilterApply": {"description": "Apply filters button"},
+  "libraryFilterSource": "Source",
+  "@libraryFilterSource": {"description": "Filter section - source type"},
+  "libraryFilterQuality": "Quality",
+  "@libraryFilterQuality": {"description": "Filter section - audio quality"},
+  "libraryFilterQualityHiRes": "Hi-Res (24bit)",
+  "@libraryFilterQualityHiRes": {"description": "Filter option - high resolution audio"},
+  "libraryFilterQualityCD": "CD (16bit)",
+  "@libraryFilterQualityCD": {"description": "Filter option - CD quality audio"},
+  "libraryFilterQualityLossy": "Lossy",
+  "@libraryFilterQualityLossy": {"description": "Filter option - lossy compressed audio"},
+  "libraryFilterFormat": "Format",
+  "@libraryFilterFormat": {"description": "Filter section - file format"},
+  "libraryFilterDate": "Date Added",
+  "@libraryFilterDate": {"description": "Filter section - date range"},
+  "libraryFilterDateToday": "Today",
+  "@libraryFilterDateToday": {"description": "Filter option - today only"},
+  "libraryFilterDateWeek": "This Week",
+  "@libraryFilterDateWeek": {"description": "Filter option - this week"},
+  "libraryFilterDateMonth": "This Month",
+  "@libraryFilterDateMonth": {"description": "Filter option - this month"},
+  "libraryFilterDateYear": "This Year",
+  "@libraryFilterDateYear": {"description": "Filter option - this year"},
+  "libraryFilterSort": "Sort",
+  "@libraryFilterSort": {"description": "Filter section - sort order"},
+  "libraryFilterSortLatest": "Latest",
+  "@libraryFilterSortLatest": {"description": "Sort option - newest first"},
+  "libraryFilterSortOldest": "Oldest",
+  "@libraryFilterSortOldest": {"description": "Sort option - oldest first"},
+  "libraryFilterActive": "{count} filter(s) active",
+  "@libraryFilterActive": {
+    "description": "Badge showing number of active filters",
+    "placeholders": {
+      "count": {"type": "int"}
+    }
+  },
+
+  "timeJustNow": "Just now",
+  "@timeJustNow": {"description": "Relative time - less than a minute ago"},
+  "timeMinutesAgo": "{count, plural, =1{1 minute ago} other{{count} minutes ago}}",
+  "@timeMinutesAgo": {
+    "description": "Relative time - minutes ago",
+    "placeholders": {
+      "count": {"type": "int"}
+    }
+  },
+  "timeHoursAgo": "{count, plural, =1{1 hour ago} other{{count} hours ago}}",
+  "@timeHoursAgo": {
+    "description": "Relative time - hours ago",
+    "placeholders": {
+      "count": {"type": "int"}
+    }
+  },
+
+  "storageSwitchTitle": "Switch Storage Mode",
+  "@storageSwitchTitle": {"description": "Dialog title when switching storage mode"},
+  "storageSwitchToSafTitle": "Switch to SAF Storage?",
+  "@storageSwitchToSafTitle": {"description": "Dialog title when switching to SAF"},
+  "storageSwitchToAppTitle": "Switch to App Storage?",
+  "@storageSwitchToAppTitle": {"description": "Dialog title when switching to app storage"},
+  "storageSwitchToSafMessage": "Your existing downloads will remain in the current location and stay accessible.\n\nNew downloads will be saved to your selected SAF folder.",
+  "@storageSwitchToSafMessage": {"description": "Explanation when switching to SAF"},
+  "storageSwitchToAppMessage": "Your existing downloads will remain in the current SAF location and stay accessible.\n\nNew downloads will be saved to Music/SpotiFLAC folder.",
+  "@storageSwitchToAppMessage": {"description": "Explanation when switching to app storage"},
+  "storageSwitchExistingDownloads": "Existing Downloads",
+  "@storageSwitchExistingDownloads": {"description": "Section header for existing downloads info"},
+  "storageSwitchExistingDownloadsInfo": "{count} tracks in {mode} storage",
+  "@storageSwitchExistingDownloadsInfo": {
+    "description": "Info about existing downloads count",
+    "placeholders": {
+      "count": {"type": "int"},
+      "mode": {"type": "String"}
+    }
+  },
+  "storageSwitchNewDownloads": "New Downloads",
+  "@storageSwitchNewDownloads": {"description": "Section header for new downloads info"},
+  "storageSwitchNewDownloadsLocation": "Will be saved to: {location}",
+  "@storageSwitchNewDownloadsLocation": {
+    "description": "Shows where new downloads will go",
+    "placeholders": {
+      "location": {"type": "String"}
+    }
+  },
+  "storageSwitchContinue": "Continue",
+  "@storageSwitchContinue": {"description": "Button to proceed with storage switch"},
+  "storageSwitchSelectFolder": "Select SAF Folder",
+  "@storageSwitchSelectFolder": {"description": "Button to select SAF folder"},
+  "storageAppStorage": "App Storage",
+  "@storageAppStorage": {"description": "Label for app storage mode"},
+  "storageSafStorage": "SAF Storage",
+  "@storageSafStorage": {"description": "Label for SAF storage mode"},
+  "storageModeBadge": "Storage: {mode}",
+  "@storageModeBadge": {
+    "description": "Badge showing storage mode for a track",
+    "placeholders": {
+      "mode": {"type": "String"}
+    }
+  },
+  "storageStatsTitle": "Storage Statistics",
+  "@storageStatsTitle": {"description": "Section title for storage stats"},
+  "storageStatsAppCount": "{count} tracks in App Storage",
+  "@storageStatsAppCount": {
+    "description": "Count of tracks in app storage",
+    "placeholders": {
+      "count": {"type": "int"}
+    }
+  },
+  "storageStatsSafCount": "{count} tracks in SAF Storage",
+  "@storageStatsSafCount": {
+    "description": "Count of tracks in SAF storage",
+    "placeholders": {
+      "count": {"type": "int"}
+    }
+  },
+  "storageModeInfo": "Your files are stored in multiple locations",
+  "@storageModeInfo": {"description": "Info when user has files in both storage modes"},
+
+  "tutorialWelcomeTitle": "Welcome to SpotiFLAC!",
+  "@tutorialWelcomeTitle": {"description": "Tutorial welcome page title"},
+  "tutorialWelcomeDesc": "Let's learn how to download your favorite music in lossless quality. This quick tutorial will show you the basics.",
+  "@tutorialWelcomeDesc": {"description": "Tutorial welcome page description"},
+  "tutorialWelcomeTip1": "Download music from Spotify, Deezer, or paste any supported URL",
+  "@tutorialWelcomeTip1": {"description": "Tutorial welcome tip 1"},
+  "tutorialWelcomeTip2": "Get FLAC quality audio from Tidal, Qobuz, or Amazon Music",
+  "@tutorialWelcomeTip2": {"description": "Tutorial welcome tip 2"},
+  "tutorialWelcomeTip3": "Automatic metadata, cover art, and lyrics embedding",
+  "@tutorialWelcomeTip3": {"description": "Tutorial welcome tip 3"},
+
+  "tutorialSearchTitle": "Finding Music",
+  "@tutorialSearchTitle": {"description": "Tutorial search page title"},
+  "tutorialSearchDesc": "There are two easy ways to find music you want to download.",
+  "@tutorialSearchDesc": {"description": "Tutorial search page description"},
+  "tutorialSearchTip1": "Paste a Spotify or Deezer URL directly in the search box",
+  "@tutorialSearchTip1": {"description": "Tutorial search tip 1"},
+  "tutorialSearchTip2": "Or type the song name, artist, or album to search",
+  "@tutorialSearchTip2": {"description": "Tutorial search tip 2"},
+  "tutorialSearchTip3": "Supports tracks, albums, playlists, and artist pages",
+  "@tutorialSearchTip3": {"description": "Tutorial search tip 3"},
+
+  "tutorialDownloadTitle": "Downloading Music",
+  "@tutorialDownloadTitle": {"description": "Tutorial download page title"},
+  "tutorialDownloadDesc": "Downloading music is simple and fast. Here's how it works.",
+  "@tutorialDownloadDesc": {"description": "Tutorial download page description"},
+  "tutorialDownloadTip1": "Tap the download button next to any track to start downloading",
+  "@tutorialDownloadTip1": {"description": "Tutorial download tip 1"},
+  "tutorialDownloadTip2": "Choose your preferred quality (FLAC, Hi-Res, or MP3)",
+  "@tutorialDownloadTip2": {"description": "Tutorial download tip 2"},
+  "tutorialDownloadTip3": "Download entire albums or playlists with one tap",
+  "@tutorialDownloadTip3": {"description": "Tutorial download tip 3"},
+
+  "tutorialLibraryTitle": "Your Library",
+  "@tutorialLibraryTitle": {"description": "Tutorial library page title"},
+  "tutorialLibraryDesc": "All your downloaded music is organized in the Library tab.",
+  "@tutorialLibraryDesc": {"description": "Tutorial library page description"},
+  "tutorialLibraryTip1": "View download progress and queue in the Library tab",
+  "@tutorialLibraryTip1": {"description": "Tutorial library tip 1"},
+  "tutorialLibraryTip2": "Tap any track to play it with your music player",
+  "@tutorialLibraryTip2": {"description": "Tutorial library tip 2"},
+  "tutorialLibraryTip3": "Switch between list and grid view for better browsing",
+  "@tutorialLibraryTip3": {"description": "Tutorial library tip 3"},
+
+  "tutorialExtensionsTitle": "Extensions",
+  "@tutorialExtensionsTitle": {"description": "Tutorial extensions page title"},
+  "tutorialExtensionsDesc": "Extend the app's capabilities with community extensions.",
+  "@tutorialExtensionsDesc": {"description": "Tutorial extensions page description"},
+  "tutorialExtensionsTip1": "Browse the Store tab to discover useful extensions",
+  "@tutorialExtensionsTip1": {"description": "Tutorial extensions tip 1"},
+  "tutorialExtensionsTip2": "Add new download providers or search sources",
+  "@tutorialExtensionsTip2": {"description": "Tutorial extensions tip 2"},
+  "tutorialExtensionsTip3": "Get lyrics, enhanced metadata, and more features",
+  "@tutorialExtensionsTip3": {"description": "Tutorial extensions tip 3"},
+
+  "tutorialSettingsTitle": "Customize Your Experience",
+  "@tutorialSettingsTitle": {"description": "Tutorial settings page title"},
+  "tutorialSettingsDesc": "Personalize the app in Settings to match your preferences.",
+  "@tutorialSettingsDesc": {"description": "Tutorial settings page description"},
+  "tutorialSettingsTip1": "Change download location and folder organization",
+  "@tutorialSettingsTip1": {"description": "Tutorial settings tip 1"},
+  "tutorialSettingsTip2": "Set default audio quality and format preferences",
+  "@tutorialSettingsTip2": {"description": "Tutorial settings tip 2"},
+  "tutorialSettingsTip3": "Customize app theme and appearance",
+  "@tutorialSettingsTip3": {"description": "Tutorial settings tip 3"},
+
+  "tutorialReadyMessage": "You're all set! Start downloading your favorite music now.",
+  "@tutorialReadyMessage": {"description": "Tutorial completion message"},
+  "tutorialExample": "EXAMPLE",
+  "@tutorialExample": {"description": "Example label in tutorial"},
+
+  "libraryForceFullScan": "Force Full Scan",
+  "@libraryForceFullScan": {"description": "Button to force a complete rescan of library"},
+  "libraryForceFullScanSubtitle": "Rescan all files, ignoring cache",
+  "@libraryForceFullScanSubtitle": {"description": "Subtitle for force full scan button"},
+
+  "cleanupOrphanedDownloads": "Cleanup Orphaned Downloads",
+  "@cleanupOrphanedDownloads": {"description": "Button to remove history entries for deleted files"},
+  "cleanupOrphanedDownloadsSubtitle": "Remove history entries for files that no longer exist",
+  "@cleanupOrphanedDownloadsSubtitle": {"description": "Subtitle for orphaned cleanup button"},
+  "cleanupOrphanedDownloadsResult": "Removed {count} orphaned entries from history",
+  "@cleanupOrphanedDownloadsResult": {
+    "description": "Snackbar after orphan cleanup",
+    "placeholders": {
+      "count": {"type": "int"}
+    }
+  },
+  "cleanupOrphanedDownloadsNone": "No orphaned entries found",
+  "@cleanupOrphanedDownloadsNone": {"description": "Snackbar when no orphans found"},
+
+  "cacheTitle": "Storage & Cache",
+  "@cacheTitle": {"description": "Cache management page title"},
+  "cacheSummaryTitle": "Cache overview",
+  "@cacheSummaryTitle": {"description": "Heading for cache summary card"},
+  "cacheSummarySubtitle": "Clearing cache will not remove downloaded music files.",
+  "@cacheSummarySubtitle": {"description": "Helper text for cache summary card"},
+  "cacheEstimatedTotal": "Estimated cache usage: {size}",
+  "@cacheEstimatedTotal": {
+    "description": "Total cache size shown in summary",
+    "placeholders": {
+      "size": {"type": "String"}
+    }
+  },
+  "cacheSectionStorage": "Cached Data",
+  "@cacheSectionStorage": {"description": "Section header for cache entries"},
+  "cacheSectionMaintenance": "Maintenance",
+  "@cacheSectionMaintenance": {"description": "Section header for cleanup actions"},
+  "cacheAppDirectory": "App cache directory",
+  "@cacheAppDirectory": {"description": "Cache item title for app cache directory"},
+  "cacheAppDirectoryDesc": "HTTP responses, WebView data, and other temporary app data.",
+  "@cacheAppDirectoryDesc": {"description": "Description of what app cache directory contains"},
+  "cacheTempDirectory": "Temporary directory",
+  "@cacheTempDirectory": {"description": "Cache item title for temporary files directory"},
+  "cacheTempDirectoryDesc": "Temporary files from downloads and audio conversion.",
+  "@cacheTempDirectoryDesc": {"description": "Description of what temporary directory contains"},
+  "cacheCoverImage": "Cover image cache",
+  "@cacheCoverImage": {"description": "Cache item title for persistent cover images"},
+  "cacheCoverImageDesc": "Downloaded album and track cover art. Will re-download when viewed.",
+  "@cacheCoverImageDesc": {"description": "Description of what cover image cache contains"},
+  "cacheLibraryCover": "Library cover cache",
+  "@cacheLibraryCover": {"description": "Cache item title for local library cover art images"},
+  "cacheLibraryCoverDesc": "Cover art extracted from local music files. Will re-extract on next scan.",
+  "@cacheLibraryCoverDesc": {"description": "Description of what library cover cache contains"},
+  "cacheExploreFeed": "Explore feed cache",
+  "@cacheExploreFeed": {"description": "Cache item title for explore home feed cache"},
+  "cacheExploreFeedDesc": "Explore tab content (new releases, trending). Will refresh on next visit.",
+  "@cacheExploreFeedDesc": {"description": "Description of what explore feed cache contains"},
+  "cacheTrackLookup": "Track lookup cache",
+  "@cacheTrackLookup": {"description": "Cache item title for track ID lookup cache"},
+  "cacheTrackLookupDesc": "Spotify/Deezer track ID lookups. Clearing may slow next few searches.",
+  "@cacheTrackLookupDesc": {"description": "Description of what track lookup cache contains"},
+  "cacheCleanupUnusedDesc": "Remove orphaned download history and library entries for missing files.",
+  "@cacheCleanupUnusedDesc": {"description": "Description of what cleanup unused data does"},
+  "cacheNoData": "No cached data",
+  "@cacheNoData": {"description": "Label when cache category has no data"},
+  "cacheSizeWithFiles": "{size} in {count} files",
+  "@cacheSizeWithFiles": {
+    "description": "Cache size and file count",
+    "placeholders": {
+      "size": {"type": "String"},
+      "count": {"type": "int"}
+    }
+  },
+  "cacheSizeOnly": "{size}",
+  "@cacheSizeOnly": {
+    "description": "Cache size only",
+    "placeholders": {
+      "size": {"type": "String"}
+    }
+  },
+  "cacheEntries": "{count} entries",
+  "@cacheEntries": {
+    "description": "Track cache entry count",
+    "placeholders": {
+      "count": {"type": "int"}
+    }
+  },
+  "cacheClearSuccess": "Cleared: {target}",
+  "@cacheClearSuccess": {
+    "description": "Snackbar after clearing selected cache",
+    "placeholders": {
+      "target": {"type": "String"}
+    }
+  },
+  "cacheClearConfirmTitle": "Clear cache?",
+  "@cacheClearConfirmTitle": {"description": "Dialog title before clearing one cache category"},
+  "cacheClearConfirmMessage": "This will clear cached data for {target}. Downloaded music files will not be deleted.",
+  "@cacheClearConfirmMessage": {
+    "description": "Dialog message before clearing selected cache",
+    "placeholders": {
+      "target": {"type": "String"}
+    }
+  },
+  "cacheClearAllConfirmTitle": "Clear all cache?",
+  "@cacheClearAllConfirmTitle": {"description": "Dialog title before clearing all caches"},
+  "cacheClearAllConfirmMessage": "This will clear all cache categories on this page. Downloaded music files will not be deleted.",
+  "@cacheClearAllConfirmMessage": {"description": "Dialog message before clearing all caches"},
+  "cacheClearAll": "Clear all cache",
+  "@cacheClearAll": {"description": "Button label to clear all caches"},
+  "cacheCleanupUnused": "Cleanup unused data",
+  "@cacheCleanupUnused": {"description": "Action title for cleaning unused entries"},
+  "cacheCleanupUnusedSubtitle": "Remove orphaned download history and missing library entries",
+  "@cacheCleanupUnusedSubtitle": {"description": "Subtitle for cleanup unused data action"},
+  "cacheCleanupResult": "Cleanup completed: {downloadCount} orphaned downloads, {libraryCount} missing library entries",
+  "@cacheCleanupResult": {
+    "description": "Snackbar after unused data cleanup",
+    "placeholders": {
+      "downloadCount": {"type": "int"},
+      "libraryCount": {"type": "int"}
+    }
+  },
+  "cacheRefreshStats": "Refresh stats",
+  "@cacheRefreshStats": {"description": "Button label to refresh cache statistics"},
+
+  "trackSaveCoverArt": "Save Cover Art",
+  "@trackSaveCoverArt": {"description": "Menu action - save album cover art as file"},
+  "trackSaveCoverArtSubtitle": "Save album art as .jpg file",
+  "@trackSaveCoverArtSubtitle": {"description": "Subtitle for save cover art action"},
+  "trackSaveLyrics": "Save Lyrics (.lrc)",
+  "@trackSaveLyrics": {"description": "Menu action - save lyrics as .lrc file"},
+  "trackSaveLyricsSubtitle": "Fetch and save lyrics as .lrc file",
+  "@trackSaveLyricsSubtitle": {"description": "Subtitle for save lyrics action"},
+  "trackReEnrich": "Re-enrich Metadata",
+  "@trackReEnrich": {"description": "Menu action - re-embed metadata into audio file"},
+  "trackReEnrichSubtitle": "Re-embed metadata without re-downloading",
+  "@trackReEnrichSubtitle": {"description": "Subtitle for re-enrich metadata action"},
+  "trackReEnrichOnlineSubtitle": "Search metadata online and embed into file",
+  "@trackReEnrichOnlineSubtitle": {"description": "Subtitle for re-enrich metadata action for local items"},
+  "trackEditMetadata": "Edit Metadata",
+  "@trackEditMetadata": {"description": "Menu action - edit embedded metadata"},
+  "trackCoverSaved": "Cover art saved to {fileName}",
+  "@trackCoverSaved": {
+    "description": "Snackbar after cover art saved",
+    "placeholders": {
+      "fileName": {"type": "String"}
+    }
+  },
+  "trackCoverNoSource": "No cover art source available",
+  "@trackCoverNoSource": {"description": "Snackbar when no cover art URL or embedded cover"},
+  "trackLyricsSaved": "Lyrics saved to {fileName}",
+  "@trackLyricsSaved": {
+    "description": "Snackbar after lyrics saved",
+    "placeholders": {
+      "fileName": {"type": "String"}
+    }
+  },
+  "trackReEnrichProgress": "Re-enriching metadata...",
+  "@trackReEnrichProgress": {"description": "Snackbar while re-enriching metadata"},
+  "trackReEnrichSearching": "Searching metadata online...",
+  "@trackReEnrichSearching": {"description": "Snackbar while searching metadata from internet for local items"},
+  "trackReEnrichSuccess": "Metadata re-enriched successfully",
+  "@trackReEnrichSuccess": {"description": "Snackbar after successful re-enrichment"},
+  "trackReEnrichFfmpegFailed": "FFmpeg metadata embed failed",
+  "@trackReEnrichFfmpegFailed": {"description": "Snackbar when FFmpeg embed fails for MP3/Opus"},
+  "trackSaveFailed": "Failed: {error}",
+  "@trackSaveFailed": {
+    "description": "Snackbar when save operation fails",
+    "placeholders": {
+      "error": {"type": "String"}
+    }
+  }
 }
@@ -127,6 +127,10 @@
  "@historyNoSinglesSubtitle": {
    "description": "Empty state subtitle for singles filter"
  },
+  "historySearchHint": "Search history...",
+  "@historySearchHint": {
+    "description": "Search bar placeholder in history"
+  },
  "settingsTitle": "Settings",
  "@settingsTitle": {
    "description": "Settings screen title"
@@ -512,6 +516,10 @@
  "@aboutLogoArtist": {
    "description": "Role description for logo artist"
  },
+  "aboutTranslators": "Translators",
+  "@aboutTranslators": {
+    "description": "Section for translators"
+  },
  "aboutSpecialThanks": "Special Thanks",
  "@aboutSpecialThanks": {
    "description": "Section for special thanks"
@@ -544,6 +552,26 @@
  "@aboutFeatureRequestSubtitle": {
    "description": "Subtitle for feature request"
  },
+  "aboutTelegramChannel": "Telegram Channel",
+  "@aboutTelegramChannel": {
+    "description": "Link to Telegram channel"
+  },
+  "aboutTelegramChannelSubtitle": "Announcements and updates",
+  "@aboutTelegramChannelSubtitle": {
+    "description": "Subtitle for Telegram channel"
+  },
+  "aboutTelegramChat": "Telegram Community",
+  "@aboutTelegramChat": {
+    "description": "Link to Telegram chat group"
+  },
+  "aboutTelegramChatSubtitle": "Chat with other users",
+  "@aboutTelegramChatSubtitle": {
+    "description": "Subtitle for Telegram chat"
+  },
+  "aboutSocial": "Social",
+  "@aboutSocial": {
+    "description": "Section for social links"
+  },
  "aboutSupport": "Support",
  "@aboutSupport": {
    "description": "Section for support/donation links"
@@ -1122,6 +1150,15 @@
    "description": "Dialog title - import CSV playlist"
  },
  "dialogImportPlaylistMessage": "Found {count} tracks in CSV. Add them to download queue?",
+  "csvImportTracks": "{count} tracks from CSV",
+  "@csvImportTracks": {
+    "description": "Label shown in quality picker for CSV import",
+    "placeholders": {
+      "count": {
+        "type": "int"
+      }
+    }
+  },
  "@dialogImportPlaylistMessage": {
    "description": "Dialog message - import playlist confirmation",
    "placeholders": {
@@ -1851,6 +1888,42 @@
  "@sectionFileSettings": {
    "description": "Settings section header"
  },
+  "sectionLyrics": "Lyrics",
+  "@sectionLyrics": {
+    "description": "Settings section header"
+  },
+  "lyricsMode": "Lyrics Mode",
+  "@lyricsMode": {
+    "description": "Setting - how to save lyrics"
+  },
+  "lyricsModeDescription": "Choose how lyrics are saved with your downloads",
+  "@lyricsModeDescription": {
+    "description": "Lyrics mode picker description"
+  },
+  "lyricsModeEmbed": "Embed in file",
+  "@lyricsModeEmbed": {
+    "description": "Lyrics mode option - embed in audio file"
+  },
+  "lyricsModeEmbedSubtitle": "Lyrics stored inside FLAC metadata",
+  "@lyricsModeEmbedSubtitle": {
+    "description": "Subtitle for embed option"
+  },
+  "lyricsModeExternal": "External .lrc file",
+  "@lyricsModeExternal": {
+    "description": "Lyrics mode option - separate LRC file"
+  },
+  "lyricsModeExternalSubtitle": "Separate .lrc file for players like Samsung Music",
+  "@lyricsModeExternalSubtitle": {
+    "description": "Subtitle for external option"
+  },
+  "lyricsModeBoth": "Both",
+  "@lyricsModeBoth": {
+    "description": "Lyrics mode option - embed and external"
+  },
+  "lyricsModeBothSubtitle": "Embed and save .lrc file",
+  "@lyricsModeBothSubtitle": {
+    "description": "Subtitle for both option"
+  },
  "sectionColor": "Color",
  "@sectionColor": {
    "description": "Settings section header"
@@ -1997,6 +2070,18 @@
  "@trackReleaseDate": {
    "description": "Metadata label - release date"
  },
+  "trackGenre": "Genre",
+  "@trackGenre": {
+    "description": "Metadata label - music genre"
+  },
+  "trackLabel": "Label",
+  "@trackLabel": {
+    "description": "Metadata label - record label"
+  },
+  "trackCopyright": "Copyright",
+  "@trackCopyright": {
+    "description": "Metadata label - copyright information"
+  },
  "trackDownloaded": "Downloaded",
  "@trackDownloaded": {
    "description": "Metadata label - download date"
@@ -2017,6 +2102,18 @@
  "@trackLyricsLoadFailed": {
    "description": "Message when lyrics loading fails"
  },
+  "trackEmbedLyrics": "Embed Lyrics",
+  "@trackEmbedLyrics": {
+    "description": "Action - embed lyrics into audio file"
+  },
+  "trackLyricsEmbedded": "Lyrics embedded successfully",
+  "@trackLyricsEmbedded": {
+    "description": "Snackbar - lyrics saved to file"
+  },
+  "trackInstrumental": "Instrumental track",
+  "@trackInstrumental": {
+    "description": "Message when track is instrumental (no lyrics)"
+  },
  "trackCopiedToClipboard": "Copied to clipboard",
  "@trackCopiedToClipboard": {
    "description": "Snackbar - content copied"
@@ -2328,6 +2425,26 @@
  "@qualityHiResFlacMaxSubtitle": {
    "description": "Technical spec for hi-res max"
  },
+  "qualityMp3": "MP3",
+  "@qualityMp3": {
+    "description": "Quality option - MP3 lossy format"
+  },
+  "qualityMp3Subtitle": "320kbps (converted from FLAC)",
+  "@qualityMp3Subtitle": {
+    "description": "Technical spec for MP3"
+  },
+  "enableMp3Option": "Enable MP3 Option",
+  "@enableMp3Option": {
+    "description": "Setting - enable MP3 quality option"
+  },
+  "enableMp3OptionSubtitleOn": "MP3 quality option is available",
+  "@enableMp3OptionSubtitleOn": {
+    "description": "Subtitle when MP3 is enabled"
+  },
+  "enableMp3OptionSubtitleOff": "Downloads FLAC then converts to 320kbps MP3",
+  "@enableMp3OptionSubtitleOff": {
+    "description": "Subtitle when MP3 is disabled"
+  },
  "qualityNote": "Actual quality depends on track availability from the service",
  "@qualityNote": {
    "description": "Note about quality availability"
@@ -2516,6 +2633,14 @@
  "@albumFolderYearAlbumSubtitle": {
    "description": "Folder structure example"
  },
+  "albumFolderArtistAlbumSingles": "Artist / Album + Singles",
+  "@albumFolderArtistAlbumSingles": {
+    "description": "Album folder option with singles inside artist"
+  },
+  "albumFolderArtistAlbumSinglesSubtitle": "Artist/Album/ and Artist/Singles/",
+  "@albumFolderArtistAlbumSinglesSubtitle": {
+    "description": "Folder structure example"
+  },
  "downloadedAlbumDeleteSelected": "Delete Selected",
  "@downloadedAlbumDeleteSelected": {
    "description": "Button - delete selected tracks"
@@ -2572,6 +2697,16 @@
  "@downloadedAlbumSelectToDelete": {
    "description": "Placeholder when nothing selected"
  },
+  "downloadedAlbumDiscHeader": "Disc {discNumber}",
+  "@downloadedAlbumDiscHeader": {
+    "description": "Header for disc separator in multi-disc albums",
+    "placeholders": {
+      "discNumber": {
+        "type": "int",
+        "example": "1"
+      }
+    }
+  },
  "utilityFunctions": "Utility Functions",
  "@utilityFunctions": {
    "description": "Extension capability - utility functions"
@@ -2611,5 +2746,123 @@
        "description": "Error message"
      }
    }
+  },
+  "discographyDownload": "Download Discography",
+  "@discographyDownload": {
+    "description": "Button - download artist discography"
+  },
+  "discographyDownloadAll": "Download All",
+  "@discographyDownloadAll": {
+    "description": "Option - download entire discography"
+  },
+  "discographyDownloadAllSubtitle": "{count} tracks from {albumCount} releases",
+  "@discographyDownloadAllSubtitle": {
+    "description": "Subtitle showing total tracks and albums",
+    "placeholders": {
+      "count": {
+        "type": "int"
+      },
+      "albumCount": {
+        "type": "int"
+      }
+    }
+  },
+  "discographyAlbumsOnly": "Albums Only",
+  "@discographyAlbumsOnly": {
+    "description": "Option - download only albums"
+  },
+  "discographyAlbumsOnlySubtitle": "{count} tracks from {albumCount} albums",
+  "@discographyAlbumsOnlySubtitle": {
+    "description": "Subtitle showing album tracks count",
+    "placeholders": {
+      "count": {
+        "type": "int"
+      },
+      "albumCount": {
+        "type": "int"
+      }
+    }
+  },
+  "discographySinglesOnly": "Singles & EPs Only",
+  "@discographySinglesOnly": {
+    "description": "Option - download only singles"
+  },
+  "discographySinglesOnlySubtitle": "{count} tracks from {albumCount} singles",
+  "@discographySinglesOnlySubtitle": {
+    "description": "Subtitle showing singles tracks count",
+    "placeholders": {
+      "count": {
+        "type": "int"
+      },
+      "albumCount": {
+        "type": "int"
+      }
+    }
+  },
+  "discographySelectAlbums": "Select Albums...",
+  "@discographySelectAlbums": {
+    "description": "Option - manually select albums to download"
+  },
+  "discographySelectAlbumsSubtitle": "Choose specific albums or singles",
+  "@discographySelectAlbumsSubtitle": {
+    "description": "Subtitle for select albums option"
+  },
+  "discographyFetchingTracks": "Fetching tracks...",
+  "@discographyFetchingTracks": {
+    "description": "Progress - fetching album tracks"
+  },
+  "discographyFetchingAlbum": "Fetching {current} of {total}...",
+  "@discographyFetchingAlbum": {
+    "description": "Progress - fetching specific album",
+    "placeholders": {
+      "current": {
+        "type": "int"
+      },
+      "total": {
+        "type": "int"
+      }
+    }
+  },
+  "discographySelectedCount": "{count} selected",
+  "@discographySelectedCount": {
+    "description": "Selection count badge",
+    "placeholders": {
+      "count": {
+        "type": "int"
+      }
+    }
+  },
+  "discographyDownloadSelected": "Download Selected",
+  "@discographyDownloadSelected": {
+    "description": "Button - download selected albums"
+  },
+  "discographyAddedToQueue": "Added {count} tracks to queue",
+  "@discographyAddedToQueue": {
+    "description": "Snackbar - tracks added from discography",
+    "placeholders": {
+      "count": {
+        "type": "int"
+      }
+    }
+  },
+  "discographySkippedDownloaded": "{added} added, {skipped} already downloaded",
+  "@discographySkippedDownloaded": {
+    "description": "Snackbar - with skipped tracks count",
+    "placeholders": {
+      "added": {
+        "type": "int"
+      },
+      "skipped": {
+        "type": "int"
+      }
+    }
+  },
+  "discographyNoAlbums": "No albums available",
+  "@discographyNoAlbums": {
+    "description": "Error - no albums found for artist"
+  },
+  "discographyFailedToFetch": "Failed to fetch some albums",
+  "@discographyFailedToFetch": {
+    "description": "Error - some albums failed to load"
  }
 }
@@ -1,23 +1,23 @@
 {
  "@@locale": "hi",
  "@@last_modified": "2026-01-16",
-  "appName": "SpotiFLAC",
+  "appName": "SpotiFlac",
  "@appName": {
    "description": "App name - DO NOT TRANSLATE"
  },
-  "appDescription": "Download Spotify tracks in lossless quality from Tidal, Qobuz, and Amazon Music.",
+  "appDescription": "स्पॉटीफाई ट्रैक डाउनलोड करें टाइडल, क्वाबज एवं एवं अमेजन म्यूजिक से उच्चतम क्वालिटी में।",
  "@appDescription": {
    "description": "App description shown in about page"
  },
-  "navHome": "Home",
+  "navHome": "होम",
  "@navHome": {
    "description": "Bottom navigation - Home tab"
  },
-  "navHistory": "History",
+  "navHistory": "इतिहास",
  "@navHistory": {
    "description": "Bottom navigation - History tab"
  },
-  "navSettings": "Settings",
+  "navSettings": "विकल्प",
  "@navSettings": {
    "description": "Bottom navigation - Settings tab"
  },
@@ -127,6 +127,10 @@
  "@historyNoSinglesSubtitle": {
    "description": "Empty state subtitle for singles filter"
  },
+  "historySearchHint": "Search history...",
+  "@historySearchHint": {
+    "description": "Search bar placeholder in history"
+  },
  "settingsTitle": "Settings",
  "@settingsTitle": {
    "description": "Settings screen title"
@@ -219,7 +223,7 @@
  "@quality128": {
    "description": "Audio quality option - 128kbps MP3"
  },
-  "appearanceTitle": "Appearance",
+  "appearanceTitle": "दिखावट",
  "@appearanceTitle": {
    "description": "Appearance settings page title"
  },
@@ -239,11 +243,11 @@
  "@appearanceThemeDark": {
    "description": "Dark theme"
  },
-  "appearanceDynamicColor": "Dynamic Color",
+  "appearanceDynamicColor": "डायनेमिक रंग",
  "@appearanceDynamicColor": {
    "description": "Material You dynamic colors"
  },
-  "appearanceDynamicColorSubtitle": "Use colors from your wallpaper",
+  "appearanceDynamicColorSubtitle": "वॉलपेपर से रंग इस्तेमाल करें",
  "@appearanceDynamicColorSubtitle": {
    "description": "Subtitle for dynamic color"
  },
@@ -512,6 +516,10 @@
  "@aboutLogoArtist": {
    "description": "Role description for logo artist"
  },
+  "aboutTranslators": "Translators",
+  "@aboutTranslators": {
+    "description": "Section for translators"
+  },
  "aboutSpecialThanks": "Special Thanks",
  "@aboutSpecialThanks": {
    "description": "Section for special thanks"
@@ -544,6 +552,26 @@
  "@aboutFeatureRequestSubtitle": {
    "description": "Subtitle for feature request"
  },
+  "aboutTelegramChannel": "Telegram Channel",
+  "@aboutTelegramChannel": {
+    "description": "Link to Telegram channel"
+  },
+  "aboutTelegramChannelSubtitle": "Announcements and updates",
+  "@aboutTelegramChannelSubtitle": {
+    "description": "Subtitle for Telegram channel"
+  },
+  "aboutTelegramChat": "Telegram Community",
+  "@aboutTelegramChat": {
+    "description": "Link to Telegram chat group"
+  },
+  "aboutTelegramChatSubtitle": "Chat with other users",
+  "@aboutTelegramChatSubtitle": {
+    "description": "Subtitle for Telegram chat"
+  },
+  "aboutSocial": "Social",
+  "@aboutSocial": {
+    "description": "Section for social links"
+  },
  "aboutSupport": "Support",
  "@aboutSupport": {
    "description": "Section for support/donation links"
@@ -1122,6 +1150,15 @@
    "description": "Dialog title - import CSV playlist"
  },
  "dialogImportPlaylistMessage": "Found {count} tracks in CSV. Add them to download queue?",
+  "csvImportTracks": "{count} tracks from CSV",
+  "@csvImportTracks": {
+    "description": "Label shown in quality picker for CSV import",
+    "placeholders": {
+      "count": {
+        "type": "int"
+      }
+    }
+  },
  "@dialogImportPlaylistMessage": {
    "description": "Dialog message - import playlist confirmation",
    "placeholders": {
@@ -1851,6 +1888,42 @@
  "@sectionFileSettings": {
    "description": "Settings section header"
  },
+  "sectionLyrics": "Lyrics",
+  "@sectionLyrics": {
+    "description": "Settings section header"
+  },
+  "lyricsMode": "Lyrics Mode",
+  "@lyricsMode": {
+    "description": "Setting - how to save lyrics"
+  },
+  "lyricsModeDescription": "Choose how lyrics are saved with your downloads",
+  "@lyricsModeDescription": {
+    "description": "Lyrics mode picker description"
+  },
+  "lyricsModeEmbed": "Embed in file",
+  "@lyricsModeEmbed": {
+    "description": "Lyrics mode option - embed in audio file"
+  },
+  "lyricsModeEmbedSubtitle": "Lyrics stored inside FLAC metadata",
+  "@lyricsModeEmbedSubtitle": {
+    "description": "Subtitle for embed option"
+  },
+  "lyricsModeExternal": "External .lrc file",
+  "@lyricsModeExternal": {
+    "description": "Lyrics mode option - separate LRC file"
+  },
+  "lyricsModeExternalSubtitle": "Separate .lrc file for players like Samsung Music",
+  "@lyricsModeExternalSubtitle": {
+    "description": "Subtitle for external option"
+  },
+  "lyricsModeBoth": "Both",
+  "@lyricsModeBoth": {
+    "description": "Lyrics mode option - embed and external"
+  },
+  "lyricsModeBothSubtitle": "Embed and save .lrc file",
+  "@lyricsModeBothSubtitle": {
+    "description": "Subtitle for both option"
+  },
  "sectionColor": "Color",
  "@sectionColor": {
    "description": "Settings section header"
@@ -1997,6 +2070,18 @@
  "@trackReleaseDate": {
    "description": "Metadata label - release date"
  },
+  "trackGenre": "Genre",
+  "@trackGenre": {
+    "description": "Metadata label - music genre"
+  },
+  "trackLabel": "Label",
+  "@trackLabel": {
+    "description": "Metadata label - record label"
+  },
+  "trackCopyright": "Copyright",
+  "@trackCopyright": {
+    "description": "Metadata label - copyright information"
+  },
  "trackDownloaded": "Downloaded",
  "@trackDownloaded": {
    "description": "Metadata label - download date"
@@ -2017,6 +2102,18 @@
  "@trackLyricsLoadFailed": {
    "description": "Message when lyrics loading fails"
  },
+  "trackEmbedLyrics": "Embed Lyrics",
+  "@trackEmbedLyrics": {
+    "description": "Action - embed lyrics into audio file"
+  },
+  "trackLyricsEmbedded": "Lyrics embedded successfully",
+  "@trackLyricsEmbedded": {
+    "description": "Snackbar - lyrics saved to file"
+  },
+  "trackInstrumental": "Instrumental track",
+  "@trackInstrumental": {
+    "description": "Message when track is instrumental (no lyrics)"
+  },
  "trackCopiedToClipboard": "Copied to clipboard",
  "@trackCopiedToClipboard": {
    "description": "Snackbar - content copied"
@@ -2328,6 +2425,26 @@
  "@qualityHiResFlacMaxSubtitle": {
    "description": "Technical spec for hi-res max"
  },
+  "qualityMp3": "MP3",
+  "@qualityMp3": {
+    "description": "Quality option - MP3 lossy format"
+  },
+  "qualityMp3Subtitle": "320kbps (converted from FLAC)",
+  "@qualityMp3Subtitle": {
+    "description": "Technical spec for MP3"
+  },
+  "enableMp3Option": "Enable MP3 Option",
+  "@enableMp3Option": {
+    "description": "Setting - enable MP3 quality option"
+  },
+  "enableMp3OptionSubtitleOn": "MP3 quality option is available",
+  "@enableMp3OptionSubtitleOn": {
+    "description": "Subtitle when MP3 is enabled"
+  },
+  "enableMp3OptionSubtitleOff": "Downloads FLAC then converts to 320kbps MP3",
+  "@enableMp3OptionSubtitleOff": {
+    "description": "Subtitle when MP3 is disabled"
+  },
  "qualityNote": "Actual quality depends on track availability from the service",
  "@qualityNote": {
    "description": "Note about quality availability"
@@ -2516,6 +2633,14 @@
  "@albumFolderYearAlbumSubtitle": {
    "description": "Folder structure example"
  },
+  "albumFolderArtistAlbumSingles": "Artist / Album + Singles",
+  "@albumFolderArtistAlbumSingles": {
+    "description": "Album folder option with singles inside artist"
+  },
+  "albumFolderArtistAlbumSinglesSubtitle": "Artist/Album/ and Artist/Singles/",
+  "@albumFolderArtistAlbumSinglesSubtitle": {
+    "description": "Folder structure example"
+  },
  "downloadedAlbumDeleteSelected": "Delete Selected",
  "@downloadedAlbumDeleteSelected": {
    "description": "Button - delete selected tracks"
@@ -2572,6 +2697,16 @@
  "@downloadedAlbumSelectToDelete": {
    "description": "Placeholder when nothing selected"
  },
+  "downloadedAlbumDiscHeader": "Disc {discNumber}",
+  "@downloadedAlbumDiscHeader": {
+    "description": "Header for disc separator in multi-disc albums",
+    "placeholders": {
+      "discNumber": {
+        "type": "int",
+        "example": "1"
+      }
+    }
+  },
  "utilityFunctions": "Utility Functions",
  "@utilityFunctions": {
    "description": "Extension capability - utility functions"
@@ -2611,5 +2746,123 @@
        "description": "Error message"
      }
    }
+  },
+  "discographyDownload": "Download Discography",
+  "@discographyDownload": {
+    "description": "Button - download artist discography"
+  },
+  "discographyDownloadAll": "Download All",
+  "@discographyDownloadAll": {
+    "description": "Option - download entire discography"
+  },
+  "discographyDownloadAllSubtitle": "{count} tracks from {albumCount} releases",
+  "@discographyDownloadAllSubtitle": {
+    "description": "Subtitle showing total tracks and albums",
+    "placeholders": {
+      "count": {
+        "type": "int"
+      },
+      "albumCount": {
+        "type": "int"
+      }
+    }
+  },
+  "discographyAlbumsOnly": "Albums Only",
+  "@discographyAlbumsOnly": {
+    "description": "Option - download only albums"
+  },
+  "discographyAlbumsOnlySubtitle": "{count} tracks from {albumCount} albums",
+  "@discographyAlbumsOnlySubtitle": {
+    "description": "Subtitle showing album tracks count",
+    "placeholders": {
+      "count": {
+        "type": "int"
+      },
+      "albumCount": {
+        "type": "int"
+      }
+    }
+  },
+  "discographySinglesOnly": "Singles & EPs Only",
+  "@discographySinglesOnly": {
+    "description": "Option - download only singles"
+  },
+  "discographySinglesOnlySubtitle": "{count} tracks from {albumCount} singles",
+  "@discographySinglesOnlySubtitle": {
+    "description": "Subtitle showing singles tracks count",
+    "placeholders": {
+      "count": {
+        "type": "int"
+      },
+      "albumCount": {
+        "type": "int"
+      }
+    }
+  },
+  "discographySelectAlbums": "Select Albums...",
+  "@discographySelectAlbums": {
+    "description": "Option - manually select albums to download"
+  },
+  "discographySelectAlbumsSubtitle": "Choose specific albums or singles",
+  "@discographySelectAlbumsSubtitle": {
+    "description": "Subtitle for select albums option"
+  },
+  "discographyFetchingTracks": "Fetching tracks...",
+  "@discographyFetchingTracks": {
+    "description": "Progress - fetching album tracks"
+  },
+  "discographyFetchingAlbum": "Fetching {current} of {total}...",
+  "@discographyFetchingAlbum": {
+    "description": "Progress - fetching specific album",
+    "placeholders": {
+      "current": {
+        "type": "int"
+      },
+      "total": {
+        "type": "int"
+      }
+    }
+  },
+  "discographySelectedCount": "{count} selected",
+  "@discographySelectedCount": {
+    "description": "Selection count badge",
+    "placeholders": {
+      "count": {
+        "type": "int"
+      }
+    }
+  },
+  "discographyDownloadSelected": "Download Selected",
+  "@discographyDownloadSelected": {
+    "description": "Button - download selected albums"
+  },
+  "discographyAddedToQueue": "Added {count} tracks to queue",
+  "@discographyAddedToQueue": {
+    "description": "Snackbar - tracks added from discography",
+    "placeholders": {
+      "count": {
+        "type": "int"
+      }
+    }
+  },
+  "discographySkippedDownloaded": "{added} added, {skipped} already downloaded",
+  "@discographySkippedDownloaded": {
+    "description": "Snackbar - with skipped tracks count",
+    "placeholders": {
+      "added": {
+        "type": "int"
+      },
+      "skipped": {
+        "type": "int"
+      }
+    }
+  },
+  "discographyNoAlbums": "No albums available",
+  "@discographyNoAlbums": {
+    "description": "Error - no albums found for artist"
+  },
+  "discographyFailedToFetch": "Failed to fetch some albums",
+  "@discographyFailedToFetch": {
+    "description": "Error - some albums failed to load"
  }
 }
@@ -127,6 +127,10 @@
  "@historyNoSinglesSubtitle": {
    "description": "Empty state subtitle for singles filter"
  },
+  "historySearchHint": "Search history...",
+  "@historySearchHint": {
+    "description": "Search bar placeholder in history"
+  },
  "settingsTitle": "Settings",
  "@settingsTitle": {
    "description": "Settings screen title"
@@ -512,6 +516,10 @@
  "@aboutLogoArtist": {
    "description": "Role description for logo artist"
  },
+  "aboutTranslators": "Translators",
+  "@aboutTranslators": {
+    "description": "Section for translators"
+  },
  "aboutSpecialThanks": "Special Thanks",
  "@aboutSpecialThanks": {
    "description": "Section for special thanks"
@@ -544,6 +552,26 @@
  "@aboutFeatureRequestSubtitle": {
    "description": "Subtitle for feature request"
  },
+  "aboutTelegramChannel": "Telegram Channel",
+  "@aboutTelegramChannel": {
+    "description": "Link to Telegram channel"
+  },
+  "aboutTelegramChannelSubtitle": "Announcements and updates",
+  "@aboutTelegramChannelSubtitle": {
+    "description": "Subtitle for Telegram channel"
+  },
+  "aboutTelegramChat": "Telegram Community",
+  "@aboutTelegramChat": {
+    "description": "Link to Telegram chat group"
+  },
+  "aboutTelegramChatSubtitle": "Chat with other users",
+  "@aboutTelegramChatSubtitle": {
+    "description": "Subtitle for Telegram chat"
+  },
+  "aboutSocial": "Social",
+  "@aboutSocial": {
+    "description": "Section for social links"
+  },
  "aboutSupport": "Support",
  "@aboutSupport": {
    "description": "Section for support/donation links"
@@ -1122,6 +1150,15 @@
    "description": "Dialog title - import CSV playlist"
  },
  "dialogImportPlaylistMessage": "Found {count} tracks in CSV. Add them to download queue?",
+  "csvImportTracks": "{count} tracks from CSV",
+  "@csvImportTracks": {
+    "description": "Label shown in quality picker for CSV import",
+    "placeholders": {
+      "count": {
+        "type": "int"
+      }
+    }
+  },
  "@dialogImportPlaylistMessage": {
    "description": "Dialog message - import playlist confirmation",
    "placeholders": {
@@ -1851,6 +1888,42 @@
  "@sectionFileSettings": {
    "description": "Settings section header"
  },
+  "sectionLyrics": "Lyrics",
+  "@sectionLyrics": {
+    "description": "Settings section header"
+  },
+  "lyricsMode": "Lyrics Mode",
+  "@lyricsMode": {
+    "description": "Setting - how to save lyrics"
+  },
+  "lyricsModeDescription": "Choose how lyrics are saved with your downloads",
+  "@lyricsModeDescription": {
+    "description": "Lyrics mode picker description"
+  },
+  "lyricsModeEmbed": "Embed in file",
+  "@lyricsModeEmbed": {
+    "description": "Lyrics mode option - embed in audio file"
+  },
+  "lyricsModeEmbedSubtitle": "Lyrics stored inside FLAC metadata",
+  "@lyricsModeEmbedSubtitle": {
+    "description": "Subtitle for embed option"
+  },
+  "lyricsModeExternal": "External .lrc file",
+  "@lyricsModeExternal": {
+    "description": "Lyrics mode option - separate LRC file"
+  },
+  "lyricsModeExternalSubtitle": "Separate .lrc file for players like Samsung Music",
+  "@lyricsModeExternalSubtitle": {
+    "description": "Subtitle for external option"
+  },
+  "lyricsModeBoth": "Both",
+  "@lyricsModeBoth": {
+    "description": "Lyrics mode option - embed and external"
+  },
+  "lyricsModeBothSubtitle": "Embed and save .lrc file",
+  "@lyricsModeBothSubtitle": {
+    "description": "Subtitle for both option"
+  },
  "sectionColor": "Color",
  "@sectionColor": {
    "description": "Settings section header"
@@ -1997,6 +2070,18 @@
  "@trackReleaseDate": {
    "description": "Metadata label - release date"
  },
+  "trackGenre": "Genre",
+  "@trackGenre": {
+    "description": "Metadata label - music genre"
+  },
+  "trackLabel": "Label",
+  "@trackLabel": {
+    "description": "Metadata label - record label"
+  },
+  "trackCopyright": "Copyright",
+  "@trackCopyright": {
+    "description": "Metadata label - copyright information"
+  },
  "trackDownloaded": "Downloaded",
  "@trackDownloaded": {
    "description": "Metadata label - download date"
@@ -2017,6 +2102,18 @@
  "@trackLyricsLoadFailed": {
    "description": "Message when lyrics loading fails"
  },
+  "trackEmbedLyrics": "Embed Lyrics",
+  "@trackEmbedLyrics": {
+    "description": "Action - embed lyrics into audio file"
+  },
+  "trackLyricsEmbedded": "Lyrics embedded successfully",
+  "@trackLyricsEmbedded": {
+    "description": "Snackbar - lyrics saved to file"
+  },
+  "trackInstrumental": "Instrumental track",
+  "@trackInstrumental": {
+    "description": "Message when track is instrumental (no lyrics)"
+  },
  "trackCopiedToClipboard": "Copied to clipboard",
  "@trackCopiedToClipboard": {
    "description": "Snackbar - content copied"
@@ -2328,6 +2425,26 @@
  "@qualityHiResFlacMaxSubtitle": {
    "description": "Technical spec for hi-res max"
  },
+  "qualityMp3": "MP3",
+  "@qualityMp3": {
+    "description": "Quality option - MP3 lossy format"
+  },
+  "qualityMp3Subtitle": "320kbps (converted from FLAC)",
+  "@qualityMp3Subtitle": {
+    "description": "Technical spec for MP3"
+  },
+  "enableMp3Option": "Enable MP3 Option",
+  "@enableMp3Option": {
+    "description": "Setting - enable MP3 quality option"
+  },
+  "enableMp3OptionSubtitleOn": "MP3 quality option is available",
+  "@enableMp3OptionSubtitleOn": {
+    "description": "Subtitle when MP3 is enabled"
+  },
+  "enableMp3OptionSubtitleOff": "Downloads FLAC then converts to 320kbps MP3",
+  "@enableMp3OptionSubtitleOff": {
+    "description": "Subtitle when MP3 is disabled"
+  },
  "qualityNote": "Actual quality depends on track availability from the service",
  "@qualityNote": {
    "description": "Note about quality availability"
@@ -2516,6 +2633,14 @@
  "@albumFolderYearAlbumSubtitle": {
    "description": "Folder structure example"
  },
+  "albumFolderArtistAlbumSingles": "Artist / Album + Singles",
+  "@albumFolderArtistAlbumSingles": {
+    "description": "Album folder option with singles inside artist"
+  },
+  "albumFolderArtistAlbumSinglesSubtitle": "Artist/Album/ and Artist/Singles/",
+  "@albumFolderArtistAlbumSinglesSubtitle": {
+    "description": "Folder structure example"
+  },
  "downloadedAlbumDeleteSelected": "Delete Selected",
  "@downloadedAlbumDeleteSelected": {
    "description": "Button - delete selected tracks"
@@ -2572,6 +2697,16 @@
  "@downloadedAlbumSelectToDelete": {
    "description": "Placeholder when nothing selected"
  },
+  "downloadedAlbumDiscHeader": "Disc {discNumber}",
+  "@downloadedAlbumDiscHeader": {
+    "description": "Header for disc separator in multi-disc albums",
+    "placeholders": {
+      "discNumber": {
+        "type": "int",
+        "example": "1"
+      }
+    }
+  },
  "utilityFunctions": "Utility Functions",
  "@utilityFunctions": {
    "description": "Extension capability - utility functions"
@@ -2611,5 +2746,123 @@
        "description": "Error message"
      }
    }
+  },
+  "discographyDownload": "Download Discography",
+  "@discographyDownload": {
+    "description": "Button - download artist discography"
+  },
+  "discographyDownloadAll": "Download All",
+  "@discographyDownloadAll": {
+    "description": "Option - download entire discography"
+  },
+  "discographyDownloadAllSubtitle": "{count} tracks from {albumCount} releases",
+  "@discographyDownloadAllSubtitle": {
+    "description": "Subtitle showing total tracks and albums",
+    "placeholders": {
+      "count": {
+        "type": "int"
+      },
+      "albumCount": {
+        "type": "int"
+      }
+    }
+  },
+  "discographyAlbumsOnly": "Albums Only",
+  "@discographyAlbumsOnly": {
+    "description": "Option - download only albums"
+  },
+  "discographyAlbumsOnlySubtitle": "{count} tracks from {albumCount} albums",
+  "@discographyAlbumsOnlySubtitle": {
+    "description": "Subtitle showing album tracks count",
+    "placeholders": {
+      "count": {
+        "type": "int"
+      },
+      "albumCount": {
+        "type": "int"
+      }
+    }
+  },
+  "discographySinglesOnly": "Singles & EPs Only",
+  "@discographySinglesOnly": {
+    "description": "Option - download only singles"
+  },
+  "discographySinglesOnlySubtitle": "{count} tracks from {albumCount} singles",
+  "@discographySinglesOnlySubtitle": {
+    "description": "Subtitle showing singles tracks count",
+    "placeholders": {
+      "count": {
+        "type": "int"
+      },
+      "albumCount": {
+        "type": "int"
+      }
+    }
+  },
+  "discographySelectAlbums": "Select Albums...",
+  "@discographySelectAlbums": {
+    "description": "Option - manually select albums to download"
+  },
+  "discographySelectAlbumsSubtitle": "Choose specific albums or singles",
+  "@discographySelectAlbumsSubtitle": {
+    "description": "Subtitle for select albums option"
+  },
+  "discographyFetchingTracks": "Fetching tracks...",
+  "@discographyFetchingTracks": {
+    "description": "Progress - fetching album tracks"
+  },
+  "discographyFetchingAlbum": "Fetching {current} of {total}...",
+  "@discographyFetchingAlbum": {
+    "description": "Progress - fetching specific album",
+    "placeholders": {
+      "current": {
+        "type": "int"
+      },
+      "total": {
+        "type": "int"
+      }
+    }
+  },
+  "discographySelectedCount": "{count} selected",
+  "@discographySelectedCount": {
+    "description": "Selection count badge",
+    "placeholders": {
+      "count": {
+        "type": "int"
+      }
+    }
+  },
+  "discographyDownloadSelected": "Download Selected",
+  "@discographyDownloadSelected": {
+    "description": "Button - download selected albums"
+  },
+  "discographyAddedToQueue": "Added {count} tracks to queue",
+  "@discographyAddedToQueue": {
+    "description": "Snackbar - tracks added from discography",
+    "placeholders": {
+      "count": {
+        "type": "int"
+      }
+    }
+  },
+  "discographySkippedDownloaded": "{added} added, {skipped} already downloaded",
+  "@discographySkippedDownloaded": {
+    "description": "Snackbar - with skipped tracks count",
+    "placeholders": {
+      "added": {
+        "type": "int"
+      },
+      "skipped": {
+        "type": "int"
+      }
+    }
+  },
+  "discographyNoAlbums": "No albums available",
+  "@discographyNoAlbums": {
+    "description": "Error - no albums found for artist"
+  },
+  "discographyFailedToFetch": "Failed to fetch some albums",
+  "@discographyFailedToFetch": {
+    "description": "Error - some albums failed to load"
  }
 }
@@ -127,6 +127,10 @@
  "@historyNoSinglesSubtitle": {
    "description": "Empty state subtitle for singles filter"
  },
+  "historySearchHint": "Search history...",
+  "@historySearchHint": {
+    "description": "Search bar placeholder in history"
+  },
  "settingsTitle": "Settings",
  "@settingsTitle": {
    "description": "Settings screen title"
@@ -512,6 +516,10 @@
  "@aboutLogoArtist": {
    "description": "Role description for logo artist"
  },
+  "aboutTranslators": "Translators",
+  "@aboutTranslators": {
+    "description": "Section for translators"
+  },
  "aboutSpecialThanks": "Special Thanks",
  "@aboutSpecialThanks": {
    "description": "Section for special thanks"
@@ -544,6 +552,26 @@
  "@aboutFeatureRequestSubtitle": {
    "description": "Subtitle for feature request"
  },
+  "aboutTelegramChannel": "Telegram Channel",
+  "@aboutTelegramChannel": {
+    "description": "Link to Telegram channel"
+  },
+  "aboutTelegramChannelSubtitle": "Announcements and updates",
+  "@aboutTelegramChannelSubtitle": {
+    "description": "Subtitle for Telegram channel"
+  },
+  "aboutTelegramChat": "Telegram Community",
+  "@aboutTelegramChat": {
+    "description": "Link to Telegram chat group"
+  },
+  "aboutTelegramChatSubtitle": "Chat with other users",
+  "@aboutTelegramChatSubtitle": {
+    "description": "Subtitle for Telegram chat"
+  },
+  "aboutSocial": "Social",
+  "@aboutSocial": {
+    "description": "Section for social links"
+  },
  "aboutSupport": "Support",
  "@aboutSupport": {
    "description": "Section for support/donation links"
@@ -1122,6 +1150,15 @@
    "description": "Dialog title - import CSV playlist"
  },
  "dialogImportPlaylistMessage": "Found {count} tracks in CSV. Add them to download queue?",
+  "csvImportTracks": "{count} tracks from CSV",
+  "@csvImportTracks": {
+    "description": "Label shown in quality picker for CSV import",
+    "placeholders": {
+      "count": {
+        "type": "int"
+      }
+    }
+  },
  "@dialogImportPlaylistMessage": {
    "description": "Dialog message - import playlist confirmation",
    "placeholders": {
@@ -1851,6 +1888,42 @@
  "@sectionFileSettings": {
    "description": "Settings section header"
  },
+  "sectionLyrics": "Lyrics",
+  "@sectionLyrics": {
+    "description": "Settings section header"
+  },
+  "lyricsMode": "Lyrics Mode",
+  "@lyricsMode": {
+    "description": "Setting - how to save lyrics"
+  },
+  "lyricsModeDescription": "Choose how lyrics are saved with your downloads",
+  "@lyricsModeDescription": {
+    "description": "Lyrics mode picker description"
+  },
+  "lyricsModeEmbed": "Embed in file",
+  "@lyricsModeEmbed": {
+    "description": "Lyrics mode option - embed in audio file"
+  },
+  "lyricsModeEmbedSubtitle": "Lyrics stored inside FLAC metadata",
+  "@lyricsModeEmbedSubtitle": {
+    "description": "Subtitle for embed option"
+  },
+  "lyricsModeExternal": "External .lrc file",
+  "@lyricsModeExternal": {
+    "description": "Lyrics mode option - separate LRC file"
+  },
+  "lyricsModeExternalSubtitle": "Separate .lrc file for players like Samsung Music",
+  "@lyricsModeExternalSubtitle": {
+    "description": "Subtitle for external option"
+  },
+  "lyricsModeBoth": "Both",
+  "@lyricsModeBoth": {
+    "description": "Lyrics mode option - embed and external"
+  },
+  "lyricsModeBothSubtitle": "Embed and save .lrc file",
+  "@lyricsModeBothSubtitle": {
+    "description": "Subtitle for both option"
+  },
  "sectionColor": "Color",
  "@sectionColor": {
    "description": "Settings section header"
@@ -1997,6 +2070,18 @@
  "@trackReleaseDate": {
    "description": "Metadata label - release date"
  },
+  "trackGenre": "Genre",
+  "@trackGenre": {
+    "description": "Metadata label - music genre"
+  },
+  "trackLabel": "Label",
+  "@trackLabel": {
+    "description": "Metadata label - record label"
+  },
+  "trackCopyright": "Copyright",
+  "@trackCopyright": {
+    "description": "Metadata label - copyright information"
+  },
  "trackDownloaded": "Downloaded",
  "@trackDownloaded": {
    "description": "Metadata label - download date"
@@ -2017,6 +2102,18 @@
  "@trackLyricsLoadFailed": {
    "description": "Message when lyrics loading fails"
  },
+  "trackEmbedLyrics": "Embed Lyrics",
+  "@trackEmbedLyrics": {
+    "description": "Action - embed lyrics into audio file"
+  },
+  "trackLyricsEmbedded": "Lyrics embedded successfully",
+  "@trackLyricsEmbedded": {
+    "description": "Snackbar - lyrics saved to file"
+  },
+  "trackInstrumental": "Instrumental track",
+  "@trackInstrumental": {
+    "description": "Message when track is instrumental (no lyrics)"
+  },
  "trackCopiedToClipboard": "Copied to clipboard",
  "@trackCopiedToClipboard": {
    "description": "Snackbar - content copied"
@@ -2328,6 +2425,26 @@
  "@qualityHiResFlacMaxSubtitle": {
    "description": "Technical spec for hi-res max"
  },
+  "qualityMp3": "MP3",
+  "@qualityMp3": {
+    "description": "Quality option - MP3 lossy format"
+  },
+  "qualityMp3Subtitle": "320kbps (converted from FLAC)",
+  "@qualityMp3Subtitle": {
+    "description": "Technical spec for MP3"
+  },
+  "enableMp3Option": "Enable MP3 Option",
+  "@enableMp3Option": {
+    "description": "Setting - enable MP3 quality option"
+  },
+  "enableMp3OptionSubtitleOn": "MP3 quality option is available",
+  "@enableMp3OptionSubtitleOn": {
+    "description": "Subtitle when MP3 is enabled"
+  },
+  "enableMp3OptionSubtitleOff": "Downloads FLAC then converts to 320kbps MP3",
+  "@enableMp3OptionSubtitleOff": {
+    "description": "Subtitle when MP3 is disabled"
+  },
  "qualityNote": "Actual quality depends on track availability from the service",
  "@qualityNote": {
    "description": "Note about quality availability"
@@ -2516,6 +2633,14 @@
  "@albumFolderYearAlbumSubtitle": {
    "description": "Folder structure example"
  },
+  "albumFolderArtistAlbumSingles": "Artist / Album + Singles",
+  "@albumFolderArtistAlbumSingles": {
+    "description": "Album folder option with singles inside artist"
+  },
+  "albumFolderArtistAlbumSinglesSubtitle": "Artist/Album/ and Artist/Singles/",
+  "@albumFolderArtistAlbumSinglesSubtitle": {
+    "description": "Folder structure example"
+  },
  "downloadedAlbumDeleteSelected": "Delete Selected",
  "@downloadedAlbumDeleteSelected": {
    "description": "Button - delete selected tracks"
@@ -2572,6 +2697,16 @@
  "@downloadedAlbumSelectToDelete": {
    "description": "Placeholder when nothing selected"
  },
+  "downloadedAlbumDiscHeader": "Disc {discNumber}",
+  "@downloadedAlbumDiscHeader": {
+    "description": "Header for disc separator in multi-disc albums",
+    "placeholders": {
+      "discNumber": {
+        "type": "int",
+        "example": "1"
+      }
+    }
+  },
  "utilityFunctions": "Utility Functions",
  "@utilityFunctions": {
    "description": "Extension capability - utility functions"
@@ -2611,5 +2746,123 @@
        "description": "Error message"
      }
    }
+  },
+  "discographyDownload": "Download Discography",
+  "@discographyDownload": {
+    "description": "Button - download artist discography"
+  },
+  "discographyDownloadAll": "Download All",
+  "@discographyDownloadAll": {
+    "description": "Option - download entire discography"
+  },
+  "discographyDownloadAllSubtitle": "{count} tracks from {albumCount} releases",
+  "@discographyDownloadAllSubtitle": {
+    "description": "Subtitle showing total tracks and albums",
+    "placeholders": {
+      "count": {
+        "type": "int"
+      },
+      "albumCount": {
+        "type": "int"
+      }
+    }
+  },
+  "discographyAlbumsOnly": "Albums Only",
+  "@discographyAlbumsOnly": {
+    "description": "Option - download only albums"
+  },
+  "discographyAlbumsOnlySubtitle": "{count} tracks from {albumCount} albums",
+  "@discographyAlbumsOnlySubtitle": {
+    "description": "Subtitle showing album tracks count",
+    "placeholders": {
+      "count": {
+        "type": "int"
+      },
+      "albumCount": {
+        "type": "int"
+      }
+    }
+  },
+  "discographySinglesOnly": "Singles & EPs Only",
+  "@discographySinglesOnly": {
+    "description": "Option - download only singles"
+  },
+  "discographySinglesOnlySubtitle": "{count} tracks from {albumCount} singles",
+  "@discographySinglesOnlySubtitle": {
+    "description": "Subtitle showing singles tracks count",
+    "placeholders": {
+      "count": {
+        "type": "int"
+      },
+      "albumCount": {
+        "type": "int"
+      }
+    }
+  },
+  "discographySelectAlbums": "Select Albums...",
+  "@discographySelectAlbums": {
+    "description": "Option - manually select albums to download"
+  },
+  "discographySelectAlbumsSubtitle": "Choose specific albums or singles",
+  "@discographySelectAlbumsSubtitle": {
+    "description": "Subtitle for select albums option"
+  },
+  "discographyFetchingTracks": "Fetching tracks...",
+  "@discographyFetchingTracks": {
+    "description": "Progress - fetching album tracks"
+  },
+  "discographyFetchingAlbum": "Fetching {current} of {total}...",
+  "@discographyFetchingAlbum": {
+    "description": "Progress - fetching specific album",
+    "placeholders": {
+      "current": {
+        "type": "int"
+      },
+      "total": {
+        "type": "int"
+      }
+    }
+  },
+  "discographySelectedCount": "{count} selected",
+  "@discographySelectedCount": {
+    "description": "Selection count badge",
+    "placeholders": {
+      "count": {
+        "type": "int"
+      }
+    }
+  },
+  "discographyDownloadSelected": "Download Selected",
+  "@discographyDownloadSelected": {
+    "description": "Button - download selected albums"
+  },
+  "discographyAddedToQueue": "Added {count} tracks to queue",
+  "@discographyAddedToQueue": {
+    "description": "Snackbar - tracks added from discography",
+    "placeholders": {
+      "count": {
+        "type": "int"
+      }
+    }
+  },
+  "discographySkippedDownloaded": "{added} added, {skipped} already downloaded",
+  "@discographySkippedDownloaded": {
+    "description": "Snackbar - with skipped tracks count",
+    "placeholders": {
+      "added": {
+        "type": "int"
+      },
+      "skipped": {
+        "type": "int"
+      }
+    }
+  },
+  "discographyNoAlbums": "No albums available",
+  "@discographyNoAlbums": {
+    "description": "Error - no albums found for artist"
+  },
+  "discographyFailedToFetch": "Failed to fetch some albums",
+  "@discographyFailedToFetch": {
+    "description": "Error - some albums failed to load"
  }
 }
@@ -835,19 +835,19 @@
  "@setupIosEmptyFolderWarning": {
    "description": "iOS folder selection warning"
  },
-  "setupDownloadInFlac": "Download Spotify tracks in FLAC",
+  "setupDownloadInFlac": "Baixe faixas do Spotify em FLAC",
  "@setupDownloadInFlac": {
    "description": "App tagline in setup"
  },
-  "setupStepStorage": "Storage",
+  "setupStepStorage": "Armazenamento",
  "@setupStepStorage": {
    "description": "Setup step indicator - storage"
  },
-  "setupStepNotification": "Notification",
+  "setupStepNotification": "Notificação",
  "@setupStepNotification": {
    "description": "Setup step indicator - notification"
  },
-  "setupStepFolder": "Folder",
+  "setupStepFolder": "Pasta",
  "@setupStepFolder": {
    "description": "Setup step indicator - folder"
  },
@@ -855,19 +855,19 @@
  "@setupStepSpotify": {
    "description": "Setup step indicator - Spotify API"
  },
-  "setupStepPermission": "Permission",
+  "setupStepPermission": "Permissão",
  "@setupStepPermission": {
    "description": "Setup step indicator - permission"
  },
-  "setupStorageGranted": "Storage Permission Granted!",
+  "setupStorageGranted": "Permissão de Armazenamento Concedida!",
  "@setupStorageGranted": {
    "description": "Success message for storage permission"
  },
-  "setupStorageRequired": "Storage Permission Required",
+  "setupStorageRequired": "Permissão de Armazenamento Necessária",
  "@setupStorageRequired": {
    "description": "Title when storage permission needed"
  },
-  "setupStorageDescription": "SpotiFLAC needs storage permission to save your downloaded music files.",
+  "setupStorageDescription": "O SpotiFLAC precisa de permissão de armazenamento para salvar os seus arquivos de música baixados.",
  "@setupStorageDescription": {
    "description": "Explanation for storage permission"
  },
@@ -1071,23 +1071,23 @@
  "@dialogClearAllDownloads": {
    "description": "Dialog message - clear downloads confirmation"
  },
-  "dialogRemoveFromDevice": "Remove from device?",
+  "dialogRemoveFromDevice": "Remover do dispositivo?",
  "@dialogRemoveFromDevice": {
    "description": "Dialog title - delete file confirmation"
  },
-  "dialogRemoveExtension": "Remove Extension",
+  "dialogRemoveExtension": "Remover Extensão",
  "@dialogRemoveExtension": {
    "description": "Dialog title - uninstall extension"
  },
-  "dialogRemoveExtensionMessage": "Are you sure you want to remove this extension? This cannot be undone.",
+  "dialogRemoveExtensionMessage": "Tem certeza de que deseja remover esta extensão? Isso não pode ser desfeito.",
  "@dialogRemoveExtensionMessage": {
    "description": "Dialog message - uninstall confirmation"
  },
-  "dialogUninstallExtension": "Uninstall Extension?",
+  "dialogUninstallExtension": "Desinstalar Extensão?",
  "@dialogUninstallExtension": {
    "description": "Dialog title - uninstall extension"
  },
-  "dialogUninstallExtensionMessage": "Are you sure you want to remove {extensionName}?",
+  "dialogUninstallExtensionMessage": "Tem certeza de que deseja remover {extensionName}?",
  "@dialogUninstallExtensionMessage": {
    "description": "Dialog message - uninstall specific extension",
    "placeholders": {
@@ -1096,19 +1096,19 @@
      }
    }
  },
-  "dialogClearHistoryTitle": "Clear History",
+  "dialogClearHistoryTitle": "Limpar Histórico",
  "@dialogClearHistoryTitle": {
    "description": "Dialog title - clear download history"
  },
-  "dialogClearHistoryMessage": "Are you sure you want to clear all download history? This cannot be undone.",
+  "dialogClearHistoryMessage": "Tem certeza de que deseja limpar todo o histórico de downloads? Isso não pode ser desfeito.",
  "@dialogClearHistoryMessage": {
    "description": "Dialog message - clear history confirmation"
  },
-  "dialogDeleteSelectedTitle": "Delete Selected",
+  "dialogDeleteSelectedTitle": "Apagar Selecionados",
  "@dialogDeleteSelectedTitle": {
    "description": "Dialog title - delete selected items"
  },
-  "dialogDeleteSelectedMessage": "Delete {count} {count, plural, =1{track} other{tracks}} from history?\n\nThis will also delete the files from storage.",
+  "dialogDeleteSelectedMessage": "Apagar {count} {count, plural, =1{faixa} other{faixas}} do histórico?\n\nIsso também apagará os arquivos do armazenamento.",
  "@dialogDeleteSelectedMessage": {
    "description": "Dialog message - delete selected tracks",
    "placeholders": {
@@ -1117,11 +1117,11 @@
      }
    }
  },
-  "dialogImportPlaylistTitle": "Import Playlist",
+  "dialogImportPlaylistTitle": "Importar Playlist",
  "@dialogImportPlaylistTitle": {
    "description": "Dialog title - import CSV playlist"
  },
-  "dialogImportPlaylistMessage": "Found {count} tracks in CSV. Add them to download queue?",
+  "dialogImportPlaylistMessage": "Encontradas {count} faixas no CSV. Adicionar à fila de download?",
  "@dialogImportPlaylistMessage": {
    "description": "Dialog message - import playlist confirmation",
    "placeholders": {
@@ -1130,7 +1130,7 @@
      }
    }
  },
-  "snackbarAddedToQueue": "Added \"{trackName}\" to queue",
+  "snackbarAddedToQueue": "\"{trackName}\" adicionada à fila",
  "@snackbarAddedToQueue": {
    "description": "Snackbar - track added to download queue",
    "placeholders": {
@@ -1139,7 +1139,7 @@
      }
    }
  },
-  "snackbarAddedTracksToQueue": "Added {count} tracks to queue",
+  "snackbarAddedTracksToQueue": "{count} faixas adicionadas à fila",
  "@snackbarAddedTracksToQueue": {
    "description": "Snackbar - multiple tracks added to queue",
    "placeholders": {
@@ -1148,7 +1148,7 @@
      }
    }
  },
-  "snackbarAlreadyDownloaded": "\"{trackName}\" already downloaded",
+  "snackbarAlreadyDownloaded": "\"{trackName}\" já foi baixada",
  "@snackbarAlreadyDownloaded": {
    "description": "Snackbar - track already exists",
    "placeholders": {
@@ -1157,19 +1157,19 @@
      }
    }
  },
-  "snackbarHistoryCleared": "History cleared",
+  "snackbarHistoryCleared": "Histórico limpo",
  "@snackbarHistoryCleared": {
    "description": "Snackbar - history deleted"
  },
-  "snackbarCredentialsSaved": "Credentials saved",
+  "snackbarCredentialsSaved": "Credenciais salvas",
  "@snackbarCredentialsSaved": {
    "description": "Snackbar - Spotify credentials saved"
  },
-  "snackbarCredentialsCleared": "Credentials cleared",
+  "snackbarCredentialsCleared": "Credenciais removidas",
  "@snackbarCredentialsCleared": {
    "description": "Snackbar - Spotify credentials removed"
  },
-  "snackbarDeletedTracks": "Deleted {count} {count, plural, =1{track} other{tracks}}",
+  "snackbarDeletedTracks": "{count} {count, plural, =1{faixa apagada} other{faixas apagadas}}",
  "@snackbarDeletedTracks": {
    "description": "Snackbar - tracks deleted",
    "placeholders": {
@@ -1178,7 +1178,7 @@
      }
    }
  },
-  "snackbarCannotOpenFile": "Cannot open file: {error}",
+  "snackbarCannotOpenFile": "Não foi possível abrir o arquivo: {error}",
  "@snackbarCannotOpenFile": {
    "description": "Snackbar - file open error",
    "placeholders": {
@@ -1187,15 +1187,15 @@
      }
    }
  },
-  "snackbarFillAllFields": "Please fill all fields",
+  "snackbarFillAllFields": "Por favor, preencha todos os campos",
  "@snackbarFillAllFields": {
    "description": "Snackbar - validation error"
  },
-  "snackbarViewQueue": "View Queue",
+  "snackbarViewQueue": "Ver Fila",
  "@snackbarViewQueue": {
    "description": "Snackbar action - view download queue"
  },
-  "snackbarFailedToLoad": "Failed to load: {error}",
+  "snackbarFailedToLoad": "Falha ao carregar: {error}",
  "@snackbarFailedToLoad": {
    "description": "Snackbar - loading error",
    "placeholders": {
@@ -1204,7 +1204,7 @@
      }
    }
  },
-  "snackbarUrlCopied": "{platform} URL copied to clipboard",
+  "snackbarUrlCopied": "URL do {platform} copiada para a área de transferência",
  "@snackbarUrlCopied": {
    "description": "Snackbar - URL copied",
    "placeholders": {
@@ -1214,23 +1214,23 @@
      }
    }
  },
-  "snackbarFileNotFound": "File not found",
+  "snackbarFileNotFound": "Arquivo não encontrado",
  "@snackbarFileNotFound": {
    "description": "Snackbar - file doesn't exist"
  },
-  "snackbarSelectExtFile": "Please select a .spotiflac-ext file",
+  "snackbarSelectExtFile": "Por favor, selecione um arquivo .spotiflac-ext",
  "@snackbarSelectExtFile": {
    "description": "Snackbar - wrong file type selected"
  },
-  "snackbarProviderPrioritySaved": "Provider priority saved",
+  "snackbarProviderPrioritySaved": "Prioridade de provedor salva",
  "@snackbarProviderPrioritySaved": {
    "description": "Snackbar - provider order saved"
  },
-  "snackbarMetadataProviderSaved": "Metadata provider priority saved",
+  "snackbarMetadataProviderSaved": "Prioridade de provedor de metadados salva",
  "@snackbarMetadataProviderSaved": {
    "description": "Snackbar - metadata provider order saved"
  },
-  "snackbarExtensionInstalled": "{extensionName} installed.",
+  "snackbarExtensionInstalled": "{extensionName} instalada.",
  "@snackbarExtensionInstalled": {
    "description": "Snackbar - extension installed successfully",
    "placeholders": {
@@ -1239,7 +1239,7 @@
      }
    }
  },
-  "snackbarExtensionUpdated": "{extensionName} updated.",
+  "snackbarExtensionUpdated": "{extensionName} atualizada.",
  "@snackbarExtensionUpdated": {
    "description": "Snackbar - extension updated successfully",
    "placeholders": {
@@ -1248,23 +1248,23 @@
      }
    }
  },
-  "snackbarFailedToInstall": "Failed to install extension",
+  "snackbarFailedToInstall": "Falha ao instalar extensão",
  "@snackbarFailedToInstall": {
    "description": "Snackbar - extension install error"
  },
-  "snackbarFailedToUpdate": "Failed to update extension",
+  "snackbarFailedToUpdate": "Falha ao atualizar extensão",
  "@snackbarFailedToUpdate": {
    "description": "Snackbar - extension update error"
  },
-  "errorRateLimited": "Rate Limited",
+  "errorRateLimited": "Taxa Limitada",
  "@errorRateLimited": {
    "description": "Error title - too many requests"
  },
-  "errorRateLimitedMessage": "Too many requests. Please wait a moment before searching again.",
+  "errorRateLimitedMessage": "Muitas solicitações. Por favor, aguarde um momento antes de pesquisar novamente.",
  "@errorRateLimitedMessage": {
    "description": "Error message - rate limit explanation"
  },
-  "errorFailedToLoad": "Failed to load {item}",
+  "errorFailedToLoad": "Falha ao carregar {item}",
  "@errorFailedToLoad": {
    "description": "Error message - loading failed",
    "placeholders": {
@@ -1274,11 +1274,11 @@
      }
    }
  },
-  "errorNoTracksFound": "No tracks found",
+  "errorNoTracksFound": "Nenhuma faixa encontrada",
  "@errorNoTracksFound": {
    "description": "Error - search returned no results"
  },
-  "errorMissingExtensionSource": "Cannot load {item}: missing extension source",
+  "errorMissingExtensionSource": "Não foi possível carregar {item}: fonte de extensão ausente",
  "@errorMissingExtensionSource": {
    "description": "Error - extension source not available",
    "placeholders": {
@@ -1287,23 +1287,23 @@
      }
    }
  },
-  "statusQueued": "Queued",
+  "statusQueued": "Na Fila",
  "@statusQueued": {
    "description": "Download status - waiting in queue"
  },
-  "statusDownloading": "Downloading",
+  "statusDownloading": "Baixando",
  "@statusDownloading": {
    "description": "Download status - in progress"
  },
-  "statusFinalizing": "Finalizing",
+  "statusFinalizing": "Finalizando",
  "@statusFinalizing": {
    "description": "Download status - writing metadata"
  },
-  "statusCompleted": "Completed",
+  "statusCompleted": "Concluído",
  "@statusCompleted": {
    "description": "Download status - finished"
  },
-  "statusFailed": "Failed",
+  "statusFailed": "Falhou",
  "@statusFailed": {
    "description": "Download status - error occurred"
  },
@@ -1735,19 +1735,19 @@
  "@logNetworkErrorDescription": {
    "description": "Network error explanation"
  },
-  "logNetworkErrorSuggestion": "Check your internet connection",
+  "logNetworkErrorSuggestion": "Verifique a sua conexão com a internet",
  "@logNetworkErrorSuggestion": {
    "description": "Network error fix suggestion"
  },
-  "logTrackNotFoundDescription": "Some tracks could not be found on download services",
+  "logTrackNotFoundDescription": "Algumas faixas não foram encontradas nos serviços de download",
  "@logTrackNotFoundDescription": {
    "description": "Track not found explanation"
  },
-  "logTrackNotFoundSuggestion": "The track may not be available in lossless quality",
+  "logTrackNotFoundSuggestion": "A faixa pode não estar disponível em qualidade lossless",
  "@logTrackNotFoundSuggestion": {
    "description": "Track not found explanation"
  },
-  "logTotalErrors": "Total errors: {count}",
+  "logTotalErrors": "Total de erros: {count}",
  "@logTotalErrors": {
    "description": "Error count display",
    "placeholders": {
@@ -1756,7 +1756,7 @@
      }
    }
  },
-  "logAffected": "Affected: {domains}",
+  "logAffected": "Afetados: {domains}",
  "@logAffected": {
    "description": "Affected domains display",
    "placeholders": {
@@ -1765,7 +1765,7 @@
      }
    }
  },
-  "logEntriesFiltered": "Entries ({count} filtered)",
+  "logEntriesFiltered": "Entradas ({count} filtradas)",
  "@logEntriesFiltered": {
    "description": "Log count with filter active",
    "placeholders": {
@@ -1774,7 +1774,7 @@
      }
    }
  },
-  "logEntries": "Entries ({count})",
+  "logEntries": "Entradas ({count})",
  "@logEntries": {
    "description": "Total log count",
    "placeholders": {
@@ -1783,11 +1783,11 @@
      }
    }
  },
-  "credentialsTitle": "Spotify Credentials",
+  "credentialsTitle": "Credenciais do Spotify",
  "@credentialsTitle": {
    "description": "Credentials dialog title"
  },
-  "credentialsDescription": "Enter your Client ID and Secret to use your own Spotify application quota.",
+  "credentialsDescription": "Insira o seu Client ID e Secret para usar a sua própria cota de aplicativo do Spotify.",
  "@credentialsDescription": {
    "description": "Credentials dialog explanation"
  },
@@ -2001,35 +2001,35 @@
  "@trackDownloaded": {
    "description": "Metadata label - download date"
  },
-  "trackCopyLyrics": "Copy lyrics",
+  "trackCopyLyrics": "Copiar letras",
  "@trackCopyLyrics": {
    "description": "Action - copy lyrics to clipboard"
  },
-  "trackLyricsNotAvailable": "Lyrics not available for this track",
+  "trackLyricsNotAvailable": "Letras não disponíveis para esta faixa",
  "@trackLyricsNotAvailable": {
    "description": "Message when lyrics not found"
  },
-  "trackLyricsTimeout": "Request timed out. Try again later.",
+  "trackLyricsTimeout": "A solicitação expirou. Tente novamente mais tarde.",
  "@trackLyricsTimeout": {
    "description": "Message when lyrics request times out"
  },
-  "trackLyricsLoadFailed": "Failed to load lyrics",
+  "trackLyricsLoadFailed": "Falha ao carregar letras",
  "@trackLyricsLoadFailed": {
    "description": "Message when lyrics loading fails"
  },
-  "trackCopiedToClipboard": "Copied to clipboard",
+  "trackCopiedToClipboard": "Copiado para a área de transferência",
  "@trackCopiedToClipboard": {
    "description": "Snackbar - content copied"
  },
-  "trackDeleteConfirmTitle": "Remove from device?",
+  "trackDeleteConfirmTitle": "Remover do dispositivo?",
  "@trackDeleteConfirmTitle": {
    "description": "Delete confirmation title"
  },
-  "trackDeleteConfirmMessage": "This will permanently delete the downloaded file and remove it from your history.",
+  "trackDeleteConfirmMessage": "Isso apagará permanentemente o arquivo baixado e o removerá do seu histórico.",
  "@trackDeleteConfirmMessage": {
    "description": "Delete confirmation message"
  },
-  "trackCannotOpen": "Cannot open: {message}",
+  "trackCannotOpen": "Não foi possível abrir: {message}",
  "@trackCannotOpen": {
    "description": "Error opening file",
    "placeholders": {
@@ -2038,15 +2038,15 @@
      }
    }
  },
-  "dateToday": "Today",
+  "dateToday": "Hoje",
  "@dateToday": {
    "description": "Relative date - today"
  },
-  "dateYesterday": "Yesterday",
+  "dateYesterday": "Ontem",
  "@dateYesterday": {
    "description": "Relative date - yesterday"
  },
-  "dateDaysAgo": "{count} days ago",
+  "dateDaysAgo": "Há {count} dias",
  "@dateDaysAgo": {
    "description": "Relative date - days ago",
    "placeholders": {
@@ -2055,7 +2055,7 @@
      }
    }
  },
-  "dateWeeksAgo": "{count} weeks ago",
+  "dateWeeksAgo": "Há {count} semanas",
  "@dateWeeksAgo": {
    "description": "Relative date - weeks ago",
    "placeholders": {
@@ -2064,7 +2064,7 @@
      }
    }
  },
-  "dateMonthsAgo": "{count} months ago",
+  "dateMonthsAgo": "Há {count} meses",
  "@dateMonthsAgo": {
    "description": "Relative date - months ago",
    "placeholders": {
@@ -2073,27 +2073,27 @@
      }
    }
  },
-  "concurrentSequential": "Sequential",
+  "concurrentSequential": "Sequencial",
  "@concurrentSequential": {
    "description": "Download mode - one at a time"
  },
-  "concurrentParallel2": "2 Parallel",
+  "concurrentParallel2": "2 Paralelos",
  "@concurrentParallel2": {
    "description": "Download mode - 2 simultaneous"
  },
-  "concurrentParallel3": "3 Parallel",
+  "concurrentParallel3": "3 Paralelos",
  "@concurrentParallel3": {
    "description": "Download mode - 3 simultaneous"
  },
-  "tapToSeeError": "Tap to see error details",
+  "tapToSeeError": "Toque para ver detalhes do erro",
  "@tapToSeeError": {
    "description": "Tooltip for failed download"
  },
-  "storeFilterAll": "All",
+  "storeFilterAll": "Todos",
  "@storeFilterAll": {
    "description": "Store filter - all extensions"
  },
-  "storeFilterMetadata": "Metadata",
+  "storeFilterMetadata": "Metadados",
  "@storeFilterMetadata": {
    "description": "Store filter - metadata providers"
  },
@@ -2101,43 +2101,43 @@
  "@storeFilterDownload": {
    "description": "Store filter - download providers"
  },
-  "storeFilterUtility": "Utility",
+  "storeFilterUtility": "Utilitário",
  "@storeFilterUtility": {
    "description": "Store filter - utility extensions"
  },
-  "storeFilterLyrics": "Lyrics",
+  "storeFilterLyrics": "Letras",
  "@storeFilterLyrics": {
    "description": "Store filter - lyrics providers"
  },
-  "storeFilterIntegration": "Integration",
+  "storeFilterIntegration": "Integração",
  "@storeFilterIntegration": {
    "description": "Store filter - integrations"
  },
-  "storeClearFilters": "Clear filters",
+  "storeClearFilters": "Limpar filtros",
  "@storeClearFilters": {
    "description": "Button to clear all filters"
  },
-  "storeNoResults": "No extensions found",
+  "storeNoResults": "Nenhuma extensão encontrada",
  "@storeNoResults": {
    "description": "Empty state when no extensions match filters"
  },
-  "extensionProviderPriority": "Provider Priority",
+  "extensionProviderPriority": "Prioridade de Provedor",
  "@extensionProviderPriority": {
    "description": "Extension capability - provider priority"
  },
-  "extensionInstallButton": "Install Extension",
+  "extensionInstallButton": "Instalar Extensão",
  "@extensionInstallButton": {
    "description": "Button to install extension"
  },
-  "extensionDefaultProvider": "Default (Deezer/Spotify)",
+  "extensionDefaultProvider": "Padrão (Deezer/Spotify)",
  "@extensionDefaultProvider": {
    "description": "Default search provider option"
  },
-  "extensionDefaultProviderSubtitle": "Use built-in search",
+  "extensionDefaultProviderSubtitle": "Usar pesquisa integrada",
  "@extensionDefaultProviderSubtitle": {
    "description": "Subtitle for default provider"
  },
-  "extensionAuthor": "Author",
+  "extensionAuthor": "Autor",
  "@extensionAuthor": {
    "description": "Extension detail - author"
  },
@@ -2145,43 +2145,43 @@
  "@extensionId": {
    "description": "Extension detail - unique ID"
  },
-  "extensionError": "Error",
+  "extensionError": "Erro",
  "@extensionError": {
    "description": "Extension detail - error message"
  },
-  "extensionCapabilities": "Capabilities",
+  "extensionCapabilities": "Capacidades",
  "@extensionCapabilities": {
    "description": "Section header - extension features"
  },
-  "extensionMetadataProvider": "Metadata Provider",
+  "extensionMetadataProvider": "Provedor de Metadados",
  "@extensionMetadataProvider": {
    "description": "Capability - provides metadata"
  },
-  "extensionDownloadProvider": "Download Provider",
+  "extensionDownloadProvider": "Provedor de Download",
  "@extensionDownloadProvider": {
    "description": "Capability - provides downloads"
  },
-  "extensionLyricsProvider": "Lyrics Provider",
+  "extensionLyricsProvider": "Provedor de Letras",
  "@extensionLyricsProvider": {
    "description": "Capability - provides lyrics"
  },
-  "extensionUrlHandler": "URL Handler",
+  "extensionUrlHandler": "Manipulador de URL",
  "@extensionUrlHandler": {
    "description": "Capability - handles URLs"
  },
-  "extensionQualityOptions": "Quality Options",
+  "extensionQualityOptions": "Opções de Qualidade",
  "@extensionQualityOptions": {
    "description": "Capability - quality selection"
  },
-  "extensionPostProcessingHooks": "Post-Processing Hooks",
+  "extensionPostProcessingHooks": "Ganchos de Pós-Processamento",
  "@extensionPostProcessingHooks": {
    "description": "Capability - post-processing"
  },
-  "extensionPermissions": "Permissions",
+  "extensionPermissions": "Permissões",
  "@extensionPermissions": {
    "description": "Section header - required permissions"
  },
-  "extensionSettings": "Settings",
+  "extensionSettings": "Configurações",
  "@extensionSettings": {
    "description": "Section header - extension settings"
  },
@@ -2376,31 +2376,31 @@
  "@folderNone": {
    "description": "Folder option - no organization"
  },
-  "folderNoneSubtitle": "Save all files directly to download folder",
+  "folderNoneSubtitle": "Salvar todos os arquivos diretamente na pasta de download",
  "@folderNoneSubtitle": {
    "description": "Subtitle for no folder organization"
  },
-  "folderArtist": "Artist",
+  "folderArtist": "Artista",
  "@folderArtist": {
    "description": "Folder option - by artist"
  },
-  "folderArtistSubtitle": "Artist Name/filename",
+  "folderArtistSubtitle": "Nome do Artista/nome do arquivo",
  "@folderArtistSubtitle": {
    "description": "Folder structure example"
  },
-  "folderAlbum": "Album",
+  "folderAlbum": "Álbum",
  "@folderAlbum": {
    "description": "Folder option - by album"
  },
-  "folderAlbumSubtitle": "Album Name/filename",
+  "folderAlbumSubtitle": "Nome do Álbum/nome do arquivo",
  "@folderAlbumSubtitle": {
    "description": "Folder structure example"
  },
-  "folderArtistAlbum": "Artist/Album",
+  "folderArtistAlbum": "Artista/Álbum",
  "@folderArtistAlbum": {
    "description": "Folder option - nested"
  },
-  "folderArtistAlbumSubtitle": "Artist Name/Album Name/filename",
+  "folderArtistAlbumSubtitle": "Nome do Artista/Nome do Álbum/nome do arquivo",
  "@folderArtistAlbumSubtitle": {
    "description": "Folder structure example"
  },
@@ -2424,103 +2424,103 @@
  "@serviceSpotify": {
    "description": "Service name - DO NOT TRANSLATE"
  },
-  "appearanceAmoledDark": "AMOLED Dark",
+  "appearanceAmoledDark": "AMOLED Escuro",
  "@appearanceAmoledDark": {
    "description": "Theme option - pure black"
  },
-  "appearanceAmoledDarkSubtitle": "Pure black background",
+  "appearanceAmoledDarkSubtitle": "Fundo preto puro",
  "@appearanceAmoledDarkSubtitle": {
    "description": "Subtitle for AMOLED dark"
  },
-  "appearanceChooseAccentColor": "Choose Accent Color",
+  "appearanceChooseAccentColor": "Escolher Cor de Destaque",
  "@appearanceChooseAccentColor": {
    "description": "Color picker dialog title"
  },
-  "appearanceChooseTheme": "Theme Mode",
+  "appearanceChooseTheme": "Modo de Tema",
  "@appearanceChooseTheme": {
    "description": "Theme picker dialog title"
  },
-  "queueTitle": "Download Queue",
+  "queueTitle": "Fila de Download",
  "@queueTitle": {
    "description": "Queue screen title"
  },
-  "queueClearAll": "Clear All",
+  "queueClearAll": "Limpar Tudo",
  "@queueClearAll": {
    "description": "Button - clear all queue items"
  },
-  "queueClearAllMessage": "Are you sure you want to clear all downloads?",
+  "queueClearAllMessage": "Tem certeza de que deseja limpar todos os downloads?",
  "@queueClearAllMessage": {
    "description": "Clear queue confirmation"
  },
-  "queueEmpty": "No downloads in queue",
+  "queueEmpty": "Nenhum download na fila",
  "@queueEmpty": {
    "description": "Empty queue state title"
  },
-  "queueEmptySubtitle": "Add tracks from the home screen",
+  "queueEmptySubtitle": "Adicione faixas a partir da tela inicial",
  "@queueEmptySubtitle": {
    "description": "Empty queue state subtitle"
  },
-  "queueClearCompleted": "Clear completed",
+  "queueClearCompleted": "Limpar concluídos",
  "@queueClearCompleted": {
    "description": "Button - clear finished downloads"
  },
-  "queueDownloadFailed": "Download Failed",
+  "queueDownloadFailed": "Download Falhou",
  "@queueDownloadFailed": {
    "description": "Error dialog title"
  },
-  "queueTrackLabel": "Track:",
+  "queueTrackLabel": "Faixa:",
  "@queueTrackLabel": {
    "description": "Label in error dialog"
  },
-  "queueArtistLabel": "Artist:",
+  "queueArtistLabel": "Artista:",
  "@queueArtistLabel": {
    "description": "Label in error dialog"
  },
-  "queueErrorLabel": "Error:",
+  "queueErrorLabel": "Erro:",
  "@queueErrorLabel": {
    "description": "Label in error dialog"
  },
-  "queueUnknownError": "Unknown error",
+  "queueUnknownError": "Erro desconhecido",
  "@queueUnknownError": {
    "description": "Fallback error message"
  },
-  "albumFolderArtistAlbum": "Artist / Album",
+  "albumFolderArtistAlbum": "Artista / Álbum",
  "@albumFolderArtistAlbum": {
    "description": "Album folder option"
  },
-  "albumFolderArtistAlbumSubtitle": "Albums/Artist Name/Album Name/",
+  "albumFolderArtistAlbumSubtitle": "Álbuns/Nome do Artista/Nome do Álbum/",
  "@albumFolderArtistAlbumSubtitle": {
    "description": "Folder structure example"
  },
-  "albumFolderArtistYearAlbum": "Artist / [Year] Album",
+  "albumFolderArtistYearAlbum": "Artista / [Ano] Álbum",
  "@albumFolderArtistYearAlbum": {
    "description": "Album folder option with year"
  },
-  "albumFolderArtistYearAlbumSubtitle": "Albums/Artist Name/[2005] Album Name/",
+  "albumFolderArtistYearAlbumSubtitle": "Álbuns/Nome do Artista/[2005] Nome do Álbum/",
  "@albumFolderArtistYearAlbumSubtitle": {
    "description": "Folder structure example"
  },
-  "albumFolderAlbumOnly": "Album Only",
+  "albumFolderAlbumOnly": "Apenas Álbum",
  "@albumFolderAlbumOnly": {
    "description": "Album folder option"
  },
-  "albumFolderAlbumOnlySubtitle": "Albums/Album Name/",
+  "albumFolderAlbumOnlySubtitle": "Álbuns/Nome do Álbum/",
  "@albumFolderAlbumOnlySubtitle": {
    "description": "Folder structure example"
  },
-  "albumFolderYearAlbum": "[Year] Album",
+  "albumFolderYearAlbum": "[Ano] Álbum",
  "@albumFolderYearAlbum": {
    "description": "Album folder option with year"
  },
-  "albumFolderYearAlbumSubtitle": "Albums/[2005] Album Name/",
+  "albumFolderYearAlbumSubtitle": "Álbuns/[2005] Nome do Álbum/",
  "@albumFolderYearAlbumSubtitle": {
    "description": "Folder structure example"
  },
-  "downloadedAlbumDeleteSelected": "Delete Selected",
+  "downloadedAlbumDeleteSelected": "Apagar Selecionados",
  "@downloadedAlbumDeleteSelected": {
    "description": "Button - delete selected tracks"
  },
-  "downloadedAlbumDeleteMessage": "Delete {count} {count, plural, =1{track} other{tracks}} from this album?\n\nThis will also delete the files from storage.",
+  "downloadedAlbumDeleteMessage": "Apagar {count} {count, plural, =1{faixa} other{faixas}} deste álbum?\n\nIsso também apagará os arquivos do armazenamento.",
  "@downloadedAlbumDeleteMessage": {
    "description": "Delete confirmation with count",
    "placeholders": {
@@ -2529,11 +2529,11 @@
      }
    }
  },
-  "downloadedAlbumTracksHeader": "Tracks",
+  "downloadedAlbumTracksHeader": "Faixas",
  "@downloadedAlbumTracksHeader": {
    "description": "Section header for tracks"
  },
-  "downloadedAlbumDownloadedCount": "{count} downloaded",
+  "downloadedAlbumDownloadedCount": "{count} baixadas",
  "@downloadedAlbumDownloadedCount": {
    "description": "Downloaded tracks count badge",
    "placeholders": {
@@ -2542,7 +2542,7 @@
      }
    }
  },
-  "downloadedAlbumSelectedCount": "{count} selected",
+  "downloadedAlbumSelectedCount": "{count} selecionadas",
  "@downloadedAlbumSelectedCount": {
    "description": "Selection count indicator",
    "placeholders": {
@@ -2551,15 +2551,15 @@
      }
    }
  },
-  "downloadedAlbumAllSelected": "All tracks selected",
+  "downloadedAlbumAllSelected": "Todas as faixas selecionadas",
  "@downloadedAlbumAllSelected": {
    "description": "Status - all items selected"
  },
-  "downloadedAlbumTapToSelect": "Tap tracks to select",
+  "downloadedAlbumTapToSelect": "Toque nas faixas para selecionar",
  "@downloadedAlbumTapToSelect": {
    "description": "Selection hint"
  },
-  "downloadedAlbumDeleteCount": "Delete {count} {count, plural, =1{track} other{tracks}}",
+  "downloadedAlbumDeleteCount": "Apagar {count} {count, plural, =1{faixa} other{faixas}}",
  "@downloadedAlbumDeleteCount": {
    "description": "Delete button text with count",
    "placeholders": {
@@ -2568,23 +2568,23 @@
      }
    }
  },
-  "downloadedAlbumSelectToDelete": "Select tracks to delete",
+  "downloadedAlbumSelectToDelete": "Selecione faixas para apagar",
  "@downloadedAlbumSelectToDelete": {
    "description": "Placeholder when nothing selected"
  },
-  "utilityFunctions": "Utility Functions",
+  "utilityFunctions": "Funções Utilitárias",
  "@utilityFunctions": {
    "description": "Extension capability - utility functions"
  },
-  "recentTypeArtist": "Artist",
+  "recentTypeArtist": "Artista",
  "@recentTypeArtist": {
    "description": "Recent access item type - artist"
  },
-  "recentTypeAlbum": "Album",
+  "recentTypeAlbum": "Álbum",
  "@recentTypeAlbum": {
    "description": "Recent access item type - album"
  },
-  "recentTypeSong": "Song",
+  "recentTypeSong": "Música",
  "@recentTypeSong": {
    "description": "Recent access item type - song/track"
  },
@@ -2602,7 +2602,7 @@
      }
    }
  },
-  "errorGeneric": "Error: {message}",
+  "errorGeneric": "Erro: {message}",
  "@errorGeneric": {
    "description": "Generic error message format",
    "placeholders": {
@@ -127,6 +127,10 @@
  "@historyNoSinglesSubtitle": {
    "description": "Empty state subtitle for singles filter"
  },
+  "historySearchHint": "Поиск в истории...",
+  "@historySearchHint": {
+    "description": "Search bar placeholder in history"
+  },
  "settingsTitle": "Настройки",
  "@settingsTitle": {
    "description": "Settings screen title"
@@ -512,6 +516,10 @@
  "@aboutLogoArtist": {
    "description": "Role description for logo artist"
  },
+  "aboutTranslators": "Переводчики",
+  "@aboutTranslators": {
+    "description": "Section for translators"
+  },
  "aboutSpecialThanks": "Особая благодарность",
  "@aboutSpecialThanks": {
    "description": "Section for special thanks"
@@ -544,6 +552,26 @@
  "@aboutFeatureRequestSubtitle": {
    "description": "Subtitle for feature request"
  },
+  "aboutTelegramChannel": "Telegram канал",
+  "@aboutTelegramChannel": {
+    "description": "Link to Telegram channel"
+  },
+  "aboutTelegramChannelSubtitle": "Объявления и обновления",
+  "@aboutTelegramChannelSubtitle": {
+    "description": "Subtitle for Telegram channel"
+  },
+  "aboutTelegramChat": "Сообщество в Telegram",
+  "@aboutTelegramChat": {
+    "description": "Link to Telegram chat group"
+  },
+  "aboutTelegramChatSubtitle": "Чат с другими пользователями",
+  "@aboutTelegramChatSubtitle": {
+    "description": "Subtitle for Telegram chat"
+  },
+  "aboutSocial": "Соцсети",
+  "@aboutSocial": {
+    "description": "Section for social links"
+  },
  "aboutSupport": "Поддержка",
  "@aboutSupport": {
    "description": "Section for support/donation links"
@@ -1108,7 +1136,7 @@
  "@dialogDeleteSelectedTitle": {
    "description": "Dialog title - delete selected items"
  },
-  "dialogDeleteSelectedMessage": "Удалить {count} {count, plural, one {трек} few {трека} many {треков} other{треков}} из истории?\n\nЭто также удалит файлы из хранилища.",
+  "dialogDeleteSelectedMessage": "Удалить {count} {count, plural, one {трек} few {трека} many {треков} other {треков}} из истории?\n\nЭто также удалит файлы из хранилища.",
  "@dialogDeleteSelectedMessage": {
    "description": "Dialog message - delete selected tracks",
    "placeholders": {
@@ -1122,6 +1150,15 @@
    "description": "Dialog title - import CSV playlist"
  },
  "dialogImportPlaylistMessage": "Найдено {count} треков в CSV. Добавить их в очередь загрузки?",
+  "csvImportTracks": "{count} треков из CSV",
+  "@csvImportTracks": {
+    "description": "Label shown in quality picker for CSV import",
+    "placeholders": {
+      "count": {
+        "type": "int"
+      }
+    }
+  },
  "@dialogImportPlaylistMessage": {
    "description": "Dialog message - import playlist confirmation",
    "placeholders": {
@@ -1169,7 +1206,7 @@
  "@snackbarCredentialsCleared": {
    "description": "Snackbar - Spotify credentials removed"
  },
-  "snackbarDeletedTracks": "Удалено {count} {count, plural, one {трек} few {трека} many {треков} other{треков}}",
+  "snackbarDeletedTracks": "Удалено {count} {count, plural, one {трек} few {трека} many {треков} other {треков}}",
  "@snackbarDeletedTracks": {
    "description": "Snackbar - tracks deleted",
    "placeholders": {
@@ -1376,7 +1413,7 @@
  "@selectionTapToSelect": {
    "description": "Hint - how to select items"
  },
-  "selectionDeleteTracks": "Удалить {count} {count, plural, one {трек} few {трека} many {треков} other{треков}}",
+  "selectionDeleteTracks": "Удалить {count} {count, plural, one {трек} few {трека} many {треков} other {треков}}",
  "@selectionDeleteTracks": {
    "description": "Delete button with count",
    "placeholders": {
@@ -1851,6 +1888,42 @@
  "@sectionFileSettings": {
    "description": "Settings section header"
  },
+  "sectionLyrics": "Тексты песен",
+  "@sectionLyrics": {
+    "description": "Settings section header"
+  },
+  "lyricsMode": "Режим текстов песен",
+  "@lyricsMode": {
+    "description": "Setting - how to save lyrics"
+  },
+  "lyricsModeDescription": "Выберите как сохранить тексты песен при скачивании",
+  "@lyricsModeDescription": {
+    "description": "Lyrics mode picker description"
+  },
+  "lyricsModeEmbed": "Вставить в файл",
+  "@lyricsModeEmbed": {
+    "description": "Lyrics mode option - embed in audio file"
+  },
+  "lyricsModeEmbedSubtitle": "Встроить текст в метаданные FLAC",
+  "@lyricsModeEmbedSubtitle": {
+    "description": "Subtitle for embed option"
+  },
+  "lyricsModeExternal": "Внешний файл .lrc",
+  "@lyricsModeExternal": {
+    "description": "Lyrics mode option - separate LRC file"
+  },
+  "lyricsModeExternalSubtitle": "Отдельный файл .lrc для плееров, таких, как Samsung Music",
+  "@lyricsModeExternalSubtitle": {
+    "description": "Subtitle for external option"
+  },
+  "lyricsModeBoth": "Оба варианта",
+  "@lyricsModeBoth": {
+    "description": "Lyrics mode option - embed and external"
+  },
+  "lyricsModeBothSubtitle": "Вставить и сохранить файл .lrc",
+  "@lyricsModeBothSubtitle": {
+    "description": "Subtitle for both option"
+  },
  "sectionColor": "Цвет",
  "@sectionColor": {
    "description": "Settings section header"
@@ -1997,6 +2070,18 @@
  "@trackReleaseDate": {
    "description": "Metadata label - release date"
  },
+  "trackGenre": "Жанр",
+  "@trackGenre": {
+    "description": "Metadata label - music genre"
+  },
+  "trackLabel": "Заголовок",
+  "@trackLabel": {
+    "description": "Metadata label - record label"
+  },
+  "trackCopyright": "Авторские права",
+  "@trackCopyright": {
+    "description": "Metadata label - copyright information"
+  },
  "trackDownloaded": "Скачано",
  "@trackDownloaded": {
    "description": "Metadata label - download date"
@@ -2017,6 +2102,18 @@
  "@trackLyricsLoadFailed": {
    "description": "Message when lyrics loading fails"
  },
+  "trackEmbedLyrics": "Вставить текст песни",
+  "@trackEmbedLyrics": {
+    "description": "Action - embed lyrics into audio file"
+  },
+  "trackLyricsEmbedded": "Текст успешно добавлен",
+  "@trackLyricsEmbedded": {
+    "description": "Snackbar - lyrics saved to file"
+  },
+  "trackInstrumental": "Инструментальный трек",
+  "@trackInstrumental": {
+    "description": "Message when track is instrumental (no lyrics)"
+  },
  "trackCopiedToClipboard": "Скопировано в буфер обмена",
  "@trackCopiedToClipboard": {
    "description": "Snackbar - content copied"
@@ -2328,6 +2425,26 @@
  "@qualityHiResFlacMaxSubtitle": {
    "description": "Technical spec for hi-res max"
  },
+  "qualityMp3": "MP3",
+  "@qualityMp3": {
+    "description": "Quality option - MP3 lossy format"
+  },
+  "qualityMp3Subtitle": "320 кбит/с (Конвертировано из FLAC)",
+  "@qualityMp3Subtitle": {
+    "description": "Technical spec for MP3"
+  },
+  "enableMp3Option": "Скачивние в MP3",
+  "@enableMp3Option": {
+    "description": "Setting - enable MP3 quality option"
+  },
+  "enableMp3OptionSubtitleOn": "MP3 качество доступно",
+  "@enableMp3OptionSubtitleOn": {
+    "description": "Subtitle when MP3 is enabled"
+  },
+  "enableMp3OptionSubtitleOff": "Скачивать FLAC и конвертировать в MP3 320 кбит/с",
+  "@enableMp3OptionSubtitleOff": {
+    "description": "Subtitle when MP3 is disabled"
+  },
  "qualityNote": "Фактическое качество зависит от доступности треков в сервисе",
  "@qualityNote": {
    "description": "Note about quality availability"
@@ -2516,11 +2633,19 @@
  "@albumFolderYearAlbumSubtitle": {
    "description": "Folder structure example"
  },
+  "albumFolderArtistAlbumSingles": "Исполнитель / Альбом + Синглы",
+  "@albumFolderArtistAlbumSingles": {
+    "description": "Album folder option with singles inside artist"
+  },
+  "albumFolderArtistAlbumSinglesSubtitle": "Исполнитель/Альбом и Исполнитель/Сингл/",
+  "@albumFolderArtistAlbumSinglesSubtitle": {
+    "description": "Folder structure example"
+  },
  "downloadedAlbumDeleteSelected": "Удалить выбранные",
  "@downloadedAlbumDeleteSelected": {
    "description": "Button - delete selected tracks"
  },
-  "downloadedAlbumDeleteMessage": "Удалить {count} {count, plural, one {трек} few {трека} many {треков} other{треков}} из этого альбома?\n\nЭто также удалит файлы из хранилища.",
+  "downloadedAlbumDeleteMessage": "Удалить {count} {count, plural, one {трек} few {трека} many {треков} other {треков}} из этого альбома?\n\nЭто также удалит файлы из хранилища.",
  "@downloadedAlbumDeleteMessage": {
    "description": "Delete confirmation with count",
    "placeholders": {
@@ -2559,7 +2684,7 @@
  "@downloadedAlbumTapToSelect": {
    "description": "Selection hint"
  },
-  "downloadedAlbumDeleteCount": "Удалить {count} {count, plural, one {трек} few {трека} many {треков} other{треков}}",
+  "downloadedAlbumDeleteCount": "Удалить {count} {count, plural, one {трек} few {трека} many {треков} other {треков}}",
  "@downloadedAlbumDeleteCount": {
    "description": "Delete button text with count",
    "placeholders": {
@@ -2572,6 +2697,16 @@
  "@downloadedAlbumSelectToDelete": {
    "description": "Placeholder when nothing selected"
  },
+  "downloadedAlbumDiscHeader": "Диск {discNumber}",
+  "@downloadedAlbumDiscHeader": {
+    "description": "Header for disc separator in multi-disc albums",
+    "placeholders": {
+      "discNumber": {
+        "type": "int",
+        "example": "1"
+      }
+    }
+  },
  "utilityFunctions": "Функции утилиты",
  "@utilityFunctions": {
    "description": "Extension capability - utility functions"
@@ -2611,5 +2746,123 @@
        "description": "Error message"
      }
    }
+  },
+  "discographyDownload": "Скачать дискографию",
+  "@discographyDownload": {
+    "description": "Button - download artist discography"
+  },
+  "discographyDownloadAll": "Скачать всё",
+  "@discographyDownloadAll": {
+    "description": "Option - download entire discography"
+  },
+  "discographyDownloadAllSubtitle": "{count} треков из {albumCount} релизов",
+  "@discographyDownloadAllSubtitle": {
+    "description": "Subtitle showing total tracks and albums",
+    "placeholders": {
+      "count": {
+        "type": "int"
+      },
+      "albumCount": {
+        "type": "int"
+      }
+    }
+  },
+  "discographyAlbumsOnly": "Только альбомы",
+  "@discographyAlbumsOnly": {
+    "description": "Option - download only albums"
+  },
+  "discographyAlbumsOnlySubtitle": "{count} треков из {albumCount} альбомов",
+  "@discographyAlbumsOnlySubtitle": {
+    "description": "Subtitle showing album tracks count",
+    "placeholders": {
+      "count": {
+        "type": "int"
+      },
+      "albumCount": {
+        "type": "int"
+      }
+    }
+  },
+  "discographySinglesOnly": "Только синглы и EP",
+  "@discographySinglesOnly": {
+    "description": "Option - download only singles"
+  },
+  "discographySinglesOnlySubtitle": "{count} треков из {albumCount} синглов",
+  "@discographySinglesOnlySubtitle": {
+    "description": "Subtitle showing singles tracks count",
+    "placeholders": {
+      "count": {
+        "type": "int"
+      },
+      "albumCount": {
+        "type": "int"
+      }
+    }
+  },
+  "discographySelectAlbums": "Выбрать альбомы...",
+  "@discographySelectAlbums": {
+    "description": "Option - manually select albums to download"
+  },
+  "discographySelectAlbumsSubtitle": "Выберите конкретные альбомы или синглы",
+  "@discographySelectAlbumsSubtitle": {
+    "description": "Subtitle for select albums option"
+  },
+  "discographyFetchingTracks": "Получение треков...",
+  "@discographyFetchingTracks": {
+    "description": "Progress - fetching album tracks"
+  },
+  "discographyFetchingAlbum": "Получение {current} из {total}...",
+  "@discographyFetchingAlbum": {
+    "description": "Progress - fetching specific album",
+    "placeholders": {
+      "current": {
+        "type": "int"
+      },
+      "total": {
+        "type": "int"
+      }
+    }
+  },
+  "discographySelectedCount": "{count} выбрано",
+  "@discographySelectedCount": {
+    "description": "Selection count badge",
+    "placeholders": {
+      "count": {
+        "type": "int"
+      }
+    }
+  },
+  "discographyDownloadSelected": "Скачать выбранное",
+  "@discographyDownloadSelected": {
+    "description": "Button - download selected albums"
+  },
+  "discographyAddedToQueue": "Добавлено {count} треков в очередь",
+  "@discographyAddedToQueue": {
+    "description": "Snackbar - tracks added from discography",
+    "placeholders": {
+      "count": {
+        "type": "int"
+      }
+    }
+  },
+  "discographySkippedDownloaded": "{added} добавлено, {skipped} уже скачано",
+  "@discographySkippedDownloaded": {
+    "description": "Snackbar - with skipped tracks count",
+    "placeholders": {
+      "added": {
+        "type": "int"
+      },
+      "skipped": {
+        "type": "int"
+      }
+    }
+  },
+  "discographyNoAlbums": "Нет доступных альбомов",
+  "@discographyNoAlbums": {
+    "description": "Error - no albums found for artist"
+  },
+  "discographyFailedToFetch": "Не удалось получить некоторые альбомы",
+  "@discographyFailedToFetch": {
+    "description": "Error - some albums failed to load"
  }
 }
@@ -127,6 +127,10 @@
  "@historyNoSinglesSubtitle": {
    "description": "Empty state subtitle for singles filter"
  },
+  "historySearchHint": "Search history...",
+  "@historySearchHint": {
+    "description": "Search bar placeholder in history"
+  },
  "settingsTitle": "Settings",
  "@settingsTitle": {
    "description": "Settings screen title"
@@ -512,6 +516,10 @@
  "@aboutLogoArtist": {
    "description": "Role description for logo artist"
  },
+  "aboutTranslators": "Translators",
+  "@aboutTranslators": {
+    "description": "Section for translators"
+  },
  "aboutSpecialThanks": "Special Thanks",
  "@aboutSpecialThanks": {
    "description": "Section for special thanks"
@@ -544,6 +552,26 @@
  "@aboutFeatureRequestSubtitle": {
    "description": "Subtitle for feature request"
  },
+  "aboutTelegramChannel": "Telegram Channel",
+  "@aboutTelegramChannel": {
+    "description": "Link to Telegram channel"
+  },
+  "aboutTelegramChannelSubtitle": "Announcements and updates",
+  "@aboutTelegramChannelSubtitle": {
+    "description": "Subtitle for Telegram channel"
+  },
+  "aboutTelegramChat": "Telegram Community",
+  "@aboutTelegramChat": {
+    "description": "Link to Telegram chat group"
+  },
+  "aboutTelegramChatSubtitle": "Chat with other users",
+  "@aboutTelegramChatSubtitle": {
+    "description": "Subtitle for Telegram chat"
+  },
+  "aboutSocial": "Social",
+  "@aboutSocial": {
+    "description": "Section for social links"
+  },
  "aboutSupport": "Support",
  "@aboutSupport": {
    "description": "Section for support/donation links"
@@ -1122,6 +1150,15 @@
    "description": "Dialog title - import CSV playlist"
  },
  "dialogImportPlaylistMessage": "Found {count} tracks in CSV. Add them to download queue?",
+  "csvImportTracks": "{count} tracks from CSV",
+  "@csvImportTracks": {
+    "description": "Label shown in quality picker for CSV import",
+    "placeholders": {
+      "count": {
+        "type": "int"
+      }
+    }
+  },
  "@dialogImportPlaylistMessage": {
    "description": "Dialog message - import playlist confirmation",
    "placeholders": {
@@ -1851,6 +1888,42 @@
  "@sectionFileSettings": {
    "description": "Settings section header"
  },
+  "sectionLyrics": "Lyrics",
+  "@sectionLyrics": {
+    "description": "Settings section header"
+  },
+  "lyricsMode": "Lyrics Mode",
+  "@lyricsMode": {
+    "description": "Setting - how to save lyrics"
+  },
+  "lyricsModeDescription": "Choose how lyrics are saved with your downloads",
+  "@lyricsModeDescription": {
+    "description": "Lyrics mode picker description"
+  },
+  "lyricsModeEmbed": "Embed in file",
+  "@lyricsModeEmbed": {
+    "description": "Lyrics mode option - embed in audio file"
+  },
+  "lyricsModeEmbedSubtitle": "Lyrics stored inside FLAC metadata",
+  "@lyricsModeEmbedSubtitle": {
+    "description": "Subtitle for embed option"
+  },
+  "lyricsModeExternal": "External .lrc file",
+  "@lyricsModeExternal": {
+    "description": "Lyrics mode option - separate LRC file"
+  },
+  "lyricsModeExternalSubtitle": "Separate .lrc file for players like Samsung Music",
+  "@lyricsModeExternalSubtitle": {
+    "description": "Subtitle for external option"
+  },
+  "lyricsModeBoth": "Both",
+  "@lyricsModeBoth": {
+    "description": "Lyrics mode option - embed and external"
+  },
+  "lyricsModeBothSubtitle": "Embed and save .lrc file",
+  "@lyricsModeBothSubtitle": {
+    "description": "Subtitle for both option"
+  },
  "sectionColor": "Color",
  "@sectionColor": {
    "description": "Settings section header"
@@ -1997,6 +2070,18 @@
  "@trackReleaseDate": {
    "description": "Metadata label - release date"
  },
+  "trackGenre": "Genre",
+  "@trackGenre": {
+    "description": "Metadata label - music genre"
+  },
+  "trackLabel": "Label",
+  "@trackLabel": {
+    "description": "Metadata label - record label"
+  },
+  "trackCopyright": "Copyright",
+  "@trackCopyright": {
+    "description": "Metadata label - copyright information"
+  },
  "trackDownloaded": "Downloaded",
  "@trackDownloaded": {
    "description": "Metadata label - download date"
@@ -2017,6 +2102,18 @@
  "@trackLyricsLoadFailed": {
    "description": "Message when lyrics loading fails"
  },
+  "trackEmbedLyrics": "Embed Lyrics",
+  "@trackEmbedLyrics": {
+    "description": "Action - embed lyrics into audio file"
+  },
+  "trackLyricsEmbedded": "Lyrics embedded successfully",
+  "@trackLyricsEmbedded": {
+    "description": "Snackbar - lyrics saved to file"
+  },
+  "trackInstrumental": "Instrumental track",
+  "@trackInstrumental": {
+    "description": "Message when track is instrumental (no lyrics)"
+  },
  "trackCopiedToClipboard": "Copied to clipboard",
  "@trackCopiedToClipboard": {
    "description": "Snackbar - content copied"
@@ -2328,6 +2425,26 @@
  "@qualityHiResFlacMaxSubtitle": {
    "description": "Technical spec for hi-res max"
  },
+  "qualityMp3": "MP3",
+  "@qualityMp3": {
+    "description": "Quality option - MP3 lossy format"
+  },
+  "qualityMp3Subtitle": "320kbps (converted from FLAC)",
+  "@qualityMp3Subtitle": {
+    "description": "Technical spec for MP3"
+  },
+  "enableMp3Option": "Enable MP3 Option",
+  "@enableMp3Option": {
+    "description": "Setting - enable MP3 quality option"
+  },
+  "enableMp3OptionSubtitleOn": "MP3 quality option is available",
+  "@enableMp3OptionSubtitleOn": {
+    "description": "Subtitle when MP3 is enabled"
+  },
+  "enableMp3OptionSubtitleOff": "Downloads FLAC then converts to 320kbps MP3",
+  "@enableMp3OptionSubtitleOff": {
+    "description": "Subtitle when MP3 is disabled"
+  },
  "qualityNote": "Actual quality depends on track availability from the service",
  "@qualityNote": {
    "description": "Note about quality availability"
@@ -2516,6 +2633,14 @@
  "@albumFolderYearAlbumSubtitle": {
    "description": "Folder structure example"
  },
+  "albumFolderArtistAlbumSingles": "Artist / Album + Singles",
+  "@albumFolderArtistAlbumSingles": {
+    "description": "Album folder option with singles inside artist"
+  },
+  "albumFolderArtistAlbumSinglesSubtitle": "Artist/Album/ and Artist/Singles/",
+  "@albumFolderArtistAlbumSinglesSubtitle": {
+    "description": "Folder structure example"
+  },
  "downloadedAlbumDeleteSelected": "Delete Selected",
  "@downloadedAlbumDeleteSelected": {
    "description": "Button - delete selected tracks"
@@ -2572,6 +2697,16 @@
  "@downloadedAlbumSelectToDelete": {
    "description": "Placeholder when nothing selected"
  },
+  "downloadedAlbumDiscHeader": "Disc {discNumber}",
+  "@downloadedAlbumDiscHeader": {
+    "description": "Header for disc separator in multi-disc albums",
+    "placeholders": {
+      "discNumber": {
+        "type": "int",
+        "example": "1"
+      }
+    }
+  },
  "utilityFunctions": "Utility Functions",
  "@utilityFunctions": {
    "description": "Extension capability - utility functions"
@@ -2611,5 +2746,123 @@
        "description": "Error message"
      }
    }
+  },
+  "discographyDownload": "Download Discography",
+  "@discographyDownload": {
+    "description": "Button - download artist discography"
+  },
+  "discographyDownloadAll": "Download All",
+  "@discographyDownloadAll": {
+    "description": "Option - download entire discography"
+  },
+  "discographyDownloadAllSubtitle": "{count} tracks from {albumCount} releases",
+  "@discographyDownloadAllSubtitle": {
+    "description": "Subtitle showing total tracks and albums",
+    "placeholders": {
+      "count": {
+        "type": "int"
+      },
+      "albumCount": {
+        "type": "int"
+      }
+    }
+  },
+  "discographyAlbumsOnly": "Albums Only",
+  "@discographyAlbumsOnly": {
+    "description": "Option - download only albums"
+  },
+  "discographyAlbumsOnlySubtitle": "{count} tracks from {albumCount} albums",
+  "@discographyAlbumsOnlySubtitle": {
+    "description": "Subtitle showing album tracks count",
+    "placeholders": {
+      "count": {
+        "type": "int"
+      },
+      "albumCount": {
+        "type": "int"
+      }
+    }
+  },
+  "discographySinglesOnly": "Singles & EPs Only",
+  "@discographySinglesOnly": {
+    "description": "Option - download only singles"
+  },
+  "discographySinglesOnlySubtitle": "{count} tracks from {albumCount} singles",
+  "@discographySinglesOnlySubtitle": {
+    "description": "Subtitle showing singles tracks count",
+    "placeholders": {
+      "count": {
+        "type": "int"
+      },
+      "albumCount": {
+        "type": "int"
+      }
+    }
+  },
+  "discographySelectAlbums": "Select Albums...",
+  "@discographySelectAlbums": {
+    "description": "Option - manually select albums to download"
+  },
+  "discographySelectAlbumsSubtitle": "Choose specific albums or singles",
+  "@discographySelectAlbumsSubtitle": {
+    "description": "Subtitle for select albums option"
+  },
+  "discographyFetchingTracks": "Fetching tracks...",
+  "@discographyFetchingTracks": {
+    "description": "Progress - fetching album tracks"
+  },
+  "discographyFetchingAlbum": "Fetching {current} of {total}...",
+  "@discographyFetchingAlbum": {
+    "description": "Progress - fetching specific album",
+    "placeholders": {
+      "current": {
+        "type": "int"
+      },
+      "total": {
+        "type": "int"
+      }
+    }
+  },
+  "discographySelectedCount": "{count} selected",
+  "@discographySelectedCount": {
+    "description": "Selection count badge",
+    "placeholders": {
+      "count": {
+        "type": "int"
+      }
+    }
+  },
+  "discographyDownloadSelected": "Download Selected",
+  "@discographyDownloadSelected": {
+    "description": "Button - download selected albums"
+  },
+  "discographyAddedToQueue": "Added {count} tracks to queue",
+  "@discographyAddedToQueue": {
+    "description": "Snackbar - tracks added from discography",
+    "placeholders": {
+      "count": {
+        "type": "int"
+      }
+    }
+  },
+  "discographySkippedDownloaded": "{added} added, {skipped} already downloaded",
+  "@discographySkippedDownloaded": {
+    "description": "Snackbar - with skipped tracks count",
+    "placeholders": {
+      "added": {
+        "type": "int"
+      },
+      "skipped": {
+        "type": "int"
+      }
+    }
+  },
+  "discographyNoAlbums": "No albums available",
+  "@discographyNoAlbums": {
+    "description": "Error - no albums found for artist"
+  },
+  "discographyFailedToFetch": "Failed to fetch some albums",
+  "@discographyFailedToFetch": {
+    "description": "Error - some albums failed to load"
  }
 }
@@ -127,6 +127,10 @@
  "@historyNoSinglesSubtitle": {
    "description": "Empty state subtitle for singles filter"
  },
+  "historySearchHint": "Search history...",
+  "@historySearchHint": {
+    "description": "Search bar placeholder in history"
+  },
  "settingsTitle": "Settings",
  "@settingsTitle": {
    "description": "Settings screen title"
@@ -512,6 +516,10 @@
  "@aboutLogoArtist": {
    "description": "Role description for logo artist"
  },
+  "aboutTranslators": "Translators",
+  "@aboutTranslators": {
+    "description": "Section for translators"
+  },
  "aboutSpecialThanks": "Special Thanks",
  "@aboutSpecialThanks": {
    "description": "Section for special thanks"
@@ -544,6 +552,26 @@
  "@aboutFeatureRequestSubtitle": {
    "description": "Subtitle for feature request"
  },
+  "aboutTelegramChannel": "Telegram Channel",
+  "@aboutTelegramChannel": {
+    "description": "Link to Telegram channel"
+  },
+  "aboutTelegramChannelSubtitle": "Announcements and updates",
+  "@aboutTelegramChannelSubtitle": {
+    "description": "Subtitle for Telegram channel"
+  },
+  "aboutTelegramChat": "Telegram Community",
+  "@aboutTelegramChat": {
+    "description": "Link to Telegram chat group"
+  },
+  "aboutTelegramChatSubtitle": "Chat with other users",
+  "@aboutTelegramChatSubtitle": {
+    "description": "Subtitle for Telegram chat"
+  },
+  "aboutSocial": "Social",
+  "@aboutSocial": {
+    "description": "Section for social links"
+  },
  "aboutSupport": "Support",
  "@aboutSupport": {
    "description": "Section for support/donation links"
@@ -1122,6 +1150,15 @@
    "description": "Dialog title - import CSV playlist"
  },
  "dialogImportPlaylistMessage": "Found {count} tracks in CSV. Add them to download queue?",
+  "csvImportTracks": "{count} tracks from CSV",
+  "@csvImportTracks": {
+    "description": "Label shown in quality picker for CSV import",
+    "placeholders": {
+      "count": {
+        "type": "int"
+      }
+    }
+  },
  "@dialogImportPlaylistMessage": {
    "description": "Dialog message - import playlist confirmation",
    "placeholders": {
@@ -1851,6 +1888,42 @@
  "@sectionFileSettings": {
    "description": "Settings section header"
  },
+  "sectionLyrics": "Lyrics",
+  "@sectionLyrics": {
+    "description": "Settings section header"
+  },
+  "lyricsMode": "Lyrics Mode",
+  "@lyricsMode": {
+    "description": "Setting - how to save lyrics"
+  },
+  "lyricsModeDescription": "Choose how lyrics are saved with your downloads",
+  "@lyricsModeDescription": {
+    "description": "Lyrics mode picker description"
+  },
+  "lyricsModeEmbed": "Embed in file",
+  "@lyricsModeEmbed": {
+    "description": "Lyrics mode option - embed in audio file"
+  },
+  "lyricsModeEmbedSubtitle": "Lyrics stored inside FLAC metadata",
+  "@lyricsModeEmbedSubtitle": {
+    "description": "Subtitle for embed option"
+  },
+  "lyricsModeExternal": "External .lrc file",
+  "@lyricsModeExternal": {
+    "description": "Lyrics mode option - separate LRC file"
+  },
+  "lyricsModeExternalSubtitle": "Separate .lrc file for players like Samsung Music",
+  "@lyricsModeExternalSubtitle": {
+    "description": "Subtitle for external option"
+  },
+  "lyricsModeBoth": "Both",
+  "@lyricsModeBoth": {
+    "description": "Lyrics mode option - embed and external"
+  },
+  "lyricsModeBothSubtitle": "Embed and save .lrc file",
+  "@lyricsModeBothSubtitle": {
+    "description": "Subtitle for both option"
+  },
  "sectionColor": "Color",
  "@sectionColor": {
    "description": "Settings section header"
@@ -1997,6 +2070,18 @@
  "@trackReleaseDate": {
    "description": "Metadata label - release date"
  },
+  "trackGenre": "Genre",
+  "@trackGenre": {
+    "description": "Metadata label - music genre"
+  },
+  "trackLabel": "Label",
+  "@trackLabel": {
+    "description": "Metadata label - record label"
+  },
+  "trackCopyright": "Copyright",
+  "@trackCopyright": {
+    "description": "Metadata label - copyright information"
+  },
  "trackDownloaded": "Downloaded",
  "@trackDownloaded": {
    "description": "Metadata label - download date"
@@ -2017,6 +2102,18 @@
  "@trackLyricsLoadFailed": {
    "description": "Message when lyrics loading fails"
  },
+  "trackEmbedLyrics": "Embed Lyrics",
+  "@trackEmbedLyrics": {
+    "description": "Action - embed lyrics into audio file"
+  },
+  "trackLyricsEmbedded": "Lyrics embedded successfully",
+  "@trackLyricsEmbedded": {
+    "description": "Snackbar - lyrics saved to file"
+  },
+  "trackInstrumental": "Instrumental track",
+  "@trackInstrumental": {
+    "description": "Message when track is instrumental (no lyrics)"
+  },
  "trackCopiedToClipboard": "Copied to clipboard",
  "@trackCopiedToClipboard": {
    "description": "Snackbar - content copied"
@@ -2328,6 +2425,26 @@
  "@qualityHiResFlacMaxSubtitle": {
    "description": "Technical spec for hi-res max"
  },
+  "qualityMp3": "MP3",
+  "@qualityMp3": {
+    "description": "Quality option - MP3 lossy format"
+  },
+  "qualityMp3Subtitle": "320kbps (converted from FLAC)",
+  "@qualityMp3Subtitle": {
+    "description": "Technical spec for MP3"
+  },
+  "enableMp3Option": "Enable MP3 Option",
+  "@enableMp3Option": {
+    "description": "Setting - enable MP3 quality option"
+  },
+  "enableMp3OptionSubtitleOn": "MP3 quality option is available",
+  "@enableMp3OptionSubtitleOn": {
+    "description": "Subtitle when MP3 is enabled"
+  },
+  "enableMp3OptionSubtitleOff": "Downloads FLAC then converts to 320kbps MP3",
+  "@enableMp3OptionSubtitleOff": {
+    "description": "Subtitle when MP3 is disabled"
+  },
  "qualityNote": "Actual quality depends on track availability from the service",
  "@qualityNote": {
    "description": "Note about quality availability"
@@ -2516,6 +2633,14 @@
  "@albumFolderYearAlbumSubtitle": {
    "description": "Folder structure example"
  },
+  "albumFolderArtistAlbumSingles": "Artist / Album + Singles",
+  "@albumFolderArtistAlbumSingles": {
+    "description": "Album folder option with singles inside artist"
+  },
+  "albumFolderArtistAlbumSinglesSubtitle": "Artist/Album/ and Artist/Singles/",
+  "@albumFolderArtistAlbumSinglesSubtitle": {
+    "description": "Folder structure example"
+  },
  "downloadedAlbumDeleteSelected": "Delete Selected",
  "@downloadedAlbumDeleteSelected": {
    "description": "Button - delete selected tracks"
@@ -2572,6 +2697,16 @@
  "@downloadedAlbumSelectToDelete": {
    "description": "Placeholder when nothing selected"
  },
+  "downloadedAlbumDiscHeader": "Disc {discNumber}",
+  "@downloadedAlbumDiscHeader": {
+    "description": "Header for disc separator in multi-disc albums",
+    "placeholders": {
+      "discNumber": {
+        "type": "int",
+        "example": "1"
+      }
+    }
+  },
  "utilityFunctions": "Utility Functions",
  "@utilityFunctions": {
    "description": "Extension capability - utility functions"
@@ -2611,5 +2746,123 @@
        "description": "Error message"
      }
    }
+  },
+  "discographyDownload": "Download Discography",
+  "@discographyDownload": {
+    "description": "Button - download artist discography"
+  },
+  "discographyDownloadAll": "Download All",
+  "@discographyDownloadAll": {
+    "description": "Option - download entire discography"
+  },
+  "discographyDownloadAllSubtitle": "{count} tracks from {albumCount} releases",
+  "@discographyDownloadAllSubtitle": {
+    "description": "Subtitle showing total tracks and albums",
+    "placeholders": {
+      "count": {
+        "type": "int"
+      },
+      "albumCount": {
+        "type": "int"
+      }
+    }
+  },
+  "discographyAlbumsOnly": "Albums Only",
+  "@discographyAlbumsOnly": {
+    "description": "Option - download only albums"
+  },
+  "discographyAlbumsOnlySubtitle": "{count} tracks from {albumCount} albums",
+  "@discographyAlbumsOnlySubtitle": {
+    "description": "Subtitle showing album tracks count",
+    "placeholders": {
+      "count": {
+        "type": "int"
+      },
+      "albumCount": {
+        "type": "int"
+      }
+    }
+  },
+  "discographySinglesOnly": "Singles & EPs Only",
+  "@discographySinglesOnly": {
+    "description": "Option - download only singles"
+  },
+  "discographySinglesOnlySubtitle": "{count} tracks from {albumCount} singles",
+  "@discographySinglesOnlySubtitle": {
+    "description": "Subtitle showing singles tracks count",
+    "placeholders": {
+      "count": {
+        "type": "int"
+      },
+      "albumCount": {
+        "type": "int"
+      }
+    }
+  },
+  "discographySelectAlbums": "Select Albums...",
+  "@discographySelectAlbums": {
+    "description": "Option - manually select albums to download"
+  },
+  "discographySelectAlbumsSubtitle": "Choose specific albums or singles",
+  "@discographySelectAlbumsSubtitle": {
+    "description": "Subtitle for select albums option"
+  },
+  "discographyFetchingTracks": "Fetching tracks...",
+  "@discographyFetchingTracks": {
+    "description": "Progress - fetching album tracks"
+  },
+  "discographyFetchingAlbum": "Fetching {current} of {total}...",
+  "@discographyFetchingAlbum": {
+    "description": "Progress - fetching specific album",
+    "placeholders": {
+      "current": {
+        "type": "int"
+      },
+      "total": {
+        "type": "int"
+      }
+    }
+  },
+  "discographySelectedCount": "{count} selected",
+  "@discographySelectedCount": {
+    "description": "Selection count badge",
+    "placeholders": {
+      "count": {
+        "type": "int"
+      }
+    }
+  },
+  "discographyDownloadSelected": "Download Selected",
+  "@discographyDownloadSelected": {
+    "description": "Button - download selected albums"
+  },
+  "discographyAddedToQueue": "Added {count} tracks to queue",
+  "@discographyAddedToQueue": {
+    "description": "Snackbar - tracks added from discography",
+    "placeholders": {
+      "count": {
+        "type": "int"
+      }
+    }
+  },
+  "discographySkippedDownloaded": "{added} added, {skipped} already downloaded",
+  "@discographySkippedDownloaded": {
+    "description": "Snackbar - with skipped tracks count",
+    "placeholders": {
+      "added": {
+        "type": "int"
+      },
+      "skipped": {
+        "type": "int"
+      }
+    }
+  },
+  "discographyNoAlbums": "No albums available",
+  "@discographyNoAlbums": {
+    "description": "Error - no albums found for artist"
+  },
+  "discographyFailedToFetch": "Failed to fetch some albums",
+  "@discographyFailedToFetch": {
+    "description": "Error - some albums failed to load"
  }
 }
@@ -18,6 +18,8 @@ const List<Locale> filteredSupportedLocales = <Locale>[
  Locale('es', 'ES'),
  Locale('id'),
  Locale('pt', 'PT'),
+  Locale('ja'),
+  Locale('tr'),
 ];

 /// Set of locale codes for quick lookup.
@@ -27,4 +29,6 @@ const Set<String> filteredLocaleCodes = <String>{
  'es_ES',
  'id',
  'pt_PT',
+  'ja',
+  'tr',
 };
@@ -11,21 +11,9 @@ import 'package:spotiflac_android/services/cover_cache_manager.dart';

 void main() async {
  WidgetsFlutterBinding.ensureInitialized();
-  
-  await CoverCacheManager.initialize();
-  debugPrint('CoverCacheManager initialized: ${CoverCacheManager.isInitialized}');
-  
-  await Future.wait([
-    NotificationService().initialize(),
-    ShareIntentService().initialize(),
-  ]);
-  
+
  runApp(
-    ProviderScope(
-      child: const _EagerInitialization(
-        child: SpotiFLACApp(),
-      ),
-    ),
+    ProviderScope(child: const _EagerInitialization(child: SpotiFLACApp())),
  );
 }

@@ -35,14 +23,29 @@ class _EagerInitialization extends ConsumerStatefulWidget {
  final Widget child;

  @override
-  ConsumerState<_EagerInitialization> createState() => _EagerInitializationState();
+  ConsumerState<_EagerInitialization> createState() =>
+      _EagerInitializationState();
 }

 class _EagerInitializationState extends ConsumerState<_EagerInitialization> {
  @override
  void initState() {
    super.initState();
+    _initializeAppServices();
    _initializeExtensions();
+    ref.read(downloadHistoryProvider);
+  }
+
+  Future<void> _initializeAppServices() async {
+    try {
+      await CoverCacheManager.initialize();
+      await Future.wait([
+        NotificationService().initialize(),
+        ShareIntentService().initialize(),
+      ]);
+    } catch (e) {
+      debugPrint('Failed to initialize app services: $e');
+    }
  }

  Future<void> _initializeExtensions() async {
@@ -50,11 +53,13 @@ class _EagerInitializationState extends ConsumerState<_EagerInitialization> {
      final appDir = await getApplicationDocumentsDirectory();
      final extensionsDir = '${appDir.path}/extensions';
      final dataDir = '${appDir.path}/extension_data';
-      
+
      await Directory(extensionsDir).create(recursive: true);
      await Directory(dataDir).create(recursive: true);
-      
-      await ref.read(extensionProvider.notifier).initialize(extensionsDir, dataDir);
+
+      await ref
+          .read(extensionProvider.notifier)
+          .initialize(extensionsDir, dataDir);
    } catch (e) {
      debugPrint('Failed to initialize extensions: $e');
    }
@@ -62,7 +67,6 @@ class _EagerInitializationState extends ConsumerState<_EagerInitialization> {

  @override
  Widget build(BuildContext context) {
-    ref.watch(downloadHistoryProvider);
    return widget.child;
  }
 }
@@ -28,6 +28,7 @@ class DownloadItem {
  final DownloadStatus status;
  final double progress;
  final double speedMBps;
+  final int bytesReceived; // Bytes downloaded so far (for unknown size downloads)
  final String? filePath;
  final String? error;
  final DownloadErrorType? errorType;
@@ -41,6 +42,7 @@ class DownloadItem {
    this.status = DownloadStatus.queued,
    this.progress = 0.0,
    this.speedMBps = 0.0,
+    this.bytesReceived = 0,
    this.filePath,
    this.error,
    this.errorType,
@@ -55,6 +57,7 @@ class DownloadItem {
    DownloadStatus? status,
    double? progress,
    double? speedMBps,
+    int? bytesReceived,
    String? filePath,
    String? error,
    DownloadErrorType? errorType,
@@ -68,6 +71,7 @@ class DownloadItem {
      status: status ?? this.status,
      progress: progress ?? this.progress,
      speedMBps: speedMBps ?? this.speedMBps,
+      bytesReceived: bytesReceived ?? this.bytesReceived,
      filePath: filePath ?? this.filePath,
      error: error ?? this.error,
      errorType: errorType ?? this.errorType,
@@ -15,6 +15,7 @@ DownloadItem _$DownloadItemFromJson(Map<String, dynamic> json) => DownloadItem(
      DownloadStatus.queued,
  progress: (json['progress'] as num?)?.toDouble() ?? 0.0,
  speedMBps: (json['speedMBps'] as num?)?.toDouble() ?? 0.0,
+  bytesReceived: (json['bytesReceived'] as num?)?.toInt() ?? 0,
  filePath: json['filePath'] as String?,
  error: json['error'] as String?,
  errorType: $enumDecodeNullable(_$DownloadErrorTypeEnumMap, json['errorType']),
@@ -30,6 +31,7 @@ Map<String, dynamic> _$DownloadItemToJson(DownloadItem instance) =>
      'status': _$DownloadStatusEnumMap[instance.status]!,
      'progress': instance.progress,
      'speedMBps': instance.speedMBps,
+      'bytesReceived': instance.bytesReceived,
      'filePath': instance.filePath,
      'error': instance.error,
      'errorType': _$DownloadErrorTypeEnumMap[instance.errorType],
@@ -8,6 +8,8 @@ class AppSettings {
  final String audioQuality;
  final String filenameFormat;
  final String downloadDirectory;
+  final String storageMode; // 'app' or 'saf'
+  final String downloadTreeUri; // SAF persistable tree URI
  final bool autoFallback;
  final bool embedLyrics;
  final bool maxQualityCover;
@@ -17,6 +19,7 @@ class AppSettings {
  final String updateChannel;
  final bool hasSearchedBefore;
  final String folderOrganization;
+  final bool useAlbumArtistForFolders;
  final String historyViewMode;
  final String historyFilterMode;
  final bool askQualityBeforeDownload;
@@ -31,14 +34,27 @@ class AppSettings {
  final String albumFolderStructure;
  final bool showExtensionStore;
  final String locale;
-  final bool enableMp3Option;
  final String lyricsMode;
+  final String tidalHighFormat; // Format for Tidal HIGH quality: 'mp3_320', 'opus_256', or 'opus_128'
+  final bool useAllFilesAccess; // Android 13+ only: enable MANAGE_EXTERNAL_STORAGE
+  final bool autoExportFailedDownloads; // Auto export failed downloads to TXT file
+  final String downloadNetworkMode; // 'any' = WiFi + Mobile, 'wifi_only' = WiFi only
+  
+  // Local Library Settings
+  final bool localLibraryEnabled; // Enable local library scanning
+  final String localLibraryPath; // Path to scan for audio files
+  final bool localLibraryShowDuplicates; // Show indicator when searching for existing tracks
+  
+  // Tutorial/Onboarding
+  final bool hasCompletedTutorial; // Track if user has completed the app tutorial

  const AppSettings({
    this.defaultService = 'tidal',
    this.audioQuality = 'LOSSLESS',
    this.filenameFormat = '{title} - {artist}',
    this.downloadDirectory = '',
+    this.storageMode = 'app',
+    this.downloadTreeUri = '',
    this.autoFallback = true,
    this.embedLyrics = true,
    this.maxQualityCover = true,
@@ -48,6 +64,7 @@ class AppSettings {
    this.updateChannel = 'stable',
    this.hasSearchedBefore = false,
    this.folderOrganization = 'none',
+    this.useAlbumArtistForFolders = true,
    this.historyViewMode = 'grid',
    this.historyFilterMode = 'all',
    this.askQualityBeforeDownload = true,
@@ -62,8 +79,17 @@ class AppSettings {
    this.albumFolderStructure = 'artist_album',
    this.showExtensionStore = true,
    this.locale = 'system',
-    this.enableMp3Option = false,
    this.lyricsMode = 'embed',
+    this.tidalHighFormat = 'mp3_320',
+    this.useAllFilesAccess = false,
+    this.autoExportFailedDownloads = false,
+    this.downloadNetworkMode = 'any',
+    // Local Library defaults
+    this.localLibraryEnabled = false,
+    this.localLibraryPath = '',
+    this.localLibraryShowDuplicates = true,
+    // Tutorial default
+    this.hasCompletedTutorial = false,
  });

  AppSettings copyWith({
@@ -71,6 +97,8 @@ class AppSettings {
    String? audioQuality,
    String? filenameFormat,
    String? downloadDirectory,
+    String? storageMode,
+    String? downloadTreeUri,
    bool? autoFallback,
    bool? embedLyrics,
    bool? maxQualityCover,
@@ -80,6 +108,7 @@ class AppSettings {
    String? updateChannel,
    bool? hasSearchedBefore,
    String? folderOrganization,
+    bool? useAlbumArtistForFolders,
    String? historyViewMode,
    String? historyFilterMode,
    bool? askQualityBeforeDownload,
@@ -95,14 +124,25 @@ class AppSettings {
    String? albumFolderStructure,
    bool? showExtensionStore,
    String? locale,
-    bool? enableMp3Option,
    String? lyricsMode,
+    String? tidalHighFormat,
+    bool? useAllFilesAccess,
+    bool? autoExportFailedDownloads,
+    String? downloadNetworkMode,
+    // Local Library
+    bool? localLibraryEnabled,
+    String? localLibraryPath,
+    bool? localLibraryShowDuplicates,
+    // Tutorial
+    bool? hasCompletedTutorial,
  }) {
    return AppSettings(
      defaultService: defaultService ?? this.defaultService,
      audioQuality: audioQuality ?? this.audioQuality,
      filenameFormat: filenameFormat ?? this.filenameFormat,
      downloadDirectory: downloadDirectory ?? this.downloadDirectory,
+      storageMode: storageMode ?? this.storageMode,
+      downloadTreeUri: downloadTreeUri ?? this.downloadTreeUri,
      autoFallback: autoFallback ?? this.autoFallback,
      embedLyrics: embedLyrics ?? this.embedLyrics,
      maxQualityCover: maxQualityCover ?? this.maxQualityCover,
@@ -112,6 +152,8 @@ class AppSettings {
      updateChannel: updateChannel ?? this.updateChannel,
      hasSearchedBefore: hasSearchedBefore ?? this.hasSearchedBefore,
      folderOrganization: folderOrganization ?? this.folderOrganization,
+      useAlbumArtistForFolders:
+          useAlbumArtistForFolders ?? this.useAlbumArtistForFolders,
      historyViewMode: historyViewMode ?? this.historyViewMode,
      historyFilterMode: historyFilterMode ?? this.historyFilterMode,
      askQualityBeforeDownload: askQualityBeforeDownload ?? this.askQualityBeforeDownload,
@@ -126,8 +168,17 @@ class AppSettings {
      albumFolderStructure: albumFolderStructure ?? this.albumFolderStructure,
      showExtensionStore: showExtensionStore ?? this.showExtensionStore,
      locale: locale ?? this.locale,
-      enableMp3Option: enableMp3Option ?? this.enableMp3Option,
      lyricsMode: lyricsMode ?? this.lyricsMode,
+      tidalHighFormat: tidalHighFormat ?? this.tidalHighFormat,
+      useAllFilesAccess: useAllFilesAccess ?? this.useAllFilesAccess,
+      autoExportFailedDownloads: autoExportFailedDownloads ?? this.autoExportFailedDownloads,
+      downloadNetworkMode: downloadNetworkMode ?? this.downloadNetworkMode,
+      // Local Library
+      localLibraryEnabled: localLibraryEnabled ?? this.localLibraryEnabled,
+      localLibraryPath: localLibraryPath ?? this.localLibraryPath,
+      localLibraryShowDuplicates: localLibraryShowDuplicates ?? this.localLibraryShowDuplicates,
+      // Tutorial
+      hasCompletedTutorial: hasCompletedTutorial ?? this.hasCompletedTutorial,
    );
  }

@@ -11,6 +11,8 @@ AppSettings _$AppSettingsFromJson(Map<String, dynamic> json) => AppSettings(
  audioQuality: json['audioQuality'] as String? ?? 'LOSSLESS',
  filenameFormat: json['filenameFormat'] as String? ?? '{title} - {artist}',
  downloadDirectory: json['downloadDirectory'] as String? ?? '',
+  storageMode: json['storageMode'] as String? ?? 'app',
+  downloadTreeUri: json['downloadTreeUri'] as String? ?? '',
  autoFallback: json['autoFallback'] as bool? ?? true,
  embedLyrics: json['embedLyrics'] as bool? ?? true,
  maxQualityCover: json['maxQualityCover'] as bool? ?? true,
@@ -20,6 +22,7 @@ AppSettings _$AppSettingsFromJson(Map<String, dynamic> json) => AppSettings(
  updateChannel: json['updateChannel'] as String? ?? 'stable',
  hasSearchedBefore: json['hasSearchedBefore'] as bool? ?? false,
  folderOrganization: json['folderOrganization'] as String? ?? 'none',
+  useAlbumArtistForFolders: json['useAlbumArtistForFolders'] as bool? ?? true,
  historyViewMode: json['historyViewMode'] as String? ?? 'grid',
  historyFilterMode: json['historyFilterMode'] as String? ?? 'all',
  askQualityBeforeDownload: json['askQualityBeforeDownload'] as bool? ?? true,
@@ -36,8 +39,17 @@ AppSettings _$AppSettingsFromJson(Map<String, dynamic> json) => AppSettings(
      json['albumFolderStructure'] as String? ?? 'artist_album',
  showExtensionStore: json['showExtensionStore'] as bool? ?? true,
  locale: json['locale'] as String? ?? 'system',
-  enableMp3Option: json['enableMp3Option'] as bool? ?? false,
  lyricsMode: json['lyricsMode'] as String? ?? 'embed',
+  tidalHighFormat: json['tidalHighFormat'] as String? ?? 'mp3_320',
+  useAllFilesAccess: json['useAllFilesAccess'] as bool? ?? false,
+  autoExportFailedDownloads:
+      json['autoExportFailedDownloads'] as bool? ?? false,
+  downloadNetworkMode: json['downloadNetworkMode'] as String? ?? 'any',
+  localLibraryEnabled: json['localLibraryEnabled'] as bool? ?? false,
+  localLibraryPath: json['localLibraryPath'] as String? ?? '',
+  localLibraryShowDuplicates:
+      json['localLibraryShowDuplicates'] as bool? ?? true,
+  hasCompletedTutorial: json['hasCompletedTutorial'] as bool? ?? false,
 );

 Map<String, dynamic> _$AppSettingsToJson(AppSettings instance) =>
@@ -46,6 +58,8 @@ Map<String, dynamic> _$AppSettingsToJson(AppSettings instance) =>
      'audioQuality': instance.audioQuality,
      'filenameFormat': instance.filenameFormat,
      'downloadDirectory': instance.downloadDirectory,
+      'storageMode': instance.storageMode,
+      'downloadTreeUri': instance.downloadTreeUri,
      'autoFallback': instance.autoFallback,
      'embedLyrics': instance.embedLyrics,
      'maxQualityCover': instance.maxQualityCover,
@@ -55,6 +69,7 @@ Map<String, dynamic> _$AppSettingsToJson(AppSettings instance) =>
      'updateChannel': instance.updateChannel,
      'hasSearchedBefore': instance.hasSearchedBefore,
      'folderOrganization': instance.folderOrganization,
+      'useAlbumArtistForFolders': instance.useAlbumArtistForFolders,
      'historyViewMode': instance.historyViewMode,
      'historyFilterMode': instance.historyFilterMode,
      'askQualityBeforeDownload': instance.askQualityBeforeDownload,
@@ -69,6 +84,13 @@ Map<String, dynamic> _$AppSettingsToJson(AppSettings instance) =>
      'albumFolderStructure': instance.albumFolderStructure,
      'showExtensionStore': instance.showExtensionStore,
      'locale': instance.locale,
-      'enableMp3Option': instance.enableMp3Option,
      'lyricsMode': instance.lyricsMode,
+      'tidalHighFormat': instance.tidalHighFormat,
+      'useAllFilesAccess': instance.useAllFilesAccess,
+      'autoExportFailedDownloads': instance.autoExportFailedDownloads,
+      'downloadNetworkMode': instance.downloadNetworkMode,
+      'localLibraryEnabled': instance.localLibraryEnabled,
+      'localLibraryPath': instance.localLibraryPath,
+      'localLibraryShowDuplicates': instance.localLibraryShowDuplicates,
+      'hasCompletedTutorial': instance.hasCompletedTutorial,
    };
@@ -1,11 +1,12 @@
+import 'dart:convert';
 import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:shared_preferences/shared_preferences.dart';
 import 'package:spotiflac_android/services/platform_bridge.dart';
 import 'package:spotiflac_android/utils/logger.dart';
 import 'package:spotiflac_android/providers/extension_provider.dart';

 final _log = AppLogger('ExploreProvider');

-/// Represents an item in a Spotify home section
 class ExploreItem {
  final String id;
  final String uri;
@@ -48,33 +49,56 @@ class ExploreItem {
      durationMs: json['duration_ms'] as int? ?? 0,
    );
  }
+
+  Map<String, dynamic> toJson() => {
+    'id': id,
+    'uri': uri,
+    'type': type,
+    'name': name,
+    'artists': artists,
+    'description': description,
+    'cover_url': coverUrl,
+    'provider_id': providerId,
+    'album_id': albumId,
+    'album_name': albumName,
+    'duration_ms': durationMs,
+  };
 }

-/// Represents a section in Spotify home feed
 class ExploreSection {
  final String uri;
  final String title;
  final List<ExploreItem> items;
+  final bool isYTMusicQuickPicks;

  const ExploreSection({
    required this.uri,
    required this.title,
    required this.items,
+    this.isYTMusicQuickPicks = false,
  });

  factory ExploreSection.fromJson(Map<String, dynamic> json) {
    final itemsList = json['items'] as List<dynamic>? ?? [];
+    final items = itemsList
+        .map((item) => ExploreItem.fromJson(item as Map<String, dynamic>))
+        .toList();
+    final isQuickPicks = _isYTMusicQuickPicksItems(items);
    return ExploreSection(
      uri: json['uri'] as String? ?? '',
      title: json['title'] as String? ?? '',
-      items: itemsList
-          .map((item) => ExploreItem.fromJson(item as Map<String, dynamic>))
-          .toList(),
+      items: items,
+      isYTMusicQuickPicks: isQuickPicks,
    );
  }
+
+  Map<String, dynamic> toJson() => {
+    'uri': uri,
+    'title': title,
+    'items': items.map((i) => i.toJson()).toList(),
+  };
 }

-/// State for explore/home feed
 class ExploreState {
  final bool isLoading;
  final String? error;
@@ -109,23 +133,96 @@ class ExploreState {
  }
 }

-/// Provider for explore/home feed state
+String _getLocalGreeting() {
+  final hour = DateTime.now().hour;
+  if (hour >= 5 && hour < 12) {
+    return 'Good morning';
+  } else if (hour >= 12 && hour < 17) {
+    return 'Good afternoon';
+  } else if (hour >= 17 && hour < 21) {
+    return 'Good evening';
+  } else {
+    return 'Good night';
+  }
+}
+
+bool _isYTMusicQuickPicksItems(List<ExploreItem> items) {
+  if (items.isEmpty) return false;
+  if (items.first.providerId != 'ytmusic-spotiflac') return false;
+  for (final item in items) {
+    if (item.type != 'track') {
+      return false;
+    }
+  }
+  return true;
+}
+
 class ExploreNotifier extends Notifier<ExploreState> {
+  static const _cacheKey = 'explore_home_feed_cache';
+  static const _cacheTsKey = 'explore_home_feed_ts';
+
  @override
  ExploreState build() {
+    _restoreFromCache();
    return const ExploreState();
  }

+  /// Restore cached home feed from SharedPreferences immediately on startup
+  Future<void> _restoreFromCache() async {
+    try {
+      final prefs = await SharedPreferences.getInstance();
+      final cached = prefs.getString(_cacheKey);
+      final cachedTs = prefs.getInt(_cacheTsKey);
+      if (cached == null || cached.isEmpty) return;
+
+      final data = jsonDecode(cached) as Map<String, dynamic>;
+      final sectionsData = data['sections'] as List<dynamic>? ?? [];
+      final sections = sectionsData
+          .map((s) => ExploreSection.fromJson(s as Map<String, dynamic>))
+          .toList();
+
+      if (sections.isEmpty) return;
+
+      final lastFetched = cachedTs != null
+          ? DateTime.fromMillisecondsSinceEpoch(cachedTs)
+          : null;
+
+      _log.i('Restored ${sections.length} cached explore sections');
+      state = ExploreState(
+        greeting: _getLocalGreeting(),
+        sections: sections,
+        lastFetched: lastFetched,
+      );
+    } catch (e) {
+      _log.w('Failed to restore explore cache: $e');
+    }
+  }
+
+  /// Save home feed to SharedPreferences for instant restore on next launch
+  Future<void> _saveToCache(List<ExploreSection> sections) async {
+    try {
+      final prefs = await SharedPreferences.getInstance();
+      final data = {
+        'sections': sections.map((s) => s.toJson()).toList(),
+      };
+      await prefs.setString(_cacheKey, jsonEncode(data));
+      await prefs.setInt(_cacheTsKey, DateTime.now().millisecondsSinceEpoch);
+      _log.d('Saved ${sections.length} explore sections to cache');
+    } catch (e) {
+      _log.w('Failed to save explore cache: $e');
+    }
+  }
+
  /// Fetch home feed from spotify-web extension
  Future<void> fetchHomeFeed({bool forceRefresh = false}) async {
    _log.i('fetchHomeFeed called, forceRefresh=$forceRefresh');
    
-    // Don't refetch if we have data and it's less than 5 minutes old
+    // If we have cached content and it's fresh enough, skip network fetch
    if (!forceRefresh && 
        state.hasContent && 
        state.lastFetched != null &&
        DateTime.now().difference(state.lastFetched!).inMinutes < 5) {
-      _log.d('Using cached home feed');
+      _log.d('Using cached home feed (fresh enough)');
      return;
    }
    
@@ -134,14 +231,14 @@ class ExploreNotifier extends Notifier<ExploreState> {
      return;
    }

-    state = state.copyWith(isLoading: true, error: null);
+    // Only show loading spinner if we have no cached content to display
+    final showLoading = !state.hasContent;
+    state = state.copyWith(isLoading: showLoading, error: null);

    try {
-      // Find any extension with homeFeed capability
      final extState = ref.read(extensionProvider);
      _log.d('Extensions count: ${extState.extensions.length}');
      
-      // Look for extensions with homeFeed capability (prefer spotify-web)
      Extension? targetExt;
      for (final extension in extState.extensions) {
        if (!extension.enabled || !extension.hasHomeFeed) {
@@ -195,18 +292,23 @@ class ExploreNotifier extends Notifier<ExploreState> {

      _log.i('Fetched ${sections.length} sections');
      
-      // Debug: log first section items
      if (sections.isNotEmpty && sections.first.items.isNotEmpty) {
        final firstItem = sections.first.items.first;
        _log.d('First item: name=${firstItem.name}, artists=${firstItem.artists}, type=${firstItem.type}');
      }

+      final localGreeting = _getLocalGreeting();
+      _log.d('Greeting from extension: $greeting, using local: $localGreeting');
+
      state = ExploreState(
        isLoading: false,
-        greeting: greeting,
+        greeting: localGreeting,
        sections: sections,
        lastFetched: DateTime.now(),
      );
+
+      // Save to disk cache for instant restore on next app launch
+      _saveToCache(sections);
    } catch (e, stack) {
      _log.e('Error fetching home feed: $e', e, stack);
      state = state.copyWith(
@@ -216,15 +318,14 @@ class ExploreNotifier extends Notifier<ExploreState> {
    }
  }

-  /// Clear cached data
  void clear() {
    state = const ExploreState();
  }

-  /// Refresh home feed
  Future<void> refresh() => fetchHomeFeed(forceRefresh: true);
 }

+
 final exploreProvider = NotifierProvider<ExploreNotifier, ExploreState>(() {
  return ExploreNotifier();
 });
@@ -1,10 +1,15 @@
+import 'dart:convert';
 import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:shared_preferences/shared_preferences.dart';
 import 'package:spotiflac_android/services/platform_bridge.dart';
 import 'package:spotiflac_android/utils/logger.dart';
 import 'package:spotiflac_android/providers/settings_provider.dart';

 final _log = AppLogger('ExtensionProvider');

+const _metadataProviderPriorityKey = 'metadata_provider_priority';
+const _providerPriorityKey = 'provider_priority';
+
 class Extension {
  final String id;
  final String name;
@@ -146,6 +151,26 @@ class Extension {
  bool get hasBrowseCategories => capabilities['browseCategories'] == true;
 }

+class SearchFilter {
+  final String id;
+  final String? label;
+  final String? icon;
+
+  const SearchFilter({
+    required this.id,
+    this.label,
+    this.icon,
+  });
+
+  factory SearchFilter.fromJson(Map<String, dynamic> json) {
+    return SearchFilter(
+      id: json['id'] as String? ?? '',
+      label: json['label'] as String?,
+      icon: json['icon'] as String?,
+    );
+  }
+}
+
 class SearchBehavior {
  final bool enabled;
  final String? placeholder;
@@ -154,6 +179,7 @@ class SearchBehavior {
  final String? thumbnailRatio; // "square" (1:1), "wide" (16:9), "portrait" (2:3)
  final int? thumbnailWidth;
  final int? thumbnailHeight;
+  final List<SearchFilter> filters; // Available search filters (e.g., track, album, artist, playlist)

  const SearchBehavior({
    required this.enabled,
@@ -163,6 +189,7 @@ class SearchBehavior {
    this.thumbnailRatio,
    this.thumbnailWidth,
    this.thumbnailHeight,
+    this.filters = const [],
  });

  factory SearchBehavior.fromJson(Map<String, dynamic> json) {
@@ -174,6 +201,9 @@ class SearchBehavior {
      thumbnailRatio: json['thumbnailRatio'] as String?,
      thumbnailWidth: json['thumbnailWidth'] as int?,
      thumbnailHeight: json['thumbnailHeight'] as int?,
+      filters: (json['filters'] as List<dynamic>?)
+          ?.map((f) => SearchFilter.fromJson(f as Map<String, dynamic>))
+          .toList() ?? [],
    );
  }

@@ -427,7 +457,6 @@ class ExtensionNotifier extends Notifier<ExtensionState> {
    return const ExtensionState();
  }

-  /// Initialize the extension system
  Future<void> initialize(String extensionsDir, String dataDir) async {
    if (state.isInitialized) return;
    
@@ -460,7 +489,6 @@ class ExtensionNotifier extends Notifier<ExtensionState> {
    }
  }

-  /// Refresh the list of installed extensions
  Future<void> refreshExtensions() async {
    try {
      final list = await PlatformBridge.getInstalledExtensions();
@@ -468,7 +496,6 @@ class ExtensionNotifier extends Notifier<ExtensionState> {
      state = state.copyWith(extensions: extensions);
      _log.d('Loaded ${extensions.length} extensions');
      
-      // Log search behavior for extensions that have it
      for (final ext in extensions) {
        if (ext.searchBehavior != null) {
          _log.d('Extension ${ext.id}: thumbnailRatio=${ext.searchBehavior!.thumbnailRatio}');
@@ -480,6 +507,7 @@ class ExtensionNotifier extends Notifier<ExtensionState> {
    }
  }

+
  void clearError() {
    state = state.copyWith(error: null);
  }
@@ -525,7 +553,6 @@ class ExtensionNotifier extends Notifier<ExtensionState> {
    }
  }

-  /// Uninstall/remove an extension
  Future<bool> removeExtension(String extensionId) async {
    state = state.copyWith(isLoading: true, error: null);
    
@@ -542,6 +569,7 @@ class ExtensionNotifier extends Notifier<ExtensionState> {
    }
  }

+
  Future<void> setExtensionEnabled(String extensionId, bool enabled) async {
    try {
      await PlatformBridge.setExtensionEnabled(extensionId, enabled);
@@ -578,7 +606,6 @@ class ExtensionNotifier extends Notifier<ExtensionState> {
    }
  }

-  /// Get settings for an extension
  Future<Map<String, dynamic>> getExtensionSettings(String extensionId) async {
    try {
      return await PlatformBridge.getExtensionSettings(extensionId);
@@ -598,31 +625,67 @@ class ExtensionNotifier extends Notifier<ExtensionState> {
    }
  }

-  /// Load provider priority order
  Future<void> loadProviderPriority() async {
    try {
-      final priority = await PlatformBridge.getProviderPriority();
+      // Load from SharedPreferences first (persisted)
+      final prefs = await SharedPreferences.getInstance();
+      final savedJson = prefs.getString(_providerPriorityKey);
+      
+      List<String> priority;
+      if (savedJson != null) {
+        final saved = jsonDecode(savedJson) as List<dynamic>;
+        priority = saved.map((e) => e as String).toList();
+        _log.d('Loaded provider priority from prefs: $priority');
+        // Sync to Go backend
+        await PlatformBridge.setProviderPriority(priority);
+      } else {
+        // Fallback to Go backend default
+        priority = await PlatformBridge.getProviderPriority();
+        _log.d('Using default provider priority: $priority');
+      }
+      
      state = state.copyWith(providerPriority: priority);
    } catch (e) {
      _log.e('Failed to load provider priority: $e');
    }
  }

+
  Future<void> setProviderPriority(List<String> priority) async {
    try {
+      // Save to SharedPreferences for persistence
+      final prefs = await SharedPreferences.getInstance();
+      await prefs.setString(_providerPriorityKey, jsonEncode(priority));
+      
+      // Sync to Go backend
      await PlatformBridge.setProviderPriority(priority);
      state = state.copyWith(providerPriority: priority);
-      _log.d('Updated provider priority: $priority');
+      _log.d('Saved provider priority: $priority');
    } catch (e) {
      _log.e('Failed to set provider priority: $e');
      state = state.copyWith(error: e.toString());
    }
  }

-  /// Load metadata provider priority order
  Future<void> loadMetadataProviderPriority() async {
    try {
-      final priority = await PlatformBridge.getMetadataProviderPriority();
+      // Load from SharedPreferences first (persisted)
+      final prefs = await SharedPreferences.getInstance();
+      final savedJson = prefs.getString(_metadataProviderPriorityKey);
+      
+      List<String> priority;
+      if (savedJson != null) {
+        final saved = jsonDecode(savedJson) as List<dynamic>;
+        priority = saved.map((e) => e as String).toList();
+        _log.d('Loaded metadata provider priority from prefs: $priority');
+        // Sync to Go backend
+        await PlatformBridge.setMetadataProviderPriority(priority);
+      } else {
+        // Fallback to Go backend default
+        priority = await PlatformBridge.getMetadataProviderPriority();
+        _log.d('Using default metadata provider priority: $priority');
+      }
+      
      state = state.copyWith(metadataProviderPriority: priority);
    } catch (e) {
      _log.e('Failed to load metadata provider priority: $e');
@@ -631,16 +694,20 @@ class ExtensionNotifier extends Notifier<ExtensionState> {

  Future<void> setMetadataProviderPriority(List<String> priority) async {
    try {
+      // Save to SharedPreferences for persistence
+      final prefs = await SharedPreferences.getInstance();
+      await prefs.setString(_metadataProviderPriorityKey, jsonEncode(priority));
+      
+      // Sync to Go backend
      await PlatformBridge.setMetadataProviderPriority(priority);
      state = state.copyWith(metadataProviderPriority: priority);
-      _log.d('Updated metadata provider priority: $priority');
+      _log.d('Saved metadata provider priority: $priority');
    } catch (e) {
      _log.e('Failed to set metadata provider priority: $e');
      state = state.copyWith(error: e.toString());
    }
  }

-  /// Cleanup all extensions (call on app close)
  Future<void> cleanup() async {
    try {
      await PlatformBridge.cleanupExtensions();
@@ -658,7 +725,6 @@ class ExtensionNotifier extends Notifier<ExtensionState> {
    }
  }

-  /// Get all enabled extensions
  List<Extension> get enabledExtensions {
    return state.extensions.where((ext) => ext.enabled).toList();
  }
@@ -673,7 +739,6 @@ class ExtensionNotifier extends Notifier<ExtensionState> {
    return providers;
  }

-  /// Get all metadata providers (built-in + extensions)
  List<String> getAllMetadataProviders() {
    final providers = ['deezer', 'spotify'];
    for (final ext in state.extensions) {
@@ -683,6 +748,7 @@ class ExtensionNotifier extends Notifier<ExtensionState> {
    }
    return providers;
  }
+
  List<Extension> get searchProviders {
    return state.extensions.where((ext) => ext.enabled && ext.hasCustomSearch).toList();
  }
@@ -0,0 +1,582 @@
+import 'dart:async';
+import 'dart:io';
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:path_provider/path_provider.dart';
+import 'package:shared_preferences/shared_preferences.dart';
+import 'package:spotiflac_android/services/history_database.dart';
+import 'package:spotiflac_android/services/library_database.dart';
+import 'package:spotiflac_android/services/platform_bridge.dart';
+import 'package:spotiflac_android/utils/logger.dart';
+
+final _log = AppLogger('LocalLibrary');
+
+const _lastScannedAtKey = 'local_library_last_scanned_at';
+const _excludedDownloadedCountKey = 'local_library_excluded_downloaded_count';
+
+class LocalLibraryState {
+  final List<LocalLibraryItem> items;
+  final bool isScanning;
+  final double scanProgress;
+  final String? scanCurrentFile;
+  final int scanTotalFiles;
+  final int scannedFiles;
+  final int scanErrorCount;
+  final bool scanWasCancelled;
+  final DateTime? lastScannedAt;
+  final int excludedDownloadedCount;
+  final Set<String> _isrcSet;
+  final Set<String> _trackKeySet;
+  final Map<String, LocalLibraryItem> _byIsrc;
+
+  LocalLibraryState({
+    this.items = const [],
+    this.isScanning = false,
+    this.scanProgress = 0,
+    this.scanCurrentFile,
+    this.scanTotalFiles = 0,
+    this.scannedFiles = 0,
+    this.scanErrorCount = 0,
+    this.scanWasCancelled = false,
+    this.lastScannedAt,
+    this.excludedDownloadedCount = 0,
+  }) : _isrcSet = items
+           .where((item) => item.isrc != null && item.isrc!.isNotEmpty)
+           .map((item) => item.isrc!)
+           .toSet(),
+       _trackKeySet = items.map((item) => item.matchKey).toSet(),
+       _byIsrc = Map.fromEntries(
+         items
+             .where((item) => item.isrc != null && item.isrc!.isNotEmpty)
+             .map((item) => MapEntry(item.isrc!, item)),
+       );
+
+  bool hasIsrc(String isrc) => _isrcSet.contains(isrc);
+
+  bool hasTrack(String trackName, String artistName) {
+    final key = '${trackName.toLowerCase()}|${artistName.toLowerCase()}';
+    return _trackKeySet.contains(key);
+  }
+
+  LocalLibraryItem? getByIsrc(String isrc) => _byIsrc[isrc];
+
+  LocalLibraryItem? findByTrackAndArtist(String trackName, String artistName) {
+    final key = '${trackName.toLowerCase()}|${artistName.toLowerCase()}';
+    return items.where((item) => item.matchKey == key).firstOrNull;
+  }
+
+  bool existsInLibrary({String? isrc, String? trackName, String? artistName}) {
+    if (isrc != null && isrc.isNotEmpty && hasIsrc(isrc)) {
+      return true;
+    }
+    if (trackName != null && artistName != null) {
+      return hasTrack(trackName, artistName);
+    }
+    return false;
+  }
+
+  LocalLibraryState copyWith({
+    List<LocalLibraryItem>? items,
+    bool? isScanning,
+    double? scanProgress,
+    String? scanCurrentFile,
+    int? scanTotalFiles,
+    int? scannedFiles,
+    int? scanErrorCount,
+    bool? scanWasCancelled,
+    DateTime? lastScannedAt,
+    int? excludedDownloadedCount,
+  }) {
+    return LocalLibraryState(
+      items: items ?? this.items,
+      isScanning: isScanning ?? this.isScanning,
+      scanProgress: scanProgress ?? this.scanProgress,
+      scanCurrentFile: scanCurrentFile ?? this.scanCurrentFile,
+      scanTotalFiles: scanTotalFiles ?? this.scanTotalFiles,
+      scannedFiles: scannedFiles ?? this.scannedFiles,
+      scanErrorCount: scanErrorCount ?? this.scanErrorCount,
+      scanWasCancelled: scanWasCancelled ?? this.scanWasCancelled,
+      lastScannedAt: lastScannedAt ?? this.lastScannedAt,
+      excludedDownloadedCount:
+          excludedDownloadedCount ?? this.excludedDownloadedCount,
+    );
+  }
+}
+
+class LocalLibraryNotifier extends Notifier<LocalLibraryState> {
+  final LibraryDatabase _db = LibraryDatabase.instance;
+  final HistoryDatabase _historyDb = HistoryDatabase.instance;
+  static const _progressPollingInterval = Duration(milliseconds: 800);
+  Timer? _progressTimer;
+  bool _isLoaded = false;
+  bool _scanCancelRequested = false;
+  int _progressPollingErrorCount = 0;
+
+  @override
+  LocalLibraryState build() {
+    ref.onDispose(() {
+      _progressTimer?.cancel();
+    });
+
+    Future.microtask(() async {
+      await _loadFromDatabase();
+    });
+    return LocalLibraryState();
+  }
+
+  Future<void> _loadFromDatabase() async {
+    if (_isLoaded) return;
+    _isLoaded = true;
+
+    try {
+      final jsonList = await _db.getAll();
+      final items = jsonList.map((e) => LocalLibraryItem.fromJson(e)).toList();
+
+      DateTime? lastScannedAt;
+      var excludedDownloadedCount = 0;
+      try {
+        final prefs = await SharedPreferences.getInstance();
+        final lastScannedAtStr = prefs.getString(_lastScannedAtKey);
+        if (lastScannedAtStr != null && lastScannedAtStr.isNotEmpty) {
+          lastScannedAt = DateTime.tryParse(lastScannedAtStr);
+        }
+        excludedDownloadedCount =
+            prefs.getInt(_excludedDownloadedCountKey) ?? 0;
+      } catch (e) {
+        _log.w('Failed to load lastScannedAt: $e');
+      }
+
+      state = state.copyWith(
+        items: items,
+        lastScannedAt: lastScannedAt,
+        excludedDownloadedCount: excludedDownloadedCount,
+      );
+      _log.i(
+        'Loaded ${items.length} items from library database, lastScannedAt: '
+        '$lastScannedAt, excludedDownloadedCount: $excludedDownloadedCount',
+      );
+    } catch (e, stack) {
+      _log.e('Failed to load library from database: $e', e, stack);
+    }
+  }
+
+  Future<void> reloadFromStorage() async {
+    _isLoaded = false;
+    await _loadFromDatabase();
+  }
+
+  Future<void> startScan(
+    String folderPath, {
+    bool forceFullScan = false,
+  }) async {
+    if (state.isScanning) {
+      _log.w('Scan already in progress');
+      return;
+    }
+
+    _scanCancelRequested = false;
+    _log.i(
+      'Starting library scan: $folderPath (incremental: ${!forceFullScan})',
+    );
+    state = state.copyWith(
+      isScanning: true,
+      scanProgress: 0,
+      scanCurrentFile: null,
+      scanTotalFiles: 0,
+      scannedFiles: 0,
+      scanErrorCount: 0,
+      scanWasCancelled: false,
+    );
+
+    try {
+      final appSupportDir = await getApplicationSupportDirectory();
+      final coverCacheDir = '${appSupportDir.path}/library_covers';
+      await PlatformBridge.setLibraryCoverCacheDir(coverCacheDir);
+      _log.i('Cover cache directory set to: $coverCacheDir');
+    } catch (e) {
+      _log.w('Failed to set cover cache directory: $e');
+    }
+
+    _startProgressPolling();
+
+    try {
+      final isSaf = folderPath.startsWith('content://');
+
+      // Get all file paths from download history to exclude them
+      final downloadedPaths = await _historyDb.getAllFilePaths();
+      _log.i(
+        'Excluding ${downloadedPaths.length} downloaded files from library scan',
+      );
+
+      if (forceFullScan) {
+        // Full scan path - ignores existing data
+        final results = isSaf
+            ? await PlatformBridge.scanSafTree(folderPath)
+            : await PlatformBridge.scanLibraryFolder(folderPath);
+        if (_scanCancelRequested) {
+          state = state.copyWith(isScanning: false, scanWasCancelled: true);
+          return;
+        }
+
+        final items = <LocalLibraryItem>[];
+        int skippedDownloads = 0;
+        for (final json in results) {
+          final filePath = json['filePath'] as String?;
+          // Skip files that are already in download history
+          if (filePath != null && downloadedPaths.contains(filePath)) {
+            skippedDownloads++;
+            continue;
+          }
+          final item = LocalLibraryItem.fromJson(json);
+          items.add(item);
+        }
+
+        if (skippedDownloads > 0) {
+          _log.i('Skipped $skippedDownloads files already in download history');
+        }
+
+        await _db.upsertBatch(items.map((e) => e.toJson()).toList());
+
+        final now = DateTime.now();
+        try {
+          final prefs = await SharedPreferences.getInstance();
+          await prefs.setString(_lastScannedAtKey, now.toIso8601String());
+          await prefs.setInt(_excludedDownloadedCountKey, skippedDownloads);
+          _log.d('Saved lastScannedAt: $now');
+        } catch (e) {
+          _log.w('Failed to save lastScannedAt: $e');
+        }
+
+        state = state.copyWith(
+          items: items,
+          isScanning: false,
+          scanProgress: 100,
+          lastScannedAt: now,
+          scanWasCancelled: false,
+          excludedDownloadedCount: skippedDownloads,
+        );
+
+        _log.i(
+          'Full scan complete: ${items.length} tracks found, '
+          '$skippedDownloads already in downloads',
+        );
+      } else {
+        // Incremental scan path - only scans new/modified files
+        final existingFiles = await _db.getFileModTimes();
+        _log.i(
+          'Incremental scan: ${existingFiles.length} existing files in database',
+        );
+
+        final backfilledModTimes = await _backfillLegacyFileModTimes(
+          isSaf: isSaf,
+          existingFiles: existingFiles,
+        );
+        if (backfilledModTimes.isNotEmpty) {
+          await _db.updateFileModTimes(backfilledModTimes);
+          existingFiles.addAll(backfilledModTimes);
+          _log.i('Backfilled ${backfilledModTimes.length} legacy mod times');
+        }
+
+        // Use appropriate incremental scan method based on SAF or not
+        final Map<String, dynamic> result;
+        if (isSaf) {
+          result = await PlatformBridge.scanSafTreeIncremental(
+            folderPath,
+            existingFiles,
+          );
+        } else {
+          result = await PlatformBridge.scanLibraryFolderIncremental(
+            folderPath,
+            existingFiles,
+          );
+        }
+
+        if (_scanCancelRequested) {
+          state = state.copyWith(isScanning: false, scanWasCancelled: true);
+          return;
+        }
+
+        // Parse incremental scan result
+        // SAF returns 'files' and 'removedUris', non-SAF returns 'scanned' and 'deletedPaths'
+        final scannedList =
+            (result['files'] as List<dynamic>?) ??
+            (result['scanned'] as List<dynamic>?) ??
+            [];
+        final deletedPaths =
+            (result['removedUris'] as List<dynamic>?)
+                ?.map((e) => e as String)
+                .toList() ??
+            (result['deletedPaths'] as List<dynamic>?)
+                ?.map((e) => e as String)
+                .toList() ??
+            [];
+        final skippedCount = result['skippedCount'] as int? ?? 0;
+        final totalFiles = result['totalFiles'] as int? ?? 0;
+
+        _log.i(
+          'Incremental result: ${scannedList.length} scanned, '
+          '$skippedCount skipped, ${deletedPaths.length} deleted, $totalFiles total',
+        );
+
+        final currentByPath = <String, LocalLibraryItem>{
+          for (final item in state.items) item.filePath: item,
+        };
+
+        // Upsert new/modified items (excluding downloaded files)
+        final updatedItems = <LocalLibraryItem>[];
+        int skippedDownloads = 0;
+        if (scannedList.isNotEmpty) {
+          for (final json in scannedList) {
+            final map = json as Map<String, dynamic>;
+            final filePath = map['filePath'] as String?;
+            if (filePath != null && downloadedPaths.contains(filePath)) {
+              skippedDownloads++;
+              continue;
+            }
+            final item = LocalLibraryItem.fromJson(map);
+            updatedItems.add(item);
+            currentByPath[item.filePath] = item;
+          }
+          if (updatedItems.isNotEmpty) {
+            await _db.upsertBatch(updatedItems.map((e) => e.toJson()).toList());
+            _log.i('Upserted ${updatedItems.length} items');
+          }
+          if (skippedDownloads > 0) {
+            _log.i(
+              'Skipped $skippedDownloads files already in download history',
+            );
+          }
+        }
+
+        // Delete removed items
+        if (deletedPaths.isNotEmpty) {
+          final deleteCount = await _db.deleteByPaths(deletedPaths);
+          for (final path in deletedPaths) {
+            currentByPath.remove(path);
+          }
+          _log.i('Deleted $deleteCount items from database');
+        }
+
+        final items = currentByPath.values.toList(growable: false)
+          ..sort(_compareLibraryItems);
+
+        final now = DateTime.now();
+        try {
+          final prefs = await SharedPreferences.getInstance();
+          await prefs.setString(_lastScannedAtKey, now.toIso8601String());
+          await prefs.setInt(_excludedDownloadedCountKey, skippedDownloads);
+          _log.d('Saved lastScannedAt: $now');
+        } catch (e) {
+          _log.w('Failed to save lastScannedAt: $e');
+        }
+
+        state = state.copyWith(
+          items: items,
+          isScanning: false,
+          scanProgress: 100,
+          lastScannedAt: now,
+          scanWasCancelled: false,
+          excludedDownloadedCount: skippedDownloads,
+        );
+
+        _log.i(
+          'Incremental scan complete: ${items.length} total tracks '
+          '(${scannedList.length} new/updated, $skippedCount unchanged, '
+          '${deletedPaths.length} removed, $skippedDownloads already in downloads)',
+        );
+      }
+    } catch (e, stack) {
+      _log.e('Library scan failed: $e', e, stack);
+      state = state.copyWith(isScanning: false, scanWasCancelled: false);
+    } finally {
+      _stopProgressPolling();
+    }
+  }
+
+  void _startProgressPolling() {
+    _progressTimer?.cancel();
+    _progressTimer = Timer.periodic(_progressPollingInterval, (_) async {
+      try {
+        final progress = await PlatformBridge.getLibraryScanProgress();
+
+        state = state.copyWith(
+          scanProgress: (progress['progress_pct'] as num?)?.toDouble() ?? 0,
+          scanCurrentFile: progress['current_file'] as String?,
+          scanTotalFiles: progress['total_files'] as int? ?? 0,
+          scannedFiles: progress['scanned_files'] as int? ?? 0,
+          scanErrorCount: progress['error_count'] as int? ?? 0,
+        );
+
+        if (progress['is_complete'] == true) {
+          _stopProgressPolling();
+        }
+        _progressPollingErrorCount = 0;
+      } catch (e) {
+        _progressPollingErrorCount++;
+        if (_progressPollingErrorCount <= 3) {
+          _log.w('Library scan progress polling failed: $e');
+        }
+      }
+    });
+  }
+
+  void _stopProgressPolling() {
+    _progressTimer?.cancel();
+    _progressTimer = null;
+    _progressPollingErrorCount = 0;
+  }
+
+  Future<void> cancelScan() async {
+    if (!state.isScanning) return;
+
+    _log.i('Cancelling library scan');
+    _scanCancelRequested = true;
+    await PlatformBridge.cancelLibraryScan();
+    state = state.copyWith(isScanning: false, scanWasCancelled: true);
+    _stopProgressPolling();
+  }
+
+  Future<int> cleanupMissingFiles() async {
+    final removed = await _db.cleanupMissingFiles();
+    if (removed > 0) {
+      await reloadFromStorage();
+    }
+    return removed;
+  }
+
+  Future<void> clearLibrary() async {
+    await _db.clearAll();
+
+    try {
+      final prefs = await SharedPreferences.getInstance();
+      await prefs.remove(_lastScannedAtKey);
+      await prefs.remove(_excludedDownloadedCountKey);
+    } catch (e) {
+      _log.w('Failed to clear lastScannedAt: $e');
+    }
+
+    state = LocalLibraryState();
+    _log.i('Library cleared');
+  }
+
+  Future<void> removeItem(String id) async {
+    await _db.delete(id);
+    state = state.copyWith(
+      items: state.items.where((item) => item.id != id).toList(),
+    );
+  }
+
+  bool existsInLibrary({String? isrc, String? trackName, String? artistName}) {
+    return state.existsInLibrary(
+      isrc: isrc,
+      trackName: trackName,
+      artistName: artistName,
+    );
+  }
+
+  LocalLibraryItem? getByIsrc(String isrc) {
+    return state.getByIsrc(isrc);
+  }
+
+  LocalLibraryItem? findExisting({
+    String? isrc,
+    String? trackName,
+    String? artistName,
+  }) {
+    if (isrc != null && isrc.isNotEmpty) {
+      final byIsrc = state.getByIsrc(isrc);
+      if (byIsrc != null) return byIsrc;
+    }
+    if (trackName != null && artistName != null) {
+      return state.findByTrackAndArtist(trackName, artistName);
+    }
+    return null;
+  }
+
+  Future<List<LocalLibraryItem>> search(String query) async {
+    if (query.isEmpty) return [];
+
+    final results = await _db.search(query);
+    return results.map((e) => LocalLibraryItem.fromJson(e)).toList();
+  }
+
+  Future<int> getCount() async {
+    return await _db.getCount();
+  }
+
+  int _compareLibraryItems(LocalLibraryItem a, LocalLibraryItem b) {
+    final artistA = (a.albumArtist ?? a.artistName).toLowerCase();
+    final artistB = (b.albumArtist ?? b.artistName).toLowerCase();
+    final artistCompare = artistA.compareTo(artistB);
+    if (artistCompare != 0) return artistCompare;
+
+    final albumCompare = a.albumName.toLowerCase().compareTo(
+      b.albumName.toLowerCase(),
+    );
+    if (albumCompare != 0) return albumCompare;
+
+    final discCompare = (a.discNumber ?? 0).compareTo(b.discNumber ?? 0);
+    if (discCompare != 0) return discCompare;
+
+    return (a.trackNumber ?? 0).compareTo(b.trackNumber ?? 0);
+  }
+
+  Future<Map<String, int>> _backfillLegacyFileModTimes({
+    required bool isSaf,
+    required Map<String, int> existingFiles,
+  }) async {
+    final legacyPaths = existingFiles.entries
+        .where((entry) => entry.value <= 0)
+        .map((entry) => entry.key)
+        .toList();
+    if (legacyPaths.isEmpty) {
+      return const {};
+    }
+
+    if (isSaf) {
+      final uris = legacyPaths
+          .where((path) => path.startsWith('content://'))
+          .toList();
+      if (uris.isEmpty) {
+        return const {};
+      }
+      const chunkSize = 500;
+      final backfilled = <String, int>{};
+      try {
+        for (var i = 0; i < uris.length; i += chunkSize) {
+          if (_scanCancelRequested) {
+            break;
+          }
+          final end = (i + chunkSize < uris.length)
+              ? i + chunkSize
+              : uris.length;
+          final chunk = uris.sublist(i, end);
+          final chunkResult = await PlatformBridge.getSafFileModTimes(chunk);
+          backfilled.addAll(chunkResult);
+        }
+        return backfilled;
+      } catch (e) {
+        _log.w('Failed to backfill SAF mod times: $e');
+        return const {};
+      }
+    }
+
+    final backfilled = <String, int>{};
+    for (final path in legacyPaths) {
+      if (_scanCancelRequested || path.startsWith('content://')) {
+        continue;
+      }
+      try {
+        final stat = await File(path).stat();
+        if (stat.type == FileSystemEntityType.file) {
+          backfilled[path] = stat.modified.millisecondsSinceEpoch;
+        }
+      } catch (_) {}
+    }
+    return backfilled;
+  }
+}
+
+final localLibraryProvider =
+    NotifierProvider<LocalLibraryNotifier, LocalLibraryState>(
+      LocalLibraryNotifier.new,
+    );
--- a/Show More
+++ b/Show More