fix(ios): remove stale built-in Spotify bridge handlers

docs: add centered Trendshift badge below README banner
2026-07-03 19:27:57 +02:00 · 2026-03-11 17:08:46 +07:00 · 2026-03-11 17:08:45 +07:00
195 changed files with 18642 additions and 52268 deletions
@@ -1,3 +0,0 @@
-{
-  "flutter": "3.41.5"
-}
@@ -4,5 +4,5 @@ contact_links:
    url: https://github.com/zarzet/SpotiFLAC-Mobile#readme
    about: Check the README for setup instructions and FAQ
  - name: Extension Development Guide
-    url: https://spotiflac.zarz.moe/docs
+    url: https://zarz.moe/docs
    about: Documentation for building SpotiFLAC extensions
@@ -71,7 +71,7 @@ jobs:
      - name: Setup Go
        uses: actions/setup-go@v6
        with:
-          go-version: "1.25.8"
+          go-version: "1.25.7"
          cache-dependency-path: go_backend/go.sum

      # Cache Gradle for faster builds
@@ -93,12 +93,12 @@ jobs:
          # Accept licenses
          yes | $ANDROID_HOME/cmdline-tools/latest/bin/sdkmanager --licenses || true

-          # Install NDK r29 (supports 16KB page size for Android 15+)
+          # Install NDK r27d LTS (required for 16KB page size support on Android 15+)
          # Platform android-36 and build-tools 36.0.0 for targetSdk 36 (Android 16)
-          $ANDROID_HOME/cmdline-tools/latest/bin/sdkmanager "ndk;29.0.14206865" "platforms;android-36" "build-tools;36.0.0"
+          $ANDROID_HOME/cmdline-tools/latest/bin/sdkmanager "ndk;27.3.13750724" "platforms;android-36" "build-tools;36.0.0"

          # Set NDK path
-          echo "ANDROID_NDK_HOME=$ANDROID_HOME/ndk/29.0.14206865" >> $GITHUB_ENV
+          echo "ANDROID_NDK_HOME=$ANDROID_HOME/ndk/27.3.13750724" >> $GITHUB_ENV

      - name: Install gomobile
        run: |
@@ -164,22 +164,17 @@ jobs:
          path: build/app/outputs/flutter-apk/SpotiFLAC-*.apk

  build-ios:
-    runs-on: macos-15
+    runs-on: macos-latest
    needs: get-version # Only depends on version, NOT android build!

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

-      - name: Select Xcode 26.1.1
-        run: |
-          sudo xcode-select -s /Applications/Xcode_26.1.1.app
-          xcodebuild -version
-
      - name: Setup Go
        uses: actions/setup-go@v6
        with:
-          go-version: "1.25.8"
+          go-version: "1.25.7"
          cache-dependency-path: go_backend/go.sum

      # Cache CocoaPods
@@ -349,18 +344,9 @@ jobs:
          VERSION=${{ needs.get-version.outputs.version }}
          REPO_OWNER="${{ github.repository_owner }}"
          REPO_NAME="${{ github.event.repository.name }}"
-          CURRENT_REF=$(git rev-list -n 1 "$VERSION" 2>/dev/null || git rev-parse HEAD)
-          PREVIOUS_TAG=$(git describe --tags --abbrev=0 "${CURRENT_REF}^" 2>/dev/null || true)

-          # Start with git-cliff changelog, but replace its compare footer with a
-          # deterministic previous-tag lookup from git.
-          sed '/^## [0-9][0-9.[:alpha:]-]*$/d; /^\*\*Full Changelog\*\*/d' /tmp/changelog.txt > /tmp/release_body.txt
-
-          if [ -n "$PREVIOUS_TAG" ]; then
-            printf '\n**Full Changelog**: [%s...%s](https://github.com/%s/%s/compare/%s...%s)\n' \
-              "$PREVIOUS_TAG" "$VERSION" "$REPO_OWNER" "$REPO_NAME" "$PREVIOUS_TAG" "$VERSION" \
-              >> /tmp/release_body.txt
-          fi
+          # Start with git-cliff changelog
+          cp /tmp/changelog.txt /tmp/release_body.txt

          # Append download section
          cat >> /tmp/release_body.txt << FOOTER
@@ -398,63 +384,6 @@ jobs:
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

-  update-altstore:
-    runs-on: ubuntu-latest
-    needs: [get-version, build-ios, create-release]
-    if: ${{ needs.get-version.outputs.is_prerelease != 'true' }}
-    permissions:
-      contents: write
-
-    steps:
-      - name: Checkout main branch
-        uses: actions/checkout@v6
-        with:
-          ref: main
-
-      - name: Download iOS IPA
-        uses: actions/download-artifact@v7
-        with:
-          name: ios-ipa
-          path: ./release
-
-      - name: Update apps.json
-        run: |
-          VERSION="${{ needs.get-version.outputs.version }}"
-          VERSION_NUM="${VERSION#v}"
-          DATE=$(date -u +%Y-%m-%d)
-          IPA_FILE=$(find ./release -name "*ios*.ipa" | head -1)
-
-          if [ -z "$IPA_FILE" ]; then
-            echo "WARNING: IPA file not found, skipping apps.json update"
-            exit 0
-          fi
-
-          IPA_SIZE=$(stat -c%s "$IPA_FILE" 2>/dev/null || stat -f%z "$IPA_FILE")
-
-          if [ ! -f apps.json ]; then
-            echo "WARNING: apps.json not found on main, skipping"
-            exit 0
-          fi
-
-          jq --arg ver "$VERSION_NUM" \
-             --arg date "$DATE" \
-             --arg url "https://github.com/zarzet/SpotiFLAC-Mobile/releases/download/${VERSION}/SpotiFLAC-${VERSION}-ios-unsigned.ipa" \
-             --argjson size "$IPA_SIZE" \
-             '.apps[0].version = $ver | .apps[0].versionDate = $date | .apps[0].downloadURL = $url | .apps[0].size = $size' \
-             apps.json > apps.json.tmp && mv apps.json.tmp apps.json
-
-          echo "Updated apps.json:"
-          cat apps.json
-
-      - name: Commit and push
-        run: |
-          VERSION="${{ needs.get-version.outputs.version }}"
-          git config user.name "github-actions[bot]"
-          git config user.email "github-actions[bot]@users.noreply.github.com"
-          git add apps.json
-          git diff --cached --quiet && echo "No changes to commit" || \
-            (git commit -m "chore: update AltStore source to ${VERSION}" && git push)
-
  notify-telegram:
    runs-on: ubuntu-latest
    needs: [get-version, create-release]
@@ -495,10 +424,7 @@ jobs:
          else
            # Convert Markdown to Telegram HTML
            CHANGELOG=$(cat /tmp/cliff_tg.txt | \
-              sed '/^## [0-9][0-9.[:alpha:]-]*$/d' | \
              sed '/^\*\*Full Changelog\*\*/d' | \
-              sed 's/ by \[@[^]]*\](https:\/\/github\.com\/[^)]*)//g' | \
-              sed 's/ by @[A-Za-z0-9_-]\+//g' | \
              sed 's/\[#\([0-9]*\)\]([^)]*)/#\1/g' | \
              sed 's/\[@\([^]]*\)\]([^)]*)/@\1/g' | \
              sed 's/&/\&amp;/g' | \
@@ -67,7 +67,6 @@ AGENTS.md

 # Temp/misc
 nul
-network_requests.txt

 # Log files
 *.log
@@ -77,7 +76,3 @@ flutter_*.log
 # Development tools
 tool/
 .claude/settings.local.json
-.playwright-mcp/
-
-# FVM Version Cache
-.fvm/
@@ -334,7 +334,7 @@ Thank you for your understanding and continued support. This decision was made t
  - Routing priority: YouTube service -> extension fallback -> built-in fallback -> direct service
 - New Android method channel handler: `"downloadByStrategy"` -> `Gobackend.downloadByStrategy(...)`
 - SpotFetch metadata fallback integration for Spotify-blocked regions
-  - New backend client for `sp.afkarxyz.qzz.io/api`
+  - New backend client for `spotify.afkarxyz.fun/api`
  - Automatic fallback in Spotify metadata fetch path when primary source fails
 - Lyrics extraction now supports MP3 (ID3v2) and Opus/OGG (Vorbis comments) in addition to FLAC
  - Includes heuristic detection of lyrics stored in Comment fields
@@ -349,7 +349,7 @@ Thank you for your understanding and continued support. This decision was made t
 - Legacy Dart bridge methods (`downloadTrack`, `downloadWithFallback`, `downloadWithExtensions`, `downloadFromYouTube`) are now thin wrappers and marked `@Deprecated`
 - Qobuz downloader updated to latest Jumo API contract (`/get` endpoint, required headers)
 - Amazon download flow now returns `decryption_key` from Go and performs decryption in Flutter (local file + SAF paths)
- Amazon now uses the new `amzn.afkarxyz.qzz.io` API flow (ASIN-based track endpoint + legacy fallback) with encrypted stream support
+- Amazon now uses the new `amazon.afkarxyz.fun` API flow (ASIN-based track endpoint + legacy fallback) with encrypted stream support
 - Amazon ASIN extraction rewritten with robust URL/query-param parsing and regex fallback
 - Amazon provider re-enabled in download service picker and download settings (alongside Tidal, Qobuz, and YouTube picker flow)
 - Track Metadata cover UI now refreshes from the embedded file after Edit Metadata/Re-enrich, so the displayed art matches actual file tags
@@ -86,31 +86,17 @@ Translation files are located in `lib/l10n/arb/`.
   git remote add upstream https://github.com/zarzet/SpotiFLAC-Mobile.git
   ```

-3. **Use FVM (Flutter Version: 3.38.1)**
-   ```bash
-   fvm use
-   ```
-
-4. **Install dependencies**
+3. **Install dependencies**
   ```bash
   flutter pub get
   ```

-5. **Generate code** (for Riverpod, JSON serialization, etc.)
+4. **Generate code** (for Riverpod, JSON serialization, etc.)
   ```bash
   dart run build_runner build --delete-conflicting-outputs
   ```

-6. **Set up Go environment (Go Version: 1.25.7)**
-   ```bash
-   cd go_backend 
-   mkdir -p ../android/app/libs
-   gomobile init
-   gomobile bind -target=android -androidapi 24 -o ../android/app/libs/gobackend.aar .
-   cd ..
-   ```
-
-7. **Run the app**
+5. **Run the app**
   ```bash
   flutter run
   ```
@@ -14,17 +14,6 @@

 </div>

-<div align="center">
-
-[![GitHub Release](https://img.shields.io/github/v/release/zarzet/SpotiFLAC-Mobile?style=for-the-badge&logo=github)](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/31d1bf3c3b2015c13e83c4f909a7c6093a9423e3e702f0c582a3e0035c849424)
-[![Crowdin](https://img.shields.io/badge/HELP%20TRANSLATE%20ON-CROWDIN-%2321252b?style=for-the-badge&logo=crowdin)](https://crowdin.com/project/spotiflac-mobile)
-
-[![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)
-
-</div>
-
 ## Screenshots

 <p align="center">
@@ -34,154 +23,68 @@
  <img src="assets/images/4.jpg?v=2" width="200" />
 </p>

---
+<div align="center">
+
+[![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/0a2bd2a033551983fc9fcd83f82fd912c83914fd1094cd8d1c7c6a68eb23233f)
+[![Crowdin](https://img.shields.io/badge/HELP%20TRANSLATE%20ON-CROWDIN-%2321252b?style=for-the-badge&logo=crowdin)](https://crowdin.com/project/spotiflac-mobile)
+
+[![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)
+
+</div>

 ## Extensions

-Extensions let the community 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.
+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.

 ### Installing Extensions
-
-1. Open the **Store** tab in the app
-2. On first launch, enter an **Extension Repository URL** when prompted
-3. Browse and install extensions with one tap
-4. Or download a `.spotiflac-ext` file and install manually via **Settings > Extensions**
-5. Configure extension settings if needed
-6. Set provider priority under **Settings > Extensions > Provider Priority**
+1. Go to **Store** tab in the app
+2. Browse and install extensions with one tap
+3. Or download a `.spotiflac-ext` file and install manually via **Settings > Extensions**
+4. Configure extension settings if needed
+5. Set provider priority in **Settings > Extensions > Provider Priority**

 ### Developing Extensions
+Want to create your own extension? Check out the [Extension Development Guide](https://zarz.moe/docs) for complete documentation.

-> [!NOTE]
-> Want to build your own extension? The [Extension Development Guide](https://zarzet.github.io/SpotiFLAC-Mobile/docs) has everything you need.
-
---
-
-## Related Projects
+## Other project

 ### [SpotiFLAC (Desktop)](https://github.com/afkarxyz/SpotiFLAC)
-Download music in true lossless FLAC from Tidal, Qobuz & Amazon Music available for Windows, macOS & Linux.
-
-### [SpotiFLAC (Python Module)](https://github.com/ShuShuzinhuu/SpotiFLAC-Module-Version)
-Python library for SpotiFLAC integration, maintained by [@ShuShuzinhuu](https://github.com/ShuShuzinhuu).
-
---
+Download music in true lossless FLAC from Tidal, Qobuz & Amazon Music for Windows, macOS & Linux

 ## FAQ

-<details>
-<summary><b>Why does the Store tab ask me to enter a URL?</b></summary>
-<br>
+**Q: Why is my download failing with "Song not found"?**  
+A: The track may not be available on the streaming services. Try enabling more download services in Settings > Download > Provider Priority, or install additional extensions like Amazon Music from the Store.

-Starting from version 3.8.0, SpotiFLAC uses a decentralized extension repository system extensions are hosted on GitHub repositories rather than a built-in server, so anyone can create and host their own. Enter a repository URL in the Store tab to browse and install extensions.
+**Q: Why are some tracks downloading in lower quality?**  
+A: Quality depends on what's available from the streaming service and extensions. Built-in providers: Tidal offers up to 24-bit/192kHz, Qobuz up to 24-bit/192kHz, and Deezer up to 16-bit/44.1kHz.

-</details>
+**Q: Can I download playlists?**  
+A: Yes! Just paste the playlist URL in the search bar. The app will fetch all tracks and queue them for download.

-<details>
-<summary><b>Why is my download failing with "Song not found"?</b></summary>
-<br>
+**Q: Why do I need to grant storage permission?**  
+A: The app needs permission to save downloaded files to your device. On Android 13+, you may need to grant "All files access" in Settings > Apps > SpotiFLAC > Permissions.

-The track may not be available on the streaming services. Try enabling more providers under **Settings > Download > Provider Priority**, or install additional extensions like Amazon Music from the Store.
+**Q: Is this app safe?**  
+A: Yes, the app is open source and you can verify the code yourself. Each release is scanned with VirusTotal (see badge at top of README).

-</details>
+**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.

-<details>
-<summary><b>Why are some tracks downloading in lower quality?</b></summary>
-<br>

-Quality depends on what's available from the streaming service and its extensions. Built-in providers:
- **Tidal** up to 24-bit/192kHz
- **Qobuz** up to 24-bit/192kHz
- **Deezer** up to 16-bit/44.1kHz
+### Want to support SpotiFLAC-Mobile?

-</details>
+_If this software is useful and brings you value, consider supporting the project. Your support helps keep development going._

-<details>
-<summary><b>Can I download playlists?</b></summary>
-<br>
-
-Yes! Just paste the playlist URL in the search bar. The app will fetch all tracks and queue them for download.
-
-</details>
-
-<details>
-<summary><b>Why do I need to grant storage permission?</b></summary>
-<br>
-
-The app needs permission to save downloaded files to your device. On Android 13+, you may need to grant **All files access** under **Settings > Apps > SpotiFLAC > Permissions**.
-
-</details>
-
-<details>
-<summary><b>Is this app safe?</b></summary>
-<br>
-
-Yes SpotiFLAC is open source and you can verify the code yourself. Each release is also scanned with VirusTotal (see badge above).
-
-</details>
-
-<details>
-<summary><b>Why is downloading not working in my country?</b></summary>
-<br>
-
-Some countries have restricted access to certain streaming service APIs. If downloads are failing, try using a VPN to connect through a different region.
-
-</details>
-
-<details>
-<summary><b>Can I add SpotiFLAC to AltStore or SideStore?</b></summary>
-<br>
-
-Yes! Add the official source to receive updates directly within the app. Copy this link:
-
-```
-https://raw.githubusercontent.com/zarzet/SpotiFLAC-Mobile/refs/heads/main/apps.json
-```
-
-In AltStore/SideStore, go to **Browse > Sources**, tap **+**, and paste the link.
-
-</details>
-
-> [!NOTE]
-> If SpotiFLAC is useful to you, consider supporting development:
->
-> [![Ko-fi](https://ko-fi.com/img/githubbutton_sm.svg)](https://ko-fi.com/zarzet)
-
---
-
-## Contributors
-
-Thanks to everyone who has contributed to SpotiFLAC Mobile!
-
-<a href="https://github.com/zarzet/SpotiFLAC-Mobile/graphs/contributors">
-  <img src="https://contrib.rocks/image?repo=zarzet/SpotiFLAC-Mobile" />
-</a>
-
-We also appreciate everyone who helped with [translations on Crowdin](https://crowdin.com/project/spotiflac-mobile), reported bugs, suggested features, and spread the word.
-
-Interested in contributing? Check out the [Contributing Guide](CONTRIBUTING.md) to get started!
-
---
+[![Ko-fi](https://ko-fi.com/img/githubbutton_sm.svg)](https://ko-fi.com/zarzet)

 ## API Credits

-| | | | | |
-|---|---|---|---|---|
-| [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) |
-| [dabmusic.xyz](https://dabmusic.xyz) | [AfkarXYZ](https://github.com/afkarxyz) | [LRCLib](https://lrclib.net) | [Paxsenix](https://lyrics.paxsenix.org) | [Cobalt](https://cobalt.tools) |
-| [qwkuns.me](https://qwkuns.me) | [SpotubeDL](https://spotubedl.com) | [Song.link](https://song.link) | [IDHS](https://github.com/sjdonado/idonthavespotify) | |
+[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) · [dabmusic.xyz](https://dabmusic.xyz) · [AfkarXYZ](https://github.com/afkarxyz) · [LRCLib](https://lrclib.net) · [Paxsenix](https://lyrics.paxsenix.org) · [Cobalt](https://cobalt.tools) · [qwkuns.me](https://qwkuns.me) · [SpotubeDL](https://spotubedl.com) · [Song.link](https://song.link) · [IDHS](https://github.com/sjdonado/idonthavespotify)

---
-
-## Disclaimer
-
-This repository and its contents are provided strictly for educational and research purposes. The software is provided "as-is" without warranty of any kind, express or implied, as stated in the [MIT License](LICENSE).
-
- No copyrighted content is hosted, stored, mirrored, or distributed by this repository.
- Users must ensure that their use of this software is properly authorized and complies with all applicable laws, regulations, and third-party terms of service.
- This software is provided free of charge by the maintainer. If you paid a third party for access to this software in its original form from this repository, you may have been misled or scammed. Any redistribution or commercial use by third parties must comply with the terms of the repository license. No affiliation, endorsement, or support by the maintainer is implied unless explicitly stated in writing.
- SpotiFLAC Mobile is an independent project. It is not affiliated with, endorsed by, or connected to any other project or version on other platforms that may share a similar name. The maintainer of this repository has no control over or responsibility for third-party projects.
- The author(s) disclaim all liability for any direct, indirect, incidental, or consequential damages arising from the use or misuse of this software. Users assume all risk associated with its use.
- If you are a copyright holder or authorized representative and believe this repository infringes upon your rights, please contact the maintainer with sufficient detail (including relevant URLs and proof of ownership). The matter will be promptly investigated and appropriate action will be taken, which may include removal of the referenced material.

 > [!TIP]
-> **Star the repo** to get notified about all new releases directly from GitHub.
+>
+> **Star Us**, You will receive all release notifications from GitHub without any delay ~
@@ -9,19 +9,6 @@
 # packages, and plugins designed to encourage good coding practices.
 include: package:flutter_lints/flutter.yaml

-analyzer:
-  exclude:
-    - build/**
-    - .dart_tool/**
-    - lib/**/*.g.dart
-    - lib/l10n/*.dart
-  language:
-    strict-casts: true
-    strict-inference: true
-    strict-raw-types: true
-  plugins:
-    - custom_lint
-
 linter:
  # The lint rules applied to this project can be customized in the
  # section below to disable rules from the `package:flutter_lints/flutter.yaml`
@@ -36,13 +23,6 @@ linter:
  rules:
    # avoid_print: false  # Uncomment to disable the `avoid_print` rule
    # prefer_single_quotes: true  # Uncomment to enable the `prefer_single_quotes` rule
-    avoid_dynamic_calls: true
-    cancel_subscriptions: true
-    close_sinks: true
-
-custom_lint:
-  rules:
-    - avoid_public_notifier_properties

 # Additional information about this file can be found at
 # https://dart.dev/guides/language/analysis-options
@@ -57,18 +57,6 @@ android {
    }

    buildTypes {
-        getByName("debug") {
-            ndk {
-                debugSymbolLevel = "FULL"
-            }
-        }
-
-        getByName("profile") {
-            ndk {
-                debugSymbolLevel = "FULL"
-            }
-        }
-
        release {
            // For local builds: use release signing if key.properties exists
            // For CI builds: APK is signed by GitHub Action after build
@@ -83,9 +71,6 @@ android {
                getDefaultProguardFile("proguard-android-optimize.txt"),
                "proguard-rules.pro"
            )
-            ndk {
-                debugSymbolLevel = "FULL"
-            }
        }
    }
    
@@ -94,6 +94,24 @@
            android:exported="false"
            android:foregroundServiceType="dataSync" />

+        <!-- Audio playback service for media notification / background audio -->
+        <service
+            android:name="com.ryanheise.audioservice.AudioService"
+            android:exported="true"
+            android:foregroundServiceType="mediaPlayback">
+            <intent-filter>
+                <action android:name="android.media.browse.MediaBrowserService" />
+            </intent-filter>
+        </service>
+
+        <receiver
+            android:name="com.ryanheise.audioservice.MediaButtonReceiver"
+            android:exported="true">
+            <intent-filter>
+                <action android:name="android.intent.action.MEDIA_BUTTON" />
+            </intent-filter>
+        </receiver>
+
        <!-- flutter_local_notifications receivers -->
        <receiver android:exported="false" android:name="com.dexterous.flutterlocalnotifications.ScheduledNotificationReceiver" />
        <receiver android:exported="false" android:name="com.dexterous.flutterlocalnotifications.ScheduledNotificationBootReceiver">
@@ -104,7 +104,7 @@ class DownloadService : Service() {
                updateNotification(progress, total)
            }
        }
-        return START_NOT_STICKY
+        return START_STICKY
    }
    
    override fun onBind(intent: Intent?): IBinder? = null
@@ -115,8 +115,10 @@ class DownloadService : Service() {
     * We must call stopSelf() within a few seconds to avoid a crash.
     */
    override fun onTimeout(startId: Int, fgsType: Int) {
+        // Log the timeout for debugging
        android.util.Log.w("DownloadService", "Foreground service timeout reached (6 hours limit). Stopping service.")
        
+        // Gracefully stop the service
        stopForegroundService()
    }
    
@@ -137,13 +139,14 @@ class DownloadService : Service() {
    
    private fun startForegroundService() {
        isRunning = true
-
+        
+        // Acquire wake lock to prevent CPU sleep
        val powerManager = getSystemService(Context.POWER_SERVICE) as PowerManager
        wakeLock = powerManager.newWakeLock(
            PowerManager.PARTIAL_WAKE_LOCK,
            WAKELOCK_TAG
        ).apply {
-            acquire(60 * 60 * 1000L)
+            acquire(60 * 60 * 1000L) // 1 hour max
        }
        
        val notification = buildNotification(0, 0)
@@ -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-9.4.1-all.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-9.3.1-all.zip
@@ -20,7 +20,7 @@ pluginManagement {
 plugins {
    id("dev.flutter.flutter-plugin-loader") version "1.0.0"
    id("com.android.application") version "8.13.2" apply false
-    id("org.jetbrains.kotlin.android") version "2.3.20" apply false
+    id("org.jetbrains.kotlin.android") version "2.2.21" apply false
 }

 include(":app")
@@ -1,18 +0,0 @@
-{
-  "name": "SpotiFLAC Source",
-  "identifier": "com.zarzet.spotiflac.source",
-  "subtitle": "FLAC Downloader for iOS",
-  "apps": [
-    {
-      "name": "SpotiFLAC",
-      "bundleIdentifier": "com.zarzet.spotiflac",
-      "developerName": "zarzet",
-      "version": "3.9.0",
-      "versionDate": "2026-03-25",
-      "downloadURL": "https://github.com/zarzet/SpotiFLAC-Mobile/releases/download/v3.9.0/SpotiFLAC-v3.9.0-ios-unsigned.ipa",
-      "localizedDescription": "Mobile version of SpotiFLAC written in Flutter. Download Tracks in true FLAC from Tidal, Qobuz, & Amazon Music.",
-      "iconURL": "https://raw.githubusercontent.com/zarzet/SpotiFLAC-Mobile/main/assets/images/logo.png",
-      "size": 34477323
-    }
-  ]
-}
@@ -22,7 +22,7 @@ body = """
            {% if commit.github.pr_number %} \
                ([#{{ commit.github.pr_number }}]({{ self::remote_url() }}/pull/{{ commit.github.pr_number }}))\
            {% endif %}\
-            {%- if commit.github.username and commit.github.username != "zarzet" %} by [@{{ commit.github.username }}](https://github.com/{{ commit.github.username }}){%- endif %}
+            {%- if commit.github.username %} by [@{{ commit.github.username }}](https://github.com/{{ commit.github.username }}){%- endif %}
    {%- endfor %}
 {% endfor %}

@@ -58,6 +58,8 @@ split_commits = false

 # Regex for preprocessing the commit messages
 commit_preprocessors = [
+  # Remove PR number from message (we add it back via GitHub integration)
+  { pattern = '\(#(\d+)\)', replace = '' },
  # Strip conventional commit prefix for cleaner messages
  # (group header already shows the type)
 ]
@@ -1,611 +0,0 @@
-package gobackend
-
-import (
-	"encoding/binary"
-	"fmt"
-	"io"
-	"os"
-	"strings"
-)
-
-// APEv2 tag format constants.
-const (
-	apeTagPreamble     = "APETAGEX"
-	apeTagHeaderSize   = 32
-	apeTagVersion2     = 2000
-	apeTagFlagHeader   = 1 << 29 // bit 29: this is the header, not the footer
-	apeTagFlagReadOnly = 1 << 0
-	// Item flags: bits 1-2 encode content type
-	apeItemFlagUTF8   = 0 << 1 // 00: UTF-8 text
-	apeItemFlagBinary = 1 << 1 // 01: binary data
-	apeItemFlagLink   = 2 << 1 // 10: external link
-)
-
-// APETagItem represents a single key-value item in an APEv2 tag.
-type APETagItem struct {
-	Key   string
-	Value string
-	Flags uint32
-}
-
-// APETag represents a complete APEv2 tag block.
-type APETag struct {
-	Version  uint32
-	Items    []APETagItem
-	ReadOnly bool
-}
-
-// ReadAPETags reads APEv2 tags from a file.
-// APEv2 tags are typically appended at the end of the file.
-// The layout is: [audio data] [APEv2 header (optional)] [items...] [APEv2 footer]
-// We locate the footer first (last 32 bytes), then read the tag block.
-func ReadAPETags(filePath string) (*APETag, error) {
-	f, err := os.Open(filePath)
-	if err != nil {
-		return nil, fmt.Errorf("failed to open file: %w", err)
-	}
-	defer f.Close()
-
-	fi, err := f.Stat()
-	if err != nil {
-		return nil, fmt.Errorf("failed to stat file: %w", err)
-	}
-	fileSize := fi.Size()
-
-	if fileSize < apeTagHeaderSize {
-		return nil, fmt.Errorf("file too small for APE tag")
-	}
-
-	// Try to find APE tag footer at the end of file.
-	// The footer is the last 32 bytes before any ID3v1 tag (128 bytes).
-	tag, err := readAPETagAtOffset(f, fileSize, fileSize-apeTagHeaderSize)
-	if err == nil {
-		return tag, nil
-	}
-
-	// Retry: skip ID3v1 tag (128 bytes) if present
-	if fileSize > apeTagHeaderSize+128 {
-		tag, err = readAPETagAtOffset(f, fileSize, fileSize-apeTagHeaderSize-128)
-		if err == nil {
-			return tag, nil
-		}
-	}
-
-	return nil, fmt.Errorf("no APEv2 tag found")
-}
-
-func readAPETagAtOffset(f *os.File, fileSize, footerOffset int64) (*APETag, error) {
-	if footerOffset < 0 || footerOffset+apeTagHeaderSize > fileSize {
-		return nil, fmt.Errorf("invalid footer offset")
-	}
-
-	footer := make([]byte, apeTagHeaderSize)
-	if _, err := f.ReadAt(footer, footerOffset); err != nil {
-		return nil, fmt.Errorf("failed to read APE footer: %w", err)
-	}
-
-	if string(footer[0:8]) != apeTagPreamble {
-		return nil, fmt.Errorf("APE preamble not found")
-	}
-
-	version := binary.LittleEndian.Uint32(footer[8:12])
-	tagSize := binary.LittleEndian.Uint32(footer[12:16]) // size of items + footer (32 bytes)
-	itemCount := binary.LittleEndian.Uint32(footer[16:20])
-	flags := binary.LittleEndian.Uint32(footer[20:24])
-
-	if version != apeTagVersion2 && version != 1000 {
-		return nil, fmt.Errorf("unsupported APE tag version: %d", version)
-	}
-	if tagSize < apeTagHeaderSize {
-		return nil, fmt.Errorf("APE tag size too small: %d", tagSize)
-	}
-	if itemCount > 1000 {
-		return nil, fmt.Errorf("APE tag item count too large: %d", itemCount)
-	}
-
-	// This should be the footer (bit 29 clear)
-	isHeader := (flags & apeTagFlagHeader) != 0
-	if isHeader {
-		return nil, fmt.Errorf("expected APE footer but found header")
-	}
-
-	// tagSize includes items + footer (32 bytes), but NOT the header.
-	itemsSize := int64(tagSize) - apeTagHeaderSize
-	if itemsSize < 0 {
-		return nil, fmt.Errorf("invalid APE tag: items size negative")
-	}
-
-	itemsOffset := footerOffset - itemsSize
-	if itemsOffset < 0 {
-		return nil, fmt.Errorf("APE tag items extend before file start")
-	}
-
-	itemsData := make([]byte, itemsSize)
-	if _, err := f.ReadAt(itemsData, itemsOffset); err != nil {
-		return nil, fmt.Errorf("failed to read APE items: %w", err)
-	}
-
-	items, err := parseAPEItems(itemsData, int(itemCount))
-	if err != nil {
-		return nil, fmt.Errorf("failed to parse APE items: %w", err)
-	}
-
-	return &APETag{
-		Version:  version,
-		Items:    items,
-		ReadOnly: (flags & apeTagFlagReadOnly) != 0,
-	}, nil
-}
-
-func parseAPEItems(data []byte, count int) ([]APETagItem, error) {
-	items := make([]APETagItem, 0, count)
-	pos := 0
-
-	for i := 0; i < count && pos < len(data); i++ {
-		if pos+8 > len(data) {
-			break
-		}
-
-		valueSize := int(binary.LittleEndian.Uint32(data[pos : pos+4]))
-		itemFlags := binary.LittleEndian.Uint32(data[pos+4 : pos+8])
-		pos += 8
-
-		// Key is null-terminated ASCII (2-255 bytes, case-insensitive)
-		keyEnd := pos
-		for keyEnd < len(data) && data[keyEnd] != 0 {
-			keyEnd++
-		}
-		if keyEnd >= len(data) {
-			break
-		}
-
-		key := string(data[pos:keyEnd])
-		pos = keyEnd + 1
-
-		if pos+valueSize > len(data) {
-			break
-		}
-		value := string(data[pos : pos+valueSize])
-		pos += valueSize
-
-		items = append(items, APETagItem{
-			Key:   key,
-			Value: value,
-			Flags: itemFlags,
-		})
-	}
-
-	return items, nil
-}
-
-// WriteAPETags writes APEv2 tags to the end of a file.
-// If the file already has APEv2 tags, they are replaced.
-// The tag is written with both header and footer.
-func WriteAPETags(filePath string, tag *APETag) error {
-	existingSize, err := findExistingAPETagSize(filePath)
-	if err != nil {
-		return fmt.Errorf("failed to check existing APE tag: %w", err)
-	}
-
-	tagData, err := marshalAPETag(tag)
-	if err != nil {
-		return fmt.Errorf("failed to marshal APE tag: %w", err)
-	}
-
-	if existingSize > 0 {
-		fi, err := os.Stat(filePath)
-		if err != nil {
-			return fmt.Errorf("failed to stat file: %w", err)
-		}
-		newSize := fi.Size() - int64(existingSize)
-		if err := os.Truncate(filePath, newSize); err != nil {
-			return fmt.Errorf("failed to truncate existing APE tag: %w", err)
-		}
-	}
-
-	f, err := os.OpenFile(filePath, os.O_WRONLY|os.O_APPEND, 0644)
-	if err != nil {
-		return fmt.Errorf("failed to open file for writing: %w", err)
-	}
-	defer f.Close()
-
-	if _, err := f.Write(tagData); err != nil {
-		return fmt.Errorf("failed to write APE tag: %w", err)
-	}
-
-	return nil
-}
-
-// findExistingAPETagSize returns the total size of an existing APE tag
-// (header + items + footer) at the end of the file, or 0 if none exists.
-func findExistingAPETagSize(filePath string) (int64, error) {
-	f, err := os.Open(filePath)
-	if err != nil {
-		return 0, err
-	}
-	defer f.Close()
-
-	fi, err := f.Stat()
-	if err != nil {
-		return 0, err
-	}
-	fileSize := fi.Size()
-
-	offsets := []int64{fileSize - apeTagHeaderSize}
-	if fileSize > apeTagHeaderSize+128 {
-		offsets = append(offsets, fileSize-apeTagHeaderSize-128)
-	}
-
-	for _, offset := range offsets {
-		if offset < 0 {
-			continue
-		}
-		footer := make([]byte, apeTagHeaderSize)
-		if _, err := f.ReadAt(footer, offset); err != nil {
-			continue
-		}
-		if string(footer[0:8]) != apeTagPreamble {
-			continue
-		}
-
-		flags := binary.LittleEndian.Uint32(footer[20:24])
-		if (flags & apeTagFlagHeader) != 0 {
-			continue
-		}
-
-		tagSize := int64(binary.LittleEndian.Uint32(footer[12:16]))
-
-		// Check if there's also a header (tagSize only covers items + footer)
-		hasHeader := (flags & (1 << 31)) != 0 // bit 31 = tag contains header
-		totalSize := tagSize
-		if hasHeader {
-			totalSize += apeTagHeaderSize
-		}
-
-		// Include any trailing data after the footer (e.g. ID3v1 128-byte tag).
-		// When truncating, we must remove the APE tag AND everything after it.
-		trailingBytes := fileSize - (offset + apeTagHeaderSize)
-		totalSize += trailingBytes
-
-		return totalSize, nil
-	}
-
-	return 0, nil
-}
-
-// marshalAPETag serializes an APETag into bytes (header + items + footer).
-func marshalAPETag(tag *APETag) ([]byte, error) {
-	if tag == nil || len(tag.Items) == 0 {
-		return nil, fmt.Errorf("empty APE tag")
-	}
-
-	var itemsData []byte
-	for _, item := range tag.Items {
-		keyBytes := []byte(item.Key)
-		valueBytes := []byte(item.Value)
-
-		// 4 bytes: value size (LE)
-		sizeBuf := make([]byte, 4)
-		binary.LittleEndian.PutUint32(sizeBuf, uint32(len(valueBytes)))
-
-		// 4 bytes: item flags (LE)
-		flagsBuf := make([]byte, 4)
-		binary.LittleEndian.PutUint32(flagsBuf, item.Flags)
-
-		itemsData = append(itemsData, sizeBuf...)
-		itemsData = append(itemsData, flagsBuf...)
-		itemsData = append(itemsData, keyBytes...)
-		itemsData = append(itemsData, 0)
-		itemsData = append(itemsData, valueBytes...)
-	}
-
-	// tagSize = items data + footer (32 bytes)
-	tagSize := uint32(len(itemsData) + apeTagHeaderSize)
-	itemCount := uint32(len(tag.Items))
-
-	version := uint32(apeTagVersion2)
-	if tag.Version != 0 {
-		version = tag.Version
-	}
-
-	// flags: bit 29 = 1 (is header), bit 31 = 1 (contains header)
-	headerFlags := uint32(apeTagFlagHeader | (1 << 31))
-	header := buildAPEHeaderFooter(version, tagSize, itemCount, headerFlags)
-
-	// flags: bit 29 = 0 (is footer), bit 31 = 1 (contains header)
-	footerFlags := uint32(1 << 31)
-	footer := buildAPEHeaderFooter(version, tagSize, itemCount, footerFlags)
-
-	// Final layout: header + items + footer
-	result := make([]byte, 0, len(header)+len(itemsData)+len(footer))
-	result = append(result, header...)
-	result = append(result, itemsData...)
-	result = append(result, footer...)
-
-	return result, nil
-}
-
-func buildAPEHeaderFooter(version, tagSize, itemCount, flags uint32) []byte {
-	buf := make([]byte, apeTagHeaderSize)
-	copy(buf[0:8], apeTagPreamble)
-	binary.LittleEndian.PutUint32(buf[8:12], version)
-	binary.LittleEndian.PutUint32(buf[12:16], tagSize)
-	binary.LittleEndian.PutUint32(buf[16:20], itemCount)
-	binary.LittleEndian.PutUint32(buf[20:24], flags)
-	// bytes 24-31 are reserved (zeros)
-	return buf
-}
-
-// APETagToAudioMetadata converts an APETag to our unified AudioMetadata struct.
-func APETagToAudioMetadata(tag *APETag) *AudioMetadata {
-	if tag == nil {
-		return nil
-	}
-
-	metadata := &AudioMetadata{}
-	for _, item := range tag.Items {
-		key := strings.ToUpper(strings.TrimSpace(item.Key))
-		value := strings.TrimSpace(item.Value)
-		if value == "" {
-			continue
-		}
-
-		switch key {
-		case "TITLE":
-			metadata.Title = value
-		case "ARTIST":
-			metadata.Artist = value
-		case "ALBUM":
-			metadata.Album = value
-		case "ALBUMARTIST", "ALBUM ARTIST":
-			metadata.AlbumArtist = value
-		case "GENRE":
-			metadata.Genre = value
-		case "YEAR":
-			metadata.Year = value
-		case "DATE":
-			metadata.Date = value
-		case "TRACK", "TRACKNUMBER":
-			metadata.TrackNumber, metadata.TotalTracks = parseIndexPair(value)
-		case "DISC", "DISCNUMBER":
-			metadata.DiscNumber, metadata.TotalDiscs = parseIndexPair(value)
-		case "ISRC":
-			metadata.ISRC = value
-		case "LYRICS", "UNSYNCEDLYRICS":
-			if metadata.Lyrics == "" {
-				metadata.Lyrics = value
-			}
-		case "LABEL", "PUBLISHER":
-			metadata.Label = value
-		case "COPYRIGHT":
-			metadata.Copyright = value
-		case "COMPOSER":
-			metadata.Composer = value
-		case "COMMENT":
-			metadata.Comment = value
-		case "REPLAYGAIN_TRACK_GAIN":
-			metadata.ReplayGainTrackGain = value
-		case "REPLAYGAIN_TRACK_PEAK":
-			metadata.ReplayGainTrackPeak = value
-		case "REPLAYGAIN_ALBUM_GAIN":
-			metadata.ReplayGainAlbumGain = value
-		case "REPLAYGAIN_ALBUM_PEAK":
-			metadata.ReplayGainAlbumPeak = value
-		}
-	}
-
-	return metadata
-}
-
-// AudioMetadataToAPEItems converts metadata fields to APE tag items.
-func AudioMetadataToAPEItems(metadata *AudioMetadata) []APETagItem {
-	if metadata == nil {
-		return nil
-	}
-
-	var items []APETagItem
-	addItem := func(key, value string) {
-		if value != "" {
-			items = append(items, APETagItem{Key: key, Value: value})
-		}
-	}
-
-	addItem("Title", metadata.Title)
-	addItem("Artist", metadata.Artist)
-	addItem("Album", metadata.Album)
-	addItem("Album Artist", metadata.AlbumArtist)
-	addItem("Genre", metadata.Genre)
-	if metadata.Date != "" {
-		addItem("Year", metadata.Date)
-	} else if metadata.Year != "" {
-		addItem("Year", metadata.Year)
-	}
-	if metadata.TrackNumber > 0 {
-		addItem("Track", formatIndexValue(metadata.TrackNumber, metadata.TotalTracks))
-	}
-	if metadata.DiscNumber > 0 {
-		addItem("Disc", formatIndexValue(metadata.DiscNumber, metadata.TotalDiscs))
-	}
-	addItem("ISRC", metadata.ISRC)
-	addItem("Lyrics", metadata.Lyrics)
-	addItem("Label", metadata.Label)
-	addItem("Copyright", metadata.Copyright)
-	addItem("Composer", metadata.Composer)
-	addItem("Comment", metadata.Comment)
-	addItem("REPLAYGAIN_TRACK_GAIN", metadata.ReplayGainTrackGain)
-	addItem("REPLAYGAIN_TRACK_PEAK", metadata.ReplayGainTrackPeak)
-	addItem("REPLAYGAIN_ALBUM_GAIN", metadata.ReplayGainAlbumGain)
-	addItem("REPLAYGAIN_ALBUM_PEAK", metadata.ReplayGainAlbumPeak)
-
-	return items
-}
-
-// apeKeysFromFields builds a set of upper-case APE tag keys corresponding to
-// the metadata fields map sent by the editor.  This is used during merge to
-// ensure that even empty (cleared) fields override old values.
-func apeKeysFromFields(fields map[string]string) map[string]struct{} {
-	mapping := map[string]string{
-		"title":                 "TITLE",
-		"artist":                "ARTIST",
-		"album":                 "ALBUM",
-		"album_artist":          "ALBUM ARTIST",
-		"date":                  "DATE",
-		"genre":                 "GENRE",
-		"track_number":          "TRACK",
-		"disc_number":           "DISC",
-		"isrc":                  "ISRC",
-		"lyrics":                "LYRICS",
-		"label":                 "LABEL",
-		"copyright":             "COPYRIGHT",
-		"composer":              "COMPOSER",
-		"comment":               "COMMENT",
-		"replaygain_track_gain": "REPLAYGAIN_TRACK_GAIN",
-		"replaygain_track_peak": "REPLAYGAIN_TRACK_PEAK",
-		"replaygain_album_gain": "REPLAYGAIN_ALBUM_GAIN",
-		"replaygain_album_peak": "REPLAYGAIN_ALBUM_PEAK",
-	}
-	result := make(map[string]struct{})
-	for fk, apeKey := range mapping {
-		if _, present := fields[fk]; present {
-			result[strings.ToUpper(apeKey)] = struct{}{}
-		}
-	}
-	// Some fields have reader aliases that must also be cleared when the
-	// canonical key is updated (e.g. DATE writer ↔ DATE/YEAR reader,
-	// DISC ↔ DISCNUMBER, TRACK ↔ TRACKNUMBER, "ALBUM ARTIST" ↔ ALBUMARTIST,
-	// LABEL ↔ PUBLISHER, LYRICS ↔ UNSYNCEDLYRICS).
-	if _, present := fields["date"]; present {
-		result["DATE"] = struct{}{}
-	}
-	if _, present := fields["disc_number"]; present {
-		result["DISCNUMBER"] = struct{}{}
-	}
-	if _, present := fields["disc_total"]; present {
-		result["DISCNUMBER"] = struct{}{}
-	}
-	if _, present := fields["track_number"]; present {
-		result["TRACKNUMBER"] = struct{}{}
-	}
-	if _, present := fields["track_total"]; present {
-		result["TRACKNUMBER"] = struct{}{}
-	}
-	if _, present := fields["album_artist"]; present {
-		result["ALBUMARTIST"] = struct{}{}
-	}
-	if _, present := fields["label"]; present {
-		result["PUBLISHER"] = struct{}{}
-	}
-	if _, present := fields["lyrics"]; present {
-		result["UNSYNCEDLYRICS"] = struct{}{}
-	}
-	return result
-}
-
-// MergeAPEItems overlays newItems on top of existing items.
-// For each new item, if a matching key exists (case-insensitive) in existing,
-// it is replaced. New keys are appended. Existing items whose keys are NOT
-// in newItems are preserved (cover art, ReplayGain, custom tags, etc.).
-//
-// overrideKeys is an optional set of upper-case keys that should be removed
-// from existing even if they do not appear in newItems.  This handles field
-// deletion: the caller sends an empty value which is not serialized into
-// newItems, but the old value must still be dropped.
-func MergeAPEItems(existing, newItems []APETagItem, overrideKeys map[string]struct{}) []APETagItem {
-	// Build a set of keys being updated (upper-case for case-insensitive match)
-	combined := make(map[string]struct{}, len(newItems)+len(overrideKeys))
-	for k := range overrideKeys {
-		combined[strings.ToUpper(k)] = struct{}{}
-	}
-	for _, item := range newItems {
-		combined[strings.ToUpper(item.Key)] = struct{}{}
-	}
-
-	var merged []APETagItem
-	for _, item := range existing {
-		if _, overwritten := combined[strings.ToUpper(item.Key)]; !overwritten {
-			merged = append(merged, item)
-		}
-	}
-
-	merged = append(merged, newItems...)
-
-	return merged
-}
-
-// ReadAPETagsFromReader reads APEv2 tags from an io.ReaderAt + size.
-// This is useful for reading APE tags from files opened via SAF or other abstractions.
-func ReadAPETagsFromReader(r io.ReaderAt, fileSize int64) (*APETag, error) {
-	if fileSize < apeTagHeaderSize {
-		return nil, fmt.Errorf("file too small for APE tag")
-	}
-
-	// Try footer at end of file
-	footer := make([]byte, apeTagHeaderSize)
-	if _, err := r.ReadAt(footer, fileSize-apeTagHeaderSize); err != nil {
-		return nil, fmt.Errorf("failed to read APE footer: %w", err)
-	}
-
-	if string(footer[0:8]) == apeTagPreamble {
-		tag, err := parseAPETagFromFooter(r, fileSize, fileSize-apeTagHeaderSize, footer)
-		if err == nil {
-			return tag, nil
-		}
-	}
-
-	// Retry: skip ID3v1 tag (128 bytes)
-	if fileSize > apeTagHeaderSize+128 {
-		offset := fileSize - apeTagHeaderSize - 128
-		if _, err := r.ReadAt(footer, offset); err == nil {
-			if string(footer[0:8]) == apeTagPreamble {
-				tag, err := parseAPETagFromFooter(r, fileSize, offset, footer)
-				if err == nil {
-					return tag, nil
-				}
-			}
-		}
-	}
-
-	return nil, fmt.Errorf("no APEv2 tag found")
-}
-
-func parseAPETagFromFooter(r io.ReaderAt, fileSize, footerOffset int64, footer []byte) (*APETag, error) {
-	version := binary.LittleEndian.Uint32(footer[8:12])
-	tagSize := binary.LittleEndian.Uint32(footer[12:16])
-	itemCount := binary.LittleEndian.Uint32(footer[16:20])
-	flags := binary.LittleEndian.Uint32(footer[20:24])
-
-	if version != apeTagVersion2 && version != 1000 {
-		return nil, fmt.Errorf("unsupported APE tag version: %d", version)
-	}
-	if tagSize < apeTagHeaderSize {
-		return nil, fmt.Errorf("APE tag size too small: %d", tagSize)
-	}
-	if itemCount > 1000 {
-		return nil, fmt.Errorf("APE tag item count too large: %d", itemCount)
-	}
-	if (flags & apeTagFlagHeader) != 0 {
-		return nil, fmt.Errorf("expected footer, found header")
-	}
-
-	itemsSize := int64(tagSize) - apeTagHeaderSize
-	itemsOffset := footerOffset - itemsSize
-	if itemsOffset < 0 {
-		return nil, fmt.Errorf("APE items extend before file start")
-	}
-
-	itemsData := make([]byte, itemsSize)
-	if _, err := r.ReadAt(itemsData, itemsOffset); err != nil {
-		return nil, fmt.Errorf("failed to read APE items: %w", err)
-	}
-
-	items, err := parseAPEItems(itemsData, int(itemCount))
-	if err != nil {
-		return nil, fmt.Errorf("failed to parse APE items: %w", err)
-	}
-
-	return &APETag{
-		Version:  version,
-		Items:    items,
-		ReadOnly: (flags & apeTagFlagReadOnly) != 0,
-	}, nil
-}
@@ -21,20 +21,13 @@ type AudioMetadata struct {
 	Year        string
 	Date        string
 	TrackNumber int
-	TotalTracks int
 	DiscNumber  int
-	TotalDiscs  int
 	ISRC        string
 	Lyrics      string
 	Label       string
 	Copyright   string
 	Composer    string
 	Comment     string
-	// ReplayGain fields (text values, e.g. "-6.50 dB", "0.988831")
-	ReplayGainTrackGain string
-	ReplayGainTrackPeak string
-	ReplayGainAlbumGain string
-	ReplayGainAlbumPeak string
 }

 type MP3Quality struct {
@@ -175,9 +168,9 @@ func parseID3v22Frames(data []byte, metadata *AudioMetadata, tagUnsync bool) {
 		case "TCO":
 			metadata.Genre = cleanGenre(value)
 		case "TRK":
-			metadata.TrackNumber, metadata.TotalTracks = parseIndexPair(value)
+			metadata.TrackNumber = parseTrackNumber(value)
 		case "TPA":
-			metadata.DiscNumber, metadata.TotalDiscs = parseIndexPair(value)
+			metadata.DiscNumber = parseTrackNumber(value)
 		case "TCM":
 			metadata.Composer = value
 		case "TPB":
@@ -294,9 +287,9 @@ func parseID3v23Frames(data []byte, metadata *AudioMetadata, version byte, tagUn
 		case "TCON":
 			metadata.Genre = cleanGenre(value)
 		case "TRCK":
-			metadata.TrackNumber, metadata.TotalTracks = parseIndexPair(value)
+			metadata.TrackNumber = parseTrackNumber(value)
 		case "TPOS":
-			metadata.DiscNumber, metadata.TotalDiscs = parseIndexPair(value)
+			metadata.DiscNumber = parseTrackNumber(value)
 		case "TSRC":
 			metadata.ISRC = value
 		case "TCOM":
@@ -318,17 +311,6 @@ func parseID3v23Frames(data []byte, metadata *AudioMetadata, version byte, tagUn
 			if isLyricsDescription(desc) && userValue != "" && metadata.Lyrics == "" {
 				metadata.Lyrics = userValue
 			}
-			upperDesc := strings.ToUpper(desc)
-			switch upperDesc {
-			case "REPLAYGAIN_TRACK_GAIN":
-				metadata.ReplayGainTrackGain = userValue
-			case "REPLAYGAIN_TRACK_PEAK":
-				metadata.ReplayGainTrackPeak = userValue
-			case "REPLAYGAIN_ALBUM_GAIN":
-				metadata.ReplayGainAlbumGain = userValue
-			case "REPLAYGAIN_ALBUM_PEAK":
-				metadata.ReplayGainAlbumPeak = userValue
-			}
 		}

 		pos += 10 + frameSize
@@ -356,6 +338,7 @@ func readID3v1(file *os.File) (*AudioMetadata, error) {
 		Year:   strings.TrimRight(string(tag[93:97]), " \x00"),
 	}

+	// ID3v1.1 track number (if byte 125 is 0 and byte 126 is not)
 	if tag[125] == 0 && tag[126] != 0 {
 		metadata.TrackNumber = int(tag[126])
 	}
@@ -390,23 +373,27 @@ func extractTextFrame(data []byte) string {
 	}
 }

+// extractCommentFrame parses an ID3v2 COMM frame.
+// Format: encoding(1) + language(3) + description(null-terminated) + text
 func extractCommentFrame(data []byte) string {
 	if len(data) < 5 {
 		return ""
 	}
 	encoding := data[0]
+	// skip 3-byte language code
 	rest := data[4:]

+	// find null terminator separating description from text
 	var text []byte
 	switch encoding {
-	case 1, 2:
+	case 1, 2: // UTF-16 variants use double-null terminator
 		for i := 0; i+1 < len(rest); i += 2 {
 			if rest[i] == 0 && rest[i+1] == 0 {
 				text = rest[i+2:]
 				break
 			}
 		}
-	default:
+	default: // ISO-8859-1 or UTF-8
 		idx := bytes.IndexByte(rest, 0)
 		if idx >= 0 && idx+1 < len(rest) {
 			text = rest[idx+1:]
@@ -419,30 +406,33 @@ func extractCommentFrame(data []byte) string {
 		return ""
 	}

+	// re-prepend encoding byte so extractTextFrame can decode properly
 	framed := make([]byte, 1+len(text))
 	framed[0] = encoding
 	copy(framed[1:], text)
 	return extractTextFrame(framed)
 }

+// extractLyricsFrame parses ID3 unsynchronized lyrics frames (USLT/ULT).
+// Format: encoding(1) + language(3) + description(null-terminated) + lyrics text.
 func extractLyricsFrame(data []byte) string {
 	if len(data) < 5 {
 		return ""
 	}

 	encoding := data[0]
-	rest := data[4:]
+	rest := data[4:] // skip 3-byte language code

 	var text []byte
 	switch encoding {
-	case 1, 2:
+	case 1, 2: // UTF-16 variants use double-null terminator
 		for i := 0; i+1 < len(rest); i += 2 {
 			if rest[i] == 0 && rest[i+1] == 0 {
 				text = rest[i+2:]
 				break
 			}
 		}
-	default:
+	default: // ISO-8859-1 or UTF-8
 		idx := bytes.IndexByte(rest, 0)
 		if idx >= 0 && idx+1 < len(rest) {
 			text = rest[idx+1:]
@@ -461,6 +451,8 @@ func extractLyricsFrame(data []byte) string {
 	return extractTextFrame(framed)
 }

+// extractUserTextFrame parses ID3 TXXX/TXX user text frame:
+// encoding(1) + description + separator + value.
 func extractUserTextFrame(data []byte) (string, string) {
 	if len(data) < 2 {
 		return "", ""
@@ -471,7 +463,7 @@ func extractUserTextFrame(data []byte) (string, string) {

 	var descRaw, valueRaw []byte
 	switch encoding {
-	case 1, 2:
+	case 1, 2: // UTF-16 variants
 		for i := 0; i+1 < len(payload); i += 2 {
 			if payload[i] == 0 && payload[i+1] == 0 {
 				descRaw = payload[:i]
@@ -479,7 +471,7 @@ func extractUserTextFrame(data []byte) (string, string) {
 				break
 			}
 		}
-	default:
+	default: // ISO-8859-1 or UTF-8
 		idx := bytes.IndexByte(payload, 0)
 		if idx >= 0 {
 			descRaw = payload[:idx]
@@ -506,13 +498,7 @@ func extractUserTextFrame(data []byte) (string, string) {

 func isLyricsDescription(description string) bool {
 	switch strings.ToLower(strings.TrimSpace(description)) {
-	case
-		"lyrics",
-		"lyric",
-		"unsyncedlyrics",
-		"unsynced lyrics",
-		"uslt",
-		"lrc":
+	case "lyrics", "lyric", "unsyncedlyrics", "unsynced lyrics", "lrc":
 		return true
 	default:
 		return false
@@ -582,26 +568,12 @@ func cleanGenre(genre string) string {
 }

 func parseTrackNumber(s string) int {
-	num, _ := parseIndexPair(s)
-	return num
-}
-
-func parseIndexPair(s string) (int, int) {
 	s = strings.TrimSpace(s)
-	if s == "" {
-		return 0, 0
-	}
-
-	first := s
-	second := ""
 	if idx := strings.Index(s, "/"); idx > 0 {
-		first = s[:idx]
-		second = s[idx+1:]
+		s = s[:idx]
 	}
-
-	num, _ := strconv.Atoi(strings.TrimSpace(first))
-	total, _ := strconv.Atoi(strings.TrimSpace(second))
-	return num, total
+	num, _ := strconv.Atoi(s)
+	return num
 }

 func removeUnsync(data []byte) []byte {
@@ -687,6 +659,7 @@ func GetMP3Quality(filePath string) (*MP3Quality, error) {

 	file.Seek(audioStart, io.SeekStart)

+	// Find first valid MP3 frame sync
 	frameHeader := make([]byte, 4)
 	var frameStart int64 = -1
 	for i := 0; i < 10000; i++ {
@@ -713,6 +686,8 @@ func GetMP3Quality(filePath string) (*MP3Quality, error) {
 	sampleRateIdx := (frameHeader[2] >> 2) & 0x03
 	channelMode := (frameHeader[3] >> 6) & 0x03

+	// Sample rate tables: [version][index]
+	// version: 0=MPEG2.5, 1=reserved, 2=MPEG2, 3=MPEG1
 	sampleRates := [][]int{
 		{11025, 12000, 8000},
 		{0, 0, 0},
@@ -723,12 +698,15 @@ func GetMP3Quality(filePath string) (*MP3Quality, error) {
 		quality.SampleRate = sampleRates[version][sampleRateIdx]
 	}

+	// Bitrate tables for all MPEG versions and layers
+	// MPEG1 Layer III
 	if version == 3 && layer == 1 {
 		bitrates := []int{0, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 0}
 		if bitrateIdx < 16 {
 			quality.Bitrate = bitrates[bitrateIdx] * 1000
 		}
 	}
+	// MPEG2/2.5 Layer III
 	if (version == 0 || version == 2) && layer == 1 {
 		bitrates := []int{0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160, 0}
 		if bitrateIdx < 16 {
@@ -736,11 +714,14 @@ func GetMP3Quality(filePath string) (*MP3Quality, error) {
 		}
 	}

+	// Determine samples per frame for duration calculation
 	samplesPerFrame := 1152 // MPEG1 Layer III
 	if version == 0 || version == 2 {
 		samplesPerFrame = 576 // MPEG2/2.5 Layer III
 	}

+	// Try to read Xing/VBRI header from the first frame for VBR info
+	// Xing header offset depends on MPEG version and channel mode
 	var xingOffset int
 	if version == 3 { // MPEG1
 		if channelMode == 3 { // Mono
@@ -756,6 +737,7 @@ func GetMP3Quality(filePath string) (*MP3Quality, error) {
 		}
 	}

+	// Read enough of the first frame to find Xing/VBRI header
 	xingBuf := make([]byte, 200)
 	file.Seek(frameStart+4, io.SeekStart)
 	n, _ := io.ReadFull(file, xingBuf)
@@ -765,6 +747,7 @@ func GetMP3Quality(filePath string) (*MP3Quality, error) {
 	vbrBytes := int64(0)
 	isVBR := false

+	// Check for Xing/Info header
 	if xingOffset+8 <= n {
 		tag := string(xingBuf[xingOffset : xingOffset+4])
 		if tag == "Xing" || tag == "Info" {
@@ -783,6 +766,7 @@ func GetMP3Quality(filePath string) (*MP3Quality, error) {
 		}
 	}

+	// Check for VBRI header (always at offset 32 from frame start + 4)
 	if !isVBR && 36+26 <= n {
 		if string(xingBuf[32:36]) == "VBRI" {
 			vbrBytes = int64(binary.BigEndian.Uint32(xingBuf[36+6 : 36+10]))
@@ -794,9 +778,11 @@ func GetMP3Quality(filePath string) (*MP3Quality, error) {
 	}

 	if isVBR && vbrFrames > 0 && quality.SampleRate > 0 {
+		// Accurate duration from total frames
 		totalSamples := int64(vbrFrames) * int64(samplesPerFrame)
 		quality.Duration = int(totalSamples / int64(quality.SampleRate))

+		// Accurate average bitrate
 		if vbrBytes > 0 && quality.Duration > 0 {
 			quality.Bitrate = int(vbrBytes * 8 / int64(quality.Duration))
 		} else if quality.Duration > 0 {
@@ -804,6 +790,7 @@ func GetMP3Quality(filePath string) (*MP3Quality, error) {
 			quality.Bitrate = int(audioSize * 8 / int64(quality.Duration))
 		}
 	} else if quality.Bitrate > 0 {
+		// CBR fallback: estimate duration from file size and frame bitrate
 		audioSize := fileSize - audioStart - 128 // subtract possible ID3v1 tag
 		if audioSize > 0 {
 			quality.Duration = int(audioSize * 8 / int64(quality.Bitrate))
@@ -987,9 +974,8 @@ func parseVorbisComments(data []byte, metadata *AudioMetadata) {
 	}

 	reader := bytes.NewReader(data)
-	artistValues := make([]string, 0, 1)
-	albumArtistValues := make([]string, 0, 1)

+	// Read vendor string length
 	var vendorLen uint32
 	if err := binary.Read(reader, binary.LittleEndian, &vendorLen); err != nil {
 		return
@@ -1018,6 +1004,8 @@ func parseVorbisComments(data []byte, metadata *AudioMetadata) {
 		if commentLen > remaining {
 			break
 		}
+		// Large comment entries are typically METADATA_BLOCK_PICTURE.
+		// Skip them so we can continue parsing normal text tags after/before.
 		if commentLen > 512*1024 {
 			reader.Seek(int64(commentLen), io.SeekCurrent)
 			continue
@@ -1040,9 +1028,9 @@ func parseVorbisComments(data []byte, metadata *AudioMetadata) {
 		case "TITLE":
 			metadata.Title = value
 		case "ARTIST":
-			artistValues = append(artistValues, value)
+			metadata.Artist = value
 		case "ALBUMARTIST", "ALBUM_ARTIST", "ALBUM ARTIST":
-			albumArtistValues = append(albumArtistValues, value)
+			metadata.AlbumArtist = value
 		case "ALBUM":
 			metadata.Album = value
 		case "DATE", "YEAR":
@@ -1053,9 +1041,9 @@ func parseVorbisComments(data []byte, metadata *AudioMetadata) {
 		case "GENRE":
 			metadata.Genre = value
 		case "TRACKNUMBER", "TRACK":
-			metadata.TrackNumber, metadata.TotalTracks = parseIndexPair(value)
+			metadata.TrackNumber = parseTrackNumber(value)
 		case "DISCNUMBER", "DISC":
-			metadata.DiscNumber, metadata.TotalDiscs = parseIndexPair(value)
+			metadata.DiscNumber = parseTrackNumber(value)
 		case "ISRC":
 			metadata.ISRC = value
 		case "COMPOSER":
@@ -1070,23 +1058,8 @@ func parseVorbisComments(data []byte, metadata *AudioMetadata) {
 			metadata.Label = value
 		case "COPYRIGHT":
 			metadata.Copyright = value
-		case "REPLAYGAIN_TRACK_GAIN":
-			metadata.ReplayGainTrackGain = value
-		case "REPLAYGAIN_TRACK_PEAK":
-			metadata.ReplayGainTrackPeak = value
-		case "REPLAYGAIN_ALBUM_GAIN":
-			metadata.ReplayGainAlbumGain = value
-		case "REPLAYGAIN_ALBUM_PEAK":
-			metadata.ReplayGainAlbumPeak = value
 		}
 	}
-
-	if len(artistValues) > 0 {
-		metadata.Artist = joinVorbisCommentValues(artistValues)
-	}
-	if len(albumArtistValues) > 0 {
-		metadata.AlbumArtist = joinVorbisCommentValues(albumArtistValues)
-	}
 }

 func GetOggQuality(filePath string) (*OggQuality, error) {
@@ -1135,6 +1108,7 @@ func GetOggQuality(filePath string) (*OggQuality, error) {
 		}
 	}

+	// Read granule position from the last Ogg page for accurate duration
 	stat, err := file.Stat()
 	if err != nil {
 		return quality, nil
@@ -1144,6 +1118,7 @@ func GetOggQuality(filePath string) (*OggQuality, error) {
 	granule := readLastOggGranulePosition(file, fileSize)
 	if granule > 0 {
 		if isOpus {
+			// Opus always uses 48kHz granule position internally
 			totalSamples := granule - int64(preSkip)
 			if totalSamples > 0 {
 				durationSec := float64(totalSamples) / 48000.0
@@ -1161,9 +1136,11 @@ func GetOggQuality(filePath string) (*OggQuality, error) {
 		}
 	}

+	// Fallback bitrate estimate if duration exists but bitrate couldn't be derived.
 	if quality.Bitrate <= 0 && quality.Duration > 0 {
 		quality.Bitrate = int(fileSize * 8 / int64(quality.Duration))
 	}
+	// Guard against obviously invalid values from corrupted/unreliable granule reads.
 	if quality.Duration > 24*60*60 {
 		quality.Duration = 0
 		quality.Bitrate = 0
@@ -1175,7 +1152,10 @@ func GetOggQuality(filePath string) (*OggQuality, error) {
 	return quality, nil
 }

+// readLastOggGranulePosition seeks to the end of the file and scans backwards
+// to find the last Ogg page, then reads its granule position (bytes 6-13).
 func readLastOggGranulePosition(file *os.File, fileSize int64) int64 {
+	// Read the last chunk of the file to find the last OggS sync
 	searchSize := int64(65536)
 	if searchSize > fileSize {
 		searchSize = fileSize
@@ -1199,6 +1179,7 @@ func readLastOggGranulePosition(file *os.File, fileSize int64) int64 {
 		if i+27 > n {
 			continue
 		}
+		// Validate minimal header fields to avoid false positives inside payload bytes.
 		version := buf[i+4]
 		headerType := buf[i+5]
 		if version != 0 || headerType > 0x07 {
@@ -1216,6 +1197,7 @@ func readLastOggGranulePosition(file *os.File, fileSize int64) int64 {
 		if i+headerLen+payloadLen > n {
 			continue
 		}
+		// Granule position is at bytes 6-13 of the Ogg page header (little-endian int64).
 		return int64(binary.LittleEndian.Uint64(buf[i+6 : i+14]))
 	}
 	return 0
@@ -1275,6 +1257,7 @@ func extractMP3CoverArt(filePath string) ([]byte, string, error) {
 		return nil, "", err
 	}

+	// Parse frames looking for APIC (Attached Picture)
 	pos := 0
 	var frameIDLen, headerLen int
 	if majorVersion == 2 {
@@ -1305,6 +1288,7 @@ func extractMP3CoverArt(filePath string) ([]byte, string, error) {
 			break
 		}

+		// Check for APIC (ID3v2.3/2.4) or PIC (ID3v2.2)
 		if (frameIDLen == 4 && frameID == "APIC") || (frameIDLen == 3 && frameID == "PIC") {
 			frameData := tagData[pos+headerLen : pos+headerLen+frameSize]
 			imageData, mimeType := parseAPICFrame(frameData, majorVersion)
@@ -1582,14 +1566,7 @@ func base64StdDecode(dst, src []byte) (int, error) {
 }

 func extractAnyCoverArt(filePath string) ([]byte, string, error) {
-	return extractAnyCoverArtWithHint(filePath, "")
-}
-
-func extractAnyCoverArtWithHint(filePath, displayNameHint string) ([]byte, string, error) {
 	ext := strings.ToLower(filepath.Ext(filePath))
-	if ext == "" {
-		ext = strings.ToLower(filepath.Ext(displayNameHint))
-	}

 	switch ext {
 	case ".flac":
@@ -1610,19 +1587,7 @@ func extractAnyCoverArtWithHint(filePath, displayNameHint string) ([]byte, strin
 		return extractOggCoverArt(filePath)

 	case ".m4a":
-		data, err := extractCoverFromM4A(filePath)
-		if err != nil {
-			return nil, "", err
-		}
-		mimeType := "image/jpeg"
-		if len(data) >= 8 &&
-			data[0] == 0x89 &&
-			data[1] == 0x50 &&
-			data[2] == 0x4E &&
-			data[3] == 0x47 {
-			mimeType = "image/png"
-		}
-		return data, mimeType, nil
+		return nil, "", fmt.Errorf("M4A cover extraction not yet supported")

 	default:
 		return nil, "", fmt.Errorf("unsupported format: %s", ext)
@@ -1630,28 +1595,10 @@ func extractAnyCoverArtWithHint(filePath, displayNameHint string) ([]byte, strin
 }

 func SaveCoverToCache(filePath, cacheDir string) (string, error) {
-	return SaveCoverToCacheWithHintAndKey(filePath, "", cacheDir, "")
-}
-
-func SaveCoverToCacheWithHint(filePath, displayNameHint, cacheDir string) (string, error) {
-	return SaveCoverToCacheWithHintAndKey(filePath, displayNameHint, cacheDir, "")
-}
-
-func resolveLibraryCoverCacheKey(filePath, explicitKey string) string {
-	explicitKey = strings.TrimSpace(explicitKey)
-	if explicitKey != "" {
-		return explicitKey
-	}
-
 	cacheKey := filePath
 	if stat, err := os.Stat(filePath); err == nil {
 		cacheKey = fmt.Sprintf("%s|%d|%d", filePath, stat.Size(), stat.ModTime().UnixNano())
 	}
-	return cacheKey
-}
-
-func SaveCoverToCacheWithHintAndKey(filePath, displayNameHint, cacheDir, coverCacheKey string) (string, error) {
-	cacheKey := resolveLibraryCoverCacheKey(filePath, coverCacheKey)
 	hash := hashString(cacheKey)

 	jpgPath := filepath.Join(cacheDir, fmt.Sprintf("cover_%x.jpg", hash))
@@ -1664,7 +1611,7 @@ func SaveCoverToCacheWithHintAndKey(filePath, displayNameHint, cacheDir, coverCa
 		return pngPath, nil
 	}

-	imageData, mimeType, err := extractAnyCoverArtWithHint(filePath, displayNameHint)
+	imageData, mimeType, err := extractAnyCoverArt(filePath)
 	if err != nil {
 		return "", err
 	}
@@ -1,34 +0,0 @@
-package gobackend
-
-import (
-	"os"
-	"strings"
-	"testing"
-)
-
-func TestResolveLibraryCoverCacheKeyUsesExplicitKey(t *testing.T) {
-	t.Parallel()
-
-	const explicitKey = "content://media/external/audio/media/42|123456"
-	got := resolveLibraryCoverCacheKey("/tmp/saf_random.flac", explicitKey)
-	if got != explicitKey {
-		t.Fatalf("expected explicit cache key %q, got %q", explicitKey, got)
-	}
-}
-
-func TestResolveLibraryCoverCacheKeyUsesFilePathAndStatWhenNoExplicitKey(t *testing.T) {
-	t.Parallel()
-
-	tempFile, err := os.CreateTemp("", "cover-cache-*.flac")
-	if err != nil {
-		t.Fatalf("CreateTemp failed: %v", err)
-	}
-	tempPath := tempFile.Name()
-	tempFile.Close()
-	defer os.Remove(tempPath)
-
-	got := resolveLibraryCoverCacheKey(tempPath, "")
-	if !strings.HasPrefix(got, tempPath+"|") {
-		t.Fatalf("expected stat-based cache key to start with %q, got %q", tempPath+"|", got)
-	}
-}
@@ -1,133 +0,0 @@
-package gobackend
-
-import (
-	"os"
-	"os/exec"
-	"path/filepath"
-	"strings"
-	"testing"
-)
-
-func ffmpegCommand(args ...string) *exec.Cmd {
-	if ffmpegPath, err := exec.LookPath("ffmpeg"); err == nil {
-		return exec.Command(ffmpegPath, args...)
-	}
-	return exec.Command("ffmpeg", args...)
-}
-
-func runFFmpegTestCommand(t *testing.T, args ...string) {
-	t.Helper()
-	cmd := ffmpegCommand(args...)
-	output, err := cmd.CombinedOutput()
-	if err != nil {
-		t.Fatalf("ffmpeg failed: %v\n%s", err, string(output))
-	}
-}
-
-func TestExtractLyricsReadsMp3AfterCoverEmbed(t *testing.T) {
-	if _, err := exec.LookPath("ffmpeg"); err != nil {
-		t.Skip("ffmpeg not available")
-	}
-
-	tempDir := t.TempDir()
-	sourceFlac := filepath.Join(tempDir, "source.flac")
-	baseMp3 := filepath.Join(tempDir, "base.mp3")
-	finalMp3 := filepath.Join(tempDir, "final.mp3")
-	coverPath := filepath.Join(tempDir, "cover.jpg")
-	lyrics := "[ti:Test Song]\n[ar:Test Artist]\n[00:00.00]Hello from embedded lyrics"
-
-	runFFmpegTestCommand(
-		t,
-		"-y",
-		"-f",
-		"lavfi",
-		"-i",
-		"sine=frequency=440:duration=1",
-		"-c:a",
-		"flac",
-		sourceFlac,
-	)
-
-	runFFmpegTestCommand(
-		t,
-		"-y",
-		"-f",
-		"lavfi",
-		"-i",
-		"color=c=red:s=32x32:d=1",
-		"-frames:v",
-		"1",
-		coverPath,
-	)
-
-	runFFmpegTestCommand(
-		t,
-		"-y",
-		"-i",
-		sourceFlac,
-		"-b:a",
-		"320k",
-		"-metadata",
-		"title=Test Song",
-		"-metadata",
-		"artist=Test Artist",
-		"-metadata",
-		"lyrics="+lyrics,
-		baseMp3,
-	)
-
-	runFFmpegTestCommand(
-		t,
-		"-y",
-		"-i",
-		baseMp3,
-		"-i",
-		coverPath,
-		"-map",
-		"0:a",
-		"-map_metadata",
-		"-1",
-		"-map",
-		"1:0",
-		"-c:v:0",
-		"copy",
-		"-id3v2_version",
-		"3",
-		"-metadata",
-		"title=Test Song",
-		"-metadata",
-		"artist=Test Artist",
-		"-metadata",
-		"lyrics="+lyrics,
-		"-metadata:s:v",
-		"title=Album cover",
-		"-metadata:s:v",
-		"comment=Cover (front)",
-		"-c:a",
-		"copy",
-		finalMp3,
-	)
-
-	meta, err := ReadID3Tags(finalMp3)
-	if err != nil {
-		t.Fatalf("ReadID3Tags failed: %v", err)
-	}
-	if meta == nil {
-		t.Fatalf("ReadID3Tags returned nil metadata")
-	}
-
-	embeddedLyrics, err := ExtractLyrics(finalMp3)
-	if err != nil {
-		t.Fatalf("ExtractLyrics failed: %v (metadata=%+v)", err, meta)
-	}
-	if !strings.Contains(embeddedLyrics, "Hello from embedded lyrics") {
-		t.Fatalf("embedded lyrics missing, got %q (metadata=%+v)", embeddedLyrics, meta)
-	}
-	if !strings.Contains(meta.Lyrics, "Hello from embedded lyrics") {
-		t.Fatalf("ReadID3Tags lyrics missing, got %+v", meta)
-	}
-
-	if _, err := os.Stat(finalMp3); err != nil {
-		t.Fatalf("expected final mp3 to exist: %v", err)
-	}
-}
@@ -17,8 +17,6 @@ const (
 // Deezer CDN supports these sizes: 56, 250, 500, 1000, 1400, 1800
 var deezerSizeRegex = regexp.MustCompile(`/(\d+)x(\d+)-\d+-\d+-\d+-\d+\.jpg$`)

-var tidalSizeRegex = regexp.MustCompile(`/\d+x\d+\.jpg$`)
-
 func convertSmallToMedium(imageURL string) string {
 	if strings.Contains(imageURL, spotifySize300) {
 		return strings.Replace(imageURL, spotifySize300, spotifySize640, 1)
@@ -42,6 +40,7 @@ func downloadCoverToMemory(coverURL string, maxQuality bool) ([]byte, error) {
 		maxURL := upgradeToMaxQuality(downloadURL)
 		if maxURL != downloadURL {
 			downloadURL = maxURL
+			// Log already printed by upgradeToMaxQuality for Deezer
 			if strings.Contains(coverURL, "scdn.co") || strings.Contains(coverURL, "spotifycdn") {
 				GoLog("[Cover] Spotify: upgraded to max resolution (~2000x2000)")
 			}
@@ -87,22 +86,16 @@ func downloadCoverToMemory(coverURL string, maxQuality bool) ([]byte, error) {
 }

 func upgradeToMaxQuality(coverURL string) string {
+	// Spotify CDN upgrade
 	if strings.Contains(coverURL, spotifySize640) {
 		return strings.Replace(coverURL, spotifySize640, spotifySizeMax, 1)
 	}

+	// Deezer CDN upgrade
 	if strings.Contains(coverURL, "cdn-images.dzcdn.net") {
 		return upgradeDeezerCover(coverURL)
 	}

-	if strings.Contains(coverURL, "resources.tidal.com") {
-		return upgradeTidalCover(coverURL)
-	}
-
-	if strings.Contains(coverURL, "static.qobuz.com") {
-		return upgradeQobuzCover(coverURL)
-	}
-
 	return coverURL
 }

@@ -111,6 +104,7 @@ func upgradeDeezerCover(coverURL string) string {
 		return coverURL
 	}

+	// Replace any size pattern with 1800x1800
 	upgraded := deezerSizeRegex.ReplaceAllString(coverURL, "/1800x1800-000000-80-0-0.jpg")
 	if upgraded != coverURL {
 		GoLog("[Cover] Deezer: upgraded to 1800x1800")
@@ -118,35 +112,12 @@ func upgradeDeezerCover(coverURL string) string {
 	return upgraded
 }

-func upgradeTidalCover(coverURL string) string {
-	if !strings.Contains(coverURL, "resources.tidal.com") {
-		return coverURL
-	}
-
-	upgraded := tidalSizeRegex.ReplaceAllString(coverURL, "/origin.jpg")
-	if upgraded != coverURL {
-		GoLog("[Cover] Tidal: upgraded to origin resolution")
-	}
-	return upgraded
-}
-
-func upgradeQobuzCover(coverURL string) string {
-	if !strings.Contains(coverURL, "static.qobuz.com") {
-		return coverURL
-	}
-
-	upgraded := qobuzImageSizeRe.ReplaceAllString(coverURL, "_max.jpg")
-	if upgraded != coverURL {
-		GoLog("[Cover] Qobuz: upgraded to max resolution")
-	}
-	return upgraded
-}
-
 func GetCoverFromSpotify(imageURL string, maxQuality bool) string {
 	if imageURL == "" {
 		return ""
 	}

+	// Always upgrade small to medium first
 	result := convertSmallToMedium(imageURL)

 	if maxQuality {
@@ -11,7 +11,9 @@ import (
 	"strings"
 )

+// CueSheet represents a parsed .cue file
 type CueSheet struct {
+	// Album-level metadata
 	Performer string     `json:"performer"`
 	Title     string     `json:"title"`
 	FileName  string     `json:"file_name"`
@@ -23,16 +25,19 @@ type CueSheet struct {
 	Tracks    []CueTrack `json:"tracks"`
 }

+// CueTrack represents a single track in a cue sheet
 type CueTrack struct {
-	Number    int     `json:"number"`
-	Title     string  `json:"title"`
-	Performer string  `json:"performer"`
-	ISRC      string  `json:"isrc,omitempty"`
-	Composer  string  `json:"composer,omitempty"`
+	Number    int    `json:"number"`
+	Title     string `json:"title"`
+	Performer string `json:"performer"`
+	ISRC      string `json:"isrc,omitempty"`
+	Composer  string `json:"composer,omitempty"`
+	// Index positions in seconds (fractional)
 	StartTime float64 `json:"start_time"` // INDEX 01 in seconds
 	PreGap    float64 `json:"pre_gap"`    // INDEX 00 in seconds (or -1 if not present)
 }

+// CueSplitInfo represents the information needed to split a CUE+audio file
 type CueSplitInfo struct {
 	CuePath   string          `json:"cue_path"`
 	AudioPath string          `json:"audio_path"`
@@ -43,6 +48,7 @@ type CueSplitInfo struct {
 	Tracks    []CueSplitTrack `json:"tracks"`
 }

+// CueSplitTrack has the FFmpeg split parameters for a single track
 type CueSplitTrack struct {
 	Number   int     `json:"number"`
 	Title    string  `json:"title"`
@@ -58,6 +64,7 @@ var (
 	reQuoted     = regexp.MustCompile(`"([^"]*)"`)
 )

+// ParseCueFile parses a .cue file and returns a CueSheet
 func ParseCueFile(cuePath string) (*CueSheet, error) {
 	f, err := os.Open(cuePath)
 	if err != nil {
@@ -75,6 +82,7 @@ func ParseCueFile(cuePath string) (*CueSheet, error) {
 			continue
 		}

+		// Handle BOM at start of file
 		if strings.HasPrefix(line, "\xef\xbb\xbf") {
 			line = strings.TrimPrefix(line, "\xef\xbb\xbf")
 			line = strings.TrimSpace(line)
@@ -82,6 +90,7 @@ func ParseCueFile(cuePath string) (*CueSheet, error) {

 		upper := strings.ToUpper(line)

+		// REM commands (album-level metadata)
 		if strings.HasPrefix(upper, "REM ") {
 			matches := reRemCommand.FindStringSubmatch(line)
 			if len(matches) == 3 {
@@ -105,6 +114,7 @@ func ParseCueFile(cuePath string) (*CueSheet, error) {
 			continue
 		}

+		// PERFORMER
 		if strings.HasPrefix(upper, "PERFORMER ") {
 			value := unquoteCue(line[len("PERFORMER "):])
 			if currentTrack != nil {
@@ -115,6 +125,7 @@ func ParseCueFile(cuePath string) (*CueSheet, error) {
 			continue
 		}

+		// TITLE
 		if strings.HasPrefix(upper, "TITLE ") {
 			value := unquoteCue(line[len("TITLE "):])
 			if currentTrack != nil {
@@ -125,15 +136,21 @@ func ParseCueFile(cuePath string) (*CueSheet, error) {
 			continue
 		}

+		// FILE
 		if strings.HasPrefix(upper, "FILE ") {
 			rest := line[len("FILE "):]
+			// Extract filename and type
+			// Format: FILE "filename.flac" WAVE
+			// or: FILE filename.flac WAVE
 			fname, ftype := parseCueFileLine(rest)
 			sheet.FileName = fname
 			sheet.FileType = ftype
 			continue
 		}

+		// TRACK
 		if strings.HasPrefix(upper, "TRACK ") {
+			// Save previous track
 			if currentTrack != nil {
 				sheet.Tracks = append(sheet.Tracks, *currentTrack)
 			}
@@ -151,6 +168,7 @@ func ParseCueFile(cuePath string) (*CueSheet, error) {
 			continue
 		}

+		// INDEX
 		if strings.HasPrefix(upper, "INDEX ") && currentTrack != nil {
 			parts := strings.Fields(line)
 			if len(parts) >= 3 {
@@ -166,11 +184,13 @@ func ParseCueFile(cuePath string) (*CueSheet, error) {
 			continue
 		}

+		// ISRC
 		if strings.HasPrefix(upper, "ISRC ") && currentTrack != nil {
 			currentTrack.ISRC = strings.TrimSpace(line[len("ISRC "):])
 			continue
 		}

+		// SONGWRITER (used as composer sometimes)
 		if strings.HasPrefix(upper, "SONGWRITER ") {
 			value := unquoteCue(line[len("SONGWRITER "):])
 			if currentTrack != nil {
@@ -182,6 +202,7 @@ func ParseCueFile(cuePath string) (*CueSheet, error) {
 		}
 	}

+	// Don't forget the last track
 	if currentTrack != nil {
 		sheet.Tracks = append(sheet.Tracks, *currentTrack)
 	}
@@ -197,6 +218,7 @@ func ParseCueFile(cuePath string) (*CueSheet, error) {
 	return sheet, nil
 }

+// parseCueTimestamp converts MM:SS:FF (frames at 75fps) to seconds
 func parseCueTimestamp(ts string) float64 {
 	parts := strings.Split(ts, ":")
 	if len(parts) != 3 {
@@ -210,6 +232,7 @@ func parseCueTimestamp(ts string) float64 {
 	return float64(minutes)*60 + float64(seconds) + float64(frames)/75.0
 }

+// formatCueTimestamp converts seconds to HH:MM:SS.mmm format for FFmpeg
 func formatCueTimestamp(seconds float64) string {
 	if seconds < 0 {
 		return "0"
@@ -220,6 +243,7 @@ func formatCueTimestamp(seconds float64) string {
 	return fmt.Sprintf("%02d:%02d:%06.3f", hours, mins, secs)
 }

+// unquoteCue removes surrounding quotes from a CUE value
 func unquoteCue(s string) string {
 	s = strings.TrimSpace(s)
 	if matches := reQuoted.FindStringSubmatch(s); len(matches) == 2 {
@@ -228,12 +252,14 @@ func unquoteCue(s string) string {
 	return s
 }

+// parseCueFileLine parses the FILE command's filename and type
 func parseCueFileLine(rest string) (string, string) {
 	rest = strings.TrimSpace(rest)

 	var filename, ftype string

 	if strings.HasPrefix(rest, "\"") {
+		// Quoted filename
 		endQuote := strings.Index(rest[1:], "\"")
 		if endQuote >= 0 {
 			filename = rest[1 : endQuote+1]
@@ -243,6 +269,7 @@ func parseCueFileLine(rest string) (string, string) {
 			filename = rest
 		}
 	} else {
+		// Unquoted filename - last word is the type
 		parts := strings.Fields(rest)
 		if len(parts) >= 2 {
 			ftype = parts[len(parts)-1]
@@ -255,14 +282,18 @@ func parseCueFileLine(rest string) (string, string) {
 	return filename, strings.TrimSpace(ftype)
 }

+// ResolveCueAudioPath finds the actual audio file referenced by a .cue sheet.
+// It checks relative to the cue file's directory.
 func ResolveCueAudioPath(cuePath string, cueFileName string) string {
 	cueDir := filepath.Dir(cuePath)

+	// 1. Try the exact filename from the .cue
 	candidate := filepath.Join(cueDir, cueFileName)
 	if _, err := os.Stat(candidate); err == nil {
 		return candidate
 	}

+	// 2. Try common case variations
 	baseName := strings.TrimSuffix(cueFileName, filepath.Ext(cueFileName))
 	commonExts := []string{".flac", ".wav", ".ape", ".mp3", ".ogg", ".wv", ".m4a"}
 	for _, ext := range commonExts {
@@ -270,12 +301,14 @@ func ResolveCueAudioPath(cuePath string, cueFileName string) string {
 		if _, err := os.Stat(candidate); err == nil {
 			return candidate
 		}
+		// Try uppercase ext
 		candidate = filepath.Join(cueDir, baseName+strings.ToUpper(ext))
 		if _, err := os.Stat(candidate); err == nil {
 			return candidate
 		}
 	}

+	// 3. Try to find any audio file with the same base name as the .cue file
 	cueBase := strings.TrimSuffix(filepath.Base(cuePath), filepath.Ext(cuePath))
 	for _, ext := range commonExts {
 		candidate = filepath.Join(cueDir, cueBase+ext)
@@ -284,6 +317,7 @@ func ResolveCueAudioPath(cuePath string, cueFileName string) string {
 		}
 	}

+	// 4. If there's only one audio file in the directory, use that
 	entries, err := os.ReadDir(cueDir)
 	if err == nil {
 		audioExts := map[string]bool{
@@ -308,9 +342,13 @@ func ResolveCueAudioPath(cuePath string, cueFileName string) string {
 	return ""
 }

+// BuildCueSplitInfo creates the split information from a parsed CUE sheet.
+// This is returned to the Dart side so FFmpeg can perform the splitting.
+// audioDir, if non-empty, overrides the directory for audio file resolution.
 func BuildCueSplitInfo(cuePath string, sheet *CueSheet, audioDir string) (*CueSplitInfo, error) {
 	resolveDir := cuePath
 	if audioDir != "" {
+		// Create a virtual path in audioDir so ResolveCueAudioPath looks there
 		resolveDir = filepath.Join(audioDir, filepath.Base(cuePath))
 	}
 	audioPath := ResolveCueAudioPath(resolveDir, sheet.FileName)
@@ -338,9 +376,11 @@ func BuildCueSplitInfo(cuePath string, sheet *CueSheet, audioDir string) (*CueSp
 			composer = sheet.Composer
 		}

+		// End time is the start of the next track, or -1 for the last track
 		endSec := float64(-1)
 		if i+1 < len(sheet.Tracks) {
 			nextTrack := sheet.Tracks[i+1]
+			// Use pre-gap of next track if available, otherwise its start time
 			if nextTrack.PreGap >= 0 {
 				endSec = nextTrack.PreGap
 			} else {
@@ -362,6 +402,11 @@ func BuildCueSplitInfo(cuePath string, sheet *CueSheet, audioDir string) (*CueSp
 	return info, nil
 }

+// ParseCueFileJSON parses a .cue file and returns JSON with split info.
+// This is the main entry point called from Dart via the platform bridge.
+// audioDir, if non-empty, overrides the directory used for resolving the
+// referenced audio file (useful when the .cue was copied to a temp dir
+// but the audio still lives in the original location, e.g. SAF).
 func ParseCueFileJSON(cuePath string, audioDir string) (string, error) {
 	sheet, err := ParseCueFile(cuePath)
 	if err != nil {
@@ -381,69 +426,41 @@ func ParseCueFileJSON(cuePath string, audioDir string) (string, error) {
 	return string(jsonBytes), nil
 }

+// ScanCueFileForLibrary parses a .cue file and returns multiple LibraryScanResult
+// entries, one per track. This is used by the library scanner to populate the
+// library with individual track entries from a single CUE+FLAC album.
 func ScanCueFileForLibrary(cuePath string, scanTime string) ([]LibraryScanResult, error) {
-	sheet, err := ParseCueFile(cuePath)
-	if err != nil {
-		return nil, err
-	}
-	audioPath, err := resolveCueAudioPathForLibrary(cuePath, sheet, "")
-	if err != nil {
-		return nil, err
-	}
-	return scanCueSheetForLibrary(cuePath, sheet, audioPath, "", 0, "", scanTime)
+	return scanCueFileForLibraryInternal(cuePath, "", "", 0, scanTime)
 }

+// ScanCueFileForLibraryExt is like ScanCueFileForLibrary but with extra parameters
+// for SAF (Storage Access Framework) scenarios:
+//   - audioDir: if non-empty, overrides the directory used to find the audio file
+//   - virtualPathPrefix: if non-empty, used instead of cuePath as the base for
+//     virtual file paths (e.g. a content:// URI). IDs are also based on this.
+//   - fileModTime: if > 0, used as the FileModTime for all results instead of
+//     stat-ing the cuePath on disk (useful when the real file lives behind SAF)
 func ScanCueFileForLibraryExt(cuePath, audioDir, virtualPathPrefix string, fileModTime int64, scanTime string) ([]LibraryScanResult, error) {
-	return ScanCueFileForLibraryExtWithCoverCacheKey(
-		cuePath,
-		audioDir,
-		virtualPathPrefix,
-		fileModTime,
-		"",
-		scanTime,
-	)
+	return scanCueFileForLibraryInternal(cuePath, audioDir, virtualPathPrefix, fileModTime, scanTime)
 }

-func ScanCueFileForLibraryExtWithCoverCacheKey(cuePath, audioDir, virtualPathPrefix string, fileModTime int64, coverCacheKey, scanTime string) ([]LibraryScanResult, error) {
+func scanCueFileForLibraryInternal(cuePath, audioDir, virtualPathPrefix string, fileModTime int64, scanTime string) ([]LibraryScanResult, error) {
 	sheet, err := ParseCueFile(cuePath)
 	if err != nil {
 		return nil, err
 	}
-	audioPath, err := resolveCueAudioPathForLibrary(cuePath, sheet, audioDir)
-	if err != nil {
-		return nil, err
-	}
-	return scanCueSheetForLibrary(
-		cuePath,
-		sheet,
-		audioPath,
-		virtualPathPrefix,
-		fileModTime,
-		coverCacheKey,
-		scanTime,
-	)
-}

-func resolveCueAudioPathForLibrary(cuePath string, sheet *CueSheet, audioDir string) (string, error) {
-	if sheet == nil {
-		return "", fmt.Errorf("cue sheet is nil for %s", cuePath)
-	}
+	// Resolve audio file — optionally in an overridden directory
 	resolveBase := cuePath
 	if audioDir != "" {
 		resolveBase = filepath.Join(audioDir, filepath.Base(cuePath))
 	}
 	audioPath := ResolveCueAudioPath(resolveBase, sheet.FileName)
 	if audioPath == "" {
-		return "", fmt.Errorf("audio file not found for cue: %s (referenced: %s)", cuePath, sheet.FileName)
-	}
-	return audioPath, nil
-}
-
-func scanCueSheetForLibrary(cuePath string, sheet *CueSheet, audioPath, virtualPathPrefix string, fileModTime int64, coverCacheKey, scanTime string) ([]LibraryScanResult, error) {
-	if sheet == nil {
-		return nil, fmt.Errorf("cue sheet is nil for %s", cuePath)
+		return nil, fmt.Errorf("audio file not found for cue: %s (referenced: %s)", cuePath, sheet.FileName)
 	}

+	// Try to get quality info from the audio file
 	var bitDepth, sampleRate int
 	var totalDurationSec float64
 	audioExt := strings.ToLower(filepath.Ext(audioPath))
@@ -465,27 +482,25 @@ func scanCueSheetForLibrary(cuePath string, sheet *CueSheet, audioPath, virtualP
 		}
 	}

+	// Extract cover from audio file for all tracks
 	var coverPath string
 	libraryCoverCacheMu.RLock()
 	coverCacheDir := libraryCoverCacheDir
 	libraryCoverCacheMu.RUnlock()
 	if coverCacheDir != "" {
-		cp, err := SaveCoverToCacheWithHintAndKey(
-			audioPath,
-			"",
-			coverCacheDir,
-			coverCacheKey,
-		)
+		cp, err := SaveCoverToCache(audioPath, coverCacheDir)
 		if err == nil && cp != "" {
 			coverPath = cp
 		}
 	}

+	// Determine the base path for virtual paths and IDs
 	pathBase := cuePath
 	if virtualPathPrefix != "" {
 		pathBase = virtualPathPrefix
 	}

+	// Determine fileModTime
 	modTime := fileModTime
 	if modTime <= 0 {
 		if info, err := os.Stat(cuePath); err == nil {
@@ -513,11 +528,7 @@ func scanCueSheetForLibrary(cuePath string, sheet *CueSheet, audioPath, virtualP
 			album = "Unknown Album"
 		}

-		composer := track.Composer
-		if composer == "" {
-			composer = sheet.Composer
-		}
-
+		// Calculate duration for this track
 		var duration int
 		if i+1 < len(sheet.Tracks) {
 			nextStart := sheet.Tracks[i+1].StartTime
@@ -529,8 +540,12 @@ func scanCueSheetForLibrary(cuePath string, sheet *CueSheet, audioPath, virtualP
 			duration = int(totalDurationSec - track.StartTime)
 		}

+		// Use a unique ID based on pathBase + track number
 		id := generateLibraryID(fmt.Sprintf("%s#track%d", pathBase, track.Number))

+		// Use a virtual file path that includes the track number to ensure
+		// uniqueness in the database (file_path has a UNIQUE constraint).
+		// Format: /path/to/album.cue#track01 or content://...album.cue#track01
 		virtualFilePath := fmt.Sprintf("%s#track%02d", pathBase, track.Number)

 		result := LibraryScanResult{
@@ -544,15 +559,12 @@ func scanCueSheetForLibrary(cuePath string, sheet *CueSheet, audioPath, virtualP
 			ScannedAt:   scanTime,
 			ISRC:        track.ISRC,
 			TrackNumber: track.Number,
-			TotalTracks: len(sheet.Tracks),
 			DiscNumber:  1,
-			TotalDiscs:  1,
 			Duration:    duration,
 			ReleaseDate: sheet.Date,
 			BitDepth:    bitDepth,
 			SampleRate:  sampleRate,
 			Genre:       sheet.Genre,
-			Composer:    composer,
 			Format:      "cue+" + strings.TrimPrefix(audioExt, "."),
 		}

@@ -196,22 +196,15 @@ type deezerAlbumSimple struct {
 	RecordType  string `json:"record_type"`
 }

-// deezerTrackArtistDisplay returns the display artist string for a track,
-// preferring the Contributors list (comma-joined) when available, falling
-// back to the primary Artist.Name.
-func deezerTrackArtistDisplay(track deezerTrack) string {
+func (c *DeezerClient) convertTrack(track deezerTrack) TrackMetadata {
+	artistName := track.Artist.Name
 	if len(track.Contributors) > 0 {
 		names := make([]string, len(track.Contributors))
 		for i, a := range track.Contributors {
 			names[i] = a.Name
 		}
-		return strings.Join(names, ", ")
+		artistName = strings.Join(names, ", ")
 	}
-	return track.Artist.Name
-}
-
-func (c *DeezerClient) convertTrack(track deezerTrack) TrackMetadata {
-	artistName := deezerTrackArtistDisplay(track)

 	albumImage := track.Album.CoverXL
 	if albumImage == "" {
@@ -263,7 +256,6 @@ type deezerAlbumFull struct {
 	NbTracks    int    `json:"nb_tracks"`
 	RecordType  string `json:"record_type"`
 	Label       string `json:"label"`
-	Copyright   string `json:"copyright"`
 	Genres      struct {
 		Data []deezerGenre `json:"data"`
 	} `json:"genres"`
@@ -630,12 +622,6 @@ func (c *DeezerClient) GetAlbum(ctx context.Context, albumID string) (*AlbumResp
 	}

 	isrcMap := c.fetchISRCsParallel(ctx, allTracks)
-	totalDiscs := 0
-	for _, track := range allTracks {
-		if track.DiskNumber > totalDiscs {
-			totalDiscs = track.DiskNumber
-		}
-	}

 	tracks := make([]AlbumTrackMetadata, 0, len(allTracks))
 	albumType := album.RecordType
@@ -654,7 +640,7 @@ func (c *DeezerClient) GetAlbum(ctx context.Context, albumID string) (*AlbumResp

 		tracks = append(tracks, AlbumTrackMetadata{
 			SpotifyID:   fmt.Sprintf("deezer:%d", track.ID),
-			Artists:     deezerTrackArtistDisplay(track),
+			Artists:     track.Artist.Name,
 			Name:        track.Title,
 			AlbumName:   album.Title,
 			AlbumArtist: artistName,
@@ -664,7 +650,6 @@ func (c *DeezerClient) GetAlbum(ctx context.Context, albumID string) (*AlbumResp
 			TrackNumber: trackNum,
 			TotalTracks: album.NbTracks,
 			DiscNumber:  track.DiskNumber,
-			TotalDiscs:  totalDiscs,
 			ExternalURL: track.Link,
 			ISRC:        isrc,
 			AlbumID:     fmt.Sprintf("deezer:%d", album.ID),
@@ -755,10 +740,6 @@ func (c *DeezerClient) GetArtist(ctx context.Context, artistID string) (*ArtistR
 				Artists:     artist.Name,
 			})
 		}
-
-		// The Deezer /artist/{id}/albums endpoint does not return nb_tracks.
-		// Fetch track counts in parallel from individual /album/{id} endpoints.
-		c.fetchAlbumTrackCounts(ctx, albums)
 	}

 	result := &ArtistResponsePayload{
@@ -778,63 +759,6 @@ func (c *DeezerClient) GetArtist(ctx context.Context, artistID string) (*ArtistR
 	return result, nil
 }

-// fetchAlbumTrackCounts fetches nb_tracks for each album in parallel using
-// individual /album/{id} calls, since the /artist/{id}/albums endpoint does
-// not include this field. Albums whose track count is already known (non-zero)
-// are skipped.
-func (c *DeezerClient) fetchAlbumTrackCounts(ctx context.Context, albums []ArtistAlbumMetadata) {
-	// Find albums that need track counts
-	type indexedID struct {
-		idx     int
-		albumID string
-	}
-	var toFetch []indexedID
-	for i, a := range albums {
-		if a.TotalTracks == 0 {
-			rawID := strings.TrimPrefix(a.ID, "deezer:")
-			if rawID != "" {
-				toFetch = append(toFetch, indexedID{idx: i, albumID: rawID})
-			}
-		}
-	}
-	if len(toFetch) == 0 {
-		return
-	}
-
-	const maxParallel = 10
-	sem := make(chan struct{}, maxParallel)
-	var mu sync.Mutex
-	var wg sync.WaitGroup
-
-	for _, item := range toFetch {
-		wg.Add(1)
-		go func(it indexedID) {
-			defer wg.Done()
-
-			select {
-			case sem <- struct{}{}:
-				defer func() { <-sem }()
-			case <-ctx.Done():
-				return
-			}
-
-			albumURL := fmt.Sprintf(deezerAlbumURL, it.albumID)
-			var resp struct {
-				NbTracks int `json:"nb_tracks"`
-			}
-			if err := c.getJSON(ctx, albumURL, &resp); err != nil {
-				return
-			}
-
-			mu.Lock()
-			albums[it.idx].TotalTracks = resp.NbTracks
-			mu.Unlock()
-		}(item)
-	}
-
-	wg.Wait()
-}
-
 func (c *DeezerClient) GetRelatedArtists(ctx context.Context, artistID string, limit int) ([]SearchArtistResult, error) {
 	normalizedArtistID := strings.TrimSpace(strings.TrimPrefix(artistID, "deezer:"))
 	if normalizedArtistID == "" {
@@ -967,7 +891,7 @@ func (c *DeezerClient) GetPlaylist(ctx context.Context, playlistID string) (*Pla

 		tracks = append(tracks, AlbumTrackMetadata{
 			SpotifyID:   fmt.Sprintf("deezer:%d", track.ID),
-			Artists:     deezerTrackArtistDisplay(track),
+			Artists:     track.Artist.Name,
 			Name:        track.Title,
 			AlbumName:   track.Album.Title,
 			AlbumArtist: track.Artist.Name,
@@ -1160,9 +1084,8 @@ func (c *DeezerClient) getBestAlbumImage(album deezerAlbumFull) string {
 }

 type AlbumExtendedMetadata struct {
-	Genre     string
-	Label     string
-	Copyright string
+	Genre string
+	Label string
 }

 func (c *DeezerClient) GetAlbumExtendedMetadata(ctx context.Context, albumID string) (*AlbumExtendedMetadata, error) {
@@ -1193,9 +1116,8 @@ func (c *DeezerClient) GetAlbumExtendedMetadata(ctx context.Context, albumID str
 	}

 	result := &AlbumExtendedMetadata{
-		Genre:     strings.Join(genres, ", "),
-		Label:     album.Label,
-		Copyright: album.Copyright,
+		Genre: strings.Join(genres, ", "),
+		Label: album.Label,
 	}

 	c.cacheMu.Lock()
@@ -1207,7 +1129,7 @@ func (c *DeezerClient) GetAlbumExtendedMetadata(ctx context.Context, albumID str
 	c.maybeCleanupCachesLocked(now)
 	c.cacheMu.Unlock()

-	GoLog("[Deezer] Album metadata fetched - Genre: %s, Label: %s, Copyright: %s\n", result.Genre, result.Label, result.Copyright)
+	GoLog("[Deezer] Album metadata fetched - Genre: %s, Label: %s\n", result.Genre, result.Label)

 	return result, nil
 }
@@ -1256,7 +1178,7 @@ func (c *DeezerClient) getJSON(ctx context.Context, endpoint string, dst interfa

 	for attempt := 0; attempt <= deezerMaxRetries; attempt++ {
 		if attempt > 0 {
-			delay := deezerRetryDelay * time.Duration(1<<(attempt-1))
+			delay := deezerRetryDelay * time.Duration(1<<(attempt-1)) // Exponential backoff
 			GoLog("[Deezer] Retry %d/%d after %v...\n", attempt, deezerMaxRetries, delay)
 			time.Sleep(delay)
 		}
@@ -1269,6 +1191,7 @@ func (c *DeezerClient) getJSON(ctx context.Context, endpoint string, dst interfa
 		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") ||
@@ -14,7 +14,14 @@ import (
 	"strings"
 )

-const deezerMusicDLURL = "https://api.zarz.moe/v1/dzr"
+const deezerYoinkifyURL = "https://yoinkify.lol/api/download"
+const deezerMusicDLURL = "https://www.musicdl.me/api/download"
+
+type YoinkifyRequest struct {
+	URL         string `json:"url"`
+	Format      string `json:"format"`
+	GenreSource string `json:"genreSource"`
+}

 type DeezerDownloadResult struct {
 	FilePath    string
@@ -30,6 +37,41 @@ type DeezerDownloadResult struct {
 	LyricsLRC   string
 }

+func resolveSpotifyURLForYoinkify(req DownloadRequest) (string, error) {
+	rawSpotify := strings.TrimSpace(req.SpotifyID)
+	if rawSpotify != "" {
+		if isLikelySpotifyTrackID(rawSpotify) {
+			return fmt.Sprintf("https://open.spotify.com/track/%s", rawSpotify), nil
+		}
+
+		if parsed, err := parseSpotifyURI(rawSpotify); err == nil && parsed.Type == "track" && parsed.ID != "" {
+			return fmt.Sprintf("https://open.spotify.com/track/%s", parsed.ID), nil
+		}
+	}
+
+	deezerID := strings.TrimSpace(req.DeezerID)
+	if deezerID == "" {
+		if prefixed, found := strings.CutPrefix(rawSpotify, "deezer:"); found {
+			deezerID = strings.TrimSpace(prefixed)
+		}
+	}
+
+	if deezerID != "" {
+		songlink := NewSongLinkClient()
+		spotifyID, err := songlink.GetSpotifyIDFromDeezer(deezerID)
+		if err != nil {
+			return "", fmt.Errorf("failed to map deezer:%s to Spotify ID: %w", deezerID, err)
+		}
+		spotifyID = strings.TrimSpace(spotifyID)
+		if spotifyID == "" {
+			return "", fmt.Errorf("SongLink returned empty Spotify ID for deezer:%s", deezerID)
+		}
+		return fmt.Sprintf("https://open.spotify.com/track/%s", spotifyID), nil
+	}
+
+	return "", fmt.Errorf("missing Spotify track ID for Deezer Yoinkify")
+}
+
 func isLikelySpotifyTrackID(value string) bool {
 	if len(value) != 22 {
 		return false
@@ -46,6 +88,113 @@ func isLikelySpotifyTrackID(value string) bool {
 	return true
 }

+func (c *DeezerClient) DownloadFromYoinkify(spotifyURL, outputPath string, outputFD int, itemID string) error {
+	payload := YoinkifyRequest{
+		URL:         spotifyURL,
+		Format:      "flac",
+		GenreSource: "spotify",
+	}
+
+	jsonData, err := json.Marshal(payload)
+	if err != nil {
+		return fmt.Errorf("failed to encode Yoinkify request: %w", err)
+	}
+
+	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, http.MethodPost, deezerYoinkifyURL, bytes.NewBuffer(jsonData))
+	if err != nil {
+		return fmt.Errorf("failed to create Yoinkify request: %w", err)
+	}
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("Accept", "*/*")
+	req.Header.Set("User-Agent", getRandomUserAgent())
+
+	resp, err := GetDownloadClient().Do(req)
+	if err != nil {
+		if isDownloadCancelled(itemID) {
+			return ErrDownloadCancelled
+		}
+		return fmt.Errorf("failed to call Yoinkify: %w", err)
+	}
+	defer resp.Body.Close()
+
+	contentType := strings.ToLower(strings.TrimSpace(resp.Header.Get("Content-Type")))
+	if resp.StatusCode != http.StatusOK {
+		bodyBytes, _ := io.ReadAll(io.LimitReader(resp.Body, 4096))
+		bodyText := strings.TrimSpace(string(bodyBytes))
+		if bodyText != "" {
+			return fmt.Errorf("Yoinkify returned status %d: %s", resp.StatusCode, bodyText)
+		}
+		return fmt.Errorf("Yoinkify returned status %d", resp.StatusCode)
+	}
+
+	if strings.Contains(contentType, "application/json") {
+		bodyBytes, _ := io.ReadAll(io.LimitReader(resp.Body, 4096))
+		bodyText := strings.TrimSpace(string(bodyBytes))
+		if bodyText == "" {
+			bodyText = "empty JSON payload"
+		}
+		return fmt.Errorf("Yoinkify returned JSON instead of audio: %s", bodyText)
+	}
+
+	expectedSize := resp.ContentLength
+	if expectedSize > 0 && itemID != "" {
+		SetItemBytesTotal(itemID, expectedSize)
+	}
+
+	out, err := openOutputForWrite(outputPath, outputFD)
+	if err != nil {
+		return err
+	}
+
+	bufWriter := bufio.NewWriterSize(out, 256*1024)
+	var written int64
+	if itemID != "" {
+		pw := NewItemProgressWriter(bufWriter, itemID)
+		written, err = io.Copy(pw, 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 output: %w", flushErr)
+	}
+	if closeErr != nil {
+		cleanupOutputOnError(outputPath, outputFD)
+		return fmt.Errorf("failed to close output: %w", closeErr)
+	}
+
+	if expectedSize > 0 && written != expectedSize {
+		cleanupOutputOnError(outputPath, outputFD)
+		return fmt.Errorf("incomplete download: expected %d bytes, got %d bytes", expectedSize, written)
+	}
+
+	GoLog("[Deezer] Downloaded via Yoinkify: %.2f MB\n", float64(written)/(1024*1024))
+	return nil
+}
+
 func resolveDeezerTrackURL(req DownloadRequest) (string, error) {
 	deezerID := strings.TrimSpace(req.DeezerID)
 	if deezerID == "" {
@@ -54,46 +203,29 @@ func resolveDeezerTrackURL(req DownloadRequest) (string, error) {
 		}
 	}
 	if deezerID != "" {
-		trackURL := fmt.Sprintf("https://www.deezer.com/track/%s", deezerID)
-		if err := verifyDeezerTrack(req, deezerID, false); err != nil {
-			GoLog("[Deezer] Direct ID %s verification failed: %v\n", deezerID, err)
-			// Don't reject direct IDs from request payload — they're presumably correct.
-		}
-		return trackURL, nil
+		return fmt.Sprintf("https://www.deezer.com/track/%s", deezerID), nil
 	}

+	// Try resolving Deezer ID from Spotify ID via SongLink
 	spotifyID := strings.TrimSpace(req.SpotifyID)
 	if spotifyID != "" && isLikelySpotifyTrackID(spotifyID) {
 		songlink := NewSongLinkClient()
 		availability, err := songlink.CheckTrackAvailability(spotifyID, "")
 		if err == nil && availability.Deezer && availability.DeezerURL != "" {
-			resolvedID := extractDeezerIDFromURL(availability.DeezerURL)
-			if resolvedID != "" {
-				if verifyErr := verifyDeezerTrack(req, resolvedID, true); verifyErr != nil {
-					GoLog("[Deezer] SongLink ID %s rejected: %v\n", resolvedID, verifyErr)
-					// Fall through to ISRC search instead of using wrong track.
-				} else {
-					return availability.DeezerURL, nil
-				}
-			} else {
-				return availability.DeezerURL, nil
-			}
+			return availability.DeezerURL, nil
 		}
 	}

+	// Try resolving from ISRC
 	isrc := strings.TrimSpace(req.ISRC)
 	if isrc != "" {
 		ctx, cancel := context.WithTimeout(context.Background(), SongLinkTimeout)
 		defer cancel()
 		track, err := GetDeezerClient().SearchByISRC(ctx, isrc)
 		if err == nil && track != nil {
-			resolvedID := songLinkExtractDeezerTrackID(track)
-			if resolvedID != "" {
-				if verifyErr := verifyDeezerTrack(req, resolvedID, false); verifyErr != nil {
-					GoLog("[Deezer] ISRC-resolved ID %s rejected: %v\n", resolvedID, verifyErr)
-					return "", fmt.Errorf("deezer track resolved via ISRC does not match: %w", verifyErr)
-				}
-				return fmt.Sprintf("https://www.deezer.com/track/%s", resolvedID), nil
+			deezerID = songLinkExtractDeezerTrackID(track)
+			if deezerID != "" {
+				return fmt.Sprintf("https://www.deezer.com/track/%s", deezerID), nil
 			}
 		}
 	}
@@ -101,28 +233,6 @@ func resolveDeezerTrackURL(req DownloadRequest) (string, error) {
 	return "", fmt.Errorf("could not resolve Deezer track URL")
 }

-func verifyDeezerTrack(req DownloadRequest, deezerID string, skipNameVerification bool) error {
-	ctx, cancel := context.WithTimeout(context.Background(), SongLinkTimeout)
-	defer cancel()
-	trackResp, err := GetDeezerClient().GetTrack(ctx, deezerID)
-	if err != nil {
-		return nil // Can't verify — don't block the download.
-	}
-	resolved := resolvedTrackInfo{
-		Title:                trackResp.Track.Name,
-		ArtistName:           trackResp.Track.Artists,
-		ISRC:                 trackResp.Track.ISRC,
-		Duration:             trackResp.Track.DurationMS / 1000,
-		SkipNameVerification: skipNameVerification,
-	}
-	if !trackMatchesRequest(req, resolved, "Deezer") {
-		return fmt.Errorf("expected '%s - %s', got '%s - %s'",
-			req.ArtistName, req.TrackName, resolved.ArtistName, resolved.Title)
-	}
-	GoLog("[Deezer] Track %s verified: '%s - %s' ✓\n", deezerID, resolved.ArtistName, resolved.Title)
-	return nil
-}
-
 type deezerMusicDLRequest struct {
 	Platform string `json:"platform"`
 	URL      string `json:"url"`
@@ -143,6 +253,7 @@ func (c *DeezerClient) GetMusicDLDownloadURL(deezerTrackURL string) (string, err
 		return "", fmt.Errorf("failed to create MusicDL request: %w", err)
 	}
 	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("X-Debug-Key", getQobuzDebugKey())
 	req.Header.Set("User-Agent", getRandomUserAgent())

 	resp, err := c.httpClient.Do(req)
@@ -169,6 +280,7 @@ func (c *DeezerClient) GetMusicDLDownloadURL(deezerTrackURL string) (string, err
 		return "", fmt.Errorf("MusicDL error: %s", errMsg)
 	}

+	// Try various response fields for download URL
 	for _, key := range []string{"download_url", "url", "link"} {
 		if urlVal, ok := raw[key].(string); ok && strings.TrimSpace(urlVal) != "" {
 			return strings.TrimSpace(urlVal), nil
@@ -282,6 +394,11 @@ func downloadFromDeezer(req DownloadRequest) (DeezerDownloadResult, error) {
 		}
 	}

+	spotifyURL, err := resolveSpotifyURLForYoinkify(req)
+	if err != nil {
+		return DeezerDownloadResult{}, err
+	}
+
 	filename := buildFilenameFromTemplate(req.FilenameFormat, map[string]interface{}{
 		"title":  req.TrackName,
 		"artist": req.ArtistName,
@@ -327,29 +444,30 @@ func downloadFromDeezer(req DownloadRequest) (DeezerDownloadResult, error) {
 		)
 	}()

+	// Try MusicDL first (better quality), fallback to Yoinkify
+	var downloadErr error
 	deezerTrackURL, deezerURLErr := resolveDeezerTrackURL(req)
-	if deezerURLErr != nil {
-		return DeezerDownloadResult{}, fmt.Errorf(
-			"deezer download failed: could not resolve Deezer URL: %w",
-			deezerURLErr,
-		)
+	if deezerURLErr == nil {
+		GoLog("[Deezer] Trying MusicDL for: %s\n", deezerTrackURL)
+		downloadErr = deezerClient.DownloadFromMusicDL(deezerTrackURL, outputPath, req.OutputFD, req.ItemID)
+		if downloadErr != nil {
+			if errors.Is(downloadErr, ErrDownloadCancelled) {
+				return DeezerDownloadResult{}, ErrDownloadCancelled
+			}
+			GoLog("[Deezer] MusicDL failed: %v, falling back to Yoinkify\n", downloadErr)
+		}
+	} else {
+		GoLog("[Deezer] Could not resolve Deezer URL: %v, using Yoinkify directly\n", deezerURLErr)
 	}

-	GoLog("[Deezer] Trying MusicDL for: %s\n", deezerTrackURL)
-	downloadErr := deezerClient.DownloadFromMusicDL(
-		deezerTrackURL,
-		outputPath,
-		req.OutputFD,
-		req.ItemID,
-	)
-	if downloadErr != nil {
-		if errors.Is(downloadErr, ErrDownloadCancelled) {
-			return DeezerDownloadResult{}, ErrDownloadCancelled
+	if downloadErr != nil || deezerURLErr != nil {
+		downloadErr = deezerClient.DownloadFromYoinkify(spotifyURL, outputPath, req.OutputFD, req.ItemID)
+		if downloadErr != nil {
+			if errors.Is(downloadErr, ErrDownloadCancelled) {
+				return DeezerDownloadResult{}, ErrDownloadCancelled
+			}
+			return DeezerDownloadResult{}, fmt.Errorf("deezer download failed (MusicDL + Yoinkify): %w", downloadErr)
 		}
-		return DeezerDownloadResult{}, fmt.Errorf(
-			"deezer download failed via MusicDL: %w",
-			downloadErr,
-		)
 	}

 	<-parallelDone
@@ -360,21 +478,18 @@ func downloadFromDeezer(req DownloadRequest) (DeezerDownloadResult, error) {
 	}

 	metadata := Metadata{
-		Title:         req.TrackName,
-		Artist:        req.ArtistName,
-		Album:         req.AlbumName,
-		AlbumArtist:   req.AlbumArtist,
-		ArtistTagMode: req.ArtistTagMode,
-		Date:          req.ReleaseDate,
-		TrackNumber:   req.TrackNumber,
-		TotalTracks:   req.TotalTracks,
-		DiscNumber:    req.DiscNumber,
-		TotalDiscs:    req.TotalDiscs,
-		ISRC:          req.ISRC,
-		Genre:         req.Genre,
-		Label:         req.Label,
-		Copyright:     req.Copyright,
-		Composer:      req.Composer,
+		Title:       req.TrackName,
+		Artist:      req.ArtistName,
+		Album:       req.AlbumName,
+		AlbumArtist: req.AlbumArtist,
+		Date:        req.ReleaseDate,
+		TrackNumber: req.TrackNumber,
+		TotalTracks: req.TotalTracks,
+		DiscNumber:  req.DiscNumber,
+		ISRC:        req.ISRC,
+		Genre:       req.Genre,
+		Label:       req.Label,
+		Copyright:   req.Copyright,
 	}

 	var coverData []byte
@@ -25,6 +25,7 @@ var (
 )

 func GetISRCIndex(outputDir string) *ISRCIndex {
+	// Fast path: check cache first
 	isrcIndexCacheMu.RLock()
 	idx, exists := isrcIndexCache[outputDir]
 	isrcIndexCacheMu.RUnlock()
@@ -33,11 +34,14 @@ func GetISRCIndex(outputDir string) *ISRCIndex {
 		return idx
 	}

+	// Slow path: need to build index
+	// Use per-directory mutex to prevent multiple goroutines from building simultaneously
 	buildLock, _ := isrcBuildingMu.LoadOrStore(outputDir, &sync.Mutex{})
 	mu := buildLock.(*sync.Mutex)
 	mu.Lock()
 	defer mu.Unlock()

+	// Double-check cache after acquiring lock (another goroutine may have built it)
 	isrcIndexCacheMu.RLock()
 	idx, exists = isrcIndexCache[outputDir]
 	isrcIndexCacheMu.RUnlock()
@@ -1,59 +0,0 @@
-package gobackend
-
-import "testing"
-
-func TestBuildDeezerExtendedMetadataResultHandlesNil(t *testing.T) {
-	result := buildDeezerExtendedMetadataResult(nil)
-
-	if result["genre"] != "" {
-		t.Fatalf("expected empty genre, got %q", result["genre"])
-	}
-	if result["label"] != "" {
-		t.Fatalf("expected empty label, got %q", result["label"])
-	}
-	if result["copyright"] != "" {
-		t.Fatalf("expected empty copyright, got %q", result["copyright"])
-	}
-}
-
-func TestBuildDeezerExtendedMetadataResultIncludesCopyright(t *testing.T) {
-	result := buildDeezerExtendedMetadataResult(&AlbumExtendedMetadata{
-		Genre:     "Rock",
-		Label:     "EMI",
-		Copyright: "(C) Queen",
-	})
-
-	if result["genre"] != "Rock" {
-		t.Fatalf("unexpected genre: %q", result["genre"])
-	}
-	if result["label"] != "EMI" {
-		t.Fatalf("unexpected label: %q", result["label"])
-	}
-	if result["copyright"] != "(C) Queen" {
-		t.Fatalf("unexpected copyright: %q", result["copyright"])
-	}
-}
-
-func TestBuildDeezerISRCSearchResultAddsCompatibilityIDs(t *testing.T) {
-	result := buildDeezerISRCSearchResult(&TrackMetadata{
-		SpotifyID:   "deezer:3135556",
-		Name:        "Love Of My Life",
-		Artists:     "Queen",
-		AlbumName:   "A Night at the Opera",
-		ISRC:        "GBUM71029604",
-		ReleaseDate: "1975-11-21",
-	})
-
-	if result["spotify_id"] != "deezer:3135556" {
-		t.Fatalf("unexpected spotify_id: %v", result["spotify_id"])
-	}
-	if result["id"] != "3135556" {
-		t.Fatalf("unexpected id: %v", result["id"])
-	}
-	if result["track_id"] != "3135556" {
-		t.Fatalf("unexpected track_id: %v", result["track_id"])
-	}
-	if result["success"] != true {
-		t.Fatalf("expected success=true, got %v", result["success"])
-	}
-}
@@ -1,270 +0,0 @@
-package gobackend
-
-import "testing"
-
-func TestBuildDownloadSuccessResponsePrefersRequestedAlbumMetadata(t *testing.T) {
-	req := DownloadRequest{
-		TrackName:   "Bonus Track",
-		ArtistName:  "Artist",
-		AlbumName:   "Album (Deluxe)",
-		AlbumArtist: "Artist",
-		ReleaseDate: "2024-01-01",
-		TrackNumber: 14,
-		DiscNumber:  1,
-		ISRC:        "REQ123",
-		CoverURL:    "https://example.com/cover.jpg",
-		Genre:       "Pop",
-		Label:       "Label",
-		Copyright:   "Copyright",
-	}
-
-	result := DownloadResult{
-		Title:       "Bonus Track",
-		Artist:      "Artist",
-		Album:       "Album",
-		ReleaseDate: "2023-12-01",
-		TrackNumber: 2,
-		DiscNumber:  9,
-		ISRC:        "RES456",
-	}
-
-	resp := buildDownloadSuccessResponse(
-		req,
-		result,
-		"tidal",
-		"ok",
-		"/tmp/test.flac",
-		false,
-	)
-
-	if resp.Album != req.AlbumName {
-		t.Fatalf("album = %q, want %q", resp.Album, req.AlbumName)
-	}
-	if resp.ReleaseDate != req.ReleaseDate {
-		t.Fatalf("release date = %q, want %q", resp.ReleaseDate, req.ReleaseDate)
-	}
-	if resp.TrackNumber != req.TrackNumber {
-		t.Fatalf("track number = %d, want %d", resp.TrackNumber, req.TrackNumber)
-	}
-	if resp.DiscNumber != req.DiscNumber {
-		t.Fatalf("disc number = %d, want %d", resp.DiscNumber, req.DiscNumber)
-	}
-	if resp.Artist != result.Artist {
-		t.Fatalf("artist = %q, want provider artist %q", resp.Artist, result.Artist)
-	}
-	if resp.ISRC != result.ISRC {
-		t.Fatalf("isrc = %q, want provider isrc %q", resp.ISRC, result.ISRC)
-	}
-}
-
-func TestPreferredReleaseMetadataPrefersRequestValues(t *testing.T) {
-	album, releaseDate, trackNumber, discNumber := preferredReleaseMetadata(
-		DownloadRequest{
-			AlbumName:   "Album (Deluxe Edition)",
-			ReleaseDate: "2024-01-01",
-			TrackNumber: 13,
-			DiscNumber:  2,
-		},
-		"Album",
-		"2023-01-01",
-		3,
-		1,
-	)
-
-	if album != "Album (Deluxe Edition)" {
-		t.Fatalf("album = %q", album)
-	}
-	if releaseDate != "2024-01-01" {
-		t.Fatalf("release date = %q", releaseDate)
-	}
-	if trackNumber != 13 {
-		t.Fatalf("track number = %d", trackNumber)
-	}
-	if discNumber != 2 {
-		t.Fatalf("disc number = %d", discNumber)
-	}
-}
-
-func TestBuildDownloadSuccessResponsePrefersProviderCoverURL(t *testing.T) {
-	req := DownloadRequest{
-		TrackName:   "Track",
-		ArtistName:  "Artist",
-		AlbumName:   "Album",
-		AlbumArtist: "Artist",
-	}
-
-	result := DownloadResult{
-		Title:    "Track",
-		Artist:   "Artist",
-		Album:    "Album",
-		CoverURL: "https://cdn.qobuz.test/cover.jpg",
-	}
-
-	resp := buildDownloadSuccessResponse(
-		req,
-		result,
-		"qobuz",
-		"ok",
-		"/tmp/test.flac",
-		false,
-	)
-
-	if resp.CoverURL != result.CoverURL {
-		t.Fatalf("cover url = %q, want %q", resp.CoverURL, result.CoverURL)
-	}
-}
-
-func TestApplyReEnrichTrackMetadataPreservesExistingReleaseDateWhenCandidateMissing(t *testing.T) {
-	req := reEnrichRequest{
-		SpotifyID:   "spotify-track-id",
-		AlbumName:   "Original Album",
-		ReleaseDate: "2024-01-01",
-		ISRC:        "REQ123",
-	}
-
-	applyReEnrichTrackMetadata(&req, ExtTrackMetadata{
-		AlbumName:   "Resolved Album",
-		ReleaseDate: "",
-		ISRC:        "",
-	})
-
-	if req.ReleaseDate != "2024-01-01" {
-		t.Fatalf("release date = %q, want existing value preserved", req.ReleaseDate)
-	}
-	if req.AlbumName != "Resolved Album" {
-		t.Fatalf("album = %q, want updated album", req.AlbumName)
-	}
-	if req.ISRC != "REQ123" {
-		t.Fatalf("isrc = %q, want existing value preserved", req.ISRC)
-	}
-}
-
-func TestSelectBestReEnrichTrackPrefersCandidateWithReleaseDate(t *testing.T) {
-	req := reEnrichRequest{
-		TrackName:   "Song Title",
-		ArtistName:  "Artist Name",
-		AlbumName:   "Album Name",
-		ReleaseDate: "",
-		DurationMs:  180000,
-	}
-
-	tracks := []ExtTrackMetadata{
-		{
-			ID:          "first",
-			Name:        "Song Title",
-			Artists:     "Artist Name",
-			AlbumName:   "Album Name",
-			DurationMS:  180000,
-			ReleaseDate: "",
-			ProviderID:  "spotify",
-		},
-		{
-			ID:          "second",
-			Name:        "Song Title",
-			Artists:     "Artist Name",
-			AlbumName:   "Album Name",
-			DurationMS:  180000,
-			ReleaseDate: "2024-03-09",
-			ProviderID:  "deezer",
-		},
-	}
-
-	best := selectBestReEnrichTrack(req, tracks)
-	if best == nil {
-		t.Fatal("expected a selected track")
-	}
-	if best.ID != "second" {
-		t.Fatalf("selected track = %q, want candidate with release date", best.ID)
-	}
-}
-
-func TestBuildReEnrichFFmpegMetadataOmitsEmptyFields(t *testing.T) {
-	req := reEnrichRequest{
-		TrackName:   "Song",
-		ArtistName:  "Artist",
-		AlbumName:   "Album",
-		AlbumArtist: "",
-		ReleaseDate: "",
-		TrackNumber: 0,
-		DiscNumber:  0,
-		ISRC:        "",
-		Genre:       "",
-		Label:       "",
-		Copyright:   "",
-	}
-
-	metadata := buildReEnrichFFmpegMetadata(&req, "")
-
-	// Title and Artist are never written by re-enrich (they are search keys
-	// preserved as-is from the file).
-	if _, exists := metadata["TITLE"]; exists {
-		t.Fatalf("TITLE should not be in metadata: %#v", metadata)
-	}
-	if _, exists := metadata["ARTIST"]; exists {
-		t.Fatalf("ARTIST should not be in metadata: %#v", metadata)
-	}
-	if metadata["ALBUM"] != "Album" {
-		t.Fatalf("album = %q", metadata["ALBUM"])
-	}
-
-	for _, key := range []string{
-		"ALBUMARTIST",
-		"DATE",
-		"TRACKNUMBER",
-		"DISCNUMBER",
-		"ISRC",
-		"GENRE",
-		"ORGANIZATION",
-		"COPYRIGHT",
-		"LYRICS",
-		"UNSYNCEDLYRICS",
-	} {
-		if _, exists := metadata[key]; exists {
-			t.Fatalf("did not expect key %s in metadata: %#v", key, metadata)
-		}
-	}
-}
-
-func TestApplyReEnrichTrackMetadataCopiesComposerAndTotals(t *testing.T) {
-	req := reEnrichRequest{}
-
-	applyReEnrichTrackMetadata(&req, ExtTrackMetadata{
-		TrackNumber: 7,
-		TotalTracks: 12,
-		DiscNumber:  2,
-		TotalDiscs:  3,
-		Composer:    "Composer",
-	})
-
-	if req.TrackNumber != 7 || req.TotalTracks != 12 {
-		t.Fatalf("track metadata = %d/%d", req.TrackNumber, req.TotalTracks)
-	}
-	if req.DiscNumber != 2 || req.TotalDiscs != 3 {
-		t.Fatalf("disc metadata = %d/%d", req.DiscNumber, req.TotalDiscs)
-	}
-	if req.Composer != "Composer" {
-		t.Fatalf("composer = %q", req.Composer)
-	}
-}
-
-func TestBuildReEnrichFFmpegMetadataFormatsTotalsAndComposer(t *testing.T) {
-	req := reEnrichRequest{
-		TrackNumber: 7,
-		TotalTracks: 12,
-		DiscNumber:  2,
-		TotalDiscs:  3,
-		Composer:    "Composer",
-	}
-
-	metadata := buildReEnrichFFmpegMetadata(&req, "")
-
-	if metadata["TRACKNUMBER"] != "7/12" {
-		t.Fatalf("TRACKNUMBER = %q", metadata["TRACKNUMBER"])
-	}
-	if metadata["DISCNUMBER"] != "2/3" {
-		t.Fatalf("DISCNUMBER = %q", metadata["DISCNUMBER"])
-	}
-	if metadata["COMPOSER"] != "Composer" {
-		t.Fatalf("COMPOSER = %q", metadata["COMPOSER"])
-	}
-}
@@ -43,101 +43,41 @@ func compareVersions(v1, v2 string) int {
 	return 0
 }

-type loadedExtension struct {
-	ID          string             `json:"id"`
-	Manifest    *ExtensionManifest `json:"manifest"`
-	VM          *goja.Runtime      `json:"-"`
-	VMMu        sync.Mutex         `json:"-"`
-	runtime     *extensionRuntime
-	initialized bool
-	Enabled     bool   `json:"enabled"`
-	Error       string `json:"error,omitempty"`
-	DataDir     string `json:"data_dir"`
-	SourceDir   string `json:"source_dir"`
-	IconPath    string `json:"icon_path"`
+type LoadedExtension struct {
+	ID        string             `json:"id"`
+	Manifest  *ExtensionManifest `json:"manifest"`
+	VM        *goja.Runtime      `json:"-"`
+	VMMu      sync.Mutex         `json:"-"`
+	runtime   *ExtensionRuntime
+	Enabled   bool   `json:"enabled"`
+	Error     string `json:"error,omitempty"`
+	DataDir   string `json:"data_dir"`
+	SourceDir string `json:"source_dir"`
+	IconPath  string `json:"icon_path"`
 }

-func getExtensionInitSettings(extensionID string) map[string]interface{} {
-	settings := GetExtensionSettingsStore().GetAll(extensionID)
-	if len(settings) == 0 {
-		return settings
-	}
-
-	filtered := make(map[string]interface{}, len(settings))
-	for key, value := range settings {
-		if strings.HasPrefix(key, "_") {
-			continue
-		}
-		filtered[key] = value
-	}
-	return filtered
-}
-
-func ensureRuntimeReadyLocked(ext *loadedExtension, applyStoredSettings bool) error {
-	if ext.VM == nil || ext.runtime == nil {
-		if err := initializeVMLocked(ext); err != nil {
-			ext.Error = err.Error()
-			ext.Enabled = false
-			return err
-		}
-	}
-
-	if applyStoredSettings && !ext.initialized {
-		settings := getExtensionInitSettings(ext.ID)
-		if len(settings) > 0 {
-			if err := initializeExtensionWithSettingsLocked(ext, settings); err != nil {
-				teardownVMLocked(ext)
-				ext.Error = err.Error()
-				ext.Enabled = false
-				return err
-			}
-		} else {
-			ext.initialized = true
-		}
-	}
-
-	ext.Error = ""
-	return nil
-}
-
-func (ext *loadedExtension) ensureRuntimeReady() error {
-	ext.VMMu.Lock()
-	defer ext.VMMu.Unlock()
-
-	return ensureRuntimeReadyLocked(ext, true)
-}
-
-func (ext *loadedExtension) lockReadyVM() (*goja.Runtime, error) {
-	ext.VMMu.Lock()
-	if err := ensureRuntimeReadyLocked(ext, true); err != nil {
-		ext.VMMu.Unlock()
-		return nil, err
-	}
-	return ext.VM, nil
-}
-
-type extensionManager struct {
+type ExtensionManager struct {
 	mu            sync.RWMutex
-	extensions    map[string]*loadedExtension
+	extensions    map[string]*LoadedExtension
 	extensionsDir string
 	dataDir       string
 }

 var (
-	globalExtManager     *extensionManager
+	globalExtManager     *ExtensionManager
 	globalExtManagerOnce sync.Once
 )

-func getExtensionManager() *extensionManager {
+func GetExtensionManager() *ExtensionManager {
 	globalExtManagerOnce.Do(func() {
-		globalExtManager = &extensionManager{
-			extensions: make(map[string]*loadedExtension),
+		globalExtManager = &ExtensionManager{
+			extensions: make(map[string]*LoadedExtension),
 		}
 	})
 	return globalExtManager
 }

-func (m *extensionManager) SetDirectories(extensionsDir, dataDir string) error {
+func (m *ExtensionManager) SetDirectories(extensionsDir, dataDir string) error {
 	m.mu.Lock()
 	defer m.mu.Unlock()

@@ -154,7 +94,7 @@ func (m *extensionManager) SetDirectories(extensionsDir, dataDir string) error {
 	return nil
 }

-func (m *extensionManager) LoadExtensionFromFile(filePath string) (*loadedExtension, error) {
+func (m *ExtensionManager) LoadExtensionFromFile(filePath string) (*LoadedExtension, error) {
 	if !strings.HasSuffix(strings.ToLower(filePath), ".spotiflac-ext") {
 		return nil, fmt.Errorf("Invalid file format. Please select a .spotiflac-ext file")
 	}
@@ -211,6 +151,7 @@ func (m *extensionManager) LoadExtensionFromFile(filePath string) (*loadedExtens
 	if exists {
 		versionCompare := compareVersions(manifest.Version, existingVersion)
 		if versionCompare > 0 {
+			// This is an upgrade - call UpgradeExtension
 			return m.UpgradeExtension(filePath)
 		} else if versionCompare == 0 {
 			return nil, fmt.Errorf("Extension '%s' v%s is already installed", existingDisplayName, existingVersion)
@@ -272,7 +213,7 @@ func (m *extensionManager) LoadExtensionFromFile(filePath string) (*loadedExtens
 		return nil, fmt.Errorf("failed to create extension data directory: %w", err)
 	}

-	ext := &loadedExtension{
+	ext := &LoadedExtension{
 		ID:        manifest.Name,
 		Manifest:  manifest,
 		Enabled:   false, // New extensions start disabled
@@ -280,10 +221,10 @@ func (m *extensionManager) LoadExtensionFromFile(filePath string) (*loadedExtens
 		SourceDir: extDir,
 	}

-	if err := validateExtensionLoad(ext); err != nil {
+	if err := m.initializeVM(ext); err != nil {
 		ext.Error = err.Error()
 		ext.Enabled = false
-		GoLog("[Extension] Failed to validate extension %s: %v\n", manifest.Name, err)
+		GoLog("[Extension] Failed to initialize VM for %s: %v\n", manifest.Name, err)
 	}

 	m.extensions[manifest.Name] = ext
@@ -292,10 +233,7 @@ func (m *extensionManager) LoadExtensionFromFile(filePath string) (*loadedExtens
 	return ext, nil
 }

-func initializeVMLocked(ext *loadedExtension) error {
-	ext.VM = nil
-	ext.runtime = nil
-	ext.initialized = false
+func (m *ExtensionManager) initializeVM(ext *LoadedExtension) error {
 	vm := goja.New()
 	ext.VM = vm

@@ -305,7 +243,7 @@ func initializeVMLocked(ext *loadedExtension) error {
 		return fmt.Errorf("failed to read index.js: %w", err)
 	}

-	runtime := newExtensionRuntime(ext)
+	runtime := NewExtensionRuntime(ext)
 	ext.runtime = runtime
 	runtime.RegisterAPIs(vm)
 	runtime.RegisterGoBackendAPIs(vm)
@@ -342,137 +280,7 @@ func initializeVMLocked(ext *loadedExtension) error {
 	return nil
 }

-func (m *extensionManager) initializeVM(ext *loadedExtension) error {
-	ext.VMMu.Lock()
-	defer ext.VMMu.Unlock()
-	return initializeVMLocked(ext)
-}
-
-func initializeExtensionWithSettingsLocked(
-	ext *loadedExtension,
-	settings map[string]interface{},
-) error {
-	if ext.VM == nil {
-		return fmt.Errorf("Extension failed to load. Please reinstall the extension")
-	}
-
-	settingsJSON, err := json.Marshal(settings)
-	if err != nil {
-		return fmt.Errorf("Failed to save settings")
-	}
-
-	script := fmt.Sprintf(`
-		(function() {
-			var settings = %s;
-			if (typeof extension !== 'undefined' && typeof extension.initialize === 'function') {
-				try {
-					extension.initialize(settings);
-					return { success: true };
-				} catch (e) {
-					return { success: false, error: e.toString() };
-				}
-			}
-			return { success: true, message: 'no initialize function' };
-		})()
-	`, string(settingsJSON))
-
-	result, err := ext.VM.RunString(script)
-	if err != nil {
-		ext.Error = fmt.Sprintf("initialize failed: %v", err)
-		ext.Enabled = false
-		GoLog("[Extension] Initialize error for %s: %v\n", ext.ID, err)
-		return err
-	}
-
-	if result != nil && !goja.IsUndefined(result) {
-		exported := result.Export()
-		if resultMap, ok := exported.(map[string]interface{}); ok {
-			if success, ok := resultMap["success"].(bool); ok && !success {
-				errMsg := "unknown error"
-				if e, ok := resultMap["error"].(string); ok {
-					errMsg = e
-				}
-				ext.Error = errMsg
-				ext.Enabled = false
-				GoLog("[Extension] Initialize failed for %s: %s\n", ext.ID, errMsg)
-				return fmt.Errorf("initialize failed: %s", errMsg)
-			}
-		}
-	}
-
-	ext.initialized = true
-	GoLog("[Extension] Initialized %s\n", ext.ID)
-	return nil
-}
-
-func runCleanupLocked(ext *loadedExtension) error {
-	if ext.VM != nil {
-		script := `
-			(function() {
-				if (typeof extension !== 'undefined' && typeof extension.cleanup === 'function') {
-					try {
-						extension.cleanup();
-						return { success: true };
-					} catch (e) {
-						return { success: false, error: e.toString() };
-					}
-				}
-				return { success: true, message: 'no cleanup function' };
-			})()
-		`
-
-		result, err := ext.VM.RunString(script)
-		if err != nil {
-			return err
-		}
-
-		if result != nil && !goja.IsUndefined(result) {
-			exported := result.Export()
-			if resultMap, ok := exported.(map[string]interface{}); ok {
-				if success, ok := resultMap["success"].(bool); ok && !success {
-					errMsg := "unknown error"
-					if e, ok := resultMap["error"].(string); ok {
-						errMsg = e
-					}
-					return fmt.Errorf("cleanup failed: %s", errMsg)
-				}
-			}
-		}
-
-		if result != nil && !goja.IsUndefined(result) && !goja.IsNull(result) {
-			GoLog("[Extension] Cleanup called for %s\n", ext.ID)
-		}
-	}
-	return nil
-}
-
-func teardownVMLocked(ext *loadedExtension) {
-	if err := runCleanupLocked(ext); err != nil {
-		GoLog("[Extension] Error calling cleanup for %s: %v\n", ext.ID, err)
-	}
-	if ext.runtime != nil {
-		if err := ext.runtime.flushStorageNow(); err != nil {
-			GoLog("[Extension] Failed to flush storage for %s: %v\n", ext.ID, err)
-		}
-		ext.runtime.closeStorageFlusher()
-	}
-	ext.runtime = nil
-	ext.VM = nil
-	ext.initialized = false
-}
-
-func validateExtensionLoad(ext *loadedExtension) error {
-	ext.VMMu.Lock()
-	defer ext.VMMu.Unlock()
-
-	if err := initializeVMLocked(ext); err != nil {
-		return err
-	}
-	teardownVMLocked(ext)
-	return nil
-}
-
-func (m *extensionManager) UnloadExtension(extensionID string) error {
+func (m *ExtensionManager) UnloadExtension(extensionID string) error {
 	m.mu.Lock()
 	defer m.mu.Unlock()

@@ -481,9 +289,21 @@ func (m *extensionManager) UnloadExtension(extensionID string) error {
 		return fmt.Errorf("Extension not found")
 	}

-	ext.VMMu.Lock()
-	teardownVMLocked(ext)
-	ext.VMMu.Unlock()
+	if ext.VM != nil {
+		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)
+		} else if cleanup != nil && !goja.IsUndefined(cleanup) && !goja.IsNull(cleanup) {
+			GoLog("[Extension] Cleanup called for %s\n", extensionID)
+		}
+	}
+	if ext.runtime != nil {
+		if err := ext.runtime.flushStorageNow(); err != nil {
+			GoLog("[Extension] Failed to flush storage for %s: %v\n", extensionID, err)
+		}
+		ext.runtime.closeStorageFlusher()
+		ext.runtime = nil
+	}

 	delete(m.extensions, extensionID)
 	GoLog("[Extension] Unloaded extension: %s\n", extensionID)
@@ -491,7 +311,7 @@ func (m *extensionManager) UnloadExtension(extensionID string) error {
 	return nil
 }

-func (m *extensionManager) GetExtension(extensionID string) (*loadedExtension, error) {
+func (m *ExtensionManager) GetExtension(extensionID string) (*LoadedExtension, error) {
 	m.mu.RLock()
 	defer m.mu.RUnlock()

@@ -502,18 +322,18 @@ func (m *extensionManager) GetExtension(extensionID string) (*loadedExtension, e
 	return ext, nil
 }

-func (m *extensionManager) GetAllExtensions() []*loadedExtension {
+func (m *ExtensionManager) GetAllExtensions() []*LoadedExtension {
 	m.mu.RLock()
 	defer m.mu.RUnlock()

-	result := make([]*loadedExtension, 0, len(m.extensions))
+	result := make([]*LoadedExtension, 0, len(m.extensions))
 	for _, ext := range m.extensions {
 		result = append(result, ext)
 	}
 	return result
 }

-func (m *extensionManager) SetExtensionEnabled(extensionID string, enabled bool) error {
+func (m *ExtensionManager) SetExtensionEnabled(extensionID string, enabled bool) error {
 	m.mu.Lock()
 	defer m.mu.Unlock()

@@ -522,21 +342,7 @@ func (m *extensionManager) SetExtensionEnabled(extensionID string, enabled bool)
 		return fmt.Errorf("Extension not found")
 	}

-	if enabled {
-		ext.Enabled = true
-		if err := ext.ensureRuntimeReady(); err != nil {
-			store := GetExtensionSettingsStore()
-			ext.Enabled = false
-			_ = store.Set(extensionID, "_enabled", false)
-			return err
-		}
-	} else {
-		ext.Enabled = false
-		ext.Error = ""
-		ext.VMMu.Lock()
-		teardownVMLocked(ext)
-		ext.VMMu.Unlock()
-	}
+	ext.Enabled = enabled
 	GoLog("[Extension] %s %s\n", extensionID, map[bool]string{true: "enabled", false: "disabled"}[enabled])

 	store := GetExtensionSettingsStore()
@@ -547,7 +353,7 @@ func (m *extensionManager) SetExtensionEnabled(extensionID string, enabled bool)
 	return nil
 }

-func (m *extensionManager) LoadExtensionsFromDirectory(dirPath string) ([]string, []error) {
+func (m *ExtensionManager) LoadExtensionsFromDirectory(dirPath string) ([]string, []error) {
 	var loaded []string
 	var errors []error

@@ -585,7 +391,7 @@ func (m *extensionManager) LoadExtensionsFromDirectory(dirPath string) ([]string
 	return loaded, errors
 }

-func (m *extensionManager) loadExtensionFromDirectory(dirPath string) (*loadedExtension, error) {
+func (m *ExtensionManager) loadExtensionFromDirectory(dirPath string) (*LoadedExtension, error) {
 	m.mu.Lock()
 	defer m.mu.Unlock()

@@ -615,7 +421,7 @@ func (m *extensionManager) loadExtensionFromDirectory(dirPath string) (*loadedEx
 		return nil, fmt.Errorf("failed to create extension data directory: %w", err)
 	}

-	ext := &loadedExtension{
+	ext := &LoadedExtension{
 		ID:        manifest.Name,
 		Manifest:  manifest,
 		Enabled:   false, // Will be restored from settings store
@@ -623,6 +429,7 @@ func (m *extensionManager) loadExtensionFromDirectory(dirPath string) (*loadedEx
 		SourceDir: dirPath,
 	}

+	// Restore enabled state from settings store
 	store := GetExtensionSettingsStore()
 	if enabledVal, err := store.Get(manifest.Name, "_enabled"); err == nil {
 		if enabled, ok := enabledVal.(bool); ok {
@@ -631,10 +438,10 @@ func (m *extensionManager) loadExtensionFromDirectory(dirPath string) (*loadedEx
 		}
 	}

-	if err := validateExtensionLoad(ext); err != nil {
+	if err := m.initializeVM(ext); err != nil {
 		ext.Error = err.Error()
 		ext.Enabled = false
-		GoLog("[Extension] Failed to validate extension %s: %v\n", manifest.Name, err)
+		GoLog("[Extension] Failed to initialize VM for %s: %v\n", manifest.Name, err)
 	}

 	m.extensions[manifest.Name] = ext
@@ -643,7 +450,7 @@ func (m *extensionManager) loadExtensionFromDirectory(dirPath string) (*loadedEx
 	return ext, nil
 }

-func (m *extensionManager) RemoveExtension(extensionID string) error {
+func (m *ExtensionManager) RemoveExtension(extensionID string) error {
 	ext, err := m.GetExtension(extensionID)
 	if err != nil {
 		return err
@@ -663,7 +470,7 @@ func (m *extensionManager) RemoveExtension(extensionID string) error {
 }

 // Only allows upgrades (new version > current version), not downgrades
-func (m *extensionManager) UpgradeExtension(filePath string) (*loadedExtension, error) {
+func (m *ExtensionManager) UpgradeExtension(filePath string) (*LoadedExtension, error) {
 	if !strings.HasSuffix(strings.ToLower(filePath), ".spotiflac-ext") {
 		return nil, fmt.Errorf("Invalid file format. Please select a .spotiflac-ext file")
 	}
@@ -777,7 +584,7 @@ func (m *extensionManager) UpgradeExtension(filePath string) (*loadedExtension,
 		}
 	}

-	ext := &loadedExtension{
+	ext := &LoadedExtension{
 		ID:        newManifest.Name,
 		Manifest:  newManifest,
 		Enabled:   wasEnabled, // Preserve enabled state from before upgrade
@@ -785,14 +592,10 @@ func (m *extensionManager) UpgradeExtension(filePath string) (*loadedExtension,
 		SourceDir: extDir,
 	}

-	if wasEnabled {
-		if err := ext.ensureRuntimeReady(); err != nil {
-			GoLog("[Extension] Failed to initialize upgraded extension %s: %v\n", newManifest.Name, err)
-		}
-	} else if err := validateExtensionLoad(ext); err != nil {
+	if err := m.initializeVM(ext); err != nil {
 		ext.Error = err.Error()
 		ext.Enabled = false
-		GoLog("[Extension] Failed to validate upgraded extension %s: %v\n", newManifest.Name, err)
+		GoLog("[Extension] Failed to initialize VM for %s: %v\n", newManifest.Name, err)
 	}

 	m.mu.Lock()
@@ -812,7 +615,7 @@ type ExtensionUpgradeInfo struct {
 	IsInstalled    bool   `json:"is_installed"`
 }

-func (m *extensionManager) checkExtensionUpgradeInternal(filePath string) (*ExtensionUpgradeInfo, error) {
+func (m *ExtensionManager) checkExtensionUpgradeInternal(filePath string) (*ExtensionUpgradeInfo, error) {
 	if !strings.HasSuffix(strings.ToLower(filePath), ".spotiflac-ext") {
 		return nil, fmt.Errorf("Invalid file format. Please select a .spotiflac-ext file")
 	}
@@ -871,7 +674,7 @@ func (m *extensionManager) checkExtensionUpgradeInternal(filePath string) (*Exte
 	return info, nil
 }

-func (m *extensionManager) CheckExtensionUpgradeJSON(filePath string) (string, error) {
+func (m *ExtensionManager) CheckExtensionUpgradeJSON(filePath string) (string, error) {
 	info, err := m.checkExtensionUpgradeInternal(filePath)
 	if err != nil {
 		return "", err
@@ -885,7 +688,7 @@ func (m *extensionManager) CheckExtensionUpgradeJSON(filePath string) (string, e
 	return string(jsonBytes), nil
 }

-func (m *extensionManager) GetInstalledExtensionsJSON() (string, error) {
+func (m *ExtensionManager) GetInstalledExtensionsJSON() (string, error) {
 	extensions := m.GetAllExtensions()

 	type ExtensionInfo struct {
@@ -908,7 +711,6 @@ func (m *extensionManager) GetInstalledExtensionsJSON() (string, error) {
 		HasDownloadProvider    bool                   `json:"has_download_provider"`
 		HasLyricsProvider      bool                   `json:"has_lyrics_provider"`
 		SkipMetadataEnrichment bool                   `json:"skip_metadata_enrichment"`
-		SkipLyrics             bool                   `json:"skip_lyrics"`
 		SearchBehavior         *SearchBehaviorConfig  `json:"search_behavior,omitempty"`
 		TrackMatching          *TrackMatchingConfig   `json:"track_matching,omitempty"`
 		PostProcessing         *PostProcessingConfig  `json:"post_processing,omitempty"`
@@ -966,7 +768,6 @@ func (m *extensionManager) GetInstalledExtensionsJSON() (string, error) {
 			HasDownloadProvider:    ext.Manifest.IsDownloadProvider(),
 			HasLyricsProvider:      ext.Manifest.IsLyricsProvider(),
 			SkipMetadataEnrichment: ext.Manifest.SkipMetadataEnrichment,
-			SkipLyrics:             ext.Manifest.SkipLyrics,
 			SearchBehavior:         ext.Manifest.SearchBehavior,
 			TrackMatching:          ext.Manifest.TrackMatching,
 			PostProcessing:         ext.Manifest.PostProcessing,
@@ -982,7 +783,7 @@ func (m *extensionManager) GetInstalledExtensionsJSON() (string, error) {
 	return string(jsonBytes), nil
 }

-func (m *extensionManager) InitializeExtension(extensionID string, settings map[string]interface{}) error {
+func (m *ExtensionManager) InitializeExtension(extensionID string, settings map[string]interface{}) error {
 	m.mu.Lock()
 	defer m.mu.Unlock()

@@ -991,16 +792,59 @@ func (m *extensionManager) InitializeExtension(extensionID string, settings map[
 		return fmt.Errorf("Extension not found")
 	}

-	ext.VMMu.Lock()
-	defer ext.VMMu.Unlock()
+	if ext.VM == nil {
+		return fmt.Errorf("Extension failed to load. Please reinstall the extension")
+	}

-	if err := ensureRuntimeReadyLocked(ext, false); err != nil {
+	settingsJSON, err := json.Marshal(settings)
+	if err != nil {
+		return fmt.Errorf("Failed to save settings")
+	}
+
+	script := fmt.Sprintf(`
+		(function() {
+			var settings = %s;
+			if (typeof extension !== 'undefined' && typeof extension.initialize === 'function') {
+				try {
+					extension.initialize(settings);
+					return { success: true };
+				} catch (e) {
+					return { success: false, error: e.toString() };
+				}
+			}
+			return { success: true, message: 'no initialize function' };
+		})()
+	`, string(settingsJSON))
+
+	result, err := ext.VM.RunString(script)
+	if err != nil {
+		ext.Error = fmt.Sprintf("initialize failed: %v", err)
+		ext.Enabled = false
+		GoLog("[Extension] Initialize error for %s: %v\n", extensionID, err)
 		return err
 	}
-	return initializeExtensionWithSettingsLocked(ext, settings)
+
+	if result != nil && !goja.IsUndefined(result) {
+		exported := result.Export()
+		if resultMap, ok := exported.(map[string]interface{}); ok {
+			if success, ok := resultMap["success"].(bool); ok && !success {
+				errMsg := "unknown error"
+				if e, ok := resultMap["error"].(string); ok {
+					errMsg = e
+				}
+				ext.Error = errMsg
+				ext.Enabled = false
+				GoLog("[Extension] Initialize failed for %s: %s\n", extensionID, errMsg)
+				return fmt.Errorf("initialize failed: %s", errMsg)
+			}
+		}
+	}
+
+	GoLog("[Extension] Initialized %s\n", extensionID)
+	return nil
 }

-func (m *extensionManager) CleanupExtension(extensionID string) error {
+func (m *ExtensionManager) CleanupExtension(extensionID string) error {
 	m.mu.Lock()
 	defer m.mu.Unlock()

@@ -1012,17 +856,46 @@ func (m *extensionManager) CleanupExtension(extensionID string) error {
 	if ext.VM == nil {
 		return nil
 	}
-	ext.VMMu.Lock()
-	defer ext.VMMu.Unlock()
-	if err := runCleanupLocked(ext); err != nil {
+
+	script := `
+		(function() {
+			if (typeof extension !== 'undefined' && typeof extension.cleanup === 'function') {
+				try {
+					extension.cleanup();
+					return { success: true };
+				} catch (e) {
+					return { success: false, error: e.toString() };
+				}
+			}
+			return { success: true, message: 'no cleanup function' };
+		})()
+	`
+
+	result, err := ext.VM.RunString(script)
+	if err != nil {
 		GoLog("[Extension] Cleanup error for %s: %v\n", extensionID, err)
 		return err
 	}
+
+	if result != nil && !goja.IsUndefined(result) {
+		exported := result.Export()
+		if resultMap, ok := exported.(map[string]interface{}); ok {
+			if success, ok := resultMap["success"].(bool); ok && !success {
+				errMsg := "unknown error"
+				if e, ok := resultMap["error"].(string); ok {
+					errMsg = e
+				}
+				GoLog("[Extension] Cleanup failed for %s: %s\n", extensionID, errMsg)
+				return fmt.Errorf("cleanup failed: %s", errMsg)
+			}
+		}
+	}
+
 	GoLog("[Extension] Cleaned up %s\n", extensionID)
 	return nil
 }

-func (m *extensionManager) UnloadAllExtensions() {
+func (m *ExtensionManager) UnloadAllExtensions() {
 	m.mu.Lock()
 	extensionIDs := make([]string, 0, len(m.extensions))
 	for id := range m.extensions {
@@ -1037,7 +910,7 @@ func (m *extensionManager) UnloadAllExtensions() {
 	GoLog("[Extension] All extensions unloaded\n")
 }

-func (m *extensionManager) InvokeAction(extensionID string, actionName string) (map[string]interface{}, error) {
+func (m *ExtensionManager) InvokeAction(extensionID string, actionName string) (map[string]interface{}, error) {
 	m.mu.Lock()
 	defer m.mu.Unlock()

@@ -1046,14 +919,13 @@ func (m *extensionManager) InvokeAction(extensionID string, actionName string) (
 		return nil, fmt.Errorf("extension not found: %s", extensionID)
 	}

+	if ext.VM == nil {
+		return nil, fmt.Errorf("extension VM not initialized")
+	}
+
 	if !ext.Enabled {
 		return nil, fmt.Errorf("extension is disabled")
 	}
-	vm, err := ext.lockReadyVM()
-	if err != nil {
-		return nil, err
-	}
-	defer ext.VMMu.Unlock()

 	script := fmt.Sprintf(`
 		(function() {
@@ -1073,7 +945,7 @@ func (m *extensionManager) InvokeAction(extensionID string, actionName string) (
 		})()
 	`, actionName, actionName, actionName)

-	result, err := RunWithTimeoutAndRecover(vm, script, DefaultJSTimeout)
+	result, err := RunWithTimeoutAndRecover(ext.VM, script, DefaultJSTimeout)
 	if err != nil {
 		GoLog("[Extension] InvokeAction error for %s.%s: %v\n", extensionID, actionName, err)
 		return nil, fmt.Errorf("action failed: %v", err)
@@ -115,7 +115,6 @@ type ExtensionManifest struct {
 	QualityOptions         []QualityOption        `json:"qualityOptions,omitempty"`
 	MinAppVersion          string                 `json:"minAppVersion,omitempty"`
 	SkipMetadataEnrichment bool                   `json:"skipMetadataEnrichment,omitempty"`
-	SkipLyrics             bool                   `json:"skipLyrics,omitempty"`
 	SkipBuiltInFallback    bool                   `json:"skipBuiltInFallback,omitempty"`
 	SearchBehavior         *SearchBehaviorConfig  `json:"searchBehavior,omitempty"`
 	URLHandler             *URLHandlerConfig      `json:"urlHandler,omitempty"`
@@ -1,68 +0,0 @@
-package gobackend
-
-import "testing"
-
-func TestSetMetadataProviderPriorityAddsBuiltIns(t *testing.T) {
-	original := GetMetadataProviderPriority()
-	defer SetMetadataProviderPriority(original)
-
-	SetMetadataProviderPriority([]string{"tidal"})
-	got := GetMetadataProviderPriority()
-	want := []string{"tidal", "deezer", "qobuz"}
-	if len(got) != len(want) {
-		t.Fatalf("unexpected priority length: got %v want %v", got, want)
-	}
-	for i := range want {
-		if got[i] != want[i] {
-			t.Fatalf("unexpected priority at %d: got %v want %v", i, got, want)
-		}
-	}
-}
-
-func TestSearchTracksWithMetadataProvidersUsesPriorityAndDedupes(t *testing.T) {
-	originalPriority := GetMetadataProviderPriority()
-	originalSearch := searchBuiltInMetadataTracksFunc
-	defer func() {
-		SetMetadataProviderPriority(originalPriority)
-		searchBuiltInMetadataTracksFunc = originalSearch
-	}()
-
-	SetMetadataProviderPriority([]string{"qobuz", "tidal", "deezer"})
-
-	var calls []string
-	searchBuiltInMetadataTracksFunc = func(providerID, query string, limit int) ([]ExtTrackMetadata, error) {
-		calls = append(calls, providerID)
-		switch providerID {
-		case "qobuz":
-			return []ExtTrackMetadata{
-				{ProviderID: "qobuz", SpotifyID: "qobuz:1", ISRC: "AAA111", Name: "First"},
-			}, nil
-		case "tidal":
-			return []ExtTrackMetadata{
-				{ProviderID: "tidal", SpotifyID: "tidal:2", ISRC: "AAA111", Name: "Duplicate"},
-				{ProviderID: "tidal", SpotifyID: "tidal:3", ISRC: "BBB222", Name: "Second"},
-			}, nil
-		case "deezer":
-			return []ExtTrackMetadata{
-				{ProviderID: "deezer", SpotifyID: "deezer:4", ISRC: "CCC333", Name: "Third"},
-			}, nil
-		default:
-			return nil, nil
-		}
-	}
-
-	manager := getExtensionManager()
-	tracks, err := manager.SearchTracksWithMetadataProviders("query", 3, false)
-	if err != nil {
-		t.Fatalf("SearchTracksWithMetadataProviders returned error: %v", err)
-	}
-	if len(tracks) != 3 {
-		t.Fatalf("unexpected track count: got %d want 3", len(tracks))
-	}
-	if tracks[0].ProviderID != "qobuz" || tracks[1].ProviderID != "tidal" || tracks[2].ProviderID != "deezer" {
-		t.Fatalf("unexpected track provider order: %+v", tracks)
-	}
-	if len(calls) != 3 || calls[0] != "qobuz" || calls[1] != "tidal" || calls[2] != "deezer" {
-		t.Fatalf("unexpected provider call order: %v", calls)
-	}
-}
@@ -80,18 +80,14 @@ func SetExtensionTokens(extensionID string, accessToken, refreshToken string, ex
 	state.IsAuthenticated = accessToken != ""
 }

-type extensionRuntime struct {
-	extensionID    string
-	manifest       *ExtensionManifest
-	settings       map[string]interface{}
-	httpClient     *http.Client
-	downloadClient *http.Client
-	cookieJar      http.CookieJar
-	dataDir        string
-	vm             *goja.Runtime
-
-	activeDownloadMu     sync.RWMutex
-	activeDownloadItemID string
+type ExtensionRuntime struct {
+	extensionID string
+	manifest    *ExtensionManifest
+	settings    map[string]interface{}
+	httpClient  *http.Client
+	cookieJar   http.CookieJar
+	dataDir     string
+	vm          *goja.Runtime

 	storageMu      sync.RWMutex
 	storageCache   map[string]interface{}
@@ -123,10 +119,10 @@ var (
 	privateIPCacheMu sync.RWMutex
 )

-func newExtensionRuntime(ext *loadedExtension) *extensionRuntime {
+func NewExtensionRuntime(ext *LoadedExtension) *ExtensionRuntime {
 	jar, _ := newSimpleCookieJar()

-	runtime := &extensionRuntime{
+	runtime := &ExtensionRuntime{
 		extensionID:       ext.ID,
 		manifest:          ext.Manifest,
 		settings:          make(map[string]interface{}),
@@ -136,38 +132,13 @@ func newExtensionRuntime(ext *loadedExtension) *extensionRuntime {
 		storageFlushDelay: defaultStorageFlushDelay,
 	}

-	runtime.httpClient = newExtensionHTTPClient(ext, jar, 30*time.Second)
-	runtime.downloadClient = newExtensionHTTPClient(ext, jar, DownloadTimeout)
-
-	return runtime
-}
-
-func (r *extensionRuntime) setActiveDownloadItemID(itemID string) {
-	r.activeDownloadMu.Lock()
-	defer r.activeDownloadMu.Unlock()
-	r.activeDownloadItemID = strings.TrimSpace(itemID)
-}
-
-func (r *extensionRuntime) clearActiveDownloadItemID() {
-	r.activeDownloadMu.Lock()
-	defer r.activeDownloadMu.Unlock()
-	r.activeDownloadItemID = ""
-}
-
-func (r *extensionRuntime) getActiveDownloadItemID() string {
-	r.activeDownloadMu.RLock()
-	defer r.activeDownloadMu.RUnlock()
-	return r.activeDownloadItemID
-}
-
-func newExtensionHTTPClient(ext *loadedExtension, jar http.CookieJar, timeout time.Duration) *http.Client {
 	// Extension sandbox enforces HTTPS-only domains. Do not apply global
 	// allow_http scheme downgrade here, because some extension APIs (e.g.
 	// spotify-web) will redirect http -> https and can end up in 301 loops.
 	// We still reuse sharedTransport so insecure TLS compatibility mode remains effective.
 	client := &http.Client{
 		Transport: sharedTransport,
-		Timeout:   timeout,
+		Timeout:   30 * time.Second,
 		Jar:       jar,
 	}
 	client.CheckRedirect = func(req *http.Request, via []*http.Request) error {
@@ -194,7 +165,9 @@ func newExtensionHTTPClient(ext *loadedExtension, jar http.CookieJar, timeout ti
 		}
 		return nil
 	}
-	return client
+	runtime.httpClient = client
+
+	return runtime
 }

 type RedirectBlockedError struct {
@@ -329,11 +302,11 @@ func (j *simpleCookieJar) Cookies(u *url.URL) []*http.Cookie {
 	return j.cookies[u.Host]
 }

-func (r *extensionRuntime) SetSettings(settings map[string]interface{}) {
+func (r *ExtensionRuntime) SetSettings(settings map[string]interface{}) {
 	r.settings = settings
 }

-func (r *extensionRuntime) RegisterAPIs(vm *goja.Runtime) {
+func (r *ExtensionRuntime) RegisterAPIs(vm *goja.Runtime) {
 	r.vm = vm

 	httpObj := vm.NewObject()
@@ -52,7 +52,7 @@ func summarizeURLForLog(urlStr string) string {
 	return fmt.Sprintf("%s://%s%s", parsed.Scheme, parsed.Host, parsed.Path)
 }

-func (r *extensionRuntime) authOpenUrl(call goja.FunctionCall) goja.Value {
+func (r *ExtensionRuntime) authOpenUrl(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 1 {
 		return r.vm.ToValue(map[string]interface{}{
 			"success": false,
@@ -99,7 +99,7 @@ func (r *extensionRuntime) authOpenUrl(call goja.FunctionCall) goja.Value {
 	})
 }

-func (r *extensionRuntime) authGetCode(call goja.FunctionCall) goja.Value {
+func (r *ExtensionRuntime) authGetCode(call goja.FunctionCall) goja.Value {
 	extensionAuthStateMu.RLock()
 	defer extensionAuthStateMu.RUnlock()

@@ -111,7 +111,7 @@ func (r *extensionRuntime) authGetCode(call goja.FunctionCall) goja.Value {
 	return r.vm.ToValue(state.AuthCode)
 }

-func (r *extensionRuntime) authSetCode(call goja.FunctionCall) goja.Value {
+func (r *ExtensionRuntime) authSetCode(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 1 {
 		return r.vm.ToValue(false)
 	}
@@ -149,7 +149,7 @@ func (r *extensionRuntime) authSetCode(call goja.FunctionCall) goja.Value {
 	return r.vm.ToValue(true)
 }

-func (r *extensionRuntime) authClear(call goja.FunctionCall) goja.Value {
+func (r *ExtensionRuntime) authClear(call goja.FunctionCall) goja.Value {
 	extensionAuthStateMu.Lock()
 	delete(extensionAuthState, r.extensionID)
 	extensionAuthStateMu.Unlock()
@@ -162,7 +162,7 @@ func (r *extensionRuntime) authClear(call goja.FunctionCall) goja.Value {
 	return r.vm.ToValue(true)
 }

-func (r *extensionRuntime) authIsAuthenticated(call goja.FunctionCall) goja.Value {
+func (r *ExtensionRuntime) authIsAuthenticated(call goja.FunctionCall) goja.Value {
 	extensionAuthStateMu.RLock()
 	defer extensionAuthStateMu.RUnlock()

@@ -178,7 +178,7 @@ func (r *extensionRuntime) authIsAuthenticated(call goja.FunctionCall) goja.Valu
 	return r.vm.ToValue(state.IsAuthenticated)
 }

-func (r *extensionRuntime) authGetTokens(call goja.FunctionCall) goja.Value {
+func (r *ExtensionRuntime) authGetTokens(call goja.FunctionCall) goja.Value {
 	extensionAuthStateMu.RLock()
 	defer extensionAuthStateMu.RUnlock()

@@ -201,6 +201,7 @@ func (r *extensionRuntime) authGetTokens(call goja.FunctionCall) goja.Value {
 	return r.vm.ToValue(result)
 }

+// Length should be between 43-128 characters (RFC 7636)
 func generatePKCEVerifier(length int) (string, error) {
 	if length < 43 {
 		length = 43
@@ -225,10 +226,11 @@ func generatePKCEVerifier(length int) (string, error) {

 func generatePKCEChallenge(verifier string) string {
 	hash := sha256.Sum256([]byte(verifier))
+	// Base64url encode without padding (RFC 7636)
 	return base64.RawURLEncoding.EncodeToString(hash[:])
 }

-func (r *extensionRuntime) authGeneratePKCE(call goja.FunctionCall) goja.Value {
+func (r *ExtensionRuntime) authGeneratePKCE(call goja.FunctionCall) goja.Value {
 	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 {
@@ -265,7 +267,7 @@ func (r *extensionRuntime) authGeneratePKCE(call goja.FunctionCall) goja.Value {
 	})
 }

-func (r *extensionRuntime) authGetPKCE(call goja.FunctionCall) goja.Value {
+func (r *ExtensionRuntime) authGetPKCE(call goja.FunctionCall) goja.Value {
 	extensionAuthStateMu.RLock()
 	defer extensionAuthStateMu.RUnlock()

@@ -281,7 +283,8 @@ func (r *extensionRuntime) authGetPKCE(call goja.FunctionCall) goja.Value {
 	})
 }

-func (r *extensionRuntime) authStartOAuthWithPKCE(call goja.FunctionCall) goja.Value {
+// config: { authUrl, clientId, redirectUri, scope, extraParams }
+func (r *ExtensionRuntime) authStartOAuthWithPKCE(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 1 {
 		return r.vm.ToValue(map[string]interface{}{
 			"success": false,
@@ -385,7 +388,8 @@ func (r *extensionRuntime) authStartOAuthWithPKCE(call goja.FunctionCall) goja.V
 	})
 }

-func (r *extensionRuntime) authExchangeCodeWithPKCE(call goja.FunctionCall) goja.Value {
+// config: { tokenUrl, clientId, redirectUri, code, extraParams }
+func (r *ExtensionRuntime) authExchangeCodeWithPKCE(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 1 {
 		return r.vm.ToValue(map[string]interface{}{
 			"success": false,
@@ -50,7 +50,7 @@ func ClearFFmpegCommand(commandID string) {
 	delete(ffmpegCommands, commandID)
 }

-func (r *extensionRuntime) ffmpegExecute(call goja.FunctionCall) goja.Value {
+func (r *ExtensionRuntime) ffmpegExecute(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 1 {
 		return r.vm.ToValue(map[string]interface{}{
 			"success": false,
@@ -107,7 +107,7 @@ func (r *extensionRuntime) ffmpegExecute(call goja.FunctionCall) goja.Value {
 	}
 }

-func (r *extensionRuntime) ffmpegGetInfo(call goja.FunctionCall) goja.Value {
+func (r *ExtensionRuntime) ffmpegGetInfo(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 1 {
 		return r.vm.ToValue(map[string]interface{}{
 			"success": false,
@@ -134,7 +134,7 @@ func (r *extensionRuntime) ffmpegGetInfo(call goja.FunctionCall) goja.Value {
 	})
 }

-func (r *extensionRuntime) ffmpegConvert(call goja.FunctionCall) goja.Value {
+func (r *ExtensionRuntime) ffmpegConvert(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 2 {
 		return r.vm.ToValue(map[string]interface{}{
 			"success": false,
@@ -71,7 +71,7 @@ func isPathWithinBase(baseDir, targetPath string) bool {
 	return true
 }

-func (r *extensionRuntime) validatePath(path string) (string, error) {
+func (r *ExtensionRuntime) validatePath(path string) (string, error) {
 	if !r.manifest.Permissions.File {
 		return "", fmt.Errorf("file access denied: extension does not have 'file' permission")
 	}
@@ -106,7 +106,7 @@ func (r *extensionRuntime) validatePath(path string) (string, error) {
 	return absPath, nil
 }

-func (r *extensionRuntime) fileDownload(call goja.FunctionCall) goja.Value {
+func (r *ExtensionRuntime) fileDownload(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 2 {
 		return r.vm.ToValue(map[string]interface{}{
 			"success": false,
@@ -174,12 +174,7 @@ func (r *extensionRuntime) fileDownload(call goja.FunctionCall) goja.Value {
 		req.Header.Set("User-Agent", "SpotiFLAC-Extension/1.0")
 	}

-	client := r.downloadClient
-	if client == nil {
-		client = r.httpClient
-	}
-
-	resp, err := client.Do(req)
+	resp, err := r.httpClient.Do(req)
 	if err != nil {
 		return r.vm.ToValue(map[string]interface{}{
 			"success": false,
@@ -205,22 +200,13 @@ func (r *extensionRuntime) fileDownload(call goja.FunctionCall) goja.Value {
 	defer out.Close()

 	contentLength := resp.ContentLength
-	activeItemID := r.getActiveDownloadItemID()
-	if activeItemID != "" && contentLength > 0 {
-		SetItemBytesTotal(activeItemID, contentLength)
-	}
-
-	var progressWriter interface{ Write([]byte) (int, error) } = out
-	if activeItemID != "" {
-		progressWriter = NewItemProgressWriter(out, activeItemID)
-	}

 	var written int64
 	buf := make([]byte, 32*1024)
 	for {
 		nr, er := resp.Body.Read(buf)
 		if nr > 0 {
-			nw, ew := progressWriter.Write(buf[0:nr])
+			nw, ew := out.Write(buf[0:nr])
 			if nw < 0 || nr < nw {
 				nw = 0
 				if ew == nil {
@@ -229,12 +215,6 @@ func (r *extensionRuntime) fileDownload(call goja.FunctionCall) goja.Value {
 			}
 			written += int64(nw)
 			if ew != nil {
-				if ew == ErrDownloadCancelled {
-					return r.vm.ToValue(map[string]interface{}{
-						"success": false,
-						"error":   "download cancelled",
-					})
-				}
 				return r.vm.ToValue(map[string]interface{}{
 					"success": false,
 					"error":   fmt.Sprintf("failed to write file: %v", ew),
@@ -271,7 +251,7 @@ func (r *extensionRuntime) fileDownload(call goja.FunctionCall) goja.Value {
 	})
 }

-func (r *extensionRuntime) fileExists(call goja.FunctionCall) goja.Value {
+func (r *ExtensionRuntime) fileExists(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 1 {
 		return r.vm.ToValue(false)
 	}
@@ -286,7 +266,7 @@ func (r *extensionRuntime) fileExists(call goja.FunctionCall) goja.Value {
 	return r.vm.ToValue(err == nil)
 }

-func (r *extensionRuntime) fileDelete(call goja.FunctionCall) goja.Value {
+func (r *ExtensionRuntime) fileDelete(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 1 {
 		return r.vm.ToValue(map[string]interface{}{
 			"success": false,
@@ -315,7 +295,7 @@ func (r *extensionRuntime) fileDelete(call goja.FunctionCall) goja.Value {
 	})
 }

-func (r *extensionRuntime) fileRead(call goja.FunctionCall) goja.Value {
+func (r *ExtensionRuntime) fileRead(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 1 {
 		return r.vm.ToValue(map[string]interface{}{
 			"success": false,
@@ -346,7 +326,7 @@ func (r *extensionRuntime) fileRead(call goja.FunctionCall) goja.Value {
 	})
 }

-func (r *extensionRuntime) fileWrite(call goja.FunctionCall) goja.Value {
+func (r *ExtensionRuntime) fileWrite(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 2 {
 		return r.vm.ToValue(map[string]interface{}{
 			"success": false,
@@ -386,7 +366,7 @@ func (r *extensionRuntime) fileWrite(call goja.FunctionCall) goja.Value {
 	})
 }

-func (r *extensionRuntime) fileCopy(call goja.FunctionCall) goja.Value {
+func (r *ExtensionRuntime) fileCopy(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 2 {
 		return r.vm.ToValue(map[string]interface{}{
 			"success": false,
@@ -459,7 +439,7 @@ func (r *extensionRuntime) fileCopy(call goja.FunctionCall) goja.Value {
 	})
 }

-func (r *extensionRuntime) fileMove(call goja.FunctionCall) goja.Value {
+func (r *ExtensionRuntime) fileMove(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 2 {
 		return r.vm.ToValue(map[string]interface{}{
 			"success": false,
@@ -507,7 +487,7 @@ func (r *extensionRuntime) fileMove(call goja.FunctionCall) goja.Value {
 	})
 }

-func (r *extensionRuntime) fileGetSize(call goja.FunctionCall) goja.Value {
+func (r *ExtensionRuntime) fileGetSize(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 1 {
 		return r.vm.ToValue(map[string]interface{}{
 			"success": false,
@@ -17,7 +17,7 @@ type HTTPResponse struct {
 	Headers    map[string]string `json:"headers"`
 }

-func (r *extensionRuntime) validateDomain(urlStr string) error {
+func (r *ExtensionRuntime) validateDomain(urlStr string) error {
 	parsed, err := url.Parse(urlStr)
 	if err != nil {
 		return fmt.Errorf("invalid URL: %w", err)
@@ -49,7 +49,7 @@ func (r *extensionRuntime) validateDomain(urlStr string) error {
 	return nil
 }

-func (r *extensionRuntime) httpGet(call goja.FunctionCall) goja.Value {
+func (r *ExtensionRuntime) httpGet(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 1 {
 		return r.vm.ToValue(map[string]interface{}{
 			"error": "URL is required",
@@ -118,13 +118,12 @@ func (r *extensionRuntime) httpGet(call goja.FunctionCall) goja.Value {
 		"statusCode": resp.StatusCode,
 		"status":     resp.StatusCode,
 		"ok":         resp.StatusCode >= 200 && resp.StatusCode < 300,
-		"url":        resp.Request.URL.String(),
 		"body":       string(body),
 		"headers":    respHeaders,
 	})
 }

-func (r *extensionRuntime) httpPost(call goja.FunctionCall) goja.Value {
+func (r *ExtensionRuntime) httpPost(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 1 {
 		return r.vm.ToValue(map[string]interface{}{
 			"error": "URL is required",
@@ -215,13 +214,12 @@ func (r *extensionRuntime) httpPost(call goja.FunctionCall) goja.Value {
 		"statusCode": resp.StatusCode,
 		"status":     resp.StatusCode,
 		"ok":         resp.StatusCode >= 200 && resp.StatusCode < 300,
-		"url":        resp.Request.URL.String(),
 		"body":       string(body),
 		"headers":    respHeaders,
 	})
 }

-func (r *extensionRuntime) httpRequest(call goja.FunctionCall) goja.Value {
+func (r *ExtensionRuntime) httpRequest(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 1 {
 		return r.vm.ToValue(map[string]interface{}{
 			"error": "URL is required",
@@ -324,25 +322,24 @@ func (r *extensionRuntime) httpRequest(call goja.FunctionCall) goja.Value {
 		"statusCode": resp.StatusCode,
 		"status":     resp.StatusCode,
 		"ok":         resp.StatusCode >= 200 && resp.StatusCode < 300,
-		"url":        resp.Request.URL.String(),
 		"body":       string(body),
 		"headers":    respHeaders,
 	})
 }

-func (r *extensionRuntime) httpPut(call goja.FunctionCall) goja.Value {
+func (r *ExtensionRuntime) httpPut(call goja.FunctionCall) goja.Value {
 	return r.httpMethodShortcut("PUT", call)
 }

-func (r *extensionRuntime) httpDelete(call goja.FunctionCall) goja.Value {
+func (r *ExtensionRuntime) httpDelete(call goja.FunctionCall) goja.Value {
 	return r.httpMethodShortcut("DELETE", call)
 }

-func (r *extensionRuntime) httpPatch(call goja.FunctionCall) goja.Value {
+func (r *ExtensionRuntime) httpPatch(call goja.FunctionCall) goja.Value {
 	return r.httpMethodShortcut("PATCH", call)
 }

-func (r *extensionRuntime) httpMethodShortcut(method string, call goja.FunctionCall) goja.Value {
+func (r *ExtensionRuntime) httpMethodShortcut(method string, call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 1 {
 		return r.vm.ToValue(map[string]interface{}{
 			"error": "URL is required",
@@ -449,13 +446,12 @@ func (r *extensionRuntime) httpMethodShortcut(method string, call goja.FunctionC
 		"statusCode": resp.StatusCode,
 		"status":     resp.StatusCode,
 		"ok":         resp.StatusCode >= 200 && resp.StatusCode < 300,
-		"url":        resp.Request.URL.String(),
 		"body":       string(body),
 		"headers":    respHeaders,
 	})
 }

-func (r *extensionRuntime) httpClearCookies(call goja.FunctionCall) goja.Value {
+func (r *ExtensionRuntime) httpClearCookies(call goja.FunctionCall) goja.Value {
 	if jar, ok := r.cookieJar.(*simpleCookieJar); ok {
 		jar.mu.Lock()
 		jar.cookies = make(map[string][]*http.Cookie)
@@ -6,7 +6,7 @@ import (
 	"github.com/dop251/goja"
 )

-func (r *extensionRuntime) matchingCompareStrings(call goja.FunctionCall) goja.Value {
+func (r *ExtensionRuntime) matchingCompareStrings(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 2 {
 		return r.vm.ToValue(0.0)
 	}
@@ -22,7 +22,7 @@ func (r *extensionRuntime) matchingCompareStrings(call goja.FunctionCall) goja.V
 	return r.vm.ToValue(similarity)
 }

-func (r *extensionRuntime) matchingCompareDuration(call goja.FunctionCall) goja.Value {
+func (r *ExtensionRuntime) matchingCompareDuration(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 2 {
 		return r.vm.ToValue(false)
 	}
@@ -43,7 +43,7 @@ func (r *extensionRuntime) matchingCompareDuration(call goja.FunctionCall) goja.
 	return r.vm.ToValue(diff <= tolerance)
 }

-func (r *extensionRuntime) matchingNormalizeString(call goja.FunctionCall) goja.Value {
+func (r *ExtensionRuntime) matchingNormalizeString(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 1 {
 		return r.vm.ToValue("")
 	}
@@ -12,7 +12,11 @@ import (
 	"github.com/dop251/goja"
 )

-func (r *extensionRuntime) fetchPolyfill(call goja.FunctionCall) goja.Value {
+// These polyfills make porting browser/Node.js libraries easier
+// without compromising sandbox security.
+
+// Returns a Promise-like object with json(), text() methods.
+func (r *ExtensionRuntime) fetchPolyfill(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 1 {
 		return r.createFetchError("URL is required")
 	}
@@ -34,6 +38,7 @@ func (r *extensionRuntime) fetchPolyfill(call goja.FunctionCall) goja.Value {
 				method = strings.ToUpper(m)
 			}

+			// Body - support string, object (auto-stringify), or nil
 			if bodyArg, ok := opts["body"]; ok && bodyArg != nil {
 				switch v := bodyArg.(type) {
 				case string:
@@ -105,7 +110,7 @@ func (r *extensionRuntime) fetchPolyfill(call goja.FunctionCall) goja.Value {
 	responseObj.Set("status", resp.StatusCode)
 	responseObj.Set("statusText", http.StatusText(resp.StatusCode))
 	responseObj.Set("headers", respHeaders)
-	responseObj.Set("url", resp.Request.URL.String())
+	responseObj.Set("url", urlStr)

 	bodyString := string(body)

@@ -133,7 +138,7 @@ func (r *extensionRuntime) fetchPolyfill(call goja.FunctionCall) goja.Value {
 	return responseObj
 }

-func (r *extensionRuntime) createFetchError(message string) goja.Value {
+func (r *ExtensionRuntime) createFetchError(message string) goja.Value {
 	errorObj := r.vm.NewObject()
 	errorObj.Set("ok", false)
 	errorObj.Set("status", 0)
@@ -148,7 +153,7 @@ func (r *extensionRuntime) createFetchError(message string) goja.Value {
 	return errorObj
 }

-func (r *extensionRuntime) atobPolyfill(call goja.FunctionCall) goja.Value {
+func (r *ExtensionRuntime) atobPolyfill(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 1 {
 		return r.vm.ToValue("")
 	}
@@ -164,7 +169,7 @@ func (r *extensionRuntime) atobPolyfill(call goja.FunctionCall) goja.Value {
 	return r.vm.ToValue(string(decoded))
 }

-func (r *extensionRuntime) btoaPolyfill(call goja.FunctionCall) goja.Value {
+func (r *ExtensionRuntime) btoaPolyfill(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 1 {
 		return r.vm.ToValue("")
 	}
@@ -172,7 +177,7 @@ func (r *extensionRuntime) btoaPolyfill(call goja.FunctionCall) goja.Value {
 	return r.vm.ToValue(base64.StdEncoding.EncodeToString([]byte(input)))
 }

-func (r *extensionRuntime) registerTextEncoderDecoder(vm *goja.Runtime) {
+func (r *ExtensionRuntime) registerTextEncoderDecoder(vm *goja.Runtime) {
 	vm.Set("TextEncoder", func(call goja.ConstructorCall) *goja.Object {
 		encoder := call.This
 		encoder.Set("encoding", "utf-8")
@@ -192,6 +197,7 @@ func (r *extensionRuntime) registerTextEncoderDecoder(vm *goja.Runtime) {
 		})

 		encoder.Set("encodeInto", func(call goja.FunctionCall) goja.Value {
+			// Simplified implementation
 			if len(call.Arguments) < 2 {
 				return vm.ToValue(map[string]interface{}{"read": 0, "written": 0})
 			}
@@ -252,7 +258,7 @@ func (r *extensionRuntime) registerTextEncoderDecoder(vm *goja.Runtime) {
 	})
 }

-func (r *extensionRuntime) registerURLClass(vm *goja.Runtime) {
+func (r *ExtensionRuntime) registerURLClass(vm *goja.Runtime) {
 	vm.Set("URL", func(call goja.ConstructorCall) *goja.Object {
 		urlObj := call.This

@@ -416,7 +422,8 @@ func (r *extensionRuntime) registerURLClass(vm *goja.Runtime) {
 	})
 }

-func (r *extensionRuntime) registerJSONGlobal(vm *goja.Runtime) {
+// JSON is already built-in to Goja; this ensures a fallback exists.
+func (r *ExtensionRuntime) registerJSONGlobal(vm *goja.Runtime) {
 	jsonScript := `
 		if (typeof JSON === 'undefined') {
 			var JSON = {
@@ -21,7 +21,7 @@ const (
 	storageFlushRetryDelay   = 2 * time.Second
 )

-func (r *extensionRuntime) getStoragePath() string {
+func (r *ExtensionRuntime) getStoragePath() string {
 	return filepath.Join(r.dataDir, "storage.json")
 }

@@ -36,7 +36,7 @@ func cloneInterfaceMap(src map[string]interface{}) map[string]interface{} {
 	return dst
 }

-func (r *extensionRuntime) ensureStorageLoaded() error {
+func (r *ExtensionRuntime) ensureStorageLoaded() error {
 	r.storageMu.RLock()
 	if r.storageLoaded {
 		r.storageMu.RUnlock()
@@ -74,7 +74,7 @@ func (r *extensionRuntime) ensureStorageLoaded() error {
 	return nil
 }

-func (r *extensionRuntime) loadStorage() (map[string]interface{}, error) {
+func (r *ExtensionRuntime) loadStorage() (map[string]interface{}, error) {
 	if err := r.ensureStorageLoaded(); err != nil {
 		return nil, err
 	}
@@ -84,7 +84,7 @@ func (r *extensionRuntime) loadStorage() (map[string]interface{}, error) {
 	return cloneInterfaceMap(r.storageCache), nil
 }

-func (r *extensionRuntime) queueStorageFlushLocked(delay time.Duration) {
+func (r *ExtensionRuntime) queueStorageFlushLocked(delay time.Duration) {
 	if r.storageClosed {
 		return
 	}
@@ -94,7 +94,7 @@ func (r *extensionRuntime) queueStorageFlushLocked(delay time.Duration) {
 	r.storageTimer = time.AfterFunc(delay, r.flushStorageDirtyAsync)
 }

-func (r *extensionRuntime) persistStorageSnapshot(storage map[string]interface{}) error {
+func (r *ExtensionRuntime) persistStorageSnapshot(storage map[string]interface{}) error {
 	data, err := json.Marshal(storage)
 	if err != nil {
 		return err
@@ -106,13 +106,13 @@ func (r *extensionRuntime) persistStorageSnapshot(storage map[string]interface{}
 	return os.WriteFile(r.getStoragePath(), data, 0600)
 }

-func (r *extensionRuntime) flushStorageDirtyAsync() {
+func (r *ExtensionRuntime) flushStorageDirtyAsync() {
 	if err := r.flushStorageDirty(); err != nil {
 		GoLog("[Extension:%s] Storage flush error: %v\n", r.extensionID, err)
 	}
 }

-func (r *extensionRuntime) flushStorageDirty() error {
+func (r *ExtensionRuntime) flushStorageDirty() error {
 	r.storageMu.Lock()
 	if r.storageClosed {
 		r.storageTimer = nil
@@ -140,7 +140,7 @@ func (r *extensionRuntime) flushStorageDirty() error {
 	return nil
 }

-func (r *extensionRuntime) flushStorageNow() error {
+func (r *ExtensionRuntime) flushStorageNow() error {
 	r.storageMu.Lock()
 	if r.storageTimer != nil {
 		r.storageTimer.Stop()
@@ -157,7 +157,7 @@ func (r *extensionRuntime) flushStorageNow() error {
 	return r.persistStorageSnapshot(snapshot)
 }

-func (r *extensionRuntime) closeStorageFlusher() {
+func (r *ExtensionRuntime) closeStorageFlusher() {
 	r.storageMu.Lock()
 	r.storageClosed = true
 	r.storageDirty = false
@@ -168,7 +168,7 @@ func (r *extensionRuntime) closeStorageFlusher() {
 	r.storageMu.Unlock()
 }

-func (r *extensionRuntime) storageGet(call goja.FunctionCall) goja.Value {
+func (r *ExtensionRuntime) storageGet(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 1 {
 		return goja.Undefined()
 	}
@@ -193,7 +193,7 @@ func (r *extensionRuntime) storageGet(call goja.FunctionCall) goja.Value {
 	return r.vm.ToValue(value)
 }

-func (r *extensionRuntime) storageSet(call goja.FunctionCall) goja.Value {
+func (r *ExtensionRuntime) storageSet(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 2 {
 		return r.vm.ToValue(false)
 	}
@@ -225,7 +225,7 @@ func (r *extensionRuntime) storageSet(call goja.FunctionCall) goja.Value {
 	return r.vm.ToValue(true)
 }

-func (r *extensionRuntime) storageRemove(call goja.FunctionCall) goja.Value {
+func (r *ExtensionRuntime) storageRemove(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 1 {
 		return r.vm.ToValue(false)
 	}
@@ -254,15 +254,15 @@ func (r *extensionRuntime) storageRemove(call goja.FunctionCall) goja.Value {
 	return r.vm.ToValue(true)
 }

-func (r *extensionRuntime) getCredentialsPath() string {
+func (r *ExtensionRuntime) getCredentialsPath() string {
 	return filepath.Join(r.dataDir, ".credentials.enc")
 }

-func (r *extensionRuntime) getSaltPath() string {
+func (r *ExtensionRuntime) getSaltPath() string {
 	return filepath.Join(r.dataDir, ".cred_salt")
 }

-func (r *extensionRuntime) getOrCreateSalt() ([]byte, error) {
+func (r *ExtensionRuntime) getOrCreateSalt() ([]byte, error) {
 	saltPath := r.getSaltPath()

 	salt, err := os.ReadFile(saltPath)
@@ -282,7 +282,7 @@ func (r *extensionRuntime) getOrCreateSalt() ([]byte, error) {
 	return salt, nil
 }

-func (r *extensionRuntime) getEncryptionKey() ([]byte, error) {
+func (r *ExtensionRuntime) getEncryptionKey() ([]byte, error) {
 	salt, err := r.getOrCreateSalt()
 	if err != nil {
 		return nil, err
@@ -293,7 +293,7 @@ func (r *extensionRuntime) getEncryptionKey() ([]byte, error) {
 	return hash[:], nil
 }

-func (r *extensionRuntime) ensureCredentialsLoaded() error {
+func (r *ExtensionRuntime) ensureCredentialsLoaded() error {
 	r.credentialsMu.RLock()
 	if r.credentialsLoaded {
 		r.credentialsMu.RUnlock()
@@ -340,7 +340,7 @@ func (r *extensionRuntime) ensureCredentialsLoaded() error {
 	return nil
 }

-func (r *extensionRuntime) loadCredentials() (map[string]interface{}, error) {
+func (r *ExtensionRuntime) loadCredentials() (map[string]interface{}, error) {
 	if err := r.ensureCredentialsLoaded(); err != nil {
 		return nil, err
 	}
@@ -350,7 +350,7 @@ func (r *extensionRuntime) loadCredentials() (map[string]interface{}, error) {
 	return cloneInterfaceMap(r.credentialsCache), nil
 }

-func (r *extensionRuntime) saveCredentials(creds map[string]interface{}) error {
+func (r *ExtensionRuntime) saveCredentials(creds map[string]interface{}) error {
 	data, err := json.Marshal(creds)
 	if err != nil {
 		return err
@@ -377,7 +377,7 @@ func (r *extensionRuntime) saveCredentials(creds map[string]interface{}) error {
 	return nil
 }

-func (r *extensionRuntime) credentialsStore(call goja.FunctionCall) goja.Value {
+func (r *ExtensionRuntime) credentialsStore(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 2 {
 		return r.vm.ToValue(map[string]interface{}{
 			"success": false,
@@ -414,7 +414,7 @@ func (r *extensionRuntime) credentialsStore(call goja.FunctionCall) goja.Value {
 	})
 }

-func (r *extensionRuntime) credentialsGet(call goja.FunctionCall) goja.Value {
+func (r *ExtensionRuntime) credentialsGet(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 1 {
 		return goja.Undefined()
 	}
@@ -439,7 +439,7 @@ func (r *extensionRuntime) credentialsGet(call goja.FunctionCall) goja.Value {
 	return r.vm.ToValue(value)
 }

-func (r *extensionRuntime) credentialsRemove(call goja.FunctionCall) goja.Value {
+func (r *ExtensionRuntime) credentialsRemove(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 1 {
 		return r.vm.ToValue(false)
 	}
@@ -464,7 +464,7 @@ func (r *extensionRuntime) credentialsRemove(call goja.FunctionCall) goja.Value
 	return r.vm.ToValue(true)
 }

-func (r *extensionRuntime) credentialsHas(call goja.FunctionCall) goja.Value {
+func (r *ExtensionRuntime) credentialsHas(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 1 {
 		return r.vm.ToValue(false)
 	}
@@ -11,7 +11,7 @@ import (
 	"github.com/dop251/goja"
 )

-func setStorageValue(t *testing.T, runtime *extensionRuntime, key string, value interface{}) {
+func setStorageValue(t *testing.T, runtime *ExtensionRuntime, key string, value interface{}) {
 	t.Helper()
 	result := runtime.storageSet(goja.FunctionCall{
 		Arguments: []goja.Value{
@@ -39,7 +39,7 @@ func readStorageMap(t *testing.T, storagePath string) map[string]interface{} {
 }

 func TestExtensionRuntimeStorage_DebouncedWriteCompactJSON(t *testing.T) {
-	ext := &loadedExtension{
+	ext := &LoadedExtension{
 		ID: "storage-test",
 		Manifest: &ExtensionManifest{
 			Name: "storage-test",
@@ -47,7 +47,7 @@ func TestExtensionRuntimeStorage_DebouncedWriteCompactJSON(t *testing.T) {
 		DataDir: t.TempDir(),
 	}

-	runtime := newExtensionRuntime(ext)
+	runtime := NewExtensionRuntime(ext)
 	runtime.storageFlushDelay = 25 * time.Millisecond
 	runtime.RegisterAPIs(goja.New())

@@ -86,7 +86,7 @@ func TestExtensionRuntimeStorage_DebouncedWriteCompactJSON(t *testing.T) {
 }

 func TestUnloadExtension_FlushesPendingStorage(t *testing.T) {
-	ext := &loadedExtension{
+	ext := &LoadedExtension{
 		ID: "unload-storage-test",
 		Manifest: &ExtensionManifest{
 			Name: "unload-storage-test",
@@ -95,13 +95,13 @@ func TestUnloadExtension_FlushesPendingStorage(t *testing.T) {
 		VM:      goja.New(),
 	}

-	runtime := newExtensionRuntime(ext)
+	runtime := NewExtensionRuntime(ext)
 	runtime.storageFlushDelay = time.Hour
 	runtime.RegisterAPIs(ext.VM)
 	ext.runtime = runtime

-	manager := &extensionManager{
-		extensions: map[string]*loadedExtension{
+	manager := &ExtensionManager{
+		extensions: map[string]*LoadedExtension{
 			ext.ID: ext,
 		},
 	}
@@ -16,7 +16,7 @@ import (
 	"github.com/dop251/goja"
 )

-func (r *extensionRuntime) base64Encode(call goja.FunctionCall) goja.Value {
+func (r *ExtensionRuntime) base64Encode(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 1 {
 		return r.vm.ToValue("")
 	}
@@ -24,7 +24,7 @@ func (r *extensionRuntime) base64Encode(call goja.FunctionCall) goja.Value {
 	return r.vm.ToValue(base64.StdEncoding.EncodeToString([]byte(input)))
 }

-func (r *extensionRuntime) base64Decode(call goja.FunctionCall) goja.Value {
+func (r *ExtensionRuntime) base64Decode(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 1 {
 		return r.vm.ToValue("")
 	}
@@ -36,7 +36,7 @@ func (r *extensionRuntime) base64Decode(call goja.FunctionCall) goja.Value {
 	return r.vm.ToValue(string(decoded))
 }

-func (r *extensionRuntime) md5Hash(call goja.FunctionCall) goja.Value {
+func (r *ExtensionRuntime) md5Hash(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 1 {
 		return r.vm.ToValue("")
 	}
@@ -45,7 +45,7 @@ func (r *extensionRuntime) md5Hash(call goja.FunctionCall) goja.Value {
 	return r.vm.ToValue(hex.EncodeToString(hash[:]))
 }

-func (r *extensionRuntime) sha256Hash(call goja.FunctionCall) goja.Value {
+func (r *ExtensionRuntime) sha256Hash(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 1 {
 		return r.vm.ToValue("")
 	}
@@ -54,7 +54,7 @@ func (r *extensionRuntime) sha256Hash(call goja.FunctionCall) goja.Value {
 	return r.vm.ToValue(hex.EncodeToString(hash[:]))
 }

-func (r *extensionRuntime) hmacSHA256(call goja.FunctionCall) goja.Value {
+func (r *ExtensionRuntime) hmacSHA256(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 2 {
 		return r.vm.ToValue("")
 	}
@@ -66,7 +66,7 @@ func (r *extensionRuntime) hmacSHA256(call goja.FunctionCall) goja.Value {
 	return r.vm.ToValue(hex.EncodeToString(mac.Sum(nil)))
 }

-func (r *extensionRuntime) hmacSHA256Base64(call goja.FunctionCall) goja.Value {
+func (r *ExtensionRuntime) hmacSHA256Base64(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 2 {
 		return r.vm.ToValue("")
 	}
@@ -78,7 +78,7 @@ func (r *extensionRuntime) hmacSHA256Base64(call goja.FunctionCall) goja.Value {
 	return r.vm.ToValue(base64.StdEncoding.EncodeToString(mac.Sum(nil)))
 }

-func (r *extensionRuntime) hmacSHA1(call goja.FunctionCall) goja.Value {
+func (r *ExtensionRuntime) hmacSHA1(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 2 {
 		return r.vm.ToValue([]byte{})
 	}
@@ -130,7 +130,7 @@ func (r *extensionRuntime) hmacSHA1(call goja.FunctionCall) goja.Value {
 	return r.vm.ToValue(jsArray)
 }

-func (r *extensionRuntime) parseJSON(call goja.FunctionCall) goja.Value {
+func (r *ExtensionRuntime) parseJSON(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 1 {
 		return goja.Undefined()
 	}
@@ -145,7 +145,7 @@ func (r *extensionRuntime) parseJSON(call goja.FunctionCall) goja.Value {
 	return r.vm.ToValue(result)
 }

-func (r *extensionRuntime) stringifyJSON(call goja.FunctionCall) goja.Value {
+func (r *ExtensionRuntime) stringifyJSON(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 1 {
 		return r.vm.ToValue("")
 	}
@@ -160,7 +160,7 @@ func (r *extensionRuntime) stringifyJSON(call goja.FunctionCall) goja.Value {
 	return r.vm.ToValue(string(data))
 }

-func (r *extensionRuntime) cryptoEncrypt(call goja.FunctionCall) goja.Value {
+func (r *ExtensionRuntime) cryptoEncrypt(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 2 {
 		return r.vm.ToValue(map[string]interface{}{
 			"success": false,
@@ -187,7 +187,7 @@ func (r *extensionRuntime) cryptoEncrypt(call goja.FunctionCall) goja.Value {
 	})
 }

-func (r *extensionRuntime) cryptoDecrypt(call goja.FunctionCall) goja.Value {
+func (r *ExtensionRuntime) cryptoDecrypt(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 2 {
 		return r.vm.ToValue(map[string]interface{}{
 			"success": false,
@@ -222,7 +222,7 @@ func (r *extensionRuntime) cryptoDecrypt(call goja.FunctionCall) goja.Value {
 	})
 }

-func (r *extensionRuntime) cryptoGenerateKey(call goja.FunctionCall) goja.Value {
+func (r *ExtensionRuntime) cryptoGenerateKey(call goja.FunctionCall) goja.Value {
 	length := 32
 	if len(call.Arguments) > 0 && !goja.IsUndefined(call.Arguments[0]) {
 		if l, ok := call.Arguments[0].Export().(float64); ok {
@@ -245,35 +245,35 @@ func (r *extensionRuntime) cryptoGenerateKey(call goja.FunctionCall) goja.Value
 	})
 }

-func (r *extensionRuntime) randomUserAgent(call goja.FunctionCall) goja.Value {
+func (r *ExtensionRuntime) randomUserAgent(call goja.FunctionCall) goja.Value {
 	return r.vm.ToValue(getRandomUserAgent())
 }

-func (r *extensionRuntime) logDebug(call goja.FunctionCall) goja.Value {
+func (r *ExtensionRuntime) logDebug(call goja.FunctionCall) goja.Value {
 	msg := r.formatLogArgs(call.Arguments)
 	GoLog("[Extension:%s:DEBUG] %s\n", r.extensionID, msg)
 	return goja.Undefined()
 }

-func (r *extensionRuntime) logInfo(call goja.FunctionCall) goja.Value {
+func (r *ExtensionRuntime) logInfo(call goja.FunctionCall) goja.Value {
 	msg := r.formatLogArgs(call.Arguments)
 	GoLog("[Extension:%s:INFO] %s\n", r.extensionID, msg)
 	return goja.Undefined()
 }

-func (r *extensionRuntime) logWarn(call goja.FunctionCall) goja.Value {
+func (r *ExtensionRuntime) logWarn(call goja.FunctionCall) goja.Value {
 	msg := r.formatLogArgs(call.Arguments)
 	GoLog("[Extension:%s:WARN] %s\n", r.extensionID, msg)
 	return goja.Undefined()
 }

-func (r *extensionRuntime) logError(call goja.FunctionCall) goja.Value {
+func (r *ExtensionRuntime) logError(call goja.FunctionCall) goja.Value {
 	msg := r.formatLogArgs(call.Arguments)
 	GoLog("[Extension:%s:ERROR] %s\n", r.extensionID, msg)
 	return goja.Undefined()
 }

-func (r *extensionRuntime) formatLogArgs(args []goja.Value) string {
+func (r *ExtensionRuntime) formatLogArgs(args []goja.Value) string {
 	parts := make([]string, len(args))
 	for i, arg := range args {
 		parts[i] = fmt.Sprintf("%v", arg.Export())
@@ -281,7 +281,7 @@ func (r *extensionRuntime) formatLogArgs(args []goja.Value) string {
 	return strings.Join(parts, " ")
 }

-func (r *extensionRuntime) sanitizeFilenameWrapper(call goja.FunctionCall) goja.Value {
+func (r *ExtensionRuntime) sanitizeFilenameWrapper(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 1 {
 		return r.vm.ToValue("")
 	}
@@ -289,7 +289,7 @@ func (r *extensionRuntime) sanitizeFilenameWrapper(call goja.FunctionCall) goja.
 	return r.vm.ToValue(sanitizeFilename(input))
 }

-func (r *extensionRuntime) RegisterGoBackendAPIs(vm *goja.Runtime) {
+func (r *ExtensionRuntime) RegisterGoBackendAPIs(vm *goja.Runtime) {
 	gobackendObj := vm.Get("gobackend")
 	if gobackendObj == nil || goja.IsUndefined(gobackendObj) {
 		gobackendObj = vm.NewObject()
@@ -8,7 +8,6 @@ import (
 	"net/url"
 	"os"
 	"path/filepath"
-	"strings"
 	"sync"
 	"time"
 )
@@ -21,7 +20,7 @@ const (
 	CategoryIntegration = "integration"
 )

-type storeExtension struct {
+type StoreExtension struct {
 	ID               string   `json:"id"`
 	Name             string   `json:"name"`
 	DisplayName      string   `json:"display_name,omitempty"`
@@ -41,7 +40,7 @@ type storeExtension struct {
 	MinAppVersionAlt string   `json:"minAppVersion,omitempty"`
 }

-func (e *storeExtension) getDisplayName() string {
+func (e *StoreExtension) getDisplayName() string {
 	if e.DisplayName != "" {
 		return e.DisplayName
 	}
@@ -51,34 +50,34 @@ func (e *storeExtension) getDisplayName() string {
 	return e.Name
 }

-func (e *storeExtension) getDownloadURL() string {
+func (e *StoreExtension) getDownloadURL() string {
 	if e.DownloadURL != "" {
 		return e.DownloadURL
 	}
 	return e.DownloadURLAlt
 }

-func (e *storeExtension) getIconURL() string {
+func (e *StoreExtension) getIconURL() string {
 	if e.IconURL != "" {
 		return e.IconURL
 	}
 	return e.IconURLAlt
 }

-func (e *storeExtension) getMinAppVersion() string {
+func (e *StoreExtension) getMinAppVersion() string {
 	if e.MinAppVersion != "" {
 		return e.MinAppVersion
 	}
 	return e.MinAppVersionAlt
 }

-type storeRegistry struct {
+type StoreRegistry struct {
 	Version    int              `json:"version"`
 	UpdatedAt  string           `json:"updated_at"`
-	Extensions []storeExtension `json:"extensions"`
+	Extensions []StoreExtension `json:"extensions"`
 }

-type storeExtensionResponse struct {
+type StoreExtensionResponse struct {
 	ID               string   `json:"id"`
 	Name             string   `json:"name"`
 	DisplayName      string   `json:"display_name"`
@@ -97,8 +96,8 @@ type storeExtensionResponse struct {
 	HasUpdate        bool     `json:"has_update"`
 }

-func (e *storeExtension) toResponse() storeExtensionResponse {
-	resp := storeExtensionResponse{
+func (e *StoreExtension) ToResponse() StoreExtensionResponse {
+	return StoreExtensionResponse{
 		ID:            e.ID,
 		Name:          e.Name,
 		DisplayName:   e.getDisplayName(),
@@ -108,85 +107,55 @@ func (e *storeExtension) toResponse() storeExtensionResponse {
 		DownloadURL:   e.getDownloadURL(),
 		IconURL:       e.getIconURL(),
 		Category:      e.Category,
+		Tags:          e.Tags,
 		Downloads:     e.Downloads,
 		UpdatedAt:     e.UpdatedAt,
 		MinAppVersion: e.getMinAppVersion(),
 	}
-
-	if len(e.Tags) > 0 {
-		resp.Tags = append([]string(nil), e.Tags...)
-	}
-
-	return resp
 }

-type extensionStore struct {
+type ExtensionStore struct {
 	registryURL string
 	cacheDir    string
-	cache       *storeRegistry
+	cache       *StoreRegistry
 	cacheMu     sync.RWMutex
 	cacheTime   time.Time
 	cacheTTL    time.Duration
 }

 var (
-	globalExtensionStore *extensionStore
-	extensionStoreMu     sync.Mutex
+	extensionStore   *ExtensionStore
+	extensionStoreMu sync.Mutex
 )

 const (
-	cacheTTL      = 30 * time.Minute
-	cacheFileName = "store_cache.json"
+	defaultRegistryURL = "https://raw.githubusercontent.com/zarzet/SpotiFLAC-Extension/main/registry.json"
+	cacheTTL           = 30 * time.Minute
+	cacheFileName      = "store_cache.json"
 )

-func initExtensionStore(cacheDir string) *extensionStore {
+func InitExtensionStore(cacheDir string) *ExtensionStore {
 	extensionStoreMu.Lock()
 	defer extensionStoreMu.Unlock()

-	if globalExtensionStore == nil {
-		globalExtensionStore = &extensionStore{
-			registryURL: "",
+	if extensionStore == nil {
+		extensionStore = &ExtensionStore{
+			registryURL: defaultRegistryURL,
 			cacheDir:    cacheDir,
 			cacheTTL:    cacheTTL,
 		}
-		globalExtensionStore.loadDiskCache()
+		extensionStore.loadDiskCache()
 	}
-	return globalExtensionStore
+	return extensionStore
 }

-func (s *extensionStore) setRegistryURL(registryURL string) {
-	s.cacheMu.Lock()
-	defer s.cacheMu.Unlock()
-
-	if s.registryURL == registryURL {
-		return
-	}
-
-	s.registryURL = registryURL
-	s.cache = nil
-	s.cacheTime = time.Time{}
-
-	if s.cacheDir != "" {
-		cachePath := filepath.Join(s.cacheDir, cacheFileName)
-		os.Remove(cachePath)
-	}
-
-	LogInfo("ExtensionStore", "Registry URL updated to: %s", registryURL)
-}
-
-func (s *extensionStore) getRegistryURL() string {
-	s.cacheMu.RLock()
-	defer s.cacheMu.RUnlock()
-	return s.registryURL
-}
-
-func getExtensionStore() *extensionStore {
+func GetExtensionStore() *ExtensionStore {
 	extensionStoreMu.Lock()
 	defer extensionStoreMu.Unlock()
-	return globalExtensionStore
+	return extensionStore
 }

-func (s *extensionStore) loadDiskCache() {
+func (s *ExtensionStore) loadDiskCache() {
 	if s.cacheDir == "" {
 		return
 	}
@@ -198,7 +167,7 @@ func (s *extensionStore) loadDiskCache() {
 	}

 	var cacheData struct {
-		Registry  storeRegistry `json:"registry"`
+		Registry  StoreRegistry `json:"registry"`
 		CacheTime int64         `json:"cache_time"`
 	}

@@ -211,13 +180,13 @@ func (s *extensionStore) loadDiskCache() {
 	LogDebug("ExtensionStore", "Loaded %d extensions from disk cache", len(s.cache.Extensions))
 }

-func (s *extensionStore) saveDiskCache() {
+func (s *ExtensionStore) saveDiskCache() {
 	if s.cacheDir == "" || s.cache == nil {
 		return
 	}

 	cacheData := struct {
-		Registry  storeRegistry `json:"registry"`
+		Registry  StoreRegistry `json:"registry"`
 		CacheTime int64         `json:"cache_time"`
 	}{
 		Registry:  *s.cache,
@@ -233,14 +202,10 @@ func (s *extensionStore) saveDiskCache() {
 	os.WriteFile(cachePath, data, 0644)
 }

-func (s *extensionStore) fetchRegistry(forceRefresh bool) (*storeRegistry, error) {
+func (s *ExtensionStore) FetchRegistry(forceRefresh bool) (*StoreRegistry, error) {
 	s.cacheMu.Lock()
 	defer s.cacheMu.Unlock()

-	if s.registryURL == "" {
-		return nil, fmt.Errorf("no registry URL configured. Please add a repository URL first")
-	}
-
 	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
@@ -276,7 +241,7 @@ func (s *extensionStore) fetchRegistry(forceRefresh bool) (*storeRegistry, error
 		return nil, fmt.Errorf("failed to read registry: %w", err)
 	}

-	var registry storeRegistry
+	var registry StoreRegistry
 	if err := json.Unmarshal(body, &registry); err != nil {
 		return nil, fmt.Errorf("failed to parse registry: %w", err)
 	}
@@ -289,13 +254,13 @@ func (s *extensionStore) fetchRegistry(forceRefresh bool) (*storeRegistry, error
 	return &registry, nil
 }

-func (s *extensionStore) getExtensionsWithStatus(forceRefresh bool) ([]storeExtensionResponse, error) {
-	registry, err := s.fetchRegistry(forceRefresh)
+func (s *ExtensionStore) GetExtensionsWithStatus() ([]StoreExtensionResponse, error) {
+	registry, err := s.FetchRegistry(false)
 	if err != nil {
 		return nil, err
 	}

-	manager := getExtensionManager()
+	manager := GetExtensionManager()
 	installed := make(map[string]string) // id -> version

 	if manager != nil {
@@ -304,32 +269,29 @@ func (s *extensionStore) getExtensionsWithStatus(forceRefresh bool) ([]storeExte
 		}
 	}

-	LogDebug("ExtensionStore", "Building store response for %d registry extensions (%d installed)", len(registry.Extensions), len(installed))
+	result := make([]StoreExtensionResponse, len(registry.Extensions))
+	for i, ext := range registry.Extensions {
+		resp := ext.ToResponse()

-	result := make([]storeExtensionResponse, 0, len(registry.Extensions))
-	for i := range registry.Extensions {
-		ext := &registry.Extensions[i]
-		resp := ext.toResponse()
 		if installedVersion, ok := installed[ext.ID]; ok {
 			resp.IsInstalled = true
 			resp.InstalledVersion = installedVersion
 			resp.HasUpdate = compareVersions(ext.Version, installedVersion) > 0
 		}

-		result = append(result, resp)
+		result[i] = resp
 	}

-	LogDebug("ExtensionStore", "Built store response payload for %d extensions", len(result))
 	return result, nil
 }

-func (s *extensionStore) downloadExtension(extensionID string, destPath string) error {
-	registry, err := s.fetchRegistry(false)
+func (s *ExtensionStore) DownloadExtension(extensionID string, destPath string) error {
+	registry, err := s.FetchRegistry(false)
 	if err != nil {
 		return err
 	}

-	var ext *storeExtension
+	var ext *StoreExtension
 	for _, e := range registry.Extensions {
 		if e.ID == extensionID {
 			ext = &e
@@ -374,68 +336,6 @@ func (s *extensionStore) downloadExtension(extensionID string, destPath string)
 	return nil
 }

-func resolveRegistryURL(input string) (string, error) {
-	input = strings.TrimSpace(input)
-	if input == "" {
-		return "", fmt.Errorf("registry URL is empty")
-	}
-
-	if strings.Contains(input, "raw.githubusercontent.com") {
-		return input, nil
-	}
-
-	const ghPrefix = "https://github.com/"
-	if !strings.HasPrefix(input, ghPrefix) {
-		const ghPrefixHTTP = "http://github.com/"
-		if strings.HasPrefix(input, ghPrefixHTTP) {
-			input = "https://github.com/" + input[len(ghPrefixHTTP):]
-		} else {
-			return input, nil
-		}
-	}
-
-	path := input[len(ghPrefix):]
-	parts := strings.SplitN(path, "/", 3) // owner, repo, [rest]
-	if len(parts) < 2 || parts[0] == "" || parts[1] == "" {
-		return "", fmt.Errorf("invalid GitHub URL: expected github.com/<owner>/<repo>")
-	}
-	owner := parts[0]
-	repo := strings.TrimSuffix(parts[1], ".git")
-
-	branch := resolveGitHubDefaultBranch(owner, repo)
-
-	resolved := fmt.Sprintf("https://raw.githubusercontent.com/%s/%s/%s/registry.json", owner, repo, branch)
-	LogInfo("ExtensionStore", "Resolved %s → %s (branch: %s)", input, resolved, branch)
-	return resolved, nil
-}
-
-func resolveGitHubDefaultBranch(owner, repo string) string {
-	apiURL := fmt.Sprintf("https://api.github.com/repos/%s/%s", owner, repo)
-	client := NewHTTPClientWithTimeout(10 * time.Second)
-
-	resp, err := client.Get(apiURL)
-	if err != nil {
-		LogWarn("ExtensionStore", "GitHub API request failed for %s/%s: %v – falling back to main", owner, repo, err)
-		return "main"
-	}
-	defer resp.Body.Close()
-
-	if resp.StatusCode != http.StatusOK {
-		LogWarn("ExtensionStore", "GitHub API returned %d for %s/%s – falling back to main", resp.StatusCode, owner, repo)
-		return "main"
-	}
-
-	var info struct {
-		DefaultBranch string `json:"default_branch"`
-	}
-	if err := json.NewDecoder(resp.Body).Decode(&info); err != nil || info.DefaultBranch == "" {
-		LogWarn("ExtensionStore", "Could not parse default_branch for %s/%s – falling back to main", owner, repo)
-		return "main"
-	}
-
-	return info.DefaultBranch
-}
-
 func requireHTTPSURL(rawURL string, context string) error {
 	if rawURL == "" {
 		return fmt.Errorf("%s URL is empty", context)
@@ -450,7 +350,7 @@ func requireHTTPSURL(rawURL string, context string) error {
 	return nil
 }

-func (s *extensionStore) getCategories() []string {
+func (s *ExtensionStore) GetCategories() []string {
 	return []string{
 		CategoryMetadata,
 		CategoryDownload,
@@ -460,8 +360,8 @@ func (s *extensionStore) getCategories() []string {
 	}
 }

-func (s *extensionStore) searchExtensions(query string, category string) ([]storeExtensionResponse, error) {
-	extensions, err := s.getExtensionsWithStatus(false)
+func (s *ExtensionStore) SearchExtensions(query string, category string) ([]StoreExtensionResponse, error) {
+	extensions, err := s.GetExtensionsWithStatus()
 	if err != nil {
 		return nil, err
 	}
@@ -470,19 +370,22 @@ func (s *extensionStore) searchExtensions(query string, category string) ([]stor
 		return extensions, nil
 	}

-	result := make([]storeExtensionResponse, 0, len(extensions))
+	var result []StoreExtensionResponse
 	queryLower := toLower(query)

 	for _, ext := range extensions {
+		// Filter by category
 		if category != "" && ext.Category != category {
 			continue
 		}

+		// Filter by query
 		if query != "" {
 			if !containsIgnoreCase(ext.Name, queryLower) &&
 				!containsIgnoreCase(ext.DisplayName, queryLower) &&
 				!containsIgnoreCase(ext.Description, queryLower) &&
 				!containsIgnoreCase(ext.Author, queryLower) {
+				// Check tags
 				found := false
 				for _, tag := range ext.Tags {
 					if containsIgnoreCase(tag, queryLower) {
@@ -502,7 +405,7 @@ func (s *extensionStore) searchExtensions(query string, category string) ([]stor
 	return result, nil
 }

-func (s *extensionStore) clearCache() {
+func (s *ExtensionStore) ClearCache() {
 	s.cacheMu.Lock()
 	defer s.cacheMu.Unlock()

@@ -99,7 +99,7 @@ func TestIsDomainAllowed(t *testing.T) {

 func TestExtensionRuntime_NetworkSandbox(t *testing.T) {
 	// Create a mock extension with limited network permissions
-	ext := &loadedExtension{
+	ext := &LoadedExtension{
 		ID: "test-ext",
 		Manifest: &ExtensionManifest{
 			Name: "test-ext",
@@ -110,7 +110,7 @@ func TestExtensionRuntime_NetworkSandbox(t *testing.T) {
 		DataDir: t.TempDir(),
 	}

-	runtime := newExtensionRuntime(ext)
+	runtime := NewExtensionRuntime(ext)

 	if err := runtime.validateDomain("https://api.allowed.com/path"); err != nil {
 		t.Errorf("Expected api.allowed.com to be allowed, got error: %v", err)
@@ -132,7 +132,7 @@ func TestExtensionRuntime_NetworkSandbox(t *testing.T) {
 func TestExtensionRuntime_FileSandbox(t *testing.T) {
 	tempDir := t.TempDir()

-	ext := &loadedExtension{
+	ext := &LoadedExtension{
 		ID: "test-ext",
 		Manifest: &ExtensionManifest{
 			Name: "test-ext",
@@ -143,7 +143,7 @@ func TestExtensionRuntime_FileSandbox(t *testing.T) {
 		DataDir: tempDir,
 	}

-	runtime := newExtensionRuntime(ext)
+	runtime := NewExtensionRuntime(ext)

 	validPath, err := runtime.validatePath("test.txt")
 	if err != nil {
@@ -177,7 +177,7 @@ func TestExtensionRuntime_FileSandbox(t *testing.T) {
 		t.Error("Expected absolute path to be blocked")
 	}

-	extNoFile := &loadedExtension{
+	extNoFile := &LoadedExtension{
 		ID: "test-ext-no-file",
 		Manifest: &ExtensionManifest{
 			Name: "test-ext-no-file",
@@ -187,7 +187,7 @@ func TestExtensionRuntime_FileSandbox(t *testing.T) {
 		},
 		DataDir: tempDir,
 	}
-	runtimeNoFile := newExtensionRuntime(extNoFile)
+	runtimeNoFile := NewExtensionRuntime(extNoFile)
 	_, err = runtimeNoFile.validatePath("test.txt")
 	if err == nil {
 		t.Error("Expected file access to be denied without file permission")
@@ -195,7 +195,7 @@ func TestExtensionRuntime_FileSandbox(t *testing.T) {
 }

 func TestExtensionRuntime_UtilityFunctions(t *testing.T) {
-	ext := &loadedExtension{
+	ext := &LoadedExtension{
 		ID: "test-ext",
 		Manifest: &ExtensionManifest{
 			Name: "test-ext",
@@ -203,7 +203,7 @@ func TestExtensionRuntime_UtilityFunctions(t *testing.T) {
 		DataDir: t.TempDir(),
 	}

-	runtime := newExtensionRuntime(ext)
+	runtime := NewExtensionRuntime(ext)
 	vm := goja.New()
 	runtime.RegisterAPIs(vm)

@@ -243,7 +243,7 @@ func TestExtensionRuntime_UtilityFunctions(t *testing.T) {

 func TestExtensionRuntime_SSRFProtection(t *testing.T) {
 	// Create extension with limited network permissions
-	ext := &loadedExtension{
+	ext := &LoadedExtension{
 		ID: "test-ext",
 		Manifest: &ExtensionManifest{
 			Name: "test-ext",
@@ -254,7 +254,7 @@ func TestExtensionRuntime_SSRFProtection(t *testing.T) {
 		DataDir: t.TempDir(),
 	}

-	runtime := newExtensionRuntime(ext)
+	runtime := NewExtensionRuntime(ext)

 	privateIPs := []string{
 		"http://localhost/admin",
@@ -20,10 +20,6 @@ func (e *JSExecutionError) Error() string {
 }

 func RunWithTimeout(vm *goja.Runtime, script string, timeout time.Duration) (goja.Value, error) {
-	if vm == nil {
-		return nil, fmt.Errorf("extension runtime unavailable")
-	}
-
 	if timeout <= 0 {
 		timeout = DefaultJSTimeout
 	}
@@ -53,7 +49,7 @@ func RunWithTimeout(vm *goja.Runtime, script string, timeout time.Duration) (goj
 						IsTimeout: true,
 					}}
 				} else {
-					GoLog("[extensionRuntime] panic during JS execution: %v\n%s\n", r, string(debug.Stack()))
+					GoLog("[ExtensionRuntime] panic during JS execution: %v\n%s\n", r, string(debug.Stack()))
 					resultCh <- result{nil, fmt.Errorf("panic during execution: %v", r)}
 				}
 			}
@@ -73,11 +69,6 @@ func RunWithTimeout(vm *goja.Runtime, script string, timeout time.Duration) (goj

 		vm.Interrupt("execution timeout")

-		// MUST wait for the goroutine to finish before returning.
-		// The Goja VM is NOT thread-safe — if we return while the goroutine
-		// is still executing JS (e.g. blocked on an HTTP call), the next
-		// caller will access the VM concurrently and crash with a nil
-		// pointer dereference.
 		select {
 		case res := <-resultCh:
 			if res.err != nil {
@@ -87,10 +78,7 @@ func RunWithTimeout(vm *goja.Runtime, script string, timeout time.Duration) (goj
 				Message:   "execution timeout exceeded",
 				IsTimeout: true,
 			}
-		case <-time.After(60 * time.Second):
-			// Goroutine is truly stuck (e.g. HTTP read with no timeout).
-			// Log a warning — the VM should NOT be reused after this.
-			GoLog("[extensionRuntime] WARNING: JS goroutine did not exit within 60s after interrupt, VM may be unsafe\n")
+		case <-time.After(1 * time.Second):
 			return nil, &JSExecutionError{
 				Message:   "execution timeout exceeded (force)",
 				IsTimeout: true,
@@ -104,9 +92,8 @@ func RunWithTimeout(vm *goja.Runtime, script string, timeout time.Duration) (goj
 func RunWithTimeoutAndRecover(vm *goja.Runtime, script string, timeout time.Duration) (goja.Value, error) {
 	result, err := RunWithTimeout(vm, script, timeout)

-	if vm != nil {
-		vm.ClearInterrupt()
-	}
+	// Clear any interrupt state so VM can be reused
+	vm.ClearInterrupt()

 	return result, err
 }
@@ -2,28 +2,28 @@ module github.com/zarz/spotiflac_android/go_backend

 go 1.25.0

-toolchain go1.25.8
+toolchain go1.25.7

 require (
-	github.com/dop251/goja v0.0.0-20260311135729-065cd970411c
+	github.com/dop251/goja v0.0.0-20260216154549-8b74ce4618c5
 	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-20260312152759-81488f6aeb60
-	golang.org/x/net v0.52.0
-	golang.org/x/text v0.35.0
+	golang.org/x/mobile v0.0.0-20260211191516-dcd2a3258864
+	golang.org/x/net v0.50.0
 )

 require (
-	github.com/andybalholm/brotli v1.2.0 // indirect
-	github.com/dlclark/regexp2 v1.11.5 // indirect
-	github.com/go-sourcemap/sourcemap v2.1.4+incompatible // indirect
-	github.com/google/pprof v0.0.0-20260302011040-a15ffb7f9dcc // indirect
-	github.com/klauspost/compress v1.18.5 // indirect
-	golang.org/x/crypto v0.49.0 // indirect
-	golang.org/x/mod v0.34.0 // indirect
-	golang.org/x/sync v0.20.0 // indirect
-	golang.org/x/sys v0.42.0 // indirect
-	golang.org/x/tools v0.43.0 // indirect
+	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
+	github.com/klauspost/compress v1.17.4 // indirect
+	golang.org/x/crypto v0.48.0 // indirect
+	golang.org/x/mod v0.33.0 // indirect
+	golang.org/x/sync v0.19.0 // indirect
+	golang.org/x/sys v0.41.0 // indirect
+	golang.org/x/text v0.34.0 // indirect
+	golang.org/x/tools v0.42.0 // indirect
 )
@@ -1,51 +1,67 @@
 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.2.0 h1:ukwgCxwYrmACq68yiUqwIWnGY0cTPox/M94sVwToPjQ=
-github.com/andybalholm/brotli v1.2.0/go.mod h1:rzTDkvFWvIrjDXZHkuS16NPggd91W3kUSvPlQ1pLaKY=
+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.5 h1:Q/sSnsKerHeCkc/jSTNq1oCm7KiVgUMZRDUoRu0JQZQ=
-github.com/dlclark/regexp2 v1.11.5/go.mod h1:DHkYz0B9wPfa6wondMfaivmHpzrQ3v9q8cnmRbL6yW8=
-github.com/dop251/goja v0.0.0-20260311135729-065cd970411c h1:OcLmPfx1T1RmZVHHFwWMPaZDdRf0DBMZOFMVWJa7Pdk=
-github.com/dop251/goja v0.0.0-20260311135729-065cd970411c/go.mod h1:MxLav0peU43GgvwVgNbLAj1s/bSGboKkhuULvq/7hx4=
+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/dop251/goja v0.0.0-20260216154549-8b74ce4618c5 h1:QckvTXtu55YMopmVeDrPQ/r+T6xjw8KMCmE3UgUldkw=
+github.com/dop251/goja v0.0.0-20260216154549-8b74ce4618c5/go.mod h1:MxLav0peU43GgvwVgNbLAj1s/bSGboKkhuULvq/7hx4=
 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.4+incompatible h1:a+iTbH5auLKxaNwQFg0B+TCYl6lbukKPc7b5x0n1s6Q=
-github.com/go-sourcemap/sourcemap v2.1.4+incompatible/go.mod h1:F8jJfvm2KbVjc5NqelyYJmf/v5J0dwNLS2mL4sNA1Jg=
+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-20260302011040-a15ffb7f9dcc h1:VBbFa1lDYWEeV5FZKUiYKYT0VxCp9twUmmaq9eb8sXw=
-github.com/google/pprof v0.0.0-20260302011040-a15ffb7f9dcc/go.mod h1:MxpfABSjhmINe3F1It9d+8exIHFvUqtLIRCdOGNXqiI=
-github.com/klauspost/compress v1.18.5 h1:/h1gH5Ce+VWNLSWqPzOVn6XBO+vJbCNGvjoaGBFW2IE=
-github.com/klauspost/compress v1.18.5/go.mod h1:cwPg85FWrGar70rWktvGQj8/hthj3wpl0PGDogxkrSQ=
+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=
+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=
-github.com/xyproto/randomstring v1.0.5 h1:YtlWPoRdgMu3NZtP45drfy1GKoojuR7hmRcnhZqKjWU=
-github.com/xyproto/randomstring v1.0.5/go.mod h1:rgmS5DeNXLivK7YprL0pY+lTuhNQW3iGxZ18UQApw/E=
-golang.org/x/crypto v0.49.0 h1:+Ng2ULVvLHnJ/ZFEq4KdcDd/cfjrrjjNSXNzxg0Y4U4=
-golang.org/x/crypto v0.49.0/go.mod h1:ErX4dUh2UM+CFYiXZRTcMpEcN8b/1gxEuv3nODoYtCA=
-golang.org/x/mobile v0.0.0-20260312152759-81488f6aeb60 h1:MOzyaj0wu2xneBkzkg9LHNYjDBB4W5vP043A2SYQRPA=
-golang.org/x/mobile v0.0.0-20260312152759-81488f6aeb60/go.mod h1:th6VJvzjMbrYF8SduQY5rpD0HG0GleGxjadkqSxFs3k=
-golang.org/x/mod v0.34.0 h1:xIHgNUUnW6sYkcM5Jleh05DvLOtwc6RitGHbDk4akRI=
-golang.org/x/mod v0.34.0/go.mod h1:ykgH52iCZe79kzLLMhyCUzhMci+nQj+0XkbXpNYtVjY=
-golang.org/x/net v0.52.0 h1:He/TN1l0e4mmR3QqHMT2Xab3Aj3L9qjbhRm78/6jrW0=
-golang.org/x/net v0.52.0/go.mod h1:R1MAz7uMZxVMualyPXb+VaqGSa3LIaUqk0eEt3w36Sw=
-golang.org/x/sync v0.20.0 h1:e0PTpb7pjO8GAtTs2dQ6jYa5BWYlMuX047Dco/pItO4=
-golang.org/x/sync v0.20.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0=
-golang.org/x/sys v0.42.0 h1:omrd2nAlyT5ESRdCLYdm3+fMfNFE/+Rf4bDIQImRJeo=
-golang.org/x/sys v0.42.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=
-golang.org/x/text v0.35.0 h1:JOVx6vVDFokkpaq1AEptVzLTpDe9KGpj5tR4/X+ybL8=
-golang.org/x/text v0.35.0/go.mod h1:khi/HExzZJ2pGnjenulevKNX1W67CUy0AsXcNubPGCA=
-golang.org/x/tools v0.43.0 h1:12BdW9CeB3Z+J/I/wj34VMl8X+fEXBxVR90JeMX5E7s=
-golang.org/x/tools v0.43.0/go.mod h1:uHkMso649BX2cZK6+RpuIPXS3ho2hZo4FVwfoy1vIk0=
+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/crypto v0.48.0 h1:/VRzVqiRSggnhY7gNRxPauEQ5Drw9haKdM0jqfcCFts=
+golang.org/x/crypto v0.48.0/go.mod h1:r0kV5h3qnFPlQnBSrULhlsRfryS2pmewsg+XfMgkVos=
+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/mobile v0.0.0-20260209203831-923679eb55af h1:VqXrZNyqFISxo0rNDFZQlRDRIp7RXSJDeh/LbrK+W1k=
+golang.org/x/mobile v0.0.0-20260209203831-923679eb55af/go.mod h1:tbwefIr7RlQD1OpZ0KEZ9nux/uiihAOGdafgZfJkmII=
+golang.org/x/mobile v0.0.0-20260211191516-dcd2a3258864 h1:cTVynMSsMYgbUrtia2HB1jrhdUwQNtQti91vUCyjMp4=
+golang.org/x/mobile v0.0.0-20260211191516-dcd2a3258864/go.mod h1:4OGHIUSBiIqyFAQDaX1tpY0BVnO20DvNDeATBu8aeFQ=
+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/mod v0.33.0 h1:tHFzIWbBifEmbwtGz65eaWyGiGZatSrT9prnU8DbVL8=
+golang.org/x/mod v0.33.0/go.mod h1:swjeQEj+6r7fODbD2cqrnje9PnziFuw4bmLbBZFrQ5w=
+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/net v0.50.0 h1:ucWh9eiCGyDR3vtzso0WMQinm2Dnt8cFMuQa9K33J60=
+golang.org/x/net v0.50.0/go.mod h1:UgoSli3F/pBgdJBHCTc+tp3gmrU4XswgGRgtnwWTfyM=
+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/sys v0.40.0 h1:DBZZqJ2Rkml6QMQsZywtnjnnGvHza6BTfYFWY9kjEWQ=
+golang.org/x/sys v0.40.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
+golang.org/x/sys v0.41.0 h1:Ivj+2Cp/ylzLiEU89QhWblYnOE9zerudt9Ftecq2C6k=
+golang.org/x/sys v0.41.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/text v0.34.0 h1:oL/Qq0Kdaqxa1KbNeMKwQq0reLCCaFtqu2eNuSeNHbk=
+golang.org/x/text v0.34.0/go.mod h1:homfLqTYRFyVYemLBFl5GgL/DWEiH5wcsQ5gSh1yziA=
+golang.org/x/tools v0.41.0 h1:a9b8iMweWG+S0OBnlU36rzLp20z1Rp10w+IY2czHTQc=
+golang.org/x/tools v0.41.0/go.mod h1:XSY6eDqxVNiYgezAVqqCeihT4j1U2CCsqvH3WhQpnlg=
+golang.org/x/tools v0.42.0 h1:uNgphsn75Tdz5Ji2q36v/nsFSfR/9BRFvqhGBaJGd5k=
+golang.org/x/tools v0.42.0/go.mod h1:Ma6lCIwGZvHK6XtgbswSoWroEkhugApmsXyrUmBhfr0=
 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=
@@ -31,7 +31,7 @@ func getRandomUserAgent() string {

 const (
 	DefaultTimeout    = 60 * time.Second
-	DownloadTimeout   = 24 * time.Hour
+	DownloadTimeout   = 120 * time.Second
 	SongLinkTimeout   = 30 * time.Second
 	DefaultMaxRetries = 3
 	DefaultRetryDelay = 1 * time.Second
@@ -66,6 +66,9 @@ 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,
@@ -101,6 +104,8 @@ 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: newCompatibilityTransport(metadataTransport),
@@ -224,6 +229,7 @@ func cloneRequestWithHTTPScheme(req *http.Request, scheme string) (*http.Request
 	return reqCopy, nil
 }

+// Also checks for ISP blocking on errors
 func DoRequestWithUserAgent(client *http.Client, req *http.Request) (*http.Response, error) {
 	req.Header.Set("User-Agent", getRandomUserAgent())
 	resp, err := client.Do(req)
@@ -233,6 +239,7 @@ func DoRequestWithUserAgent(client *http.Client, req *http.Request) (*http.Respo
 	return resp, err
 }

+// RetryConfig holds configuration for retry logic
 type RetryConfig struct {
 	MaxRetries    int
 	InitialDelay  time.Duration
@@ -293,11 +300,14 @@ func DoRequestWithRetry(client *http.Client, req *http.Request, config RetryConf
 			continue
 		}

+		// Check for ISP blocking via HTTP status codes
+		// Some ISPs return 403 or 451 when blocking content
 		if resp.StatusCode == 403 || resp.StatusCode == 451 {
 			body, _ := io.ReadAll(resp.Body)
 			resp.Body.Close()
 			bodyStr := strings.ToLower(string(body))

+			// Check if response looks like ISP blocking page
 			ispBlockingIndicators := []string{
 				"blocked", "forbidden", "access denied", "not available in your",
 				"restricted", "censored", "unavailable for legal", "blocked by",
@@ -336,12 +346,11 @@ func calculateNextDelay(currentDelay time.Duration, config RetryConfig) time.Dur
 	return min(nextDelay, config.MaxDelay)
 }

-// Returns 0 if the header is missing or invalid so callers can keep their
-// normal exponential backoff instead of stalling for an arbitrary minute.
+// Returns 60 seconds as default if header is missing or invalid
 func getRetryAfterDuration(resp *http.Response) time.Duration {
 	retryAfter := resp.Header.Get("Retry-After")
 	if retryAfter == "" {
-		return 0
+		return 60 * time.Second // Default wait time
 	}

 	if seconds, err := strconv.Atoi(retryAfter); err == nil {
@@ -355,7 +364,7 @@ func getRetryAfterDuration(resp *http.Response) time.Duration {
 		}
 	}

-	return 0
+	return 60 * time.Second // Default
 }

 func ReadResponseBody(resp *http.Response) ([]byte, error) {
@@ -508,6 +517,7 @@ func IsISPBlocking(err error, requestURL string) *ISPBlockingError {
 	return nil
 }

+// Returns true if ISP blocking was detected
 func CheckAndLogISPBlocking(err error, requestURL string, tag string) bool {
 	ispErr := IsISPBlocking(err, requestURL)
 	if ispErr != nil {
@@ -542,6 +552,7 @@ func extractDomain(rawURL string) string {
 	return "unknown"
 }

+// If ISP blocking is detected, returns a more descriptive error
 func WrapErrorWithISPCheck(err error, requestURL string, tag string) error {
 	if err == nil {
 		return nil
@@ -6,10 +6,17 @@ 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)
@@ -16,6 +16,8 @@ import (
 	"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
@@ -96,15 +98,21 @@ var cloudflareBypassClient = &http.Client{
 	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())

 	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()
@@ -135,6 +143,7 @@ func DoRequestWithCloudflareBypass(req *http.Request) (*http.Response, error) {
 				}
 			}

+			// Not Cloudflare, return original response (recreate body)
 			return &http.Response{
 				Status:     resp.Status,
 				StatusCode: resp.StatusCode,
@@ -145,6 +154,7 @@ func DoRequestWithCloudflareBypass(req *http.Request) (*http.Response, error) {
 		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") ||
@@ -10,6 +10,8 @@ import (
 	"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
 }
@@ -53,6 +55,7 @@ func NewIDHSClient() *IDHSClient {
 	return globalIDHSClient
 }

+// Search converts a music link to links on other platforms
 func (c *IDHSClient) Search(link string, adapters []string) (*IDHSSearchResponse, error) {
 	idhsRateLimiter.WaitForSlot()

@@ -106,6 +109,7 @@ func (c *IDHSClient) Search(link string, adapters []string) (*IDHSSearchResponse
 	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)

@@ -1,43 +1,35 @@
 package gobackend

 import (
-	"bufio"
 	"encoding/json"
 	"fmt"
 	"os"
 	"path/filepath"
-	"strconv"
 	"strings"
 	"sync"
 	"time"
 )

 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"`
-	TotalTracks          int    `json:"totalTracks,omitempty"`
-	DiscNumber           int    `json:"discNumber,omitempty"`
-	TotalDiscs           int    `json:"totalDiscs,omitempty"`
-	Duration             int    `json:"duration,omitempty"`
-	ReleaseDate          string `json:"releaseDate,omitempty"`
-	BitDepth             int    `json:"bitDepth,omitempty"`
-	SampleRate           int    `json:"sampleRate,omitempty"`
-	Bitrate              int    `json:"bitrate,omitempty"` // kbps, for lossy formats (MP3, Opus, Vorbis)
-	Genre                string `json:"genre,omitempty"`
-	Composer             string `json:"composer,omitempty"`
-	Label                string `json:"label,omitempty"`
-	Copyright            string `json:"copyright,omitempty"`
-	Format               string `json:"format,omitempty"`
-	MetadataFromFilename bool   `json:"metadataFromFilename,omitempty"`
+	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"`
+	Bitrate     int    `json:"bitrate,omitempty"` // kbps, for lossy formats (MP3, Opus, Vorbis)
+	Genre       string `json:"genre,omitempty"`
+	Format      string `json:"format,omitempty"`
 }

 type LibraryScanProgress struct {
@@ -71,9 +63,6 @@ var supportedAudioFormats = map[string]bool{
 	".mp3":  true,
 	".opus": true,
 	".ogg":  true,
-	".ape":  true,
-	".wv":   true,
-	".mpc":  true,
 	".cue":  true,
 }

@@ -82,11 +71,6 @@ type libraryAudioFileInfo struct {
 	modTime int64
 }

-type scannedCueFileInfo struct {
-	sheet     *CueSheet
-	audioPath string
-}
-
 func collectLibraryAudioFiles(folderPath string, cancelCh <-chan struct{}) ([]libraryAudioFileInfo, error) {
 	var files []libraryAudioFileInfo

@@ -160,7 +144,12 @@ func ScanLibraryFolder(folderPath string) (string, error) {
 		return "[]", err
 	}

-	totalFiles := len(audioFileInfos)
+	audioFiles := make([]string, 0, len(audioFileInfos))
+	for _, fileInfo := range audioFileInfos {
+		audioFiles = append(audioFiles, fileInfo.path)
+	}
+
+	totalFiles := len(audioFiles)
 	libraryScanProgressMu.Lock()
 	libraryScanProgress.TotalFiles = totalFiles
 	libraryScanProgressMu.Unlock()
@@ -178,29 +167,24 @@ func ScanLibraryFolder(folderPath string) (string, error) {
 	scanTime := time.Now().UTC().Format(time.RFC3339)
 	errorCount := 0

+	// Track audio files referenced by .cue sheets to avoid duplicates
 	cueReferencedAudioFiles := make(map[string]bool)
-	parsedCueFiles := make(map[string]scannedCueFileInfo)

-	for _, fileInfo := range audioFileInfos {
-		filePath := fileInfo.path
+	// First pass: scan .cue files to collect referenced audio paths
+	for _, filePath := range audioFiles {
 		ext := strings.ToLower(filepath.Ext(filePath))
 		if ext == ".cue" {
 			sheet, err := ParseCueFile(filePath)
 			if err == nil && sheet.FileName != "" {
 				audioPath := ResolveCueAudioPath(filePath, sheet.FileName)
 				if audioPath != "" {
-					parsedCueFiles[filePath] = scannedCueFileInfo{
-						sheet:     sheet,
-						audioPath: audioPath,
-					}
 					cueReferencedAudioFiles[audioPath] = true
 				}
 			}
 		}
 	}

-	for i, fileInfo := range audioFileInfos {
-		filePath := fileInfo.path
+	for i, filePath := range audioFiles {
 		select {
 		case <-cancelCh:
 			return "[]", fmt.Errorf("scan cancelled")
@@ -215,22 +199,9 @@ func ScanLibraryFolder(folderPath string) (string, error) {

 		ext := strings.ToLower(filepath.Ext(filePath))

+		// Handle .cue files: produce multiple track results
 		if ext == ".cue" {
-			var cueResults []LibraryScanResult
-			cueInfo, ok := parsedCueFiles[filePath]
-			if ok {
-				cueResults, err = scanCueSheetForLibrary(
-					filePath,
-					cueInfo.sheet,
-					cueInfo.audioPath,
-					"",
-					fileInfo.modTime,
-					"",
-					scanTime,
-				)
-			} else {
-				cueResults, err = ScanCueFileForLibrary(filePath, scanTime)
-			}
+			cueResults, err := ScanCueFileForLibrary(filePath, scanTime)
 			if err != nil {
 				errorCount++
 				GoLog("[LibraryScan] Error scanning cue %s: %v\n", filePath, err)
@@ -241,12 +212,14 @@ func ScanLibraryFolder(folderPath string) (string, error) {
 			continue
 		}

+		// Skip audio files that are referenced by a .cue sheet
+		// (they will be represented by the cue sheet's track entries instead)
 		if cueReferencedAudioFiles[filePath] {
 			GoLog("[LibraryScan] Skipping %s (referenced by .cue sheet)\n", filepath.Base(filePath))
 			continue
 		}

-		result, err := scanAudioFileWithKnownModTime(filePath, scanTime, fileInfo.modTime)
+		result, err := scanAudioFile(filePath, scanTime)
 		if err != nil {
 			errorCount++
 			GoLog("[LibraryScan] Error scanning %s: %v\n", filePath, err)
@@ -272,19 +245,7 @@ func ScanLibraryFolder(folderPath string) (string, error) {
 }

 func scanAudioFile(filePath, scanTime string) (*LibraryScanResult, error) {
-	return scanAudioFileWithKnownModTimeAndDisplayName(filePath, "", scanTime, 0)
-}
-
-func scanAudioFileWithKnownModTime(filePath, scanTime string, knownModTime int64) (*LibraryScanResult, error) {
-	return scanAudioFileWithKnownModTimeAndDisplayNameAndCoverCacheKey(filePath, "", "", scanTime, knownModTime)
-}
-
-func scanAudioFileWithKnownModTimeAndDisplayName(filePath, displayNameHint, scanTime string, knownModTime int64) (*LibraryScanResult, error) {
-	return scanAudioFileWithKnownModTimeAndDisplayNameAndCoverCacheKey(filePath, displayNameHint, "", scanTime, knownModTime)
-}
-
-func scanAudioFileWithKnownModTimeAndDisplayNameAndCoverCacheKey(filePath, displayNameHint, coverCacheKey, scanTime string, knownModTime int64) (*LibraryScanResult, error) {
-	ext := resolveLibraryAudioExt(filePath, displayNameHint)
+	ext := strings.ToLower(filepath.Ext(filePath))

 	result := &LibraryScanResult{
 		ID:        generateLibraryID(filePath),
@@ -293,22 +254,15 @@ func scanAudioFileWithKnownModTimeAndDisplayNameAndCoverCacheKey(filePath, displ
 		Format:    strings.TrimPrefix(ext, "."),
 	}

-	if knownModTime > 0 {
-		result.FileModTime = knownModTime
-	} else if info, err := os.Stat(filePath); err == nil {
+	if info, err := os.Stat(filePath); err == nil {
 		result.FileModTime = info.ModTime().UnixMilli()
 	}

 	libraryCoverCacheMu.RLock()
 	coverCacheDir := libraryCoverCacheDir
 	libraryCoverCacheMu.RUnlock()
-	if coverCacheDir != "" {
-		coverPath, err := SaveCoverToCacheWithHintAndKey(
-			filePath,
-			displayNameHint,
-			coverCacheDir,
-			coverCacheKey,
-		)
+	if coverCacheDir != "" && ext != ".m4a" {
+		coverPath, err := SaveCoverToCache(filePath, coverCacheDir)
 		if err == nil && coverPath != "" {
 			result.CoverPath = coverPath
 		}
@@ -316,39 +270,21 @@ func scanAudioFileWithKnownModTimeAndDisplayNameAndCoverCacheKey(filePath, displ

 	switch ext {
 	case ".flac":
-		return scanFLACFile(filePath, result, displayNameHint)
+		return scanFLACFile(filePath, result)
 	case ".m4a":
-		return scanM4AFile(filePath, result, displayNameHint)
+		return scanM4AFile(filePath, result)
 	case ".mp3":
-		return scanMP3File(filePath, result, displayNameHint)
+		return scanMP3File(filePath, result)
 	case ".opus", ".ogg":
-		return scanOggFile(filePath, result, displayNameHint)
-	case ".ape", ".wv", ".mpc":
-		return scanAPEFile(filePath, result, displayNameHint)
+		return scanOggFile(filePath, result)
 	default:
-		return scanFromFilename(filePath, displayNameHint, result)
+		return scanFromFilename(filePath, result)
 	}
 }

-func resolveLibraryAudioExt(filePath, displayNameHint string) string {
-	ext := strings.ToLower(filepath.Ext(filePath))
-	if ext != "" {
-		return ext
-	}
-	return strings.ToLower(filepath.Ext(displayNameHint))
-}
-
-func libraryDisplayNameOrPath(filePath, displayNameHint string) string {
-	if displayNameHint != "" {
-		return displayNameHint
-	}
-	return filePath
-}
-
-func applyDefaultLibraryMetadata(filePath, displayNameHint string, result *LibraryScanResult) {
-	nameSource := libraryDisplayNameOrPath(filePath, displayNameHint)
+func applyDefaultLibraryMetadata(filePath string, result *LibraryScanResult) {
 	if result.TrackName == "" {
-		result.TrackName = strings.TrimSuffix(filepath.Base(nameSource), filepath.Ext(nameSource))
+		result.TrackName = strings.TrimSuffix(filepath.Base(filePath), filepath.Ext(filePath))
 	}
 	if result.ArtistName == "" {
 		result.ArtistName = "Unknown Artist"
@@ -358,10 +294,10 @@ func applyDefaultLibraryMetadata(filePath, displayNameHint string, result *Libra
 	}
 }

-func scanFLACFile(filePath string, result *LibraryScanResult, displayNameHint string) (*LibraryScanResult, error) {
+func scanFLACFile(filePath string, result *LibraryScanResult) (*LibraryScanResult, error) {
 	metadata, err := ReadMetadata(filePath)
 	if err != nil {
-		return scanFromFilename(filePath, displayNameHint, result)
+		return scanFromFilename(filePath, result)
 	}

 	result.TrackName = metadata.Title
@@ -370,14 +306,9 @@ func scanFLACFile(filePath string, result *LibraryScanResult, displayNameHint st
 	result.AlbumArtist = metadata.AlbumArtist
 	result.ISRC = metadata.ISRC
 	result.TrackNumber = metadata.TrackNumber
-	result.TotalTracks = metadata.TotalTracks
 	result.DiscNumber = metadata.DiscNumber
-	result.TotalDiscs = metadata.TotalDiscs
 	result.ReleaseDate = metadata.Date
 	result.Genre = metadata.Genre
-	result.Composer = metadata.Composer
-	result.Label = metadata.Label
-	result.Copyright = metadata.Copyright

 	quality, err := GetAudioQuality(filePath)
 	if err == nil {
@@ -388,53 +319,26 @@ func scanFLACFile(filePath string, result *LibraryScanResult, displayNameHint st
 		}
 	}

-	applyDefaultLibraryMetadata(filePath, displayNameHint, result)
+	applyDefaultLibraryMetadata(filePath, result)

 	return result, nil
 }

-func scanM4AFile(filePath string, result *LibraryScanResult, displayNameHint string) (*LibraryScanResult, error) {
-	metadata, err := ReadM4ATags(filePath)
-	if err != nil {
-		GoLog("[LibraryScan] M4A read error for %s: %v\n", filePath, err)
-		return scanFromFilename(filePath, displayNameHint, result)
-	}
-
-	if metadata != nil {
-		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.TotalTracks = metadata.TotalTracks
-		result.DiscNumber = metadata.DiscNumber
-		result.TotalDiscs = metadata.TotalDiscs
-		result.ReleaseDate = metadata.Date
-		if result.ReleaseDate == "" {
-			result.ReleaseDate = metadata.Year
-		}
-		result.Genre = metadata.Genre
-		result.Composer = metadata.Composer
-		result.Label = metadata.Label
-		result.Copyright = metadata.Copyright
-	}
-
+func scanM4AFile(filePath string, result *LibraryScanResult) (*LibraryScanResult, error) {
 	quality, err := GetM4AQuality(filePath)
 	if err == nil {
 		result.BitDepth = quality.BitDepth
 		result.SampleRate = quality.SampleRate
 	}

-	applyDefaultLibraryMetadata(filePath, displayNameHint, result)
-	return result, nil
+	return scanFromFilename(filePath, result)
 }

-func scanMP3File(filePath string, result *LibraryScanResult, displayNameHint string) (*LibraryScanResult, error) {
+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, displayNameHint, result)
+		return scanFromFilename(filePath, result)
 	}

 	result.TrackName = metadata.Title
@@ -442,9 +346,7 @@ func scanMP3File(filePath string, result *LibraryScanResult, displayNameHint str
 	result.AlbumName = metadata.Album
 	result.AlbumArtist = metadata.AlbumArtist
 	result.TrackNumber = metadata.TrackNumber
-	result.TotalTracks = metadata.TotalTracks
 	result.DiscNumber = metadata.DiscNumber
-	result.TotalDiscs = metadata.TotalDiscs
 	result.Genre = metadata.Genre
 	if metadata.Date != "" {
 		result.ReleaseDate = metadata.Date
@@ -452,9 +354,6 @@ func scanMP3File(filePath string, result *LibraryScanResult, displayNameHint str
 		result.ReleaseDate = metadata.Year
 	}
 	result.ISRC = metadata.ISRC
-	result.Composer = metadata.Composer
-	result.Label = metadata.Label
-	result.Copyright = metadata.Copyright

 	quality, err := GetMP3Quality(filePath)
 	if err == nil {
@@ -466,16 +365,16 @@ func scanMP3File(filePath string, result *LibraryScanResult, displayNameHint str
 		}
 	}

-	applyDefaultLibraryMetadata(filePath, displayNameHint, result)
+	applyDefaultLibraryMetadata(filePath, result)

 	return result, nil
 }

-func scanOggFile(filePath string, result *LibraryScanResult, displayNameHint string) (*LibraryScanResult, error) {
+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, displayNameHint, result)
+		return scanFromFilename(filePath, result)
 	}

 	result.TrackName = metadata.Title
@@ -484,14 +383,9 @@ func scanOggFile(filePath string, result *LibraryScanResult, displayNameHint str
 	result.AlbumArtist = metadata.AlbumArtist
 	result.ISRC = metadata.ISRC
 	result.TrackNumber = metadata.TrackNumber
-	result.TotalTracks = metadata.TotalTracks
 	result.DiscNumber = metadata.DiscNumber
-	result.TotalDiscs = metadata.TotalDiscs
 	result.Genre = metadata.Genre
 	result.ReleaseDate = metadata.Date
-	result.Composer = metadata.Composer
-	result.Label = metadata.Label
-	result.Copyright = metadata.Copyright

 	quality, err := GetOggQuality(filePath)
 	if err == nil {
@@ -503,51 +397,13 @@ func scanOggFile(filePath string, result *LibraryScanResult, displayNameHint str
 		}
 	}

-	applyDefaultLibraryMetadata(filePath, displayNameHint, result)
+	applyDefaultLibraryMetadata(filePath, result)

 	return result, nil
 }

-func scanAPEFile(filePath string, result *LibraryScanResult, displayNameHint string) (*LibraryScanResult, error) {
-	tag, err := ReadAPETags(filePath)
-	if err != nil {
-		GoLog("[LibraryScan] APE tag read error for %s: %v\n", filePath, err)
-		return scanFromFilename(filePath, displayNameHint, result)
-	}
-
-	metadata := APETagToAudioMetadata(tag)
-	if metadata == nil {
-		return scanFromFilename(filePath, displayNameHint, 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.TotalTracks = metadata.TotalTracks
-	result.DiscNumber = metadata.DiscNumber
-	result.TotalDiscs = metadata.TotalDiscs
-	result.Genre = metadata.Genre
-	if metadata.Date != "" {
-		result.ReleaseDate = metadata.Date
-	} else {
-		result.ReleaseDate = metadata.Year
-	}
-	result.Composer = metadata.Composer
-	result.Label = metadata.Label
-	result.Copyright = metadata.Copyright
-
-	applyDefaultLibraryMetadata(filePath, displayNameHint, result)
-
-	return result, nil
-}
-
-func scanFromFilename(filePath, displayNameHint string, result *LibraryScanResult) (*LibraryScanResult, error) {
-	result.MetadataFromFilename = true
-	nameSource := libraryDisplayNameOrPath(filePath, displayNameHint)
-	filename := strings.TrimSuffix(filepath.Base(nameSource), filepath.Ext(nameSource))
+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 {
@@ -570,7 +426,7 @@ func scanFromFilename(filePath, displayNameHint string, result *LibraryScanResul

 	dir := filepath.Dir(filePath)
 	result.AlbumName = filepath.Base(dir)
-	if result.AlbumName == "." || result.AlbumName == "" || result.AlbumName == "fd" || result.AlbumName == "self" {
+	if result.AlbumName == "." || result.AlbumName == "" {
 		result.AlbumName = "Unknown Album"
 	}

@@ -617,22 +473,8 @@ func CancelLibraryScan() {
 }

 func ReadAudioMetadata(filePath string) (string, error) {
-	return ReadAudioMetadataWithDisplayName(filePath, "")
-}
-
-func ReadAudioMetadataWithDisplayName(filePath, displayNameHint string) (string, error) {
-	return ReadAudioMetadataWithDisplayNameAndCoverCacheKey(filePath, displayNameHint, "")
-}
-
-func ReadAudioMetadataWithDisplayNameAndCoverCacheKey(filePath, displayNameHint, coverCacheKey string) (string, error) {
 	scanTime := time.Now().UTC().Format(time.RFC3339)
-	result, err := scanAudioFileWithKnownModTimeAndDisplayNameAndCoverCacheKey(
-		filePath,
-		displayNameHint,
-		coverCacheKey,
-		scanTime,
-		0,
-	)
+	result, err := scanAudioFile(filePath, scanTime)
 	if err != nil {
 		return "", err
 	}
@@ -645,43 +487,10 @@ func ReadAudioMetadataWithDisplayNameAndCoverCacheKey(filePath, displayNameHint,
 	return string(jsonBytes), nil
 }

-func loadExistingFilesSnapshot(snapshotPath string) (map[string]int64, error) {
-	existingFiles := make(map[string]int64)
-	if snapshotPath == "" {
-		return existingFiles, nil
-	}
-
-	file, err := os.Open(snapshotPath)
-	if err != nil {
-		return nil, err
-	}
-	defer file.Close()
-
-	scanner := bufio.NewScanner(file)
-	for scanner.Scan() {
-		line := scanner.Text()
-		if line == "" {
-			continue
-		}
-		parts := strings.SplitN(line, "\t", 2)
-		if len(parts) != 2 {
-			continue
-		}
-		modTime, err := strconv.ParseInt(parts[0], 10, 64)
-		if err != nil {
-			continue
-		}
-		existingFiles[parts[1]] = modTime
-	}
-
-	if err := scanner.Err(); err != nil {
-		return nil, err
-	}
-
-	return existingFiles, nil
-}
-
-func scanLibraryFolderIncrementalWithExistingFiles(folderPath string, existingFiles map[string]int64) (string, error) {
+// 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")
 	}
@@ -694,6 +503,13 @@ func scanLibraryFolderIncrementalWithExistingFiles(folderPath string, existingFi
 		return "{}", fmt.Errorf("path is not a folder: %s", folderPath)
 	}

+	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))

 	libraryScanProgressMu.Lock()
@@ -722,27 +538,44 @@ func scanLibraryFolderIncrementalWithExistingFiles(folderPath string, existingFi
 	libraryScanProgress.TotalFiles = totalFiles
 	libraryScanProgressMu.Unlock()

+	// Find files to scan (new or modified)
 	var filesToScan []libraryAudioFileInfo
 	skippedCount := 0
-	existingCueTrackModTimes := make(map[string]int64)
-	for existingPath, modTime := range existingFiles {
-		if idx := strings.LastIndex(existingPath, "#track"); idx > 0 {
-			baseCuePath := existingPath[:idx]
-			if _, exists := existingCueTrackModTimes[baseCuePath]; !exists {
-				existingCueTrackModTimes[baseCuePath] = modTime
-			}
+
+	// Build a set of existing CUE virtual path base files for incremental matching.
+	// CUE tracks are stored with virtual paths like "/path/album.cue#track01".
+	// We need to match these against the actual .cue file's modTime.
+	cueBaseModTimes := make(map[string]int64) // base cue path -> modTime from disk
+	for _, f := range currentFiles {
+		if strings.ToLower(filepath.Ext(f.path)) == ".cue" {
+			cueBaseModTimes[f.path] = f.modTime
 		}
 	}

 	for _, f := range currentFiles {
 		existingModTime, exists := existingFiles[f.path]
 		if !exists {
+			// For .cue files, also check if any virtual path entries exist
 			if strings.ToLower(filepath.Ext(f.path)) == ".cue" {
-				if cueTrackModTime, hasCueTracks := existingCueTrackModTimes[f.path]; hasCueTracks {
-					if f.modTime == cueTrackModTime {
-						skippedCount++
-					} else {
-						filesToScan = append(filesToScan, f)
+				hasCueTracks := false
+				for existingPath := range existingFiles {
+					if strings.HasPrefix(existingPath, f.path+"#track") {
+						hasCueTracks = true
+						break
+					}
+				}
+				if hasCueTracks {
+					// CUE file exists in DB via virtual paths; check if modTime changed
+					// Use modTime from any virtual path (they all share the same .cue modTime)
+					for existingPath, modTime := range existingFiles {
+						if strings.HasPrefix(existingPath, f.path+"#track") {
+							if f.modTime == modTime {
+								skippedCount++
+							} else {
+								filesToScan = append(filesToScan, f)
+							}
+							break
+						}
 					}
 					continue
 				}
@@ -757,11 +590,14 @@ func scanLibraryFolderIncrementalWithExistingFiles(folderPath string, existingFi

 	var deletedPaths []string
 	for existingPath := range existingFiles {
+		// For CUE virtual paths (e.g. "/path/album.cue#track01"),
+		// check if the base .cue file still exists on disk
 		if idx := strings.LastIndex(existingPath, "#track"); idx > 0 {
 			baseCuePath := existingPath[:idx]
 			if currentPathSet[baseCuePath] {
-				continue
+				continue // Base .cue file still exists, not deleted
 			}
+			// Base CUE file is gone, mark virtual path as deleted
 			deletedPaths = append(deletedPaths, existingPath)
 		} else if !currentPathSet[existingPath] {
 			deletedPaths = append(deletedPaths, existingPath)
@@ -792,8 +628,8 @@ func scanLibraryFolderIncrementalWithExistingFiles(folderPath string, existingFi
 	scanTime := time.Now().UTC().Format(time.RFC3339)
 	errorCount := 0

+	// Track audio files referenced by .cue sheets to avoid duplicates (incremental)
 	cueReferencedAudioFilesInc := make(map[string]bool)
-	parsedCueFiles := make(map[string]scannedCueFileInfo)
 	for _, f := range filesToScan {
 		ext := strings.ToLower(filepath.Ext(f.path))
 		if ext == ".cue" {
@@ -801,10 +637,6 @@ func scanLibraryFolderIncrementalWithExistingFiles(folderPath string, existingFi
 			if err == nil && sheet.FileName != "" {
 				audioPath := ResolveCueAudioPath(f.path, sheet.FileName)
 				if audioPath != "" {
-					parsedCueFiles[f.path] = scannedCueFileInfo{
-						sheet:     sheet,
-						audioPath: audioPath,
-					}
 					cueReferencedAudioFilesInc[audioPath] = true
 				}
 			}
@@ -826,22 +658,9 @@ func scanLibraryFolderIncrementalWithExistingFiles(folderPath string, existingFi

 		ext := strings.ToLower(filepath.Ext(f.path))

+		// Handle .cue files: produce multiple track results
 		if ext == ".cue" {
-			var cueResults []LibraryScanResult
-			cueInfo, ok := parsedCueFiles[f.path]
-			if ok {
-				cueResults, err = scanCueSheetForLibrary(
-					f.path,
-					cueInfo.sheet,
-					cueInfo.audioPath,
-					"",
-					f.modTime,
-					"",
-					scanTime,
-				)
-			} else {
-				cueResults, err = ScanCueFileForLibrary(f.path, scanTime)
-			}
+			cueResults, err := ScanCueFileForLibrary(f.path, scanTime)
 			if err != nil {
 				errorCount++
 				GoLog("[LibraryScan] Error scanning cue %s: %v\n", f.path, err)
@@ -851,11 +670,12 @@ func scanLibraryFolderIncrementalWithExistingFiles(folderPath string, existingFi
 			continue
 		}

+		// Skip audio files referenced by .cue sheets
 		if cueReferencedAudioFilesInc[f.path] {
 			continue
 		}

-		result, err := scanAudioFileWithKnownModTime(f.path, scanTime, f.modTime)
+		result, err := scanAudioFile(f.path, scanTime)
 		if err != nil {
 			errorCount++
 			GoLog("[LibraryScan] Error scanning %s: %v\n", f.path, err)
@@ -889,21 +709,3 @@ func scanLibraryFolderIncrementalWithExistingFiles(folderPath string, existingFi

 	return string(jsonBytes), nil
 }
-
-func ScanLibraryFolderIncremental(folderPath, existingFilesJSON string) (string, error) {
-	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)
-		}
-	}
-	return scanLibraryFolderIncrementalWithExistingFiles(folderPath, existingFiles)
-}
-
-func ScanLibraryFolderIncrementalFromSnapshot(folderPath, snapshotPath string) (string, error) {
-	existingFiles, err := loadExistingFilesSnapshot(snapshotPath)
-	if err != nil {
-		return "{}", fmt.Errorf("failed to load incremental snapshot: %w", err)
-	}
-	return scanLibraryFolderIncrementalWithExistingFiles(folderPath, existingFiles)
-}
@@ -1,25 +0,0 @@
-package gobackend
-
-import "testing"
-
-func TestScanFromFilenameMarksMetadataFallback(t *testing.T) {
-	result := &LibraryScanResult{}
-
-	scanned, err := scanFromFilename(
-		"/proc/self/fd/209",
-		"189.mp3",
-		result,
-	)
-	if err != nil {
-		t.Fatalf("scanFromFilename returned error: %v", err)
-	}
-	if !scanned.MetadataFromFilename {
-		t.Fatal("expected filename fallback marker to be set")
-	}
-	if scanned.TrackName != "189" {
-		t.Fatalf("unexpected track name: %q", scanned.TrackName)
-	}
-	if scanned.ArtistName != "Unknown Artist" {
-		t.Fatalf("unexpected artist name: %q", scanned.ArtistName)
-	}
-}
@@ -25,6 +25,7 @@ type LogBuffer struct {

 const (
 	defaultLogBufferSize = 500
+	maxLogMessageLength  = 500
 )

 var (
@@ -51,12 +52,20 @@ func GetLogBuffer() *LogBuffer {
 		globalLogBuffer = &LogBuffer{
 			entries:        make([]LogEntry, 0, defaultLogBufferSize),
 			maxSize:        defaultLogBufferSize,
-			loggingEnabled: false,
+			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()
@@ -78,6 +87,7 @@ func (lb *LogBuffer) Add(level, tag, message string) {
 	}

 	message = sanitizeSensitiveLogText(message)
+	message = truncateLogMessage(message)

 	entry := LogEntry{
 		Timestamp: time.Now().Format("15:04:05.000"),
@@ -145,10 +155,13 @@ func LogError(tag, format string, args ...interface{}) {
 	GetLogBuffer().Add("ERROR", tag, fmt.Sprintf(format, args...))
 }

+// GoLog is a drop-in replacement for fmt.Printf that also logs to buffer
+// It parses the tag from the format string if it starts with [Tag]
 func GoLog(format string, args ...interface{}) {
 	message := fmt.Sprintf(format, args...)
 	message = strings.TrimSuffix(message, "\n")

+	// Extract tag from message if present (e.g., "[Tidal] message")
 	tag := "Go"
 	level := "INFO"

@@ -160,6 +173,7 @@ func GoLog(format string, args ...interface{}) {
 		}
 	}

+	// Determine level from message content
 	msgLower := strings.ToLower(message)
 	if strings.Contains(msgLower, "error") || strings.Contains(msgLower, "failed") {
 		level = "ERROR"
@@ -20,7 +20,9 @@ const (
 	durationToleranceSec = 10.0
 )

+// Lyrics provider names (used in settings and cascade ordering)
 const (
+	LyricsProviderSpotifyAPI = "spotify_api"
 	LyricsProviderLRCLIB     = "lrclib"
 	LyricsProviderNetease    = "netease"
 	LyricsProviderMusixmatch = "musixmatch"
@@ -28,8 +30,11 @@ const (
 	LyricsProviderQQMusic    = "qqmusic"
 )

+// DefaultLyricsProviders is the default cascade order for lyrics fetching.
+// LRCLIB first (no proxy dependency), then the others.
 var DefaultLyricsProviders = []string{
 	LyricsProviderLRCLIB,
+	LyricsProviderSpotifyAPI,
 	LyricsProviderMusixmatch,
 	LyricsProviderNetease,
 	LyricsProviderAppleMusic,
@@ -41,6 +46,12 @@ var (
 	lyricsProviders   []string // ordered list of enabled providers
 )

+var (
+	spotifyLyricsRateLimitMu    sync.RWMutex
+	spotifyLyricsRateLimitedTil time.Time
+)
+
+// LyricsFetchOptions controls optional provider-specific enhancements.
 type LyricsFetchOptions struct {
 	IncludeTranslationNetease  bool   `json:"include_translation_netease"`
 	IncludeRomanizationNetease bool   `json:"include_romanization_netease"`
@@ -60,6 +71,8 @@ var (
 	lyricsFetchOptions   = defaultLyricsFetchOptions
 )

+// SetLyricsProviderOrder sets the ordered list of lyrics providers to try.
+// Providers not in the list are disabled. An empty list resets to defaults.
 func SetLyricsProviderOrder(providers []string) {
 	lyricsProvidersMu.Lock()
 	defer lyricsProvidersMu.Unlock()
@@ -69,7 +82,9 @@ func SetLyricsProviderOrder(providers []string) {
 		return
 	}

+	// Validate provider names
 	validNames := map[string]bool{
+		LyricsProviderSpotifyAPI: true,
 		LyricsProviderLRCLIB:     true,
 		LyricsProviderNetease:    true,
 		LyricsProviderMusixmatch: true,
@@ -89,6 +104,7 @@ func SetLyricsProviderOrder(providers []string) {
 	GoLog("[Lyrics] Provider order set to: %v\n", valid)
 }

+// GetLyricsProviderOrder returns the current lyrics provider order.
 func GetLyricsProviderOrder() []string {
 	lyricsProvidersMu.RLock()
 	defer lyricsProvidersMu.RUnlock()
@@ -102,13 +118,15 @@ func GetLyricsProviderOrder() []string {
 	return result
 }

+// GetAvailableLyricsProviders returns metadata about all available providers.
 func GetAvailableLyricsProviders() []map[string]interface{} {
 	return []map[string]interface{}{
+		{"id": LyricsProviderSpotifyAPI, "name": "Spotify Lyrics API", "has_proxy_dependency": true, "description": "Spotify-sourced synced lyrics via community API"},
 		{"id": LyricsProviderLRCLIB, "name": "LRCLIB", "has_proxy_dependency": false, "description": "Open-source synced lyrics database"},
-		{"id": LyricsProviderNetease, "name": "Netease", "has_proxy_dependency": true, "description": "NetEase Cloud Music lyrics via Paxsenix"},
-		{"id": LyricsProviderMusixmatch, "name": "Musixmatch", "has_proxy_dependency": true, "description": "Musixmatch lyrics via Paxsenix"},
-		{"id": LyricsProviderAppleMusic, "name": "Apple Music", "has_proxy_dependency": true, "description": "Apple Music synced lyrics via Paxsenix"},
-		{"id": LyricsProviderQQMusic, "name": "QQ Music", "has_proxy_dependency": true, "description": "QQ Music lyrics via Paxsenix"},
+		{"id": LyricsProviderNetease, "name": "Netease", "has_proxy_dependency": false, "description": "NetEase Cloud Music (good for Asian songs)"},
+		{"id": LyricsProviderMusixmatch, "name": "Musixmatch", "has_proxy_dependency": true, "description": "Largest lyrics database (multi-language)"},
+		{"id": LyricsProviderAppleMusic, "name": "Apple Music", "has_proxy_dependency": true, "description": "Word-by-word synced lyrics"},
+		{"id": LyricsProviderQQMusic, "name": "QQ Music", "has_proxy_dependency": true, "description": "QQ Music lyrics (good for Chinese songs)"},
 	}
 }

@@ -121,6 +139,7 @@ func normalizeLyricsFetchOptions(opts LyricsFetchOptions) LyricsFetchOptions {
 	return opts
 }

+// SetLyricsFetchOptions sets provider-specific lyric fetch behavior.
 func SetLyricsFetchOptions(opts LyricsFetchOptions) {
 	normalized := normalizeLyricsFetchOptions(opts)

@@ -136,6 +155,7 @@ func SetLyricsFetchOptions(opts LyricsFetchOptions) {
 	)
 }

+// GetLyricsFetchOptions returns current provider-specific lyric fetch behavior.
 func GetLyricsFetchOptions() LyricsFetchOptions {
 	lyricsFetchOptionsMu.RLock()
 	defer lyricsFetchOptionsMu.RUnlock()
@@ -233,6 +253,18 @@ type LRCLibResponse struct {
 	SyncedLyrics string  `json:"syncedLyrics"`
 }

+type SpotifyLyricsLine struct {
+	TimeTag string `json:"timeTag"`
+	Words   string `json:"words"`
+}
+
+type SpotifyLyricsAPIResponse struct {
+	Error    bool                `json:"error"`
+	Message  string              `json:"message"`
+	SyncType string              `json:"syncType"`
+	Lines    []SpotifyLyricsLine `json:"lines"`
+}
+
 type LyricsLine struct {
 	StartTimeMs int64  `json:"startTimeMs"`
 	Words       string `json:"words"`
@@ -340,6 +372,172 @@ func (c *LyricsClient) FetchLyricsFromLRCLibSearch(query string, durationSec flo
 	return c.parseLRCLibResponse(&results[0]), nil
 }

+func parseSpotifyLyricsTimeTagToMs(tag string) int64 {
+	raw := strings.TrimSpace(tag)
+	raw = strings.TrimPrefix(raw, "[")
+	raw = strings.TrimSuffix(raw, "]")
+	if raw == "" {
+		return 0
+	}
+
+	if ms, err := strconv.ParseInt(raw, 10, 64); err == nil {
+		return ms
+	}
+
+	re := regexp.MustCompile(`^(\d{1,2}):(\d{2})\.(\d{1,3})$`)
+	matches := re.FindStringSubmatch(raw)
+	if len(matches) != 4 {
+		return 0
+	}
+
+	minutes, _ := strconv.ParseInt(matches[1], 10, 64)
+	seconds, _ := strconv.ParseInt(matches[2], 10, 64)
+	fraction := matches[3]
+	fractionInt, _ := strconv.ParseInt(fraction, 10, 64)
+	if len(fraction) == 2 {
+		fractionInt *= 10
+	} else if len(fraction) == 1 {
+		fractionInt *= 100
+	}
+	return minutes*60*1000 + seconds*1000 + fractionInt
+}
+
+func getSpotifyLyricsRateLimitUntil() time.Time {
+	spotifyLyricsRateLimitMu.RLock()
+	defer spotifyLyricsRateLimitMu.RUnlock()
+	return spotifyLyricsRateLimitedTil
+}
+
+func setSpotifyLyricsRateLimitUntil(until time.Time) {
+	spotifyLyricsRateLimitMu.Lock()
+	spotifyLyricsRateLimitedTil = until
+	spotifyLyricsRateLimitMu.Unlock()
+}
+
+func parseSpotifyRetryAfter(retryAfter string, now time.Time) time.Time {
+	raw := strings.TrimSpace(retryAfter)
+	if raw == "" {
+		return now.Add(10 * time.Minute)
+	}
+
+	if sec, err := strconv.Atoi(raw); err == nil && sec > 0 {
+		return now.Add(time.Duration(sec) * time.Second)
+	}
+
+	if when, err := http.ParseTime(raw); err == nil && when.After(now) {
+		return when
+	}
+
+	return now.Add(10 * time.Minute)
+}
+
+func (c *LyricsClient) FetchLyricsFromSpotifyAPI(spotifyID string) (*LyricsResponse, error) {
+	now := time.Now()
+	if limitedUntil := getSpotifyLyricsRateLimitUntil(); limitedUntil.After(now) {
+		waitFor := int(math.Ceil(limitedUntil.Sub(now).Seconds()))
+		return nil, fmt.Errorf(
+			"Spotify Lyrics API cooldown active (%ds remaining after previous 429)",
+			waitFor,
+		)
+	}
+
+	spotifyID = strings.TrimSpace(spotifyID)
+	if spotifyID == "" {
+		return nil, fmt.Errorf("spotify ID is empty")
+	}
+	if parsed, err := parseSpotifyURI(spotifyID); err == nil && parsed.Type == "track" && parsed.ID != "" {
+		spotifyID = parsed.ID
+	}
+
+	apiURL := fmt.Sprintf("https://spotify-lyrics-api-pi.vercel.app/?trackid=%s&format=lrc", url.QueryEscape(spotifyID))
+	req, err := http.NewRequest("GET", apiURL, nil)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create request: %w", err)
+	}
+	req.Header.Set("User-Agent", getRandomUserAgent())
+
+	resp, err := c.httpClient.Do(req)
+	if err != nil {
+		return nil, fmt.Errorf("failed to fetch from Spotify Lyrics API: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != 200 {
+		if resp.StatusCode == http.StatusTooManyRequests {
+			retryUntil := parseSpotifyRetryAfter(resp.Header.Get("Retry-After"), now)
+			setSpotifyLyricsRateLimitUntil(retryUntil)
+		}
+		var payload map[string]interface{}
+		if err := json.NewDecoder(resp.Body).Decode(&payload); err == nil {
+			if msg, ok := payload["message"].(string); ok && strings.TrimSpace(msg) != "" {
+				return nil, fmt.Errorf("Spotify Lyrics API returned status %d: %s", resp.StatusCode, strings.TrimSpace(msg))
+			}
+			if msg, ok := payload["error"].(string); ok && strings.TrimSpace(msg) != "" {
+				return nil, fmt.Errorf("Spotify Lyrics API returned status %d: %s", resp.StatusCode, strings.TrimSpace(msg))
+			}
+		}
+		return nil, fmt.Errorf("Spotify Lyrics API returned status %d", resp.StatusCode)
+	}
+
+	var apiResp SpotifyLyricsAPIResponse
+	if err := json.NewDecoder(resp.Body).Decode(&apiResp); err != nil {
+		return nil, fmt.Errorf("failed to parse Spotify Lyrics API response: %w", err)
+	}
+
+	if apiResp.Error {
+		msg := strings.TrimSpace(apiResp.Message)
+		if msg == "" {
+			msg = "Spotify Lyrics API returned error"
+		}
+		return nil, fmt.Errorf("%s", msg)
+	}
+
+	result := &LyricsResponse{
+		Lines:        make([]LyricsLine, 0, len(apiResp.Lines)),
+		SyncType:     apiResp.SyncType,
+		Instrumental: false,
+		PlainLyrics:  "",
+		Provider:     "Spotify Lyrics API",
+		Source:       "Spotify Lyrics API",
+	}
+
+	for _, line := range apiResp.Lines {
+		words := strings.TrimSpace(line.Words)
+		if words == "" {
+			continue
+		}
+		startMs := parseSpotifyLyricsTimeTagToMs(line.TimeTag)
+		result.Lines = append(result.Lines, LyricsLine{
+			StartTimeMs: startMs,
+			Words:       words,
+			EndTimeMs:   0,
+		})
+	}
+
+	if len(result.Lines) > 1 {
+		for i := 0; i < len(result.Lines)-1; i++ {
+			nextStart := result.Lines[i+1].StartTimeMs
+			if nextStart > result.Lines[i].StartTimeMs {
+				result.Lines[i].EndTimeMs = nextStart
+			}
+		}
+		last := len(result.Lines) - 1
+		if result.Lines[last].EndTimeMs == 0 {
+			result.Lines[last].EndTimeMs = result.Lines[last].StartTimeMs + 5000
+		}
+	}
+
+	if len(result.Lines) == 0 {
+		return nil, fmt.Errorf("Spotify Lyrics API returned empty lines")
+	}
+
+	if result.SyncType == "" {
+		result.SyncType = "LINE_SYNCED"
+	}
+
+	return result, nil
+}
+
 func (c *LyricsClient) findBestMatch(results []LRCLibResponse, targetDurationSec float64) *LRCLibResponse {
 	var bestSynced *LRCLibResponse
 	var bestPlain *LRCLibResponse
@@ -364,18 +562,6 @@ func (c *LyricsClient) findBestMatch(results []LRCLibResponse, targetDurationSec
 	return bestPlain
 }

-func plainLyricsFromTimedLines(lines []LyricsLine) string {
-	parts := make([]string, 0, len(lines))
-	for _, line := range lines {
-		words := strings.TrimSpace(line.Words)
-		if words == "" {
-			continue
-		}
-		parts = append(parts, words)
-	}
-	return strings.Join(parts, "\n")
-}
-
 func (c *LyricsClient) durationMatches(lrcDuration, targetDuration float64) bool {
 	diff := math.Abs(lrcDuration - targetDuration)
 	return diff <= durationToleranceSec
@@ -385,8 +571,8 @@ func (c *LyricsClient) FetchLyricsAllSources(spotifyID, trackName, artistName st
 	primaryArtist := normalizeArtistName(artistName)
 	fetchOptions := GetLyricsFetchOptions()

-	extManager := getExtensionManager()
-	var extensionProviders []*extensionProviderWrapper
+	extManager := GetExtensionManager()
+	var extensionProviders []*ExtensionProviderWrapper
 	if extManager != nil {
 		extensionProviders = extManager.GetLyricsProviders()
 	}
@@ -438,6 +624,7 @@ func (c *LyricsClient) FetchLyricsAllSources(spotifyID, trackName, artistName st

 	GoLog("[Lyrics] Searching for: %s - %s (providers: %v)\n", artistName, trackName, providerOrder)

+	// Cascade through all configured built-in providers
 	for _, providerName := range providerOrder {
 		GoLog("[Lyrics] Trying provider: %s\n", providerName)

@@ -445,6 +632,9 @@ func (c *LyricsClient) FetchLyricsAllSources(spotifyID, trackName, artistName st
 		var err error

 		switch providerName {
+		case LyricsProviderSpotifyAPI:
+			lyrics, err = c.FetchLyricsFromSpotifyAPI(spotifyID)
+
 		case LyricsProviderLRCLIB:
 			lyrics, err = c.tryLRCLIB(primaryArtist, artistName, trackName, simplifiedTrack, durationSec)

@@ -526,16 +716,19 @@ func (c *LyricsClient) FetchLyricsAllSources(spotifyID, trackName, artistName st
 	return nil, fmt.Errorf("lyrics not found from any source")
 }

+// tryLRCLIB attempts all LRCLIB search strategies (exact match, simplified, search).
 func (c *LyricsClient) tryLRCLIB(primaryArtist, artistName, trackName, simplifiedTrack string, durationSec float64) (*LyricsResponse, error) {
 	var lyrics *LyricsResponse
 	var err error

+	// 1. Exact match with primary artist
 	lyrics, err = c.FetchLyricsWithMetadata(primaryArtist, trackName)
 	if err == nil && lyrics != nil && (len(lyrics.Lines) > 0 || lyrics.Instrumental) {
 		lyrics.Source = "LRCLIB"
 		return lyrics, nil
 	}

+	// 2. Exact match with full artist name
 	if primaryArtist != artistName {
 		lyrics, err = c.FetchLyricsWithMetadata(artistName, trackName)
 		if err == nil && lyrics != nil && (len(lyrics.Lines) > 0 || lyrics.Instrumental) {
@@ -544,6 +737,7 @@ func (c *LyricsClient) tryLRCLIB(primaryArtist, artistName, trackName, simplifie
 		}
 	}

+	// 3. Simplified track name
 	if simplifiedTrack != trackName {
 		lyrics, err = c.FetchLyricsWithMetadata(primaryArtist, simplifiedTrack)
 		if err == nil && lyrics != nil && (len(lyrics.Lines) > 0 || lyrics.Instrumental) {
@@ -552,6 +746,7 @@ func (c *LyricsClient) tryLRCLIB(primaryArtist, artistName, trackName, simplifie
 		}
 	}

+	// 4. Search by query
 	query := primaryArtist + " " + trackName
 	lyrics, err = c.FetchLyricsFromLRCLibSearch(query, durationSec)
 	if err == nil && lyrics != nil && (len(lyrics.Lines) > 0 || lyrics.Instrumental) {
@@ -559,6 +754,7 @@ func (c *LyricsClient) tryLRCLIB(primaryArtist, artistName, trackName, simplifie
 		return lyrics, nil
 	}

+	// 5. Search with simplified track name
 	if simplifiedTrack != trackName {
 		query = primaryArtist + " " + simplifiedTrack
 		lyrics, err = c.FetchLyricsFromLRCLibSearch(query, durationSec)
@@ -676,6 +872,8 @@ func lyricsHasUsableText(lyrics *LyricsResponse) bool {
 	return false
 }

+// detectLyricsErrorPayload extracts human-readable error messages from
+// JSON payloads returned by lyrics proxies when no lyric is available.
 func detectLyricsErrorPayload(raw string) (string, bool) {
 	trimmed := strings.TrimSpace(raw)
 	if trimmed == "" || !strings.HasPrefix(trimmed, "{") {
@@ -747,7 +945,7 @@ func convertToLRCWithMetadata(lyrics *LyricsResponse, trackName, artistName stri

 	builder.WriteString(fmt.Sprintf("[ti:%s]\n", trackName))
 	builder.WriteString(fmt.Sprintf("[ar:%s]\n", artistName))
-	builder.WriteString("[by:Implemented by SpotiFLAC-Mobile using Paxsenix API]\n")
+	builder.WriteString("[by:SpotiFLAC-Mobile]\n")
 	builder.WriteString("\n")

 	if lyrics.SyncType == "LINE_SYNCED" {
@@ -800,6 +998,8 @@ func simplifyTrackName(name string) string {
 		return result
 	}

+	// Add a loose fallback form for provider queries where punctuation
+	// and separators differ (e.g. "/" vs "_" vs spaces).
 	if loose := normalizeLooseTitle(result); loose != "" {
 		return loose
 	}
@@ -4,25 +4,124 @@ import (
 	"encoding/json"
 	"fmt"
 	"io"
-	"math"
 	"net/http"
 	"net/url"
+	"regexp"
 	"strings"
+	"sync"
 	"time"
 )

+// AppleMusicClient fetches lyrics from Apple Music.
+// Uses a scraped JWT token for search and a proxy for lyrics.
 type AppleMusicClient struct {
 	httpClient *http.Client
 }

-type appleMusicSearchResult struct {
-	ID         string `json:"id"`
-	SongName   string `json:"songName"`
-	ArtistName string `json:"artistName"`
-	AlbumName  string `json:"albumName"`
-	Duration   int    `json:"duration"`
+// Apple Music token manager — singleton with mutex for thread safety
+type appleTokenManager struct {
+	mu    sync.Mutex
+	token string
 }

+var globalAppleTokenManager = &appleTokenManager{}
+
+func (m *appleTokenManager) getToken(client *http.Client) (string, error) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	if m.token != "" {
+		return m.token, nil
+	}
+
+	// Step 1: Fetch the Apple Music beta page
+	req, err := http.NewRequest("GET", "https://beta.music.apple.com", nil)
+	if err != nil {
+		return "", fmt.Errorf("failed to create request: %w", err)
+	}
+	req.Header.Set("User-Agent", getRandomUserAgent())
+
+	resp, err := client.Do(req)
+	if err != nil {
+		return "", fmt.Errorf("failed to fetch Apple Music page: %w", err)
+	}
+	defer resp.Body.Close()
+
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return "", fmt.Errorf("failed to read Apple Music page: %w", err)
+	}
+
+	// Step 2: Find the index JS file URL
+	indexJsRegex := regexp.MustCompile(`/assets/index~[^/]+\.js`)
+	match := indexJsRegex.Find(body)
+	if match == nil {
+		return "", fmt.Errorf("could not find index JS script URL on Apple Music page")
+	}
+
+	indexJsURL := "https://beta.music.apple.com" + string(match)
+
+	// Step 3: Fetch the JS file
+	jsReq, err := http.NewRequest("GET", indexJsURL, nil)
+	if err != nil {
+		return "", fmt.Errorf("failed to create JS request: %w", err)
+	}
+	jsReq.Header.Set("User-Agent", getRandomUserAgent())
+
+	jsResp, err := client.Do(jsReq)
+	if err != nil {
+		return "", fmt.Errorf("failed to fetch Apple Music JS: %w", err)
+	}
+	defer jsResp.Body.Close()
+
+	jsBody, err := io.ReadAll(jsResp.Body)
+	if err != nil {
+		return "", fmt.Errorf("failed to read Apple Music JS: %w", err)
+	}
+
+	// Step 4: Extract JWT token (starts with eyJh)
+	tokenRegex := regexp.MustCompile(`eyJh[^"]*`)
+	tokenMatch := tokenRegex.Find(jsBody)
+	if tokenMatch == nil {
+		return "", fmt.Errorf("could not find JWT token in Apple Music JS")
+	}
+
+	m.token = string(tokenMatch)
+	GoLog("[AppleMusic] Token obtained successfully (length: %d)\n", len(m.token))
+	return m.token, nil
+}
+
+func (m *appleTokenManager) clearToken() {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	m.token = ""
+}
+
+type appleMusicSearchResponse struct {
+	Results struct {
+		Songs *struct {
+			Data []struct {
+				ID   string `json:"id"`
+				Type string `json:"type"`
+			} `json:"data"`
+		} `json:"songs"`
+	} `json:"results"`
+	Resources *struct {
+		Songs map[string]struct {
+			Attributes struct {
+				Name       string `json:"name"`
+				ArtistName string `json:"artistName"`
+				AlbumName  string `json:"albumName"`
+				URL        string `json:"url"`
+				Artwork    struct {
+					URL string `json:"url"`
+				} `json:"artwork"`
+			} `json:"attributes"`
+		} `json:"songs"`
+	} `json:"resources"`
+}
+
+// PaxResponse represents the lyrics proxy response for word-by-word / line lyrics
 type paxResponse struct {
 	Type    string      `json:"type"`    // "Syllable" or "Line"
 	Content []paxLyrics `json:"content"` // List of lyric lines
@@ -50,70 +149,32 @@ func NewAppleMusicClient() *AppleMusicClient {
 	}
 }

-func selectBestAppleMusicSearchResult(results []appleMusicSearchResult, trackName, artistName string, durationSec float64) *appleMusicSearchResult {
-	if len(results) == 0 {
-		return nil
-	}
-
-	normalizedTrack := strings.ToLower(strings.TrimSpace(simplifyTrackName(trackName)))
-	normalizedArtist := strings.ToLower(strings.TrimSpace(normalizeArtistName(artistName)))
-	if normalizedArtist == "" {
-		normalizedArtist = strings.ToLower(strings.TrimSpace(artistName))
-	}
-
-	bestIndex := 0
-	bestScore := -1
-	for i := range results {
-		result := &results[i]
-		score := 0
-
-		candidateTrack := strings.ToLower(strings.TrimSpace(simplifyTrackName(result.SongName)))
-		candidateArtist := strings.ToLower(strings.TrimSpace(normalizeArtistName(result.ArtistName)))
-
-		switch {
-		case candidateTrack == normalizedTrack:
-			score += 50
-		case strings.Contains(candidateTrack, normalizedTrack) || strings.Contains(normalizedTrack, candidateTrack):
-			score += 25
-		}
-
-		switch {
-		case candidateArtist == normalizedArtist:
-			score += 60
-		case strings.Contains(candidateArtist, normalizedArtist) || strings.Contains(normalizedArtist, candidateArtist):
-			score += 30
-		}
-
-		if durationSec > 0 && result.Duration > 0 {
-			diff := math.Abs(float64(result.Duration)/1000.0 - durationSec)
-			if diff <= durationToleranceSec {
-				score += 20
-			}
-		}
-
-		if score > bestScore {
-			bestScore = score
-			bestIndex = i
-		}
-	}
-
-	return &results[bestIndex]
-}
-
-func (c *AppleMusicClient) SearchSong(trackName, artistName string, durationSec float64) (string, error) {
+// SearchSong searches for a song on Apple Music and returns its ID.
+func (c *AppleMusicClient) SearchSong(trackName, artistName string) (string, error) {
 	query := trackName + " " + artistName
 	if strings.TrimSpace(query) == "" {
 		return "", fmt.Errorf("empty search query")
 	}

+	token, err := globalAppleTokenManager.getToken(c.httpClient)
+	if err != nil {
+		return "", fmt.Errorf("apple music token error: %w", err)
+	}
+
 	encodedQuery := url.QueryEscape(query)
-	searchURL := fmt.Sprintf("https://lyrics.paxsenix.org/apple-music/search?q=%s", encodedQuery)
+	searchURL := fmt.Sprintf(
+		"https://amp-api.music.apple.com/v1/catalog/us/search?term=%s&types=songs&limit=5&l=en-US&platform=web&format[resources]=map&include[songs]=artists&extend=artistUrl",
+		encodedQuery,
+	)

 	req, err := http.NewRequest("GET", searchURL, nil)
 	if err != nil {
 		return "", fmt.Errorf("failed to create request: %w", err)
 	}

+	req.Header.Set("Authorization", "Bearer "+token)
+	req.Header.Set("Origin", "https://music.apple.com")
+	req.Header.Set("Referer", "https://music.apple.com/")
 	req.Header.Set("User-Agent", getRandomUserAgent())
 	req.Header.Set("Accept", "application/json")

@@ -123,23 +184,28 @@ func (c *AppleMusicClient) SearchSong(trackName, artistName string, durationSec
 	}
 	defer resp.Body.Close()

+	if resp.StatusCode == 401 {
+		globalAppleTokenManager.clearToken()
+		return "", fmt.Errorf("apple music token expired")
+	}
+
 	if resp.StatusCode != 200 {
 		return "", fmt.Errorf("apple music search returned HTTP %d", resp.StatusCode)
 	}

-	var searchResp []appleMusicSearchResult
+	var searchResp appleMusicSearchResponse
 	if err := json.NewDecoder(resp.Body).Decode(&searchResp); err != nil {
 		return "", fmt.Errorf("failed to decode apple music response: %w", err)
 	}

-	best := selectBestAppleMusicSearchResult(searchResp, trackName, artistName, durationSec)
-	if best == nil || strings.TrimSpace(best.ID) == "" {
+	if searchResp.Results.Songs == nil || len(searchResp.Results.Songs.Data) == 0 {
 		return "", fmt.Errorf("no songs found on apple music")
 	}

-	return strings.TrimSpace(best.ID), nil
+	return searchResp.Results.Songs.Data[0].ID, nil
 }

+// FetchLyricsByID fetches lyrics from the paxsenix proxy using Apple Music song ID.
 func (c *AppleMusicClient) FetchLyricsByID(songID string) (string, error) {
 	lyricsURL := fmt.Sprintf("https://lyrics.paxsenix.org/apple-music/lyrics?id=%s", songID)

@@ -247,13 +313,14 @@ func formatPaxContent(lyricsType string, content []paxLyrics, multiPersonWordByW
 	return strings.TrimSpace(sb.String())
 }

+// FetchLyrics searches Apple Music and returns parsed LyricsResponse.
 func (c *AppleMusicClient) FetchLyrics(
 	trackName,
 	artistName string,
 	durationSec float64,
 	multiPersonWordByWord bool,
 ) (*LyricsResponse, error) {
-	songID, err := c.SearchSong(trackName, artistName, durationSec)
+	songID, err := c.SearchSong(trackName, artistName)
 	if err != nil {
 		return nil, err
 	}
@@ -266,8 +333,10 @@ func (c *AppleMusicClient) FetchLyrics(
 		return nil, fmt.Errorf("apple music proxy returned non-lyric payload: %s", errMsg)
 	}

+	// Try to parse as pax format (word-by-word or line)
 	lrcText, err := formatPaxLyricsToLRC(rawLyrics, multiPersonWordByWord)
 	if err != nil {
+		// If pax parsing fails, try to parse as direct LRC text
 		lrcText = rawLyrics
 	}

@@ -281,6 +350,7 @@ func (c *AppleMusicClient) FetchLyrics(
 		}, nil
 	}

+	// Fall back to plain text if no timestamps found
 	resultLines := plainTextLyricsLines(lrcText)

 	if len(resultLines) > 0 {
@@ -3,14 +3,14 @@ package gobackend
 import (
 	"encoding/json"
 	"fmt"
-	"io"
-	"math"
 	"net/http"
 	"net/url"
 	"strings"
 	"time"
 )

+// MusixmatchClient fetches lyrics from Musixmatch via a proxy server.
+// The proxy handles Musixmatch authentication internally.
 type MusixmatchClient struct {
 	httpClient *http.Client
 	baseURL    string
@@ -45,143 +45,144 @@ type musixmatchLyricsResponse struct {
 func NewMusixmatchClient() *MusixmatchClient {
 	return &MusixmatchClient{
 		httpClient: NewMetadataHTTPClient(15 * time.Second),
-		baseURL:    "https://lyrics.paxsenix.org/musixmatch/lyrics",
+		baseURL:    "http://158.180.60.95",
 	}
 }

-func (c *MusixmatchClient) fetchLyricsPayload(trackName, artistName string, durationSec float64, lyricsType, language string) (string, error) {
+// searchAndGetLyrics searches for a song and retrieves its lyrics in one call.
+// The Musixmatch proxy returns both search result and lyrics in a single response.
+func (c *MusixmatchClient) searchAndGetLyrics(trackName, artistName string) (*musixmatchSearchResponse, error) {
 	if strings.TrimSpace(trackName) == "" || strings.TrimSpace(artistName) == "" {
-		return "", fmt.Errorf("empty track or artist name")
+		return nil, fmt.Errorf("empty track or artist name")
 	}

-	params := url.Values{}
-	params.Set("t", trackName)
-	params.Set("a", artistName)
-	params.Set("type", lyricsType)
-	params.Set("format", "lrc")
-	if durationSec > 0 {
-		params.Set("d", fmt.Sprintf("%d", int(math.Round(durationSec))))
-	}
-	if strings.TrimSpace(language) != "" {
-		params.Set("l", strings.ToLower(strings.TrimSpace(language)))
-	}
-	fullURL := c.baseURL + "?" + params.Encode()
+	encodedArtist := url.QueryEscape(artistName)
+	encodedTrack := url.QueryEscape(trackName)
+
+	fullURL := fmt.Sprintf("%s/v2/full?artist=%s&track=%s", c.baseURL, encodedArtist, encodedTrack)

 	req, err := http.NewRequest("GET", fullURL, nil)
 	if err != nil {
-		return "", fmt.Errorf("failed to create request: %w", err)
+		return nil, fmt.Errorf("failed to create request: %w", err)
 	}
-	req.Header.Set("Accept", "application/json")
 	req.Header.Set("User-Agent", getRandomUserAgent())

 	resp, err := c.httpClient.Do(req)
 	if err != nil {
-		return "", fmt.Errorf("musixmatch request failed: %w", err)
+		return nil, fmt.Errorf("musixmatch search failed: %w", err)
 	}
 	defer resp.Body.Close()

-	body, err := io.ReadAll(resp.Body)
-	if err != nil {
-		return "", fmt.Errorf("failed to read musixmatch response: %w", err)
-	}
-
 	if resp.StatusCode != 200 {
-		trimmed := strings.TrimSpace(string(body))
-		if errMsg, isErrorPayload := detectLyricsErrorPayload(trimmed); isErrorPayload {
-			return "", fmt.Errorf("musixmatch proxy returned HTTP %d: %s", resp.StatusCode, errMsg)
-		}
-		return "", fmt.Errorf("musixmatch proxy returned HTTP %d", resp.StatusCode)
+		return nil, fmt.Errorf("musixmatch proxy returned HTTP %d", resp.StatusCode)
 	}

-	var lrcPayload string
-	if err := json.Unmarshal(body, &lrcPayload); err == nil {
-		lrcPayload = strings.TrimSpace(lrcPayload)
-		if lrcPayload == "" {
-			return "", fmt.Errorf("empty musixmatch lyrics payload")
-		}
-		return lrcPayload, nil
+	var result musixmatchSearchResponse
+	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
+		return nil, fmt.Errorf("failed to decode musixmatch response: %w", err)
 	}

-	trimmed := strings.TrimSpace(string(body))
-	if errMsg, isErrorPayload := detectLyricsErrorPayload(trimmed); isErrorPayload {
-		return "", fmt.Errorf("%s", errMsg)
-	}
-	if trimmed != "" && !strings.HasPrefix(trimmed, "{") {
-		return trimmed, nil
-	}
-	return "", fmt.Errorf("failed to decode musixmatch response")
+	return &result, nil
 }

-func (c *MusixmatchClient) FetchLyricsInLanguage(trackName, artistName string, durationSec float64, language string) (*LyricsResponse, error) {
+// FetchLyricsInLanguage retrieves lyrics from Musixmatch for a specific language code.
+func (c *MusixmatchClient) FetchLyricsInLanguage(songID int64, language string) (*LyricsResponse, error) {
 	lang := strings.ToLower(strings.TrimSpace(language))
-	if lang == "" {
-		return nil, fmt.Errorf("invalid language")
+	if songID <= 0 || lang == "" {
+		return nil, fmt.Errorf("invalid song id or language")
 	}

-	lrcText, err := c.fetchLyricsPayload(trackName, artistName, durationSec, "translate", lang)
+	fullURL := fmt.Sprintf("%s/v2/full?id=%d&lang=%s", c.baseURL, songID, url.QueryEscape(lang))
+
+	req, err := http.NewRequest("GET", fullURL, nil)
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("failed to create request: %w", err)
+	}
+	req.Header.Set("User-Agent", getRandomUserAgent())
+
+	resp, err := c.httpClient.Do(req)
+	if err != nil {
+		return nil, fmt.Errorf("musixmatch language fetch failed: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != 200 {
+		return nil, fmt.Errorf("musixmatch language endpoint returned HTTP %d", resp.StatusCode)
 	}

-	lines := parseSyncedLyrics(lrcText)
-	if len(lines) > 0 {
-		return &LyricsResponse{
-			Lines:       lines,
-			SyncType:    "LINE_SYNCED",
-			PlainLyrics: plainLyricsFromTimedLines(lines),
-			Provider:    "Musixmatch",
-			Source:      fmt.Sprintf("Musixmatch (%s)", lang),
-		}, nil
+	var result musixmatchSearchResponse
+	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
+		return nil, fmt.Errorf("failed to decode musixmatch language response: %w", err)
 	}

-	plainLines := plainTextLyricsLines(lrcText)
-	if len(plainLines) > 0 {
-		return &LyricsResponse{
-			Lines:       plainLines,
-			SyncType:    "UNSYNCED",
-			PlainLyrics: lrcText,
-			Provider:    "Musixmatch",
-			Source:      fmt.Sprintf("Musixmatch (%s)", lang),
-		}, nil
+	if result.SyncedLyrics != nil && strings.TrimSpace(result.SyncedLyrics.Lyrics) != "" {
+		lines := parseSyncedLyrics(result.SyncedLyrics.Lyrics)
+		if len(lines) > 0 {
+			return &LyricsResponse{
+				Lines:    lines,
+				SyncType: "LINE_SYNCED",
+				Provider: "Musixmatch",
+				Source:   fmt.Sprintf("Musixmatch (%s)", lang),
+			}, nil
+		}
+	}
+
+	if result.UnsyncedLyrics != nil && strings.TrimSpace(result.UnsyncedLyrics.Lyrics) != "" {
+		lines := plainTextLyricsLines(result.UnsyncedLyrics.Lyrics)
+
+		if len(lines) > 0 {
+			return &LyricsResponse{
+				Lines:       lines,
+				SyncType:    "UNSYNCED",
+				PlainLyrics: result.UnsyncedLyrics.Lyrics,
+				Provider:    "Musixmatch",
+				Source:      fmt.Sprintf("Musixmatch (%s)", lang),
+			}, nil
+		}
 	}

 	return nil, fmt.Errorf("no lyrics found on musixmatch for language %s", lang)
 }

+// FetchLyrics searches Musixmatch and returns parsed LyricsResponse.
 func (c *MusixmatchClient) FetchLyrics(trackName, artistName string, durationSec float64, preferredLanguage string) (*LyricsResponse, error) {
-	if preferred := strings.ToLower(strings.TrimSpace(preferredLanguage)); preferred != "" {
-		localized, localizedErr := c.FetchLyricsInLanguage(trackName, artistName, durationSec, preferred)
+	result, err := c.searchAndGetLyrics(trackName, artistName)
+	if err != nil {
+		return nil, err
+	}
+
+	if preferred := strings.ToLower(strings.TrimSpace(preferredLanguage)); preferred != "" && result.ID > 0 {
+		localized, localizedErr := c.FetchLyricsInLanguage(result.ID, preferred)
 		if localizedErr == nil {
 			return localized, nil
 		}
 		GoLog("[Musixmatch] Language override '%s' failed: %v\n", preferred, localizedErr)
 	}

-	lrcText, err := c.fetchLyricsPayload(trackName, artistName, durationSec, "word", "")
-	if err != nil {
-		return nil, err
+	if result.SyncedLyrics != nil && strings.TrimSpace(result.SyncedLyrics.Lyrics) != "" {
+		lines := parseSyncedLyrics(result.SyncedLyrics.Lyrics)
+		if len(lines) > 0 {
+			return &LyricsResponse{
+				Lines:    lines,
+				SyncType: "LINE_SYNCED",
+				Provider: "Musixmatch",
+				Source:   "Musixmatch",
+			}, nil
+		}
 	}

-	lines := parseSyncedLyrics(lrcText)
-	if len(lines) > 0 {
-		return &LyricsResponse{
-			Lines:       lines,
-			SyncType:    "LINE_SYNCED",
-			PlainLyrics: plainLyricsFromTimedLines(lines),
-			Provider:    "Musixmatch",
-			Source:      "Musixmatch",
-		}, nil
-	}
+	if result.UnsyncedLyrics != nil && strings.TrimSpace(result.UnsyncedLyrics.Lyrics) != "" {
+		lines := plainTextLyricsLines(result.UnsyncedLyrics.Lyrics)

-	plainLines := plainTextLyricsLines(lrcText)
-	if len(plainLines) > 0 {
-		return &LyricsResponse{
-			Lines:       plainLines,
-			SyncType:    "UNSYNCED",
-			PlainLyrics: lrcText,
-			Provider:    "Musixmatch",
-			Source:      "Musixmatch",
-		}, nil
+		if len(lines) > 0 {
+			return &LyricsResponse{
+				Lines:       lines,
+				SyncType:    "UNSYNCED",
+				PlainLyrics: result.UnsyncedLyrics.Lyrics,
+				Provider:    "Musixmatch",
+				Source:      "Musixmatch",
+			}, nil
+		}
 	}

 	return nil, fmt.Errorf("no lyrics found on musixmatch")
@@ -9,6 +9,8 @@ import (
 	"time"
 )

+// NeteaseClient fetches lyrics from NetEase Cloud Music (music.163.com).
+// This is a direct public API — no proxy dependency.
 type NeteaseClient struct {
 	httpClient *http.Client
 }
@@ -50,15 +52,19 @@ func NewNeteaseClient() *NeteaseClient {
 	}
 }

+// SearchSong searches for a song on Netease and returns the song ID.
 func (c *NeteaseClient) SearchSong(trackName, artistName string) (int64, error) {
 	query := trackName + " " + artistName
 	if strings.TrimSpace(query) == "" {
 		return 0, fmt.Errorf("empty search query")
 	}

-	searchURL := "https://lyrics.paxsenix.org/netease/search"
+	searchURL := "http://music.163.com/api/search/pc"
 	params := url.Values{}
-	params.Set("q", query)
+	params.Set("s", query)
+	params.Set("type", "1")
+	params.Set("limit", "1")
+	params.Set("offset", "0")

 	fullURL := searchURL + "?" + params.Encode()

@@ -94,10 +100,14 @@ func (c *NeteaseClient) SearchSong(trackName, artistName string) (int64, error)
 	return searchResp.Result.Songs[0].ID, nil
 }

+// FetchLyricsByID fetches synced lyrics for a given Netease song ID.
 func (c *NeteaseClient) FetchLyricsByID(songID int64, includeTranslation, includeRomanization bool) (string, error) {
-	lyricsURL := "https://lyrics.paxsenix.org/netease/lyrics"
+	lyricsURL := "http://music.163.com/api/song/lyric"
 	params := url.Values{}
 	params.Set("id", fmt.Sprintf("%d", songID))
+	params.Set("lv", "1")
+	params.Set("tv", "1")
+	params.Set("rv", "1")

 	fullURL := lyricsURL + "?" + params.Encode()

@@ -143,6 +153,7 @@ func (c *NeteaseClient) FetchLyricsByID(songID int64, includeTranslation, includ
 	return lyric, nil
 }

+// FetchLyrics searches for a track and returns parsed LyricsResponse.
 func (c *NeteaseClient) FetchLyrics(
 	trackName,
 	artistName string,
@@ -162,6 +173,7 @@ func (c *NeteaseClient) FetchLyrics(

 	lines := parseSyncedLyrics(lrcText)
 	if len(lines) == 0 {
+		// May be plain text lyrics without timestamps
 		plainLines := strings.Split(lrcText, "\n")
 		for _, line := range plainLines {
 			trimmed := strings.TrimSpace(line)
@@ -1,29 +1,45 @@
 package gobackend

 import (
+	"bytes"
 	"encoding/json"
 	"fmt"
 	"io"
-	"math"
 	"net/http"
+	"net/url"
 	"strings"
 	"time"
 )

+// QQMusicClient fetches lyrics from QQ Music.
+// Search uses public QQ Music API, lyrics use the paxsenix proxy.
 type QQMusicClient struct {
 	httpClient *http.Client
 }

-type qqLyricsMetadataRequest struct {
-	Artist   []string `json:"artist"`
-	Album    string   `json:"album,omitempty"`
-	SongID   int64    `json:"songid,omitempty"`
-	Title    string   `json:"title"`
-	Duration int64    `json:"duration,omitempty"`
+type qqMusicSearchResponse struct {
+	Data struct {
+		Song struct {
+			List []struct {
+				Title  string `json:"title"`
+				Singer []struct {
+					Name string `json:"name"`
+				} `json:"singer"`
+				Album struct {
+					Name string `json:"name"`
+				} `json:"album"`
+				ID int64 `json:"id"`
+			} `json:"list"`
+		} `json:"song"`
+	} `json:"data"`
 }

-type qqLyricsMetadataResponse struct {
-	Lyrics []paxLyrics `json:"lyrics"`
+// QQ Music lyrics request payload for paxsenix proxy
+type qqLyricsPayload struct {
+	Artist []string `json:"artist"`
+	Album  string   `json:"album"`
+	ID     int64    `json:"id"`
+	Title  string   `json:"title"`
 }

 func NewQQMusicClient() *QQMusicClient {
@@ -32,28 +48,79 @@ func NewQQMusicClient() *QQMusicClient {
 	}
 }

-func (c *QQMusicClient) fetchLyricsByMetadata(trackName, artistName string, durationSec float64) (string, error) {
-	payload := qqLyricsMetadataRequest{
-		Artist: []string{artistName},
-		Title:  trackName,
-	}
-	if durationSec > 0 {
-		payload.Duration = int64(math.Round(durationSec))
+// searchSong searches QQ Music and returns the song info needed for lyrics fetch.
+func (c *QQMusicClient) searchSong(trackName, artistName string) (*qqLyricsPayload, error) {
+	query := trackName + " " + artistName
+	if strings.TrimSpace(query) == "" {
+		return nil, fmt.Errorf("empty search query")
 	}

-	lyricsURL := "https://lyrics.paxsenix.org/qq/lyrics-metadata"
+	searchURL := "https://c.y.qq.com/soso/fcgi-bin/client_search_cp"
+	params := url.Values{}
+	params.Set("format", "json")
+	params.Set("inCharset", "utf8")
+	params.Set("outCharset", "utf8")
+	params.Set("platform", "yqq.json")
+	params.Set("new_json", "1")
+	params.Set("w", query)
+
+	fullURL := searchURL + "?" + params.Encode()
+
+	req, err := http.NewRequest("GET", fullURL, nil)
+	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.httpClient.Do(req)
+	if err != nil {
+		return nil, fmt.Errorf("qqmusic search failed: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != 200 {
+		return nil, fmt.Errorf("qqmusic search returned HTTP %d", resp.StatusCode)
+	}
+
+	var searchResp qqMusicSearchResponse
+	if err := json.NewDecoder(resp.Body).Decode(&searchResp); err != nil {
+		return nil, fmt.Errorf("failed to decode qqmusic response: %w", err)
+	}
+
+	if len(searchResp.Data.Song.List) == 0 {
+		return nil, fmt.Errorf("no songs found on qqmusic")
+	}
+
+	song := searchResp.Data.Song.List[0]
+
+	var artists []string
+	for _, singer := range song.Singer {
+		artists = append(artists, singer.Name)
+	}
+
+	return &qqLyricsPayload{
+		Artist: artists,
+		Album:  song.Album.Name,
+		ID:     song.ID,
+		Title:  song.Title,
+	}, nil
+}
+
+// fetchLyricsByPayload fetches lyrics from the paxsenix proxy using QQ Music song info.
+func (c *QQMusicClient) fetchLyricsByPayload(payload *qqLyricsPayload) (string, error) {
+	lyricsURL := "https://paxsenix.alwaysdata.net/getQQLyrics.php"

 	payloadBytes, err := json.Marshal(payload)
 	if err != nil {
 		return "", fmt.Errorf("failed to marshal payload: %w", err)
 	}

-	req, err := http.NewRequest("POST", lyricsURL, strings.NewReader(string(payloadBytes)))
+	req, err := http.NewRequest("POST", lyricsURL, bytes.NewReader(payloadBytes))
 	if err != nil {
 		return "", fmt.Errorf("failed to create request: %w", err)
 	}
 	req.Header.Set("Content-Type", "application/json")
-	req.Header.Set("Accept", "application/json")
 	req.Header.Set("User-Agent", getRandomUserAgent())

 	resp, err := c.httpClient.Do(req)
@@ -79,24 +146,19 @@ func (c *QQMusicClient) fetchLyricsByMetadata(trackName, artistName string, dura
 	return bodyStr, nil
 }

-func formatQQLyricsMetadataToLRC(rawJSON string, multiPersonWordByWord bool) (string, error) {
-	var response qqLyricsMetadataResponse
-	if err := json.Unmarshal([]byte(rawJSON), &response); err != nil {
-		return "", fmt.Errorf("failed to parse qq metadata lyrics response")
-	}
-	if len(response.Lyrics) == 0 {
-		return "", fmt.Errorf("qq metadata lyrics response was empty")
-	}
-	return formatPaxContent("Syllable", response.Lyrics, multiPersonWordByWord), nil
-}
-
+// FetchLyrics searches QQ Music and returns parsed LyricsResponse.
 func (c *QQMusicClient) FetchLyrics(
 	trackName,
 	artistName string,
 	durationSec float64,
 	multiPersonWordByWord bool,
 ) (*LyricsResponse, error) {
-	rawLyrics, err := c.fetchLyricsByMetadata(trackName, artistName, durationSec)
+	payload, err := c.searchSong(trackName, artistName)
+	if err != nil {
+		return nil, err
+	}
+
+	rawLyrics, err := c.fetchLyricsByPayload(payload)
 	if err != nil {
 		return nil, err
 	}
@@ -104,13 +166,11 @@ func (c *QQMusicClient) FetchLyrics(
 		return nil, fmt.Errorf("qqmusic proxy returned non-lyric payload: %s", errMsg)
 	}

-	lrcText, err := formatQQLyricsMetadataToLRC(rawLyrics, multiPersonWordByWord)
+	// Try to parse as pax format (word-by-word or line)
+	lrcText, err := formatPaxLyricsToLRC(rawLyrics, multiPersonWordByWord)
 	if err != nil {
-		if fallback, fallbackErr := formatPaxLyricsToLRC(rawLyrics, multiPersonWordByWord); fallbackErr == nil {
-			lrcText = fallback
-		} else {
-			lrcText = rawLyrics
-		}
+		// If pax parsing fails, try to use as direct LRC text
+		lrcText = rawLyrics
 	}

 	lines := parseSyncedLyrics(lrcText)
@@ -1,67 +0,0 @@
-package gobackend
-
-import (
-	"bytes"
-	"encoding/binary"
-	"slices"
-	"testing"
-
-	"github.com/go-flac/flacvorbis/v2"
-)
-
-func TestSplitArtistTagValues(t *testing.T) {
-	got := splitArtistTagValues("Artist A, Artist B feat. Artist C & Artist B")
-	want := []string{"Artist A", "Artist B", "Artist C"}
-	if !slices.Equal(got, want) {
-		t.Fatalf("splitArtistTagValues() = %#v, want %#v", got, want)
-	}
-}
-
-func TestSetArtistCommentsSplitVorbis(t *testing.T) {
-	cmt := flacvorbis.New()
-	setArtistComments(cmt, "ARTIST", "Artist A, Artist B", artistTagModeSplitVorbis)
-
-	got := getCommentValues(cmt, "ARTIST")
-	want := []string{"Artist A", "Artist B"}
-	if !slices.Equal(got, want) {
-		t.Fatalf("getCommentValues(ARTIST) = %#v, want %#v", got, want)
-	}
-}
-
-func TestParseVorbisCommentsJoinsRepeatedArtists(t *testing.T) {
-	metadata := &AudioMetadata{}
-	parseVorbisComments(
-		buildVorbisCommentPayload(
-			[]string{
-				"TITLE=Song",
-				"ARTIST=Artist A",
-				"ARTIST=Artist B",
-				"ALBUMARTIST=Album Artist A",
-				"ALBUMARTIST=Album Artist B",
-			},
-		),
-		metadata,
-	)
-
-	if metadata.Title != "Song" {
-		t.Fatalf("title = %q", metadata.Title)
-	}
-	if metadata.Artist != "Artist A, Artist B" {
-		t.Fatalf("artist = %q", metadata.Artist)
-	}
-	if metadata.AlbumArtist != "Album Artist A, Album Artist B" {
-		t.Fatalf("album artist = %q", metadata.AlbumArtist)
-	}
-}
-
-func buildVorbisCommentPayload(comments []string) []byte {
-	var buf bytes.Buffer
-	_ = binary.Write(&buf, binary.LittleEndian, uint32(len("spotiflac")))
-	buf.WriteString("spotiflac")
-	_ = binary.Write(&buf, binary.LittleEndian, uint32(len(comments)))
-	for _, comment := range comments {
-		_ = binary.Write(&buf, binary.LittleEndian, uint32(len(comment)))
-		buf.WriteString(comment)
-	}
-	return buf.Bytes()
-}
@@ -1,149 +0,0 @@
-package gobackend
-
-import "time"
-
-type cacheEntry struct {
-	data      interface{}
-	expiresAt time.Time
-}
-
-func (e *cacheEntry) isExpired() bool {
-	return time.Now().After(e.expiresAt)
-}
-
-type TrackMetadata struct {
-	SpotifyID   string `json:"spotify_id,omitempty"`
-	Artists     string `json:"artists"`
-	Name        string `json:"name"`
-	AlbumName   string `json:"album_name"`
-	AlbumArtist string `json:"album_artist,omitempty"`
-	DurationMS  int    `json:"duration_ms"`
-	Images      string `json:"images"`
-	ReleaseDate string `json:"release_date"`
-	TrackNumber int    `json:"track_number"`
-	TotalTracks int    `json:"total_tracks,omitempty"`
-	DiscNumber  int    `json:"disc_number,omitempty"`
-	TotalDiscs  int    `json:"total_discs,omitempty"`
-	ExternalURL string `json:"external_urls"`
-	ISRC        string `json:"isrc"`
-	AlbumID     string `json:"album_id,omitempty"`
-	ArtistID    string `json:"artist_id,omitempty"`
-	AlbumType   string `json:"album_type,omitempty"`
-	Composer    string `json:"composer,omitempty"`
-}
-
-type AlbumTrackMetadata struct {
-	SpotifyID   string `json:"spotify_id,omitempty"`
-	Artists     string `json:"artists"`
-	Name        string `json:"name"`
-	AlbumName   string `json:"album_name"`
-	AlbumArtist string `json:"album_artist,omitempty"`
-	DurationMS  int    `json:"duration_ms"`
-	Images      string `json:"images"`
-	ReleaseDate string `json:"release_date"`
-	TrackNumber int    `json:"track_number"`
-	TotalTracks int    `json:"total_tracks,omitempty"`
-	DiscNumber  int    `json:"disc_number,omitempty"`
-	TotalDiscs  int    `json:"total_discs,omitempty"`
-	ExternalURL string `json:"external_urls"`
-	ISRC        string `json:"isrc"`
-	AlbumID     string `json:"album_id,omitempty"`
-	AlbumURL    string `json:"album_url,omitempty"`
-	AlbumType   string `json:"album_type,omitempty"`
-	Composer    string `json:"composer,omitempty"`
-}
-
-type AlbumInfoMetadata struct {
-	TotalTracks int    `json:"total_tracks"`
-	Name        string `json:"name"`
-	ReleaseDate string `json:"release_date"`
-	Artists     string `json:"artists"`
-	ArtistId    string `json:"artist_id,omitempty"`
-	Images      string `json:"images"`
-	Genre       string `json:"genre,omitempty"`
-	Label       string `json:"label,omitempty"`
-	Copyright   string `json:"copyright,omitempty"`
-}
-
-type AlbumResponsePayload struct {
-	AlbumInfo AlbumInfoMetadata    `json:"album_info"`
-	TrackList []AlbumTrackMetadata `json:"track_list"`
-}
-
-type PlaylistInfoMetadata struct {
-	Name   string `json:"name,omitempty"`
-	Images string `json:"images,omitempty"`
-	Tracks struct {
-		Total int `json:"total"`
-	} `json:"tracks"`
-	Owner struct {
-		DisplayName string `json:"display_name"`
-		Name        string `json:"name"`
-		Images      string `json:"images"`
-	} `json:"owner"`
-}
-
-type PlaylistResponsePayload struct {
-	PlaylistInfo PlaylistInfoMetadata `json:"playlist_info"`
-	TrackList    []AlbumTrackMetadata `json:"track_list"`
-}
-
-type ArtistInfoMetadata struct {
-	ID         string `json:"id"`
-	Name       string `json:"name"`
-	Images     string `json:"images"`
-	Followers  int    `json:"followers"`
-	Popularity int    `json:"popularity"`
-}
-
-type ArtistAlbumMetadata struct {
-	ID          string `json:"id"`
-	Name        string `json:"name"`
-	ReleaseDate string `json:"release_date"`
-	TotalTracks int    `json:"total_tracks"`
-	Images      string `json:"images"`
-	AlbumType   string `json:"album_type"`
-	Artists     string `json:"artists"`
-}
-
-type ArtistResponsePayload struct {
-	ArtistInfo ArtistInfoMetadata    `json:"artist_info"`
-	Albums     []ArtistAlbumMetadata `json:"albums"`
-}
-
-type TrackResponse struct {
-	Track TrackMetadata `json:"track"`
-}
-
-type SearchArtistResult struct {
-	ID         string `json:"id"`
-	Name       string `json:"name"`
-	Images     string `json:"images"`
-	Followers  int    `json:"followers"`
-	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"`
-	Albums    []SearchAlbumResult    `json:"albums"`
-	Playlists []SearchPlaylistResult `json:"playlists"`
-}
@@ -34,16 +34,10 @@ var (
 	downloadDir   string
 	downloadDirMu sync.RWMutex

-	multiProgress       = MultiProgress{Items: make(map[string]*ItemProgress)}
-	multiMu             sync.RWMutex
-	multiProgressDirty  = true
-	cachedMultiProgress = "{\"items\":{}}"
+	multiProgress = MultiProgress{Items: make(map[string]*ItemProgress)}
+	multiMu       sync.RWMutex
 )

-func markMultiProgressDirtyLocked() {
-	multiProgressDirty = true
-}
-
 func getProgress() DownloadProgress {
 	multiMu.RLock()
 	defer multiMu.RUnlock()
@@ -64,25 +58,13 @@ func getProgress() DownloadProgress {

 func GetMultiProgress() string {
 	multiMu.RLock()
-	if !multiProgressDirty {
-		cached := cachedMultiProgress
-		multiMu.RUnlock()
-		return cached
-	}
-	multiMu.RUnlock()
+	defer multiMu.RUnlock()

-	multiMu.Lock()
-	defer multiMu.Unlock()
-	if !multiProgressDirty {
-		return cachedMultiProgress
-	}
 	jsonBytes, err := json.Marshal(multiProgress)
 	if err != nil {
 		return "{\"items\":{}}"
 	}
-	cachedMultiProgress = string(jsonBytes)
-	multiProgressDirty = false
-	return cachedMultiProgress
+	return string(jsonBytes)
 }

 func GetItemProgress(itemID string) string {
@@ -108,7 +90,6 @@ func StartItemProgress(itemID string) {
 		IsDownloading: true,
 		Status:        "downloading",
 	}
-	markMultiProgressDirtyLocked()
 }

 func SetItemBytesTotal(itemID string, total int64) {
@@ -117,7 +98,6 @@ func SetItemBytesTotal(itemID string, total int64) {

 	if item, ok := multiProgress.Items[itemID]; ok {
 		item.BytesTotal = total
-		markMultiProgressDirtyLocked()
 	}
 }

@@ -130,7 +110,6 @@ func SetItemBytesReceived(itemID string, received int64) {
 		if item.BytesTotal > 0 {
 			item.Progress = float64(received) / float64(item.BytesTotal)
 		}
-		markMultiProgressDirtyLocked()
 	}
 }

@@ -144,7 +123,6 @@ func SetItemBytesReceivedWithSpeed(itemID string, received int64, speedMBps floa
 		if item.BytesTotal > 0 {
 			item.Progress = float64(received) / float64(item.BytesTotal)
 		}
-		markMultiProgressDirtyLocked()
 	}
 }

@@ -156,7 +134,6 @@ func CompleteItemProgress(itemID string) {
 		item.Progress = 1.0
 		item.IsDownloading = false
 		item.Status = "completed"
-		markMultiProgressDirtyLocked()
 	}
 }

@@ -172,7 +149,6 @@ func SetItemProgress(itemID string, progress float64, bytesReceived, bytesTotal
 		if bytesTotal > 0 {
 			item.BytesTotal = bytesTotal
 		}
-		markMultiProgressDirtyLocked()
 	}
 }

@@ -183,7 +159,6 @@ func SetItemFinalizing(itemID string) {
 	if item, ok := multiProgress.Items[itemID]; ok {
 		item.Progress = 1.0
 		item.Status = "finalizing"
-		markMultiProgressDirtyLocked()
 	}
 }

@@ -192,7 +167,6 @@ func RemoveItemProgress(itemID string) {
 	defer multiMu.Unlock()

 	delete(multiProgress.Items, itemID)
-	markMultiProgressDirtyLocked()
 }

 func ClearAllItemProgress() {
@@ -200,7 +174,6 @@ func ClearAllItemProgress() {
 	defer multiMu.Unlock()

 	multiProgress.Items = make(map[string]*ItemProgress)
-	markMultiProgressDirtyLocked()
 }

 func setDownloadDir(path string) error {
@@ -1,113 +1,6 @@
 package gobackend

-import (
-	"encoding/json"
-	"testing"
-)
-
-func buildTestQobuzAlbum(id, title, artist string, tracks ...QobuzTrack) *qobuzAlbumDetails {
-	album := &qobuzAlbumDetails{
-		ID:                  id,
-		Title:               title,
-		ReleaseDateOriginal: "2013-05-20",
-		TracksCount:         len(tracks),
-		ProductType:         "album",
-		ReleaseType:         "album",
-	}
-	album.Artist = qobuzArtistRef{ID: 1, Name: artist}
-	album.Artists = []qobuzArtistRef{{ID: 1, Name: artist}}
-	album.Tracks.Items = tracks
-	return album
-}
-
-func TestParseQobuzURL(t *testing.T) {
-	tests := []struct {
-		name      string
-		input     string
-		wantType  string
-		wantID    string
-		expectErr bool
-	}{
-		{
-			name:     "store album url",
-			input:    "https://www.qobuz.com/us-en/album/harry-styles-harry-styles/0886446451985",
-			wantType: "album",
-			wantID:   "0886446451985",
-		},
-		{
-			name:     "store playlist url",
-			input:    "https://www.qobuz.com/us-en/playlists/new-releases/2049430",
-			wantType: "playlist",
-			wantID:   "2049430",
-		},
-		{
-			name:     "store artist url",
-			input:    "https://www.qobuz.com/us-en/interpreter/harry-styles/729886",
-			wantType: "artist",
-			wantID:   "729886",
-		},
-		{
-			name:     "play track url",
-			input:    "https://play.qobuz.com/track/40681594",
-			wantType: "track",
-			wantID:   "40681594",
-		},
-		{
-			name:     "custom scheme playlist url",
-			input:    "qobuzapp://playlist/2049430",
-			wantType: "playlist",
-			wantID:   "2049430",
-		},
-		{
-			name:      "unsupported url",
-			input:     "https://example.com/not-qobuz",
-			expectErr: true,
-		},
-	}
-
-	for _, test := range tests {
-		t.Run(test.name, func(t *testing.T) {
-			gotType, gotID, err := parseQobuzURL(test.input)
-			if test.expectErr {
-				if err == nil {
-					t.Fatalf("expected error, got none")
-				}
-				return
-			}
-			if err != nil {
-				t.Fatalf("expected no error, got %v", err)
-			}
-			if gotType != test.wantType || gotID != test.wantID {
-				t.Fatalf("parseQobuzURL(%q) = (%q, %q), want (%q, %q)", test.input, gotType, gotID, test.wantType, test.wantID)
-			}
-		})
-	}
-}
-
-func TestExtractQobuzArtistAlbumIDs(t *testing.T) {
-	body := []byte(`
-<div class="product__item">
-  <button data-itemtype="album" data-itemId="yrpbt0lwm3g0y"></button>
-</div>
-<div class="product__item">
-  <button data-itemtype="album" data-itemId="yrpbt0lwm3g0y"></button>
-</div>
-<div class="product__item">
-  <button data-itemtype="album" data-itemId="0886446451985"></button>
-</div>
-`)
-
-	matches := qobuzArtistAlbumIDRegex.FindAllSubmatch(body, -1)
-	if len(matches) != 3 {
-		t.Fatalf("expected 3 regex matches, got %d", len(matches))
-	}
-	if string(matches[0][1]) != "yrpbt0lwm3g0y" {
-		t.Fatalf("unexpected first album id: %q", matches[0][1])
-	}
-	if string(matches[2][1]) != "0886446451985" {
-		t.Fatalf("unexpected last album id: %q", matches[2][1])
-	}
-}
+import "testing"

 func TestExtractQobuzDownloadURLFromBody(t *testing.T) {
 	t.Run("reads top-level download_url and quality metadata", func(t *testing.T) {
@@ -201,56 +94,28 @@ func TestNormalizeQobuzQualityCode(t *testing.T) {
 	}
 }

-func TestBuildQobuzMusicDLPayloadUsesOpenTrackURL(t *testing.T) {
-	payloadBytes, err := buildQobuzMusicDLPayload(374610875, "7")
-	if err != nil {
-		t.Fatalf("buildQobuzMusicDLPayload returned error: %v", err)
+func TestGetQobuzDebugKey(t *testing.T) {
+	got := getQobuzDebugKey()
+	if len(got) != len(qobuzDebugKeyObfuscated) {
+		t.Fatalf("unexpected debug key length: %d", len(got))
 	}
-
-	var payload map[string]any
-	if err := json.Unmarshal(payloadBytes, &payload); err != nil {
-		t.Fatalf("payload is not valid JSON: %v", err)
-	}
-
-	if got := payload["url"]; got != "https://open.qobuz.com/track/374610875" {
-		t.Fatalf("payload url = %v, want open.qobuz.com track URL", got)
-	}
-	if got := payload["quality"]; got != "hi-res" {
-		t.Fatalf("payload quality = %v, want hi-res", got)
-	}
-	if got := payload["upload_to_r2"]; got != false {
-		t.Fatalf("payload upload_to_r2 = %v, want false", got)
-	}
-}
-
-func TestExtractQobuzAlbumIDsFromArtistHTML(t *testing.T) {
-	body := []byte(`
-		<button data-itemtype="album" data-itemId="0886446451985"></button>
-		<button data-itemtype="album" data-itemId="0886446451985"></button>
-		<button data-itemtype="album" data-itemId="pvv406bth40ya"></button>
-	`)
-
-	got := extractQobuzAlbumIDsFromArtistHTML(body)
-	if len(got) != 2 {
-		t.Fatalf("expected 2 unique album IDs, got %d (%v)", len(got), got)
-	}
-	if got[0] != "0886446451985" || got[1] != "pvv406bth40ya" {
-		t.Fatalf("unexpected album IDs: %v", got)
+	for i := range got {
+		if got[i]^qobuzDebugKeyXORMask != qobuzDebugKeyObfuscated[i] {
+			t.Fatalf("unexpected debug key reconstruction at index %d", i)
+		}
 	}
 }

 func TestQobuzAvailableProviders(t *testing.T) {
 	providers := NewQobuzDownloader().GetAvailableProviders()
-	if len(providers) != 5 {
-		t.Fatalf("expected 5 Qobuz providers, got %d", len(providers))
+	if len(providers) != 3 {
+		t.Fatalf("expected 3 Qobuz providers, got %d", len(providers))
 	}

 	want := map[string]string{
 		"musicdl":  qobuzAPIKindMusicDL,
 		"dabmusic": qobuzAPIKindStandard,
 		"deeb":     qobuzAPIKindStandard,
-		"qbz":      qobuzAPIKindStandard,
-		"squid":    qobuzAPIKindStandard,
 	}

 	for _, provider := range providers {
@@ -268,253 +133,3 @@ func TestQobuzAvailableProviders(t *testing.T) {
 		t.Fatalf("missing providers: %v", want)
 	}
 }
-
-func testQobuzTrack(id int64, title, artist string, duration int) *QobuzTrack {
-	track := &QobuzTrack{
-		ID:       id,
-		Title:    title,
-		Duration: duration,
-	}
-	track.Performer.Name = artist
-	return track
-}
-
-func TestSelectQobuzTracksFromAlbumSearchResultsPrefersMatchingTrack(t *testing.T) {
-	summaries := []qobuzAlbumDetails{
-		{ID: "album-a"},
-		{ID: "album-b"},
-	}
-
-	match := *testQobuzTrack(1, "Get Lucky", "Daft Punk", 369)
-	other := *testQobuzTrack(2, "Fragments of Time", "Daft Punk", 280)
-	fallback := *testQobuzTrack(3, "Da Funk", "Daft Punk", 330)
-
-	albums := map[string]*qobuzAlbumDetails{
-		"album-a": buildTestQobuzAlbum("album-a", "Random Access Memories", "Daft Punk", match, other),
-		"album-b": buildTestQobuzAlbum("album-b", "Homework", "Daft Punk", fallback),
-	}
-
-	tracks, err := selectQobuzTracksFromAlbumSearchResults(
-		"daft punk get lucky",
-		3,
-		summaries,
-		func(id string) (*qobuzAlbumDetails, error) { return albums[id], nil },
-	)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if len(tracks) == 0 {
-		t.Fatal("expected tracks, got none")
-	}
-	if tracks[0].ID != 1 {
-		t.Fatalf("expected Get Lucky to rank first, got track id %d", tracks[0].ID)
-	}
-}
-
-func TestSelectQobuzTracksFromAlbumSearchResultsDedupesTracks(t *testing.T) {
-	summaries := []qobuzAlbumDetails{
-		{ID: "album-a"},
-		{ID: "album-b"},
-	}
-
-	shared := *testQobuzTrack(42, "Get Lucky", "Daft Punk", 369)
-
-	albums := map[string]*qobuzAlbumDetails{
-		"album-a": buildTestQobuzAlbum("album-a", "Random Access Memories", "Daft Punk", shared),
-		"album-b": buildTestQobuzAlbum("album-b", "Random Access Memories Deluxe", "Daft Punk", shared),
-	}
-
-	tracks, err := selectQobuzTracksFromAlbumSearchResults(
-		"daft punk get lucky",
-		5,
-		summaries,
-		func(id string) (*qobuzAlbumDetails, error) { return albums[id], nil },
-	)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if len(tracks) != 1 {
-		t.Fatalf("expected 1 deduped track, got %d", len(tracks))
-	}
-	if tracks[0].ID != 42 {
-		t.Fatalf("unexpected deduped track id: %d", tracks[0].ID)
-	}
-}
-
-func TestResolveQobuzTrackForRequestRejectsSongLinkMismatch(t *testing.T) {
-	origGetTrackByID := qobuzGetTrackByIDFunc
-	origSearchISRC := qobuzSearchTrackByISRCWithDurationFunc
-	origSearchMetadata := qobuzSearchTrackByMetadataWithDurationFunc
-	origSongLinkCheck := songLinkCheckTrackAvailabilityFunc
-	t.Cleanup(func() {
-		qobuzGetTrackByIDFunc = origGetTrackByID
-		qobuzSearchTrackByISRCWithDurationFunc = origSearchISRC
-		qobuzSearchTrackByMetadataWithDurationFunc = origSearchMetadata
-		songLinkCheckTrackAvailabilityFunc = origSongLinkCheck
-		GetTrackIDCache().Clear()
-	})
-	GetTrackIDCache().Clear()
-
-	qobuzGetTrackByIDFunc = func(_ *QobuzDownloader, trackID int64) (*QobuzTrack, error) {
-		if trackID != 111 {
-			t.Fatalf("unexpected track ID lookup: %d", trackID)
-		}
-		return testQobuzTrack(111, "Aperture", "Harry Styles", 180), nil
-	}
-	qobuzSearchTrackByISRCWithDurationFunc = func(_ *QobuzDownloader, isrc string, expectedDurationSec int) (*QobuzTrack, error) {
-		if isrc != "TESTISRC1" {
-			t.Fatalf("unexpected ISRC lookup: %q", isrc)
-		}
-		if expectedDurationSec != 180 {
-			t.Fatalf("unexpected duration: %d", expectedDurationSec)
-		}
-		return testQobuzTrack(222, "Taste Back", "Harry Styles", 180), nil
-	}
-	qobuzSearchTrackByMetadataWithDurationFunc = func(_ *QobuzDownloader, _, _ string, _ int) (*QobuzTrack, error) {
-		t.Fatal("metadata fallback should not run when ISRC fallback succeeds")
-		return nil, nil
-	}
-	songLinkCheckTrackAvailabilityFunc = func(_ *SongLinkClient, spotifyTrackID string, isrc string) (*TrackAvailability, error) {
-		if spotifyTrackID != "spotify-track-id" {
-			t.Fatalf("unexpected spotify ID: %q", spotifyTrackID)
-		}
-		if isrc != "TESTISRC1" {
-			t.Fatalf("unexpected SongLink ISRC: %q", isrc)
-		}
-		return &TrackAvailability{QobuzID: "111"}, nil
-	}
-
-	req := DownloadRequest{
-		ISRC:       "TESTISRC1",
-		SpotifyID:  "spotify-track-id",
-		TrackName:  "Taste Back",
-		ArtistName: "Harry Styles",
-		DurationMS: 180000,
-	}
-
-	track, err := resolveQobuzTrackForRequest(req, &QobuzDownloader{}, "Test")
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	if track == nil || track.ID != 222 || track.Title != "Taste Back" {
-		t.Fatalf("unexpected resolved track: %+v", track)
-	}
-
-	cached := GetTrackIDCache().Get(req.ISRC)
-	if cached == nil || cached.QobuzTrackID != 222 {
-		t.Fatalf("expected validated fallback track to be cached, got %+v", cached)
-	}
-}
-
-func TestResolveQobuzTrackForRequestRejectsOdesliMismatch(t *testing.T) {
-	origGetTrackByID := qobuzGetTrackByIDFunc
-	origSearchISRC := qobuzSearchTrackByISRCWithDurationFunc
-	origSearchMetadata := qobuzSearchTrackByMetadataWithDurationFunc
-	origSongLinkCheck := songLinkCheckTrackAvailabilityFunc
-	t.Cleanup(func() {
-		qobuzGetTrackByIDFunc = origGetTrackByID
-		qobuzSearchTrackByISRCWithDurationFunc = origSearchISRC
-		qobuzSearchTrackByMetadataWithDurationFunc = origSearchMetadata
-		songLinkCheckTrackAvailabilityFunc = origSongLinkCheck
-	})
-
-	qobuzGetTrackByIDFunc = func(_ *QobuzDownloader, trackID int64) (*QobuzTrack, error) {
-		if trackID != 333 {
-			t.Fatalf("unexpected track ID lookup: %d", trackID)
-		}
-		return testQobuzTrack(333, "American Girls", "Harry Styles", 181), nil
-	}
-	qobuzSearchTrackByISRCWithDurationFunc = func(_ *QobuzDownloader, _ string, _ int) (*QobuzTrack, error) {
-		t.Fatal("ISRC fallback should not run without an ISRC")
-		return nil, nil
-	}
-	qobuzSearchTrackByMetadataWithDurationFunc = func(_ *QobuzDownloader, trackName, artistName string, expectedDurationSec int) (*QobuzTrack, error) {
-		if trackName != "Taste Back" || artistName != "Harry Styles" || expectedDurationSec != 181 {
-			t.Fatalf("unexpected metadata fallback arguments: %q / %q / %d", trackName, artistName, expectedDurationSec)
-		}
-		return testQobuzTrack(444, "Taste Back", "Harry Styles", 181), nil
-	}
-	songLinkCheckTrackAvailabilityFunc = func(_ *SongLinkClient, _, _ string) (*TrackAvailability, error) {
-		t.Fatal("SongLink should not run when Odesli QobuzID is provided")
-		return nil, nil
-	}
-
-	req := DownloadRequest{
-		QobuzID:    "333",
-		TrackName:  "Taste Back",
-		ArtistName: "Harry Styles",
-		DurationMS: 181000,
-	}
-
-	track, err := resolveQobuzTrackForRequest(req, &QobuzDownloader{}, "Test")
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	if track == nil || track.ID != 444 || track.Title != "Taste Back" {
-		t.Fatalf("unexpected resolved track: %+v", track)
-	}
-}
-
-func TestResolveQobuzTrackForRequestUsesPrefixedQobuzIDWithoutSongLink(t *testing.T) {
-	origGetTrackByID := qobuzGetTrackByIDFunc
-	origSearchISRC := qobuzSearchTrackByISRCWithDurationFunc
-	origSearchMetadata := qobuzSearchTrackByMetadataWithDurationFunc
-	origSongLinkCheck := songLinkCheckTrackAvailabilityFunc
-	t.Cleanup(func() {
-		qobuzGetTrackByIDFunc = origGetTrackByID
-		qobuzSearchTrackByISRCWithDurationFunc = origSearchISRC
-		qobuzSearchTrackByMetadataWithDurationFunc = origSearchMetadata
-		songLinkCheckTrackAvailabilityFunc = origSongLinkCheck
-	})
-
-	qobuzGetTrackByIDFunc = func(_ *QobuzDownloader, trackID int64) (*QobuzTrack, error) {
-		if trackID != 40681594 {
-			t.Fatalf("unexpected track ID lookup: %d", trackID)
-		}
-		return testQobuzTrack(40681594, "Sign of the Times", "Harry Styles", 341), nil
-	}
-	qobuzSearchTrackByISRCWithDurationFunc = func(_ *QobuzDownloader, _ string, _ int) (*QobuzTrack, error) {
-		t.Fatal("ISRC fallback should not run when request qobuz id succeeds")
-		return nil, nil
-	}
-	qobuzSearchTrackByMetadataWithDurationFunc = func(_ *QobuzDownloader, _, _ string, _ int) (*QobuzTrack, error) {
-		t.Fatal("metadata fallback should not run when request qobuz id succeeds")
-		return nil, nil
-	}
-	songLinkCheckTrackAvailabilityFunc = func(_ *SongLinkClient, _, _ string) (*TrackAvailability, error) {
-		t.Fatal("SongLink should not run when request qobuz id is provided")
-		return nil, nil
-	}
-
-	req := DownloadRequest{
-		QobuzID:    "qobuz:40681594",
-		TrackName:  "Sign of the Times",
-		ArtistName: "Harry Styles",
-		DurationMS: 341000,
-	}
-
-	track, err := resolveQobuzTrackForRequest(req, &QobuzDownloader{}, "Test")
-	if err != nil {
-		t.Fatalf("expected no error, got %v", err)
-	}
-	if track == nil || track.ID != 40681594 {
-		t.Fatalf("unexpected resolved track: %+v", track)
-	}
-}
-
-func TestQobuzTrackMatchesRequest_SongLinkBypassesArtistAndTitle(t *testing.T) {
-	req := DownloadRequest{
-		TrackName:  "Ringišpil",
-		ArtistName: "Djordje Balasevic",
-	}
-
-	track := &QobuzTrack{
-		Title:    "Different Title",
-		Duration: 0,
-	}
-	track.Performer.Name = "Different Artist"
-
-	if !qobuzTrackMatchesRequest(req, track, "Qobuz", "SongLink Qobuz ID", true) {
-		t.Fatal("expected SongLink Qobuz source to bypass artist/title verification")
-	}
-}
@@ -16,13 +16,16 @@ var hiraganaToRomaji = map[rune]string{
 	'や': "ya", 'ゆ': "yu", 'よ': "yo",
 	'ら': "ra", 'り': "ri", 'る': "ru", 'れ': "re", 'ろ': "ro",
 	'わ': "wa", 'を': "wo", 'ん': "n",
+	// Dakuten (voiced)
 	'が': "ga", 'ぎ': "gi", 'ぐ': "gu", 'げ': "ge", 'ご': "go",
 	'ざ': "za", 'じ': "ji", 'ず': "zu", 'ぜ': "ze", 'ぞ': "zo",
 	'だ': "da", 'ぢ': "ji", 'づ': "zu", 'で': "de", 'ど': "do",
 	'ば': "ba", 'び': "bi", 'ぶ': "bu", 'べ': "be", 'ぼ': "bo",
+	// Handakuten (semi-voiced)
 	'ぱ': "pa", 'ぴ': "pi", 'ぷ': "pu", 'ぺ': "pe", 'ぽ': "po",
+	// Small characters
 	'ゃ': "ya", 'ゅ': "yu", 'ょ': "yo",
-	'っ': "",
+	'っ': "", // Double consonant marker
 	'ぁ': "a", 'ぃ': "i", 'ぅ': "u", 'ぇ': "e", 'ぉ': "o",
 }

@@ -37,15 +40,19 @@ var katakanaToRomaji = map[rune]string{
 	'ヤ': "ya", 'ユ': "yu", 'ヨ': "yo",
 	'ラ': "ra", 'リ': "ri", 'ル': "ru", 'レ': "re", 'ロ': "ro",
 	'ワ': "wa", 'ヲ': "wo", 'ン': "n",
+	// Dakuten (voiced)
 	'ガ': "ga", 'ギ': "gi", 'グ': "gu", 'ゲ': "ge", 'ゴ': "go",
 	'ザ': "za", 'ジ': "ji", 'ズ': "zu", 'ゼ': "ze", 'ゾ': "zo",
 	'ダ': "da", 'ヂ': "ji", 'ヅ': "zu", 'デ': "de", 'ド': "do",
 	'バ': "ba", 'ビ': "bi", 'ブ': "bu", 'ベ': "be", 'ボ': "bo",
+	// Handakuten (semi-voiced)
 	'パ': "pa", 'ピ': "pi", 'プ': "pu", 'ペ': "pe", 'ポ': "po",
+	// Small characters
 	'ャ': "ya", 'ュ': "yu", 'ョ': "yo",
-	'ッ': "",
+	'ッ': "", // Double consonant marker
 	'ァ': "a", 'ィ': "i", 'ゥ': "u", 'ェ': "e", 'ォ': "o",
-	'ー': "",
+	// Extended katakana
+	'ー': "", // Long vowel mark
 	'ヴ': "vu",
 }

@@ -75,6 +82,7 @@ var combinationKatakana = map[string]string{
 	"ジャ": "ja", "ジュ": "ju", "ジョ": "jo",
 	"ビャ": "bya", "ビュ": "byu", "ビョ": "byo",
 	"ピャ": "pya", "ピュ": "pyu", "ピョ": "pyo",
+	// Extended combinations
 	"ティ": "ti", "ディ": "di", "トゥ": "tu", "ドゥ": "du",
 	"ファ": "fa", "フィ": "fi", "フェ": "fe", "フォ": "fo",
 	"ウィ": "wi", "ウェ": "we", "ウォ": "wo",
@@ -112,6 +120,7 @@ func JapaneseToRomaji(text string) string {
 	i := 0

 	for i < len(runes) {
+		// Check for っ/ッ (double consonant)
 		if i < len(runes)-1 && (runes[i] == 'っ' || runes[i] == 'ッ') {
 			nextRomaji := ""
 			if romaji, ok := hiraganaToRomaji[runes[i+1]]; ok {
@@ -120,12 +129,13 @@ func JapaneseToRomaji(text string) string {
 				nextRomaji = romaji
 			}
 			if len(nextRomaji) > 0 {
-				result.WriteByte(nextRomaji[0])
+				result.WriteByte(nextRomaji[0]) // Double the first consonant
 			}
 			i++
 			continue
 		}

+		// Check for two-character combinations
 		if i < len(runes)-1 {
 			combo := string(runes[i : i+2])
 			if romaji, ok := combinationHiragana[combo]; ok {
@@ -140,14 +150,17 @@ func JapaneseToRomaji(text string) string {
 			}
 		}

+		// Single character conversion
 		r := runes[i]
 		if romaji, ok := hiraganaToRomaji[r]; ok {
 			result.WriteString(romaji)
 		} else if romaji, ok := katakanaToRomaji[r]; ok {
 			result.WriteString(romaji)
 		} else if isKanji(r) {
+			// Keep kanji as-is (would need dictionary for proper conversion)
 			result.WriteRune(r)
 		} else {
+			// Keep other characters (punctuation, spaces, etc.)
 			result.WriteRune(r)
 		}
 		i++
@@ -0,0 +1,80 @@
+package gobackend
+
+import (
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestSanitizeSensitiveLogText(t *testing.T) {
+	input := "access_token=abc123 Authorization:Bearer xyz456 https://api.example.com/cb?refresh_token=zzz"
+	redacted := sanitizeSensitiveLogText(input)
+
+	if strings.Contains(redacted, "abc123") || strings.Contains(redacted, "xyz456") || strings.Contains(redacted, "zzz") {
+		t.Fatalf("expected sensitive values to be redacted, got: %s", redacted)
+	}
+	if !strings.Contains(redacted, "[REDACTED]") {
+		t.Fatalf("expected redaction marker in output, got: %s", redacted)
+	}
+}
+
+func TestValidateExtensionAuthURL(t *testing.T) {
+	if err := validateExtensionAuthURL("https://accounts.example.com/oauth/authorize"); err != nil {
+		t.Fatalf("expected valid auth URL, got error: %v", err)
+	}
+
+	blocked := []string{
+		"http://accounts.example.com/oauth/authorize",
+		"https://user:pass@accounts.example.com/oauth/authorize",
+		"https://localhost/oauth/authorize",
+	}
+
+	for _, rawURL := range blocked {
+		if err := validateExtensionAuthURL(rawURL); err == nil {
+			t.Fatalf("expected URL to be blocked: %s", rawURL)
+		}
+	}
+}
+
+func TestValidateDomainRejectsEmbeddedCredentials(t *testing.T) {
+	ext := &LoadedExtension{
+		ID: "test-ext",
+		Manifest: &ExtensionManifest{
+			Name: "test-ext",
+			Permissions: ExtensionPermissions{
+				Network: []string{"api.example.com"},
+			},
+		},
+		DataDir: t.TempDir(),
+	}
+
+	runtime := NewExtensionRuntime(ext)
+	if err := runtime.validateDomain("https://user:pass@api.example.com/resource"); err == nil {
+		t.Fatal("expected embedded URL credentials to be rejected")
+	}
+}
+
+func TestBuildStoreExtensionDestPath(t *testing.T) {
+	baseDir := t.TempDir()
+
+	destPath, err := buildStoreExtensionDestPath(baseDir, "../evil/name")
+	if err != nil {
+		t.Fatalf("expected sanitized path to be generated, got error: %v", err)
+	}
+
+	if !isPathWithinBase(baseDir, destPath) {
+		t.Fatalf("expected destination path to remain under base dir: %s", destPath)
+	}
+
+	baseName := filepath.Base(destPath)
+	if strings.Contains(baseName, "/") || strings.Contains(baseName, `\`) {
+		t.Fatalf("expected filename to be sanitized, got: %s", baseName)
+	}
+	if !strings.HasSuffix(baseName, ".spotiflac-ext") {
+		t.Fatalf("expected .spotiflac-ext suffix, got: %s", baseName)
+	}
+
+	if _, err := buildStoreExtensionDestPath(baseDir, "   "); err == nil {
+		t.Fatal("expected empty extension id to be rejected")
+	}
+}
@@ -1,7 +1,6 @@
 package gobackend

 import (
-	"bytes"
 	"context"
 	"encoding/json"
 	"fmt"
@@ -15,10 +14,6 @@ type SongLinkClient struct {
 	client *http.Client
 }

-type songLinkPlatformLink struct {
-	URL string `json:"url"`
-}
-
 type TrackAvailability struct {
 	SpotifyID  string `json:"spotify_id"`
 	Tidal      bool   `json:"tidal"`
@@ -48,7 +43,6 @@ var (
 	songLinkCheckAvailabilityFromDeezer = func(s *SongLinkClient, deezerTrackID string) (*TrackAvailability, error) {
 		return s.CheckAvailabilityFromDeezer(deezerTrackID)
 	}
-	songLinkRetryConfig = DefaultRetryConfig
 )

 func NewSongLinkClient() *SongLinkClient {
@@ -87,210 +81,38 @@ func GetSongLinkRegion() string {
 	return region
 }

-const resolveAPIURL = "https://api.zarz.moe/v1/resolve"
-
 func songLinkBaseURL() string {
+	opts := GetNetworkCompatibilityOptions()
+	if opts.AllowHTTP {
+		return "http://api.song.link/v1-alpha.1/links"
+	}
 	return "https://api.song.link/v1-alpha.1/links"
 }

-// resolveTrackPlatforms resolves a music URL to all platforms.
-// Spotify URLs use the resolve API; if that fails, falls back to SongLink.
-// All other URLs go directly to SongLink.
-func (s *SongLinkClient) resolveTrackPlatforms(inputURL string) (map[string]songLinkPlatformLink, error) {
-	if isSpotifyURL(inputURL) {
-		payload, err := json.Marshal(map[string]string{"url": inputURL})
-		if err != nil {
-			return nil, fmt.Errorf("failed to encode resolve request: %w", err)
-		}
-		links, err := s.doResolveRequest(payload)
-		if err == nil {
-			return links, nil
-		}
-		GoLog("[SongLink] Resolve proxy failed for %s: %v, falling back to SongLink", inputURL, err)
-		return s.songLinkByTargetURL(inputURL)
+func buildSongLinkURLFromTarget(targetURL string, userCountry string) string {
+	if userCountry == "" {
+		userCountry = GetSongLinkRegion()
 	}
-	return s.songLinkByTargetURL(inputURL)
+	apiURL := fmt.Sprintf("%s?url=%s", songLinkBaseURL(), url.QueryEscape(targetURL))
+	if userCountry != "" {
+		apiURL = fmt.Sprintf("%s&userCountry=%s", apiURL, url.QueryEscape(userCountry))
+	}
+	return apiURL
 }

-// resolveTrackPlatformsByPlatform resolves using platform + type + id.
-// Spotify uses the resolve API with SongLink fallback; all other platforms use SongLink directly.
-func (s *SongLinkClient) resolveTrackPlatformsByPlatform(platform, entityType, entityID string) (map[string]songLinkPlatformLink, error) {
-	if strings.EqualFold(platform, "spotify") {
-		payload, err := json.Marshal(map[string]string{
-			"platform": platform,
-			"type":     entityType,
-			"id":       entityID,
-		})
-		if err != nil {
-			return nil, fmt.Errorf("failed to encode resolve request: %w", err)
-		}
-		links, err := s.doResolveRequest(payload)
-		if err == nil {
-			return links, nil
-		}
-		GoLog("[SongLink] Resolve proxy failed for %s/%s/%s: %v, falling back to SongLink", platform, entityType, entityID, err)
-		return s.songLinkByPlatform(platform, entityType, entityID)
+func buildSongLinkURLByPlatform(platform, entityType, entityID, userCountry string) string {
+	if userCountry == "" {
+		userCountry = GetSongLinkRegion()
 	}
-	return s.songLinkByPlatform(platform, entityType, entityID)
-}
-
-func isSpotifyURL(u string) bool {
-	lower := strings.ToLower(u)
-	return strings.Contains(lower, "spotify.com/") || strings.Contains(lower, "spotify:")
-}
-
-// doResolveRequest sends a JSON payload to the resolve API (api.zarz.moe)
-// and parses the response into a platform link map.
-func (s *SongLinkClient) doResolveRequest(payload []byte) (map[string]songLinkPlatformLink, error) {
-	req, err := http.NewRequest("POST", resolveAPIURL, bytes.NewReader(payload))
-	if err != nil {
-		return nil, fmt.Errorf("failed to create resolve request: %w", err)
-	}
-	req.Header.Set("Content-Type", "application/json")
-
-	resp, err := s.client.Do(req)
-	if err != nil {
-		return nil, fmt.Errorf("resolve API request failed: %w", err)
-	}
-	defer resp.Body.Close()
-
-	if resp.StatusCode != 200 {
-		return nil, fmt.Errorf("resolve API returned status %d", resp.StatusCode)
-	}
-
-	body, err := ReadResponseBody(resp)
-	if err != nil {
-		return nil, fmt.Errorf("failed to read resolve response: %w", err)
-	}
-
-	var resolveResp struct {
-		Success  bool                           `json:"success"`
-		ISRC     string                         `json:"isrc"`
-		SongUrls map[string]json.RawMessage     `json:"songUrls"`
-	}
-	if err := json.Unmarshal(body, &resolveResp); err != nil {
-		return nil, fmt.Errorf("failed to decode resolve response: %w", err)
-	}
-	if !resolveResp.Success {
-		return nil, fmt.Errorf("resolve API returned success=false")
-	}
-
-	keyMap := map[string]string{
-		"Spotify":      "spotify",
-		"Deezer":       "deezer",
-		"Tidal":        "tidal",
-		"YouTubeMusic": "youtubeMusic",
-		"YouTube":      "youtube",
-		"AmazonMusic":  "amazonMusic",
-		"Qobuz":        "qobuz",
-		"AppleMusic":   "appleMusic",
-	}
-
-	links := make(map[string]songLinkPlatformLink)
-	for resolveKey, platformKey := range keyMap {
-		rawValue, ok := resolveResp.SongUrls[resolveKey]
-		if !ok {
-			continue
-		}
-		if u := extractResolveURLValue(rawValue); u != "" {
-			links[platformKey] = songLinkPlatformLink{URL: u}
-		}
-	}
-
-	if len(links) == 0 {
-		return nil, fmt.Errorf("resolve API returned no platform links")
-	}
-
-	return links, nil
-}
-
-func extractResolveURLValue(raw json.RawMessage) string {
-	trimmed := bytes.TrimSpace(raw)
-	if len(trimmed) == 0 || bytes.Equal(trimmed, []byte("null")) {
-		return ""
-	}
-
-	var direct string
-	if err := json.Unmarshal(trimmed, &direct); err == nil {
-		return strings.TrimSpace(direct)
-	}
-
-	var list []string
-	if err := json.Unmarshal(trimmed, &list); err == nil {
-		for _, candidate := range list {
-			if cleaned := strings.TrimSpace(candidate); cleaned != "" {
-				return cleaned
-			}
-		}
-	}
-
-	return ""
-}
-
-// songLinkByTargetURL calls the SongLink API with a target URL (for non-Spotify URLs).
-func (s *SongLinkClient) songLinkByTargetURL(targetURL string) (map[string]songLinkPlatformLink, error) {
-	songLinkRateLimiter.WaitForSlot()
-
-	apiURL := fmt.Sprintf("%s?url=%s&userCountry=%s",
-		songLinkBaseURL(),
-		url.QueryEscape(targetURL),
-		url.QueryEscape(GetSongLinkRegion()))
-
-	return s.doSongLinkRequest(apiURL)
-}
-
-// songLinkByPlatform calls the SongLink API with platform + type + id (for non-Spotify platforms).
-func (s *SongLinkClient) songLinkByPlatform(platform, entityType, entityID string) (map[string]songLinkPlatformLink, error) {
-	songLinkRateLimiter.WaitForSlot()
-
-	apiURL := fmt.Sprintf("%s?platform=%s&type=%s&id=%s&userCountry=%s",
+	apiURL := fmt.Sprintf("%s?platform=%s&type=%s&id=%s",
 		songLinkBaseURL(),
 		url.QueryEscape(platform),
 		url.QueryEscape(entityType),
-		url.QueryEscape(entityID),
-		url.QueryEscape(GetSongLinkRegion()))
-
-	return s.doSongLinkRequest(apiURL)
-}
-
-// doSongLinkRequest calls the SongLink API and parses the response.
-func (s *SongLinkClient) doSongLinkRequest(apiURL string) (map[string]songLinkPlatformLink, error) {
-	req, err := http.NewRequest("GET", apiURL, nil)
-	if err != nil {
-		return nil, fmt.Errorf("failed to create SongLink request: %w", err)
+		url.QueryEscape(entityID))
+	if userCountry != "" {
+		apiURL = fmt.Sprintf("%s&userCountry=%s", apiURL, url.QueryEscape(userCountry))
 	}
-
-	retryConfig := songLinkRetryConfig()
-	resp, err := DoRequestWithRetry(s.client, req, retryConfig)
-	if err != nil {
-		return nil, fmt.Errorf("SongLink request failed: %w", err)
-	}
-	defer resp.Body.Close()
-
-	if resp.StatusCode == 429 {
-		return nil, fmt.Errorf("SongLink rate limit exceeded")
-	}
-	if resp.StatusCode != 200 {
-		return nil, fmt.Errorf("SongLink returned status %d", resp.StatusCode)
-	}
-
-	body, err := ReadResponseBody(resp)
-	if err != nil {
-		return nil, fmt.Errorf("failed to read SongLink response: %w", err)
-	}
-
-	var songLinkResp struct {
-		LinksByPlatform map[string]songLinkPlatformLink `json:"linksByPlatform"`
-	}
-	if err := json.Unmarshal(body, &songLinkResp); err != nil {
-		return nil, fmt.Errorf("failed to decode SongLink response: %w", err)
-	}
-
-	if len(songLinkResp.LinksByPlatform) == 0 {
-		return nil, fmt.Errorf("SongLink returned no platform links")
-	}
-
-	return songLinkResp.LinksByPlatform, nil
+	return apiURL
 }

 func (s *SongLinkClient) CheckTrackAvailability(spotifyTrackID string, isrc string) (*TrackAvailability, error) {
@@ -308,12 +130,95 @@ func (s *SongLinkClient) CheckTrackAvailability(spotifyTrackID string, isrc stri
 }

 func (s *SongLinkClient) checkTrackAvailabilityFromSpotify(spotifyTrackID string) (*TrackAvailability, error) {
+	songLinkRateLimiter.WaitForSlot()
+
 	spotifyURL := fmt.Sprintf("https://open.spotify.com/track/%s", spotifyTrackID)
-	links, err := s.resolveTrackPlatforms(spotifyURL)
+	apiURL := buildSongLinkURLFromTarget(spotifyURL, "")
+
+	req, err := http.NewRequest("GET", apiURL, nil)
 	if err != nil {
-		return nil, fmt.Errorf("resolve proxy failed for Spotify %s: %w", spotifyTrackID, err)
+		return nil, fmt.Errorf("failed to create request: %w", err)
 	}
-	return buildTrackAvailabilityFromSongLinkLinks(spotifyTrackID, links), nil
+
+	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 {
+		return nil, fmt.Errorf("track not found on SongLink (invalid Spotify ID or track unavailable)")
+	}
+	if resp.StatusCode == 404 {
+		return nil, fmt.Errorf("track not found on any streaming platform")
+	}
+	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"`
+		} `json:"linksByPlatform"`
+	}
+
+	if err := json.Unmarshal(body, &songLinkResp); err != nil {
+		return nil, fmt.Errorf("failed to decode response: %w", err)
+	}
+
+	availability := &TrackAvailability{
+		SpotifyID: spotifyTrackID,
+	}
+
+	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 deezerLink, ok := songLinkResp.LinksByPlatform["deezer"]; ok && deezerLink.URL != "" {
+		availability.Deezer = true
+		availability.DeezerURL = deezerLink.URL
+		availability.DeezerID = extractDeezerIDFromURL(deezerLink.URL)
+	}
+
+	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
 }

 func (s *SongLinkClient) checkTrackAvailabilityFromISRC(isrc string) (*TrackAvailability, error) {
@@ -508,6 +413,8 @@ func extractYouTubeIDFromURL(youtubeURL string) string {
 	return ""
 }

+// isNumeric is defined in library_scan.go
+
 func (s *SongLinkClient) GetDeezerIDFromSpotify(spotifyTrackID string) (string, error) {
 	availability, err := s.CheckTrackAvailability(spotifyTrackID, "")
 	if err != nil {
@@ -542,17 +449,47 @@ type AlbumAvailability struct {
 }

 func (s *SongLinkClient) CheckAlbumAvailability(spotifyAlbumID string) (*AlbumAvailability, error) {
+	songLinkRateLimiter.WaitForSlot()
+
 	spotifyURL := fmt.Sprintf("https://open.spotify.com/album/%s", spotifyAlbumID)
-	links, err := s.resolveTrackPlatforms(spotifyURL)
+	apiURL := buildSongLinkURLFromTarget(spotifyURL, "")
+
+	req, err := http.NewRequest("GET", apiURL, nil)
 	if err != nil {
-		return nil, fmt.Errorf("resolve proxy failed for album %s: %w", spotifyAlbumID, err)
+		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 album availability: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != 200 {
+		return nil, fmt.Errorf("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"`
+		} `json:"linksByPlatform"`
+	}
+
+	if err := json.Unmarshal(body, &songLinkResp); err != nil {
+		return nil, fmt.Errorf("failed to decode response: %w", err)
 	}

 	availability := &AlbumAvailability{
 		SpotifyID: spotifyAlbumID,
 	}

-	if deezerLink, ok := links["deezer"]; ok && deezerLink.URL != "" {
+	if deezerLink, ok := songLinkResp.LinksByPlatform["deezer"]; ok && deezerLink.URL != "" {
 		availability.Deezer = true
 		availability.DeezerURL = deezerLink.URL
 		availability.DeezerID = extractDeezerIDFromURL(deezerLink.URL)
@@ -595,19 +532,101 @@ func (s *SongLinkClient) CheckAvailabilityFromDeezer(deezerTrackID string) (*Tra
 }

 func (s *SongLinkClient) checkAvailabilityFromDeezerSongLink(deezerTrackID string) (*TrackAvailability, error) {
+	songLinkRateLimiter.WaitForSlot()
+
 	deezerURL := fmt.Sprintf("https://www.deezer.com/track/%s", deezerTrackID)
-	links, err := s.resolveTrackPlatforms(deezerURL)
+	apiURL := buildSongLinkURLFromTarget(deezerURL, "")
+
+	req, err := http.NewRequest("GET", apiURL, nil)
 	if err != nil {
-		return nil, fmt.Errorf("resolve failed for Deezer %s: %w", deezerTrackID, err)
+		return nil, fmt.Errorf("failed to create request: %w", err)
 	}

-	availability := buildTrackAvailabilityFromSongLinkLinks("", links)
-	// Ensure Deezer is always marked available since we started from a Deezer URL
-	availability.Deezer = true
-	availability.DeezerID = deezerTrackID
-	if availability.DeezerURL == "" {
-		availability.DeezerURL = deezerURL
+	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 {
+		return nil, fmt.Errorf("track not found on SongLink (invalid Deezer ID)")
+	}
+	if resp.StatusCode == 404 {
+		return nil, fmt.Errorf("track not found on any streaming platform")
+	}
+	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"`
+		} `json:"linksByPlatform"`
+		EntitiesByUniqueId map[string]struct {
+			ID         string `json:"id"`
+			Type       string `json:"type"`
+			Title      string `json:"title"`
+			ArtistName string `json:"artistName"`
+		} `json:"entitiesByUniqueId"`
+	}
+
+	if err := json.Unmarshal(body, &songLinkResp); err != nil {
+		return nil, fmt.Errorf("failed to decode response: %w", err)
+	}
+
+	availability := &TrackAvailability{
+		Deezer:   true,
+		DeezerID: deezerTrackID,
+	}
+
+	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.DeezerURL = deezerLink.URL
+	}
+
+	// Prefer youtubeMusic URLs — they are usually closer to music catalog matches.
+	if ytMusicLink, ok := songLinkResp.LinksByPlatform["youtubeMusic"]; ok && ytMusicLink.URL != "" {
+		availability.YouTube = true
+		availability.YouTubeURL = ytMusicLink.URL
+		availability.YouTubeID = extractYouTubeIDFromURL(ytMusicLink.URL)
+	}
+	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
 }

@@ -619,57 +638,94 @@ func (s *SongLinkClient) CheckAvailabilityByPlatform(platform, entityType, entit
 		return nil, fmt.Errorf("%s ID is empty", platform)
 	}

-	links, err := s.resolveTrackPlatformsByPlatform(platform, entityType, entityID)
+	songLinkRateLimiter.WaitForSlot()
+
+	apiURL := buildSongLinkURLByPlatform(platform, entityType, entityID, "")
+
+	req, err := http.NewRequest("GET", apiURL, nil)
 	if err != nil {
-		return nil, fmt.Errorf("resolve failed for %s %s: %w", platform, entityID, err)
+		return nil, fmt.Errorf("failed to create request: %w", err)
 	}

-	return buildTrackAvailabilityFromSongLinkLinks("", links), nil
-}
+	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()

-func buildTrackAvailabilityFromSongLinkLinks(spotifyTrackID string, links map[string]songLinkPlatformLink) *TrackAvailability {
-	availability := &TrackAvailability{
-		SpotifyID: spotifyTrackID,
+	if resp.StatusCode == 400 {
+		return nil, fmt.Errorf("track not found on SongLink (invalid %s ID)", platform)
+	}
+	if resp.StatusCode == 404 {
+		return nil, fmt.Errorf("track not found on any streaming platform")
+	}
+	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)
 	}

-	if availability.SpotifyID == "" {
-		if spotifyLink, ok := links["spotify"]; ok && spotifyLink.URL != "" {
-			availability.SpotifyID = extractSpotifyIDFromURL(spotifyLink.URL)
-		}
+	body, err := ReadResponseBody(resp)
+	if err != nil {
+		return nil, fmt.Errorf("failed to read response: %w", err)
 	}
-	if tidalLink, ok := links["tidal"]; ok && tidalLink.URL != "" {
+
+	var songLinkResp struct {
+		LinksByPlatform map[string]struct {
+			URL string `json:"url"`
+		} `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 := links["amazonMusic"]; ok && amazonLink.URL != "" {
+
+	if amazonLink, ok := songLinkResp.LinksByPlatform["amazonMusic"]; ok && amazonLink.URL != "" {
 		availability.Amazon = true
 		availability.AmazonURL = amazonLink.URL
 	}
-	if qobuzLink, ok := links["qobuz"]; ok && qobuzLink.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 := links["deezer"]; ok && deezerLink.URL != "" {
+
+	if deezerLink, ok := songLinkResp.LinksByPlatform["deezer"]; ok && deezerLink.URL != "" {
 		availability.Deezer = true
 		availability.DeezerURL = deezerLink.URL
 		availability.DeezerID = extractDeezerIDFromURL(deezerLink.URL)
 	}
-	if ytMusicLink, ok := links["youtubeMusic"]; ok && ytMusicLink.URL != "" {
+
+	// Prefer youtubeMusic URLs — they are usually closer to music catalog matches.
+	if ytMusicLink, ok := songLinkResp.LinksByPlatform["youtubeMusic"]; ok && ytMusicLink.URL != "" {
 		availability.YouTube = true
 		availability.YouTubeURL = ytMusicLink.URL
 		availability.YouTubeID = extractYouTubeIDFromURL(ytMusicLink.URL)
 	}
 	if !availability.YouTube {
-		if youtubeLink, ok := links["youtube"]; ok && youtubeLink.URL != "" {
+		if youtubeLink, ok := songLinkResp.LinksByPlatform["youtube"]; ok && youtubeLink.URL != "" {
 			availability.YouTube = true
 			availability.YouTubeURL = youtubeLink.URL
 			availability.YouTubeID = extractYouTubeIDFromURL(youtubeLink.URL)
 		}
 	}

-	return availability
+	return availability, nil
 }

 func extractSpotifyIDFromURL(spotifyURL string) string {
@@ -737,10 +793,85 @@ func (s *SongLinkClient) GetYouTubeURLFromDeezer(deezerTrackID string) (string,
 }

 func (s *SongLinkClient) CheckAvailabilityFromURL(inputURL string) (*TrackAvailability, error) {
-	links, err := s.resolveTrackPlatforms(inputURL)
+	songLinkRateLimiter.WaitForSlot()
+
+	apiURL := buildSongLinkURLFromTarget(inputURL, "")
+
+	req, err := http.NewRequest("GET", apiURL, nil)
 	if err != nil {
-		return nil, fmt.Errorf("resolve failed for URL %s: %w", inputURL, err)
+		return nil, fmt.Errorf("failed to create request: %w", err)
 	}

-	return buildTrackAvailabilityFromSongLinkLinks("", links), nil
+	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)
+	}
+	// Prefer youtubeMusic URLs — they are usually closer to music catalog matches.
+	if ytMusicLink, ok := songLinkResp.LinksByPlatform["youtubeMusic"]; ok && ytMusicLink.URL != "" {
+		availability.YouTube = true
+		availability.YouTubeURL = ytMusicLink.URL
+		availability.YouTubeID = extractYouTubeIDFromURL(ytMusicLink.URL)
+	}
+	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
 }
@@ -1,199 +0,0 @@
-package gobackend
-
-import (
-	"io"
-	"net/http"
-	"strings"
-	"testing"
-)
-
-type roundTripFunc func(*http.Request) (*http.Response, error)
-
-func (fn roundTripFunc) RoundTrip(req *http.Request) (*http.Response, error) {
-	return fn(req)
-}
-
-func TestGetRetryAfterDurationMissingHeaderReturnsZero(t *testing.T) {
-	resp := &http.Response{
-		Header: make(http.Header),
-	}
-
-	if got := getRetryAfterDuration(resp); got != 0 {
-		t.Fatalf("getRetryAfterDuration() = %v, want 0", got)
-	}
-}
-
-func TestCheckTrackAvailabilityFromSpotifyViaResolveAPI(t *testing.T) {
-	origRetryConfig := songLinkRetryConfig
-	defer func() { songLinkRetryConfig = origRetryConfig }()
-
-	client := &SongLinkClient{
-		client: &http.Client{
-			Transport: roundTripFunc(func(req *http.Request) (*http.Response, error) {
-				if req.URL.Host == "api.zarz.moe" && req.URL.Path == "/v1/resolve" && req.Method == "POST" {
-					body := `{"success":true,"isrc":"USRC12345678","songUrls":{"Spotify":"https://open.spotify.com/track/testspotifyid","Deezer":"https://www.deezer.com/track/908604612","AmazonMusic":"https://music.amazon.com/albums/B086Q2QNLH?trackAsin=B086Q41M9C","Tidal":"https://listen.tidal.com/track/134858527","Qobuz":"https://open.qobuz.com/track/195125822","YouTubeMusic":"https://music.youtube.com/watch?v=testvideoid1"}}`
-					return &http.Response{
-						StatusCode: 200,
-						Header:     make(http.Header),
-						Body:       io.NopCloser(strings.NewReader(body)),
-						Request:    req,
-					}, nil
-				}
-				t.Fatalf("unexpected request: %s %s", req.Method, req.URL.String())
-				return nil, nil
-			}),
-		},
-	}
-
-	availability, err := client.CheckTrackAvailability("testspotifyid", "")
-	if err != nil {
-		t.Fatalf("CheckTrackAvailability() error = %v", err)
-	}
-
-	if availability.SpotifyID != "testspotifyid" {
-		t.Fatalf("SpotifyID = %q, want %q", availability.SpotifyID, "testspotifyid")
-	}
-	if !availability.Deezer || availability.DeezerID != "908604612" {
-		t.Fatalf("Deezer availability = %+v, want DeezerID 908604612", availability)
-	}
-	if !availability.Amazon || !availability.Tidal || !availability.Qobuz || !availability.YouTube {
-		t.Fatalf("availability flags = %+v, want Amazon/Tidal/Qobuz/YouTube true", availability)
-	}
-	if availability.YouTubeID != "testvideoid1" {
-		t.Fatalf("YouTubeID = %q, want %q", availability.YouTubeID, "testvideoid1")
-	}
-}
-
-func TestCheckTrackAvailabilityFromSpotifyResolveAPIFailure(t *testing.T) {
-	origRetryConfig := songLinkRetryConfig
-	songLinkRetryConfig = func() RetryConfig {
-		return RetryConfig{MaxRetries: 0, InitialDelay: 0, MaxDelay: 0, BackoffFactor: 1}
-	}
-	defer func() { songLinkRetryConfig = origRetryConfig }()
-
-	var hitSongLink bool
-
-	client := &SongLinkClient{
-		client: &http.Client{
-			Transport: roundTripFunc(func(req *http.Request) (*http.Response, error) {
-				// Resolve proxy returns 500
-				if req.URL.Host == "api.zarz.moe" && req.URL.Path == "/v1/resolve" {
-					return &http.Response{
-						StatusCode: 500,
-						Header:     make(http.Header),
-						Body:       io.NopCloser(strings.NewReader("internal error")),
-						Request:    req,
-					}, nil
-				}
-				// SongLink fallback should be called
-				if req.URL.Host == "api.song.link" {
-					hitSongLink = true
-					body := `{"linksByPlatform":{"spotify":{"url":"https://open.spotify.com/track/testspotifyid"},"deezer":{"url":"https://www.deezer.com/track/908604612"},"tidal":{"url":"https://listen.tidal.com/track/134858527"}}}`
-					return &http.Response{
-						StatusCode: 200,
-						Header:     make(http.Header),
-						Body:       io.NopCloser(strings.NewReader(body)),
-						Request:    req,
-					}, nil
-				}
-				t.Fatalf("unexpected request: %s %s", req.Method, req.URL.String())
-				return nil, nil
-			}),
-		},
-	}
-
-	availability, err := client.CheckTrackAvailability("testspotifyid", "")
-	if err != nil {
-		t.Fatalf("expected SongLink fallback to succeed, got error: %v", err)
-	}
-	if !hitSongLink {
-		t.Fatal("expected fallback request to SongLink API, but it was never called")
-	}
-	if !availability.Deezer || availability.DeezerID != "908604612" {
-		t.Fatalf("Deezer availability via fallback = %+v, want DeezerID 908604612", availability)
-	}
-}
-
-func TestCheckTrackAvailabilityFromSpotifyViaResolveAPIMixedSongURLShapes(t *testing.T) {
-	origRetryConfig := songLinkRetryConfig
-	defer func() { songLinkRetryConfig = origRetryConfig }()
-
-	client := &SongLinkClient{
-		client: &http.Client{
-			Transport: roundTripFunc(func(req *http.Request) (*http.Response, error) {
-				if req.URL.Host == "api.zarz.moe" && req.URL.Path == "/v1/resolve" && req.Method == "POST" {
-					body := `{"success":true,"isrc":"TCAHA2367688","songUrls":{"Spotify":"https://open.spotify.com/track/5glgyj6zH0irbNGfukHacv","Deezer":"https://www.deezer.com/track/2248583177","Tidal":"https://tidal.com/browse/track/290565315","AppleMusic":"https://geo.music.apple.com/us/album/example?i=1","YouTubeMusic":null,"YouTube":"https://www.youtube.com/watch?v=wD_e59XUNdQ","AmazonMusic":"https://music.amazon.com/tracks/B0C35TG38Y/?ref=dm_ff_amazonmusic_3p","Beatport":null,"BeatSource":null,"SoundCloud":null,"Qobuz":null,"Other":[]}}`
-					return &http.Response{
-						StatusCode: 200,
-						Header:     make(http.Header),
-						Body:       io.NopCloser(strings.NewReader(body)),
-						Request:    req,
-					}, nil
-				}
-				t.Fatalf("unexpected request: %s %s", req.Method, req.URL.String())
-				return nil, nil
-			}),
-		},
-	}
-
-	availability, err := client.CheckTrackAvailability("5glgyj6zH0irbNGfukHacv", "")
-	if err != nil {
-		t.Fatalf("CheckTrackAvailability() error = %v", err)
-	}
-
-	if availability.SpotifyID != "5glgyj6zH0irbNGfukHacv" {
-		t.Fatalf("SpotifyID = %q, want %q", availability.SpotifyID, "5glgyj6zH0irbNGfukHacv")
-	}
-	if !availability.Deezer || availability.DeezerID != "2248583177" {
-		t.Fatalf("Deezer availability = %+v, want DeezerID 2248583177", availability)
-	}
-	if !availability.Tidal || availability.TidalID != "290565315" {
-		t.Fatalf("Tidal availability = %+v, want TidalID 290565315", availability)
-	}
-	if availability.Qobuz {
-		t.Fatalf("Qobuz should remain false when resolve response contains null, got %+v", availability)
-	}
-}
-
-func TestCheckAvailabilityFromDeezerUsesSongLink(t *testing.T) {
-	origRetryConfig := songLinkRetryConfig
-	songLinkRetryConfig = func() RetryConfig {
-		return RetryConfig{MaxRetries: 0, InitialDelay: 0, MaxDelay: 0, BackoffFactor: 1}
-	}
-	defer func() { songLinkRetryConfig = origRetryConfig }()
-
-	client := &SongLinkClient{
-		client: &http.Client{
-			Transport: roundTripFunc(func(req *http.Request) (*http.Response, error) {
-				// Non-Spotify should go to SongLink, not resolve API
-				if req.URL.Host == "api.zarz.moe" {
-					t.Fatalf("non-Spotify URL should not hit resolve API, got: %s", req.URL.String())
-					return nil, nil
-				}
-				if req.URL.Host == "api.song.link" {
-					body := `{"linksByPlatform":{"spotify":{"url":"https://open.spotify.com/track/testid"},"deezer":{"url":"https://www.deezer.com/track/908604612"},"tidal":{"url":"https://listen.tidal.com/track/134858527"},"qobuz":{"url":"https://open.qobuz.com/track/195125822"},"youtubeMusic":{"url":"https://music.youtube.com/watch?v=testvid"}}}`
-					return &http.Response{
-						StatusCode: 200,
-						Header:     make(http.Header),
-						Body:       io.NopCloser(strings.NewReader(body)),
-						Request:    req,
-					}, nil
-				}
-				t.Fatalf("unexpected request: %s %s", req.Method, req.URL.String())
-				return nil, nil
-			}),
-		},
-	}
-
-	availability, err := client.checkAvailabilityFromDeezerSongLink("908604612")
-	if err != nil {
-		t.Fatalf("checkAvailabilityFromDeezerSongLink() error = %v", err)
-	}
-
-	if !availability.Deezer || availability.DeezerID != "908604612" {
-		t.Fatalf("Deezer = %+v, want DeezerID 908604612", availability)
-	}
-	if availability.SpotifyID != "testid" {
-		t.Fatalf("SpotifyID = %q, want %q", availability.SpotifyID, "testid")
-	}
-}
@@ -0,0 +1,80 @@
+package gobackend
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"strings"
+	"time"
+)
+
+const DefaultSpotFetchAPIBaseURL = "https://spotify.afkarxyz.fun/api"
+
+// GetSpotifyDataWithAPI fetches Spotify metadata through SpotFetch-compatible API.
+// This is used as a fallback when direct Spotify API access is blocked/limited.
+func GetSpotifyDataWithAPI(ctx context.Context, spotifyURL, apiBaseURL string) (interface{}, error) {
+	parsed, err := parseSpotifyURI(spotifyURL)
+	if err != nil {
+		return nil, fmt.Errorf("invalid Spotify URL: %w", err)
+	}
+
+	base := strings.TrimSpace(apiBaseURL)
+	if base == "" {
+		base = DefaultSpotFetchAPIBaseURL
+	}
+
+	endpoint := fmt.Sprintf("%s/%s/%s", strings.TrimSuffix(base, "/"), parsed.Type, parsed.ID)
+	req, err := http.NewRequestWithContext(ctx, "GET", endpoint, nil)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create SpotFetch API request: %w", err)
+	}
+	req.Header.Set("User-Agent", getRandomUserAgent())
+	req.Header.Set("Accept", "application/json")
+
+	client := NewHTTPClientWithTimeout(30 * time.Second)
+	resp, err := client.Do(req)
+	if err != nil {
+		return nil, fmt.Errorf("SpotFetch API request failed: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		return nil, fmt.Errorf("SpotFetch API error: HTTP %d", resp.StatusCode)
+	}
+
+	bodyBytes, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return nil, fmt.Errorf("failed to read SpotFetch API response: %w", err)
+	}
+
+	switch parsed.Type {
+	case "track":
+		var trackResp TrackResponse
+		if err := json.Unmarshal(bodyBytes, &trackResp); err != nil {
+			return nil, fmt.Errorf("failed to decode track response: %w", err)
+		}
+		return trackResp, nil
+	case "album":
+		var albumResp AlbumResponsePayload
+		if err := json.Unmarshal(bodyBytes, &albumResp); err != nil {
+			return nil, fmt.Errorf("failed to decode album response: %w", err)
+		}
+		return &albumResp, nil
+	case "playlist":
+		var playlistResp PlaylistResponsePayload
+		if err := json.Unmarshal(bodyBytes, &playlistResp); err != nil {
+			return nil, fmt.Errorf("failed to decode playlist response: %w", err)
+		}
+		return playlistResp, nil
+	case "artist":
+		var artistResp ArtistResponsePayload
+		if err := json.Unmarshal(bodyBytes, &artistResp); err != nil {
+			return nil, fmt.Errorf("failed to decode artist response: %w", err)
+		}
+		return &artistResp, nil
+	default:
+		return nil, fmt.Errorf("unsupported Spotify type: %s", parsed.Type)
+	}
+}
@@ -1,222 +0,0 @@
-package gobackend
-
-import "testing"
-
-func TestParseTidalURL(t *testing.T) {
-	tests := []struct {
-		name      string
-		input     string
-		wantType  string
-		wantID    string
-		expectErr bool
-	}{
-		{
-			name:     "track url",
-			input:    "https://tidal.com/track/77616174",
-			wantType: "track",
-			wantID:   "77616174",
-		},
-		{
-			name:     "browse album url",
-			input:    "https://listen.tidal.com/browse/album/77616169",
-			wantType: "album",
-			wantID:   "77616169",
-		},
-		{
-			name:     "artist url",
-			input:    "https://www.tidal.com/artist/3852143",
-			wantType: "artist",
-			wantID:   "3852143",
-		},
-		{
-			name:     "playlist url",
-			input:    "https://tidal.com/playlist/edf3b7d2-cb42-41d7-93c0-afa2a395521b",
-			wantType: "playlist",
-			wantID:   "edf3b7d2-cb42-41d7-93c0-afa2a395521b",
-		},
-		{
-			name:      "unsupported host",
-			input:     "https://example.com/track/123",
-			expectErr: true,
-		},
-	}
-
-	for _, test := range tests {
-		t.Run(test.name, func(t *testing.T) {
-			gotType, gotID, err := parseTidalURL(test.input)
-			if test.expectErr {
-				if err == nil {
-					t.Fatalf("expected error, got none")
-				}
-				return
-			}
-			if err != nil {
-				t.Fatalf("expected no error, got %v", err)
-			}
-			if gotType != test.wantType || gotID != test.wantID {
-				t.Fatalf("parseTidalURL(%q) = (%q, %q), want (%q, %q)", test.input, gotType, gotID, test.wantType, test.wantID)
-			}
-		})
-	}
-}
-
-func TestParseTidalRequestTrackID(t *testing.T) {
-	tests := []struct {
-		input string
-		want  int64
-		ok    bool
-	}{
-		{input: "40681594", want: 40681594, ok: true},
-		{input: "tidal:40681594", want: 40681594, ok: true},
-		{input: " tidal:40681594 ", want: 40681594, ok: true},
-		{input: "", want: 0, ok: false},
-		{input: "tidal:not-a-number", want: 0, ok: false},
-	}
-
-	for _, test := range tests {
-		got, ok := parseTidalRequestTrackID(test.input)
-		if got != test.want || ok != test.ok {
-			t.Fatalf("parseTidalRequestTrackID(%q) = (%d, %v), want (%d, %v)", test.input, got, ok, test.want, test.ok)
-		}
-	}
-}
-
-func TestTidalImageURL(t *testing.T) {
-	got := tidalImageURL("fc18a64b-d76b-4582-962a-224cb05193f3", "1280x1280")
-	want := "https://resources.tidal.com/images/fc18a64b/d76b/4582/962a/224cb05193f3/1280x1280.jpg"
-	if got != want {
-		t.Fatalf("tidalImageURL() = %q, want %q", got, want)
-	}
-}
-
-func TestTidalTrackToTrackMetadata(t *testing.T) {
-	track := &TidalTrack{
-		ID:           77616174,
-		Title:        "Bruckner: Symphony No. 5",
-		ISRC:         "GBUM71507433",
-		Duration:     1172,
-		TrackNumber:  5,
-		VolumeNumber: 1,
-		URL:          "http://www.tidal.com/track/77616174",
-	}
-	track.Artist.ID = 3852143
-	track.Artist.Name = "Staatskapelle Berlin"
-	track.Artists = []struct {
-		ID      int64  `json:"id"`
-		Name    string `json:"name"`
-		Type    string `json:"type"`
-		Picture string `json:"picture"`
-	}{
-		{ID: 3852143, Name: "Staatskapelle Berlin", Type: "MAIN"},
-		{ID: 12430, Name: "Daniel Barenboim", Type: "FEATURED"},
-	}
-	track.Album.ID = 77616169
-	track.Album.Title = "Bruckner: Symphonies 4-9"
-	track.Album.Cover = "fc18a64b-d76b-4582-962a-224cb05193f3"
-	track.Album.ReleaseDate = "2016-02-26"
-
-	got := tidalTrackToTrackMetadata(track)
-	if got.SpotifyID != "tidal:77616174" {
-		t.Fatalf("unexpected track ID: %q", got.SpotifyID)
-	}
-	if got.Artists != "Staatskapelle Berlin, Daniel Barenboim" {
-		t.Fatalf("unexpected artists: %q", got.Artists)
-	}
-	if got.AlbumID != "tidal:77616169" {
-		t.Fatalf("unexpected album ID: %q", got.AlbumID)
-	}
-	if got.ArtistID != "tidal:3852143" {
-		t.Fatalf("unexpected artist ID: %q", got.ArtistID)
-	}
-	if got.Images == "" || got.ExternalURL != "https://www.tidal.com/track/77616174" {
-		t.Fatalf("unexpected image/url: %q / %q", got.Images, got.ExternalURL)
-	}
-}
-
-func TestTidalAlbumToArtistAlbum(t *testing.T) {
-	album := &tidalPublicAlbum{
-		ID:             77616169,
-		Title:          "Bruckner: Symphonies 4-9",
-		Type:           "ALBUM",
-		Cover:          "fc18a64b-d76b-4582-962a-224cb05193f3",
-		ReleaseDate:    "2016-02-26",
-		NumberOfTracks: 23,
-		Artists: []tidalPublicArtist{
-			{ID: 3852143, Name: "Staatskapelle Berlin", Type: "MAIN"},
-			{ID: 12430, Name: "Daniel Barenboim", Type: "FEATURED"},
-		},
-	}
-
-	got := tidalAlbumToArtistAlbum(album)
-	if got.ID != "tidal:77616169" {
-		t.Fatalf("unexpected album ID: %q", got.ID)
-	}
-	if got.AlbumType != "album" {
-		t.Fatalf("unexpected album type: %q", got.AlbumType)
-	}
-	if got.Artists != "Staatskapelle Berlin, Daniel Barenboim" {
-		t.Fatalf("unexpected artists: %q", got.Artists)
-	}
-	if got.Images == "" {
-		t.Fatalf("expected image URL, got empty string")
-	}
-}
-
-func TestTidalAlbumToArtistAlbumWithFallbackType(t *testing.T) {
-	album := &tidalPublicAlbum{
-		ID:             490623904,
-		Title:          "LET 'EM KNOW",
-		Cover:          "fc18a64b-d76b-4582-962a-224cb05193f3",
-		NumberOfTracks: 1,
-	}
-
-	got := tidalAlbumToArtistAlbumWithType(album, "single")
-	if got.AlbumType != "single" {
-		t.Fatalf("unexpected fallback album type: %q", got.AlbumType)
-	}
-}
-
-func TestTidalArtistAlbumTypeFromModuleTitle(t *testing.T) {
-	tests := []struct {
-		title string
-		want  string
-	}{
-		{title: "Albums", want: "album"},
-		{title: "EP & Singles", want: "single"},
-		{title: "Compilations", want: "album"},
-		{title: "Appears On", want: "album"},
-		{title: "Unknown", want: ""},
-	}
-
-	for _, test := range tests {
-		if got := tidalArtistAlbumTypeFromModuleTitle(test.title); got != test.want {
-			t.Fatalf("tidalArtistAlbumTypeFromModuleTitle(%q) = %q, want %q", test.title, got, test.want)
-		}
-	}
-}
-
-func TestTidalPlaylistImageUsesOrigin(t *testing.T) {
-	got := tidalImageURL("e6b59fd3-6995-40f0-8a32-174db3a8f4f2", "origin")
-	want := "https://resources.tidal.com/images/e6b59fd3/6995/40f0/8a32/174db3a8f4f2/origin.jpg"
-	if got != want {
-		t.Fatalf("unexpected origin playlist image URL: %q", got)
-	}
-}
-
-func TestTidalPlaylistOwnerName(t *testing.T) {
-	editorial := &tidalPublicPlaylist{Type: "EDITORIAL"}
-	if got := tidalPlaylistOwnerName(editorial); got != "TIDAL" {
-		t.Fatalf("unexpected editorial owner: %q", got)
-	}
-
-	artist := &tidalPublicPlaylist{Type: "ARTIST"}
-	if got := tidalPlaylistOwnerName(artist); got != "Artist" {
-		t.Fatalf("unexpected artist owner: %q", got)
-	}
-
-	user := &tidalPublicPlaylist{}
-	user.Creator.Name = "djtest"
-	if got := tidalPlaylistOwnerName(user); got != "djtest" {
-		t.Fatalf("unexpected creator owner: %q", got)
-	}
-}
@@ -3,25 +3,10 @@ package gobackend
 import (
 	"strings"
 	"unicode"
-
-	"golang.org/x/text/unicode/norm"
 )

-func writeNormalizedArtistRune(b *strings.Builder, r rune) {
-	switch r {
-	case 'đ':
-		b.WriteString("dj")
-	case 'ß':
-		b.WriteString("ss")
-	case 'æ':
-		b.WriteString("ae")
-	case 'œ':
-		b.WriteString("oe")
-	default:
-		b.WriteRune(r)
-	}
-}
-
+// normalizeLooseTitle collapses separators/punctuation so titles like
+// "Doctor / Cops" and "Doctor _ Cops" can still match.
 func normalizeLooseTitle(title string) string {
 	trimmed := strings.TrimSpace(strings.ToLower(title))
 	if trimmed == "" {
@@ -37,37 +22,11 @@ func normalizeLooseTitle(title string) string {
 			b.WriteRune(r)
 		case unicode.IsSpace(r):
 			b.WriteByte(' ')
+		// Treat common separators as spaces.
 		case r == '/', r == '\\', r == '_', r == '-', r == '|', r == '.', r == '&', r == '+':
 			b.WriteByte(' ')
 		default:
-		}
-	}
-
-	return strings.Join(strings.Fields(b.String()), " ")
-}
-
-func normalizeLooseArtistName(name string) string {
-	trimmed := strings.TrimSpace(strings.ToLower(name))
-	if trimmed == "" {
-		return ""
-	}
-
-	decomposed := norm.NFD.String(trimmed)
-
-	var b strings.Builder
-	b.Grow(len(decomposed))
-
-	for _, r := range decomposed {
-		switch {
-		case unicode.Is(unicode.Mn, r), unicode.Is(unicode.Mc, r), unicode.Is(unicode.Me, r):
-			continue
-		case unicode.IsLetter(r), unicode.IsNumber(r):
-			writeNormalizedArtistRune(&b, r)
-		case unicode.IsSpace(r):
-			b.WriteByte(' ')
-		case r == '/', r == '\\', r == '_', r == '-', r == '|', r == '.', r == '&', r == '+':
-			b.WriteByte(' ')
-		default:
+			// Drop other punctuation/symbols (including emoji) for loose matching.
 		}
 	}

@@ -83,6 +42,9 @@ func hasAlphaNumericRunes(value string) bool {
 	return false
 }

+// normalizeSymbolOnlyTitle keeps symbol/emoji runes while dropping letters,
+// digits, spaces and punctuation. This is useful for emoji-only titles such as
+// "🪐", "🌎" etc, so we can compare them strictly and avoid false matches.
 func normalizeSymbolOnlyTitle(title string) string {
 	trimmed := strings.TrimSpace(strings.ToLower(title))
 	if trimmed == "" {
@@ -106,48 +68,3 @@ func normalizeSymbolOnlyTitle(title string) string {

 	return b.String()
 }
-
-type resolvedTrackInfo struct {
-	Title                string
-	ArtistName           string
-	ISRC                 string
-	Duration             int
-	SkipNameVerification bool
-}
-
-func trackMatchesRequest(req DownloadRequest, resolved resolvedTrackInfo, logPrefix string) bool {
-	exactISRCMatch := req.ISRC != "" &&
-		resolved.ISRC != "" &&
-		strings.EqualFold(strings.TrimSpace(req.ISRC), strings.TrimSpace(resolved.ISRC))
-
-	if !exactISRCMatch && !resolved.SkipNameVerification {
-		if req.ArtistName != "" && resolved.ArtistName != "" &&
-			!artistsMatch(req.ArtistName, resolved.ArtistName) {
-			GoLog("[%s] Verification failed: artist mismatch — expected '%s', got '%s'\n",
-				logPrefix, req.ArtistName, resolved.ArtistName)
-			return false
-		}
-
-		if req.TrackName != "" && resolved.Title != "" &&
-			!titlesMatch(req.TrackName, resolved.Title) {
-			GoLog("[%s] Verification failed: title mismatch — expected '%s', got '%s'\n",
-				logPrefix, req.TrackName, resolved.Title)
-			return false
-		}
-	}
-
-	expectedDurationSec := req.DurationMS / 1000
-	if expectedDurationSec > 0 && resolved.Duration > 0 {
-		diff := expectedDurationSec - resolved.Duration
-		if diff < 0 {
-			diff = -diff
-		}
-		if diff > 10 {
-			GoLog("[%s] Verification failed: duration mismatch — expected %ds, got %ds\n",
-				logPrefix, expectedDurationSec, resolved.Duration)
-			return false
-		}
-	}
-
-	return true
-}
@@ -21,40 +21,6 @@ func TestNormalizeLooseTitle_EmojiAndSymbols(t *testing.T) {
 	}
 }

-func TestTrackMatchesRequest_SongLinkBypassesArtistAndTitle(t *testing.T) {
-	req := DownloadRequest{
-		TrackName:  "Ringišpil",
-		ArtistName: "Djordje Balasevic",
-	}
-	resolved := resolvedTrackInfo{
-		Title:                "Completely Different Title",
-		ArtistName:           "Totally Different Artist",
-		SkipNameVerification: true,
-	}
-
-	if !trackMatchesRequest(req, resolved, "test") {
-		t.Fatal("expected SongLink-resolved track to bypass artist/title verification")
-	}
-}
-
-func TestTrackMatchesRequest_SongLinkStillChecksDuration(t *testing.T) {
-	req := DownloadRequest{
-		TrackName:  "Ringišpil",
-		ArtistName: "Djordje Balasevic",
-		DurationMS: 180000,
-	}
-	resolved := resolvedTrackInfo{
-		Title:                "Completely Different Title",
-		ArtistName:           "Totally Different Artist",
-		Duration:             240,
-		SkipNameVerification: true,
-	}
-
-	if trackMatchesRequest(req, resolved, "test") {
-		t.Fatal("expected SongLink-resolved track with large duration mismatch to be rejected")
-	}
-}
-
 func TestTitlesMatch_SeparatorVariants(t *testing.T) {
 	if !titlesMatch("Doctor / Cops", "Doctor _ Cops") {
 		t.Fatal("expected tidal titlesMatch to accept / vs _ variant")
@@ -0,0 +1,751 @@
+package gobackend
+
+import (
+	"bufio"
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"strconv"
+	"strings"
+	"sync"
+	"time"
+)
+
+type YouTubeDownloader struct {
+	client *http.Client
+	apiURL string
+	mu     sync.Mutex
+}
+
+const spotubeBaseURL = "https://spotubedl.com"
+
+var (
+	globalYouTubeDownloader *YouTubeDownloader
+	youtubeDownloaderOnce   sync.Once
+)
+
+type YouTubeQuality string
+
+const (
+	YouTubeQualityOpus256 YouTubeQuality = "opus_256"
+	YouTubeQualityOpus128 YouTubeQuality = "opus_128"
+	YouTubeQualityMP3128  YouTubeQuality = "mp3_128"
+	YouTubeQualityMP3256  YouTubeQuality = "mp3_256"
+	YouTubeQualityMP3320  YouTubeQuality = "mp3_320"
+)
+
+var (
+	youtubeOpusSupportedBitrates = []int{128, 256}
+	youtubeMp3SupportedBitrates  = []int{128, 256, 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
+}
+
+func extractBitrateFromQuality(raw string, defaultBitrate int) int {
+	parts := strings.FieldsFunc(raw, func(r rune) bool {
+		return (r < '0' || r > '9')
+	})
+	for i := len(parts) - 1; i >= 0; i-- {
+		part := parts[i]
+		if part == "" {
+			continue
+		}
+		if parsed, err := strconv.Atoi(part); err == nil {
+			return parsed
+		}
+	}
+	return defaultBitrate
+}
+
+func nearestSupportedBitrate(value int, supported []int) int {
+	nearest := supported[0]
+	nearestDistance := absInt(value - nearest)
+
+	for _, option := range supported[1:] {
+		distance := absInt(value - option)
+		// On tie prefer higher quality.
+		if distance < nearestDistance || (distance == nearestDistance && option > nearest) {
+			nearest = option
+			nearestDistance = distance
+		}
+	}
+
+	return nearest
+}
+
+func absInt(value int) int {
+	if value < 0 {
+		return -value
+	}
+	return value
+}
+
+func parseYouTubeQualityInput(raw string) (format string, bitrate int, normalized YouTubeQuality) {
+	normalizedRaw := strings.ToLower(strings.TrimSpace(raw))
+
+	if strings.HasPrefix(normalizedRaw, "opus") {
+		parsed := extractBitrateFromQuality(normalizedRaw, 256)
+		finalBitrate := nearestSupportedBitrate(parsed, youtubeOpusSupportedBitrates)
+		return "opus", finalBitrate, YouTubeQuality(fmt.Sprintf("opus_%d", finalBitrate))
+	}
+
+	if strings.HasPrefix(normalizedRaw, "mp3") {
+		parsed := extractBitrateFromQuality(normalizedRaw, 320)
+		finalBitrate := nearestSupportedBitrate(parsed, youtubeMp3SupportedBitrates)
+		return "mp3", finalBitrate, YouTubeQuality(fmt.Sprintf("mp3_%d", finalBitrate))
+	}
+
+	// Backward compatibility for legacy symbolic values.
+	switch normalizedRaw {
+	case "opus_256", "opus256", "opus":
+		return "opus", 256, YouTubeQualityOpus256
+	case "opus_128", "opus128":
+		return "opus", 128, YouTubeQualityOpus128
+	case "mp3_320", "mp3320", "mp3", "":
+		return "mp3", 320, YouTubeQualityMP3320
+	case "mp3_256", "mp3256":
+		return "mp3", 256, YouTubeQualityMP3256
+	case "mp3_128", "mp3128":
+		return "mp3", 128, YouTubeQualityMP3128
+	default:
+		return "mp3", 320, YouTubeQualityMP3320
+	}
+}
+
+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()
+
+	audioFormat, bitrate, _ := parseYouTubeQualityInput(string(quality))
+	audioBitrate := strconv.Itoa(bitrate)
+
+	// Try SpotubeDL first (primary)
+	var spotubeErr error
+	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
+		}
+		spotubeErr = err
+		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 {
+		if spotubeErr != nil {
+			return nil, fmt.Errorf("all download methods failed: spotubedl: %v, cobalt: %v", spotubeErr, err)
+		}
+		return nil, fmt.Errorf("all download methods failed: spotubedl: extractErr=%v, cobalt: %v", extractErr, err)
+	}
+
+	return resp, nil
+}
+
+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).
+// Engines v3/v2 are MP3-oriented outputs, so we only use them for MP3 requests.
+func (y *YouTubeDownloader) requestSpotubeDL(videoID, audioFormat, audioBitrate string) (*CobaltResponse, error) {
+	engines := []string{"v1"}
+	if strings.EqualFold(audioFormat, "mp3") {
+		engines = append(engines, "v3", "v2")
+	}
+	var lastErr error
+
+	for _, engine := range engines {
+		resp, err := y.requestSpotubeDLEngine(videoID, audioFormat, audioBitrate, engine)
+		if err == nil {
+			return resp, nil
+		}
+		lastErr = err
+		GoLog("[YouTube] SpotubeDL (%s) failed: %v\n", engine, err)
+	}
+
+	if lastErr == nil {
+		lastErr = fmt.Errorf("no SpotubeDL engine available")
+	}
+	return nil, lastErr
+}
+
+func (y *YouTubeDownloader) requestSpotubeDLEngine(videoID, audioFormat, audioBitrate, engine string) (*CobaltResponse, error) {
+	apiURL := fmt.Sprintf("%s/api/download/%s?engine=%s&format=%s&quality=%s",
+		spotubeBaseURL, videoID, url.QueryEscape(engine), url.QueryEscape(audioFormat), url.QueryEscape(audioBitrate))
+
+	GoLog("[YouTube] Requesting from SpotubeDL (%s): %s\n", engine, 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 (%s) response status: %d\n", engine, resp.StatusCode)
+
+	if resp.StatusCode != 200 {
+		return nil, fmt.Errorf("spotubedl(%s) returned status %d: %s", engine, resp.StatusCode, string(body))
+	}
+
+	var result struct {
+		URL      string `json:"url"`
+		Status   string `json:"status"`
+		Error    string `json:"error"`
+		Message  string `json:"message"`
+		Filename string `json:"filename"`
+	}
+	if err := json.Unmarshal(body, &result); err != nil {
+		return nil, fmt.Errorf("failed to parse spotubedl response: %w", err)
+	}
+
+	downloadURL := strings.TrimSpace(result.URL)
+	if downloadURL == "" {
+		if result.Error != "" {
+			return nil, fmt.Errorf("spotubedl(%s) error: %s", engine, result.Error)
+		}
+		if result.Message != "" {
+			return nil, fmt.Errorf("spotubedl(%s) message: %s", engine, result.Message)
+		}
+		return nil, fmt.Errorf("no download URL from spotubedl(%s)", engine)
+	}
+
+	if strings.HasPrefix(downloadURL, "/") {
+		downloadURL = spotubeBaseURL + downloadURL
+	}
+
+	if !strings.HasPrefix(downloadURL, "http://") && !strings.HasPrefix(downloadURL, "https://") {
+		return nil, fmt.Errorf("invalid download URL from spotubedl(%s): %s", engine, downloadURL)
+	}
+
+	filename := strings.TrimSpace(result.Filename)
+	if filename == "" {
+		if parsedURL, parseErr := url.Parse(downloadURL); parseErr == nil {
+			if queryFilename := strings.TrimSpace(parsedURL.Query().Get("filename")); queryFilename != "" {
+				if decodedFilename, decodeErr := url.QueryUnescape(queryFilename); decodeErr == nil {
+					filename = decodedFilename
+				} else {
+					filename = queryFilename
+				}
+			}
+		}
+	}
+
+	GoLog("[YouTube] Got download URL from SpotubeDL (%s)\n", engine)
+	return &CobaltResponse{
+		Status:   "tunnel",
+		URL:      downloadURL,
+		Filename: filename,
+	}, 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)
+}
+
+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")
+}
+
+// searchYouTubeMusicViaExtension uses the YT Music extension's customSearch
+// to find a track by artist + title. It filters for tracks only (not videos,
+// albums, or playlists) and returns the YouTube Music watch URL for the first
+// matching track, or "" if nothing was found.
+func searchYouTubeMusicViaExtension(artistName, trackName string) string {
+	extManager := GetExtensionManager()
+	searchProviders := extManager.GetSearchProviders()
+
+	// Find the ytmusic-spotiflac extension
+	var ytProvider *ExtensionProviderWrapper
+	for _, p := range searchProviders {
+		if p.extension.ID == "ytmusic-spotiflac" {
+			ytProvider = p
+			break
+		}
+	}
+	if ytProvider == nil {
+		GoLog("[YouTube] YT Music extension not found or not enabled, skipping fallback\n")
+		return ""
+	}
+
+	query := strings.TrimSpace(artistName + " " + trackName)
+	if query == "" {
+		return ""
+	}
+
+	GoLog("[YouTube] Searching YT Music extension for: %s\n", query)
+	results, err := ytProvider.CustomSearch(query, map[string]interface{}{
+		"filter": "tracks",
+	})
+	if err != nil {
+		GoLog("[YouTube] YT Music extension search failed: %v\n", err)
+		return ""
+	}
+
+	// Find the first track result (item_type == "track" with a valid video ID)
+	for _, track := range results {
+		if track.ItemType != "" && track.ItemType != "track" {
+			continue
+		}
+		videoID := strings.TrimSpace(track.ID)
+		if videoID == "" {
+			continue
+		}
+		if isYouTubeVideoID(videoID) {
+			return BuildYouTubeWatchURL(videoID)
+		}
+	}
+
+	GoLog("[YouTube] YT Music extension returned no matching tracks for: %s\n", query)
+	return ""
+}
+
+func downloadFromYouTube(req DownloadRequest) (YouTubeDownloadResult, error) {
+	downloader := NewYouTubeDownloader()
+
+	format, bitrate, quality := parseYouTubeQualityInput(req.Quality)
+
+	// URL lookup priority: YouTube video ID > YT Music extension > SongLink (Spotify/Deezer/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 YT Music extension search first (if installed) - more accurate, tracks only
+	if youtubeURL == "" && (req.TrackName != "" || req.ArtistName != "") {
+		youtubeURL = searchYouTubeMusicViaExtension(req.ArtistName, req.TrackName)
+		if youtubeURL != "" {
+			GoLog("[YouTube] Found YouTube URL via YT Music extension: %s\n", youtubeURL)
+		}
+	}
+
+	// Fallback: 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)
+		}
+	}
+
+	// Fallback: 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)
+		}
+	}
+
+	// Fallback: 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)
+	}
+
+	ext := ".mp3"
+	if format == "opus" {
+		ext = ".opus"
+	}
+
+	// Some SpotubeDL engines may return a different output container than requested.
+	// Respect the provider-reported filename to avoid saving MP3 bytes with .opus extension.
+	if cobaltResp != nil && cobaltResp.Filename != "" {
+		lowerName := strings.ToLower(strings.TrimSpace(cobaltResp.Filename))
+		switch {
+		case strings.HasSuffix(lowerName, ".mp3"):
+			ext = ".mp3"
+			format = "mp3"
+		case strings.HasSuffix(lowerName, ".opus"), strings.HasSuffix(lowerName, ".ogg"):
+			ext = ".opus"
+			format = "opus"
+		}
+	}
+
+	filename := buildFilenameFromTemplate(req.FilenameFormat, map[string]any{
+		"title":  req.TrackName,
+		"artist": req.ArtistName,
+		"album":  req.AlbumName,
+		"track":  req.TrackNumber,
+		"year":   extractYear(req.ReleaseDate),
+		"date":   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)
+
+	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
+}
@@ -0,0 +1,41 @@
+package gobackend
+
+import "testing"
+
+func TestParseYouTubeQualityInput_OpusNormalizesToSupportedBitrates(t *testing.T) {
+	format, bitrate, normalized := parseYouTubeQualityInput("opus_160")
+	if format != "opus" {
+		t.Fatalf("expected opus format, got %s", format)
+	}
+	if bitrate != 128 {
+		t.Fatalf("expected 128 bitrate, got %d", bitrate)
+	}
+	if normalized != YouTubeQualityOpus128 {
+		t.Fatalf("expected %s normalized, got %s", YouTubeQualityOpus128, normalized)
+	}
+}
+
+func TestParseYouTubeQualityInput_Mp3NormalizesToSupportedBitrates(t *testing.T) {
+	format, bitrate, normalized := parseYouTubeQualityInput("mp3_192")
+	if format != "mp3" {
+		t.Fatalf("expected mp3 format, got %s", format)
+	}
+	if bitrate != 256 {
+		t.Fatalf("expected 256 bitrate, got %d", bitrate)
+	}
+	if normalized != YouTubeQualityMP3256 {
+		t.Fatalf("expected %s normalized, got %s", YouTubeQualityMP3256, normalized)
+	}
+}
+
+func TestParseYouTubeQualityInput_PicksNearestSupportedBitrate(t *testing.T) {
+	_, opusBitrate, _ := parseYouTubeQualityInput("opus_999")
+	if opusBitrate != 256 {
+		t.Fatalf("expected opus normalization to 256, got %d", opusBitrate)
+	}
+
+	_, mp3Bitrate, _ := parseYouTubeQualityInput("mp3_1")
+	if mp3Bitrate != 128 {
+		t.Fatalf("expected mp3 normalization to 128, got %d", mp3Bitrate)
+	}
+}
@@ -27,37 +27,6 @@ require File.expand_path(File.join('packages', 'flutter_tools', 'bin', 'podhelpe

 flutter_ios_podfile_setup

-def patch_device_info_plus_vision_selector
-  plugin_file = File.join(
-    __dir__,
-    '.symlinks',
-    'plugins',
-    'device_info_plus',
-    'ios',
-    'device_info_plus',
-    'Sources',
-    'device_info_plus',
-    'FPPDeviceInfoPlusPlugin.m'
-  )
-  return unless File.exist?(plugin_file)
-
-  source = File.read(plugin_file)
-  return if source.include?('FPPDeviceInfoPlusVisionCompat')
-
-  marker = "#import <sys/utsname.h>\n"
-  declaration = <<~OBJC
-
-    // Older Xcode SDKs do not declare this selector yet, but device_info_plus
-    // only calls it behind an availability check.
-    @interface NSProcessInfo (FPPDeviceInfoPlusVisionCompat)
-    - (BOOL)isiOSAppOnVision;
-    @end
-  OBJC
-
-  patched = source.sub(marker, "#{marker}#{declaration}\n")
-  File.write(plugin_file, patched) if patched != source
-end
-
 target 'Runner' do
  use_frameworks!
  use_modular_headers!
@@ -73,8 +42,6 @@ target 'RunnerTests' do
 end

 post_install do |installer|
-  patch_device_info_plus_vision_selector
-
  installer.pods_project.targets.each do |target|
    flutter_additional_ios_build_settings(target)
    target.build_configurations.each do |config|
@@ -89,7 +89,7 @@ import Gobackend  // Import Go framework
            }
            self.lastDownloadProgressPayload = payload
            DispatchQueue.main.async { [weak self] in
-                self?.downloadProgressEventSink?(self?.parseJsonPayload(payload))
+                self?.downloadProgressEventSink?(payload)
            }
        }
        downloadProgressTimer = timer
@@ -119,7 +119,7 @@ import Gobackend  // Import Go framework
            }
            self.lastLibraryScanProgressPayload = payload
            DispatchQueue.main.async { [weak self] in
-                self?.libraryScanProgressEventSink?(self?.parseJsonPayload(payload))
+                self?.libraryScanProgressEventSink?(payload)
            }
        }
        libraryScanProgressTimer = timer
@@ -133,17 +133,6 @@ import Gobackend  // Import Go framework
        libraryScanProgressEventSink = nil
        lastLibraryScanProgressPayload = nil
    }
-
-    private func parseJsonPayload(_ payload: String) -> Any {
-        guard let data = payload.data(using: .utf8) else {
-            return payload
-        }
-        do {
-            return try JSONSerialization.jsonObject(with: data, options: [.fragmentsAllowed])
-        } catch {
-            return payload
-        }
-    }
    
    private func handleMethodCall(call: FlutterMethodCall, result: @escaping FlutterResult) {
        DispatchQueue.global(qos: .userInitiated).async {
@@ -164,6 +153,13 @@ import Gobackend  // Import Go framework
        var error: NSError?
        
        switch call.method {
+        case "parseSpotifyUrl":
+            let args = call.arguments as! [String: Any]
+            let url = args["url"] as! String
+            let response = GobackendParseSpotifyURL(url, &error)
+            if let error = error { throw error }
+            return response
+            
        case "checkAvailability":
            let args = call.arguments as! [String: Any]
            let spotifyId = args["spotify_id"] as! String
@@ -180,11 +176,11 @@ import Gobackend  // Import Go framework

        case "getDownloadProgress":
            let response = GobackendGetDownloadProgress()
-            return parseJsonPayload(response as String? ?? "{}")
+            return response
            
        case "getAllDownloadProgress":
            let response = GobackendGetAllDownloadProgress()
-            return parseJsonPayload(response as String? ?? "{}")
+            return response
            
        case "initItemProgress":
            let args = call.arguments as! [String: Any]
@@ -307,15 +303,6 @@ import Gobackend  // Import Go framework
            if let error = error { throw error }
            return response
            
-        case "rewriteSplitArtistTags":
-            let args = call.arguments as! [String: Any]
-            let filePath = args["file_path"] as! String
-            let artist = args["artist"] as! String
-            let albumArtist = args["album_artist"] as! String
-            let response = GobackendRewriteSplitArtistTagsExport(filePath, artist, albumArtist, &error)
-            if let error = error { throw error }
-            return response
-            
        case "cleanupConnections":
            GobackendCleanupConnections()
            return nil
@@ -344,8 +331,7 @@ import Gobackend  // Import Go framework
            let spotifyId = args["spotify_id"] as! String
            let durationMs = args["duration_ms"] as? Int64 ?? 0
            let outputPath = args["output_path"] as! String
-            let audioFilePath = args["audio_file_path"] as? String ?? ""
-            GobackendFetchAndSaveLyrics(trackName, artistName, spotifyId, durationMs, outputPath, audioFilePath, &error)
+            GobackendFetchAndSaveLyrics(trackName, artistName, spotifyId, durationMs, outputPath, &error)
            if let error = error { throw error }
            return "{\"success\":true}"

@@ -381,26 +367,6 @@ import Gobackend  // Import Go framework
            if let error = error { throw error }
            return response

-        case "searchTidalAll":
-            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 filter = args["filter"] as? String ?? ""
-            let response = GobackendSearchTidalAll(query, Int(trackLimit), Int(artistLimit), filter, &error)
-            if let error = error { throw error }
-            return response
-
-        case "searchQobuzAll":
-            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 filter = args["filter"] as? String ?? ""
-            let response = GobackendSearchQobuzAll(query, Int(trackLimit), Int(artistLimit), filter, &error)
-            if let error = error { throw error }
-            return response
-
        case "getDeezerRelatedArtists":
            let args = call.arguments as! [String: Any]
            let artistId = args["artist_id"] as! String
@@ -417,22 +383,6 @@ import Gobackend  // Import Go framework
            if let error = error { throw error }
            return response

-        case "getQobuzMetadata":
-            let args = call.arguments as! [String: Any]
-            let resourceType = args["resource_type"] as! String
-            let resourceId = args["resource_id"] as! String
-            let response = GobackendGetQobuzMetadata(resourceType, resourceId, &error)
-            if let error = error { throw error }
-            return response
-
-        case "getTidalMetadata":
-            let args = call.arguments as! [String: Any]
-            let resourceType = args["resource_type"] as! String
-            let resourceId = args["resource_id"] as! String
-            let response = GobackendGetTidalMetadata(resourceType, resourceId, &error)
-            if let error = error { throw error }
-            return response
-
        case "parseDeezerUrl":
            let args = call.arguments as! [String: Any]
            let url = args["url"] as! String
@@ -440,13 +390,6 @@ import Gobackend  // Import Go framework
            if let error = error { throw error }
            return response

-        case "parseQobuzUrl":
-            let args = call.arguments as! [String: Any]
-            let url = args["url"] as! String
-            let response = GobackendParseQobuzURLExport(url, &error)
-            if let error = error { throw error }
-            return response
-
        case "parseTidalUrl":
            let args = call.arguments as! [String: Any]
            let url = args["url"] as! String
@@ -483,6 +426,13 @@ import Gobackend  // Import Go framework
            if let error = error { throw error }
            return response

+        case "getSpotifyMetadataWithFallback":
+            let args = call.arguments as! [String: Any]
+            let url = args["url"] as! String
+            let response = GobackendGetSpotifyMetadataWithDeezerFallback(url, &error)
+            if let error = error { throw error }
+            return response
+            
        case "checkAvailabilityFromDeezerID":
            let args = call.arguments as! [String: Any]
            let deezerTrackId = args["deezer_track_id"] as! String
@@ -650,20 +600,6 @@ import Gobackend  // Import Go framework
            let response = GobackendSearchTracksWithExtensionsJSON(query, Int(limit), &error)
            if let error = error { throw error }
            return response
-
-        case "searchTracksWithMetadataProviders":
-            let args = call.arguments as! [String: Any]
-            let query = args["query"] as! String
-            let limit = args["limit"] as? Int ?? 20
-            let includeExtensions = args["include_extensions"] as? Bool ?? true
-            let response = GobackendSearchTracksWithMetadataProvidersJSON(
-                query,
-                Int(limit),
-                includeExtensions,
-                &error
-            )
-            if let error = error { throw error }
-            return response
            
        case "enrichTrackWithExtension":
            let args = call.arguments as! [String: Any]
@@ -855,23 +791,6 @@ import Gobackend  // Import Go framework
            if let error = error { throw error }
            return nil
            
-        case "setStoreRegistryUrl":
-            let args = call.arguments as! [String: Any]
-            let registryUrl = args["registry_url"] as? String ?? ""
-            GobackendSetStoreRegistryURLJSON(registryUrl, &error)
-            if let error = error { throw error }
-            return nil
-            
-        case "getStoreRegistryUrl":
-            let response = GobackendGetStoreRegistryURLJSON(&error)
-            if let error = error { throw error }
-            return response
-            
-        case "clearStoreRegistryUrl":
-            GobackendClearStoreRegistryURLJSON(&error)
-            if let error = error { throw error }
-            return nil
-            
        case "getStoreExtensions":
            let args = call.arguments as! [String: Any]
            let forceRefresh = args["force_refresh"] as? Bool ?? false
@@ -944,7 +863,7 @@ import Gobackend  // Import Go framework
            
        case "getLibraryScanProgress":
            let response = GobackendGetLibraryScanProgressJSON()
-            return parseJsonPayload(response as String? ?? "{}")
+            return response
            
        case "cancelLibraryScan":
            GobackendCancelLibraryScanJSON()
@@ -1,26 +1,21 @@
-import 'package:flutter/foundation.dart';
-
 /// App version and info constants
 /// Update version here only - all other files will reference this
 class AppInfo {
-  static const String version = '4.2.1';
-  static const String buildNumber = '122';
+  static const String version = '3.7.2';
+  static const String buildNumber = '105';
  static const String fullVersion = '$version+$buildNumber';
-
-  /// Shows "Internal" in debug builds, actual version in release.
-  static String get displayVersion => kDebugMode ? 'Internal' : version;
-
-  static const String appName = 'SpotiFLAC Mobile';
+  
+  
+  static const String appName = 'SpotiFLAC';
  static const String copyright = '© 2026 SpotiFLAC';
-
+  
  static const String mobileAuthor = 'zarzet';
  static const String originalAuthor = 'afkarxyz';
-
+  
  static const String githubRepo = 'zarzet/SpotiFLAC-Mobile';
  static const String githubUrl = 'https://github.com/$githubRepo';
-  static const String originalGithubUrl =
-      'https://github.com/afkarxyz/SpotiFLAC';
-
+  static const String originalGithubUrl = 'https://github.com/afkarxyz/SpotiFLAC';
+  
  static const String kofiUrl = 'https://ko-fi.com/zarzet';
  static const String githubSponsorsUrl = 'https://github.com/sponsors/zarzet/';
 }
@@ -450,7 +450,7 @@
  "@aboutSpotiSaverDesc": {
    "description": "Credit for SpotiSaver API"
  },
-  "aboutAppDescription": "Lade Spotify-Titel in verlustfreier Qualität von Tidal und Qobuz herunter.",
+  "aboutAppDescription": "Lade Spotify-Titel in verlustfreier Qualität von Tidal, Qobuz und Amazon Music herunter.",
  "@aboutAppDescription": {
    "description": "App description in header card"
  },
@@ -555,7 +555,7 @@
  "@setupDownloadLocationTitle": {
    "description": "Download location dialog title"
  },
-  "setupDownloadLocationIosMessage": "Auf iOS werden Downloads im Dokumentenordner der App gespeichert. Du kannst sie über die Datei-App aufrufen.",
+  "setupDownloadLocationIosMessage": "Auf iOS werden Downloads im Dokumentenverzeichnis der App gespeichert. Du kannst sie über die Datei-App aufrufen.",
  "@setupDownloadLocationIosMessage": {
    "description": "iOS-specific folder info"
  },
@@ -897,18 +897,6 @@
  "@errorNoTracksFound": {
    "description": "Error - search returned no results"
  },
-  "errorUrlNotRecognized": "Link wurde nicht erkannt",
-  "@errorUrlNotRecognized": {
-    "description": "Error title - URL not handled by any extension or service"
-  },
-  "errorUrlNotRecognizedMessage": "Dieser Link ist inkompatibel. Prüfe die URL und stelle sicher, dass eine kompatible Erweiterung installiert ist.",
-  "@errorUrlNotRecognizedMessage": {
-    "description": "Error message - URL not recognized explanation"
-  },
-  "errorUrlFetchFailed": "Laden fehlgeschlagen. Bitte erneut versuchen.",
-  "@errorUrlFetchFailed": {
-    "description": "Error message - generic URL fetch failure"
-  },
  "errorMissingExtensionSource": "Kann {item} nicht lade wegen fehlender Erweiterungsquelle",
  "@errorMissingExtensionSource": {
    "description": "Error - extension source not available",
@@ -959,7 +947,7 @@
  "@selectionAllSelected": {
    "description": "Status - all items selected"
  },
-  "selectionSelectToDelete": "Titel zum Löschen wählen",
+  "selectionSelectToDelete": "Titel zum Löschen auswählen",
  "@selectionSelectToDelete": {
    "description": "Placeholder when nothing selected"
  },
@@ -987,7 +975,7 @@
  "@searchArtists": {
    "description": "Search result category - artists"
  },
-  "searchAlbums": "Alben",
+  "searchAlbums": "Albums",
  "@searchAlbums": {
    "description": "Search result category - albums"
  },
@@ -1015,14 +1003,6 @@
  "@folderOrganizationNone": {
    "description": "Folder option - flat structure"
  },
-  "folderOrganizationByPlaylist": "Nach Playlist",
-  "@folderOrganizationByPlaylist": {
-    "description": "Folder option - playlist folders"
-  },
-  "folderOrganizationByPlaylistSubtitle": "Ordner für jede Playlist trennen",
-  "@folderOrganizationByPlaylistSubtitle": {
-    "description": "Subtitle for playlist folder option"
-  },
  "folderOrganizationByArtist": "Nach Künstler",
  "@folderOrganizationByArtist": {
    "description": "Folder option - artist folders"
@@ -1039,7 +1019,7 @@
  "@folderOrganizationDescription": {
    "description": "Folder organization sheet description"
  },
-  "folderOrganizationNoneSubtitle": "Alle Dateien im Download-Ordner",
+  "folderOrganizationNoneSubtitle": "Alle Dateien im Download-Verzeichnis",
  "@folderOrganizationNoneSubtitle": {
    "description": "Subtitle for no organization option"
  },
@@ -1117,7 +1097,7 @@
  },
  "providerBuiltIn": "Integriert",
  "@providerBuiltIn": {
-    "description": "Label for built-in providers (Tidal/Qobuz)"
+    "description": "Label for built-in providers (Tidal/Qobuz/Amazon)"
  },
  "providerExtension": "Erweiterung",
  "@providerExtension": {
@@ -1773,11 +1753,23 @@
  "@qualityNote": {
    "description": "Note about quality availability"
  },
+  "youtubeQualityNote": "YouTube bietet nur verlustbehaftete Audioqualität. Deswegen ist es kein Teil des verlustfreien Fallbacks.",
+  "@youtubeQualityNote": {
+    "description": "Note for YouTube service explaining lossy-only quality"
+  },
+  "youtubeOpusBitrateTitle": "YouTube Opus Bitrate",
+  "@youtubeOpusBitrateTitle": {
+    "description": "Title for YouTube Opus bitrate setting"
+  },
+  "youtubeMp3BitrateTitle": "YouTube MP3 Bitrate",
+  "@youtubeMp3BitrateTitle": {
+    "description": "Title for YouTube MP3 bitrate setting"
+  },
  "downloadAskBeforeDownload": "Qualität vor Download fragen",
  "@downloadAskBeforeDownload": {
    "description": "Setting - show quality picker"
  },
-  "downloadDirectory": "Download-Ordner",
+  "downloadDirectory": "Downloadverzeichnis",
  "@downloadDirectory": {
    "description": "Setting - download folder"
  },
@@ -1785,15 +1777,15 @@
  "@downloadSeparateSinglesFolder": {
    "description": "Setting - separate folder for singles"
  },
-  "downloadAlbumFolderStructure": "Album-Ordnerstruktur",
+  "downloadAlbumFolderStructure": "Album Folder Structure",
  "@downloadAlbumFolderStructure": {
    "description": "Setting - album folder organization"
  },
-  "downloadUseAlbumArtistForFolders": "Album-Künstler für Ordner verwenden",
+  "downloadUseAlbumArtistForFolders": "Use Album Artist for folders",
  "@downloadUseAlbumArtistForFolders": {
    "description": "Setting - choose whether artist folders use Album Artist or Track Artist"
  },
-  "downloadUsePrimaryArtistOnly": "Primärer Künstler nur für Ordner",
+  "downloadUsePrimaryArtistOnly": "Primary artist only for folders",
  "@downloadUsePrimaryArtistOnly": {
    "description": "Setting - strip featured artists from folder name"
  },
@@ -1801,7 +1793,7 @@
  "@downloadUsePrimaryArtistOnlyEnabled": {
    "description": "Subtitle when primary artist only is enabled"
  },
-  "downloadUsePrimaryArtistOnlyDisabled": "Vollständiger Künstler für Ordnername",
+  "downloadUsePrimaryArtistOnlyDisabled": "Full artist string used for folder name",
  "@downloadUsePrimaryArtistOnlyDisabled": {
    "description": "Subtitle when primary artist only is disabled"
  },
@@ -1829,7 +1821,7 @@
  "@queueClearAllMessage": {
    "description": "Clear queue confirmation"
  },
-  "settingsAutoExportFailed": "Auto-Export fehlgeschlagener Downloads",
+  "settingsAutoExportFailed": "Auto-export failed downloads",
  "@settingsAutoExportFailed": {
    "description": "Setting toggle for auto-export"
  },
@@ -1857,15 +1849,15 @@
  "@albumFolderArtistAlbum": {
    "description": "Album folder option"
  },
-  "albumFolderArtistAlbumSubtitle": "Alben/Künster Name/Album Name/",
+  "albumFolderArtistAlbumSubtitle": "Albums/Artist Name/Album Name/",
  "@albumFolderArtistAlbumSubtitle": {
    "description": "Folder structure example"
  },
-  "albumFolderArtistYearAlbum": "Künstler / [Year] Album",
+  "albumFolderArtistYearAlbum": "Artist / [Year] Album",
  "@albumFolderArtistYearAlbum": {
    "description": "Album folder option with year"
  },
-  "albumFolderArtistYearAlbumSubtitle": "Alben/Künster Name/[2005] Album Name/",
+  "albumFolderArtistYearAlbumSubtitle": "Albums/Künster Name/[2005] Album Name/",
  "@albumFolderArtistYearAlbumSubtitle": {
    "description": "Folder structure example"
  },
@@ -1881,15 +1873,15 @@
  "@albumFolderYearAlbum": {
    "description": "Album folder option with year"
  },
-  "albumFolderYearAlbumSubtitle": "Alben/[2005] Album Name/",
+  "albumFolderYearAlbumSubtitle": "Albums/[2005] Album Name/",
  "@albumFolderYearAlbumSubtitle": {
    "description": "Folder structure example"
  },
-  "albumFolderArtistAlbumSingles": "Künstler / Album + Singles",
+  "albumFolderArtistAlbumSingles": "Artist / Album + Singles",
  "@albumFolderArtistAlbumSingles": {
    "description": "Album folder option with singles inside artist"
  },
-  "albumFolderArtistAlbumSinglesSubtitle": "Künstler/Album/ und Künstler/Singles/",
+  "albumFolderArtistAlbumSinglesSubtitle": "Artist/Album/ and Artist/Singles/",
  "@albumFolderArtistAlbumSinglesSubtitle": {
    "description": "Folder structure example"
  },
@@ -1932,7 +1924,7 @@
      }
    }
  },
-  "downloadedAlbumSelectToDelete": "Titel zum Löschen wählen",
+  "downloadedAlbumSelectToDelete": "Select tracks to delete",
  "@downloadedAlbumSelectToDelete": {
    "description": "Placeholder when nothing selected"
  },
@@ -2004,7 +1996,7 @@
  "@discographyAlbumsOnly": {
    "description": "Option - download only albums"
  },
-  "discographyAlbumsOnlySubtitle": "{count} Titel aus {albumCount} Alben",
+  "discographyAlbumsOnlySubtitle": "{count} Titel von {albumCount} Albums",
  "@discographyAlbumsOnlySubtitle": {
    "description": "Subtitle showing album tracks count",
    "placeholders": {
@@ -2036,7 +2028,7 @@
  "@discographySelectAlbums": {
    "description": "Option - manually select albums to download"
  },
-  "discographySelectAlbumsSubtitle": "Wähle bestimmte Alben oder Singles",
+  "discographySelectAlbumsSubtitle": "Choose specific albums or singles",
  "@discographySelectAlbumsSubtitle": {
    "description": "Subtitle for select albums option"
  },
@@ -2044,7 +2036,7 @@
  "@discographyFetchingTracks": {
    "description": "Progress - fetching album tracks"
  },
-  "discographyFetchingAlbum": "Lade {current} von {total}...",
+  "discographyFetchingAlbum": "Fetching {current} of {total}...",
  "@discographyFetchingAlbum": {
    "description": "Progress - fetching specific album",
    "placeholders": {
@@ -2069,7 +2061,7 @@
  "@discographyDownloadSelected": {
    "description": "Button - download selected albums"
  },
-  "discographyAddedToQueue": "{count} Titel zur Warteschlange hinzugefügt",
+  "discographyAddedToQueue": "Added {count} tracks to queue",
  "@discographyAddedToQueue": {
    "description": "Snackbar - tracks added from discography",
    "placeholders": {
@@ -2094,7 +2086,7 @@
  "@discographyNoAlbums": {
    "description": "Error - no albums found for artist"
  },
-  "discographyFailedToFetch": "Fehler beim Abrufen einiger Alben",
+  "discographyFailedToFetch": "Failed to fetch some albums",
  "@discographyFailedToFetch": {
    "description": "Error - some albums failed to load"
  },
@@ -2106,15 +2098,15 @@
  "@allFilesAccess": {
    "description": "Toggle for MANAGE_EXTERNAL_STORAGE permission"
  },
-  "allFilesAccessEnabledSubtitle": "Darf in jeden Ordner schreiben",
+  "allFilesAccessEnabledSubtitle": "Can write to any folder",
  "@allFilesAccessEnabledSubtitle": {
    "description": "Subtitle when all files access is enabled"
  },
-  "allFilesAccessDisabledSubtitle": "Nur auf Medienordner begrenzt",
+  "allFilesAccessDisabledSubtitle": "Limited to media folders only",
  "@allFilesAccessDisabledSubtitle": {
    "description": "Subtitle when all files access is disabled"
  },
-  "allFilesAccessDescription": "Option bei Schreibfehlern bitte aktivieren (erforderlich ab Android 13).",
+  "allFilesAccessDescription": "Aktiviere die Option, wenn beim Speichern in benutzerdefinierten Ordnern Schreibfehler auftreten. Weil Android 13+ standardmäßig den Zugriff auf bestimmte Verzeichnisse einschränkt.",
  "@allFilesAccessDescription": {
    "description": "Description explaining when to enable all files access"
  },
@@ -2130,7 +2122,7 @@
  "@settingsLocalLibrary": {
    "description": "Settings menu item - local library"
  },
-  "settingsLocalLibrarySubtitle": "Musik scannen & Duplikate erkennen",
+  "settingsLocalLibrarySubtitle": "Scan music & detect duplicates",
  "@settingsLocalLibrarySubtitle": {
    "description": "Subtitle for local library settings"
  },
@@ -2138,7 +2130,7 @@
  "@settingsCache": {
    "description": "Settings menu item - cache management"
  },
-  "settingsCacheSubtitle": "Größe anzeigen und Daten im Cache leeren",
+  "settingsCacheSubtitle": "View size and clear cached data",
  "@settingsCacheSubtitle": {
    "description": "Subtitle for cache management menu"
  },
@@ -2154,7 +2146,7 @@
  "@libraryEnableLocalLibrary": {
    "description": "Toggle to enable library scanning"
  },
-  "libraryEnableLocalLibrarySubtitle": "Scan und verfolge deine bestehende Musik",
+  "libraryEnableLocalLibrarySubtitle": "Scan and track your existing music",
  "@libraryEnableLocalLibrarySubtitle": {
    "description": "Subtitle for enable toggle"
  },
@@ -2166,7 +2158,7 @@
  "@libraryFolderHint": {
    "description": "Placeholder when no folder selected"
  },
-  "libraryShowDuplicateIndicator": "Duplikat Indikator anzeigen",
+  "libraryShowDuplicateIndicator": "Show Duplicate Indicator",
  "@libraryShowDuplicateIndicator": {
    "description": "Toggle for duplicate indicator in search"
  },
@@ -2391,7 +2383,7 @@
  "@tutorialWelcomeTip1": {
    "description": "Tutorial welcome tip 1"
  },
-  "tutorialWelcomeTip2": "Hole dir FLAC Audio von Tidal, Qobuz oder Deezer",
+  "tutorialWelcomeTip2": "Hole dir FLAC Audio von Tidal, Qobuz oder Amazon Musik",
  "@tutorialWelcomeTip2": {
    "description": "Tutorial welcome tip 2"
  },
@@ -2463,7 +2455,7 @@
  "@tutorialSettingsDesc": {
    "description": "Tutorial settings page description"
  },
-  "tutorialSettingsTip1": "Download-Ordner und Ordner-Organisation ändern",
+  "tutorialSettingsTip1": "Downloadverzeichnis und Ordnerorganisation ändern",
  "@tutorialSettingsTip1": {
    "description": "Tutorial settings tip 1"
  },
@@ -2537,7 +2529,7 @@
  "@cacheSectionMaintenance": {
    "description": "Section header for cleanup actions"
  },
-  "cacheAppDirectory": "App-Cache Ordner",
+  "cacheAppDirectory": "App-Cache Verzeichnis",
  "@cacheAppDirectory": {
    "description": "Cache item title for app cache directory"
  },
@@ -2545,7 +2537,7 @@
  "@cacheAppDirectoryDesc": {
    "description": "Description of what app cache directory contains"
  },
-  "cacheTempDirectory": "Temporärer Ordner",
+  "cacheTempDirectory": "Temporäres Verzeichnis",
  "@cacheTempDirectory": {
    "description": "Cache item title for temporary files directory"
  },
@@ -2713,7 +2705,7 @@
  "@trackEditMetadata": {
    "description": "Menu action - edit embedded metadata"
  },
-  "trackCoverSaved": "Cover in {fileName} gespeichert",
+  "trackCoverSaved": "Cover art saved to {fileName}",
  "@trackCoverSaved": {
    "description": "Snackbar after cover art saved",
    "placeholders": {
@@ -2722,7 +2714,7 @@
      }
    }
  },
-  "trackCoverNoSource": "Keine Cover Quelle vorhanden",
+  "trackCoverNoSource": "No cover art source available",
  "@trackCoverNoSource": {
    "description": "Snackbar when no cover art URL or embedded cover"
  },
@@ -2816,90 +2808,6 @@
  "@trackConvertFailed": {
    "description": "Snackbar when conversion fails"
  },
-  "cueSplitTitle": "CUE-Sheet aufteilen",
-  "@cueSplitTitle": {
-    "description": "Title for CUE split bottom sheet"
-  },
-  "cueSplitSubtitle": "CUE+FLAC in einzelne Titel aufteilen",
-  "@cueSplitSubtitle": {
-    "description": "Subtitle for CUE split menu item"
-  },
-  "cueSplitAlbum": "Album: {album}",
-  "@cueSplitAlbum": {
-    "description": "Album name in CUE split sheet",
-    "placeholders": {
-      "album": {
-        "type": "String"
-      }
-    }
-  },
-  "cueSplitArtist": "Künstler: {artist}",
-  "@cueSplitArtist": {
-    "description": "Artist name in CUE split sheet",
-    "placeholders": {
-      "artist": {
-        "type": "String"
-      }
-    }
-  },
-  "cueSplitTrackCount": "{count} Titel",
-  "@cueSplitTrackCount": {
-    "description": "Number of tracks in CUE sheet",
-    "placeholders": {
-      "count": {
-        "type": "int"
-      }
-    }
-  },
-  "cueSplitConfirmTitle": "CUE-Album aufteilen",
-  "@cueSplitConfirmTitle": {
-    "description": "CUE split confirmation dialog title"
-  },
-  "cueSplitConfirmMessage": "Soll „{album}“ in {count} einzelne FLAC-Dateien aufgeteilt werden?\n\nDie Dateien werden im selben Ordner gespeichert.",
-  "@cueSplitConfirmMessage": {
-    "description": "CUE split confirmation dialog message",
-    "placeholders": {
-      "album": {
-        "type": "String"
-      },
-      "count": {
-        "type": "int"
-      }
-    }
-  },
-  "cueSplitSplitting": "CUE-Sheet wird geteilt... ({current}/{total})",
-  "@cueSplitSplitting": {
-    "description": "Snackbar while splitting CUE",
-    "placeholders": {
-      "current": {
-        "type": "int"
-      },
-      "total": {
-        "type": "int"
-      }
-    }
-  },
-  "cueSplitSuccess": "{count} Titel erfolgreich aufgeteilt",
-  "@cueSplitSuccess": {
-    "description": "Snackbar after successful CUE split",
-    "placeholders": {
-      "count": {
-        "type": "int"
-      }
-    }
-  },
-  "cueSplitFailed": "CUE-Aufteilung fehlgeschlagen",
-  "@cueSplitFailed": {
-    "description": "Snackbar when CUE split fails"
-  },
-  "cueSplitNoAudioFile": "Audiodatei für dieses CUE-Sheet nicht gefunden",
-  "@cueSplitNoAudioFile": {
-    "description": "Error when CUE audio file is missing"
-  },
-  "cueSplitButton": "In Titel aufteilen",
-  "@cueSplitButton": {
-    "description": "Button text to start CUE splitting"
-  },
  "actionCreate": "Erstellen",
  "@actionCreate": {
    "description": "Generic action button - create"
@@ -3186,11 +3094,11 @@
      }
    }
  },
-  "downloadUseAlbumArtistForFoldersAlbumSubtitle": "Interpret-Ordner verwenden Album-Interpret, sofern vorhanden",
+  "downloadUseAlbumArtistForFoldersAlbumSubtitle": "Künstlerordner verwenden den Album-Interpreten, wenn verfügbar",
  "@downloadUseAlbumArtistForFoldersAlbumSubtitle": {
    "description": "Subtitle when Album Artist is used for folder naming"
  },
-  "downloadUseAlbumArtistForFoldersTrackSubtitle": "Künstler-Ordner nur für Titel-Künstler",
+  "downloadUseAlbumArtistForFoldersTrackSubtitle": "Artist folders use Track Artist only",
  "@downloadUseAlbumArtistForFoldersTrackSubtitle": {
    "description": "Subtitle when Track Artist is used for folder naming"
  }
@@ -450,7 +450,7 @@
  "@aboutSpotiSaverDesc": {
    "description": "Credit for SpotiSaver API"
  },
-  "aboutAppDescription": "Download Spotify tracks in lossless quality from Tidal and Qobuz.",
+  "aboutAppDescription": "Descarga pistas de Spotify con calidad sin pérdida de Tidal y Qobuz.",
  "@aboutAppDescription": {
    "description": "App description in header card"
  },
@@ -897,18 +897,6 @@
  "@errorNoTracksFound": {
    "description": "Error - search returned no results"
  },
-  "errorUrlNotRecognized": "Link not recognized",
-  "@errorUrlNotRecognized": {
-    "description": "Error title - URL not handled by any extension or service"
-  },
-  "errorUrlNotRecognizedMessage": "This link is not supported. Make sure the URL is correct and a compatible extension is installed.",
-  "@errorUrlNotRecognizedMessage": {
-    "description": "Error message - URL not recognized explanation"
-  },
-  "errorUrlFetchFailed": "Failed to load content from this link. Please try again.",
-  "@errorUrlFetchFailed": {
-    "description": "Error message - generic URL fetch failure"
-  },
  "errorMissingExtensionSource": "No se puede cargar {item}: falta una fuente de extensión",
  "@errorMissingExtensionSource": {
    "description": "Error - extension source not available",
@@ -1003,26 +991,10 @@
  "@filenameFormat": {
    "description": "Setting title - filename pattern"
  },
-  "filenameShowAdvancedTags": "Show advanced tags",
-  "@filenameShowAdvancedTags": {
-    "description": "Toggle label for showing advanced filename tags"
-  },
-  "filenameShowAdvancedTagsDescription": "Enable formatted tags for track padding and date patterns",
-  "@filenameShowAdvancedTagsDescription": {
-    "description": "Description for advanced filename tag toggle"
-  },
  "folderOrganizationNone": "Ninguna organización",
  "@folderOrganizationNone": {
    "description": "Folder option - flat structure"
  },
-  "folderOrganizationByPlaylist": "By Playlist",
-  "@folderOrganizationByPlaylist": {
-    "description": "Folder option - playlist folders"
-  },
-  "folderOrganizationByPlaylistSubtitle": "Separate folder for each playlist",
-  "@folderOrganizationByPlaylistSubtitle": {
-    "description": "Subtitle for playlist folder option"
-  },
  "folderOrganizationByArtist": "Por Artista",
  "@folderOrganizationByArtist": {
    "description": "Folder option - artist folders"
@@ -1773,6 +1745,10 @@
  "@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": "Preguntar antes de descargar",
  "@downloadAskBeforeDownload": {
    "description": "Setting - show quality picker"
@@ -2222,15 +2198,6 @@
  "@libraryAboutDescription": {
    "description": "Description of local library feature"
  },
-  "libraryTracksUnit": "{count, plural, =1{track} other{tracks}}",
-  "@libraryTracksUnit": {
-    "description": "Unit label for tracks count (without the number itself)",
-    "placeholders": {
-      "count": {
-        "type": "int"
-      }
-    }
-  },
  "libraryLastScanned": "Last scanned: {time}",
  "@libraryLastScanned": {
    "description": "Last scan time display",
@@ -2391,7 +2358,7 @@
  "@tutorialWelcomeTip1": {
    "description": "Tutorial welcome tip 1"
  },
-  "tutorialWelcomeTip2": "Get FLAC quality audio from Tidal, Qobuz, or Deezer",
+  "tutorialWelcomeTip2": "Obtén audio en calidad FLAC de Tidal, Qobuz o Deezer",
  "@tutorialWelcomeTip2": {
    "description": "Tutorial welcome tip 2"
  },
@@ -2816,367 +2783,6 @@
  "@trackConvertFailed": {
    "description": "Snackbar when conversion fails"
  },
-  "cueSplitTitle": "Split CUE Sheet",
-  "@cueSplitTitle": {
-    "description": "Title for CUE split bottom sheet"
-  },
-  "cueSplitSubtitle": "Split CUE+FLAC into individual tracks",
-  "@cueSplitSubtitle": {
-    "description": "Subtitle for CUE split menu item"
-  },
-  "cueSplitAlbum": "Album: {album}",
-  "@cueSplitAlbum": {
-    "description": "Album name in CUE split sheet",
-    "placeholders": {
-      "album": {
-        "type": "String"
-      }
-    }
-  },
-  "cueSplitArtist": "Artist: {artist}",
-  "@cueSplitArtist": {
-    "description": "Artist name in CUE split sheet",
-    "placeholders": {
-      "artist": {
-        "type": "String"
-      }
-    }
-  },
-  "cueSplitTrackCount": "{count} tracks",
-  "@cueSplitTrackCount": {
-    "description": "Number of tracks in CUE sheet",
-    "placeholders": {
-      "count": {
-        "type": "int"
-      }
-    }
-  },
-  "cueSplitConfirmTitle": "Split CUE Album",
-  "@cueSplitConfirmTitle": {
-    "description": "CUE split confirmation dialog title"
-  },
-  "cueSplitConfirmMessage": "Split \"{album}\" into {count} individual FLAC files?\n\nFiles will be saved to the same directory.",
-  "@cueSplitConfirmMessage": {
-    "description": "CUE split confirmation dialog message",
-    "placeholders": {
-      "album": {
-        "type": "String"
-      },
-      "count": {
-        "type": "int"
-      }
-    }
-  },
-  "cueSplitSplitting": "Splitting CUE sheet... ({current}/{total})",
-  "@cueSplitSplitting": {
-    "description": "Snackbar while splitting CUE",
-    "placeholders": {
-      "current": {
-        "type": "int"
-      },
-      "total": {
-        "type": "int"
-      }
-    }
-  },
-  "cueSplitSuccess": "Split into {count} tracks successfully",
-  "@cueSplitSuccess": {
-    "description": "Snackbar after successful CUE split",
-    "placeholders": {
-      "count": {
-        "type": "int"
-      }
-    }
-  },
-  "cueSplitFailed": "CUE split failed",
-  "@cueSplitFailed": {
-    "description": "Snackbar when CUE split fails"
-  },
-  "cueSplitNoAudioFile": "Audio file not found for this CUE sheet",
-  "@cueSplitNoAudioFile": {
-    "description": "Error when CUE audio file is missing"
-  },
-  "cueSplitButton": "Split into Tracks",
-  "@cueSplitButton": {
-    "description": "Button text to start CUE splitting"
-  },
-  "actionCreate": "Create",
-  "@actionCreate": {
-    "description": "Generic action button - create"
-  },
-  "collectionFoldersTitle": "My folders",
-  "@collectionFoldersTitle": {
-    "description": "Library section title for custom folders"
-  },
-  "collectionWishlist": "Wishlist",
-  "@collectionWishlist": {
-    "description": "Custom folder for saved tracks to download later"
-  },
-  "collectionLoved": "Loved",
-  "@collectionLoved": {
-    "description": "Custom folder for favorite tracks"
-  },
-  "collectionPlaylists": "Playlists",
-  "@collectionPlaylists": {
-    "description": "Custom user playlists folder"
-  },
-  "collectionPlaylist": "Playlist",
-  "@collectionPlaylist": {
-    "description": "Single playlist label"
-  },
-  "collectionAddToPlaylist": "Add to playlist",
-  "@collectionAddToPlaylist": {
-    "description": "Action to add a track to user playlist"
-  },
-  "collectionCreatePlaylist": "Create playlist",
-  "@collectionCreatePlaylist": {
-    "description": "Action to create a new playlist"
-  },
-  "collectionNoPlaylistsYet": "No playlists yet",
-  "@collectionNoPlaylistsYet": {
-    "description": "Empty state title when user has no playlists"
-  },
-  "collectionNoPlaylistsSubtitle": "Create a playlist to start categorizing tracks",
-  "@collectionNoPlaylistsSubtitle": {
-    "description": "Empty state subtitle when user has no playlists"
-  },
-  "collectionPlaylistTracks": "{count, plural, =1{1 track} other{{count} tracks}}",
-  "@collectionPlaylistTracks": {
-    "description": "Track count label for custom playlists",
-    "placeholders": {
-      "count": {
-        "type": "int"
-      }
-    }
-  },
-  "collectionAddedToPlaylist": "Added to \"{playlistName}\"",
-  "@collectionAddedToPlaylist": {
-    "description": "Snackbar after adding track to playlist",
-    "placeholders": {
-      "playlistName": {
-        "type": "String"
-      }
-    }
-  },
-  "collectionAlreadyInPlaylist": "Already in \"{playlistName}\"",
-  "@collectionAlreadyInPlaylist": {
-    "description": "Snackbar when track already exists in playlist",
-    "placeholders": {
-      "playlistName": {
-        "type": "String"
-      }
-    }
-  },
-  "collectionPlaylistCreated": "Playlist created",
-  "@collectionPlaylistCreated": {
-    "description": "Snackbar after creating playlist"
-  },
-  "collectionPlaylistNameHint": "Playlist name",
-  "@collectionPlaylistNameHint": {
-    "description": "Hint text for playlist name input"
-  },
-  "collectionPlaylistNameRequired": "Playlist name is required",
-  "@collectionPlaylistNameRequired": {
-    "description": "Validation error for empty playlist name"
-  },
-  "collectionRenamePlaylist": "Rename playlist",
-  "@collectionRenamePlaylist": {
-    "description": "Action to rename playlist"
-  },
-  "collectionDeletePlaylist": "Delete playlist",
-  "@collectionDeletePlaylist": {
-    "description": "Action to delete playlist"
-  },
-  "collectionDeletePlaylistMessage": "Delete \"{playlistName}\" and all tracks inside it?",
-  "@collectionDeletePlaylistMessage": {
-    "description": "Confirmation message for deleting playlist",
-    "placeholders": {
-      "playlistName": {
-        "type": "String"
-      }
-    }
-  },
-  "collectionPlaylistDeleted": "Playlist deleted",
-  "@collectionPlaylistDeleted": {
-    "description": "Snackbar after deleting playlist"
-  },
-  "collectionPlaylistRenamed": "Playlist renamed",
-  "@collectionPlaylistRenamed": {
-    "description": "Snackbar after renaming playlist"
-  },
-  "collectionWishlistEmptyTitle": "Wishlist is empty",
-  "@collectionWishlistEmptyTitle": {
-    "description": "Wishlist empty state title"
-  },
-  "collectionWishlistEmptySubtitle": "Tap + on tracks to save what you want to download later",
-  "@collectionWishlistEmptySubtitle": {
-    "description": "Wishlist empty state subtitle"
-  },
-  "collectionLovedEmptyTitle": "Loved folder is empty",
-  "@collectionLovedEmptyTitle": {
-    "description": "Loved empty state title"
-  },
-  "collectionLovedEmptySubtitle": "Tap love on tracks to keep your favorites",
-  "@collectionLovedEmptySubtitle": {
-    "description": "Loved empty state subtitle"
-  },
-  "collectionPlaylistEmptyTitle": "Playlist is empty",
-  "@collectionPlaylistEmptyTitle": {
-    "description": "Playlist empty state title"
-  },
-  "collectionPlaylistEmptySubtitle": "Long-press + on any track to add it here",
-  "@collectionPlaylistEmptySubtitle": {
-    "description": "Playlist empty state subtitle"
-  },
-  "collectionRemoveFromPlaylist": "Remove from playlist",
-  "@collectionRemoveFromPlaylist": {
-    "description": "Tooltip for removing track from playlist"
-  },
-  "collectionRemoveFromFolder": "Remove from folder",
-  "@collectionRemoveFromFolder": {
-    "description": "Tooltip for removing track from wishlist/loved folder"
-  },
-  "collectionRemoved": "\"{trackName}\" removed",
-  "@collectionRemoved": {
-    "description": "Snackbar after removing a track from a collection",
-    "placeholders": {
-      "trackName": {
-        "type": "String"
-      }
-    }
-  },
-  "collectionAddedToLoved": "\"{trackName}\" added to Loved",
-  "@collectionAddedToLoved": {
-    "description": "Snackbar after adding track to loved folder",
-    "placeholders": {
-      "trackName": {
-        "type": "String"
-      }
-    }
-  },
-  "collectionRemovedFromLoved": "\"{trackName}\" removed from Loved",
-  "@collectionRemovedFromLoved": {
-    "description": "Snackbar after removing track from loved folder",
-    "placeholders": {
-      "trackName": {
-        "type": "String"
-      }
-    }
-  },
-  "collectionAddedToWishlist": "\"{trackName}\" added to Wishlist",
-  "@collectionAddedToWishlist": {
-    "description": "Snackbar after adding track to wishlist",
-    "placeholders": {
-      "trackName": {
-        "type": "String"
-      }
-    }
-  },
-  "collectionRemovedFromWishlist": "\"{trackName}\" removed from Wishlist",
-  "@collectionRemovedFromWishlist": {
-    "description": "Snackbar after removing track from wishlist",
-    "placeholders": {
-      "trackName": {
-        "type": "String"
-      }
-    }
-  },
-  "trackOptionAddToLoved": "Add to Loved",
-  "@trackOptionAddToLoved": {
-    "description": "Bottom sheet action label - add track to loved folder"
-  },
-  "trackOptionRemoveFromLoved": "Remove from Loved",
-  "@trackOptionRemoveFromLoved": {
-    "description": "Bottom sheet action label - remove track from loved folder"
-  },
-  "trackOptionAddToWishlist": "Add to Wishlist",
-  "@trackOptionAddToWishlist": {
-    "description": "Bottom sheet action label - add track to wishlist"
-  },
-  "trackOptionRemoveFromWishlist": "Remove from Wishlist",
-  "@trackOptionRemoveFromWishlist": {
-    "description": "Bottom sheet action label - remove track from wishlist"
-  },
-  "collectionPlaylistChangeCover": "Change cover image",
-  "@collectionPlaylistChangeCover": {
-    "description": "Bottom sheet action to pick a custom cover image for a playlist"
-  },
-  "collectionPlaylistRemoveCover": "Remove cover image",
-  "@collectionPlaylistRemoveCover": {
-    "description": "Bottom sheet action to remove custom cover image from a playlist"
-  },
-  "selectionShareCount": "Share {count} {count, plural, =1{track} other{tracks}}",
-  "@selectionShareCount": {
-    "description": "Share button text with count in selection mode",
-    "placeholders": {
-      "count": {
-        "type": "int"
-      }
-    }
-  },
-  "selectionShareNoFiles": "No shareable files found",
-  "@selectionShareNoFiles": {
-    "description": "Snackbar when no selected files exist on disk"
-  },
-  "selectionConvertCount": "Convert {count} {count, plural, =1{track} other{tracks}}",
-  "@selectionConvertCount": {
-    "description": "Convert button text with count in selection mode",
-    "placeholders": {
-      "count": {
-        "type": "int"
-      }
-    }
-  },
-  "selectionConvertNoConvertible": "No convertible tracks selected",
-  "@selectionConvertNoConvertible": {
-    "description": "Snackbar when no selected tracks support conversion"
-  },
-  "selectionBatchConvertConfirmTitle": "Batch Convert",
-  "@selectionBatchConvertConfirmTitle": {
-    "description": "Confirmation dialog title for batch conversion"
-  },
-  "selectionBatchConvertConfirmMessage": "Convert {count} {count, plural, =1{track} other{tracks}} to {format} at {bitrate}?\n\nOriginal files will be deleted after conversion.",
-  "@selectionBatchConvertConfirmMessage": {
-    "description": "Confirmation dialog message for batch conversion",
-    "placeholders": {
-      "count": {
-        "type": "int"
-      },
-      "format": {
-        "type": "String"
-      },
-      "bitrate": {
-        "type": "String"
-      }
-    }
-  },
-  "selectionBatchConvertProgress": "Converting {current} of {total}...",
-  "@selectionBatchConvertProgress": {
-    "description": "Snackbar during batch conversion progress",
-    "placeholders": {
-      "current": {
-        "type": "int"
-      },
-      "total": {
-        "type": "int"
-      }
-    }
-  },
-  "selectionBatchConvertSuccess": "Converted {success} of {total} tracks to {format}",
-  "@selectionBatchConvertSuccess": {
-    "description": "Snackbar after batch conversion completes",
-    "placeholders": {
-      "success": {
-        "type": "int"
-      },
-      "total": {
-        "type": "int"
-      },
-      "format": {
-        "type": "String"
-      }
-    }
-  },
  "downloadedAlbumDownloadedCount": "{count} descargado",
  "@downloadedAlbumDownloadedCount": {
    "description": "Downloaded tracks count badge",
@@ -3194,4 +2800,4 @@
  "@downloadUseAlbumArtistForFoldersTrackSubtitle": {
    "description": "Subtitle when Track Artist is used for folder naming"
  }
-}
+}
@@ -450,7 +450,7 @@
  "@aboutSpotiSaverDesc": {
    "description": "Credit for SpotiSaver API"
  },
-  "aboutAppDescription": "Download Spotify tracks in lossless quality from Tidal and Qobuz.",
+  "aboutAppDescription": "Download Spotify tracks in lossless quality from Tidal, Qobuz, and Amazon Music.",
  "@aboutAppDescription": {
    "description": "App description in header card"
  },
@@ -897,18 +897,6 @@
  "@errorNoTracksFound": {
    "description": "Error - search returned no results"
  },
-  "errorUrlNotRecognized": "Link not recognized",
-  "@errorUrlNotRecognized": {
-    "description": "Error title - URL not handled by any extension or service"
-  },
-  "errorUrlNotRecognizedMessage": "This link is not supported. Make sure the URL is correct and a compatible extension is installed.",
-  "@errorUrlNotRecognizedMessage": {
-    "description": "Error message - URL not recognized explanation"
-  },
-  "errorUrlFetchFailed": "Failed to load content from this link. Please try again.",
-  "@errorUrlFetchFailed": {
-    "description": "Error message - generic URL fetch failure"
-  },
  "errorMissingExtensionSource": "Cannot load {item}: missing extension source",
  "@errorMissingExtensionSource": {
    "description": "Error - extension source not available",
@@ -1015,14 +1003,6 @@
  "@folderOrganizationNone": {
    "description": "Folder option - flat structure"
  },
-  "folderOrganizationByPlaylist": "By Playlist",
-  "@folderOrganizationByPlaylist": {
-    "description": "Folder option - playlist folders"
-  },
-  "folderOrganizationByPlaylistSubtitle": "Separate folder for each playlist",
-  "@folderOrganizationByPlaylistSubtitle": {
-    "description": "Subtitle for playlist folder option"
-  },
  "folderOrganizationByArtist": "By Artist",
  "@folderOrganizationByArtist": {
    "description": "Folder option - artist folders"
@@ -1117,7 +1097,7 @@
  },
  "providerBuiltIn": "Built-in",
  "@providerBuiltIn": {
-    "description": "Label for built-in providers (Tidal/Qobuz)"
+    "description": "Label for built-in providers (Tidal/Qobuz/Amazon)"
  },
  "providerExtension": "Extension",
  "@providerExtension": {
@@ -1773,6 +1753,18 @@
  "@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"
+  },
+  "youtubeOpusBitrateTitle": "YouTube Opus Bitrate",
+  "@youtubeOpusBitrateTitle": {
+    "description": "Title for YouTube Opus bitrate setting"
+  },
+  "youtubeMp3BitrateTitle": "YouTube MP3 Bitrate",
+  "@youtubeMp3BitrateTitle": {
+    "description": "Title for YouTube MP3 bitrate setting"
+  },
  "downloadAskBeforeDownload": "Ask Before Download",
  "@downloadAskBeforeDownload": {
    "description": "Setting - show quality picker"
@@ -2391,7 +2383,7 @@
  "@tutorialWelcomeTip1": {
    "description": "Tutorial welcome tip 1"
  },
-  "tutorialWelcomeTip2": "Get FLAC quality audio from Tidal, Qobuz, or Deezer",
+  "tutorialWelcomeTip2": "Get FLAC quality audio from Tidal, Qobuz, or Amazon Music",
  "@tutorialWelcomeTip2": {
    "description": "Tutorial welcome tip 2"
  },
@@ -2816,90 +2808,6 @@
  "@trackConvertFailed": {
    "description": "Snackbar when conversion fails"
  },
-  "cueSplitTitle": "Split CUE Sheet",
-  "@cueSplitTitle": {
-    "description": "Title for CUE split bottom sheet"
-  },
-  "cueSplitSubtitle": "Split CUE+FLAC into individual tracks",
-  "@cueSplitSubtitle": {
-    "description": "Subtitle for CUE split menu item"
-  },
-  "cueSplitAlbum": "Album: {album}",
-  "@cueSplitAlbum": {
-    "description": "Album name in CUE split sheet",
-    "placeholders": {
-      "album": {
-        "type": "String"
-      }
-    }
-  },
-  "cueSplitArtist": "Artist: {artist}",
-  "@cueSplitArtist": {
-    "description": "Artist name in CUE split sheet",
-    "placeholders": {
-      "artist": {
-        "type": "String"
-      }
-    }
-  },
-  "cueSplitTrackCount": "{count} tracks",
-  "@cueSplitTrackCount": {
-    "description": "Number of tracks in CUE sheet",
-    "placeholders": {
-      "count": {
-        "type": "int"
-      }
-    }
-  },
-  "cueSplitConfirmTitle": "Split CUE Album",
-  "@cueSplitConfirmTitle": {
-    "description": "CUE split confirmation dialog title"
-  },
-  "cueSplitConfirmMessage": "Split \"{album}\" into {count} individual FLAC files?\n\nFiles will be saved to the same directory.",
-  "@cueSplitConfirmMessage": {
-    "description": "CUE split confirmation dialog message",
-    "placeholders": {
-      "album": {
-        "type": "String"
-      },
-      "count": {
-        "type": "int"
-      }
-    }
-  },
-  "cueSplitSplitting": "Splitting CUE sheet... ({current}/{total})",
-  "@cueSplitSplitting": {
-    "description": "Snackbar while splitting CUE",
-    "placeholders": {
-      "current": {
-        "type": "int"
-      },
-      "total": {
-        "type": "int"
-      }
-    }
-  },
-  "cueSplitSuccess": "Split into {count} tracks successfully",
-  "@cueSplitSuccess": {
-    "description": "Snackbar after successful CUE split",
-    "placeholders": {
-      "count": {
-        "type": "int"
-      }
-    }
-  },
-  "cueSplitFailed": "CUE split failed",
-  "@cueSplitFailed": {
-    "description": "Snackbar when CUE split fails"
-  },
-  "cueSplitNoAudioFile": "Audio file not found for this CUE sheet",
-  "@cueSplitNoAudioFile": {
-    "description": "Error when CUE audio file is missing"
-  },
-  "cueSplitButton": "Split into Tracks",
-  "@cueSplitButton": {
-    "description": "Button text to start CUE splitting"
-  },
  "actionCreate": "Create",
  "@actionCreate": {
    "description": "Generic action button - create"
@@ -450,7 +450,7 @@
  "@aboutSpotiSaverDesc": {
    "description": "Credit for SpotiSaver API"
  },
-  "aboutAppDescription": "Download Spotify tracks in lossless quality from Tidal and Qobuz.",
+  "aboutAppDescription": "Download Spotify tracks in lossless quality from Tidal, Qobuz, and Amazon Music.",
  "@aboutAppDescription": {
    "description": "App description in header card"
  },
@@ -897,18 +897,6 @@
  "@errorNoTracksFound": {
    "description": "Error - search returned no results"
  },
-  "errorUrlNotRecognized": "Link not recognized",
-  "@errorUrlNotRecognized": {
-    "description": "Error title - URL not handled by any extension or service"
-  },
-  "errorUrlNotRecognizedMessage": "This link is not supported. Make sure the URL is correct and a compatible extension is installed.",
-  "@errorUrlNotRecognizedMessage": {
-    "description": "Error message - URL not recognized explanation"
-  },
-  "errorUrlFetchFailed": "Failed to load content from this link. Please try again.",
-  "@errorUrlFetchFailed": {
-    "description": "Error message - generic URL fetch failure"
-  },
  "errorMissingExtensionSource": "Cannot load {item}: missing extension source",
  "@errorMissingExtensionSource": {
    "description": "Error - extension source not available",
@@ -1015,14 +1003,6 @@
  "@folderOrganizationNone": {
    "description": "Folder option - flat structure"
  },
-  "folderOrganizationByPlaylist": "By Playlist",
-  "@folderOrganizationByPlaylist": {
-    "description": "Folder option - playlist folders"
-  },
-  "folderOrganizationByPlaylistSubtitle": "Separate folder for each playlist",
-  "@folderOrganizationByPlaylistSubtitle": {
-    "description": "Subtitle for playlist folder option"
-  },
  "folderOrganizationByArtist": "By Artist",
  "@folderOrganizationByArtist": {
    "description": "Folder option - artist folders"
@@ -1117,7 +1097,7 @@
  },
  "providerBuiltIn": "Built-in",
  "@providerBuiltIn": {
-    "description": "Label for built-in providers (Tidal/Qobuz)"
+    "description": "Label for built-in providers (Tidal/Qobuz/Amazon)"
  },
  "providerExtension": "Extension",
  "@providerExtension": {
@@ -1773,6 +1753,18 @@
  "@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"
+  },
+  "youtubeOpusBitrateTitle": "YouTube Opus Bitrate",
+  "@youtubeOpusBitrateTitle": {
+    "description": "Title for YouTube Opus bitrate setting"
+  },
+  "youtubeMp3BitrateTitle": "YouTube MP3 Bitrate",
+  "@youtubeMp3BitrateTitle": {
+    "description": "Title for YouTube MP3 bitrate setting"
+  },
  "downloadAskBeforeDownload": "Ask Before Download",
  "@downloadAskBeforeDownload": {
    "description": "Setting - show quality picker"
@@ -2391,7 +2383,7 @@
  "@tutorialWelcomeTip1": {
    "description": "Tutorial welcome tip 1"
  },
-  "tutorialWelcomeTip2": "Get FLAC quality audio from Tidal, Qobuz, or Deezer",
+  "tutorialWelcomeTip2": "Get FLAC quality audio from Tidal, Qobuz, or Amazon Music",
  "@tutorialWelcomeTip2": {
    "description": "Tutorial welcome tip 2"
  },
@@ -2816,90 +2808,6 @@
  "@trackConvertFailed": {
    "description": "Snackbar when conversion fails"
  },
-  "cueSplitTitle": "Split CUE Sheet",
-  "@cueSplitTitle": {
-    "description": "Title for CUE split bottom sheet"
-  },
-  "cueSplitSubtitle": "Split CUE+FLAC into individual tracks",
-  "@cueSplitSubtitle": {
-    "description": "Subtitle for CUE split menu item"
-  },
-  "cueSplitAlbum": "Album: {album}",
-  "@cueSplitAlbum": {
-    "description": "Album name in CUE split sheet",
-    "placeholders": {
-      "album": {
-        "type": "String"
-      }
-    }
-  },
-  "cueSplitArtist": "Artist: {artist}",
-  "@cueSplitArtist": {
-    "description": "Artist name in CUE split sheet",
-    "placeholders": {
-      "artist": {
-        "type": "String"
-      }
-    }
-  },
-  "cueSplitTrackCount": "{count} tracks",
-  "@cueSplitTrackCount": {
-    "description": "Number of tracks in CUE sheet",
-    "placeholders": {
-      "count": {
-        "type": "int"
-      }
-    }
-  },
-  "cueSplitConfirmTitle": "Split CUE Album",
-  "@cueSplitConfirmTitle": {
-    "description": "CUE split confirmation dialog title"
-  },
-  "cueSplitConfirmMessage": "Split \"{album}\" into {count} individual FLAC files?\n\nFiles will be saved to the same directory.",
-  "@cueSplitConfirmMessage": {
-    "description": "CUE split confirmation dialog message",
-    "placeholders": {
-      "album": {
-        "type": "String"
-      },
-      "count": {
-        "type": "int"
-      }
-    }
-  },
-  "cueSplitSplitting": "Splitting CUE sheet... ({current}/{total})",
-  "@cueSplitSplitting": {
-    "description": "Snackbar while splitting CUE",
-    "placeholders": {
-      "current": {
-        "type": "int"
-      },
-      "total": {
-        "type": "int"
-      }
-    }
-  },
-  "cueSplitSuccess": "Split into {count} tracks successfully",
-  "@cueSplitSuccess": {
-    "description": "Snackbar after successful CUE split",
-    "placeholders": {
-      "count": {
-        "type": "int"
-      }
-    }
-  },
-  "cueSplitFailed": "CUE split failed",
-  "@cueSplitFailed": {
-    "description": "Snackbar when CUE split fails"
-  },
-  "cueSplitNoAudioFile": "Audio file not found for this CUE sheet",
-  "@cueSplitNoAudioFile": {
-    "description": "Error when CUE audio file is missing"
-  },
-  "cueSplitButton": "Split into Tracks",
-  "@cueSplitButton": {
-    "description": "Button text to start CUE splitting"
-  },
  "actionCreate": "Create",
  "@actionCreate": {
    "description": "Generic action button - create"
@@ -17,7 +17,7 @@
  "@navSettings": {
    "description": "Bottom navigation - Settings tab"
  },
-  "navStore": "Repo",
+  "navStore": "Toko",
  "@navStore": {
    "description": "Bottom navigation - Extension store tab"
  },
@@ -25,7 +25,7 @@
  "@homeTitle": {
    "description": "Home screen title"
  },
-  "homeSubtitle": "Tempel URL yang didukung atau cari berdasarkan nama",
+  "homeSubtitle": "Tempel link Spotify atau cari berdasarkan nama",
  "@homeSubtitle": {
    "description": "Subtitle shown below search box"
  },
@@ -211,11 +211,11 @@
  "@optionsConcurrentWarning": {
    "description": "Warning about rate limits"
  },
-  "optionsExtensionStore": "Repo Ekstensi",
+  "optionsExtensionStore": "Toko Ekstensi",
  "@optionsExtensionStore": {
    "description": "Show/hide store tab"
  },
-  "optionsExtensionStoreSubtitle": "Tampilkan tab Repo di navigasi",
+  "optionsExtensionStoreSubtitle": "Tampilkan tab Toko di navigasi",
  "@optionsExtensionStoreSubtitle": {
    "description": "Subtitle for extension store toggle"
  },
@@ -318,14 +318,10 @@
  "@extensionsUninstall": {
    "description": "Uninstall extension button"
  },
-  "storeTitle": "Repo Ekstensi",
+  "storeTitle": "Toko Ekstensi",
  "@storeTitle": {
    "description": "Store screen title"
  },
-  "storeLoadError": "Gagal memuat repo",
-  "@storeLoadError": {
-    "description": "Error heading when the store cannot be loaded"
-  },
  "storeSearch": "Cari ekstensi...",
  "@storeSearch": {
    "description": "Store search placeholder"
@@ -454,7 +450,7 @@
  "@aboutSpotiSaverDesc": {
    "description": "Credit for SpotiSaver API"
  },
-  "aboutAppDescription": "Unduh lagu-lagu Spotify dalam kualitas lossless dari Tidal dan Qobuz.",
+  "aboutAppDescription": "Unduh lagu Spotify dalam kualitas lossless dari Tidal, Qobuz, dan Amazon Music.",
  "@aboutAppDescription": {
    "description": "App description in header card"
  },
@@ -1007,11 +1003,11 @@
  "@filenameFormat": {
    "description": "Setting title - filename pattern"
  },
-  "filenameShowAdvancedTags": "Tampilkan tag lanjutan",
+  "filenameShowAdvancedTags": "Show advanced tags",
  "@filenameShowAdvancedTags": {
    "description": "Toggle label for showing advanced filename tags"
  },
-  "filenameShowAdvancedTagsDescription": "Aktifkan tag yang diformat untuk padding trek dan pola tanggal",
+  "filenameShowAdvancedTagsDescription": "Enable formatted tags for track padding and date patterns",
  "@filenameShowAdvancedTagsDescription": {
    "description": "Description for advanced filename tag toggle"
  },
@@ -1019,14 +1015,6 @@
  "@folderOrganizationNone": {
    "description": "Folder option - flat structure"
  },
-  "folderOrganizationByPlaylist": "Berdasarkan Daftar Putar",
-  "@folderOrganizationByPlaylist": {
-    "description": "Folder option - playlist folders"
-  },
-  "folderOrganizationByPlaylistSubtitle": "Setiap daftar putar memerlukan folder terpisah",
-  "@folderOrganizationByPlaylistSubtitle": {
-    "description": "Subtitle for playlist folder option"
-  },
  "folderOrganizationByArtist": "Berdasarkan Artis",
  "@folderOrganizationByArtist": {
    "description": "Folder option - artist folders"
@@ -1121,7 +1109,7 @@
  },
  "providerBuiltIn": "Bawaan",
  "@providerBuiltIn": {
-    "description": "Label for built-in providers (Tidal/Qobuz)"
+    "description": "Label for built-in providers (Tidal/Qobuz/Amazon)"
  },
  "providerExtension": "Ekstensi",
  "@providerExtension": {
@@ -1221,7 +1209,7 @@
  "@credentialsDescription": {
    "description": "Credentials dialog explanation"
  },
-  "credentialsClientId": "ID Klien",
+  "credentialsClientId": "Client ID",
  "@credentialsClientId": {
    "description": "Client ID field label - DO NOT TRANSLATE"
  },
@@ -1229,7 +1217,7 @@
  "@credentialsClientIdHint": {
    "description": "Client ID placeholder"
  },
-  "credentialsClientSecret": "Rahasia Klien",
+  "credentialsClientSecret": "Client Secret",
  "@credentialsClientSecret": {
    "description": "Client Secret field label - DO NOT TRANSLATE"
  },
@@ -1241,7 +1229,7 @@
  "@channelStable": {
    "description": "Update channel - stable releases"
  },
-  "channelPreview": "Pratinjau",
+  "channelPreview": "Preview",
  "@channelPreview": {
    "description": "Update channel - beta/preview releases"
  },
@@ -1281,39 +1269,39 @@
  "@sectionFileSettings": {
    "description": "Settings section header"
  },
-  "sectionLyrics": "Lirik",
+  "sectionLyrics": "Lyrics",
  "@sectionLyrics": {
    "description": "Settings section header"
  },
-  "lyricsMode": "Mode Lirik",
+  "lyricsMode": "Lyrics Mode",
  "@lyricsMode": {
    "description": "Setting - how to save lyrics"
  },
-  "lyricsModeDescription": "Pilih cara lirik disimpan bersama unduhan Anda",
+  "lyricsModeDescription": "Choose how lyrics are saved with your downloads",
  "@lyricsModeDescription": {
    "description": "Lyrics mode picker description"
  },
-  "lyricsModeEmbed": "Sematkan dalam file",
+  "lyricsModeEmbed": "Embed in file",
  "@lyricsModeEmbed": {
    "description": "Lyrics mode option - embed in audio file"
  },
-  "lyricsModeEmbedSubtitle": "Lirik tersimpan di dalam metadata FLAC",
+  "lyricsModeEmbedSubtitle": "Lyrics stored inside FLAC metadata",
  "@lyricsModeEmbedSubtitle": {
    "description": "Subtitle for embed option"
  },
-  "lyricsModeExternal": "File .lrc eksternal",
+  "lyricsModeExternal": "External .lrc file",
  "@lyricsModeExternal": {
    "description": "Lyrics mode option - separate LRC file"
  },
-  "lyricsModeExternalSubtitle": "File .lrc terpisah untuk pemutar musik seperti Samsung Music",
+  "lyricsModeExternalSubtitle": "Separate .lrc file for players like Samsung Music",
  "@lyricsModeExternalSubtitle": {
    "description": "Subtitle for external option"
  },
-  "lyricsModeBoth": "Keduanya",
+  "lyricsModeBoth": "Both",
  "@lyricsModeBoth": {
    "description": "Lyrics mode option - embed and external"
  },
-  "lyricsModeBothSubtitle": "Sematkan dan simpan file .lrc",
+  "lyricsModeBothSubtitle": "Embed and save .lrc file",
  "@lyricsModeBothSubtitle": {
    "description": "Subtitle for both option"
  },
@@ -1459,11 +1447,11 @@
  "@trackGenre": {
    "description": "Metadata label - music genre"
  },
-  "trackLabel": "Lebel",
+  "trackLabel": "Label",
  "@trackLabel": {
    "description": "Metadata label - record label"
  },
-  "trackCopyright": "Hak cipta",
+  "trackCopyright": "Copyright",
  "@trackCopyright": {
    "description": "Metadata label - copyright information"
  },
@@ -1487,15 +1475,15 @@
  "@trackLyricsLoadFailed": {
    "description": "Message when lyrics loading fails"
  },
-  "trackEmbedLyrics": "Sematkan Lirik",
+  "trackEmbedLyrics": "Embed Lyrics",
  "@trackEmbedLyrics": {
    "description": "Action - embed lyrics into audio file"
  },
-  "trackLyricsEmbedded": "Lirik berhasil disematkan",
+  "trackLyricsEmbedded": "Lyrics embedded successfully",
  "@trackLyricsEmbedded": {
    "description": "Snackbar - lyrics saved to file"
  },
-  "trackInstrumental": "Lagu instrumental",
+  "trackInstrumental": "Instrumental track",
  "@trackInstrumental": {
    "description": "Message when track is instrumental (no lyrics)"
  },
@@ -1574,7 +1562,7 @@
  "@storeClearFilters": {
    "description": "Button to clear all filters"
  },
-  "extensionDefaultProvider": "Bawaan (Deezer/Spotify)",
+  "extensionDefaultProvider": "Default (Deezer/Spotify)",
  "@extensionDefaultProvider": {
    "description": "Default search provider option"
  },
@@ -1590,7 +1578,7 @@
  "@extensionId": {
    "description": "Extension detail - unique ID"
  },
-  "extensionError": "Terjadi kesalahan",
+  "extensionError": "Error",
  "@extensionError": {
    "description": "Extension detail - error message"
  },
@@ -1777,6 +1765,18 @@
  "@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"
+  },
+  "youtubeOpusBitrateTitle": "YouTube Opus Bitrate",
+  "@youtubeOpusBitrateTitle": {
+    "description": "Title for YouTube Opus bitrate setting"
+  },
+  "youtubeMp3BitrateTitle": "YouTube MP3 Bitrate",
+  "@youtubeMp3BitrateTitle": {
+    "description": "Title for YouTube MP3 bitrate setting"
+  },
  "downloadAskBeforeDownload": "Tanya Sebelum Unduh",
  "@downloadAskBeforeDownload": {
    "description": "Setting - show quality picker"
@@ -1793,35 +1793,19 @@
  "@downloadAlbumFolderStructure": {
    "description": "Setting - album folder organization"
  },
-  "downloadUseAlbumArtistForFolders": "Gunakan Artis Album untuk folder",
+  "downloadUseAlbumArtistForFolders": "Use Album Artist for folders",
  "@downloadUseAlbumArtistForFolders": {
    "description": "Setting - choose whether artist folders use Album Artist or Track Artist"
  },
-  "downloadCreatePlaylistSourceFolder": "Buat folder sumber playlist",
-  "@downloadCreatePlaylistSourceFolder": {
-    "description": "Setting title for adding a playlist folder prefix before the normal organization structure"
-  },
-  "downloadCreatePlaylistSourceFolderEnabled": "Unduhan dari playlist memakai Playlist/ lalu struktur folder normal Anda.",
-  "@downloadCreatePlaylistSourceFolderEnabled": {
-    "description": "Subtitle when playlist source folder prefix is enabled"
-  },
-  "downloadCreatePlaylistSourceFolderDisabled": "Unduhan dari playlist hanya memakai struktur folder normal.",
-  "@downloadCreatePlaylistSourceFolderDisabled": {
-    "description": "Subtitle when playlist source folder prefix is disabled"
-  },
-  "downloadCreatePlaylistSourceFolderRedundant": "Mode Berdasarkan Playlist sudah menaruh unduhan ke dalam folder playlist.",
-  "@downloadCreatePlaylistSourceFolderRedundant": {
-    "description": "Subtitle when playlist folder prefix setting is redundant because folder organization is already by playlist"
-  },
-  "downloadUsePrimaryArtistOnly": "Hanya artis utama untuk folder",
+  "downloadUsePrimaryArtistOnly": "Primary artist only for folders",
  "@downloadUsePrimaryArtistOnly": {
    "description": "Setting - strip featured artists from folder name"
  },
-  "downloadUsePrimaryArtistOnlyEnabled": "Artis unggulan dihapus dari nama folder (misalnya Justin Bieber, Quavo → Justin Bieber)",
+  "downloadUsePrimaryArtistOnlyEnabled": "Featured artists removed from folder name (e.g. Justin Bieber, Quavo → Justin Bieber)",
  "@downloadUsePrimaryArtistOnlyEnabled": {
    "description": "Subtitle when primary artist only is enabled"
  },
-  "downloadUsePrimaryArtistOnlyDisabled": "Nama lengkap artis digunakan untuk nama folder",
+  "downloadUsePrimaryArtistOnlyDisabled": "Full artist string used for folder name",
  "@downloadUsePrimaryArtistOnlyDisabled": {
    "description": "Subtitle when primary artist only is disabled"
  },
@@ -1849,27 +1833,27 @@
  "@queueClearAllMessage": {
    "description": "Clear queue confirmation"
  },
-  "settingsAutoExportFailed": "Unduhan yang gagal diekspor otomatis",
+  "settingsAutoExportFailed": "Auto-export failed downloads",
  "@settingsAutoExportFailed": {
    "description": "Setting toggle for auto-export"
  },
-  "settingsAutoExportFailedSubtitle": "Simpan unduhan yang gagal ke file TXT secara otomatis",
+  "settingsAutoExportFailedSubtitle": "Save failed downloads to TXT file automatically",
  "@settingsAutoExportFailedSubtitle": {
    "description": "Subtitle for auto-export setting"
  },
-  "settingsDownloadNetwork": "Jaringan Unduhan",
+  "settingsDownloadNetwork": "Download Network",
  "@settingsDownloadNetwork": {
    "description": "Setting for network type preference"
  },
-  "settingsDownloadNetworkAny": "WiFi + Data Seluler",
+  "settingsDownloadNetworkAny": "WiFi + Mobile Data",
  "@settingsDownloadNetworkAny": {
    "description": "Network option - use any connection"
  },
-  "settingsDownloadNetworkWifiOnly": "Hanya WiFi",
+  "settingsDownloadNetworkWifiOnly": "WiFi Only",
  "@settingsDownloadNetworkWifiOnly": {
    "description": "Network option - only use WiFi"
  },
-  "settingsDownloadNetworkSubtitle": "Pilih jaringan mana yang akan digunakan untuk mengunduh. Jika diatur ke Hanya WiFi, unduhan akan berhenti sementara dan menggunakan data seluler.",
+  "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"
  },
@@ -1905,11 +1889,11 @@
  "@albumFolderYearAlbumSubtitle": {
    "description": "Folder structure example"
  },
-  "albumFolderArtistAlbumSingles": "Artis / Album + Singel",
+  "albumFolderArtistAlbumSingles": "Artist / Album + Singles",
  "@albumFolderArtistAlbumSingles": {
    "description": "Album folder option with singles inside artist"
  },
-  "albumFolderArtistAlbumSinglesSubtitle": "Artis/Album/ dan Artis/Single/",
+  "albumFolderArtistAlbumSinglesSubtitle": "Artist/Album/ and Artist/Singles/",
  "@albumFolderArtistAlbumSinglesSubtitle": {
    "description": "Folder structure example"
  },
@@ -1978,19 +1962,19 @@
  "@recentTypeSong": {
    "description": "Recent access item type - song/track"
  },
-  "recentTypePlaylist": "Daftar putar",
+  "recentTypePlaylist": "Playlist",
  "@recentTypePlaylist": {
    "description": "Recent access item type - playlist"
  },
-  "recentEmpty": "Belum ada item terbaru",
+  "recentEmpty": "No recent items yet",
  "@recentEmpty": {
    "description": "Empty state text for recent access list"
  },
-  "recentShowAllDownloads": "Tampilkan Semua Unduhan",
+  "recentShowAllDownloads": "Show All Downloads",
  "@recentShowAllDownloads": {
    "description": "Button label to unhide hidden downloads in recent access"
  },
-  "recentPlaylistInfo": "Daftar Putar: {name}",
+  "recentPlaylistInfo": "Playlist: {name}",
  "@recentPlaylistInfo": {
    "description": "Snackbar message when tapping playlist in recent access",
    "placeholders": {
@@ -2000,7 +1984,7 @@
      }
    }
  },
-  "discographyDownload": "Unduh Diskografi",
+  "discographyDownload": "Download Discography",
  "@discographyDownload": {
    "description": "Button - download artist discography"
  },
@@ -2399,47 +2383,47 @@
      }
    }
  },
-  "tutorialWelcomeTitle": "Selamat Datang di SpotiFLAC!",
+  "tutorialWelcomeTitle": "Welcome to SpotiFLAC!",
  "@tutorialWelcomeTitle": {
    "description": "Tutorial welcome page title"
  },
-  "tutorialWelcomeDesc": "Mari kita pelajari cara mengunduh musik favorit Anda dalam kualitas lossless. Tutorial singkat ini akan menunjukkan dasar-dasarnya.",
+  "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": "Unduh musik dari Spotify, Deezer, atau tempel URL yang didukung",
+  "tutorialWelcomeTip1": "Download music from Spotify, Deezer, or paste any supported URL",
  "@tutorialWelcomeTip1": {
    "description": "Tutorial welcome tip 1"
  },
-  "tutorialWelcomeTip2": "Dapatkan audio berkualitas FLAC dari Tidal, Qobuz, atau Deezer",
+  "tutorialWelcomeTip2": "Get FLAC quality audio from Tidal, Qobuz, or Amazon Music",
  "@tutorialWelcomeTip2": {
    "description": "Tutorial welcome tip 2"
  },
-  "tutorialWelcomeTip3": "Penyematan metadata, sampul album, dan lirik secara otomatis",
+  "tutorialWelcomeTip3": "Automatic metadata, cover art, and lyrics embedding",
  "@tutorialWelcomeTip3": {
    "description": "Tutorial welcome tip 3"
  },
-  "tutorialSearchTitle": "Menemukan Musik",
+  "tutorialSearchTitle": "Finding Music",
  "@tutorialSearchTitle": {
    "description": "Tutorial search page title"
  },
-  "tutorialSearchDesc": "Ada dua cara mudah untuk menemukan musik yang ingin Anda unduh.",
+  "tutorialSearchDesc": "There are two easy ways to find music you want to download.",
  "@tutorialSearchDesc": {
    "description": "Tutorial search page description"
  },
-  "tutorialDownloadTitle": "Mengunduh Musik",
+  "tutorialDownloadTitle": "Downloading Music",
  "@tutorialDownloadTitle": {
    "description": "Tutorial download page title"
  },
-  "tutorialDownloadDesc": "Mengunduh musik itu mudah dan cepat. Begini cara kerjanya.",
+  "tutorialDownloadDesc": "Downloading music is simple and fast. Here's how it works.",
  "@tutorialDownloadDesc": {
    "description": "Tutorial download page description"
  },
-  "tutorialLibraryTitle": "Perpustakaan Anda",
+  "tutorialLibraryTitle": "Your Library",
  "@tutorialLibraryTitle": {
    "description": "Tutorial library page title"
  },
-  "tutorialLibraryDesc": "Semua musik yang Anda unduh tersusun rapi di tab Perpustakaan.",
+  "tutorialLibraryDesc": "All your downloaded music is organized in the Library tab.",
  "@tutorialLibraryDesc": {
    "description": "Tutorial library page description"
  },
@@ -2463,7 +2447,7 @@
  "@tutorialExtensionsDesc": {
    "description": "Tutorial extensions page description"
  },
-  "tutorialExtensionsTip1": "Buka tab Repo untuk menemukan ekstensi yang berguna",
+  "tutorialExtensionsTip1": "Browse the Store tab to discover useful extensions",
  "@tutorialExtensionsTip1": {
    "description": "Tutorial extensions tip 1"
  },
@@ -2771,47 +2755,6 @@
  "@trackReEnrichFfmpegFailed": {
    "description": "Snackbar when FFmpeg embed fails for MP3/Opus"
  },
-  "queueFlacAction": "Antrekan FLAC",
-  "@queueFlacAction": {
-    "description": "Action/button label for queueing FLAC redownloads for local tracks"
-  },
-  "queueFlacConfirmMessage": "Cari kecocokan online untuk track yang dipilih lalu antrekan download FLAC.\n\nFile yang sudah ada tidak akan diubah atau dihapus.\n\nHanya kecocokan dengan keyakinan tinggi yang akan diantrikan otomatis.\n\n{count} dipilih",
-  "@queueFlacConfirmMessage": {
-    "description": "Confirmation dialog body before queueing FLAC redownloads for local tracks",
-    "placeholders": {
-      "count": {
-        "type": "int"
-      }
-    }
-  },
-  "queueFlacFindingProgress": "Mencari kecocokan FLAC... ({current}/{total})",
-  "@queueFlacFindingProgress": {
-    "description": "Snackbar while resolving remote matches for local FLAC redownloads",
-    "placeholders": {
-      "current": {
-        "type": "int"
-      },
-      "total": {
-        "type": "int"
-      }
-    }
-  },
-  "queueFlacNoReliableMatches": "Tidak ada kecocokan online yang cukup meyakinkan untuk pilihan ini",
-  "@queueFlacNoReliableMatches": {
-    "description": "Snackbar when no safe FLAC redownload matches were found"
-  },
-  "queueFlacQueuedWithSkipped": "Menambahkan {addedCount} track ke antrean, melewati {skippedCount}",
-  "@queueFlacQueuedWithSkipped": {
-    "description": "Snackbar when some selected local tracks were queued for FLAC redownload and some were skipped",
-    "placeholders": {
-      "addedCount": {
-        "type": "int"
-      },
-      "skippedCount": {
-        "type": "int"
-      }
-    }
-  },
  "trackSaveFailed": "Failed: {error}",
  "@trackSaveFailed": {
    "description": "Snackbar when save operation fails",
@@ -2825,7 +2768,7 @@
  "@trackConvertFormat": {
    "description": "Menu item - convert audio format"
  },
-  "trackConvertFormatSubtitle": "Konversi ke MP3, Opus, ALAC, atau FLAC",
+  "trackConvertFormatSubtitle": "Convert to MP3 or Opus",
  "@trackConvertFormatSubtitle": {
    "description": "Subtitle for convert format menu item"
  },
@@ -2860,22 +2803,6 @@
      }
    }
  },
-  "trackConvertConfirmMessageLossless": "Konversi dari {sourceFormat} ke {targetFormat}? (Lossless — tanpa kehilangan kualitas)\n\nFile asli akan dihapus setelah konversi.",
-  "@trackConvertConfirmMessageLossless": {
-    "description": "Confirmation dialog message for lossless-to-lossless conversion",
-    "placeholders": {
-      "sourceFormat": {
-        "type": "String"
-      },
-      "targetFormat": {
-        "type": "String"
-      }
-    }
-  },
-  "trackConvertLosslessHint": "Konversi lossless — tanpa kehilangan kualitas",
-  "@trackConvertLosslessHint": {
-    "description": "Hint shown when converting between lossless formats"
-  },
  "trackConvertConverting": "Converting audio...",
  "@trackConvertConverting": {
    "description": "Snackbar while converting"
@@ -2893,90 +2820,6 @@
  "@trackConvertFailed": {
    "description": "Snackbar when conversion fails"
  },
-  "cueSplitTitle": "Split CUE Sheet",
-  "@cueSplitTitle": {
-    "description": "Title for CUE split bottom sheet"
-  },
-  "cueSplitSubtitle": "Split CUE+FLAC into individual tracks",
-  "@cueSplitSubtitle": {
-    "description": "Subtitle for CUE split menu item"
-  },
-  "cueSplitAlbum": "Album: {album}",
-  "@cueSplitAlbum": {
-    "description": "Album name in CUE split sheet",
-    "placeholders": {
-      "album": {
-        "type": "String"
-      }
-    }
-  },
-  "cueSplitArtist": "Artist: {artist}",
-  "@cueSplitArtist": {
-    "description": "Artist name in CUE split sheet",
-    "placeholders": {
-      "artist": {
-        "type": "String"
-      }
-    }
-  },
-  "cueSplitTrackCount": "{count} tracks",
-  "@cueSplitTrackCount": {
-    "description": "Number of tracks in CUE sheet",
-    "placeholders": {
-      "count": {
-        "type": "int"
-      }
-    }
-  },
-  "cueSplitConfirmTitle": "Split CUE Album",
-  "@cueSplitConfirmTitle": {
-    "description": "CUE split confirmation dialog title"
-  },
-  "cueSplitConfirmMessage": "Split \"{album}\" into {count} individual FLAC files?\n\nFiles will be saved to the same directory.",
-  "@cueSplitConfirmMessage": {
-    "description": "CUE split confirmation dialog message",
-    "placeholders": {
-      "album": {
-        "type": "String"
-      },
-      "count": {
-        "type": "int"
-      }
-    }
-  },
-  "cueSplitSplitting": "Splitting CUE sheet... ({current}/{total})",
-  "@cueSplitSplitting": {
-    "description": "Snackbar while splitting CUE",
-    "placeholders": {
-      "current": {
-        "type": "int"
-      },
-      "total": {
-        "type": "int"
-      }
-    }
-  },
-  "cueSplitSuccess": "Split into {count} tracks successfully",
-  "@cueSplitSuccess": {
-    "description": "Snackbar after successful CUE split",
-    "placeholders": {
-      "count": {
-        "type": "int"
-      }
-    }
-  },
-  "cueSplitFailed": "CUE split failed",
-  "@cueSplitFailed": {
-    "description": "Snackbar when CUE split fails"
-  },
-  "cueSplitNoAudioFile": "Audio file not found for this CUE sheet",
-  "@cueSplitNoAudioFile": {
-    "description": "Error when CUE audio file is missing"
-  },
-  "cueSplitButton": "Split into Tracks",
-  "@cueSplitButton": {
-    "description": "Button text to start CUE splitting"
-  },
  "actionCreate": "Create",
  "@actionCreate": {
    "description": "Generic action button - create"
@@ -3271,4 +3114,4 @@
  "@downloadUseAlbumArtistForFoldersTrackSubtitle": {
    "description": "Subtitle when Track Artist is used for folder naming"
  }
-}
+}
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
zarzet	6ac4f555f6	fix(ios): remove stale built-in Spotify bridge handlers	2026-03-11 17:08:46 +07:00
zarzet	098544393e	docs: add centered Trendshift badge below README banner	2026-03-11 17:08:45 +07:00