feat(extension): Enhanced HTTP API for YouTube Music support

- Add http.put(), http.delete(), http.patch() shortcut methods - Add persistent cookie jar per extension - Add http.clearCookies() to clear session - Fix User-Agent header respect (no longer overwritten) - Return multi-value headers as arrays (Set-Cookie support) - Auto-stringify objects in POST/PUT/PATCH body - Add response.ok and response.status properties - Update documentation with YouTube Music example
Merge main into dev (sync v2.2.8 features)
2026-07-03 19:27:57 +02:00 · 2026-01-12 06:37:18 +07:00 · 2026-01-12 06:22:22 +07:00 · 2026-01-12 06:18:32 +07:00 · 2026-01-12 02:26:18 +07:00 · 2026-01-12 02:10:40 +07:00
120 changed files with 23314 additions and 3016 deletions
@@ -0,0 +1,123 @@
+name: Bug Report
+description: Report a bug or unexpected behavior
+title: "[Bug]: "
+labels: ["bug"]
+body:
+  - type: markdown
+    attributes:
+      value: |
+        Thanks for taking the time to report a bug! Please fill out the form below.
+
+  - type: checkboxes
+    id: checklist
+    attributes:
+      label: Checklist
+      description: Please confirm the following before submitting
+      options:
+        - label: I have searched existing issues and this bug hasn't been reported yet
+          required: true
+        - label: I am using the latest version of SpotiFLAC (Stable Version)
+          required: true
+
+  - type: textarea
+    id: description
+    attributes:
+      label: Bug Description
+      description: A clear and concise description of what the bug is
+      placeholder: Describe the bug...
+    validations:
+      required: true
+
+  - type: textarea
+    id: steps
+    attributes:
+      label: Steps to Reproduce
+      description: Steps to reproduce the behavior
+      placeholder: |
+        1. Go to '...'
+        2. Click on '...'
+        3. See error
+    validations:
+      required: true
+
+  - type: textarea
+    id: expected
+    attributes:
+      label: Expected Behavior
+      description: What did you expect to happen?
+      placeholder: Describe what you expected...
+    validations:
+      required: true
+
+  - type: textarea
+    id: actual
+    attributes:
+      label: Actual Behavior
+      description: What actually happened?
+      placeholder: Describe what actually happened...
+    validations:
+      required: true
+
+  - type: input
+    id: version
+    attributes:
+      label: App Version
+      description: Which version of SpotiFLAC are you using? (Check in Settings > About)
+      placeholder: "e.g., v2.2.0"
+    validations:
+      required: true
+
+  - type: dropdown
+    id: platform
+    attributes:
+      label: Platform
+      description: Which platform are you using?
+      options:
+        - Android
+        - iOS
+    validations:
+      required: true
+
+  - type: input
+    id: device
+    attributes:
+      label: Device & OS Version
+      description: What device and OS version are you using?
+      placeholder: "e.g., Samsung Galaxy S24, Android 14"
+    validations:
+      required: true
+
+  - type: dropdown
+    id: download-service
+    attributes:
+      label: Download Service
+      description: Which download service were you using when the bug occurred?
+      options:
+        - Tidal
+        - Qobuz
+        - Amazon Music
+        - Deezer (search only)
+        - Not applicable
+    validations:
+      required: true
+
+  - type: textarea
+    id: logs
+    attributes:
+      label: Logs / Screenshots
+      description: |
+        If applicable, add logs or screenshots to help explain your problem.
+        
+        **To get logs:**
+        1. Go to Settings > Options > Detailed Logging (turn ON)
+        2. Reproduce the bug
+        3. Go to Settings > Logs
+        4. Tap Share button to export logs
+      placeholder: Paste logs or drag & drop screenshots here...
+
+  - type: textarea
+    id: additional
+    attributes:
+      label: Additional Context
+      description: Any other context about the problem
+      placeholder: Add any other context...
@@ -0,0 +1,8 @@
+blank_issues_enabled: false
+contact_links:
+  - name: README
+    url: https://github.com/zarzet/SpotiFLAC-Mobile#readme
+    about: Check the README for setup instructions and FAQ
+  - name: Extension Development Guide
+    url: https://zarz.moe/docs
+    about: Documentation for building SpotiFLAC extensions
@@ -0,0 +1,111 @@
+name: Download Issue
+description: Report issues with downloading specific tracks or albums
+title: "[Download]: "
+labels: ["download-issue"]
+body:
+  - type: markdown
+    attributes:
+      value: |
+        Having trouble downloading a specific track or album? Please provide details below.
+
+  - type: checkboxes
+    id: checklist
+    attributes:
+      label: Checklist
+      description: Please confirm the following before submitting
+      options:
+        - label: I have tried downloading with a different service (Tidal/Qobuz/Amazon)
+          required: true
+        - label: I am using the latest version of SpotiFLAC (Stable Version)
+          required: true
+
+  - type: dropdown
+    id: issue-type
+    attributes:
+      label: Issue Type
+      description: What kind of download issue are you experiencing?
+      options:
+        - Track not found on service
+        - Wrong track downloaded
+        - Download fails/errors
+        - Metadata incorrect
+        - Audio quality issue
+        - Other
+    validations:
+      required: true
+
+  - type: input
+    id: spotify-url
+    attributes:
+      label: Spotify URL
+      description: The Spotify URL of the track/album you're trying to download
+      placeholder: "https://open.spotify.com/track/..."
+    validations:
+      required: true
+
+  - type: input
+    id: track-info
+    attributes:
+      label: Track Info
+      description: Artist name and track title
+      placeholder: "Artist - Track Title"
+    validations:
+      required: true
+
+  - type: dropdown
+    id: download-service
+    attributes:
+      label: Download Service
+      description: Which service did you try to download from?
+      options:
+        - Tidal
+        - Qobuz
+        - Amazon Music
+        - All services
+    validations:
+      required: true
+
+  - type: dropdown
+    id: search-service
+    attributes:
+      label: Search Service
+      description: Which search service are you using?
+      options:
+        - Spotify
+        - Deezer
+    validations:
+      required: true
+
+  - type: textarea
+    id: description
+    attributes:
+      label: Description
+      description: Describe the issue in detail
+      placeholder: |
+        What happened? What did you expect?
+        If wrong track was downloaded, what track was downloaded instead?
+    validations:
+      required: true
+
+  - type: input
+    id: version
+    attributes:
+      label: App Version
+      description: Which version of SpotiFLAC are you using?
+      placeholder: "e.g., v2.2.0"
+    validations:
+      required: true
+
+  - type: textarea
+    id: screenshots
+    attributes:
+      label: Screenshots / Logs
+      description: |
+        If applicable, add screenshots or logs.
+        
+        **To get logs:**
+        1. Go to Settings > Options > Detailed Logging (turn ON)
+        2. Try downloading the track again
+        3. Go to Settings > Logs
+        4. Tap Share button to export logs
+      placeholder: Drag & drop screenshots or paste logs here...
@@ -0,0 +1,117 @@
+name: Extension API Feature Request
+description: Request new API features or capabilities for extension development
+title: "[Extension API]: "
+labels: ["enhancement", "extension-api"]
+body:
+  - type: markdown
+    attributes:
+      value: |
+        Thanks for helping improve the SpotiFLAC Extension API! 
+        This form is for extension developers who need new features or capabilities that don't exist yet.
+
+  - type: checkboxes
+    id: checklist
+    attributes:
+      label: Checklist
+      description: Please confirm the following before submitting
+      options:
+        - label: I have read the [Extension Development Guide](https://github.com/zarzet/SpotiFLAC-Mobile/blob/main/docs/EXTENSION_DEVELOPMENT.md)
+          required: true
+        - label: I have searched existing issues and this API feature hasn't been requested yet
+          required: true
+
+  - type: textarea
+    id: extension_goal
+    attributes:
+      label: What are you trying to build?
+      description: Describe the extension or feature you're developing
+      placeholder: "I'm building an extension that downloads from [service name] / provides metadata from [source]..."
+    validations:
+      required: true
+
+  - type: textarea
+    id: current_limitation
+    attributes:
+      label: Current API Limitation
+      description: What's missing or limiting in the current extension API?
+      placeholder: |
+        The current API doesn't support:
+        - [missing feature 1]
+        - [missing feature 2]
+        
+        This prevents me from...
+    validations:
+      required: true
+
+  - type: textarea
+    id: proposed_api
+    attributes:
+      label: Proposed API / Feature
+      description: Describe the API or feature you'd like to see added
+      placeholder: |
+        I would like to have:
+        - A new function `api.newFeature()` that does X
+        - A new manifest field `newOption` that enables Y
+        - Access to Z capability...
+    validations:
+      required: true
+
+  - type: textarea
+    id: use_case
+    attributes:
+      label: Use Case Example
+      description: Provide a code example of how you would use this feature
+      placeholder: |
+        ```javascript
+        // Example usage in extension code
+        function download(request, progressCallback) {
+          const result = api.proposedFeature(params);
+          // ...
+        }
+        ```
+    validations:
+      required: false
+
+  - type: dropdown
+    id: api_category
+    attributes:
+      label: API Category
+      description: What category does this feature fall under?
+      options:
+        - HTTP/Network API
+        - File System API
+        - Storage API
+        - FFmpeg/Audio Processing
+        - Manifest Options
+        - Runtime Functions
+        - UI Integration
+        - Authentication
+        - Other
+    validations:
+      required: true
+
+  - type: dropdown
+    id: priority
+    attributes:
+      label: How critical is this for your extension?
+      options:
+        - Blocker - Cannot build my extension without this
+        - High - Major functionality depends on this
+        - Medium - Would significantly improve my extension
+        - Low - Nice to have
+    validations:
+      required: true
+
+  - type: textarea
+    id: workaround
+    attributes:
+      label: Current Workaround
+      description: Are you using any workaround currently? If so, describe it.
+      placeholder: "Currently I'm working around this by..."
+
+  - type: textarea
+    id: additional
+    attributes:
+      label: Additional Context
+      description: Add any other context, links to similar APIs, or examples from other platforms
+      placeholder: "Similar feature in other platforms: ..."
@@ -0,0 +1,66 @@
+name: Feature Request
+description: Suggest a new feature or improvement
+title: "[Feature]: "
+labels: ["enhancement"]
+body:
+  - type: markdown
+    attributes:
+      value: |
+        Thanks for suggesting a feature! Please fill out the form below.
+
+  - type: checkboxes
+    id: checklist
+    attributes:
+      label: Checklist
+      description: Please confirm the following before submitting
+      options:
+        - label: I have searched existing issues and this feature hasn't been requested yet
+          required: true
+
+  - type: textarea
+    id: problem
+    attributes:
+      label: Problem / Motivation
+      description: Is your feature request related to a problem? Please describe.
+      placeholder: "A clear description of what the problem is. Ex: I'm always frustrated when..."
+    validations:
+      required: true
+
+  - type: textarea
+    id: solution
+    attributes:
+      label: Proposed Solution
+      description: Describe the solution you'd like
+      placeholder: A clear description of what you want to happen...
+    validations:
+      required: true
+
+  - type: textarea
+    id: alternatives
+    attributes:
+      label: Alternatives Considered
+      description: Describe any alternative solutions or features you've considered
+      placeholder: Other approaches you've thought about...
+
+  - type: dropdown
+    id: category
+    attributes:
+      label: Category
+      description: What category does this feature fall under?
+      options:
+        - UI/UX Improvement
+        - Download Feature
+        - New Service Integration
+        - Metadata/Tagging
+        - Performance
+        - Settings/Configuration
+        - Other
+    validations:
+      required: true
+
+  - type: textarea
+    id: additional
+    attributes:
+      label: Additional Context
+      description: Add any other context, mockups, or screenshots about the feature request
+      placeholder: Add any other context or screenshots...
@@ -3,13 +3,13 @@ name: Release
 on:
  push:
    tags:
-      - 'v*'
+      - "v*"
  workflow_dispatch:
    inputs:
      version:
-        description: 'Version tag (e.g., v1.0.0)'
+        description: "Version tag (e.g., v1.0.0)"
        required: true
-        default: 'v1.0.0'
+        default: "v1.0.0"

 jobs:
  # Get version first (quick job)
@@ -28,7 +28,7 @@ jobs:
            VERSION="${GITHUB_REF#refs/tags/}"
          fi
          echo "version=$VERSION" >> $GITHUB_OUTPUT
-          
+
          # Check if version contains -preview, -beta, -rc, or -alpha (NOT -hotfix)
          VERSION_LOWER=$(echo "$VERSION" | tr '[:upper:]' '[:lower:]')
          if [[ "$VERSION_LOWER" == *"-preview"* ]] || [[ "$VERSION_LOWER" == *"-beta"* ]] || [[ "$VERSION_LOWER" == *"-rc"* ]] || [[ "$VERSION_LOWER" == *"-alpha"* ]]; then
@@ -43,7 +43,7 @@ jobs:
  build-android:
    runs-on: ubuntu-latest
    needs: get-version
-    
+
    steps:
      - name: Free disk space
        run: |
@@ -65,13 +65,13 @@ jobs:
      - name: Setup Java
        uses: actions/setup-java@v4
        with:
-          distribution: 'temurin'
-          java-version: '17'
+          distribution: "temurin"
+          java-version: "17"

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

      # Cache Gradle for faster builds
@@ -85,7 +85,20 @@ jobs:
          restore-keys: gradle-${{ runner.os }}-

      - name: Install Android SDK & NDK
-        uses: android-actions/setup-android@v3
+        run: |
+          # Use pre-installed Android SDK on GitHub runners
+          echo "ANDROID_HOME=$ANDROID_HOME"
+          echo "ANDROID_SDK_ROOT=$ANDROID_SDK_ROOT"
+
+          # Accept licenses
+          yes | $ANDROID_HOME/cmdline-tools/latest/bin/sdkmanager --licenses || true
+
+          # 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;27.3.13750724" "platforms;android-36" "build-tools;36.0.0"
+
+          # Set NDK path
+          echo "ANDROID_NDK_HOME=$ANDROID_HOME/ndk/27.3.13750724" >> $GITHUB_ENV

      - name: Install gomobile
        run: |
@@ -103,7 +116,7 @@ jobs:
      - name: Setup Flutter
        uses: subosito/flutter-action@v2
        with:
-          channel: 'stable'
+          channel: "stable"
          cache: true

      - name: Get Flutter dependencies
@@ -113,7 +126,14 @@ jobs:
        run: dart run flutter_launcher_icons

      - name: Build APK (Release - unsigned)
-        run: flutter build apk --release --split-per-abi
+        run: |
+          flutter build apk --release --split-per-abi || true
+          # Verify APKs were created
+          ls -la build/app/outputs/flutter-apk/
+          if [ ! -f "build/app/outputs/flutter-apk/app-arm64-v8a-release.apk" ]; then
+            echo "ERROR: APK not found!"
+            exit 1
+          fi

      - name: Sign APKs
        uses: r0adkll/sign-android-release@v1
@@ -125,7 +145,7 @@ jobs:
          keyStorePassword: ${{ secrets.KEYSTORE_PASSWORD }}
          keyPassword: ${{ secrets.KEY_PASSWORD }}
        env:
-          BUILD_TOOLS_VERSION: "34.0.0"
+          BUILD_TOOLS_VERSION: "36.0.0"

      - name: Rename APKs
        run: |
@@ -145,8 +165,8 @@ jobs:

  build-ios:
    runs-on: macos-latest
-    needs: get-version  # Only depends on version, NOT android build!
-    
+    needs: get-version # Only depends on version, NOT android build!
+
    steps:
      - name: Checkout repository
        uses: actions/checkout@v4
@@ -154,7 +174,7 @@ jobs:
      - name: Setup Go
        uses: actions/setup-go@v5
        with:
-          go-version: '1.21'
+          go-version: "1.21"
          cache-dependency-path: go_backend/go.sum

      # Cache CocoaPods
@@ -182,51 +202,51 @@ jobs:
        run: |
          ls -la ios/Frameworks/
          ls -la ios/Frameworks/Gobackend.xcframework/ || (echo "ERROR: XCFramework not found!" && exit 1)
-          
+
      - name: Add XCFramework to Xcode project
        run: |
          # Install xcodeproj gem for modifying Xcode project
          sudo gem install xcodeproj
-          
+
          # Create Ruby script to add framework
          cat > add_framework.rb << 'EOF'
          require 'xcodeproj'
-          
+
          project_path = 'ios/Runner.xcodeproj'
          project = Xcodeproj::Project.open(project_path)
-          
+
          # Get the main target
          target = project.targets.find { |t| t.name == 'Runner' }
-          
+
          # Get or create Frameworks group
          frameworks_group = project.main_group.find_subpath('Frameworks', true)
          frameworks_group ||= project.main_group.new_group('Frameworks')
-          
+
          # Add XCFramework reference
          framework_path = 'Frameworks/Gobackend.xcframework'
          framework_ref = frameworks_group.new_file(framework_path, :project)
-          
+
          # Add to frameworks build phase
          frameworks_build_phase = target.frameworks_build_phase
          frameworks_build_phase.add_file_reference(framework_ref)
-          
+
          # Add to embed frameworks build phase
          embed_phase = target.build_phases.find { |p| p.is_a?(Xcodeproj::Project::Object::PBXCopyFilesBuildPhase) && p.name == 'Embed Frameworks' }
          if embed_phase
            build_file = embed_phase.add_file_reference(framework_ref)
            build_file.settings = { 'ATTRIBUTES' => ['CodeSignOnCopy', 'RemoveHeadersOnCopy'] }
          end
-          
+
          project.save
          puts "Successfully added Gobackend.xcframework to Xcode project"
          EOF
-          
+
          ruby add_framework.rb

      - name: Setup Flutter
        uses: subosito/flutter-action@v2
        with:
-          channel: 'stable'
+          channel: "stable"
          cache: true

      # Swap pubspec for iOS build (includes ffmpeg_kit_flutter)
@@ -253,18 +273,44 @@ jobs:
        run: dart run flutter_launcher_icons

      - name: Build iOS (unsigned)
-        run: flutter build ios --release --no-codesign
+        run: |
+          # Build Flutter iOS without codesigning
+          flutter build ios --release --no-codesign --config-only
+
+          # Use xcodebuild with code signing disabled
+          cd ios
+          xcodebuild -workspace Runner.xcworkspace \
+            -scheme Runner \
+            -configuration Release \
+            -sdk iphoneos \
+            -destination 'generic/platform=iOS' \
+            -archivePath build/Runner.xcarchive \
+            archive \
+            CODE_SIGNING_ALLOWED=NO \
+            CODE_SIGNING_REQUIRED=NO \
+            CODE_SIGN_IDENTITY="" \
+            DEVELOPMENT_TEAM=""

      - name: Create IPA
        run: |
          VERSION=${{ needs.get-version.outputs.version }}
          mkdir -p build/ios/ipa
-          cd build/ios/iphoneos
+          cd ios/build/Runner.xcarchive/Products/Applications
          mkdir Payload
          cp -r Runner.app Payload/
-          zip -r ../ipa/SpotiFLAC-${VERSION}-ios-unsigned.ipa Payload
+          # Use absolute path to avoid relative path issues
+          zip -r $GITHUB_WORKSPACE/build/ios/ipa/SpotiFLAC-${VERSION}-ios-unsigned.ipa Payload
          rm -rf Payload

+      - name: Verify IPA created
+        run: |
+          ls -la build/ios/ipa/
+          VERSION=${{ needs.get-version.outputs.version }}
+          if [ ! -f "build/ios/ipa/SpotiFLAC-${VERSION}-ios-unsigned.ipa" ]; then
+            echo "ERROR: IPA not created!"
+            exit 1
+          fi
+
      - name: Upload IPA artifact
        uses: actions/upload-artifact@v4
        with:
@@ -276,7 +322,7 @@ jobs:
    needs: [get-version, build-android, build-ios]
    permissions:
      contents: write
-    
+
    steps:
      - name: Checkout repository
        uses: actions/checkout@v4
@@ -286,13 +332,13 @@ jobs:
        run: |
          VERSION=${{ needs.get-version.outputs.version }}
          VERSION_NUM=${VERSION#v}  # Remove 'v' prefix
-          
+
          echo "Looking for version: $VERSION_NUM"
-          
+
          # Extract changelog section for this version using sed
          # Find the line with version, then print until next version header or end
          CHANGELOG=$(sed -n "/^## \[$VERSION_NUM\]/,/^## \[/{ /^## \[$VERSION_NUM\]/d; /^## \[/d; p; }" CHANGELOG.md)
-          
+
          # If no changelog found, use default message
          if [ -z "$CHANGELOG" ]; then
            echo "No changelog found for version $VERSION_NUM"
@@ -300,7 +346,7 @@ jobs:
          else
            echo "Found changelog content"
          fi
-          
+
          # Save to file for multiline support
          echo "$CHANGELOG" > /tmp/changelog.txt
          echo "Extracted changelog:"
@@ -322,32 +368,34 @@ jobs:
        run: |
          VERSION=${{ needs.get-version.outputs.version }}
          cat > /tmp/release_body.txt << 'HEADER'
-          ## SpotiFLAC $VERSION
-          
-          Download Spotify tracks in FLAC quality from Tidal, Qobuz & Amazon Music.
-          
          ### What's New
          HEADER
-          
-          # Replace $VERSION in header
-          sed -i "s/\$VERSION/$VERSION/g" /tmp/release_body.txt
-          
+
          cat /tmp/changelog.txt >> /tmp/release_body.txt
+
+          REPO_OWNER="${{ github.repository_owner }}"
+          REPO_NAME="${{ github.event.repository.name }}"
          
          cat >> /tmp/release_body.txt << FOOTER
-          
+
          ---
-          
+
          ### Downloads
-          - **Android (arm64)**: \`SpotiFLAC-${VERSION}-arm64.apk\` (recommended)
-          - **Android (arm32)**: \`SpotiFLAC-${VERSION}-arm32.apk\` (older devices)
+
+          #### Android
+          - **arm64**: \`SpotiFLAC-${VERSION}-arm64.apk\` (recommended for modern devices)
+          - **arm32**: \`SpotiFLAC-${VERSION}-arm32.apk\` (older devices)
+
+          #### iOS
          - **iOS**: \`SpotiFLAC-${VERSION}-ios-unsigned.ipa\` (sideload required)
-          
+
          ### Installation
          **Android**: Enable "Install from unknown sources" and install the APK
          **iOS**: Use AltStore, Sideloadly, or similar tools to sideload the IPA
+
+          ![arm64](https://img.shields.io/github/downloads/${REPO_OWNER}/${REPO_NAME}/${VERSION}/SpotiFLAC-${VERSION}-arm64.apk?style=flat-square&logo=android&label=arm64&color=3DDC84) ![arm32](https://img.shields.io/github/downloads/${REPO_OWNER}/${REPO_NAME}/${VERSION}/SpotiFLAC-${VERSION}-arm32.apk?style=flat-square&logo=android&label=arm32&color=3DDC84) ![iOS](https://img.shields.io/github/downloads/${REPO_OWNER}/${REPO_NAME}/${VERSION}/SpotiFLAC-${VERSION}-ios-unsigned.ipa?style=flat-square&logo=apple&label=iOS&color=0078D6)
          FOOTER
-          
+
          echo "Release body:"
          cat /tmp/release_body.txt

@@ -13,6 +13,9 @@ Thumbs.db
 # Reference folder (development only)
 referensi/

+# Documentation (development only, published separately)
+docs/
+
 # Old spotiflac_android folder (moved to root)
 spotiflac_android/

@@ -1,8 +1,531 @@
 # Changelog

-## [2.1.0] - 2026-01-06
+## [3.0.0-alpha.2] - 2026-01-12

 ### Added
+
+- **Full HTTP Method Support**: New shortcut methods for all common HTTP verbs
+  - `http.put(url, body, headers)` - PUT requests
+  - `http.delete(url, headers)` - DELETE requests  
+  - `http.patch(url, body, headers)` - PATCH requests
+  - `http.clearCookies()` - Clear all cookies for the extension
+- **Persistent Cookie Jar**: Each extension now has its own cookie jar
+  - Cookies automatically stored from `Set-Cookie` headers
+  - Cookies automatically sent with subsequent requests to same domain
+  - Useful for APIs requiring session cookies (YouTube, etc.)
+- **Multi-Value Header Support**: Response headers now return arrays for multi-value headers
+  - `Set-Cookie` and other headers with multiple values returned as arrays
+  - Single-value headers still returned as strings for convenience
+- **Generic HTTP Request Method**: New `http.request()` for full HTTP control
+  - Supports all HTTP methods (GET, POST, PUT, DELETE, PATCH, etc.)
+  - Single options object for cleaner API: `http.request(url, { method, body, headers })`
+- **Response Helper Properties**: HTTP responses now include convenience properties
+  - `response.ok` - true if status code is 2xx
+  - `response.status` - alias for `statusCode`
+
+### Fixed
+
+- **User-Agent Header Respect**: Custom `User-Agent` headers are now respected
+  - Previously, extension-provided User-Agent was overwritten
+  - Now only sets default User-Agent if extension doesn't provide one
+- **HTTP POST Body Auto-Stringify**: `http.post()` now automatically stringifies objects to JSON
+  - Previously, passing an object as body resulted in `[object Object]`
+  - Now objects and arrays are automatically JSON.stringify'd
+  - String bodies still work as before (no double-encoding)
+
+### Documentation
+
+- Updated `docs/EXTENSION_DEVELOPMENT.md`:
+  - Added complete HTTP API documentation with all methods
+  - Added Cookie Jar documentation
+  - Added `http.put()`, `http.delete()`, `http.patch()`, `http.clearCookies()` docs
+  - Added YouTube Music / Innertube API example with custom User-Agent
+  - Added common domain lists for YouTube, SoundCloud, Bandcamp
+  - Improved HTTP API documentation with response properties
+
+---
+
+## [3.0.0-alpha.1] - 2026-01-11
+
+#### Extension System
+- **Custom Search Providers**: Extensions can now provide custom search functionality
+  - YouTube, SoundCloud, and other platforms via extensions
+  - Custom search placeholder text per extension
+  - Configurable thumbnail aspect ratios (square, wide, portrait)
+- **Extension Upgrade System**: Upgrade extensions without losing data
+  - Preserves extension settings and cached data during upgrades
+  - Version comparison prevents downgrades
+  - Auto-detects upgrades when installing same extension
+- **Custom Thumbnail Ratios**: Extensions can specify thumbnail display format
+  - `"square"` (1:1) - Album art style (default)
+  - `"wide"` (16:9) - YouTube/video style
+  - `"portrait"` (2:3) - Poster style
+  - Custom width/height override available
+
+### Added
+
+- **Track Source Tracking**: Tracks now remember which extension provided them
+  - `Track.source` field stores extension ID
+  - `TrackState.searchExtensionId` for current search context
+  - Enables extension-specific UI customization
+- **Extension Upgrade API**: New methods for extension management
+  - `upgradeExtension(filePath)` - Upgrade existing extension
+  - `checkExtensionUpgrade(filePath)` - Check if file is an upgrade
+  - `RemoveExtensionByID` - Remove extension by ID
+- **iOS Extension Support**: Added missing iOS method handlers
+  - `upgradeExtension` - Upgrade extension from file
+  - `checkExtensionUpgrade` - Check upgrade compatibility
+- **Extension Documentation**: Comprehensive extension development guide
+  - Thumbnail ratio customization documentation
+  - Extension upgrade workflow documentation
+  - New troubleshooting entries for common issues
+
+### Changed
+
+- **Version Bump**: 2.2.7 → 3.0.0-alpha.1 (major version for extension system)
+- **Build Number**: 49 → 50
+- **Extension Manager**: Improved upgrade detection in `LoadExtensionFromFile`
+  - Auto-detects if installing same extension with higher version
+  - Calls `UpgradeExtension` automatically for seamless upgrades
+
+### Fixed
+
+- **Extension `registerExtension`**: Fixed global `extension` variable not being set
+  - Extensions can now access their own functions via `extension.functionName()`
+  - Required for `customSearch` and other provider functions
+- **Custom Search Empty Results**: Fixed error when extension returns null
+  - Now returns empty array instead of error
+  - Prevents crash when no results found
+- **Mutex Crash on Upgrade**: Fixed "Unlock of unlocked RWMutex" crash
+  - Removed `defer m.mu.Unlock()` when manual unlock is used
+  - Proper lock handling in upgrade flow
+- **Duplicate Error Messages**: Fixed extension install errors showing twice
+  - Added `clearError()` method to extension provider
+  - Improved PlatformException parsing to remove "null, null" artifacts
+- **Extension Images Field**: Fixed thumbnails not showing in search results
+  - Added `Images` field to `ExtTrackMetadata` struct
+  - Renamed `GetCoverURL` to `ResolvedCoverURL` (gomobile conflict)
+
+### Technical
+
+- **Go Backend Changes**:
+  - `go_backend/extension_manager.go`: Added `compareVersions()`, `UpgradeExtension()`, `CheckExtensionUpgradeJSON()`
+  - `go_backend/extension_providers.go`: Added `Images` field, `ResolvedCoverURL()` method
+  - `go_backend/extension_manifest.go`: Added `ThumbnailRatio`, `ThumbnailWidth`, `ThumbnailHeight` to `SearchBehaviorConfig`
+  - `go_backend/exports.go`: Added `RemoveExtensionByID`, `UpgradeExtensionFromPath`, `CheckExtensionUpgradeFromPath`
+- **Flutter Changes**:
+  - `lib/models/track.dart`: Added `source` field
+  - `lib/models/track.g.dart`: Updated for `source` field
+  - `lib/providers/track_provider.dart`: Added `searchExtensionId`, updated `_parseSearchTrack` with source parameter
+  - `lib/providers/extension_provider.dart`: Added `SearchBehavior.getThumbnailSize()`, `clearError()`
+  - `lib/screens/home_tab.dart`: Dynamic thumbnail size based on extension config
+  - `lib/screens/settings/extensions_page.dart`: Improved error handling
+  - `lib/services/platform_bridge.dart`: Added `upgradeExtension()`, `checkExtensionUpgrade()`, `removeExtension()`
+- **iOS Changes**:
+  - `ios/Runner/AppDelegate.swift`: Added `upgradeExtension`, `checkExtensionUpgrade` handlers
+- **Android Changes**:
+  - `android/app/src/main/kotlin/com/zarz/spotiflac/MainActivity.kt`: Already had upgrade methods
+
+### Documentation
+
+- Updated `docs/EXTENSION_DEVELOPMENT.md`:
+  - Added thumbnail ratio customization section
+  - Added extension upgrade documentation
+  - Added settings fields table with `secret` field
+  - Added new troubleshooting entries
+  - Updated table of contents
+  - Updated changelog
+
+---
+
+## [2.2.8] - 2026-01-12
+
+### Added
+
+- **Multi-Select Batch Delete**: Long-press tracks in History to enter selection mode
+  - Select multiple tracks at once
+  - "Select All" and "Delete Selected" actions
+  - Modern Material 3 bottom action bar (slides up from bottom)
+  - Works in both grid and list view modes
+- **History Filter Tabs**: Filter history by All/Albums/Singles
+  - Album = tracks where album has >1 track in history
+  - Single = tracks where album has only 1 track in history
+  - Filter chips show counts for each category
+- **Album Grouping View**: When "Albums" filter is selected, tracks are grouped by album
+  - Album cards displayed in 2-column grid with cover art and track count badge
+  - Tap album to open dedicated album detail screen
+  - Album detail shows all downloaded tracks from that album
+  - Multi-select delete support within album view
+  - Auto-navigates back when album has <2 tracks remaining
+
+### Changed
+
+- **Issue Templates**: Updated version confirmation checkbox to specify "(Stable Version)"
+
+---
+
+## [2.2.7] - 2026-01-11
+
+### Added
+
+- **CSV Import Metadata Enrichment**: Tracks imported from CSV now automatically fetch metadata from Deezer
+  - Cover art, duration, track/disc number fetched via ISRC lookup
+  - Fallback to text search (artist + track name) when ISRC not found in Deezer
+  - Progress dialog shows enrichment status during import
+  - Ensures downloaded files have proper cover art and metadata
+- **Deezer Metadata Support**: Enhanced metadata viewer for Deezer tracks
+  - "Open in Deezer" button for Deezer-sourced tracks (opens app or web)
+  - Displays "Deezer ID" instead of "Spotify ID" when applicable
+- **Smart Tag Injection**: Filename format editor intelligently handles separators
+  - Auto-detects if " - " is needed between tags
+  - Prevents double separators or missing spaces
+- **Dynamic Source Info**: Search source selector now shows helpful context
+  - "No login required" for Deezer
+  - "Requires credentials" for Spotify
+
+### Changed
+
+- **UI Modernization**: Major UI consistency updates across the app
+  - **Unified App Bars**: Home, History, and Settings now share identical behavior
+    - Lowered expanded header for easier one-handed reachability
+    - Dynamic title text scaling (20px to 34px)
+  - **Appearance Settings**: Completely redesigned appearance page
+    - New "Theme Preview" card showing visualizing current theme
+    - Modern color palette picker replacing old color dots
+    - Clean, grouped layout
+    - "AMOLED Dark" switch is now hidden when using Light Mode
+  - **App Logo**: Refined logo style on Home and About screens
+    - Inverted colors: Filled primary color circle with on-color icon
+    - Removed padding for a cleaner, bolder look
+  - **Material 3 Switches**: Added checkmark icon to active switches
+- **UI Modernization (Global)**: Complete design refresh for a cleaner, modern look
+  - **Rounded Corners**: Standardized 16px radius for all cards, buttons, and input fields
+  - **Transparent Elements**: Applied subtle transparency to input fields and containers using `surfaceContainerHighest`
+  - **Consistent Buttons**: Unified button styling across the app (pill shape, 16px radius)
+- **Options Settings Redesign**: improved layout and usability
+  - **Search Source Priority**: Moved "Search Source" section to the very top for quick access
+  - **Compact Source Selector**: Redesigned provider toggle (Deezer/Spotify) to be compact and consistent
+  - **Credentials Workflow**: Reorganized Custom Credentials settings; toggle now auto-prompts if credentials missing
+  - **Modern Credentials Dialog**: Totally redesigned input dialog for Spotify Client ID/Secret
+- **Filename Format Editor 2.0**:
+  - **Modern Sheet UI**: Replaced legacy dialog with a clean, full-width bottom sheet
+  - **Tag Chips**: Added clickable chips ({artist}, {title}) for one-tap insertion
+  - **Smart Formatting**: Automatically injects separators (" - ") when adding tags for faster editing
+
+### Fixed
+
+- **CSV Import Missing Cover Art**: Fixed tracks from CSV having no cover art in download history
+  - Cover URL now properly fetched from Deezer during enrichment
+  - Falls back to text search when ISRC lookup fails
+- **CSV Import Missing Duration**: Fixed duration showing 0:00 for CSV-imported tracks
+  - Duration now fetched from Deezer metadata during enrichment
+- **Disc Number Not Displayed**: Fixed disc number not showing in track metadata screen
+  - Changed condition from `discNumber > 0` to `discNumber > 0`
+  - Now displays disc 1 instead of hiding it
+- **Download History Using Wrong Track Data**: Fixed history using original CSV data instead of enriched data
+  - Now uses `trackToDownload` (enriched) instead of `item.track` (original)
+
+### Technical
+
+- Updated `lib/services/csv_import_service.dart`:
+  - Added `_enrichTracksMetadata()` with ISRC lookup + text search fallback
+  - Added progress callback for UI feedback
+- Updated `lib/screens/home_tab.dart`:
+  - Added progress dialog during CSV enrichment
+- Updated `lib/providers/download_queue_provider.dart`:
+  - Uses enriched track data for download history
+- Updated `lib/screens/track_metadata_screen.dart`:
+  - Show disc number when > 0 (was > 1)
+- Updated `go_backend/metadata.go`:
+  - Added `TotalSamples` to `AudioQuality` struct for duration calculation
+- Updated `go_backend/exports.go`:
+  - `ReadFileMetadata` now returns duration calculated from FLAC stream info
+- Updated `AppTheme` with new `InputDecorationTheme` and `ButtonTheme` definitions
+- Refactored `DownloadSettingsPage` to use new `_showFormatEditor` with cursor-aware capabilities
+- Optimized various dialogs to use `showModalBottomSheet` with `isScrollControlled` for better keyboard handling
+
+---
+
+## [2.2.6] - 2026-01-11
+
+### Fixed
+
+- **Release Mode Logging**: Flutter app logs now properly captured in release builds
+  - Previously only Go backend logs appeared when "Detailed Logging" was enabled
+  - Now both Flutter and Go logs are captured in release mode
+  - Bypasses Logger package which filters logs in release mode
+
+### Added
+
+- **Detailed Deezer Search Logging**: Better debugging for search issues
+  - Logs API URLs, response counts, and errors
+  - Helps diagnose geo-restriction and API issues
+  - Detects Deezer API error responses
+
+### Changed
+
+- **Home Screen Logo**: Replaced music note icon with app logo
+  - Uses `assets/images/logo.png`
+  - Rounded corners (24px radius)
+  - Fallback to music note icon if logo fails to load
+- **About Page Logo**: Removed shadow/border from logo
+  - Cleaner appearance without background container
+- **About Page Icon Alignment**: Icons now aligned with contributor avatars
+  - DoubleDouble and DAB Music icons use 40x40 area
+  - Text now properly aligned with contributor items
+
+## [2.2.5] - 2026-01-10
+
+### Added
+
+- **In-App Log Viewer with Go Backend Logs**: Complete logging system for debugging
+  - Go backend logs now captured and displayed in app
+  - Circular buffer stores up to 500 log entries
+  - Real-time polling (500ms) for Go backend logs
+  - Logs include timestamp, level, tag, and message
+  - "Go" badge indicates logs from backend
+- **Detailed Logging Toggle**: Control logging in Settings > Options > Debug
+  - Disabled by default for performance
+  - Errors are always logged regardless of setting
+  - Enable before reproducing bugs for detailed logs
+- **Log Issue Summary**: Automatic detection of common issues in logs
+  - ISP Blocking detection with affected domains
+  - Rate limiting detection
+  - Network error detection
+  - Track not found detection
+  - Shows suggestions for each issue type
+- **ISP Blocking Detection**: Detects when ISP blocks download services
+  - DNS resolution failure detection
+  - Connection reset/refused detection
+  - TLS handshake failure detection
+  - HTTP 403/451 blocking page detection
+  - Suggests VPN or DNS change (1.1.1.1 / 8.8.8.8)
+
+### Fixed
+
+- **Artist Profile Placeholder**: Shows person icon when artist has no profile image
+  - Validates image URL before loading
+  - Fallback icon on load error
+- **Latin Extended Character Detection**: Fixed wrong track downloads for Polish, Czech, French, Spanish songs
+  - Characters like Ł, ę, ć, ñ, é now correctly treated as Latin script
+  - Previously treated as "different script" causing false matches
+  - Affects both Tidal and Qobuz search
+
+### Changed
+
+- **Log Screen UI Improvements**:
+  - Copy button moved to app bar (left of menu)
+  - Removed redundant info card
+  - Cleaner interface
+- **Issue Templates Updated**: Instructions for enabling detailed logging before submitting bug reports
+
+### Technical
+
+- New file: `go_backend/logbuffer.go` with circular buffer and GoLog function
+- Updated `go_backend/httputil.go` with ISP blocking detection
+- Updated `go_backend/tidal.go` and `go_backend/qobuz.go` with `isLatinScript()` function
+- Updated `lib/utils/logger.dart` with Go log polling
+- Updated `lib/screens/settings/log_screen.dart` with issue summary
+- Added method channel handlers for logging in Android and iOS
+- New error type: `isp_blocked` for ISP blocking errors
+
+---
+
+## [2.2.0] - 2026-01-10
+
+### Fixed
+
+- **ISRC Metadata Missing:** Fixed an issue where ISRC codes were not being saved to the download history or embedded in file metadata for certain downloads. The backend now correctly propagates the ISRC found from streaming services (Tidal, Qobuz, Amazon) back to the application.
+- **Tidal Track/Disc Numbers:** Fixed missing Track Number and Disc Number in Tidal downloads. The downloader now prioritizes the actual metadata returned by Tidal over the potentially incomplete metadata from the initial search request.
+- **Concurrent Download Race Condition:** Fixed a potential race condition where temporary cover art files could overwrite each other during rapid concurrent downloads by adding randomization to temporary filenames.
+- **Qobuz Search Accuracy:** Reduced the duration tolerance for Qobuz search matches from 30s to 10s to prevent matching with incorrect versions/remixes.
+- **Metadata Enrichment Null Safety**: Fixed `type 'Null' is not a subtype of type 'String'` error
+  - Added proper null checks when parsing Go backend response
+  - Added type checking for track data before parsing
+- **Duration Calculation in Enrichment**: Fixed duration conversion bug
+  - Go backend returns `duration_ms` (milliseconds)
+  - Now properly converts to seconds for Track model
+
+### Changed
+
+- **Default Service Priority:** Updated the default download fallback order to **Tidal → Qobuz → Amazon**.
+  - Tidal is now the default download service (was Qobuz)
+  - Tidal has faster and more reliable ISRC matching
+  - Existing users need to change setting manually or clear app data
+- **Metadata Enrichment:** Improved metadata handling for Deezer tracks. If critical metadata (ISRC, Track Number) is missing from the initial search, the app now automatically fetches full details from the Deezer API before finding a source.
+
+### Added
+
+- **ISRC in History:** The Download History now reliably displays the ISRC code for downloaded tracks.
+- **Tidal Search Optimization:** Optimized Tidal search logic to immediately check for ISRC matches within search results, improving match speed and accuracy.
+  - Returns as soon as ISRC match is found in first query results
+  - Significantly faster for tracks with valid ISRC
+- **ISRC Enrichment for Search Results**: Tracks from Home search now fetch ISRC before download
+  - Search results don't include ISRC (for performance)
+  - ISRC is now fetched via metadata enrichment when download starts
+  - Ensures accurate track matching on all streaming services
+- **Deezer-to-Tidal Fallback:** Added native support for converting Deezer IDs to Tidal links via SongLink when using the fallback mechanism.
+- **Better Logging for Qobuz ISRC Search**: Added detailed logs for debugging
+  - Shows when ISRC search is attempted
+  - Shows number of results and exact ISRC matches found
+
+### Technical
+
+- Updated `go_backend/tidal.go`:
+  - Early exit optimization in `SearchTrackByMetadataWithISRC()`
+  - Deezer ID support in SongLink lookup
+- Updated `go_backend/qobuz.go`:
+  - Added logging for ISRC search flow
+  - Duration tolerance reduced from 30s to 10s
+- Updated `go_backend/exports.go`:
+  - Default service order changed to `[tidal, qobuz, amazon]`
+- Updated `lib/providers/download_queue_provider.dart`:
+  - ISRC-based enrichment condition
+  - Null-safe parsing of Go backend response
+- Updated `lib/services/platform_bridge.dart`:
+  - Null check for `getDeezerMetadata` result
+- Updated `lib/models/settings.dart`:
+  - Default service changed to `tidal`
+
+---
+
+## [2.1.7] - 2026-01-09
+
+### Added
+
+- **Special Thanks Section**: Added new "Special Thanks" section in About page to credit API creators
+  - **uimaxbai** - Creator of QQDL & HiFi API for Tidal downloads
+  - **sachinsenal0x64** - Original HiFi project creator, foundation of Tidal integration
+  - **DoubleDouble** - Amazing API for Amazon Music downloads
+  - **DAB Music** - The best Qobuz streaming API for Hi-Res downloads
+- **New Contributor**: Added Amonoman to Contributors section as the app logo creator
+
+### Fixed
+
+- **Missing PlatformBridge Import**: Fixed build errors in `home_tab.dart` and `playlist_screen.dart`
+  - Added missing `import 'package:spotiflac_android/services/platform_bridge.dart'`
+- **iOS Method Channel Crash**: Fixed "Method not implemented" crash when searching Deezer from iOS
+  - Implemented missing `searchDeezerAll` handler in `AppDelegate.swift`
+  - Ensures full compatibility with new Deezer integration features on iOS
+
+---
+
+## [2.1.6] - 2026-01-08
+
+### Added
+
+- **Metadata Enrichment**: Automatically fetches full track details if metadata is incomplete (e.g., Track Number 0)
+  - Fixes missing Track Number, Disc Number, and Year for tracks added from Search results
+  - Ensures accurate tagging for Deezer/Tidal downloads
+- **ISRC Index Building**: Fast duplicate checking with cached ISRC index
+
+  - Scans download folder once and builds index of all ISRCs
+  - 5 minute cache TTL for optimal performance
+  - Parallel duplicate checking for album/playlist tracks
+  - Auto-adds new downloads to index (no rebuild needed)
+
+- **Japanese to Romaji Search**: Better search results for Japanese tracks
+
+  - Converts Hiragana/Katakana to Romaji for Tidal/Qobuz search
+  - 4 fallback search strategies (like PC version):
+    1. Original text (artist + track)
+    2. Romaji converted (artist + track)
+    3. ASCII-only cleaned version
+    4. Artist name only as last resort
+  - Handles combination characters (きゃ →kya, シャ →sha, etc.)
+
+- **SongLink Deezer Support**: Query SongLink using Deezer ID as source
+
+  - `CheckAvailabilityFromDeezer()` - find track on other platforms using Deezer ID
+  - `CheckAvailabilityByPlatform()` - generic function for any platform
+  - `GetSpotifyIDFromDeezer()`, `GetTidalURLFromDeezer()`, `GetAmazonURLFromDeezer()`
+  - Useful when starting from Deezer metadata
+
+- **LRC Metadata Headers**: Lyrics now include metadata headers
+
+  - `[ti:Track Name]` - track title
+  - `[ar:Artist Name]` - artist name
+  - `[by:SpotiFLAC-Mobile]` - generator tag
+
+- **Download Error Types**: Better error categorization for UI
+
+  - `not_found` - track not available on any service
+  - `rate_limit` - API rate limit exceeded
+  - `network` - connection/timeout errors
+  - `unknown` - other errors
+
+- **Amazon Rate Limiting**: Proper rate limiting for Amazon via SongLink
+  - 7 second minimum delay between requests
+  - Max 9 requests per minute
+  - 3x retry with 15s wait on 429 rate limit
+
+### Fixed
+
+- **SongLink 400 Error**: Added validation for empty Spotify ID
+
+  - Specific error messages for 400, 404, 429 status codes
+  - Better error handling for invalid track IDs
+
+- **gomobile Compatibility**: Fixed `ISRCIndex.Lookup()` signature
+  - Changed from `(string, bool)` to `(string, error)` for gomobile binding
+
+### Technical
+
+- New file: `go_backend/romaji.go` with Japanese to Romaji conversion
+- New file: `go_backend/duplicate.go` with ISRC index building
+- Updated `go_backend/tidal.go` and `go_backend/qobuz.go` with romaji search strategies
+- Updated `go_backend/songlink.go` with Deezer support functions
+- Updated `go_backend/exports.go` with new export functions for Flutter
+- Updated `go_backend/lyrics.go` with `convertToLRCWithMetadata()`
+- Updated `go_backend/progress.go` with `SpeedMBps` field
+- Updated `lib/models/download_item.dart` with `DownloadErrorType` enum
+- Updated `lib/screens/queue_tab.dart` with speed display and error messages
+
+---
+
+## [2.1.6-preview] - 2026-01-08
+
+### Added
+
+- **Deezer as Alternative Metadata Source**: Choose between Deezer or Spotify for search
+
+  - Configure in Settings > Options > Spotify API > Search Source
+  - Default is Deezer for better reliability
+  - Spotify URLs are always supported regardless of this setting
+
+- **Automatic Deezer Fallback for Spotify URLs**: When Spotify API is rate limited (429), automatically falls back to Deezer
+  - Uses SongLink/Odesli API to convert Spotify track/album ID to Deezer ID
+  - Fetches metadata from Deezer instead
+
+### Changed
+
+- **Default Download Service**: Changed from Tidal to Qobuz
+  - Fallback order is now: Qobuz → Tidal → Amazon
+- **Deezer API Updated to v2.0**: More reliable and complete metadata
+  - Direct ISRC lookup via `/track/isrc:{ISRC}` endpoint
+  - Search results now fetch full track info to include ISRC
+
+### Fixed
+
+- **Progress Bar Not Updating**: Fixed bug where download progress jumped from 1% directly to 100%
+  - Progress now updates smoothly every 64KB of data received
+  - First progress update happens immediately when download starts
+- **Incomplete Downloads**: Fixed bug where interrupted downloads could result in corrupted/incomplete files
+  - File size is validated against server's Content-Length header
+  - Incomplete files are automatically deleted and error is reported
+  - Applies to all services: Tidal, Qobuz, and Amazon
+- **ISRC Not Available from Deezer Search**: Search results now fetch full track details to get ISRC
+
+### Technical
+
+- Settings migration for existing users to set Deezer as default metadata source
+
+---
+
+## [2.1.5] - 2026-01-08
+
+### Added
+
 - **Service Switcher in Quality Picker**: Choose download service (Tidal/Qobuz/Amazon) directly when selecting quality
  - Service selector chips appear above quality options
  - Defaults to your preferred service from settings
@@ -18,6 +541,7 @@
  - Configure in Settings > Options > App

 ### Changed
+
 - **Reduced APK Size**: Replaced FFmpeg plugin with custom AAR containing only required codecs
  - arm64 APK: 46.6 MB (previously 51 MB)
  - arm32 APK: 59 MB (previously 64 MB)
@@ -27,6 +551,7 @@
  - Separate iOS build configuration with ffmpeg_kit_flutter plugin

 ### Fixed
+
 - **Retry Failed Downloads**: Fixed issue where retrying failed downloads sometimes did nothing
  - Now properly handles retry when queue processing has finished
  - Also allows retrying skipped (cancelled) downloads
@@ -38,6 +563,7 @@
  - Files saved to app Documents folder are accessible via iOS Files app

 ### Performance
+
 - **Download Speed Optimizations**: Significant improvements to download initialization and throughput
  - Token caching for Tidal (eliminates redundant auth requests)
  - Singleton pattern for all downloaders (HTTP connection reuse)
@@ -53,6 +579,7 @@
 ## [2.1.0-preview2] - 2026-01-06

 ### Added
+
 - **Service Switcher in Quality Picker**: Choose download service (Tidal/Qobuz/Amazon) directly when selecting quality
  - Service selector chips appear above quality options
  - Defaults to your preferred service from settings
@@ -68,6 +595,7 @@
  - Configure in Settings > Options > App

 ### Fixed
+
 - **Retry Failed Downloads**: Fixed issue where retrying failed downloads sometimes did nothing
  - Now properly handles retry when queue processing has finished
  - Also allows retrying skipped (cancelled) downloads
@@ -79,6 +607,7 @@
 ## [2.1.0-preview] - 2026-01-06

 ### Performance
+
 - **Download Speed Optimizations**: Significant improvements to download initialization and throughput
  - Token caching for Tidal (eliminates redundant auth requests)
  - Singleton pattern for all downloaders (HTTP connection reuse)
@@ -92,6 +621,7 @@
 - **Amazon Music Optimizations**: Same optimizations now applied to Amazon downloader

 ### Technical
+
 - New `go_backend/parallel.go` with `TrackIDCache`, `FetchCoverAndLyricsParallel()`, `PreWarmTrackCache()`
 - Flutter: `_preWarmCacheForTracks()` in `track_provider.dart`
 - New method channels: `preWarmTrackCache`, `getTrackCacheSize`, `clearTrackCache`
@@ -99,6 +629,7 @@
 ## [2.0.7-preview2] - 2026-01-06

 ### Fixed
+
 - **iOS Directory Picker**: Fixed unable to select download folder on iOS
  - iOS limitation: Empty folders cannot be selected via document picker
  - Added "App Documents Folder" option as recommended default
@@ -108,6 +639,7 @@
 ## [2.0.7-preview] - 2026-01-05

 ### Changed
+
 - **Reduced APK Size**: Replaced FFmpeg plugin with custom AAR containing only required codecs
  - arm64 APK: 46.6 MB (previously 51 MB)
  - arm32 APK: 59 MB (previously 64 MB)
@@ -115,6 +647,7 @@
  - Removed x86/x86_64 architectures (emulator only)

 ### Technical
+
 - Custom FFmpeg AAR with arm64-v8a and armeabi-v7a only
 - Native MethodChannel bridge for FFmpeg operations
 - Separate iOS build configuration with ffmpeg_kit_flutter plugin
@@ -122,6 +655,7 @@
 ## [2.0.6] - 2026-01-05

 ### Fixed
+
 - **Duration Display Bug**: Fixed duration showing incorrect values like "4135:53" instead of "4:14"
  - `duration_ms` (milliseconds) was being stored directly without conversion to seconds
  - Now properly converts milliseconds to seconds before display
@@ -141,14 +675,17 @@
 ## [2.0.5] - 2026-01-05

 ### Added
+
 - **Large Playlist Support**: Playlists with up to 1000 tracks are now fully fetched (was limited to 100)

 ### Fixed
+
 - **Wrong Track Download**: Fixed issue where tracks with same ISRC but different versions (e.g., short/instrumental vs full version) would download the wrong track. Now verifies duration matches before downloading (30 second tolerance).

 ## [2.0.4] - 2026-01-04

 ### Fixed
+
 - **Android 11 Storage Permission**: Fixed "Permission denied" error on Android 11 (API 30) devices
  - Added `MANAGE_EXTERNAL_STORAGE` permission for Android 11-12
  - Shows explanation dialog before opening system settings
@@ -156,6 +693,7 @@
 ## [2.0.3] - 2026-01-03

 ### Added
+
 - **Custom Spotify API Credentials**: Set your own Spotify Client ID and Secret in Settings > Options to avoid rate limiting
  - Toggle to enable/disable custom credentials without deleting them
  - Material Expressive 3 bottom sheet UI for entering credentials
@@ -163,9 +701,11 @@
 - **Rate Limit Error UI**: Shows friendly error card when API rate limit (429) is hit on Home, Artist, and Album screens

 ### Changed
+
 - **Search on Enter Only**: Removed auto-search debounce, now only searches when pressing Enter key (saves API calls)

 ### Fixed
+
 - **Download Cancel**: Fixed cancelled downloads still completing in background and appearing in history. Cancelled files are now properly deleted.
 - **Search Keyboard Dismiss**: Fixed keyboard randomly dismissing and navigating back when starting to search
 - **Back Button During Search**: Back button now properly dismisses keyboard first before clearing search
@@ -175,6 +715,7 @@
 ## [2.0.2] - 2026-01-03

 ### Added
+
 - **Actual Quality Display**: Shows real audio quality (bit depth/sample rate) after download
  - Quality badge on download history items (e.g., "24-bit", "16-bit")
  - Full quality info in Track Metadata screen (e.g., "24-bit/96kHz")
@@ -183,13 +724,16 @@
 - **Instant Lyrics Loading**: Lyrics now load from embedded file first (instant) before falling back to internet fetch

 ### Fixed
+
 - **Fallback Service Display**: Fixed download history showing wrong service when fallback occurs (e.g., showing "TIDAL" when actually downloaded from "QOBUZ")
 - **Open in Spotify**: Fixed "Open in Spotify" button not opening Spotify app correctly

 ### Removed
+
 - **Romaji Conversion**: Removed Japanese lyrics to romaji conversion feature (Kanji not supported, results were incomplete)

 ### Technical
+
 - Go backend now returns `actual_bit_depth` and `actual_sample_rate` in download response
 - Go backend now returns `service` field indicating actual service used (important for fallback)
 - Tidal API v2 response provides exact quality info
@@ -199,18 +743,21 @@
 ## [2.0.1] - 2026-01-03

 ### Added
+
 - **Quality Picker Track Info**: Shows track name, artist, and cover in quality picker
  - Tap to expand long track titles
  - Expand icon only shows when title is truncated
  - Ripple effect follows rounded corners including drag handle

 ### Changed
+
 - **Unified Progress Tracking System**: Deprecated legacy single-download progress
  - All downloads now use item-based progress tracking
  - Fixes duplicate notification bug when finalizing
  - Cleaner codebase with single progress system

 ### Fixed
+
 - **Duplicate Notification Bug**: Fixed issue where "Finalizing" and "Downloading" notifications appeared simultaneously
 - **Update Notification Stuck**: Fixed notification staying at 100% after download completes
 - **Quality Picker Consistency**: Unified quality picker UI across all screens (Home, Album, Playlist)
@@ -220,6 +767,7 @@
 ## [2.0.0] - 2026-01-03

 ### Added
+
 - **Artist Search Results**: Search now shows artists alongside tracks
  - Horizontal scrollable artist cards with circular avatars
  - Tap artist to view their discography
@@ -240,11 +788,12 @@
  - Stable users won't receive update notifications for preview versions

 ### Changed
+
 - **Instant Navigation UX**: Navigate to Artist/Album screens immediately
  - Header (name, cover) shows instantly from available data
  - Content (albums/tracks) loads in background inside the screen
  - Second visit to same artist/album is instant from Flutter cache
- **Search Results UI Redesign**: 
+- **Search Results UI Redesign**:
  - Removed "Download All" button from search results
  - Added "Songs" section header (matches "Artists" header style)
  - Track list now in grouped card with rounded corners (like Settings)
@@ -267,6 +816,7 @@
 - **Ask Before Download Default**: Now enabled by default for better UX

 ### Fixed
+
 - **Artist Profile Images**: Fixed artist images not showing in search results (field name mismatch)
 - **Album Card Overflow**: Fixed 5px overflow in artist discography album cards
 - **Optimized Rebuilds**: Each track item only rebuilds when its own status changes
@@ -277,6 +827,7 @@
 ## [1.6.3] - 2026-01-03

 ### Added
+
 - **Predictive Back Navigation**: Support for Android 14+ predictive back gesture with smooth animations
 - **Separate Detail Screens**: Album, Artist, and Playlist now open as dedicated screens with Material Expressive 3 design
  - Collapsing header with cover art and gradient overlay
@@ -286,6 +837,7 @@
 - **Double-Tap to Exit**: Press back twice to exit app when at home screen (replaces exit dialog)

 ### Changed
+
 - **Navigation Architecture**: Refactored from state-based to screen-based navigation
  - Album/Artist/Playlist URLs navigate to dedicated screens via `Navigator.push()`
  - Enables native predictive back gesture animations
@@ -295,17 +847,21 @@
 ## [1.6.2] - 2026-01-02

 ### Added
+
 - **HTTPS-Only Downloads**: APK downloads and update checks now enforce HTTPS-only connections for security

 ### Changed
+
 - **Home Tab Rename**: Renamed "Search" tab to "Home" with home icon
 - **Branding**: Changed idle screen title from "Search Music" to "SpotiFLAC"
 - **About Page Redesign**: New Material Expressive 3 grouped layout with app header, contributors section with GitHub avatars, and organized links

 ### Fixed
+
 - **Play Button Flash**: Fixed play button briefly showing red error icon on app start (now uses optimistic rendering)

 ### Performance
+
 - **Optimized State Management**: Use `.select()` for Riverpod providers to prevent unnecessary widget rebuilds
 - **List Keys**: Added keys to all list builders for efficient list updates and reordering
 - **Request Cancellation**: Outdated API requests are ignored when new search/fetch is triggered
@@ -317,12 +873,14 @@
 ## [1.6.1] - 2026-01-02

 ### Added
+
 - **Background Download Service**: Downloads now continue running when app is in background
  - Foreground service with wake lock prevents Android from killing downloads
  - Persistent notification shows download progress
  - No more "connection abort" errors when switching apps

 ### Fixed
+
 - **Share Intent App Restart**: Fixed download queue being lost when sharing from Spotify while downloads are in progress
  - Download queue is now persisted to storage and automatically restored on app restart
  - Interrupted downloads (marked as "downloading") are reset to "queued" and auto-resumed
@@ -331,11 +889,13 @@
 - **Back Button During Loading**: Back button no longer clears state while loading shared URL

 ### Changed
+
 - **Kotlin**: Upgraded from 2.2.20 to 2.3.0 for better plugin compatibility

 ## [1.6.0] - 2026-01-02

 ### Added
+
 - **Manual Quality Selection**: New option to choose audio quality before each download
  - Toggle "Ask Before Download" in Download Settings
  - When enabled, shows quality picker (Lossless, Hi-Res, Hi-Res Max) before downloading
@@ -350,12 +910,14 @@
 - **Share Audio File**: Share downloaded tracks to other apps from Track Metadata screen

 ### Fixed
+
 - **Update Checker**: Fixed version comparison for versions with suffix (e.g., `1.5.0-hotfix6`)
  - Users on hotfix versions now properly receive update notifications
  - Handles `-hotfix`, `-beta`, `-rc` suffixes correctly
 - **Settings Ripple Effect**: Fixed splash/ripple effect to properly clip within rounded card corners

 ### Changed
+
 - **Settings UI Redesign**: New Android-style grouped settings with connected cards
  - Items in same group are connected with rounded card container
  - Section headers outside cards for clear visual hierarchy
@@ -364,6 +926,7 @@
 - **Consistent Header Position**: Fixed Search tab header alignment to match History and Settings tabs

 ### Improved
+
 - **Code Quality**: Replaced all `print()` statements with structured logging using `logger` package
 - **Dependencies Updated**:
  - `share_plus`: 10.1.4 → 12.0.1
@@ -373,6 +936,7 @@
 ## [1.5.5] - 2026-01-02

 ### Added
+
 - **Share to App**: Share Spotify links directly from Spotify app or browser to SpotiFLAC
  - Supports track, album, playlist, and artist URLs
  - Auto-fetches metadata when link is shared
@@ -399,6 +963,7 @@
 - **Exit Confirmation**: Dialog prompt when pressing back to exit app (only at root)

 ### Changed
+
 - **Downloads Tab Renamed to History**: Better reflects the tab's purpose
  - Shows download queue at top when active
  - Completed downloads auto-move to history section
@@ -409,11 +974,13 @@
  - Only shows exit dialog when truly at root

 ### Fixed
+
 - **Download Progress**: Fixed progress stuck at 0% when using item-based progress tracking (affected sequential downloads after multi-download feature was added)
 - **Artist View State**: Fixed UI state not clearing properly when switching between artist and album views
 - **Share Intent Timing**: Fixed shared URLs not being processed when app was cold-started from share intent

 ### Improved
+
 - **Cleaner UI for Returning Users**: Helper text "Supports: Track, Album, Playlist URLs" now only shows for new users and hides after first search
 - **Cleaner Home Tab**: Removed redundant "Recent Downloads" section, renamed to "Search" tab
 - **Centered Search Bar**: Search bar now appears centered on screen when empty, moves to top when results are shown - easier to reach on large phones
@@ -422,26 +989,31 @@
 ## [1.5.0-hotfix6] - 2026-01-02

 ### Fixed
+
 - **App Signing**: Use r0adkll/sign-android-release GitHub Action for reliable signing

 ## [1.5.0-hotfix5] - 2026-01-02

 ### Fixed
+
 - **App Signing**: Use key.properties as per Flutter official documentation

 ## [1.5.0-hotfix4] - 2026-01-02

 ### Fixed
+
 - **App Signing**: Create keystore.properties in workflow for Gradle

 ## [1.5.0-hotfix] - 2026-01-02

 ### Important Notice
+
 We apologize for the inconvenience. Previous releases were signed with different keys, causing "package conflicts" errors when upgrading. Starting from this version, all releases will use a consistent signing key.

 **If you're upgrading from v1.5.0 or earlier, please uninstall the app first before installing this version.** This is a one-time requirement. Future updates will work seamlessly without uninstalling.

 ### Added
+
 - **In-App Update**: Download and install updates directly from the app
  - Progress bar shows download status
  - Automatic device architecture detection (arm64/arm32)
@@ -449,11 +1021,13 @@ We apologize for the inconvenience. Previous releases were signed with different
 - **Consistent App Signing**: All future releases will use the same signing key

 ### Fixed
+
 - **Update Checker**: Now downloads APK directly instead of opening browser

 ## [1.5.0] - 2026-01-02

 ### Added
+
 - **Download Progress Notification**: Shows notification with download progress percentage while downloading
  - Progress bar in notification during download
  - Completion notification when track finishes
@@ -477,6 +1051,7 @@ We apologize for the inconvenience. Previous releases were signed with different
  - Downloads correct APK for your device

 ### Changed
+
 - **Recent Downloads**: Now shows up to 10 items (was 5) for better scrolling
 - **Queue UI Redesign**: Card-based layout with clearer status indicators
  - Removed global pause/resume in favor of per-item controls
@@ -501,6 +1076,7 @@ We apologize for the inconvenience. Previous releases were signed with different
  - "Add Music" button for quick access

 ### Technical
+
 - Added `flutter_local_notifications` package for notifications
 - Added notification permission request in setup screen for Android 13+
 - Enabled core library desugaring for all Android subprojects
@@ -509,6 +1085,7 @@ We apologize for the inconvenience. Previous releases were signed with different
 - Updated platform channel handlers for both Android (Kotlin) and iOS (Swift)

 ### Performance
+
 - Optimized SliverAppBar: Removed LayoutBuilder that was called every frame during scroll
 - Optimized image caching: Added `memCacheWidth/Height` to CachedNetworkImage for memory efficiency
 - Optimized state management: Use `select()` to only rebuild when specific state changes
@@ -517,6 +1094,7 @@ We apologize for the inconvenience. Previous releases were signed with different
 ## [1.2.0] - 2026-01-02

 ### Added
+
 - **Track Metadata Screen**: New detailed metadata view when tapping on downloaded tracks
  - Material Expressive 3 design with cover art header and gradient
  - Hero animation from list to detail view
@@ -529,12 +1107,14 @@ We apologize for the inconvenience. Previous releases were signed with different
 - **Hi-Res Lossless MAX**: New highest quality option for maximum audio fidelity

 ### Fixed
+
 - **Hi-Res Quality Bug**: Fixed issue where Hi-Res downloads were stuck at Lossless quality
  - Users on previous versions are recommended to upgrade to get proper Hi-Res downloads
 - **Settings Navigation Bug**: Fixed issue where changing settings (like audio quality) would navigate back to Home tab
 - **Tidal Badge Color**: Fixed unreadable Tidal service badge (was too bright cyan, now darker blue)

 ### Changed
+
 - **Recent Downloads**: Tapping on a track now opens metadata screen instead of playing directly
  - Play button still available for quick playback
 - **Download History Model**: Extended with additional metadata fields (albumArtist, isrc, spotifyId, trackNumber, discNumber, duration, releaseDate, quality)
@@ -543,30 +1123,34 @@ We apologize for the inconvenience. Previous releases were signed with different
 ## [1.1.2] - 2026-01-01

 ### Added
+
 - **Update Checker**: Automatic check for new versions from GitHub releases
  - Shows changelog in update dialog
  - Option to disable update notifications
 - **Release Changelog**: GitHub releases now include full changelog

 ### Changed
+
 - Updated version to 1.1.2

 ## [1.1.1] - 2026-01-01

 ### Fixed
+
 - **About Dialog**: Custom About dialog with cleaner layout
 - **Setup Screen**: Fixed step indicator line alignment
 - **Warning Text**: Fixed parallel downloads warning to use Material theme colors
 - **Copyright Year**: Updated to 2026

 ### Changed
+
 - Removed Theme Preview from Settings
 - Added MIT License

-
 ## [1.1.0] - 2026-01-01

 ### Added
+
 - **Parallel Downloads**: Download up to 3 tracks simultaneously (configurable in Settings)
  - Default: Sequential (1 at a time) for stability
  - Options: 1, 2, or 3 concurrent downloads
@@ -577,15 +1161,18 @@ We apologize for the inconvenience. Previous releases were signed with different
 - **Connection Cleanup**: Automatic cleanup of idle connections every 50 downloads and at queue end

 ### Fixed
+
 - **Download Progress Bug**: Fixed 0% → 100% jump by adding proper progress tracking for BTS format downloads
 - **TCP Connection Exhaustion**: Fixed slow downloads after ~300 tracks by implementing connection pooling and periodic cleanup
 - **Trailing Space in Names**: Fixed download failures when playlist/album/track names have trailing spaces
 - **History Loss on Debug**: History no longer disappears when sideloading via `flutter run --debug`

 ### Changed
+
 - Updated version to 1.1.0

 ### Technical Details
+
 - Added `concurrentDownloads` field to `AppSettings` model (default: 1, max: 3)
 - Implemented worker pool pattern in `DownloadQueueNotifier` for parallel processing
 - Added `SetCurrentFile()`, `SetBytesTotal()`, and `ProgressWriter` for BTS downloads in Go backend
@@ -594,6 +1181,7 @@ We apologize for the inconvenience. Previous releases were signed with different
 - Added `CleanupConnections()` export for Flutter to call via method channel

 ## [1.0.5] - Previous Release
+
 - Material Expressive 3 UI
 - Dynamic color support
 - Swipe navigation with PageView
@@ -1,5 +1,5 @@
 [![GitHub All Releases](https://img.shields.io/github/downloads/zarzet/SpotiFLAC-Mobile/total?style=for-the-badge)](https://github.com/zarzet/SpotiFLAC-Mobile/releases)
-[![VirusTotal](https://img.shields.io/badge/VirusTotal-Safe-brightgreen?style=for-the-badge&logo=virustotal)](https://www.virustotal.com/gui/file/b715b67c1a027823d622a6e578e668c855dee1c364726895a7c379f080a0b987)
+[![VirusTotal](https://img.shields.io/badge/VirusTotal-Safe-brightgreen?style=for-the-badge&logo=virustotal)](https://www.virustotal.com/gui/file/09c6260e9ebaf2ff0d15f30deda939642f41887f11aad602ac697cb37fa0308c/)

 <div align="center">

@@ -23,11 +23,55 @@ Get Spotify tracks in true FLAC from Tidal, Qobuz & Amazon Music — no account
  <img src="assets/images/4.jpg?v=2" width="200" />
 </p>

+## Metadata Source
+
+SpotiFLAC supports two metadata sources for searching tracks:
+
+| Source | Pros | Cons |
+|--------|------|------|
+| **Deezer** (Default) | No developer account needed, rate limit per user IP | Slightly less comprehensive catalog |
+| **Spotify** | More comprehensive catalog, better search results | Requires developer API credentials to avoid rate limiting |
+
+### Using Spotify
+To use Spotify as your search source without hitting rate limits:
+1. Create a Spotify Developer account at [developer.spotify.com](https://developer.spotify.com)
+2. Create an app to get your Client ID and Client Secret
+3. Go to **Settings > Options > Spotify API > Change from Deezer to Spotify > Input Custom Credentials**
+4. Enter your Client ID and Secret
+5. Change **Search Source** to Spotify
+
+## Extensions (Alpha)
+
+> **Alpha Feature**: Extensions are now available in alpha. Some features may be unstable or change in future releases.
+
+SpotiFLAC supports extensions to add custom metadata and download providers. Extensions are written in JavaScript and run in a secure sandbox.
+
+### Features
+- **Metadata Providers**: Add new sources for track/album/artist search
+- **Download Providers**: Add new sources for audio downloads
+- **Custom Settings**: Extensions can have user-configurable settings
+- **Provider Priority**: Set the order in which providers are tried
+
+### Installing Extensions
+1. Download a `.spotiflac-ext` file
+2. Go to **Settings > Extensions**
+3. Tap **Install Extension** and select the file
+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](docs/EXTENSION_DEVELOPMENT.md) for complete documentation.
+
+### Example Extensions
+Sample extensions are available in the [docs/extensions_example](docs/extensions_example) folder:
+
 ## Other project

 ### [SpotiFLAC (Desktop)](https://github.com/afkarxyz/SpotiFLAC)
 Get Spotify tracks in true FLAC from Tidal, Qobuz & Amazon Music for Windows, macOS & Linux

+[![Ko-fi](https://img.shields.io/badge/Ko--fi-Support%20Me-FF5E5B?style=for-the-badge&logo=ko-fi&logoColor=white)](https://ko-fi.com/zarzet)
+
 ## Disclaimer

 > **iOS Support**: This app is primarily tested on Android. iOS support is experimental and may have bugs — the developer is too poor to afford an iPhone for proper testing. If you encounter issues on iOS, please report them!
@@ -1,3 +1,6 @@
+import java.util.Properties
+import java.io.FileInputStream
+
 plugins {
    id("com.android.application")
    id("kotlin-android")
@@ -7,9 +10,9 @@ plugins {

 // Load keystore properties for local builds
 val keystorePropertiesFile = rootProject.file("key.properties")
-val keystoreProperties = java.util.Properties()
+val keystoreProperties = Properties()
 if (keystorePropertiesFile.exists()) {
-    keystoreProperties.load(java.io.FileInputStream(keystorePropertiesFile))
+    keystoreProperties.load(FileInputStream(keystorePropertiesFile))
 }

 android {
@@ -32,10 +35,10 @@ android {
    signingConfigs {
        if (keystorePropertiesFile.exists()) {
            create("release") {
-                keyAlias = keystoreProperties["keyAlias"] as String
-                keyPassword = keystoreProperties["keyPassword"] as String
-                storeFile = file(keystoreProperties["storeFile"] as String)
-                storePassword = keystoreProperties["storePassword"] as String
+                keyAlias = keystoreProperties.getProperty("keyAlias")
+                keyPassword = keystoreProperties.getProperty("keyPassword")
+                storeFile = file(keystoreProperties.getProperty("storeFile"))
+                storePassword = keystoreProperties.getProperty("storePassword")
            }
        }
    }
@@ -43,7 +46,7 @@ android {
    defaultConfig {
        applicationId = "com.zarz.spotiflac"
        minSdk = flutter.minSdkVersion
-        targetSdk = 34
+        targetSdk = 36
        versionCode = flutter.versionCode
        versionName = flutter.versionName
        multiDexEnabled = true
@@ -94,8 +97,10 @@ repositories {

 dependencies {
    coreLibraryDesugaring("com.android.tools:desugar_jdk_libs:2.1.4")
-    implementation(files("libs/gobackend.aar"))
-    implementation(files("libs/ffmpeg-kit-with-lame.aar"))
+    
+    // Include all AAR and JAR files from libs folder
+    implementation(fileTree(mapOf("dir" to "libs", "include" to listOf("*.jar", "*.aar"))))
+    
    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-android:1.7.3")
    implementation("androidx.lifecycle:lifecycle-runtime-ktx:2.7.0")
 }
@@ -6,6 +6,14 @@
 -keep class io.flutter.** { *; }
 -keep class io.flutter.plugins.** { *; }

+# Ignore missing Play Core classes (not used, but referenced by Flutter)
+-dontwarn com.google.android.play.core.splitcompat.**
+-dontwarn com.google.android.play.core.splitinstall.**
+-dontwarn com.google.android.play.core.tasks.**
+
+# Ignore missing javax.xml.stream (not used on Android)
+-dontwarn javax.xml.stream.**
+
 # Go backend (gobackend.aar)
 -keep class gobackend.** { *; }
 -keep class go.** { *; }
@@ -14,6 +22,9 @@
 -keep class com.arthenica.ffmpegkit.** { *; }
 -keep class com.arthenica.smartexception.** { *; }

+# Apache Tika (if used by FFmpeg)
+-dontwarn org.apache.tika.**
+
 # Keep native methods
 -keepclasseswithmembernames class * {
    native <methods>;
@@ -15,6 +15,9 @@ import androidx.core.app.NotificationCompat
 /**
 * Foreground service to keep downloads running when app is in background.
 * This prevents Android from killing the download process or throttling network.
+ * 
+ * Note: Android 15+ (API 35+) has a 6-hour timeout for dataSync foreground services.
+ * The service will be stopped automatically after 6 hours of cumulative runtime in 24 hours.
 */
 class DownloadService : Service() {
    
@@ -106,6 +109,19 @@ class DownloadService : Service() {
    
    override fun onBind(intent: Intent?): IBinder? = null
    
+    /**
+     * Called when the foreground service timeout is reached (Android 15+, API 35+).
+     * dataSync services have a 6-hour limit in a 24-hour period.
+     * 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()
+    }
+    
    private fun createNotificationChannel() {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
            val channel = NotificationChannel(
@@ -180,6 +180,13 @@ class MainActivity: FlutterActivity() {
                            }
                            result.success(null)
                        }
+                        "readFileMetadata" -> {
+                            val filePath = call.argument<String>("file_path") ?: ""
+                            val response = withContext(Dispatchers.IO) {
+                                Gobackend.readFileMetadata(filePath)
+                            }
+                            result.success(response)
+                        }
                        "startDownloadService" -> {
                            val trackName = call.argument<String>("track_name") ?: ""
                            val artistName = call.argument<String>("artist_name") ?: ""
@@ -211,6 +218,12 @@ class MainActivity: FlutterActivity() {
                            }
                            result.success(null)
                        }
+                        "hasSpotifyCredentials" -> {
+                            val hasCredentials = withContext(Dispatchers.IO) {
+                                Gobackend.checkSpotifyCredentials()
+                            }
+                            result.success(hasCredentials)
+                        }
                        "preWarmTrackCache" -> {
                            val tracksJson = call.argument<String>("tracks") ?: "[]"
                            withContext(Dispatchers.IO) {
@@ -230,6 +243,329 @@ class MainActivity: FlutterActivity() {
                            }
                            result.success(null)
                        }
+                        // Deezer API methods
+                        "searchDeezerAll" -> {
+                            val query = call.argument<String>("query") ?: ""
+                            val trackLimit = call.argument<Int>("track_limit") ?: 15
+                            val artistLimit = call.argument<Int>("artist_limit") ?: 3
+                            val response = withContext(Dispatchers.IO) {
+                                Gobackend.searchDeezerAll(query, trackLimit.toLong(), artistLimit.toLong())
+                            }
+                            result.success(response)
+                        }
+                        "getDeezerMetadata" -> {
+                            val resourceType = call.argument<String>("resource_type") ?: ""
+                            val resourceId = call.argument<String>("resource_id") ?: ""
+                            val response = withContext(Dispatchers.IO) {
+                                Gobackend.getDeezerMetadata(resourceType, resourceId)
+                            }
+                            result.success(response)
+                        }
+                        "parseDeezerUrl" -> {
+                            val url = call.argument<String>("url") ?: ""
+                            val response = withContext(Dispatchers.IO) {
+                                Gobackend.parseDeezerURLExport(url)
+                            }
+                            result.success(response)
+                        }
+                        "searchDeezerByISRC" -> {
+                            val isrc = call.argument<String>("isrc") ?: ""
+                            val response = withContext(Dispatchers.IO) {
+                                Gobackend.searchDeezerByISRC(isrc)
+                            }
+                            result.success(response)
+                        }
+                        "convertSpotifyToDeezer" -> {
+                            val resourceType = call.argument<String>("resource_type") ?: ""
+                            val spotifyId = call.argument<String>("spotify_id") ?: ""
+                            val response = withContext(Dispatchers.IO) {
+                                Gobackend.convertSpotifyToDeezer(resourceType, spotifyId)
+                            }
+                            result.success(response)
+                        }
+                        "getSpotifyMetadataWithFallback" -> {
+                            val url = call.argument<String>("url") ?: ""
+                            val response = withContext(Dispatchers.IO) {
+                                Gobackend.getSpotifyMetadataWithDeezerFallback(url)
+                            }
+                            result.success(response)
+                        }
+                        // Log methods
+                        "getLogs" -> {
+                            val response = withContext(Dispatchers.IO) {
+                                Gobackend.getLogs()
+                            }
+                            result.success(response)
+                        }
+                        "getLogsSince" -> {
+                            val index = call.argument<Int>("index") ?: 0
+                            val response = withContext(Dispatchers.IO) {
+                                Gobackend.getLogsSince(index.toLong())
+                            }
+                            result.success(response)
+                        }
+                        "clearLogs" -> {
+                            withContext(Dispatchers.IO) {
+                                Gobackend.clearLogs()
+                            }
+                            result.success(null)
+                        }
+                        "getLogCount" -> {
+                            val count = withContext(Dispatchers.IO) {
+                                Gobackend.getLogCount()
+                            }
+                            result.success(count.toInt())
+                        }
+                        "setLoggingEnabled" -> {
+                            val enabled = call.argument<Boolean>("enabled") ?: false
+                            withContext(Dispatchers.IO) {
+                                Gobackend.setLoggingEnabled(enabled)
+                            }
+                            result.success(null)
+                        }
+                        // Extension System methods
+                        "initExtensionSystem" -> {
+                            val extensionsDir = call.argument<String>("extensions_dir") ?: ""
+                            val dataDir = call.argument<String>("data_dir") ?: ""
+                            withContext(Dispatchers.IO) {
+                                Gobackend.initExtensionSystem(extensionsDir, dataDir)
+                            }
+                            result.success(null)
+                        }
+                        "loadExtensionsFromDir" -> {
+                            val dirPath = call.argument<String>("dir_path") ?: ""
+                            val response = withContext(Dispatchers.IO) {
+                                Gobackend.loadExtensionsFromDir(dirPath)
+                            }
+                            result.success(response)
+                        }
+                        "loadExtensionFromPath" -> {
+                            val filePath = call.argument<String>("file_path") ?: ""
+                            val response = withContext(Dispatchers.IO) {
+                                Gobackend.loadExtensionFromPath(filePath)
+                            }
+                            result.success(response)
+                        }
+                        "unloadExtension" -> {
+                            val extensionId = call.argument<String>("extension_id") ?: ""
+                            withContext(Dispatchers.IO) {
+                                Gobackend.unloadExtensionByID(extensionId)
+                            }
+                            result.success(null)
+                        }
+                        "removeExtension" -> {
+                            val extensionId = call.argument<String>("extension_id") ?: ""
+                            withContext(Dispatchers.IO) {
+                                Gobackend.removeExtensionByID(extensionId)
+                            }
+                            result.success(null)
+                        }
+                        "upgradeExtension" -> {
+                            val filePath = call.argument<String>("file_path") ?: ""
+                            val response = withContext(Dispatchers.IO) {
+                                Gobackend.upgradeExtensionFromPath(filePath)
+                            }
+                            result.success(response)
+                        }
+                        "checkExtensionUpgrade" -> {
+                            val filePath = call.argument<String>("file_path") ?: ""
+                            val response = withContext(Dispatchers.IO) {
+                                Gobackend.checkExtensionUpgradeFromPath(filePath)
+                            }
+                            result.success(response)
+                        }
+                        "getInstalledExtensions" -> {
+                            val response = withContext(Dispatchers.IO) {
+                                Gobackend.getInstalledExtensions()
+                            }
+                            result.success(response)
+                        }
+                        "setExtensionEnabled" -> {
+                            val extensionId = call.argument<String>("extension_id") ?: ""
+                            val enabled = call.argument<Boolean>("enabled") ?: false
+                            withContext(Dispatchers.IO) {
+                                Gobackend.setExtensionEnabledByID(extensionId, enabled)
+                            }
+                            result.success(null)
+                        }
+                        "setProviderPriority" -> {
+                            val priorityJson = call.argument<String>("priority") ?: "[]"
+                            withContext(Dispatchers.IO) {
+                                Gobackend.setProviderPriorityJSON(priorityJson)
+                            }
+                            result.success(null)
+                        }
+                        "getProviderPriority" -> {
+                            val response = withContext(Dispatchers.IO) {
+                                Gobackend.getProviderPriorityJSON()
+                            }
+                            result.success(response)
+                        }
+                        "setMetadataProviderPriority" -> {
+                            val priorityJson = call.argument<String>("priority") ?: "[]"
+                            withContext(Dispatchers.IO) {
+                                Gobackend.setMetadataProviderPriorityJSON(priorityJson)
+                            }
+                            result.success(null)
+                        }
+                        "getMetadataProviderPriority" -> {
+                            val response = withContext(Dispatchers.IO) {
+                                Gobackend.getMetadataProviderPriorityJSON()
+                            }
+                            result.success(response)
+                        }
+                        "getExtensionSettings" -> {
+                            val extensionId = call.argument<String>("extension_id") ?: ""
+                            val response = withContext(Dispatchers.IO) {
+                                Gobackend.getExtensionSettingsJSON(extensionId)
+                            }
+                            result.success(response)
+                        }
+                        "setExtensionSettings" -> {
+                            val extensionId = call.argument<String>("extension_id") ?: ""
+                            val settingsJson = call.argument<String>("settings") ?: "{}"
+                            withContext(Dispatchers.IO) {
+                                Gobackend.setExtensionSettingsJSON(extensionId, settingsJson)
+                            }
+                            result.success(null)
+                        }
+                        "searchTracksWithExtensions" -> {
+                            val query = call.argument<String>("query") ?: ""
+                            val limit = call.argument<Int>("limit") ?: 20
+                            val response = withContext(Dispatchers.IO) {
+                                Gobackend.searchTracksWithExtensionsJSON(query, limit.toLong())
+                            }
+                            result.success(response)
+                        }
+                        "downloadWithExtensions" -> {
+                            val requestJson = call.arguments as String
+                            val response = withContext(Dispatchers.IO) {
+                                Gobackend.downloadWithExtensionsJSON(requestJson)
+                            }
+                            result.success(response)
+                        }
+                        "removeExtension" -> {
+                            val extensionId = call.argument<String>("extension_id") ?: ""
+                            withContext(Dispatchers.IO) {
+                                Gobackend.removeExtensionByID(extensionId)
+                            }
+                            result.success(null)
+                        }
+                        "cleanupExtensions" -> {
+                            withContext(Dispatchers.IO) {
+                                Gobackend.cleanupExtensions()
+                            }
+                            result.success(null)
+                        }
+                        // Extension Auth API methods
+                        "getExtensionPendingAuth" -> {
+                            val extensionId = call.argument<String>("extension_id") ?: ""
+                            val response = withContext(Dispatchers.IO) {
+                                Gobackend.getExtensionPendingAuthJSON(extensionId)
+                            }
+                            if (response.isNullOrEmpty()) {
+                                result.success(null)
+                            } else {
+                                result.success(response)
+                            }
+                        }
+                        "setExtensionAuthCode" -> {
+                            val extensionId = call.argument<String>("extension_id") ?: ""
+                            val authCode = call.argument<String>("auth_code") ?: ""
+                            withContext(Dispatchers.IO) {
+                                Gobackend.setExtensionAuthCodeByID(extensionId, authCode)
+                            }
+                            result.success(null)
+                        }
+                        "setExtensionTokens" -> {
+                            val extensionId = call.argument<String>("extension_id") ?: ""
+                            val accessToken = call.argument<String>("access_token") ?: ""
+                            val refreshToken = call.argument<String>("refresh_token") ?: ""
+                            val expiresIn = call.argument<Int>("expires_in") ?: 0
+                            withContext(Dispatchers.IO) {
+                                Gobackend.setExtensionTokensByID(extensionId, accessToken, refreshToken, expiresIn.toLong())
+                            }
+                            result.success(null)
+                        }
+                        "clearExtensionPendingAuth" -> {
+                            val extensionId = call.argument<String>("extension_id") ?: ""
+                            withContext(Dispatchers.IO) {
+                                Gobackend.clearExtensionPendingAuthByID(extensionId)
+                            }
+                            result.success(null)
+                        }
+                        "isExtensionAuthenticated" -> {
+                            val extensionId = call.argument<String>("extension_id") ?: ""
+                            val isAuth = withContext(Dispatchers.IO) {
+                                Gobackend.isExtensionAuthenticatedByID(extensionId)
+                            }
+                            result.success(isAuth)
+                        }
+                        "getAllPendingAuthRequests" -> {
+                            val response = withContext(Dispatchers.IO) {
+                                Gobackend.getAllPendingAuthRequestsJSON()
+                            }
+                            result.success(response)
+                        }
+                        // Extension FFmpeg API
+                        "getPendingFFmpegCommand" -> {
+                            val commandId = call.argument<String>("command_id") ?: ""
+                            val response = withContext(Dispatchers.IO) {
+                                Gobackend.getPendingFFmpegCommandJSON(commandId)
+                            }
+                            if (response.isNullOrEmpty()) {
+                                result.success(null)
+                            } else {
+                                result.success(response)
+                            }
+                        }
+                        "setFFmpegCommandResult" -> {
+                            val commandId = call.argument<String>("command_id") ?: ""
+                            val success = call.argument<Boolean>("success") ?: false
+                            val output = call.argument<String>("output") ?: ""
+                            val error = call.argument<String>("error") ?: ""
+                            withContext(Dispatchers.IO) {
+                                Gobackend.setFFmpegCommandResultByID(commandId, success, output, error)
+                            }
+                            result.success(null)
+                        }
+                        "getAllPendingFFmpegCommands" -> {
+                            val response = withContext(Dispatchers.IO) {
+                                Gobackend.getAllPendingFFmpegCommandsJSON()
+                            }
+                            result.success(response)
+                        }
+                        // Extension Custom Search API
+                        "customSearchWithExtension" -> {
+                            val extensionId = call.argument<String>("extension_id") ?: ""
+                            val query = call.argument<String>("query") ?: ""
+                            val optionsJson = call.argument<String>("options") ?: ""
+                            val response = withContext(Dispatchers.IO) {
+                                Gobackend.customSearchWithExtensionJSON(extensionId, query, optionsJson)
+                            }
+                            result.success(response)
+                        }
+                        "getSearchProviders" -> {
+                            val response = withContext(Dispatchers.IO) {
+                                Gobackend.getSearchProvidersJSON()
+                            }
+                            result.success(response)
+                        }
+                        // Extension Post-Processing API
+                        "runPostProcessing" -> {
+                            val filePath = call.argument<String>("file_path") ?: ""
+                            val metadataJson = call.argument<String>("metadata") ?: ""
+                            val response = withContext(Dispatchers.IO) {
+                                Gobackend.runPostProcessingJSON(filePath, metadataJson)
+                            }
+                            result.success(response)
+                        }
+                        "getPostProcessingProviders" -> {
+                            val response = withContext(Dispatchers.IO) {
+                                Gobackend.getPostProcessingProvidersJSON()
+                            }
+                            result.success(response)
+                        }
                        else -> result.notImplemented()
                    }
                } catch (e: Exception) {
@@ -105,6 +105,78 @@ class FFmpegServiceIOS {
    return null;
  }

+  /// Embed metadata and cover art to FLAC file
+  /// Returns the file path on success, null on failure
+  static Future<String?> embedMetadata({
+    required String flacPath,
+    String? coverPath,
+    Map<String, String>? metadata,
+  }) async {
+    final tempOutput = '$flacPath.tmp';
+    
+    // Construct command
+    final StringBuffer cmdBuffer = StringBuffer();
+    cmdBuffer.write('-i "$flacPath" ');
+    
+    // Add cover input if available
+    if (coverPath != null) {
+      cmdBuffer.write('-i "$coverPath" ');
+    }
+    
+    // Map audio stream
+    cmdBuffer.write('-map 0:a ');
+    
+    // Map cover stream if available
+    if (coverPath != null) {
+      cmdBuffer.write('-map 1:0 ');
+      cmdBuffer.write('-c:v copy ');
+      cmdBuffer.write('-disposition:v attached_pic ');
+      cmdBuffer.write('-metadata:s:v title="Album cover" ');
+      cmdBuffer.write('-metadata:s:v comment="Cover (front)" ');
+    }
+    
+    // Copy audio codec (don't re-encode)
+    cmdBuffer.write('-c:a copy ');
+    
+    // Add text metadata
+    if (metadata != null) {
+      metadata.forEach((key, value) {
+        // Sanitize value: escape double quotes
+        final sanitizedValue = value.replaceAll('"', '\\"');
+        cmdBuffer.write('-metadata $key="$sanitizedValue" ');
+      });
+    }
+    
+    cmdBuffer.write('"$tempOutput" -y');
+    
+    final command = cmdBuffer.toString();
+    _log.d('Executing FFmpeg command: $command');
+
+    final result = await _execute(command);
+
+    if (result.success) {
+      try {
+        await File(flacPath).delete();
+        await File(tempOutput).rename(flacPath);
+        return flacPath;
+      } catch (e) {
+        _log.e('Failed to replace file after metadata embed: $e');
+        return null;
+      }
+    }
+
+    // Clean up temp file if exists
+    try {
+      final tempFile = File(tempOutput);
+      if (await tempFile.exists()) {
+        await tempFile.delete();
+      }
+    } catch (_) {}
+
+    _log.e('Metadata/Cover embed failed: ${result.output}');
+    return null;
+  }
+
  /// Check if FFmpeg is available
  static Future<bool> isAvailable() async {
    try {
@@ -17,14 +17,18 @@ import (

 // AmazonDownloader handles Amazon Music downloads using DoubleDouble service (same as PC)
 type AmazonDownloader struct {
-	client  *http.Client
-	regions []string // us, eu regions for DoubleDouble service
+	client           *http.Client
+	regions          []string  // us, eu regions for DoubleDouble service
+	lastAPICallTime  time.Time // Rate limiting: track last API call
+	apiCallCount     int       // Rate limiting: counter per minute
+	apiCallResetTime time.Time // Rate limiting: reset time
 }

 var (
 	// Global Amazon downloader instance for connection reuse
 	globalAmazonDownloader *AmazonDownloader
 	amazonDownloaderOnce   sync.Once
+	amazonRateLimitMu      sync.Mutex // Mutex for rate limiting
 )

 // DoubleDoubleSubmitResponse is the response from DoubleDouble submit endpoint
@@ -48,46 +52,46 @@ type DoubleDoubleStatusResponse struct {
 func amazonArtistsMatch(expectedArtist, foundArtist string) bool {
 	normExpected := strings.ToLower(strings.TrimSpace(expectedArtist))
 	normFound := strings.ToLower(strings.TrimSpace(foundArtist))
-	
+
 	// Exact match
 	if normExpected == normFound {
 		return true
 	}
-	
+
 	// Check if one contains the other
 	if strings.Contains(normExpected, normFound) || strings.Contains(normFound, normExpected) {
 		return true
 	}
-	
+
 	// Check first artist (before comma or feat)
 	expectedFirst := strings.Split(normExpected, ",")[0]
 	expectedFirst = strings.Split(expectedFirst, " feat")[0]
 	expectedFirst = strings.Split(expectedFirst, " ft.")[0]
 	expectedFirst = strings.TrimSpace(expectedFirst)
-	
+
 	foundFirst := strings.Split(normFound, ",")[0]
 	foundFirst = strings.Split(foundFirst, " feat")[0]
 	foundFirst = strings.Split(foundFirst, " ft.")[0]
 	foundFirst = strings.TrimSpace(foundFirst)
-	
+
 	if expectedFirst == foundFirst {
 		return true
 	}
-	
+
 	// Check if first artist is contained in the other
 	if strings.Contains(expectedFirst, foundFirst) || strings.Contains(foundFirst, expectedFirst) {
 		return true
 	}
-	
+
 	// If scripts are different (one is ASCII, one is non-ASCII like Japanese/Chinese/Korean),
 	// assume they're the same artist with different transliteration
 	expectedASCII := amazonIsASCIIString(expectedArtist)
 	foundASCII := amazonIsASCIIString(foundArtist)
 	if expectedASCII != foundASCII {
-		fmt.Printf("[Amazon] Artist names in different scripts, assuming match: '%s' vs '%s'\n", expectedArtist, foundArtist)
+		GoLog("[Amazon] Artist names in different scripts, assuming match: '%s' vs '%s'\n", expectedArtist, foundArtist)
 		return true
 	}
-	
+
 	return false
 }

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

+// waitForRateLimit implements rate limiting similar to PC version
+// Max 9 requests per minute with 7 second delay between requests
+func (a *AmazonDownloader) waitForRateLimit() {
+	amazonRateLimitMu.Lock()
+	defer amazonRateLimitMu.Unlock()
+
+	now := time.Now()
+
+	// Reset counter every minute
+	if now.Sub(a.apiCallResetTime) >= time.Minute {
+		a.apiCallCount = 0
+		a.apiCallResetTime = now
+	}
+
+	// If we've hit the limit (9 requests per minute), wait until next minute
+	if a.apiCallCount >= 9 {
+		waitTime := time.Minute - now.Sub(a.apiCallResetTime)
+		if waitTime > 0 {
+			GoLog("[Amazon] Rate limit reached, waiting %v...\n", waitTime.Round(time.Second))
+			time.Sleep(waitTime)
+			a.apiCallCount = 0
+			a.apiCallResetTime = time.Now()
+		}
+	}
+
+	// Add delay between requests (7 seconds like PC version)
+	if !a.lastAPICallTime.IsZero() {
+		timeSinceLastCall := now.Sub(a.lastAPICallTime)
+		minDelay := 7 * time.Second
+		if timeSinceLastCall < minDelay {
+			waitTime := minDelay - timeSinceLastCall
+			GoLog("[Amazon] Rate limiting: waiting %v...\n", waitTime.Round(time.Second))
+			time.Sleep(waitTime)
+		}
+	}
+
+	// Update tracking
+	a.lastAPICallTime = time.Now()
+	a.apiCallCount++
+}
+
 // GetAvailableAPIs returns list of available DoubleDouble regions
 // Uses same service as PC version (doubledouble.top)
 func (a *AmazonDownloader) GetAvailableAPIs() []string {
@@ -124,26 +170,28 @@ func (a *AmazonDownloader) GetAvailableAPIs() []string {
 	return apis
 }

-
 // downloadFromDoubleDoubleService downloads a track using DoubleDouble service (same as PC)
 // This uses submit → poll → download mechanism
 // Internal function - not exported to gomobile
-func (a *AmazonDownloader) downloadFromDoubleDoubleService(amazonURL, outputDir string) (string, string, string, error) {
+func (a *AmazonDownloader) downloadFromDoubleDoubleService(amazonURL, _ string) (string, string, string, error) {
 	var lastError error

 	for _, region := range a.regions {
-		fmt.Printf("[Amazon] Trying region: %s...\n", region)
+		GoLog("[Amazon] Trying region: %s...\n", region)

 		// Build base URL for DoubleDouble service
 		// Decode base64 service URL (same as PC)
-		serviceBase, _ := base64.StdEncoding.DecodeString("aHR0cHM6Ly8=")         // https://
+		serviceBase, _ := base64.StdEncoding.DecodeString("aHR0cHM6Ly8=")               // https://
 		serviceDomain, _ := base64.StdEncoding.DecodeString("LmRvdWJsZWRvdWJsZS50b3A=") // .doubledouble.top
 		baseURL := fmt.Sprintf("%s%s%s", string(serviceBase), region, string(serviceDomain))

-		// Step 1: Submit download request
+		// Step 1: Submit download request with rate limiting
 		encodedURL := url.QueryEscape(amazonURL)
 		submitURL := fmt.Sprintf("%s/dl?url=%s", baseURL, encodedURL)

+		// Apply rate limiting before request (like PC version)
+		a.waitForRateLimit()
+
 		req, err := http.NewRequest("GET", submitURL, nil)
 		if err != nil {
 			lastError = fmt.Errorf("failed to create request: %w", err)
@@ -153,15 +201,43 @@ func (a *AmazonDownloader) downloadFromDoubleDoubleService(amazonURL, outputDir
 		req.Header.Set("User-Agent", getRandomUserAgent())

 		fmt.Println("[Amazon] Submitting download request...")
-		resp, err := a.client.Do(req)
-		if err != nil {
-			lastError = fmt.Errorf("failed to submit request: %w", err)
-			continue
+
+		// Retry logic for 429 errors (like PC version: 3 retries with 15s wait)
+		var resp *http.Response
+		maxRetries := 3
+		for retry := 0; retry < maxRetries; retry++ {
+			resp, err = a.client.Do(req)
+			if err != nil {
+				lastError = fmt.Errorf("failed to submit request: %w", err)
+				break
+			}
+
+			if resp.StatusCode == 429 { // Too Many Requests
+				resp.Body.Close()
+				if retry < maxRetries-1 {
+					waitTime := 15 * time.Second
+					GoLog("[Amazon] Rate limited (429), waiting %v before retry %d/%d...\n", waitTime, retry+2, maxRetries)
+					time.Sleep(waitTime)
+					continue
+				}
+				lastError = fmt.Errorf("API rate limit exceeded after %d retries", maxRetries)
+				break
+			}
+
+			if resp.StatusCode != 200 {
+				resp.Body.Close()
+				lastError = fmt.Errorf("submit failed with status %d", resp.StatusCode)
+				break
+			}
+
+			// Success - break retry loop
+			break
 		}

-		if resp.StatusCode != 200 {
-			resp.Body.Close()
-			lastError = fmt.Errorf("submit failed with status %d", resp.StatusCode)
+		if err != nil || lastError != nil {
+			if resp != nil {
+				resp.Body.Close()
+			}
 			continue
 		}

@@ -179,7 +255,7 @@ func (a *AmazonDownloader) downloadFromDoubleDoubleService(amazonURL, outputDir
 		}

 		downloadID := submitResp.ID
-		fmt.Printf("[Amazon] Download ID: %s\n", downloadID)
+		GoLog("[Amazon] Download ID: %s\n", downloadID)

 		// Step 2: Poll for completion
 		statusURL := fmt.Sprintf("%s/dl/%s", baseURL, downloadID)
@@ -234,7 +310,7 @@ func (a *AmazonDownloader) downloadFromDoubleDoubleService(amazonURL, outputDir
 				trackName := status.Current.Name
 				artist := status.Current.Artist

-				fmt.Printf("[Amazon] Downloading: %s - %s\n", artist, trackName)
+				GoLog("[Amazon] Downloading: %s - %s\n", artist, trackName)
 				return fileURL, trackName, artist, nil

 			} else if status.Status == "error" {
@@ -268,7 +344,6 @@ func (a *AmazonDownloader) downloadFromDoubleDoubleService(amazonURL, outputDir
 	return "", "", "", fmt.Errorf("all regions failed. Last error: %v", lastError)
 }

-
 // DownloadFile downloads a file from URL with User-Agent and progress tracking
 func (a *AmazonDownloader) DownloadFile(downloadURL, outputPath, itemID string) error {
 	// Initialize item progress (required for all downloads)
@@ -294,43 +369,70 @@ func (a *AmazonDownloader) DownloadFile(downloadURL, outputPath, itemID string)
 		return fmt.Errorf("download failed: HTTP %d", resp.StatusCode)
 	}

+	expectedSize := resp.ContentLength
 	// Set total bytes if available
-	if resp.ContentLength > 0 && itemID != "" {
-		SetItemBytesTotal(itemID, resp.ContentLength)
+	if expectedSize > 0 && itemID != "" {
+		SetItemBytesTotal(itemID, expectedSize)
 	}

 	out, err := os.Create(outputPath)
 	if err != nil {
 		return err
 	}
-	defer out.Close()

 	// Use buffered writer for better performance (256KB buffer)
 	bufWriter := bufio.NewWriterSize(out, 256*1024)
-	defer bufWriter.Flush()

 	// Use item progress writer with buffered output
-	var bytesWritten int64
+	var written int64
 	if itemID != "" {
 		pw := NewItemProgressWriter(bufWriter, itemID)
-		bytesWritten, err = io.Copy(pw, resp.Body)
+		written, err = io.Copy(pw, resp.Body)
 	} else {
 		// Fallback: direct copy without progress tracking
-		bytesWritten, err = io.Copy(bufWriter, resp.Body)
-	}
-	if err != nil {
-		return fmt.Errorf("failed to write file: %w", err)
+		written, err = io.Copy(bufWriter, resp.Body)
 	}

-	fmt.Printf("\r[Amazon] Downloaded: %.2f MB (Complete)\n", float64(bytesWritten)/(1024*1024))
+	// Flush buffer before checking for errors
+	flushErr := bufWriter.Flush()
+	closeErr := out.Close()
+
+	// Check for any errors
+	if err != nil {
+		os.Remove(outputPath)
+		return fmt.Errorf("download interrupted: %w", err)
+	}
+	if flushErr != nil {
+		os.Remove(outputPath)
+		return fmt.Errorf("failed to flush buffer: %w", flushErr)
+	}
+	if closeErr != nil {
+		os.Remove(outputPath)
+		return fmt.Errorf("failed to close file: %w", closeErr)
+	}
+
+	// Verify file size if Content-Length was provided
+	if expectedSize > 0 && written != expectedSize {
+		os.Remove(outputPath)
+		return fmt.Errorf("incomplete download: expected %d bytes, got %d bytes", expectedSize, written)
+	}
+
+	fmt.Printf("\r[Amazon] Downloaded: %.2f MB (Complete)\n", float64(written)/(1024*1024))
 	return nil
 }

 // AmazonDownloadResult contains download result with quality info
 type AmazonDownloadResult struct {
-	FilePath   string
-	BitDepth   int
-	SampleRate int
+	FilePath    string
+	BitDepth    int
+	SampleRate  int
+	Title       string
+	Artist      string
+	Album       string
+	ReleaseDate string
+	TrackNumber int
+	DiscNumber  int
+	ISRC        string
 }

 // downloadFromAmazon downloads a track using the request parameters
@@ -345,7 +447,22 @@ func downloadFromAmazon(req DownloadRequest) (AmazonDownloadResult, error) {

 	// Get Amazon URL from SongLink
 	songlink := NewSongLinkClient()
-	availability, err := songlink.CheckTrackAvailability(req.SpotifyID, req.ISRC)
+	var availability *TrackAvailability
+	var err error
+
+	// Check if SpotifyID is actually a Deezer ID (format: "deezer:xxxxx")
+	if strings.HasPrefix(req.SpotifyID, "deezer:") {
+		// Extract Deezer ID and use Deezer-based lookup
+		deezerID := strings.TrimPrefix(req.SpotifyID, "deezer:")
+		GoLog("[Amazon] Using Deezer ID for SongLink lookup: %s\n", deezerID)
+		availability, err = songlink.CheckAvailabilityFromDeezer(deezerID)
+	} else if req.SpotifyID != "" {
+		// Use Spotify ID
+		availability, err = songlink.CheckTrackAvailability(req.SpotifyID, req.ISRC)
+	} else {
+		return AmazonDownloadResult{}, fmt.Errorf("no valid Spotify or Deezer ID provided for Amazon lookup")
+	}
+
 	if err != nil {
 		return AmazonDownloadResult{}, fmt.Errorf("failed to check Amazon availability via SongLink: %w", err)
 	}
@@ -369,12 +486,12 @@ func downloadFromAmazon(req DownloadRequest) (AmazonDownloadResult, error) {

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

 	// Log match found
-	fmt.Printf("[Amazon] Match found: '%s' by '%s'\n", trackName, artistName)
+	GoLog("[Amazon] Match found: '%s' by '%s'\n", trackName, artistName)

 	// Build filename using Spotify metadata (more accurate)
 	filename := buildFilenameFromTemplate(req.FilenameFormat, map[string]interface{}{
@@ -425,19 +542,38 @@ func downloadFromAmazon(req DownloadRequest) (AmazonDownloadResult, error) {

 	// Log track info from DoubleDouble (for debugging)
 	if trackName != "" && artistName != "" {
-		fmt.Printf("[Amazon] DoubleDouble returned: %s - %s\n", artistName, trackName)
+		GoLog("[Amazon] DoubleDouble returned: %s - %s\n", artistName, trackName)
+	}
+
+	// Read existing metadata from downloaded file BEFORE embedding
+	// Amazon/DoubleDouble files often have correct track/disc numbers that we should preserve
+	existingMeta, metaErr := ReadMetadata(outputPath)
+	actualTrackNum := req.TrackNumber
+	actualDiscNum := req.DiscNumber
+
+	if metaErr == nil && existingMeta != nil {
+		// Use file metadata if it has valid track/disc numbers and request doesn't have them
+		if existingMeta.TrackNumber > 0 && (req.TrackNumber == 0 || req.TrackNumber == 1) {
+			actualTrackNum = existingMeta.TrackNumber
+			GoLog("[Amazon] Using track number from file: %d (request had: %d)\n", actualTrackNum, req.TrackNumber)
+		}
+		if existingMeta.DiscNumber > 0 && (req.DiscNumber == 0 || req.DiscNumber == 1) {
+			actualDiscNum = existingMeta.DiscNumber
+			GoLog("[Amazon] Using disc number from file: %d (request had: %d)\n", actualDiscNum, req.DiscNumber)
+		}
 	}

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

@@ -445,7 +581,7 @@ func downloadFromAmazon(req DownloadRequest) (AmazonDownloadResult, error) {
 	var coverData []byte
 	if parallelResult != nil && parallelResult.CoverData != nil {
 		coverData = parallelResult.CoverData
-		fmt.Printf("[Amazon] Using parallel-fetched cover (%d bytes)\n", len(coverData))
+		GoLog("[Amazon] Using parallel-fetched cover (%d bytes)\n", len(coverData))
 	}

 	if err := EmbedMetadataWithCoverData(outputPath, metadata, coverData); err != nil {
@@ -454,9 +590,9 @@ func downloadFromAmazon(req DownloadRequest) (AmazonDownloadResult, error) {

 	// Embed lyrics from parallel fetch
 	if req.EmbedLyrics && parallelResult != nil && parallelResult.LyricsLRC != "" {
-		fmt.Printf("[Amazon] Embedding parallel-fetched lyrics (%d lines)...\n", len(parallelResult.LyricsData.Lines))
+		GoLog("[Amazon] Embedding parallel-fetched lyrics (%d lines)...\n", len(parallelResult.LyricsData.Lines))
 		if embedErr := EmbedLyrics(outputPath, parallelResult.LyricsLRC); embedErr != nil {
-			fmt.Printf("[Amazon] Warning: failed to embed lyrics: %v\n", embedErr)
+			GoLog("[Amazon] Warning: failed to embed lyrics: %v\n", embedErr)
 		} else {
 			fmt.Println("[Amazon] Lyrics embedded successfully")
 		}
@@ -465,24 +601,50 @@ func downloadFromAmazon(req DownloadRequest) (AmazonDownloadResult, error) {
 	}

 	fmt.Println("[Amazon] ✓ Downloaded successfully from Amazon Music")
-	
+
 	// Read actual quality from the downloaded FLAC file
 	// Amazon API doesn't provide quality info, but we can read it from the file itself
 	quality, err := GetAudioQuality(outputPath)
 	if err != nil {
-		fmt.Printf("[Amazon] Warning: couldn't read quality from file: %v\n", err)
-		// Return 0 to indicate unknown quality
-		return AmazonDownloadResult{
-			FilePath:   outputPath,
-			BitDepth:   0,
-			SampleRate: 0,
-		}, nil
+		GoLog("[Amazon] Warning: couldn't read quality from file: %v\n", err)
+	} else {
+		GoLog("[Amazon] Actual quality: %d-bit/%dHz\n", quality.BitDepth, quality.SampleRate)
 	}
-	
-	fmt.Printf("[Amazon] Actual quality: %d-bit/%dHz\n", quality.BitDepth, quality.SampleRate)
+
+	// Read metadata from file AFTER embedding to get accurate values
+	// This ensures we return what's actually in the file
+	finalMeta, metaReadErr := ReadMetadata(outputPath)
+	if metaReadErr == nil && finalMeta != nil {
+		GoLog("[Amazon] Final metadata from file - Track: %d, Disc: %d, Date: %s\n",
+			finalMeta.TrackNumber, finalMeta.DiscNumber, finalMeta.Date)
+		actualTrackNum = finalMeta.TrackNumber
+		actualDiscNum = finalMeta.DiscNumber
+		if finalMeta.Date != "" {
+			// Use date from file if available
+			req.ReleaseDate = finalMeta.Date
+		}
+	}
+
+	// Add to ISRC index for fast duplicate checking
+	AddToISRCIndex(req.OutputDir, req.ISRC, outputPath)
+
+	bitDepth := 0
+	sampleRate := 0
+	if err == nil {
+		bitDepth = quality.BitDepth
+		sampleRate = quality.SampleRate
+	}
+
 	return AmazonDownloadResult{
-		FilePath:   outputPath,
-		BitDepth:   quality.BitDepth,
-		SampleRate: quality.SampleRate,
+		FilePath:    outputPath,
+		BitDepth:    bitDepth,
+		SampleRate:  sampleRate,
+		Title:       req.TrackName,
+		Artist:      req.ArtistName,
+		Album:       req.AlbumName,
+		ReleaseDate: req.ReleaseDate,
+		TrackNumber: actualTrackNum,
+		DiscNumber:  actualDiscNum,
+		ISRC:        req.ISRC,
 	}, nil
 }
@@ -0,0 +1,742 @@
+package gobackend
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"strings"
+	"sync"
+	"time"
+)
+
+const (
+	deezerBaseURL     = "https://api.deezer.com/2.0"
+	deezerSearchURL   = deezerBaseURL + "/search"
+	deezerTrackURL    = deezerBaseURL + "/track/%s"
+	deezerAlbumURL    = deezerBaseURL + "/album/%s"
+	deezerArtistURL   = deezerBaseURL + "/artist/%s"
+	deezerPlaylistURL = deezerBaseURL + "/playlist/%s"
+
+	deezerCacheTTL = 10 * time.Minute
+
+	// Parallel ISRC fetching settings
+	deezerMaxParallelISRC = 10 // Max concurrent ISRC fetches
+)
+
+// DeezerClient handles Deezer API interactions (no auth required)
+type DeezerClient struct {
+	httpClient  *http.Client
+	searchCache map[string]*cacheEntry
+	albumCache  map[string]*cacheEntry
+	artistCache map[string]*cacheEntry
+	isrcCache   map[string]string // trackID -> ISRC cache
+	cacheMu     sync.RWMutex
+}
+
+// Singleton instance
+var (
+	deezerClient     *DeezerClient
+	deezerClientOnce sync.Once
+)
+
+// GetDeezerClient returns singleton Deezer client
+func GetDeezerClient() *DeezerClient {
+	deezerClientOnce.Do(func() {
+		deezerClient = &DeezerClient{
+			httpClient:  NewHTTPClientWithTimeout(15 * time.Second),
+			searchCache: make(map[string]*cacheEntry),
+			albumCache:  make(map[string]*cacheEntry),
+			artistCache: make(map[string]*cacheEntry),
+			isrcCache:   make(map[string]string),
+		}
+	})
+	return deezerClient
+}
+
+// Deezer API response types
+type deezerTrack struct {
+	ID            int64             `json:"id"`
+	Title         string            `json:"title"`
+	Duration      int               `json:"duration"` // in seconds
+	TrackPosition int               `json:"track_position"`
+	DiskNumber    int               `json:"disk_number"`
+	ISRC          string            `json:"isrc"`
+	Link          string            `json:"link"`
+	ReleaseDate   string            `json:"release_date"` // Sometimes at track level
+	Artist        deezerArtist      `json:"artist"`
+	Album         deezerAlbumSimple `json:"album"`
+	Contributors  []deezerArtist    `json:"contributors"`
+}
+
+type deezerArtist struct {
+	ID            int64  `json:"id"`
+	Name          string `json:"name"`
+	Picture       string `json:"picture"`
+	PictureMedium string `json:"picture_medium"`
+	PictureBig    string `json:"picture_big"`
+	PictureXL     string `json:"picture_xl"`
+	NbFan         int    `json:"nb_fan"`
+}
+
+type deezerAlbumSimple struct {
+	ID          int64  `json:"id"`
+	Title       string `json:"title"`
+	Cover       string `json:"cover"`
+	CoverMedium string `json:"cover_medium"`
+	CoverBig    string `json:"cover_big"`
+	CoverXL     string `json:"cover_xl"`
+	ReleaseDate string `json:"release_date"` // Sometimes at album level
+}
+
+// ... (skip other structs as they are fine/unchanged) ...
+
+// ... (in convertTrack) ...
+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
+		}
+		artistName = strings.Join(names, ", ")
+	}
+
+	albumImage := track.Album.CoverXL
+	if albumImage == "" {
+		albumImage = track.Album.CoverBig
+	}
+	if albumImage == "" {
+		albumImage = track.Album.CoverMedium
+	}
+	if albumImage == "" {
+		albumImage = track.Album.Cover
+	}
+
+	// Try to find release date
+	releaseDate := track.ReleaseDate
+	if releaseDate == "" {
+		releaseDate = track.Album.ReleaseDate
+	}
+
+	return TrackMetadata{
+		SpotifyID:   fmt.Sprintf("deezer:%d", track.ID),
+		Artists:     artistName,
+		Name:        track.Title,
+		AlbumName:   track.Album.Title,
+		AlbumArtist: track.Artist.Name,
+		DurationMS:  track.Duration * 1000,
+		Images:      albumImage,
+		ReleaseDate: releaseDate, // Added this
+		TrackNumber: track.TrackPosition,
+		DiscNumber:  track.DiskNumber,
+		ExternalURL: track.Link,
+		ISRC:        track.ISRC,
+	}
+}
+
+type deezerAlbumFull struct {
+	ID           int64          `json:"id"`
+	Title        string         `json:"title"`
+	Cover        string         `json:"cover"`
+	CoverMedium  string         `json:"cover_medium"`
+	CoverBig     string         `json:"cover_big"`
+	CoverXL      string         `json:"cover_xl"`
+	ReleaseDate  string         `json:"release_date"`
+	NbTracks     int            `json:"nb_tracks"`
+	Artist       deezerArtist   `json:"artist"`
+	Contributors []deezerArtist `json:"contributors"`
+	Tracks       struct {
+		Data []deezerTrack `json:"data"`
+	} `json:"tracks"`
+}
+
+type deezerArtistFull struct {
+	ID            int64  `json:"id"`
+	Name          string `json:"name"`
+	Picture       string `json:"picture"`
+	PictureMedium string `json:"picture_medium"`
+	PictureBig    string `json:"picture_big"`
+	PictureXL     string `json:"picture_xl"`
+	NbFan         int    `json:"nb_fan"`
+	NbAlbum       int    `json:"nb_album"`
+}
+
+type deezerPlaylistFull struct {
+	ID            int64  `json:"id"`
+	Title         string `json:"title"`
+	Picture       string `json:"picture"`
+	PictureMedium string `json:"picture_medium"`
+	PictureBig    string `json:"picture_big"`
+	PictureXL     string `json:"picture_xl"`
+	NbTracks      int    `json:"nb_tracks"`
+	Creator       struct {
+		Name string `json:"name"`
+	} `json:"creator"`
+	Tracks struct {
+		Data []deezerTrack `json:"data"`
+	} `json:"tracks"`
+}
+
+// SearchAll searches for tracks and artists on Deezer
+// NOTE: ISRC is NOT fetched during search for performance - use GetTrackISRC when needed for download
+func (c *DeezerClient) SearchAll(ctx context.Context, query string, trackLimit, artistLimit int) (*SearchAllResult, error) {
+	GoLog("[Deezer] SearchAll: query=%q, trackLimit=%d, artistLimit=%d\n", query, trackLimit, artistLimit)
+
+	cacheKey := fmt.Sprintf("deezer:all:%s:%d:%d", query, trackLimit, artistLimit)
+
+	c.cacheMu.RLock()
+	if entry, ok := c.searchCache[cacheKey]; ok && !entry.isExpired() {
+		c.cacheMu.RUnlock()
+		GoLog("[Deezer] SearchAll: returning cached result\n")
+		return entry.data.(*SearchAllResult), nil
+	}
+	c.cacheMu.RUnlock()
+
+	result := &SearchAllResult{
+		Tracks:  make([]TrackMetadata, 0),
+		Artists: make([]SearchArtistResult, 0),
+	}
+
+	// Search tracks - NO ISRC fetch for performance
+	trackURL := fmt.Sprintf("%s/track?q=%s&limit=%d", deezerSearchURL, url.QueryEscape(query), trackLimit)
+	GoLog("[Deezer] Fetching tracks from: %s\n", trackURL)
+
+	var trackResp struct {
+		Data  []deezerTrack `json:"data"`
+		Error *struct {
+			Type    string `json:"type"`
+			Message string `json:"message"`
+			Code    int    `json:"code"`
+		} `json:"error"`
+	}
+	if err := c.getJSON(ctx, trackURL, &trackResp); err != nil {
+		GoLog("[Deezer] Track search failed: %v\n", err)
+		return nil, fmt.Errorf("deezer track search failed: %w", err)
+	}
+
+	if trackResp.Error != nil {
+		GoLog("[Deezer] API error: type=%s, code=%d, message=%s\n", trackResp.Error.Type, trackResp.Error.Code, trackResp.Error.Message)
+		return nil, fmt.Errorf("deezer API error: %s (code %d)", trackResp.Error.Message, trackResp.Error.Code)
+	}
+
+	GoLog("[Deezer] Got %d tracks from API\n", len(trackResp.Data))
+
+	for _, track := range trackResp.Data {
+		// Convert directly without fetching ISRC - much faster
+		result.Tracks = append(result.Tracks, c.convertTrack(track))
+	}
+
+	// Search artists
+	artistURL := fmt.Sprintf("%s/artist?q=%s&limit=%d", deezerSearchURL, url.QueryEscape(query), artistLimit)
+	GoLog("[Deezer] Fetching artists from: %s\n", artistURL)
+
+	var artistResp struct {
+		Data  []deezerArtist `json:"data"`
+		Error *struct {
+			Type    string `json:"type"`
+			Message string `json:"message"`
+			Code    int    `json:"code"`
+		} `json:"error"`
+	}
+	if err := c.getJSON(ctx, artistURL, &artistResp); err == nil {
+		if artistResp.Error != nil {
+			GoLog("[Deezer] Artist API error: type=%s, code=%d, message=%s\n", artistResp.Error.Type, artistResp.Error.Code, artistResp.Error.Message)
+		} else {
+			GoLog("[Deezer] Got %d artists from API\n", len(artistResp.Data))
+			for _, artist := range artistResp.Data {
+				result.Artists = append(result.Artists, SearchArtistResult{
+					ID:         fmt.Sprintf("deezer:%d", artist.ID),
+					Name:       artist.Name,
+					Images:     c.getBestArtistImage(artist),
+					Followers:  artist.NbFan,
+					Popularity: 0,
+				})
+			}
+		}
+	} else {
+		GoLog("[Deezer] Artist search failed: %v\n", err)
+	}
+
+	GoLog("[Deezer] SearchAll complete: %d tracks, %d artists\n", len(result.Tracks), len(result.Artists))
+
+	// Cache result
+	c.cacheMu.Lock()
+	c.searchCache[cacheKey] = &cacheEntry{
+		data:      result,
+		expiresAt: time.Now().Add(deezerCacheTTL),
+	}
+	c.cacheMu.Unlock()
+
+	return result, nil
+}
+
+// GetTrack fetches a single track by Deezer ID
+func (c *DeezerClient) GetTrack(ctx context.Context, trackID string) (*TrackResponse, error) {
+	trackURL := fmt.Sprintf(deezerTrackURL, trackID)
+
+	var track deezerTrack
+	if err := c.getJSON(ctx, trackURL, &track); err != nil {
+		return nil, err
+	}
+
+	return &TrackResponse{
+		Track: c.convertTrack(track),
+	}, nil
+}
+
+// GetAlbum fetches album with tracks
+// ISRC is fetched in parallel for better performance
+func (c *DeezerClient) GetAlbum(ctx context.Context, albumID string) (*AlbumResponsePayload, error) {
+	c.cacheMu.RLock()
+	if entry, ok := c.albumCache[albumID]; ok && !entry.isExpired() {
+		c.cacheMu.RUnlock()
+		return entry.data.(*AlbumResponsePayload), nil
+	}
+	c.cacheMu.RUnlock()
+
+	albumURL := fmt.Sprintf(deezerAlbumURL, albumID)
+
+	var album deezerAlbumFull
+	if err := c.getJSON(ctx, albumURL, &album); err != nil {
+		return nil, err
+	}
+
+	albumImage := c.getBestAlbumImage(album)
+	artistName := album.Artist.Name
+	if len(album.Contributors) > 0 {
+		names := make([]string, len(album.Contributors))
+		for i, a := range album.Contributors {
+			names[i] = a.Name
+		}
+		artistName = strings.Join(names, ", ")
+	}
+
+	info := AlbumInfoMetadata{
+		TotalTracks: album.NbTracks,
+		Name:        album.Title,
+		ReleaseDate: album.ReleaseDate,
+		Artists:     artistName,
+		Images:      albumImage,
+	}
+
+	// Fetch ISRCs in parallel
+	isrcMap := c.fetchISRCsParallel(ctx, album.Tracks.Data)
+
+	tracks := make([]AlbumTrackMetadata, 0, len(album.Tracks.Data))
+	for _, track := range album.Tracks.Data {
+		trackIDStr := fmt.Sprintf("%d", track.ID)
+		isrc := isrcMap[trackIDStr]
+
+		tracks = append(tracks, AlbumTrackMetadata{
+			SpotifyID:   fmt.Sprintf("deezer:%d", track.ID),
+			Artists:     track.Artist.Name,
+			Name:        track.Title,
+			AlbumName:   album.Title,
+			AlbumArtist: artistName,
+			DurationMS:  track.Duration * 1000,
+			Images:      albumImage,
+			ReleaseDate: album.ReleaseDate,
+			TrackNumber: track.TrackPosition,
+			TotalTracks: album.NbTracks,
+			DiscNumber:  track.DiskNumber,
+			ExternalURL: track.Link,
+			ISRC:        isrc,
+			AlbumID:     fmt.Sprintf("deezer:%d", album.ID),
+		})
+	}
+
+	result := &AlbumResponsePayload{
+		AlbumInfo: info,
+		TrackList: tracks,
+	}
+
+	c.cacheMu.Lock()
+	c.albumCache[albumID] = &cacheEntry{
+		data:      result,
+		expiresAt: time.Now().Add(deezerCacheTTL),
+	}
+	c.cacheMu.Unlock()
+
+	return result, nil
+}
+
+// GetArtist fetches artist with albums
+func (c *DeezerClient) GetArtist(ctx context.Context, artistID string) (*ArtistResponsePayload, error) {
+	c.cacheMu.RLock()
+	if entry, ok := c.artistCache[artistID]; ok && !entry.isExpired() {
+		c.cacheMu.RUnlock()
+		return entry.data.(*ArtistResponsePayload), nil
+	}
+	c.cacheMu.RUnlock()
+
+	// Fetch artist info
+	artistURL := fmt.Sprintf(deezerArtistURL, artistID)
+	var artist deezerArtistFull
+	if err := c.getJSON(ctx, artistURL, &artist); err != nil {
+		return nil, err
+	}
+
+	artistInfo := ArtistInfoMetadata{
+		ID:         fmt.Sprintf("deezer:%d", artist.ID),
+		Name:       artist.Name,
+		Images:     c.getBestArtistImageFull(artist),
+		Followers:  artist.NbFan,
+		Popularity: 0,
+	}
+
+	// Fetch artist albums
+	albumsURL := fmt.Sprintf("%s/albums?limit=100", fmt.Sprintf(deezerArtistURL, artistID))
+	var albumsResp struct {
+		Data []struct {
+			ID          int64  `json:"id"`
+			Title       string `json:"title"`
+			ReleaseDate string `json:"release_date"`
+			NbTracks    int    `json:"nb_tracks"`
+			Cover       string `json:"cover"`
+			CoverMedium string `json:"cover_medium"`
+			CoverBig    string `json:"cover_big"`
+			CoverXL     string `json:"cover_xl"`
+			RecordType  string `json:"record_type"` // album, single, ep, compile
+		} `json:"data"`
+	}
+
+	albums := make([]ArtistAlbumMetadata, 0)
+	if err := c.getJSON(ctx, albumsURL, &albumsResp); err == nil {
+		for _, album := range albumsResp.Data {
+			albumType := album.RecordType
+			if albumType == "compile" {
+				albumType = "compilation"
+			}
+
+			coverURL := album.CoverXL
+			if coverURL == "" {
+				coverURL = album.CoverBig
+			}
+			if coverURL == "" {
+				coverURL = album.CoverMedium
+			}
+			if coverURL == "" {
+				coverURL = album.Cover
+			}
+
+			albums = append(albums, ArtistAlbumMetadata{
+				ID:          fmt.Sprintf("deezer:%d", album.ID),
+				Name:        album.Title,
+				ReleaseDate: album.ReleaseDate,
+				TotalTracks: album.NbTracks,
+				Images:      coverURL,
+				AlbumType:   albumType,
+				Artists:     artist.Name,
+			})
+		}
+	}
+
+	result := &ArtistResponsePayload{
+		ArtistInfo: artistInfo,
+		Albums:     albums,
+	}
+
+	c.cacheMu.Lock()
+	c.artistCache[artistID] = &cacheEntry{
+		data:      result,
+		expiresAt: time.Now().Add(deezerCacheTTL),
+	}
+	c.cacheMu.Unlock()
+
+	return result, nil
+}
+
+// GetPlaylist fetches playlist with tracks
+// ISRC is fetched in parallel for better performance
+func (c *DeezerClient) GetPlaylist(ctx context.Context, playlistID string) (*PlaylistResponsePayload, error) {
+	playlistURL := fmt.Sprintf(deezerPlaylistURL, playlistID)
+
+	var playlist deezerPlaylistFull
+	if err := c.getJSON(ctx, playlistURL, &playlist); err != nil {
+		return nil, err
+	}
+
+	playlistImage := playlist.PictureXL
+	if playlistImage == "" {
+		playlistImage = playlist.PictureBig
+	}
+	if playlistImage == "" {
+		playlistImage = playlist.PictureMedium
+	}
+
+	var info PlaylistInfoMetadata
+	info.Tracks.Total = playlist.NbTracks
+	info.Owner.DisplayName = playlist.Creator.Name
+	info.Owner.Name = playlist.Title
+	info.Owner.Images = playlistImage
+
+	// Fetch ISRCs in parallel
+	isrcMap := c.fetchISRCsParallel(ctx, playlist.Tracks.Data)
+
+	tracks := make([]AlbumTrackMetadata, 0, len(playlist.Tracks.Data))
+	for _, track := range playlist.Tracks.Data {
+		albumImage := track.Album.CoverXL
+		if albumImage == "" {
+			albumImage = track.Album.CoverBig
+		}
+		if albumImage == "" {
+			albumImage = track.Album.CoverMedium
+		}
+
+		trackIDStr := fmt.Sprintf("%d", track.ID)
+		isrc := isrcMap[trackIDStr]
+
+		tracks = append(tracks, AlbumTrackMetadata{
+			SpotifyID:   fmt.Sprintf("deezer:%d", track.ID),
+			Artists:     track.Artist.Name,
+			Name:        track.Title,
+			AlbumName:   track.Album.Title,
+			AlbumArtist: track.Artist.Name,
+			DurationMS:  track.Duration * 1000,
+			Images:      albumImage,
+			ReleaseDate: "",
+			TrackNumber: track.TrackPosition,
+			DiscNumber:  track.DiskNumber,
+			ExternalURL: track.Link,
+			ISRC:        isrc,
+			AlbumID:     fmt.Sprintf("deezer:%d", track.Album.ID),
+		})
+	}
+
+	return &PlaylistResponsePayload{
+		PlaylistInfo: info,
+		TrackList:    tracks,
+	}, nil
+}
+
+// SearchByISRC searches for a track by ISRC using direct endpoint
+func (c *DeezerClient) SearchByISRC(ctx context.Context, isrc string) (*TrackMetadata, error) {
+	// Use direct ISRC endpoint (API 2.0)
+	// https://api.deezer.com/2.0/track/isrc:{ISRC}
+	directURL := fmt.Sprintf("%s/track/isrc:%s", deezerBaseURL, isrc)
+
+	var track deezerTrack
+	if err := c.getJSON(ctx, directURL, &track); err != nil {
+		// Fallback to search if direct endpoint fails
+		searchURL := fmt.Sprintf("%s/track?q=isrc:%s&limit=1", deezerSearchURL, isrc)
+		var resp struct {
+			Data []deezerTrack `json:"data"`
+		}
+		if err := c.getJSON(ctx, searchURL, &resp); err != nil {
+			return nil, err
+		}
+		if len(resp.Data) == 0 {
+			return nil, fmt.Errorf("no track found for ISRC: %s", isrc)
+		}
+		result := c.convertTrack(resp.Data[0])
+		return &result, nil
+	}
+
+	// Check if we got a valid response (ID > 0)
+	if track.ID == 0 {
+		return nil, fmt.Errorf("no track found for ISRC: %s", isrc)
+	}
+
+	result := c.convertTrack(track)
+	return &result, nil
+}
+
+func (c *DeezerClient) fetchFullTrack(ctx context.Context, trackID string) (*deezerTrack, error) {
+	trackURL := fmt.Sprintf(deezerTrackURL, trackID)
+	var track deezerTrack
+	if err := c.getJSON(ctx, trackURL, &track); err != nil {
+		return nil, err
+	}
+	return &track, nil
+}
+
+// fetchISRCsParallel fetches ISRCs for multiple tracks in parallel with caching
+func (c *DeezerClient) fetchISRCsParallel(ctx context.Context, tracks []deezerTrack) map[string]string {
+	result := make(map[string]string)
+	var resultMu sync.Mutex
+
+	// First, check cache for existing ISRCs
+	var tracksToFetch []deezerTrack
+	c.cacheMu.RLock()
+	for _, track := range tracks {
+		trackIDStr := fmt.Sprintf("%d", track.ID)
+		if isrc, ok := c.isrcCache[trackIDStr]; ok {
+			result[trackIDStr] = isrc
+		} else {
+			tracksToFetch = append(tracksToFetch, track)
+		}
+	}
+	c.cacheMu.RUnlock()
+
+	if len(tracksToFetch) == 0 {
+		return result
+	}
+
+	// Use semaphore to limit concurrent requests
+	sem := make(chan struct{}, deezerMaxParallelISRC)
+	var wg sync.WaitGroup
+
+	for _, track := range tracksToFetch {
+		wg.Add(1)
+		go func(t deezerTrack) {
+			defer wg.Done()
+
+			// Acquire semaphore
+			select {
+			case sem <- struct{}{}:
+				defer func() { <-sem }()
+			case <-ctx.Done():
+				return
+			}
+
+			trackIDStr := fmt.Sprintf("%d", t.ID)
+			fullTrack, err := c.fetchFullTrack(ctx, trackIDStr)
+			if err != nil || fullTrack == nil {
+				return
+			}
+
+			// Store in result and cache
+			resultMu.Lock()
+			result[trackIDStr] = fullTrack.ISRC
+			resultMu.Unlock()
+
+			c.cacheMu.Lock()
+			c.isrcCache[trackIDStr] = fullTrack.ISRC
+			c.cacheMu.Unlock()
+		}(track)
+	}
+
+	wg.Wait()
+	return result
+}
+
+// GetTrackISRC fetches ISRC for a single track (with caching)
+// Use this when you need ISRC for download
+func (c *DeezerClient) GetTrackISRC(ctx context.Context, trackID string) (string, error) {
+	// Check cache first
+	c.cacheMu.RLock()
+	if isrc, ok := c.isrcCache[trackID]; ok {
+		c.cacheMu.RUnlock()
+		return isrc, nil
+	}
+	c.cacheMu.RUnlock()
+
+	// Fetch from API
+	fullTrack, err := c.fetchFullTrack(ctx, trackID)
+	if err != nil {
+		return "", err
+	}
+
+	// Cache the result
+	c.cacheMu.Lock()
+	c.isrcCache[trackID] = fullTrack.ISRC
+	c.cacheMu.Unlock()
+
+	return fullTrack.ISRC, nil
+}
+
+func (c *DeezerClient) getBestArtistImage(artist deezerArtist) string {
+	if artist.PictureXL != "" {
+		return artist.PictureXL
+	}
+	if artist.PictureBig != "" {
+		return artist.PictureBig
+	}
+	if artist.PictureMedium != "" {
+		return artist.PictureMedium
+	}
+	return artist.Picture
+}
+
+func (c *DeezerClient) getBestArtistImageFull(artist deezerArtistFull) string {
+	if artist.PictureXL != "" {
+		return artist.PictureXL
+	}
+	if artist.PictureBig != "" {
+		return artist.PictureBig
+	}
+	if artist.PictureMedium != "" {
+		return artist.PictureMedium
+	}
+	return artist.Picture
+}
+
+func (c *DeezerClient) getBestAlbumImage(album deezerAlbumFull) string {
+	if album.CoverXL != "" {
+		return album.CoverXL
+	}
+	if album.CoverBig != "" {
+		return album.CoverBig
+	}
+	if album.CoverMedium != "" {
+		return album.CoverMedium
+	}
+	return album.Cover
+}
+
+func (c *DeezerClient) getJSON(ctx context.Context, endpoint string, dst interface{}) error {
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, endpoint, nil)
+	if err != nil {
+		return err
+	}
+
+	req.Header.Set("Accept", "application/json")
+
+	resp, err := c.httpClient.Do(req)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return err
+	}
+
+	if resp.StatusCode != http.StatusOK {
+		return fmt.Errorf("deezer API returned status %d: %s", resp.StatusCode, string(body))
+	}
+
+	return json.Unmarshal(body, dst)
+}
+
+// parseDeezerURL is internal function, returns type and ID
+func parseDeezerURL(input string) (string, string, error) {
+	trimmed := strings.TrimSpace(input)
+	if trimmed == "" {
+		return "", "", fmt.Errorf("empty URL")
+	}
+
+	parsed, err := url.Parse(trimmed)
+	if err != nil {
+		return "", "", err
+	}
+
+	if parsed.Host != "www.deezer.com" && parsed.Host != "deezer.com" && parsed.Host != "deezer.page.link" {
+		return "", "", fmt.Errorf("not a Deezer URL")
+	}
+
+	parts := strings.Split(strings.Trim(parsed.Path, "/"), "/")
+
+	// Skip language prefix if present (e.g., /en/, /fr/)
+	if len(parts) > 0 && len(parts[0]) == 2 {
+		parts = parts[1:]
+	}
+
+	if len(parts) < 2 {
+		return "", "", fmt.Errorf("invalid Deezer URL format")
+	}
+
+	resourceType := parts[0]
+	resourceID := parts[1]
+
+	switch resourceType {
+	case "track", "album", "artist", "playlist":
+		return resourceType, resourceID, nil
+	default:
+		return "", "", fmt.Errorf("unsupported Deezer resource type: %s", resourceType)
+	}
+}
@@ -1,49 +1,144 @@
 package gobackend

 import (
+	"encoding/json"
+	"fmt"
 	"os"
 	"path/filepath"
 	"strings"
+	"sync"
+	"time"
 )

+// ISRCIndex holds a cached map of ISRC -> file path for fast duplicate checking
+type ISRCIndex struct {
+	index     map[string]string // ISRC (uppercase) -> file path
+	outputDir string
+	buildTime time.Time
+	mu        sync.RWMutex
+}
+
+// Global ISRC index cache (per output directory)
+var (
+	isrcIndexCache   = make(map[string]*ISRCIndex)
+	isrcIndexCacheMu sync.RWMutex
+	isrcIndexTTL     = 5 * time.Minute // Cache TTL - rebuild after 5 minutes
+)
+
+// GetISRCIndex returns or builds an ISRC index for the given directory
+func GetISRCIndex(outputDir string) *ISRCIndex {
+	isrcIndexCacheMu.RLock()
+	idx, exists := isrcIndexCache[outputDir]
+	isrcIndexCacheMu.RUnlock()
+
+	// Return cached index if still valid
+	if exists && time.Since(idx.buildTime) < isrcIndexTTL {
+		return idx
+	}
+
+	// Build new index
+	return buildISRCIndex(outputDir)
+}
+
+// buildISRCIndex scans a directory and builds a map of ISRC -> file path
+// Same implementation as PC version for consistency
+func buildISRCIndex(outputDir string) *ISRCIndex {
+	idx := &ISRCIndex{
+		index:     make(map[string]string),
+		outputDir: outputDir,
+		buildTime: time.Now(),
+	}
+
+	if outputDir == "" {
+		return idx
+	}
+
+	startTime := time.Now()
+	fileCount := 0
+
+	// Walk directory - only check .flac files
+	filepath.Walk(outputDir, func(path string, info os.FileInfo, err error) error {
+		if err != nil || info.IsDir() {
+			return nil
+		}
+
+		ext := strings.ToLower(filepath.Ext(path))
+		if ext != ".flac" {
+			return nil
+		}
+
+		// Read ISRC from file
+		metadata, err := ReadMetadata(path)
+		if err != nil || metadata.ISRC == "" {
+			return nil
+		}
+
+		// Store in index (uppercase for case-insensitive matching)
+		idx.index[strings.ToUpper(metadata.ISRC)] = path
+		fileCount++
+		return nil
+	})
+
+	fmt.Printf("[ISRCIndex] Built index for %s: %d files in %v\n", 
+		outputDir, fileCount, time.Since(startTime).Round(time.Millisecond))
+
+	// Cache the index
+	isrcIndexCacheMu.Lock()
+	isrcIndexCache[outputDir] = idx
+	isrcIndexCacheMu.Unlock()
+
+	return idx
+}
+
+// lookup checks if an ISRC exists in the index (internal, returns bool)
+func (idx *ISRCIndex) lookup(isrc string) (string, bool) {
+	if isrc == "" {
+		return "", false
+	}
+
+	idx.mu.RLock()
+	defer idx.mu.RUnlock()
+
+	path, exists := idx.index[strings.ToUpper(isrc)]
+	return path, exists
+}
+
+// Lookup checks if an ISRC exists in the index (gomobile compatible)
+// Returns filepath if found, empty string if not found
+func (idx *ISRCIndex) Lookup(isrc string) (string, error) {
+	path, _ := idx.lookup(isrc)
+	return path, nil
+}
+
+// Add adds a new ISRC to the index (call after successful download)
+func (idx *ISRCIndex) Add(isrc, filePath string) {
+	if isrc == "" || filePath == "" {
+		return
+	}
+
+	idx.mu.Lock()
+	defer idx.mu.Unlock()
+
+	idx.index[strings.ToUpper(isrc)] = filePath
+}
+
+// InvalidateCache clears the ISRC index cache for a directory
+func InvalidateISRCCache(outputDir string) {
+	isrcIndexCacheMu.Lock()
+	delete(isrcIndexCache, outputDir)
+	isrcIndexCacheMu.Unlock()
+}
+
 // checkISRCExistsInternal checks if a file with the given ISRC exists (internal use)
+// Uses ISRC index for fast lookup
 func checkISRCExistsInternal(outputDir, isrc string) (string, bool) {
 	if isrc == "" || outputDir == "" {
 		return "", false
 	}

-	// Walk through directory looking for FLAC files
-	var foundFile string
-	filepath.Walk(outputDir, func(path string, info os.FileInfo, err error) error {
-		if err != nil {
-			return nil
-		}
-
-		// Only check FLAC files
-		if info.IsDir() || !strings.HasSuffix(strings.ToLower(path), ".flac") {
-			return nil
-		}
-
-		// Read metadata from file
-		metadata, err := ReadMetadata(path)
-		if err != nil {
-			return nil
-		}
-
-		// Check if ISRC matches
-		if metadata.ISRC == isrc {
-			foundFile = path
-			return filepath.SkipAll // Stop walking
-		}
-
-		return nil
-	})
-
-	if foundFile != "" {
-		return foundFile, true
-	}
-
-	return "", false
+	// Use index for fast lookup
+	idx := GetISRCIndex(outputDir)
+	return idx.lookup(isrc)
 }

 // CheckISRCExists is the exported version for gomobile (returns string, error)
@@ -61,3 +156,98 @@ func CheckFileExists(filePath string) bool {
 	}
 	return !info.IsDir() && info.Size() > 0
 }
+
+// FileExistenceResult represents the result of checking if a file exists
+type FileExistenceResult struct {
+	ISRC       string `json:"isrc"`
+	Exists     bool   `json:"exists"`
+	FilePath   string `json:"file_path,omitempty"`
+	TrackName  string `json:"track_name,omitempty"`
+	ArtistName string `json:"artist_name,omitempty"`
+}
+
+// CheckFilesExistParallel checks if multiple files exist in parallel
+// It builds an ISRC index from the output directory once, then checks all tracks against it
+// Same implementation as PC version for consistency
+func CheckFilesExistParallel(outputDir string, tracksJSON string) (string, error) {
+	// Parse input JSON
+	var tracks []struct {
+		ISRC       string `json:"isrc"`
+		TrackName  string `json:"track_name"`
+		ArtistName string `json:"artist_name"`
+	}
+	if err := json.Unmarshal([]byte(tracksJSON), &tracks); err != nil {
+		return "", fmt.Errorf("failed to parse tracks JSON: %w", err)
+	}
+
+	results := make([]FileExistenceResult, len(tracks))
+
+	// Build ISRC index from output directory (scan once)
+	isrcIdx := GetISRCIndex(outputDir)
+
+	// Check each track against the index (parallel)
+	var wg sync.WaitGroup
+	for i, track := range tracks {
+		wg.Add(1)
+		go func(resultIdx int, t struct {
+			ISRC       string `json:"isrc"`
+			TrackName  string `json:"track_name"`
+			ArtistName string `json:"artist_name"`
+		}) {
+			defer wg.Done()
+
+			result := FileExistenceResult{
+				ISRC:       t.ISRC,
+				TrackName:  t.TrackName,
+				ArtistName: t.ArtistName,
+				Exists:     false,
+			}
+
+			if t.ISRC != "" {
+				if filePath, exists := isrcIdx.lookup(t.ISRC); exists {
+					result.Exists = true
+					result.FilePath = filePath
+				}
+			}
+
+			results[resultIdx] = result
+		}(i, track)
+	}
+
+	wg.Wait()
+
+	// Return results as JSON
+	resultJSON, err := json.Marshal(results)
+	if err != nil {
+		return "", fmt.Errorf("failed to marshal results: %w", err)
+	}
+
+	return string(resultJSON), nil
+}
+
+// PreBuildISRCIndex pre-builds the ISRC index for a directory
+// Call this when app starts or when entering album/playlist screen
+func PreBuildISRCIndex(outputDir string) error {
+	if outputDir == "" {
+		return fmt.Errorf("output directory is required")
+	}
+
+	buildISRCIndex(outputDir)
+	return nil
+}
+
+// AddToISRCIndex adds a new file to the ISRC index after successful download
+// This avoids rebuilding the entire index
+func AddToISRCIndex(outputDir, isrc, filePath string) {
+	if outputDir == "" || isrc == "" || filePath == "" {
+		return
+	}
+
+	isrcIndexCacheMu.RLock()
+	idx, exists := isrcIndexCache[outputDir]
+	isrcIndexCacheMu.RUnlock()
+
+	if exists {
+		idx.Add(isrc, filePath)
+	}
+}
@@ -0,0 +1,986 @@
+// Package gobackend provides extension management functionality
+package gobackend
+
+import (
+	"archive/zip"
+	"encoding/json"
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"sync"
+
+	"github.com/dop251/goja"
+)
+
+// compareVersions compares two semantic version strings
+// Returns: -1 if v1 < v2, 0 if v1 == v2, 1 if v1 > v2
+func compareVersions(v1, v2 string) int {
+	// Parse version parts
+	parts1 := strings.Split(strings.TrimPrefix(v1, "v"), ".")
+	parts2 := strings.Split(strings.TrimPrefix(v2, "v"), ".")
+
+	// Pad shorter version with zeros
+	maxLen := len(parts1)
+	if len(parts2) > maxLen {
+		maxLen = len(parts2)
+	}
+
+	for i := 0; i < maxLen; i++ {
+		var n1, n2 int
+		if i < len(parts1) {
+			n1, _ = strconv.Atoi(parts1[i])
+		}
+		if i < len(parts2) {
+			n2, _ = strconv.Atoi(parts2[i])
+		}
+
+		if n1 < n2 {
+			return -1
+		}
+		if n1 > n2 {
+			return 1
+		}
+	}
+
+	return 0
+}
+
+// LoadedExtension represents an extension that has been loaded into memory
+type LoadedExtension struct {
+	ID        string             `json:"id"`
+	Manifest  *ExtensionManifest `json:"manifest"`
+	VM        *goja.Runtime      `json:"-"` // Goja VM instance (not serialized)
+	Enabled   bool               `json:"enabled"`
+	Error     string             `json:"error,omitempty"`
+	DataDir   string             `json:"data_dir"`   // Extension's data directory
+	SourceDir string             `json:"source_dir"` // Where extension files are extracted
+	IconPath  string             `json:"icon_path"`  // Full path to icon file (if exists)
+}
+
+// ExtensionManager manages all loaded extensions
+type ExtensionManager struct {
+	mu            sync.RWMutex
+	extensions    map[string]*LoadedExtension
+	extensionsDir string // Base directory for extensions
+	dataDir       string // Base directory for extension data
+}
+
+// Global extension manager instance
+var (
+	globalExtManager     *ExtensionManager
+	globalExtManagerOnce sync.Once
+)
+
+// GetExtensionManager returns the global extension manager instance
+func GetExtensionManager() *ExtensionManager {
+	globalExtManagerOnce.Do(func() {
+		globalExtManager = &ExtensionManager{
+			extensions: make(map[string]*LoadedExtension),
+		}
+	})
+	return globalExtManager
+}
+
+// SetDirectories sets the extensions and data directories
+func (m *ExtensionManager) SetDirectories(extensionsDir, dataDir string) error {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	m.extensionsDir = extensionsDir
+	m.dataDir = dataDir
+
+	// Create directories if they don't exist
+	if err := os.MkdirAll(extensionsDir, 0755); err != nil {
+		return fmt.Errorf("failed to create extensions directory: %w", err)
+	}
+	if err := os.MkdirAll(dataDir, 0755); err != nil {
+		return fmt.Errorf("failed to create data directory: %w", err)
+	}
+
+	return nil
+}
+
+// LoadExtensionFromFile loads an extension from a .spotiflac-ext file
+func (m *ExtensionManager) LoadExtensionFromFile(filePath string) (*LoadedExtension, error) {
+	// Validate file extension
+	if !strings.HasSuffix(strings.ToLower(filePath), ".spotiflac-ext") {
+		return nil, fmt.Errorf("Invalid file format. Please select a .spotiflac-ext file")
+	}
+
+	// Open the zip file
+	zipReader, err := zip.OpenReader(filePath)
+	if err != nil {
+		return nil, fmt.Errorf("Cannot open extension file. The file may be corrupted or not a valid extension package")
+	}
+	defer zipReader.Close()
+
+	// Find and read manifest.json
+	var manifestData []byte
+	var hasIndexJS bool
+	for _, file := range zipReader.File {
+		name := filepath.Base(file.Name)
+		if name == "manifest.json" {
+			rc, err := file.Open()
+			if err != nil {
+				return nil, fmt.Errorf("failed to open manifest.json: %w", err)
+			}
+			manifestData, err = io.ReadAll(rc)
+			rc.Close()
+			if err != nil {
+				return nil, fmt.Errorf("failed to read manifest.json: %w", err)
+			}
+		}
+		if name == "index.js" {
+			hasIndexJS = true
+		}
+	}
+
+	if manifestData == nil {
+		return nil, fmt.Errorf("Invalid extension package: manifest.json not found")
+	}
+
+	if !hasIndexJS {
+		return nil, fmt.Errorf("Invalid extension package: index.js not found")
+	}
+
+	// Parse and validate manifest
+	manifest, err := ParseManifest(manifestData)
+	if err != nil {
+		return nil, fmt.Errorf("Invalid extension manifest: %w", err)
+	}
+
+	// Check if extension already loaded - if so, try upgrade (check without holding lock for long)
+	m.mu.RLock()
+	existing, exists := m.extensions[manifest.Name]
+	var existingVersion string
+	var existingDisplayName string
+	if exists {
+		existingVersion = existing.Manifest.Version
+		existingDisplayName = existing.Manifest.DisplayName
+	}
+	m.mu.RUnlock()
+
+	if exists {
+		// Check if this is an upgrade
+		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)
+		} else {
+			return nil, fmt.Errorf("Cannot downgrade '%s' from v%s to v%s", existingDisplayName, existingVersion, manifest.Version)
+		}
+	}
+
+	// Now acquire write lock for the rest of the operation
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	// Double-check extension wasn't added while we were waiting for lock
+	if _, exists := m.extensions[manifest.Name]; exists {
+		return nil, fmt.Errorf("Extension '%s' was installed by another process", manifest.DisplayName)
+	}
+
+	// Create extension directory
+	extDir := filepath.Join(m.extensionsDir, manifest.Name)
+	if err := os.MkdirAll(extDir, 0755); err != nil {
+		return nil, fmt.Errorf("failed to create extension directory: %w", err)
+	}
+
+	// Extract all files
+	for _, file := range zipReader.File {
+		if file.FileInfo().IsDir() {
+			continue
+		}
+
+		// Get relative path within the zip
+		destPath := filepath.Join(extDir, filepath.Base(file.Name))
+
+		// Create destination file
+		destFile, err := os.Create(destPath)
+		if err != nil {
+			return nil, fmt.Errorf("failed to create file %s: %w", destPath, err)
+		}
+
+		// Copy content
+		srcFile, err := file.Open()
+		if err != nil {
+			destFile.Close()
+			return nil, fmt.Errorf("failed to open file in archive: %w", err)
+		}
+
+		_, err = io.Copy(destFile, srcFile)
+		srcFile.Close()
+		destFile.Close()
+		if err != nil {
+			return nil, fmt.Errorf("failed to extract file: %w", err)
+		}
+	}
+
+	// Create data directory for extension
+	extDataDir := filepath.Join(m.dataDir, manifest.Name)
+	if err := os.MkdirAll(extDataDir, 0755); err != nil {
+		return nil, fmt.Errorf("failed to create extension data directory: %w", err)
+	}
+
+	// Create loaded extension
+	ext := &LoadedExtension{
+		ID:        manifest.Name,
+		Manifest:  manifest,
+		Enabled:   true,
+		DataDir:   extDataDir,
+		SourceDir: extDir,
+	}
+
+	// Initialize Goja VM
+	if err := m.initializeVM(ext); err != nil {
+		ext.Error = err.Error()
+		ext.Enabled = false
+		GoLog("[Extension] Failed to initialize VM for %s: %v\n", manifest.Name, err)
+	}
+
+	m.extensions[manifest.Name] = ext
+	GoLog("[Extension] Loaded extension: %s v%s\n", manifest.DisplayName, manifest.Version)
+
+	return ext, nil
+}
+
+// initializeVM creates and initializes the Goja VM for an extension
+func (m *ExtensionManager) initializeVM(ext *LoadedExtension) error {
+	// Create new Goja runtime
+	vm := goja.New()
+	ext.VM = vm
+
+	// Read index.js
+	indexPath := filepath.Join(ext.SourceDir, "index.js")
+	jsCode, err := os.ReadFile(indexPath)
+	if err != nil {
+		return fmt.Errorf("failed to read index.js: %w", err)
+	}
+
+	// Create extension runtime and register sandboxed APIs
+	runtime := NewExtensionRuntime(ext)
+	runtime.RegisterAPIs(vm)
+	runtime.RegisterGoBackendAPIs(vm)
+
+	// Set up console.log for debugging
+	console := vm.NewObject()
+	console.Set("log", func(call goja.FunctionCall) goja.Value {
+		args := make([]interface{}, len(call.Arguments))
+		for i, arg := range call.Arguments {
+			args[i] = arg.Export()
+		}
+		GoLog("[Extension:%s] %v\n", ext.ID, args)
+		return goja.Undefined()
+	})
+	vm.Set("console", console)
+
+	// Set up registerExtension function
+	var registeredExtension goja.Value
+	vm.Set("registerExtension", func(call goja.FunctionCall) goja.Value {
+		if len(call.Arguments) > 0 {
+			registeredExtension = call.Arguments[0]
+			// Also set it as global 'extension' variable for later access
+			vm.Set("extension", call.Arguments[0])
+		}
+		return goja.Undefined()
+	})
+
+	// Run the extension code
+	_, err = vm.RunString(string(jsCode))
+	if err != nil {
+		return fmt.Errorf("failed to execute extension code: %w", err)
+	}
+
+	// Verify extension was registered
+	if registeredExtension == nil || goja.IsUndefined(registeredExtension) {
+		return fmt.Errorf("extension did not call registerExtension()")
+	}
+
+	return nil
+}
+
+// UnloadExtension unloads an extension by ID
+func (m *ExtensionManager) UnloadExtension(extensionID string) error {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	ext, exists := m.extensions[extensionID]
+	if !exists {
+		return fmt.Errorf("Extension not found")
+	}
+
+	// Call cleanup if VM is initialized
+	if ext.VM != nil {
+		// Try to call cleanup function
+		cleanup, err := ext.VM.RunString("typeof extension !== 'undefined' && typeof extension.cleanup === 'function' ? extension.cleanup() : null")
+		if err != nil {
+			GoLog("[Extension] Error calling cleanup for %s: %v\n", extensionID, err)
+		} else if cleanup != nil && !goja.IsUndefined(cleanup) && !goja.IsNull(cleanup) {
+			GoLog("[Extension] Cleanup called for %s\n", extensionID)
+		}
+	}
+
+	// Remove from registry
+	delete(m.extensions, extensionID)
+	GoLog("[Extension] Unloaded extension: %s\n", extensionID)
+
+	return nil
+}
+
+// GetExtension returns a loaded extension by ID
+// Returns error if extension not found (gomobile compatible)
+func (m *ExtensionManager) GetExtension(extensionID string) (*LoadedExtension, error) {
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+
+	ext, exists := m.extensions[extensionID]
+	if !exists {
+		return nil, fmt.Errorf("Extension not found")
+	}
+	return ext, nil
+}
+
+// GetAllExtensions returns all loaded extensions
+func (m *ExtensionManager) GetAllExtensions() []*LoadedExtension {
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+
+	result := make([]*LoadedExtension, 0, len(m.extensions))
+	for _, ext := range m.extensions {
+		result = append(result, ext)
+	}
+	return result
+}
+
+// SetExtensionEnabled enables or disables an extension
+func (m *ExtensionManager) SetExtensionEnabled(extensionID string, enabled bool) error {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	ext, exists := m.extensions[extensionID]
+	if !exists {
+		return fmt.Errorf("Extension not found")
+	}
+
+	ext.Enabled = enabled
+	GoLog("[Extension] %s %s\n", extensionID, map[bool]string{true: "enabled", false: "disabled"}[enabled])
+
+	// Persist enabled state to settings store
+	store := GetExtensionSettingsStore()
+	if err := store.Set(extensionID, "_enabled", enabled); err != nil {
+		GoLog("[Extension] Failed to persist enabled state for %s: %v\n", extensionID, err)
+	}
+
+	return nil
+}
+
+// LoadExtensionsFromDirectory scans a directory and loads all valid extensions
+func (m *ExtensionManager) LoadExtensionsFromDirectory(dirPath string) ([]string, []error) {
+	var loaded []string
+	var errors []error
+
+	entries, err := os.ReadDir(dirPath)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return loaded, errors
+		}
+		return nil, []error{fmt.Errorf("failed to read extensions directory: %w", err)}
+	}
+
+	for _, entry := range entries {
+		if entry.IsDir() {
+			// Check if it's an extracted extension directory
+			manifestPath := filepath.Join(dirPath, entry.Name(), "manifest.json")
+			if _, err := os.Stat(manifestPath); err == nil {
+				ext, err := m.loadExtensionFromDirectory(filepath.Join(dirPath, entry.Name()))
+				if err != nil {
+					GoLog("[Extension] Failed to load %s: %v\n", entry.Name(), err)
+					errors = append(errors, fmt.Errorf("%s: %w", entry.Name(), err))
+				} else {
+					loaded = append(loaded, ext.ID)
+				}
+			}
+		} else if strings.HasSuffix(strings.ToLower(entry.Name()), ".spotiflac-ext") {
+			// Load from package file
+			ext, err := m.LoadExtensionFromFile(filepath.Join(dirPath, entry.Name()))
+			if err != nil {
+				GoLog("[Extension] Failed to load %s: %v\n", entry.Name(), err)
+				errors = append(errors, fmt.Errorf("%s: %w", entry.Name(), err))
+			} else {
+				loaded = append(loaded, ext.ID)
+			}
+		}
+	}
+
+	return loaded, errors
+}
+
+// loadExtensionFromDirectory loads an extension from an already extracted directory
+func (m *ExtensionManager) loadExtensionFromDirectory(dirPath string) (*LoadedExtension, error) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	// Read manifest
+	manifestPath := filepath.Join(dirPath, "manifest.json")
+	manifestData, err := os.ReadFile(manifestPath)
+	if err != nil {
+		return nil, fmt.Errorf("failed to read manifest.json: %w", err)
+	}
+
+	// Parse and validate manifest
+	manifest, err := ParseManifest(manifestData)
+	if err != nil {
+		return nil, fmt.Errorf("Invalid extension manifest: %w", err)
+	}
+
+	// Check if index.js exists
+	indexPath := filepath.Join(dirPath, "index.js")
+	if _, err := os.Stat(indexPath); os.IsNotExist(err) {
+		return nil, fmt.Errorf("Extension is missing index.js file")
+	}
+
+	// Check if extension already loaded - skip if already exists (for directory loading on startup)
+	if _, exists := m.extensions[manifest.Name]; exists {
+		return nil, fmt.Errorf("Extension '%s' is already loaded", manifest.DisplayName)
+	}
+
+	// Create data directory for extension
+	extDataDir := filepath.Join(m.dataDir, manifest.Name)
+	if err := os.MkdirAll(extDataDir, 0755); err != nil {
+		return nil, fmt.Errorf("failed to create extension data directory: %w", err)
+	}
+
+	// Create loaded extension
+	ext := &LoadedExtension{
+		ID:        manifest.Name,
+		Manifest:  manifest,
+		Enabled:   true,
+		DataDir:   extDataDir,
+		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 {
+			ext.Enabled = enabled
+			GoLog("[Extension] Restored enabled state for %s: %v\n", manifest.Name, enabled)
+		}
+	}
+
+	// Initialize Goja VM
+	if err := m.initializeVM(ext); err != nil {
+		ext.Error = err.Error()
+		ext.Enabled = false
+		GoLog("[Extension] Failed to initialize VM for %s: %v\n", manifest.Name, err)
+	}
+
+	m.extensions[manifest.Name] = ext
+	GoLog("[Extension] Loaded extension: %s v%s\n", manifest.DisplayName, manifest.Version)
+
+	return ext, nil
+}
+
+// RemoveExtension completely removes an extension (unload + delete files)
+func (m *ExtensionManager) RemoveExtension(extensionID string) error {
+	ext, err := m.GetExtension(extensionID)
+	if err != nil {
+		return err
+	}
+
+	// Unload first
+	if err := m.UnloadExtension(extensionID); err != nil {
+		return err
+	}
+
+	// Remove source directory
+	if ext.SourceDir != "" {
+		if err := os.RemoveAll(ext.SourceDir); err != nil {
+			GoLog("[Extension] Warning: failed to remove source dir: %v\n", err)
+		}
+	}
+
+	// Optionally remove data directory (keep for now to preserve settings)
+	// if ext.DataDir != "" {
+	//     os.RemoveAll(ext.DataDir)
+	// }
+
+	return nil
+}
+
+// UpgradeExtension upgrades an existing extension from a new package file
+// Only allows upgrades (new version > current version), not downgrades
+func (m *ExtensionManager) UpgradeExtension(filePath string) (*LoadedExtension, error) {
+	// Validate file extension
+	if !strings.HasSuffix(strings.ToLower(filePath), ".spotiflac-ext") {
+		return nil, fmt.Errorf("Invalid file format. Please select a .spotiflac-ext file")
+	}
+
+	// Open the zip file
+	zipReader, err := zip.OpenReader(filePath)
+	if err != nil {
+		return nil, fmt.Errorf("Cannot open extension file. The file may be corrupted or not a valid extension package")
+	}
+	defer zipReader.Close()
+
+	// Find and read manifest.json
+	var manifestData []byte
+	var hasIndexJS bool
+	for _, file := range zipReader.File {
+		name := filepath.Base(file.Name)
+		if name == "manifest.json" {
+			rc, err := file.Open()
+			if err != nil {
+				return nil, fmt.Errorf("failed to open manifest.json: %w", err)
+			}
+			manifestData, err = io.ReadAll(rc)
+			rc.Close()
+			if err != nil {
+				return nil, fmt.Errorf("failed to read manifest.json: %w", err)
+			}
+		}
+		if name == "index.js" {
+			hasIndexJS = true
+		}
+	}
+
+	if manifestData == nil {
+		return nil, fmt.Errorf("Invalid extension package: manifest.json not found")
+	}
+
+	if !hasIndexJS {
+		return nil, fmt.Errorf("Invalid extension package: index.js not found")
+	}
+
+	// Parse and validate manifest
+	newManifest, err := ParseManifest(manifestData)
+	if err != nil {
+		return nil, fmt.Errorf("Invalid extension manifest: %w", err)
+	}
+
+	// Check if extension exists
+	m.mu.RLock()
+	existing, exists := m.extensions[newManifest.Name]
+	m.mu.RUnlock()
+
+	if !exists {
+		return nil, fmt.Errorf("Extension '%s' is not installed. Use install instead of upgrade.", newManifest.DisplayName)
+	}
+
+	// Compare versions - only allow upgrade, not downgrade
+	versionCompare := compareVersions(newManifest.Version, existing.Manifest.Version)
+	if versionCompare < 0 {
+		return nil, fmt.Errorf("Cannot downgrade extension. Current version: %s, New version: %s", existing.Manifest.Version, newManifest.Version)
+	}
+	if versionCompare == 0 {
+		return nil, fmt.Errorf("Extension is already at version %s", existing.Manifest.Version)
+	}
+
+	GoLog("[Extension] Upgrading %s from v%s to v%s\n", newManifest.DisplayName, existing.Manifest.Version, newManifest.Version)
+
+	// Save data directory path (we want to preserve it)
+	extDataDir := existing.DataDir
+	extDir := existing.SourceDir
+
+	// Cleanup and unload existing extension
+	m.CleanupExtension(existing.ID)
+	m.UnloadExtension(existing.ID)
+
+	// Remove old source files but keep data directory
+	if extDir != "" {
+		if err := os.RemoveAll(extDir); err != nil {
+			GoLog("[Extension] Warning: failed to remove old source dir: %v\n", err)
+		}
+	}
+
+	// Recreate extension directory
+	if err := os.MkdirAll(extDir, 0755); err != nil {
+		return nil, fmt.Errorf("failed to create extension directory: %w", err)
+	}
+
+	// Extract all files from new package
+	for _, file := range zipReader.File {
+		if file.FileInfo().IsDir() {
+			continue
+		}
+
+		// Get relative path within the zip
+		destPath := filepath.Join(extDir, filepath.Base(file.Name))
+
+		// Create destination file
+		destFile, err := os.Create(destPath)
+		if err != nil {
+			return nil, fmt.Errorf("failed to create file %s: %w", destPath, err)
+		}
+
+		// Copy content
+		srcFile, err := file.Open()
+		if err != nil {
+			destFile.Close()
+			return nil, fmt.Errorf("failed to open file in archive: %w", err)
+		}
+
+		_, err = io.Copy(destFile, srcFile)
+		srcFile.Close()
+		destFile.Close()
+		if err != nil {
+			return nil, fmt.Errorf("failed to extract file: %w", err)
+		}
+	}
+
+	// Create new loaded extension (reusing data directory)
+	ext := &LoadedExtension{
+		ID:        newManifest.Name,
+		Manifest:  newManifest,
+		Enabled:   true,
+		DataDir:   extDataDir,
+		SourceDir: extDir,
+	}
+
+	// Initialize Goja VM
+	if err := m.initializeVM(ext); err != nil {
+		ext.Error = err.Error()
+		ext.Enabled = false
+		GoLog("[Extension] Failed to initialize VM for %s: %v\n", newManifest.Name, err)
+	}
+
+	m.mu.Lock()
+	m.extensions[newManifest.Name] = ext
+	m.mu.Unlock()
+
+	GoLog("[Extension] Upgraded extension: %s to v%s\n", newManifest.DisplayName, newManifest.Version)
+
+	return ext, nil
+}
+
+// ExtensionUpgradeInfo holds information about extension upgrade check
+type ExtensionUpgradeInfo struct {
+	ExtensionID    string `json:"extension_id"`
+	CurrentVersion string `json:"current_version"`
+	NewVersion     string `json:"new_version"`
+	CanUpgrade     bool   `json:"can_upgrade"`
+	IsInstalled    bool   `json:"is_installed"`
+}
+
+// checkExtensionUpgradeInternal checks if a package file is an upgrade for an existing extension
+// Internal function that returns struct
+func (m *ExtensionManager) checkExtensionUpgradeInternal(filePath string) (*ExtensionUpgradeInfo, error) {
+	// Validate file extension
+	if !strings.HasSuffix(strings.ToLower(filePath), ".spotiflac-ext") {
+		return nil, fmt.Errorf("Invalid file format")
+	}
+
+	// Open the zip file
+	zipReader, err := zip.OpenReader(filePath)
+	if err != nil {
+		return nil, fmt.Errorf("Cannot open extension file")
+	}
+	defer zipReader.Close()
+
+	// Find and read manifest.json
+	var manifestData []byte
+	for _, file := range zipReader.File {
+		name := filepath.Base(file.Name)
+		if name == "manifest.json" {
+			rc, err := file.Open()
+			if err != nil {
+				return nil, fmt.Errorf("failed to open manifest.json")
+			}
+			manifestData, err = io.ReadAll(rc)
+			rc.Close()
+			if err != nil {
+				return nil, fmt.Errorf("failed to read manifest.json")
+			}
+			break
+		}
+	}
+
+	if manifestData == nil {
+		return nil, fmt.Errorf("manifest.json not found")
+	}
+
+	// Parse manifest
+	newManifest, err := ParseManifest(manifestData)
+	if err != nil {
+		return nil, fmt.Errorf("Invalid manifest: %w", err)
+	}
+
+	// Check if extension exists
+	m.mu.RLock()
+	existing, exists := m.extensions[newManifest.Name]
+	m.mu.RUnlock()
+
+	info := &ExtensionUpgradeInfo{
+		ExtensionID: newManifest.Name,
+		NewVersion:  newManifest.Version,
+		IsInstalled: exists,
+	}
+
+	if !exists {
+		// Not installed - this is a new install, not upgrade
+		info.CurrentVersion = ""
+		info.CanUpgrade = false
+	} else {
+		// Compare versions
+		info.CurrentVersion = existing.Manifest.Version
+		info.CanUpgrade = compareVersions(newManifest.Version, existing.Manifest.Version) > 0
+	}
+
+	return info, nil
+}
+
+// CheckExtensionUpgradeJSON checks if a package file is an upgrade and returns JSON
+func (m *ExtensionManager) CheckExtensionUpgradeJSON(filePath string) (string, error) {
+	info, err := m.checkExtensionUpgradeInternal(filePath)
+	if err != nil {
+		return "", err
+	}
+
+	jsonBytes, err := json.Marshal(info)
+	if err != nil {
+		return "", err
+	}
+
+	return string(jsonBytes), nil
+}
+
+// GetInstalledExtensionsJSON returns all extensions as JSON for Flutter
+func (m *ExtensionManager) GetInstalledExtensionsJSON() (string, error) {
+	extensions := m.GetAllExtensions()
+
+	type ExtensionInfo struct {
+		ID                     string                `json:"id"`
+		Name                   string                `json:"name"`
+		DisplayName            string                `json:"display_name"`
+		Version                string                `json:"version"`
+		Author                 string                `json:"author"`
+		Description            string                `json:"description"`
+		Homepage               string                `json:"homepage,omitempty"`
+		IconPath               string                `json:"icon_path,omitempty"`
+		Types                  []ExtensionType       `json:"types"`
+		Enabled                bool                  `json:"enabled"`
+		Status                 string                `json:"status"`
+		Error                  string                `json:"error_message,omitempty"`
+		Settings               []ExtensionSetting    `json:"settings,omitempty"`
+		QualityOptions         []QualityOption       `json:"quality_options,omitempty"`
+		Permissions            []string              `json:"permissions"`
+		HasMetadataProvider    bool                  `json:"has_metadata_provider"`
+		HasDownloadProvider    bool                  `json:"has_download_provider"`
+		SkipMetadataEnrichment bool                  `json:"skip_metadata_enrichment"`
+		SearchBehavior         *SearchBehaviorConfig `json:"search_behavior,omitempty"`
+		TrackMatching          *TrackMatchingConfig  `json:"track_matching,omitempty"`
+		PostProcessing         *PostProcessingConfig `json:"post_processing,omitempty"`
+	}
+
+	infos := make([]ExtensionInfo, len(extensions))
+	for i, ext := range extensions {
+		// Build permissions list
+		permissions := []string{}
+		for _, domain := range ext.Manifest.Permissions.Network {
+			permissions = append(permissions, "network:"+domain)
+		}
+		if ext.Manifest.Permissions.Storage {
+			permissions = append(permissions, "storage:enabled")
+		}
+
+		// Determine status
+		status := "loaded"
+		if ext.Error != "" {
+			status = "error"
+		} else if !ext.Enabled {
+			status = "disabled"
+		}
+
+		// Check for icon file
+		iconPath := ""
+		if ext.Manifest.Icon != "" && ext.SourceDir != "" {
+			possibleIcon := filepath.Join(ext.SourceDir, ext.Manifest.Icon)
+			if _, err := os.Stat(possibleIcon); err == nil {
+				iconPath = possibleIcon
+			}
+		}
+		// Fallback: check for icon.png if not specified in manifest
+		if iconPath == "" && ext.SourceDir != "" {
+			possibleIcon := filepath.Join(ext.SourceDir, "icon.png")
+			if _, err := os.Stat(possibleIcon); err == nil {
+				iconPath = possibleIcon
+			}
+		}
+
+		infos[i] = ExtensionInfo{
+			ID:                     ext.ID,
+			Name:                   ext.Manifest.Name,
+			DisplayName:            ext.Manifest.DisplayName,
+			Version:                ext.Manifest.Version,
+			Author:                 ext.Manifest.Author,
+			Description:            ext.Manifest.Description,
+			Homepage:               ext.Manifest.Homepage,
+			IconPath:               iconPath,
+			Types:                  ext.Manifest.Types,
+			Enabled:                ext.Enabled,
+			Status:                 status,
+			Error:                  ext.Error,
+			Settings:               ext.Manifest.Settings,
+			QualityOptions:         ext.Manifest.QualityOptions,
+			Permissions:            permissions,
+			HasMetadataProvider:    ext.Manifest.IsMetadataProvider(),
+			HasDownloadProvider:    ext.Manifest.IsDownloadProvider(),
+			SkipMetadataEnrichment: ext.Manifest.SkipMetadataEnrichment,
+			SearchBehavior:         ext.Manifest.SearchBehavior,
+			TrackMatching:          ext.Manifest.TrackMatching,
+			PostProcessing:         ext.Manifest.PostProcessing,
+		}
+	}
+
+	jsonBytes, err := json.Marshal(infos)
+	if err != nil {
+		return "", err
+	}
+
+	return string(jsonBytes), nil
+}
+
+// ==================== Extension Lifecycle ====================
+
+// InitializeExtension calls the extension's initialize method with settings
+func (m *ExtensionManager) InitializeExtension(extensionID string, settings map[string]interface{}) error {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	ext, exists := m.extensions[extensionID]
+	if !exists {
+		return fmt.Errorf("Extension not found")
+	}
+
+	if ext.VM == nil {
+		return fmt.Errorf("Extension failed to load. Please reinstall the extension")
+	}
+
+	// Convert settings to JSON for passing to JS
+	settingsJSON, err := json.Marshal(settings)
+	if err != nil {
+		return fmt.Errorf("Failed to save settings")
+	}
+
+	// Call initialize function
+	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
+	}
+
+	// Check result
+	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
+}
+
+// CleanupExtension calls the extension's cleanup method
+func (m *ExtensionManager) CleanupExtension(extensionID string) error {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	ext, exists := m.extensions[extensionID]
+	if !exists {
+		return fmt.Errorf("Extension not found")
+	}
+
+	if ext.VM == nil {
+		return nil // No VM, nothing to cleanup
+	}
+
+	// Call cleanup function
+	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
+	}
+
+	// Check result
+	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
+}
+
+// UnloadAllExtensions unloads all extensions gracefully
+func (m *ExtensionManager) UnloadAllExtensions() {
+	m.mu.Lock()
+	extensionIDs := make([]string, 0, len(m.extensions))
+	for id := range m.extensions {
+		extensionIDs = append(extensionIDs, id)
+	}
+	m.mu.Unlock()
+
+	for _, id := range extensionIDs {
+		// Call cleanup first
+		m.CleanupExtension(id)
+		// Then unload
+		m.UnloadExtension(id)
+	}
+
+	GoLog("[Extension] All extensions unloaded\n")
+}
@@ -0,0 +1,284 @@
+// Package gobackend provides extension manifest parsing and validation
+package gobackend
+
+import (
+	"encoding/json"
+	"fmt"
+	"strings"
+)
+
+// ExtensionType represents the type of extension
+type ExtensionType string
+
+const (
+	ExtensionTypeMetadataProvider ExtensionType = "metadata_provider"
+	ExtensionTypeDownloadProvider ExtensionType = "download_provider"
+)
+
+// SettingType represents the type of a setting field
+type SettingType string
+
+const (
+	SettingTypeString SettingType = "string"
+	SettingTypeNumber SettingType = "number"
+	SettingTypeBool   SettingType = "boolean"
+	SettingTypeSelect SettingType = "select"
+)
+
+// ExtensionPermissions defines what resources an extension can access
+type ExtensionPermissions struct {
+	Network []string `json:"network"` // List of allowed domains
+	Storage bool     `json:"storage"` // Whether extension can use storage API
+}
+
+// ExtensionSetting defines a configurable setting for an extension
+type ExtensionSetting struct {
+	Key         string      `json:"key"`
+	Type        SettingType `json:"type"`
+	Label       string      `json:"label"`
+	Description string      `json:"description,omitempty"`
+	Required    bool        `json:"required,omitempty"`
+	Secret      bool        `json:"secret,omitempty"`
+	Default     interface{} `json:"default,omitempty"`
+	Options     []string    `json:"options,omitempty"` // For select type
+}
+
+// QualityOption represents a quality option for download providers
+type QualityOption struct {
+	ID          string                   `json:"id"`                 // Unique identifier (e.g., "mp3_320", "opus_128")
+	Label       string                   `json:"label"`              // Display name (e.g., "MP3 320kbps")
+	Description string                   `json:"description"`        // Optional description (e.g., "Best quality MP3")
+	Settings    []QualitySpecificSetting `json:"settings,omitempty"` // Quality-specific settings
+}
+
+// QualitySpecificSetting represents a setting that's specific to a quality option
+type QualitySpecificSetting struct {
+	Key         string      `json:"key"`
+	Type        SettingType `json:"type"`
+	Label       string      `json:"label"`
+	Description string      `json:"description,omitempty"`
+	Required    bool        `json:"required,omitempty"`
+	Secret      bool        `json:"secret,omitempty"`
+	Default     interface{} `json:"default,omitempty"`
+	Options     []string    `json:"options,omitempty"` // For select type
+}
+
+// SearchBehaviorConfig defines custom search behavior for an extension
+type SearchBehaviorConfig struct {
+	Enabled         bool   `json:"enabled"`                   // Whether extension provides custom search
+	Placeholder     string `json:"placeholder,omitempty"`     // Placeholder text for search box
+	Primary         bool   `json:"primary,omitempty"`         // If true, show as primary search tab
+	Icon            string `json:"icon,omitempty"`            // Icon for search tab
+	ThumbnailRatio  string `json:"thumbnailRatio,omitempty"`  // Thumbnail aspect ratio: "square" (1:1), "wide" (16:9), "portrait" (2:3)
+	ThumbnailWidth  int    `json:"thumbnailWidth,omitempty"`  // Custom thumbnail width in pixels
+	ThumbnailHeight int    `json:"thumbnailHeight,omitempty"` // Custom thumbnail height in pixels
+}
+
+// TrackMatchingConfig defines custom track matching behavior
+type TrackMatchingConfig struct {
+	CustomMatching    bool   `json:"customMatching"`              // Whether extension handles matching
+	Strategy          string `json:"strategy,omitempty"`          // "isrc", "name", "duration", "custom"
+	DurationTolerance int    `json:"durationTolerance,omitempty"` // Tolerance in seconds for duration matching
+}
+
+// PostProcessingHook defines a post-processing hook
+type PostProcessingHook struct {
+	ID               string   `json:"id"`                         // Unique identifier
+	Name             string   `json:"name"`                       // Display name
+	Description      string   `json:"description,omitempty"`      // Description
+	DefaultEnabled   bool     `json:"defaultEnabled,omitempty"`   // Whether enabled by default
+	SupportedFormats []string `json:"supportedFormats,omitempty"` // Supported file formats (e.g., ["flac", "mp3"])
+}
+
+// PostProcessingConfig defines post-processing capabilities
+type PostProcessingConfig struct {
+	Enabled bool                 `json:"enabled"`         // Whether extension provides post-processing
+	Hooks   []PostProcessingHook `json:"hooks,omitempty"` // Available hooks
+}
+
+// ExtensionManifest represents the manifest.json of an extension
+type ExtensionManifest struct {
+	Name                   string                `json:"name"`
+	DisplayName            string                `json:"displayName"`
+	Version                string                `json:"version"`
+	Author                 string                `json:"author"`
+	Description            string                `json:"description"`
+	Homepage               string                `json:"homepage,omitempty"`
+	Icon                   string                `json:"icon,omitempty"` // Icon filename (e.g., "icon.png")
+	Types                  []ExtensionType       `json:"type"`
+	Permissions            ExtensionPermissions  `json:"permissions"`
+	Settings               []ExtensionSetting    `json:"settings,omitempty"`
+	QualityOptions         []QualityOption       `json:"qualityOptions,omitempty"` // Custom quality options for download providers
+	MinAppVersion          string                `json:"minAppVersion,omitempty"`
+	SkipMetadataEnrichment bool                  `json:"skipMetadataEnrichment,omitempty"` // If true, don't enrich metadata from Deezer/Spotify
+	SkipBuiltInFallback    bool                  `json:"skipBuiltInFallback,omitempty"`    // If true, don't fallback to built-in providers (tidal/qobuz/amazon)
+	SearchBehavior         *SearchBehaviorConfig `json:"searchBehavior,omitempty"`         // Custom search behavior
+	TrackMatching          *TrackMatchingConfig  `json:"trackMatching,omitempty"`          // Custom track matching
+	PostProcessing         *PostProcessingConfig `json:"postProcessing,omitempty"`         // Post-processing hooks
+}
+
+// ManifestValidationError represents a validation error in the manifest
+type ManifestValidationError struct {
+	Field   string
+	Message string
+}
+
+func (e *ManifestValidationError) Error() string {
+	return fmt.Sprintf("manifest validation error: %s - %s", e.Field, e.Message)
+}
+
+// ParseManifest parses and validates a manifest from JSON bytes
+func ParseManifest(data []byte) (*ExtensionManifest, error) {
+	var manifest ExtensionManifest
+	if err := json.Unmarshal(data, &manifest); err != nil {
+		return nil, fmt.Errorf("failed to parse manifest JSON: %w", err)
+	}
+
+	if err := manifest.Validate(); err != nil {
+		return nil, err
+	}
+
+	return &manifest, nil
+}
+
+// Validate checks if the manifest has all required fields and valid values
+func (m *ExtensionManifest) Validate() error {
+	// Check required fields
+	if strings.TrimSpace(m.Name) == "" {
+		return &ManifestValidationError{Field: "name", Message: "name is required"}
+	}
+
+	if strings.TrimSpace(m.Version) == "" {
+		return &ManifestValidationError{Field: "version", Message: "version is required"}
+	}
+
+	if strings.TrimSpace(m.Author) == "" {
+		return &ManifestValidationError{Field: "author", Message: "author is required"}
+	}
+
+	if strings.TrimSpace(m.Description) == "" {
+		return &ManifestValidationError{Field: "description", Message: "description is required"}
+	}
+
+	if len(m.Types) == 0 {
+		return &ManifestValidationError{Field: "type", Message: "at least one type is required"}
+	}
+
+	// Validate extension types
+	for _, t := range m.Types {
+		if t != ExtensionTypeMetadataProvider && t != ExtensionTypeDownloadProvider {
+			return &ManifestValidationError{
+				Field:   "type",
+				Message: fmt.Sprintf("invalid extension type: %s (must be 'metadata_provider' or 'download_provider')", t),
+			}
+		}
+	}
+
+	// Validate settings if present
+	for i, setting := range m.Settings {
+		if strings.TrimSpace(setting.Key) == "" {
+			return &ManifestValidationError{
+				Field:   fmt.Sprintf("settings[%d].key", i),
+				Message: "setting key is required",
+			}
+		}
+
+		if setting.Type == "" {
+			return &ManifestValidationError{
+				Field:   fmt.Sprintf("settings[%d].type", i),
+				Message: "setting type is required",
+			}
+		}
+
+		// Validate setting type
+		validTypes := map[SettingType]bool{
+			SettingTypeString: true,
+			SettingTypeNumber: true,
+			SettingTypeBool:   true,
+			SettingTypeSelect: true,
+		}
+		if !validTypes[setting.Type] {
+			return &ManifestValidationError{
+				Field:   fmt.Sprintf("settings[%d].type", i),
+				Message: fmt.Sprintf("invalid setting type: %s", setting.Type),
+			}
+		}
+
+		// Select type requires options
+		if setting.Type == SettingTypeSelect && len(setting.Options) == 0 {
+			return &ManifestValidationError{
+				Field:   fmt.Sprintf("settings[%d].options", i),
+				Message: "select type requires options",
+			}
+		}
+	}
+
+	return nil
+}
+
+// HasType checks if the extension has a specific type
+func (m *ExtensionManifest) HasType(t ExtensionType) bool {
+	for _, et := range m.Types {
+		if et == t {
+			return true
+		}
+	}
+	return false
+}
+
+// IsMetadataProvider returns true if extension provides metadata
+func (m *ExtensionManifest) IsMetadataProvider() bool {
+	return m.HasType(ExtensionTypeMetadataProvider)
+}
+
+// IsDownloadProvider returns true if extension provides downloads
+func (m *ExtensionManifest) IsDownloadProvider() bool {
+	return m.HasType(ExtensionTypeDownloadProvider)
+}
+
+// IsDomainAllowed checks if a domain is in the allowed network permissions
+func (m *ExtensionManifest) IsDomainAllowed(domain string) bool {
+	domain = strings.ToLower(strings.TrimSpace(domain))
+	for _, allowed := range m.Permissions.Network {
+		allowed = strings.ToLower(strings.TrimSpace(allowed))
+		if allowed == domain {
+			return true
+		}
+		// Support wildcard subdomains (e.g., *.example.com)
+		if strings.HasPrefix(allowed, "*.") {
+			suffix := allowed[1:] // Remove the *
+			if strings.HasSuffix(domain, suffix) {
+				return true
+			}
+		}
+	}
+	return false
+}
+
+// HasCustomSearch returns true if extension provides custom search
+func (m *ExtensionManifest) HasCustomSearch() bool {
+	return m.SearchBehavior != nil && m.SearchBehavior.Enabled
+}
+
+// HasCustomMatching returns true if extension provides custom track matching
+func (m *ExtensionManifest) HasCustomMatching() bool {
+	return m.TrackMatching != nil && m.TrackMatching.CustomMatching
+}
+
+// HasPostProcessing returns true if extension provides post-processing
+func (m *ExtensionManifest) HasPostProcessing() bool {
+	return m.PostProcessing != nil && m.PostProcessing.Enabled
+}
+
+// GetPostProcessingHooks returns all post-processing hooks
+func (m *ExtensionManifest) GetPostProcessingHooks() []PostProcessingHook {
+	if m.PostProcessing == nil {
+		return nil
+	}
+	return m.PostProcessing.Hooks
+}
+
+// ToJSON serializes the manifest to JSON
+func (m *ExtensionManifest) ToJSON() ([]byte, error) {
+	return json.Marshal(m)
+}
@@ -0,0 +1,221 @@
+// Package gobackend provides extension settings storage
+package gobackend
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
+	"sync"
+)
+
+// ExtensionSettingsStore manages settings for all extensions
+type ExtensionSettingsStore struct {
+	mu       sync.RWMutex
+	dataDir  string
+	settings map[string]map[string]interface{} // extensionID -> settings
+}
+
+// Global settings store
+var (
+	globalSettingsStore     *ExtensionSettingsStore
+	globalSettingsStoreOnce sync.Once
+)
+
+// GetExtensionSettingsStore returns the global settings store
+func GetExtensionSettingsStore() *ExtensionSettingsStore {
+	globalSettingsStoreOnce.Do(func() {
+		globalSettingsStore = &ExtensionSettingsStore{
+			settings: make(map[string]map[string]interface{}),
+		}
+	})
+	return globalSettingsStore
+}
+
+// SetDataDir sets the data directory for settings storage
+func (s *ExtensionSettingsStore) SetDataDir(dataDir string) error {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+
+	s.dataDir = dataDir
+	if err := os.MkdirAll(dataDir, 0755); err != nil {
+		return fmt.Errorf("failed to create settings directory: %w", err)
+	}
+
+	// Load all existing settings
+	return s.loadAllSettings()
+}
+
+// getSettingsPath returns the path to an extension's settings file
+func (s *ExtensionSettingsStore) getSettingsPath(extensionID string) string {
+	return filepath.Join(s.dataDir, extensionID, "settings.json")
+}
+
+// loadAllSettings loads settings for all extensions from disk
+func (s *ExtensionSettingsStore) loadAllSettings() error {
+	entries, err := os.ReadDir(s.dataDir)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return nil
+		}
+		return err
+	}
+
+	for _, entry := range entries {
+		if entry.IsDir() {
+			extensionID := entry.Name()
+			settings, err := s.loadSettings(extensionID)
+			if err != nil {
+				GoLog("[ExtensionSettings] Failed to load settings for %s: %v\n", extensionID, err)
+				continue
+			}
+			s.settings[extensionID] = settings
+		}
+	}
+
+	return nil
+}
+
+// loadSettings loads settings for a specific extension
+func (s *ExtensionSettingsStore) loadSettings(extensionID string) (map[string]interface{}, error) {
+	settingsPath := s.getSettingsPath(extensionID)
+	data, err := os.ReadFile(settingsPath)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return make(map[string]interface{}), nil
+		}
+		return nil, err
+	}
+
+	var settings map[string]interface{}
+	if err := json.Unmarshal(data, &settings); err != nil {
+		return nil, err
+	}
+
+	return settings, nil
+}
+
+// saveSettings saves settings for a specific extension
+func (s *ExtensionSettingsStore) saveSettings(extensionID string, settings map[string]interface{}) error {
+	settingsPath := s.getSettingsPath(extensionID)
+
+	// Create directory if needed
+	dir := filepath.Dir(settingsPath)
+	if err := os.MkdirAll(dir, 0755); err != nil {
+		return err
+	}
+
+	data, err := json.MarshalIndent(settings, "", "  ")
+	if err != nil {
+		return err
+	}
+
+	return os.WriteFile(settingsPath, data, 0644)
+}
+
+// Get retrieves a setting value for an extension
+// Returns error if extension or key not found (gomobile compatible)
+func (s *ExtensionSettingsStore) Get(extensionID, key string) (interface{}, error) {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+
+	extSettings, exists := s.settings[extensionID]
+	if !exists {
+		return nil, fmt.Errorf("extension '%s' settings not found", extensionID)
+	}
+
+	value, exists := extSettings[key]
+	if !exists {
+		return nil, fmt.Errorf("setting '%s' not found for extension '%s'", key, extensionID)
+	}
+	return value, nil
+}
+
+// GetAll retrieves all settings for an extension
+func (s *ExtensionSettingsStore) GetAll(extensionID string) map[string]interface{} {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+
+	extSettings, exists := s.settings[extensionID]
+	if !exists {
+		return make(map[string]interface{})
+	}
+
+	// Return a copy
+	result := make(map[string]interface{})
+	for k, v := range extSettings {
+		result[k] = v
+	}
+	return result
+}
+
+// Set stores a setting value for an extension
+func (s *ExtensionSettingsStore) Set(extensionID, key string, value interface{}) error {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+
+	if _, exists := s.settings[extensionID]; !exists {
+		s.settings[extensionID] = make(map[string]interface{})
+	}
+
+	s.settings[extensionID][key] = value
+
+	// Persist to disk
+	return s.saveSettings(extensionID, s.settings[extensionID])
+}
+
+// SetAll stores all settings for an extension
+func (s *ExtensionSettingsStore) SetAll(extensionID string, settings map[string]interface{}) error {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+
+	s.settings[extensionID] = settings
+
+	// Persist to disk
+	return s.saveSettings(extensionID, settings)
+}
+
+// Remove removes a setting for an extension
+func (s *ExtensionSettingsStore) Remove(extensionID, key string) error {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+
+	extSettings, exists := s.settings[extensionID]
+	if !exists {
+		return nil
+	}
+
+	delete(extSettings, key)
+
+	// Persist to disk
+	return s.saveSettings(extensionID, extSettings)
+}
+
+// RemoveAll removes all settings for an extension
+func (s *ExtensionSettingsStore) RemoveAll(extensionID string) error {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+
+	delete(s.settings, extensionID)
+
+	// Remove settings file
+	settingsPath := s.getSettingsPath(extensionID)
+	if err := os.Remove(settingsPath); err != nil && !os.IsNotExist(err) {
+		return err
+	}
+
+	return nil
+}
+
+// GetAllExtensionSettings returns settings for all extensions as JSON
+func (s *ExtensionSettingsStore) GetAllExtensionSettingsJSON() (string, error) {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+
+	data, err := json.Marshal(s.settings)
+	if err != nil {
+		return "", err
+	}
+
+	return string(data), nil
+}
@@ -0,0 +1,219 @@
+package gobackend
+
+import (
+	"testing"
+
+	"github.com/dop251/goja"
+)
+
+func TestParseManifest_Valid(t *testing.T) {
+	validManifest := `{
+		"name": "test-provider",
+		"displayName": "Test Provider",
+		"version": "1.0.0",
+		"author": "Test Author",
+		"description": "A test extension",
+		"type": ["metadata_provider"],
+		"permissions": {
+			"network": ["api.test.com"],
+			"storage": true
+		}
+	}`
+
+	manifest, err := ParseManifest([]byte(validManifest))
+	if err != nil {
+		t.Fatalf("Expected valid manifest to parse, got error: %v", err)
+	}
+
+	if manifest.Name != "test-provider" {
+		t.Errorf("Expected name 'test-provider', got '%s'", manifest.Name)
+	}
+
+	if manifest.Version != "1.0.0" {
+		t.Errorf("Expected version '1.0.0', got '%s'", manifest.Version)
+	}
+
+	if !manifest.IsMetadataProvider() {
+		t.Error("Expected IsMetadataProvider() to return true")
+	}
+
+	if manifest.IsDownloadProvider() {
+		t.Error("Expected IsDownloadProvider() to return false")
+	}
+}
+
+func TestParseManifest_MissingName(t *testing.T) {
+	invalidManifest := `{
+		"version": "1.0.0",
+		"author": "Test Author",
+		"description": "A test extension",
+		"type": ["metadata_provider"]
+	}`
+
+	_, err := ParseManifest([]byte(invalidManifest))
+	if err == nil {
+		t.Fatal("Expected error for missing name")
+	}
+}
+
+func TestParseManifest_MissingType(t *testing.T) {
+	invalidManifest := `{
+		"name": "test-provider",
+		"version": "1.0.0",
+		"author": "Test Author",
+		"description": "A test extension"
+	}`
+
+	_, err := ParseManifest([]byte(invalidManifest))
+	if err == nil {
+		t.Fatal("Expected error for missing type")
+	}
+}
+
+func TestIsDomainAllowed(t *testing.T) {
+	manifest := &ExtensionManifest{
+		Permissions: ExtensionPermissions{
+			Network: []string{"api.test.com", "*.example.com"},
+		},
+	}
+
+	tests := []struct {
+		domain   string
+		expected bool
+	}{
+		{"api.test.com", true},
+		{"api.example.com", true},
+		{"sub.example.com", true},
+		{"notallowed.com", false},
+		{"test.com", false},
+	}
+
+	for _, tt := range tests {
+		result := manifest.IsDomainAllowed(tt.domain)
+		if result != tt.expected {
+			t.Errorf("IsDomainAllowed(%s) = %v, expected %v", tt.domain, result, tt.expected)
+		}
+	}
+}
+
+func TestExtensionRuntime_NetworkSandbox(t *testing.T) {
+	// Create a mock extension with limited network permissions
+	ext := &LoadedExtension{
+		ID: "test-ext",
+		Manifest: &ExtensionManifest{
+			Name: "test-ext",
+			Permissions: ExtensionPermissions{
+				Network: []string{"api.allowed.com", "*.wildcard.com"},
+			},
+		},
+		DataDir: t.TempDir(),
+	}
+
+	runtime := NewExtensionRuntime(ext)
+
+	// Test allowed domains
+	if err := runtime.validateDomain("https://api.allowed.com/path"); err != nil {
+		t.Errorf("Expected api.allowed.com to be allowed, got error: %v", err)
+	}
+
+	if err := runtime.validateDomain("https://sub.wildcard.com/path"); err != nil {
+		t.Errorf("Expected sub.wildcard.com to be allowed (wildcard), got error: %v", err)
+	}
+
+	// Test blocked domains
+	if err := runtime.validateDomain("https://blocked.com/path"); err == nil {
+		t.Error("Expected blocked.com to be denied")
+	}
+
+	if err := runtime.validateDomain("https://notallowed.com/path"); err == nil {
+		t.Error("Expected notallowed.com to be denied")
+	}
+}
+
+func TestExtensionRuntime_FileSandbox(t *testing.T) {
+	tempDir := t.TempDir()
+
+	ext := &LoadedExtension{
+		ID: "test-ext",
+		Manifest: &ExtensionManifest{
+			Name: "test-ext",
+		},
+		DataDir: tempDir,
+	}
+
+	runtime := NewExtensionRuntime(ext)
+
+	// Test valid path within sandbox
+	validPath, err := runtime.validatePath("test.txt")
+	if err != nil {
+		t.Errorf("Expected relative path to be valid, got error: %v", err)
+	}
+	if validPath == "" {
+		t.Error("Expected non-empty path")
+	}
+
+	// Test path traversal attack
+	_, err = runtime.validatePath("../../../etc/passwd")
+	if err == nil {
+		t.Error("Expected path traversal to be blocked")
+	}
+
+	// Test nested path within sandbox (should be allowed)
+	nestedPath, err := runtime.validatePath("subdir/file.txt")
+	if err != nil {
+		t.Errorf("Expected nested path to be valid, got error: %v", err)
+	}
+	if nestedPath == "" {
+		t.Error("Expected non-empty nested path")
+	}
+}
+
+func TestExtensionRuntime_UtilityFunctions(t *testing.T) {
+	ext := &LoadedExtension{
+		ID: "test-ext",
+		Manifest: &ExtensionManifest{
+			Name: "test-ext",
+		},
+		DataDir: t.TempDir(),
+	}
+
+	runtime := NewExtensionRuntime(ext)
+	vm := goja.New()
+	runtime.RegisterAPIs(vm)
+
+	// Test base64 encode/decode
+	result, err := vm.RunString(`utils.base64Encode("hello")`)
+	if err != nil {
+		t.Fatalf("base64Encode failed: %v", err)
+	}
+	if result.String() != "aGVsbG8=" {
+		t.Errorf("Expected 'aGVsbG8=', got '%s'", result.String())
+	}
+
+	result, err = vm.RunString(`utils.base64Decode("aGVsbG8=")`)
+	if err != nil {
+		t.Fatalf("base64Decode failed: %v", err)
+	}
+	if result.String() != "hello" {
+		t.Errorf("Expected 'hello', got '%s'", result.String())
+	}
+
+	// Test MD5
+	result, err = vm.RunString(`utils.md5("hello")`)
+	if err != nil {
+		t.Fatalf("md5 failed: %v", err)
+	}
+	if result.String() != "5d41402abc4b2a76b9719d911017c592" {
+		t.Errorf("Expected '5d41402abc4b2a76b9719d911017c592', got '%s'", result.String())
+	}
+
+	// Test JSON parse/stringify
+	result, err = vm.RunString(`utils.stringifyJSON({name: "test", value: 123})`)
+	if err != nil {
+		t.Fatalf("stringifyJSON failed: %v", err)
+	}
+	// JSON output may vary in order, just check it's valid
+	if result.String() == "" {
+		t.Error("Expected non-empty JSON string")
+	}
+}
@@ -5,14 +5,19 @@ go 1.24.0
 toolchain go1.24.5

 require (
+	github.com/dop251/goja v0.0.0-20260106131823-651366fbe6e3
 	github.com/go-flac/flacpicture v0.3.0
 	github.com/go-flac/flacvorbis v0.2.0
 	github.com/go-flac/go-flac v1.0.0
 )

 require (
+	github.com/dlclark/regexp2 v1.11.4 // indirect
+	github.com/go-sourcemap/sourcemap v2.1.3+incompatible // indirect
+	github.com/google/pprof v0.0.0-20230207041349-798e818bf904 // indirect
 	golang.org/x/mobile v0.0.0-20251209145715-2553ed8ce294 // indirect
 	golang.org/x/mod v0.31.0 // indirect
 	golang.org/x/sync v0.19.0 // indirect
+	golang.org/x/text v0.3.8 // indirect
 	golang.org/x/tools v0.40.0 // indirect
 )
@@ -1,14 +1,28 @@
+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/dlclark/regexp2 v1.11.4 h1:rPYF9/LECdNymJufQKmri9gV604RvvABwgOA8un7yAo=
+github.com/dlclark/regexp2 v1.11.4/go.mod h1:DHkYz0B9wPfa6wondMfaivmHpzrQ3v9q8cnmRbL6yW8=
+github.com/dop251/goja v0.0.0-20260106131823-651366fbe6e3 h1:bVp3yUzvSAJzu9GqID+Z96P+eu5TKnIMJSV4QaZMauM=
+github.com/dop251/goja v0.0.0-20260106131823-651366fbe6e3/go.mod h1:MxLav0peU43GgvwVgNbLAj1s/bSGboKkhuULvq/7hx4=
 github.com/go-flac/flacpicture v0.3.0 h1:LkmTxzFLIynwfhHiZsX0s8xcr3/u33MzvV89u+zOT8I=
 github.com/go-flac/flacpicture v0.3.0/go.mod h1:DPbrzVYQ3fJcvSgLFp9HXIrEQEdfdk/+m0nQCzwodZI=
 github.com/go-flac/flacvorbis v0.2.0 h1:KH0xjpkNTXFER4cszH4zeJxYcrHbUobz/RticWGOESs=
 github.com/go-flac/flacvorbis v0.2.0/go.mod h1:uIysHOtuU7OLGoCRG92bvnkg7QEqHx19qKRV6K1pBrI=
 github.com/go-flac/go-flac v1.0.0 h1:6qI9XOVLcO50xpzm3nXvO31BgDgHhnr/p/rER/K/doY=
 github.com/go-flac/go-flac v1.0.0/go.mod h1:WnZhcpmq4u1UdZMNn9LYSoASpWOCMOoxXxcWEHSzkW8=
+github.com/go-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/pprof v0.0.0-20230207041349-798e818bf904 h1:4/hN5RUoecvl+RmJRE2YxKWtnnQls6rQjjW5oV7qg2U=
+github.com/google/pprof v0.0.0-20230207041349-798e818bf904/go.mod h1:uglQLonpP8qtYCYyzA+8c/9qtqgA3qsXGYqCPKARAFg=
 golang.org/x/mobile v0.0.0-20251209145715-2553ed8ce294 h1:Cr6kbEvA6nqvdHynE4CtVKlqpZB9dS1Jva/6IsHA19g=
 golang.org/x/mobile v0.0.0-20251209145715-2553ed8ce294/go.mod h1:RdZ+3sb4CVgpCFnzv+I4haEpwqFfsfzlLHs3L7ok+e0=
 golang.org/x/mod v0.31.0 h1:HaW9xtz0+kOcWKwli0ZXy79Ix+UW/vOfmWI5QVd2tgI=
 golang.org/x/mod v0.31.0/go.mod h1:43JraMp9cGx1Rx3AqioxrbrhNsLl2l/iNAvuBkrezpg=
 golang.org/x/sync v0.19.0 h1:vV+1eWNmZ5geRlYjzm2adRgW2/mcpevXNg50YZtPCE4=
 golang.org/x/sync v0.19.0/go.mod h1:9KTHXmSnoGruLpwFjVSX0lNNA75CykiMECbovNTZqGI=
+golang.org/x/text v0.3.8 h1:nAL+RVCQ9uMn3vJZbV+MRnydTJFPf8qqY42YiA6MrqY=
+golang.org/x/text v0.3.8/go.mod h1:E6s5w1FMmriuDzIBO73fBruAKo1PCIq6d2Q6DHfQ8WQ=
 golang.org/x/tools v0.40.0 h1:yLkxfA+Qnul4cs9QA3KnlFu0lVmd8JJfoq+E41uSutA=
 golang.org/x/tools v0.40.0/go.mod h1:Ik/tzLRlbscWpqqMRjyWYDisX8bG13FrdXp3o4Sr9lc=
+gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY=
+gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
@@ -1,45 +1,86 @@
 package gobackend

 import (
+	"crypto/tls"
+	"errors"
 	"fmt"
 	"io"
 	"math/rand"
 	"net"
 	"net/http"
+	"net/url"
 	"strconv"
+	"strings"
+	"syscall"
 	"time"
 )

 // HTTP utility functions for consistent request handling across all downloaders

-// User-Agent pool for Android Chrome browsers
-var userAgentTemplates = []string{
-	"Mozilla/5.0 (Linux; Android %d; SM-G%d) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/%d.0.%d.%d Mobile Safari/537.36",
-	"Mozilla/5.0 (Linux; Android %d; Pixel %d) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/%d.0.%d.%d Mobile Safari/537.36",
-	"Mozilla/5.0 (Linux; Android %d; SM-A%d) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/%d.0.%d.%d Mobile Safari/537.36",
-	"Mozilla/5.0 (Linux; Android %d; Redmi Note %d) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/%d.0.%d.%d Mobile Safari/537.36",
-}
-
-// getRandomUserAgent generates a random browser-like User-Agent string (Android Chrome format)
+// getRandomUserAgent generates a random Windows Chrome User-Agent string
+// Uses same format as PC version (referensi/backend/spotify_metadata.go) for better API compatibility
 func getRandomUserAgent() string {
-	template := userAgentTemplates[rand.Intn(len(userAgentTemplates))]
+	// Windows 10/11 Chrome format - same as PC version for maximum compatibility
+	// Some APIs may block mobile User-Agents, so we use desktop format
+	winMajor := rand.Intn(2) + 10 // Windows 10 or 11

-	androidVersion := rand.Intn(5) + 10 // Android 10-14
-	deviceModel := rand.Intn(900) + 100 // Random model number
-	chromeVersion := rand.Intn(25) + 100 // Chrome 100-124
-	chromeBuild := rand.Intn(5000) + 5000
-	chromePatch := rand.Intn(200) + 100
+	chromeVersion := rand.Intn(25) + 100  // Chrome 100-124
+	chromeBuild := rand.Intn(1500) + 3000 // Build 3000-4500
+	chromePatch := rand.Intn(65) + 60     // Patch 60-125

-	return fmt.Sprintf(template, androidVersion, deviceModel, chromeVersion, chromeBuild, chromePatch)
+	return fmt.Sprintf(
+		"Mozilla/5.0 (Windows NT %d.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/%d.0.%d.%d Safari/537.36",
+		winMajor,
+		chromeVersion,
+		chromeBuild,
+		chromePatch,
+	)
 }

+// getRandomMacUserAgent generates a random Mac Chrome User-Agent string
+// Alternative format matching referensi/backend/spotify_metadata.go exactly
+// Kept for potential future use
+// func getRandomMacUserAgent() string {
+// 	macMajor := rand.Intn(4) + 11 // macOS 11-14
+// 	macMinor := rand.Intn(5) + 4  // Minor 4-8
+// 	webkitMajor := rand.Intn(7) + 530
+// 	webkitMinor := rand.Intn(7) + 30
+// 	chromeMajor := rand.Intn(25) + 80
+// 	chromeBuild := rand.Intn(1500) + 3000
+// 	chromePatch := rand.Intn(65) + 60
+// 	safariMajor := rand.Intn(7) + 530
+// 	safariMinor := rand.Intn(6) + 30
+//
+// 	return fmt.Sprintf(
+// 		"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_%d_%d) AppleWebKit/%d.%d (KHTML, like Gecko) Chrome/%d.0.%d.%d Safari/%d.%d",
+// 		macMajor,
+// 		macMinor,
+// 		webkitMajor,
+// 		webkitMinor,
+// 		chromeMajor,
+// 		chromeBuild,
+// 		chromePatch,
+// 		safariMajor,
+// 		safariMinor,
+// 	)
+// }
+
+// getRandomDesktopUserAgent randomly picks between Windows and Mac User-Agent
+// Kept for potential future use
+// func getRandomDesktopUserAgent() string {
+// 	if rand.Intn(2) == 0 {
+// 		return getRandomUserAgent() // Windows
+// 	}
+// 	return getRandomMacUserAgent() // Mac
+// }
+
 // Default timeout values
 const (
-	DefaultTimeout     = 60 * time.Second  // Default HTTP timeout
-	DownloadTimeout    = 120 * time.Second // Timeout for file downloads
-	SongLinkTimeout    = 30 * time.Second  // Timeout for SongLink API
-	DefaultMaxRetries  = 3                 // Default retry count
-	DefaultRetryDelay  = 1 * time.Second   // Initial retry delay
+	DefaultTimeout    = 60 * time.Second  // Default HTTP timeout
+	DownloadTimeout   = 120 * time.Second // Timeout for file downloads
+	SongLinkTimeout   = 30 * time.Second  // Timeout for SongLink API
+	DefaultMaxRetries = 3                 // Default retry count
+	DefaultRetryDelay = 1 * time.Second   // Initial retry delay
 )

 // Shared transport with connection pooling to prevent TCP exhaustion
@@ -57,9 +98,9 @@ var sharedTransport = &http.Transport{
 	ExpectContinueTimeout: 1 * time.Second,
 	DisableKeepAlives:     false, // Enable keep-alives for connection reuse
 	ForceAttemptHTTP2:     true,
-	WriteBufferSize:       64 * 1024,  // 64KB write buffer
-	ReadBufferSize:        64 * 1024,  // 64KB read buffer
-	DisableCompression:    true,       // FLAC is already compressed
+	WriteBufferSize:       64 * 1024, // 64KB write buffer
+	ReadBufferSize:        64 * 1024, // 64KB read buffer
+	DisableCompression:    true,      // FLAC is already compressed
 }

 // Shared HTTP client for general requests (reuses connections)
@@ -100,9 +141,15 @@ func CloseIdleConnections() {
 }

 // DoRequestWithUserAgent executes an HTTP request with a random User-Agent header
+// Also checks for ISP blocking on errors
 func DoRequestWithUserAgent(client *http.Client, req *http.Request) (*http.Response, error) {
 	req.Header.Set("User-Agent", getRandomUserAgent())
-	return client.Do(req)
+	resp, err := client.Do(req)
+	if err != nil {
+		// Check for ISP blocking
+		CheckAndLogISPBlocking(err, req.URL.String(), "HTTP")
+	}
+	return resp, err
 }

 // RetryConfig holds configuration for retry logic
@@ -125,9 +172,11 @@ func DefaultRetryConfig() RetryConfig {

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

 	for attempt := 0; attempt <= config.MaxRetries; attempt++ {
 		// Clone request for retry (body needs to be re-readable)
@@ -137,7 +186,16 @@ func DoRequestWithRetry(client *http.Client, req *http.Request, config RetryConf
 		resp, err := client.Do(reqCopy)
 		if err != nil {
 			lastErr = err
+
+			// Check for ISP blocking on network errors
+			if CheckAndLogISPBlocking(err, requestURL, "HTTP") {
+				// Don't retry if ISP blocking is detected - it won't help
+				return nil, WrapErrorWithISPCheck(err, requestURL, "HTTP")
+			}
+
 			if attempt < config.MaxRetries {
+				GoLog("[HTTP] Request failed (attempt %d/%d): %v, retrying in %v...\n",
+					attempt+1, config.MaxRetries+1, err, delay)
 				time.Sleep(delay)
 				delay = calculateNextDelay(delay, config)
 			}
@@ -158,17 +216,43 @@ func DoRequestWithRetry(client *http.Client, req *http.Request, config RetryConf
 			}
 			lastErr = fmt.Errorf("rate limited (429)")
 			if attempt < config.MaxRetries {
+				GoLog("[HTTP] Rate limited, waiting %v before retry...\n", delay)
 				time.Sleep(delay)
 				delay = calculateNextDelay(delay, config)
 			}
 			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",
+			}
+
+			for _, indicator := range ispBlockingIndicators {
+				if strings.Contains(bodyStr, indicator) {
+					LogError("HTTP", "ISP BLOCKING DETECTED via HTTP %d response", resp.StatusCode)
+					LogError("HTTP", "Domain: %s", req.URL.Host)
+					LogError("HTTP", "Response contains: %s", indicator)
+					LogError("HTTP", "Suggestion: Try using a VPN or changing your DNS to 1.1.1.1 or 8.8.8.8")
+					return nil, fmt.Errorf("ISP blocking detected for %s (HTTP %d) - try using VPN or change DNS", req.URL.Host, resp.StatusCode)
+				}
+			}
+		}
+
 		// Server errors (5xx) - retry
 		if resp.StatusCode >= 500 {
 			resp.Body.Close()
 			lastErr = fmt.Errorf("server error: HTTP %d", resp.StatusCode)
 			if attempt < config.MaxRetries {
+				GoLog("[HTTP] Server error %d, retrying in %v...\n", resp.StatusCode, delay)
 				time.Sleep(delay)
 				delay = calculateNextDelay(delay, config)
 			}
@@ -185,10 +269,7 @@ func DoRequestWithRetry(client *http.Client, req *http.Request, config RetryConf
 // calculateNextDelay calculates the next delay with exponential backoff
 func calculateNextDelay(currentDelay time.Duration, config RetryConfig) time.Duration {
 	nextDelay := time.Duration(float64(currentDelay) * config.BackoffFactor)
-	if nextDelay > config.MaxDelay {
-		nextDelay = config.MaxDelay
-	}
-	return nextDelay
+	return min(nextDelay, config.MaxDelay)
 }

 // getRetryAfterDuration parses Retry-After header and returns duration
@@ -262,3 +343,172 @@ func BuildErrorMessage(apiURL string, statusCode int, responsePreview string) st
 	}
 	return msg
 }
+
+// ISPBlockingError represents an error caused by ISP blocking
+type ISPBlockingError struct {
+	Domain      string
+	Reason      string
+	OriginalErr error
+}
+
+func (e *ISPBlockingError) Error() string {
+	return fmt.Sprintf("ISP blocking detected for %s: %s", e.Domain, e.Reason)
+}
+
+// IsISPBlocking checks if an error is likely caused by ISP blocking
+// Returns the ISPBlockingError if detected, nil otherwise
+func IsISPBlocking(err error, requestURL string) *ISPBlockingError {
+	if err == nil {
+		return nil
+	}
+
+	// Extract domain from URL
+	domain := extractDomain(requestURL)
+	errStr := strings.ToLower(err.Error())
+
+	// Check for DNS resolution failure (common ISP blocking method)
+	var dnsErr *net.DNSError
+	if errors.As(err, &dnsErr) {
+		if dnsErr.IsNotFound || dnsErr.IsTemporary {
+			return &ISPBlockingError{
+				Domain:      domain,
+				Reason:      "DNS resolution failed - domain may be blocked by ISP",
+				OriginalErr: err,
+			}
+		}
+	}
+
+	// Check for connection refused (ISP firewall blocking)
+	var opErr *net.OpError
+	if errors.As(err, &opErr) {
+		if opErr.Op == "dial" {
+			// Check for specific syscall errors
+			var syscallErr syscall.Errno
+			if errors.As(opErr.Err, &syscallErr) {
+				switch syscallErr {
+				case syscall.ECONNREFUSED:
+					return &ISPBlockingError{
+						Domain:      domain,
+						Reason:      "Connection refused - port may be blocked by ISP/firewall",
+						OriginalErr: err,
+					}
+				case syscall.ECONNRESET:
+					return &ISPBlockingError{
+						Domain:      domain,
+						Reason:      "Connection reset - ISP may be intercepting traffic",
+						OriginalErr: err,
+					}
+				case syscall.ETIMEDOUT:
+					return &ISPBlockingError{
+						Domain:      domain,
+						Reason:      "Connection timed out - ISP may be blocking access",
+						OriginalErr: err,
+					}
+				case syscall.ENETUNREACH:
+					return &ISPBlockingError{
+						Domain:      domain,
+						Reason:      "Network unreachable - ISP may be blocking route",
+						OriginalErr: err,
+					}
+				case syscall.EHOSTUNREACH:
+					return &ISPBlockingError{
+						Domain:      domain,
+						Reason:      "Host unreachable - ISP may be blocking destination",
+						OriginalErr: err,
+					}
+				}
+			}
+		}
+	}
+
+	// Check for TLS handshake failure (ISP MITM or blocking HTTPS)
+	var tlsErr *tls.RecordHeaderError
+	if errors.As(err, &tlsErr) {
+		return &ISPBlockingError{
+			Domain:      domain,
+			Reason:      "TLS handshake failed - ISP may be intercepting HTTPS traffic",
+			OriginalErr: err,
+		}
+	}
+
+	// Check error message patterns for common ISP blocking indicators
+	blockingPatterns := []struct {
+		pattern string
+		reason  string
+	}{
+		{"connection reset by peer", "Connection reset - ISP may be intercepting traffic"},
+		{"connection refused", "Connection refused - port may be blocked"},
+		{"no such host", "DNS lookup failed - domain may be blocked by ISP"},
+		{"i/o timeout", "Connection timed out - ISP may be blocking access"},
+		{"network is unreachable", "Network unreachable - ISP may be blocking route"},
+		{"tls: ", "TLS error - ISP may be intercepting HTTPS traffic"},
+		{"certificate", "Certificate error - ISP may be using MITM proxy"},
+		{"eof", "Connection closed unexpectedly - ISP may be blocking"},
+		{"context deadline exceeded", "Request timed out - ISP may be throttling"},
+	}
+
+	for _, bp := range blockingPatterns {
+		if strings.Contains(errStr, bp.pattern) {
+			return &ISPBlockingError{
+				Domain:      domain,
+				Reason:      bp.reason,
+				OriginalErr: err,
+			}
+		}
+	}
+
+	return nil
+}
+
+// CheckAndLogISPBlocking checks for ISP blocking and logs if detected
+// Returns true if ISP blocking was detected
+func CheckAndLogISPBlocking(err error, requestURL string, tag string) bool {
+	ispErr := IsISPBlocking(err, requestURL)
+	if ispErr != nil {
+		LogError(tag, "ISP BLOCKING DETECTED: %s", ispErr.Error())
+		LogError(tag, "Domain: %s", ispErr.Domain)
+		LogError(tag, "Reason: %s", ispErr.Reason)
+		LogError(tag, "Original error: %v", ispErr.OriginalErr)
+		LogError(tag, "Suggestion: Try using a VPN or changing your DNS to 1.1.1.1 or 8.8.8.8")
+		return true
+	}
+	return false
+}
+
+// extractDomain extracts the domain from a URL string
+func extractDomain(rawURL string) string {
+	if rawURL == "" {
+		return "unknown"
+	}
+
+	parsed, err := url.Parse(rawURL)
+	if err != nil {
+		// Try to extract domain manually
+		rawURL = strings.TrimPrefix(rawURL, "https://")
+		rawURL = strings.TrimPrefix(rawURL, "http://")
+		if idx := strings.Index(rawURL, "/"); idx > 0 {
+			return rawURL[:idx]
+		}
+		return rawURL
+	}
+
+	if parsed.Host != "" {
+		return parsed.Host
+	}
+	return "unknown"
+}
+
+// WrapErrorWithISPCheck wraps an error with ISP blocking detection
+// If ISP blocking is detected, returns a more descriptive error
+func WrapErrorWithISPCheck(err error, requestURL string, tag string) error {
+	if err == nil {
+		return nil
+	}
+
+	if CheckAndLogISPBlocking(err, requestURL, tag) {
+		domain := extractDomain(requestURL)
+		return fmt.Errorf("ISP blocking detected for %s - try using VPN or change DNS to 1.1.1.1/8.8.8.8: %w", domain, err)
+	}
+
+	return err
+}
@@ -0,0 +1,203 @@
+package gobackend
+
+import (
+	"encoding/json"
+	"fmt"
+	"strings"
+	"sync"
+	"time"
+)
+
+// LogEntry represents a single log entry
+type LogEntry struct {
+	Timestamp string `json:"timestamp"`
+	Level     string `json:"level"`
+	Tag       string `json:"tag"`
+	Message   string `json:"message"`
+}
+
+// LogBuffer stores logs in a circular buffer for retrieval by Flutter
+type LogBuffer struct {
+	entries        []LogEntry
+	maxSize        int
+	mu             sync.RWMutex
+	loggingEnabled bool // Whether logging is enabled (controlled by Flutter)
+}
+
+var (
+	globalLogBuffer *LogBuffer
+	logBufferOnce   sync.Once
+)
+
+// GetLogBuffer returns the singleton log buffer instance
+func GetLogBuffer() *LogBuffer {
+	logBufferOnce.Do(func() {
+		globalLogBuffer = &LogBuffer{
+			entries:        make([]LogEntry, 0, 500),
+			maxSize:        500,
+			loggingEnabled: false, // Default: disabled for performance (user can enable in settings)
+		}
+	})
+	return globalLogBuffer
+}
+
+// SetLoggingEnabled enables or disables logging
+func (lb *LogBuffer) SetLoggingEnabled(enabled bool) {
+	lb.mu.Lock()
+	defer lb.mu.Unlock()
+	lb.loggingEnabled = enabled
+}
+
+// IsLoggingEnabled returns whether logging is enabled
+func (lb *LogBuffer) IsLoggingEnabled() bool {
+	lb.mu.RLock()
+	defer lb.mu.RUnlock()
+	return lb.loggingEnabled
+}
+
+// Add adds a log entry to the buffer
+func (lb *LogBuffer) Add(level, tag, message string) {
+	lb.mu.Lock()
+	defer lb.mu.Unlock()
+
+	// Skip if logging is disabled (except for errors which are always logged)
+	if !lb.loggingEnabled && level != "ERROR" && level != "FATAL" {
+		return
+	}
+
+	entry := LogEntry{
+		Timestamp: time.Now().Format("15:04:05.000"),
+		Level:     level,
+		Tag:       tag,
+		Message:   message,
+	}
+
+	if len(lb.entries) >= lb.maxSize {
+		// Remove oldest entry
+		lb.entries = lb.entries[1:]
+	}
+	lb.entries = append(lb.entries, entry)
+
+	// Also print to logcat for debugging
+	fmt.Printf("[%s] %s\n", tag, message)
+}
+
+// GetAll returns all log entries as JSON
+func (lb *LogBuffer) GetAll() string {
+	lb.mu.RLock()
+	defer lb.mu.RUnlock()
+
+	jsonBytes, _ := json.Marshal(lb.entries)
+	return string(jsonBytes)
+}
+
+// getSince returns log entries since the given index (internal use)
+func (lb *LogBuffer) getSince(index int) ([]LogEntry, int) {
+	lb.mu.RLock()
+	defer lb.mu.RUnlock()
+
+	if index < 0 {
+		index = 0
+	}
+	if index >= len(lb.entries) {
+		return []LogEntry{}, len(lb.entries)
+	}
+
+	entries := lb.entries[index:]
+	return entries, len(lb.entries)
+}
+
+// Clear clears all log entries
+func (lb *LogBuffer) Clear() {
+	lb.mu.Lock()
+	defer lb.mu.Unlock()
+	lb.entries = lb.entries[:0]
+}
+
+// Count returns the number of log entries
+func (lb *LogBuffer) Count() int {
+	lb.mu.RLock()
+	defer lb.mu.RUnlock()
+	return len(lb.entries)
+}
+
+// Helper functions for logging with different levels
+func LogDebug(tag, format string, args ...interface{}) {
+	GetLogBuffer().Add("DEBUG", tag, fmt.Sprintf(format, args...))
+}
+
+func LogInfo(tag, format string, args ...interface{}) {
+	GetLogBuffer().Add("INFO", tag, fmt.Sprintf(format, args...))
+}
+
+func LogWarn(tag, format string, args ...interface{}) {
+	GetLogBuffer().Add("WARN", tag, fmt.Sprintf(format, args...))
+}
+
+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"
+
+	if strings.HasPrefix(message, "[") {
+		endBracket := strings.Index(message, "]")
+		if endBracket > 1 {
+			tag = message[1:endBracket]
+			message = strings.TrimSpace(message[endBracket+1:])
+		}
+	}
+
+	// Determine level from message content
+	msgLower := strings.ToLower(message)
+	if strings.Contains(msgLower, "error") || strings.Contains(msgLower, "failed") || strings.HasPrefix(message, "✗") {
+		level = "ERROR"
+	} else if strings.Contains(msgLower, "warning") || strings.Contains(msgLower, "warn") {
+		level = "WARN"
+	} else if strings.HasPrefix(message, "✓") || strings.Contains(msgLower, "success") || strings.Contains(msgLower, "match found") {
+		level = "INFO"
+	} else if strings.Contains(msgLower, "searching") || strings.Contains(msgLower, "trying") || strings.Contains(msgLower, "found") {
+		level = "DEBUG"
+	}
+
+	GetLogBuffer().Add(level, tag, message)
+}
+
+// Exported functions for Flutter
+
+// GetLogs returns all logs as JSON array
+func GetLogs() string {
+	return GetLogBuffer().GetAll()
+}
+
+// GetLogsSince returns logs since the given index
+// Returns JSON: {"logs": [...], "next_index": N}
+func GetLogsSince(index int) string {
+	entries, nextIndex := GetLogBuffer().getSince(index)
+	logsJson, _ := json.Marshal(entries)
+	result := fmt.Sprintf(`{"logs":%s,"next_index":%d}`, string(logsJson), nextIndex)
+	return result
+}
+
+// ClearLogs clears all logs
+func ClearLogs() {
+	GetLogBuffer().Clear()
+}
+
+// GetLogCount returns the number of log entries
+func GetLogCount() int {
+	return GetLogBuffer().Count()
+}
+
+// SetLoggingEnabled enables or disables logging from Flutter
+func SetLoggingEnabled(enabled bool) {
+	GetLogBuffer().SetLoggingEnabled(enabled)
+}
@@ -248,15 +248,54 @@ func msToLRCTimestamp(ms int64) string {
 	return fmt.Sprintf("[%02d:%02d.%02d]", minutes, seconds, centiseconds)
 }

-func convertToLRC(lyrics *LyricsResponse) string {
+// convertToLRC converts lyrics to LRC format string (without metadata headers)
+// Use convertToLRCWithMetadata for full LRC with headers
+// Kept for potential future use
+// func convertToLRC(lyrics *LyricsResponse) string {
+// 	if lyrics == nil || len(lyrics.Lines) == 0 {
+// 		return ""
+// 	}
+//
+// 	var builder strings.Builder
+//
+// 	if lyrics.SyncType == "LINE_SYNCED" {
+// 		for _, line := range lyrics.Lines {
+// 			timestamp := msToLRCTimestamp(line.StartTimeMs)
+// 			builder.WriteString(timestamp)
+// 			builder.WriteString(line.Words)
+// 			builder.WriteString("\n")
+// 		}
+// 	} else {
+// 		for _, line := range lyrics.Lines {
+// 			builder.WriteString(line.Words)
+// 			builder.WriteString("\n")
+// 		}
+// 	}
+//
+// 	return builder.String()
+// }
+
+// convertToLRCWithMetadata converts lyrics to LRC format with metadata headers
+// Includes [ti:], [ar:], [by:] headers
+func convertToLRCWithMetadata(lyrics *LyricsResponse, trackName, artistName string) string {
 	if lyrics == nil || len(lyrics.Lines) == 0 {
 		return ""
 	}

 	var builder strings.Builder

+	// Add metadata headers
+	builder.WriteString(fmt.Sprintf("[ti:%s]\n", trackName))
+	builder.WriteString(fmt.Sprintf("[ar:%s]\n", artistName))
+	builder.WriteString("[by:SpotiFLAC-Mobile]\n")
+	builder.WriteString("\n")
+
+	// Add lyrics lines
 	if lyrics.SyncType == "LINE_SYNCED" {
 		for _, line := range lyrics.Lines {
+			if line.Words == "" {
+				continue
+			}
 			timestamp := msToLRCTimestamp(line.StartTimeMs)
 			builder.WriteString(timestamp)
 			builder.WriteString(line.Words)
@@ -264,6 +303,9 @@ func convertToLRC(lyrics *LyricsResponse) string {
 		}
 	} else {
 		for _, line := range lyrics.Lines {
+			if line.Words == "" {
+				continue
+			}
 			builder.WriteString(line.Words)
 			builder.WriteString("\n")
 		}
@@ -58,7 +58,7 @@ func EmbedMetadata(filePath string, metadata Metadata, coverPath string) error {
 	setComment(cmt, "ALBUM", metadata.Album)
 	setComment(cmt, "ALBUMARTIST", metadata.AlbumArtist)
 	setComment(cmt, "DATE", metadata.Date)
-	
+
 	if metadata.TrackNumber > 0 {
 		if metadata.TotalTracks > 0 {
 			setComment(cmt, "TRACKNUMBER", fmt.Sprintf("%d/%d", metadata.TrackNumber, metadata.TotalTracks))
@@ -66,15 +66,15 @@ func EmbedMetadata(filePath string, metadata Metadata, coverPath string) error {
 			setComment(cmt, "TRACKNUMBER", strconv.Itoa(metadata.TrackNumber))
 		}
 	}
-	
+
 	if metadata.DiscNumber > 0 {
 		setComment(cmt, "DISCNUMBER", strconv.Itoa(metadata.DiscNumber))
 	}
-	
+
 	if metadata.ISRC != "" {
 		setComment(cmt, "ISRC", metadata.ISRC)
 	}
-	
+
 	if metadata.Description != "" {
 		setComment(cmt, "DESCRIPTION", metadata.Description)
 	}
@@ -105,7 +105,7 @@ func EmbedMetadata(filePath string, metadata Metadata, coverPath string) error {
 						f.Meta = append(f.Meta[:i], f.Meta[i+1:]...)
 					}
 				}
-				
+
 				picture, err := flacpicture.NewFromImageData(
 					flacpicture.PictureTypeFrontCover,
 					"Front Cover",
@@ -162,7 +162,7 @@ func EmbedMetadataWithCoverData(filePath string, metadata Metadata, coverData []
 	setComment(cmt, "ALBUM", metadata.Album)
 	setComment(cmt, "ALBUMARTIST", metadata.AlbumArtist)
 	setComment(cmt, "DATE", metadata.Date)
-	
+
 	if metadata.TrackNumber > 0 {
 		if metadata.TotalTracks > 0 {
 			setComment(cmt, "TRACKNUMBER", fmt.Sprintf("%d/%d", metadata.TrackNumber, metadata.TotalTracks))
@@ -170,15 +170,15 @@ func EmbedMetadataWithCoverData(filePath string, metadata Metadata, coverData []
 			setComment(cmt, "TRACKNUMBER", strconv.Itoa(metadata.TrackNumber))
 		}
 	}
-	
+
 	if metadata.DiscNumber > 0 {
 		setComment(cmt, "DISCNUMBER", strconv.Itoa(metadata.DiscNumber))
 	}
-	
+
 	if metadata.ISRC != "" {
 		setComment(cmt, "ISRC", metadata.ISRC)
 	}
-	
+
 	if metadata.Description != "" {
 		setComment(cmt, "DESCRIPTION", metadata.Description)
 	}
@@ -204,7 +204,7 @@ func EmbedMetadataWithCoverData(filePath string, metadata Metadata, coverData []
 				f.Meta = append(f.Meta[:i], f.Meta[i+1:]...)
 			}
 		}
-		
+
 		picture, err := flacpicture.NewFromImageData(
 			flacpicture.PictureTypeFrontCover,
 			"Front Cover",
@@ -257,11 +257,30 @@ func ReadMetadata(filePath string) (*Metadata, error) {
 			if trackNum != "" {
 				fmt.Sscanf(trackNum, "%d", &metadata.TrackNumber)
 			}
+			// Also try lowercase variant (some encoders use lowercase)
+			if metadata.TrackNumber == 0 {
+				trackNum = getComment(cmt, "TRACK")
+				if trackNum != "" {
+					fmt.Sscanf(trackNum, "%d", &metadata.TrackNumber)
+				}
+			}

 			discNum := getComment(cmt, "DISCNUMBER")
 			if discNum != "" {
 				fmt.Sscanf(discNum, "%d", &metadata.DiscNumber)
 			}
+			// Also try DISC variant
+			if metadata.DiscNumber == 0 {
+				discNum = getComment(cmt, "DISC")
+				if discNum != "" {
+					fmt.Sscanf(discNum, "%d", &metadata.DiscNumber)
+				}
+			}
+
+			// Try DATE variants
+			if metadata.Date == "" {
+				metadata.Date = getComment(cmt, "YEAR")
+			}

 			break
 		}
@@ -291,9 +310,14 @@ func setComment(cmt *flacvorbis.MetaDataBlockVorbisComment, key, value string) {
 }

 func getComment(cmt *flacvorbis.MetaDataBlockVorbisComment, key string) string {
+	keyUpper := strings.ToUpper(key) + "="
 	for _, comment := range cmt.Comments {
-		if len(comment) > len(key)+1 && comment[:len(key)+1] == key+"=" {
-			return comment[len(key)+1:]
+		if len(comment) > len(key) {
+			// Case-insensitive comparison for Vorbis comments
+			commentUpper := strings.ToUpper(comment[:len(key)+1])
+			if commentUpper == keyUpper {
+				return comment[len(key)+1:]
+			}
 		}
 	}
 	return ""
@@ -356,13 +380,13 @@ func ExtractLyrics(filePath string) (string, error) {
 			if err != nil {
 				continue
 			}
-			
+
 			// Try LYRICS tag first
 			lyrics, err := cmt.Get("LYRICS")
 			if err == nil && len(lyrics) > 0 && lyrics[0] != "" {
 				return lyrics[0], nil
 			}
-			
+
 			// Fallback to UNSYNCEDLYRICS
 			lyrics, err = cmt.Get("UNSYNCEDLYRICS")
 			if err == nil && len(lyrics) > 0 && lyrics[0] != "" {
@@ -376,12 +400,14 @@ func ExtractLyrics(filePath string) (string, error) {

 // AudioQuality represents audio quality info from a FLAC file
 type AudioQuality struct {
-	BitDepth   int `json:"bit_depth"`
-	SampleRate int `json:"sample_rate"`
+	BitDepth     int   `json:"bit_depth"`
+	SampleRate   int   `json:"sample_rate"`
+	TotalSamples int64 `json:"total_samples"`
 }

 // GetAudioQuality reads bit depth and sample rate from a FLAC file's StreamInfo block
 // FLAC StreamInfo is always the first metadata block after the 4-byte "fLaC" marker
+// For M4A files, it delegates to GetM4AQuality
 func GetAudioQuality(filePath string) (AudioQuality, error) {
 	file, err := os.Open(filePath)
 	if err != nil {
@@ -389,45 +415,408 @@ func GetAudioQuality(filePath string) (AudioQuality, error) {
 	}
 	defer file.Close()

-	// Read FLAC marker (4 bytes: "fLaC")
+	// Read first 4 bytes to detect file type
 	marker := make([]byte, 4)
 	if _, err := file.Read(marker); err != nil {
 		return AudioQuality{}, fmt.Errorf("failed to read marker: %w", err)
 	}
-	if string(marker) != "fLaC" {
-		return AudioQuality{}, fmt.Errorf("not a FLAC file")
+
+	// Check if it's a FLAC file
+	if string(marker) == "fLaC" {
+		// Continue reading FLAC metadata
+		// Read metadata block header (4 bytes)
+		header := make([]byte, 4)
+		if _, err := file.Read(header); err != nil {
+			return AudioQuality{}, fmt.Errorf("failed to read header: %w", err)
+		}
+
+		blockType := header[0] & 0x7F
+		if blockType != 0 {
+			return AudioQuality{}, fmt.Errorf("first block is not STREAMINFO")
+		}
+
+		// Read STREAMINFO block (34 bytes minimum)
+		streamInfo := make([]byte, 34)
+		if _, err := file.Read(streamInfo); err != nil {
+			return AudioQuality{}, fmt.Errorf("failed to read STREAMINFO: %w", err)
+		}
+
+		// Parse sample rate (20 bits starting at byte 10)
+		sampleRate := (int(streamInfo[10]) << 12) | (int(streamInfo[11]) << 4) | (int(streamInfo[12]) >> 4)
+
+		// Parse bits per sample (5 bits)
+		bitsPerSample := ((int(streamInfo[12]) & 0x01) << 4) | (int(streamInfo[13]) >> 4) + 1
+
+		// Parse total samples (36 bits: 4 bits from byte 13, all of bytes 14-17)
+		totalSamples := int64(streamInfo[13]&0x0F)<<32 |
+			int64(streamInfo[14])<<24 |
+			int64(streamInfo[15])<<16 |
+			int64(streamInfo[16])<<8 |
+			int64(streamInfo[17])
+
+		return AudioQuality{
+			BitDepth:     bitsPerSample,
+			SampleRate:   sampleRate,
+			TotalSamples: totalSamples,
+		}, nil
 	}

-	// Read metadata block header (4 bytes)
-	// Byte 0: bit 7 = last block flag, bits 0-6 = block type (0 = STREAMINFO)
-	// Bytes 1-3: block length (24-bit big-endian)
-	header := make([]byte, 4)
-	if _, err := file.Read(header); err != nil {
+	// Check if it's an M4A/MP4 file (starts with size + "ftyp")
+	// First 4 bytes are size, next 4 should be "ftyp"
+	file.Seek(0, 0) // Reset to beginning
+	header8 := make([]byte, 8)
+	if _, err := file.Read(header8); err != nil {
 		return AudioQuality{}, fmt.Errorf("failed to read header: %w", err)
 	}

-	blockType := header[0] & 0x7F
-	if blockType != 0 {
-		return AudioQuality{}, fmt.Errorf("first block is not STREAMINFO")
+	if string(header8[4:8]) == "ftyp" {
+		// It's an M4A/MP4 file, use M4A quality reader
+		file.Close() // Close before calling GetM4AQuality which opens the file again
+		return GetM4AQuality(filePath)
 	}

-	// Read STREAMINFO block (34 bytes minimum)
-	// Bytes 10-13 contain sample rate (20 bits), channels (3 bits), bits per sample (5 bits)
-	streamInfo := make([]byte, 34)
-	if _, err := file.Read(streamInfo); err != nil {
-		return AudioQuality{}, fmt.Errorf("failed to read STREAMINFO: %w", err)
-	}
-
-	// Parse sample rate (20 bits starting at byte 10)
-	// Bytes 10-12: [SSSS SSSS] [SSSS SSSS] [SSSS CCCC] where S=sample rate, C=channels
-	sampleRate := (int(streamInfo[10]) << 12) | (int(streamInfo[11]) << 4) | (int(streamInfo[12]) >> 4)
-
-	// Parse bits per sample (5 bits)
-	// Byte 12 bits 0-3 and byte 13 bit 7: [.... BBBB] [B...] where B=bits per sample - 1
-	bitsPerSample := ((int(streamInfo[12]) & 0x01) << 4) | (int(streamInfo[13]) >> 4) + 1
-
-	return AudioQuality{
-		BitDepth:   bitsPerSample,
-		SampleRate: sampleRate,
-	}, nil
+	return AudioQuality{}, fmt.Errorf("unsupported file format (not FLAC or M4A)")
+}
+
+// ========================================
+// M4A (MP4/AAC) Metadata Embedding
+// ========================================
+
+// EmbedM4AMetadata embeds metadata into an M4A file using iTunes-style atoms
+// This is a simplified implementation that writes metadata to the file
+func EmbedM4AMetadata(filePath string, metadata Metadata, coverData []byte) error {
+	// Read the entire file
+	data, err := os.ReadFile(filePath)
+	if err != nil {
+		return fmt.Errorf("failed to read M4A file: %w", err)
+	}
+
+	// Find moov atom position
+	moovPos := findAtom(data, "moov", 0)
+	if moovPos < 0 {
+		return fmt.Errorf("moov atom not found in M4A file")
+	}
+
+	// Find udta atom inside moov, or create one
+	moovSize := int(data[moovPos]<<24 | data[moovPos+1]<<16 | data[moovPos+2]<<8 | data[moovPos+3])
+	udtaPos := findAtom(data, "udta", moovPos+8)
+
+	// Build new metadata atoms
+	metaAtom := buildMetaAtom(metadata, coverData)
+
+	var newData []byte
+	if udtaPos >= 0 && udtaPos < moovPos+moovSize {
+		// udta exists, find meta inside it or replace
+		udtaSize := int(data[udtaPos]<<24 | data[udtaPos+1]<<16 | data[udtaPos+2]<<8 | data[udtaPos+3])
+		metaPos := findAtom(data, "meta", udtaPos+8)
+
+		if metaPos >= 0 && metaPos < udtaPos+udtaSize {
+			// Replace existing meta atom
+			metaSize := int(data[metaPos]<<24 | data[metaPos+1]<<16 | data[metaPos+2]<<8 | data[metaPos+3])
+			newData = append(newData, data[:metaPos]...)
+			newData = append(newData, metaAtom...)
+			newData = append(newData, data[metaPos+metaSize:]...)
+		} else {
+			// Add meta atom to udta
+			newUdtaContent := append(data[udtaPos+8:udtaPos+udtaSize], metaAtom...)
+			newUdtaSize := 8 + len(newUdtaContent)
+			newUdta := make([]byte, 4)
+			newUdta[0] = byte(newUdtaSize >> 24)
+			newUdta[1] = byte(newUdtaSize >> 16)
+			newUdta[2] = byte(newUdtaSize >> 8)
+			newUdta[3] = byte(newUdtaSize)
+			newUdta = append(newUdta, []byte("udta")...)
+			newUdta = append(newUdta, newUdtaContent...)
+
+			newData = append(newData, data[:udtaPos]...)
+			newData = append(newData, newUdta...)
+			newData = append(newData, data[udtaPos+udtaSize:]...)
+		}
+	} else {
+		// Create new udta with meta
+		udtaContent := metaAtom
+		udtaSize := 8 + len(udtaContent)
+		newUdta := make([]byte, 4)
+		newUdta[0] = byte(udtaSize >> 24)
+		newUdta[1] = byte(udtaSize >> 16)
+		newUdta[2] = byte(udtaSize >> 8)
+		newUdta[3] = byte(udtaSize)
+		newUdta = append(newUdta, []byte("udta")...)
+		newUdta = append(newUdta, udtaContent...)
+
+		// Insert udta at end of moov
+		insertPos := moovPos + moovSize
+		newData = append(newData, data[:insertPos]...)
+		newData = append(newData, newUdta...)
+		newData = append(newData, data[insertPos:]...)
+	}
+
+	// Update moov size
+	newMoovSize := moovSize + len(newData) - len(data)
+	newData[moovPos] = byte(newMoovSize >> 24)
+	newData[moovPos+1] = byte(newMoovSize >> 16)
+	newData[moovPos+2] = byte(newMoovSize >> 8)
+	newData[moovPos+3] = byte(newMoovSize)
+
+	// Write back to file
+	if err := os.WriteFile(filePath, newData, 0644); err != nil {
+		return fmt.Errorf("failed to write M4A file: %w", err)
+	}
+
+	fmt.Printf("[M4A] Metadata embedded successfully\n")
+	return nil
+}
+
+// findAtom finds an atom by name starting from offset
+func findAtom(data []byte, name string, offset int) int {
+	for i := offset; i < len(data)-8; {
+		size := int(data[i]<<24 | data[i+1]<<16 | data[i+2]<<8 | data[i+3])
+		if size < 8 {
+			break
+		}
+		atomName := string(data[i+4 : i+8])
+		if atomName == name {
+			return i
+		}
+		i += size
+	}
+	return -1
+}
+
+// buildMetaAtom builds a complete meta atom with ilst containing metadata
+func buildMetaAtom(metadata Metadata, coverData []byte) []byte {
+	// Build ilst content
+	var ilst []byte
+
+	// ©nam - Title
+	if metadata.Title != "" {
+		ilst = append(ilst, buildTextAtom("©nam", metadata.Title)...)
+	}
+
+	// ©ART - Artist
+	if metadata.Artist != "" {
+		ilst = append(ilst, buildTextAtom("©ART", metadata.Artist)...)
+	}
+
+	// ©alb - Album
+	if metadata.Album != "" {
+		ilst = append(ilst, buildTextAtom("©alb", metadata.Album)...)
+	}
+
+	// aART - Album Artist
+	if metadata.AlbumArtist != "" {
+		ilst = append(ilst, buildTextAtom("aART", metadata.AlbumArtist)...)
+	}
+
+	// ©day - Year/Date
+	if metadata.Date != "" {
+		ilst = append(ilst, buildTextAtom("©day", metadata.Date)...)
+	}
+
+	// trkn - Track Number
+	if metadata.TrackNumber > 0 {
+		ilst = append(ilst, buildTrackNumberAtom(metadata.TrackNumber, metadata.TotalTracks)...)
+	}
+
+	// disk - Disc Number
+	if metadata.DiscNumber > 0 {
+		ilst = append(ilst, buildDiscNumberAtom(metadata.DiscNumber, 0)...)
+	}
+
+	// ©lyr - Lyrics
+	if metadata.Lyrics != "" {
+		ilst = append(ilst, buildTextAtom("©lyr", metadata.Lyrics)...)
+	}
+
+	// covr - Cover Art
+	if len(coverData) > 0 {
+		ilst = append(ilst, buildCoverAtom(coverData)...)
+	}
+
+	// Build ilst atom
+	ilstSize := 8 + len(ilst)
+	ilstAtom := make([]byte, 4)
+	ilstAtom[0] = byte(ilstSize >> 24)
+	ilstAtom[1] = byte(ilstSize >> 16)
+	ilstAtom[2] = byte(ilstSize >> 8)
+	ilstAtom[3] = byte(ilstSize)
+	ilstAtom = append(ilstAtom, []byte("ilst")...)
+	ilstAtom = append(ilstAtom, ilst...)
+
+	// Build hdlr atom (required for meta)
+	hdlr := []byte{
+		0, 0, 0, 33, // size = 33
+		'h', 'd', 'l', 'r',
+		0, 0, 0, 0, // version + flags
+		0, 0, 0, 0, // predefined
+		'm', 'd', 'i', 'r', // handler type
+		'a', 'p', 'p', 'l', // manufacturer
+		0, 0, 0, 0, // component flags
+		0, 0, 0, 0, // component flags mask
+		0, // null terminator
+	}
+
+	// Build meta atom
+	metaContent := append([]byte{0, 0, 0, 0}, hdlr...) // version + flags + hdlr
+	metaContent = append(metaContent, ilstAtom...)
+
+	metaSize := 8 + len(metaContent)
+	metaAtom := make([]byte, 4)
+	metaAtom[0] = byte(metaSize >> 24)
+	metaAtom[1] = byte(metaSize >> 16)
+	metaAtom[2] = byte(metaSize >> 8)
+	metaAtom[3] = byte(metaSize)
+	metaAtom = append(metaAtom, []byte("meta")...)
+	metaAtom = append(metaAtom, metaContent...)
+
+	return metaAtom
+}
+
+// buildTextAtom builds a text metadata atom (©nam, ©ART, etc.)
+func buildTextAtom(name, value string) []byte {
+	valueBytes := []byte(value)
+
+	// data atom
+	dataSize := 16 + len(valueBytes)
+	dataAtom := make([]byte, 4)
+	dataAtom[0] = byte(dataSize >> 24)
+	dataAtom[1] = byte(dataSize >> 16)
+	dataAtom[2] = byte(dataSize >> 8)
+	dataAtom[3] = byte(dataSize)
+	dataAtom = append(dataAtom, []byte("data")...)
+	dataAtom = append(dataAtom, 0, 0, 0, 1) // type = UTF-8
+	dataAtom = append(dataAtom, 0, 0, 0, 0) // locale
+	dataAtom = append(dataAtom, valueBytes...)
+
+	// container atom
+	atomSize := 8 + len(dataAtom)
+	atom := make([]byte, 4)
+	atom[0] = byte(atomSize >> 24)
+	atom[1] = byte(atomSize >> 16)
+	atom[2] = byte(atomSize >> 8)
+	atom[3] = byte(atomSize)
+	atom = append(atom, []byte(name)...)
+	atom = append(atom, dataAtom...)
+
+	return atom
+}
+
+// buildTrackNumberAtom builds trkn atom
+func buildTrackNumberAtom(track, total int) []byte {
+	// data atom with track number
+	dataAtom := []byte{
+		0, 0, 0, 24, // size
+		'd', 'a', 't', 'a',
+		0, 0, 0, 0, // type = implicit
+		0, 0, 0, 0, // locale
+		0, 0, // padding
+		byte(track >> 8), byte(track), // track number
+		byte(total >> 8), byte(total), // total tracks
+		0, 0, // padding
+	}
+
+	// trkn atom
+	atomSize := 8 + len(dataAtom)
+	atom := make([]byte, 4)
+	atom[0] = byte(atomSize >> 24)
+	atom[1] = byte(atomSize >> 16)
+	atom[2] = byte(atomSize >> 8)
+	atom[3] = byte(atomSize)
+	atom = append(atom, []byte("trkn")...)
+	atom = append(atom, dataAtom...)
+
+	return atom
+}
+
+// buildDiscNumberAtom builds disk atom
+func buildDiscNumberAtom(disc, total int) []byte {
+	// data atom with disc number
+	dataAtom := []byte{
+		0, 0, 0, 22, // size
+		'd', 'a', 't', 'a',
+		0, 0, 0, 0, // type = implicit
+		0, 0, 0, 0, // locale
+		0, 0, // padding
+		byte(disc >> 8), byte(disc), // disc number
+		byte(total >> 8), byte(total), // total discs
+	}
+
+	// disk atom
+	atomSize := 8 + len(dataAtom)
+	atom := make([]byte, 4)
+	atom[0] = byte(atomSize >> 24)
+	atom[1] = byte(atomSize >> 16)
+	atom[2] = byte(atomSize >> 8)
+	atom[3] = byte(atomSize)
+	atom = append(atom, []byte("disk")...)
+	atom = append(atom, dataAtom...)
+
+	return atom
+}
+
+// buildCoverAtom builds covr atom with image data
+func buildCoverAtom(coverData []byte) []byte {
+	// Detect image type (JPEG = 13, PNG = 14)
+	imageType := byte(13) // default JPEG
+	if len(coverData) > 8 && coverData[0] == 0x89 && coverData[1] == 'P' && coverData[2] == 'N' && coverData[3] == 'G' {
+		imageType = 14 // PNG
+	}
+
+	// data atom
+	dataSize := 16 + len(coverData)
+	dataAtom := make([]byte, 4)
+	dataAtom[0] = byte(dataSize >> 24)
+	dataAtom[1] = byte(dataSize >> 16)
+	dataAtom[2] = byte(dataSize >> 8)
+	dataAtom[3] = byte(dataSize)
+	dataAtom = append(dataAtom, []byte("data")...)
+	dataAtom = append(dataAtom, 0, 0, 0, imageType) // type = JPEG or PNG
+	dataAtom = append(dataAtom, 0, 0, 0, 0)         // locale
+	dataAtom = append(dataAtom, coverData...)
+
+	// covr atom
+	atomSize := 8 + len(dataAtom)
+	atom := make([]byte, 4)
+	atom[0] = byte(atomSize >> 24)
+	atom[1] = byte(atomSize >> 16)
+	atom[2] = byte(atomSize >> 8)
+	atom[3] = byte(atomSize)
+	atom = append(atom, []byte("covr")...)
+	atom = append(atom, dataAtom...)
+
+	return atom
+}
+
+// GetM4AQuality reads audio quality from M4A file
+func GetM4AQuality(filePath string) (AudioQuality, error) {
+	data, err := os.ReadFile(filePath)
+	if err != nil {
+		return AudioQuality{}, fmt.Errorf("failed to read M4A file: %w", err)
+	}
+
+	// Find moov -> trak -> mdia -> minf -> stbl -> stsd
+	moovPos := findAtom(data, "moov", 0)
+	if moovPos < 0 {
+		return AudioQuality{}, fmt.Errorf("moov atom not found")
+	}
+
+	// Search for mp4a or alac atom which contains audio info
+	// This is a simplified search - real implementation would traverse the atom tree
+	for i := moovPos; i < len(data)-20; i++ {
+		if string(data[i:i+4]) == "mp4a" || string(data[i:i+4]) == "alac" {
+			// Sample rate is at offset 22-23 from atom start (16-bit big-endian)
+			if i+24 < len(data) {
+				sampleRate := int(data[i+22])<<8 | int(data[i+23])
+				// For AAC, bit depth is typically 16
+				bitDepth := 16
+				if string(data[i:i+4]) == "alac" {
+					// ALAC can have higher bit depth, check esds or alac specific data
+					bitDepth = 24 // Assume 24-bit for ALAC
+				}
+				return AudioQuality{BitDepth: bitDepth, SampleRate: sampleRate}, nil
+			}
+		}
+	}
+
+	return AudioQuality{}, fmt.Errorf("audio info not found in M4A file")
 }
@@ -165,7 +165,8 @@ func FetchCoverAndLyricsParallel(
 				fmt.Printf("[Parallel] Lyrics fetch failed: %v\n", err)
 			} else if lyrics != nil && len(lyrics.Lines) > 0 {
 				result.LyricsData = lyrics
-				result.LyricsLRC = convertToLRC(lyrics)
+				// Use LRC with metadata headers (like PC version)
+				result.LyricsLRC = convertToLRCWithMetadata(lyrics, trackName, artistName)
 				fmt.Printf("[Parallel] Lyrics fetched: %d lines\n", len(lyrics.Lines))
 			} else {
 				result.LyricsErr = fmt.Errorf("no lyrics found")
@@ -232,7 +233,7 @@ func PreWarmTrackCache(requests []PreWarmCacheRequest) {
 	fmt.Printf("[Cache] Pre-warm complete. Cache size: %d\n", cache.Size())
 }

-func preWarmTidalCache(isrc, trackName, artistName string) {
+func preWarmTidalCache(isrc, _, _ string) {
 	downloader := NewTidalDownloader()
 	track, err := downloader.SearchTrackByISRC(isrc)
 	if err == nil && track != nil {
@@ -271,7 +272,7 @@ func PreWarmCache(tracksJSON string) error {
 	var requests []PreWarmCacheRequest
 	// Parse JSON (simplified - in production use proper JSON parsing)
 	// For now, this is called from exports.go with proper parsing
-	
+
 	go PreWarmTrackCache(requests) // Run in background
 	return nil
 }
@@ -3,6 +3,7 @@ package gobackend
 import (
 	"encoding/json"
 	"sync"
+	"time"
 )

 // DownloadProgress represents current download progress
@@ -22,7 +23,8 @@ type ItemProgress struct {
 	ItemID        string  `json:"item_id"`
 	BytesTotal    int64   `json:"bytes_total"`
 	BytesReceived int64   `json:"bytes_received"`
-	Progress      float64 `json:"progress"` // 0.0 to 1.0
+	Progress      float64 `json:"progress"`   // 0.0 to 1.0
+	SpeedMBps     float64 `json:"speed_mbps"` // Download speed in MB/s
 	IsDownloading bool    `json:"is_downloading"`
 	Status        string  `json:"status"` // "downloading", "finalizing", "completed"
 }
@@ -124,6 +126,20 @@ func SetItemBytesReceived(itemID string, received int64) {
 	}
 }

+// SetItemBytesReceivedWithSpeed sets bytes received and speed for an item
+func SetItemBytesReceivedWithSpeed(itemID string, received int64, speedMBps float64) {
+	multiMu.Lock()
+	defer multiMu.Unlock()
+
+	if item, ok := multiProgress.Items[itemID]; ok {
+		item.BytesReceived = received
+		item.SpeedMBps = speedMBps
+		if item.BytesTotal > 0 {
+			item.Progress = float64(received) / float64(item.BytesTotal)
+		}
+	}
+}
+
 // CompleteItemProgress marks an item as complete
 func CompleteItemProgress(itemID string) {
 	multiMu.Lock()
@@ -188,46 +204,64 @@ func setDownloadDir(path string) error {
 }

 // getDownloadDir returns the default download directory
-func getDownloadDir() string {
-	downloadDirMu.RLock()
-	defer downloadDirMu.RUnlock()
-	return downloadDir
-}
+// Kept for potential future use
+// func getDownloadDir() string {
+// 	downloadDirMu.RLock()
+// 	defer downloadDirMu.RUnlock()
+// 	return downloadDir
+// }

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

-const progressWriterBufferSize = 256 * 1024 // 256KB buffer for faster writes
+const progressUpdateThreshold = 64 * 1024 // Update progress every 64KB

 // NewItemProgressWriter creates a new progress writer for a specific item
 func NewItemProgressWriter(w interface{ Write([]byte) (int, error) }, itemID string) *ItemProgressWriter {
+	now := time.Now()
 	return &ItemProgressWriter{
-		writer:  w,
-		itemID:  itemID,
-		current: 0,
-		buffer:  make([]byte, progressWriterBufferSize),
-		bufPos:  0,
+		writer:       w,
+		itemID:       itemID,
+		current:      0,
+		lastReported: 0,
+		startTime:    now,
+		lastTime:     now,
+		lastBytes:    0,
 	}
 }

-// Write implements io.Writer with buffering
+// Write implements io.Writer with threshold-based progress updates and speed tracking
 func (pw *ItemProgressWriter) Write(p []byte) (int, error) {
 	n, err := pw.writer.Write(p)
 	if err != nil {
 		return n, err
 	}
 	pw.current += int64(n)
-	
-	// Update progress less frequently (every 64KB) to reduce lock contention
-	if pw.current%(64*1024) == 0 || pw.current == 0 {
-		SetItemBytesReceived(pw.itemID, pw.current)
+
+	// Update progress when we've received at least 64KB since last update
+	// Also update on first write to show download has started
+	if pw.lastReported == 0 || pw.current-pw.lastReported >= progressUpdateThreshold {
+		// Calculate speed (MB/s) based on bytes received since last update
+		now := time.Now()
+		elapsed := now.Sub(pw.lastTime).Seconds()
+		var speedMBps float64
+		if elapsed > 0 {
+			bytesInInterval := pw.current - pw.lastBytes
+			speedMBps = float64(bytesInInterval) / (1024 * 1024) / elapsed
+		}
+
+		SetItemBytesReceivedWithSpeed(pw.itemID, pw.current, speedMBps)
+		pw.lastReported = pw.current
+		pw.lastTime = now
+		pw.lastBytes = pw.current
 	}
 	return n, nil
 }
@@ -52,59 +52,245 @@ type QobuzTrack struct {
 func qobuzArtistsMatch(expectedArtist, foundArtist string) bool {
 	normExpected := strings.ToLower(strings.TrimSpace(expectedArtist))
 	normFound := strings.ToLower(strings.TrimSpace(foundArtist))
-	
+
 	// Exact match
 	if normExpected == normFound {
 		return true
 	}
-	
+
 	// Check if one contains the other
 	if strings.Contains(normExpected, normFound) || strings.Contains(normFound, normExpected) {
 		return true
 	}
-	
+
 	// Check first artist (before comma or feat)
 	expectedFirst := strings.Split(normExpected, ",")[0]
 	expectedFirst = strings.Split(expectedFirst, " feat")[0]
 	expectedFirst = strings.Split(expectedFirst, " ft.")[0]
 	expectedFirst = strings.TrimSpace(expectedFirst)
-	
+
 	foundFirst := strings.Split(normFound, ",")[0]
 	foundFirst = strings.Split(foundFirst, " feat")[0]
 	foundFirst = strings.Split(foundFirst, " ft.")[0]
 	foundFirst = strings.TrimSpace(foundFirst)
-	
+
 	if expectedFirst == foundFirst {
 		return true
 	}
-	
+
 	// Check if first artist is contained in the other
 	if strings.Contains(expectedFirst, foundFirst) || strings.Contains(foundFirst, expectedFirst) {
 		return true
 	}
-	
-	// If scripts are different (one is ASCII, one is non-ASCII like Japanese/Chinese/Korean),
-	// assume they're the same artist with different transliteration
-	expectedASCII := qobuzIsASCIIString(expectedArtist)
-	foundASCII := qobuzIsASCIIString(foundArtist)
-	if expectedASCII != foundASCII {
-		fmt.Printf("[Qobuz] Artist names in different scripts, assuming match: '%s' vs '%s'\n", expectedArtist, foundArtist)
+
+	// If scripts are TRULY different (Latin vs CJK/Arabic/Cyrillic), assume match (transliteration)
+	// Don't treat Latin Extended (Polish, French, etc.) as different script
+	expectedLatin := qobuzIsLatinScript(expectedArtist)
+	foundLatin := qobuzIsLatinScript(foundArtist)
+	if expectedLatin != foundLatin {
+		GoLog("[Qobuz] Artist names in different scripts, assuming match: '%s' vs '%s'\n", expectedArtist, foundArtist)
 		return true
 	}
-	
+
 	return false
 }

-// qobuzIsASCIIString checks if a string contains only ASCII characters
-func qobuzIsASCIIString(s string) bool {
+// qobuzTitlesMatch checks if track titles are similar enough
+func qobuzTitlesMatch(expectedTitle, foundTitle string) bool {
+	normExpected := strings.ToLower(strings.TrimSpace(expectedTitle))
+	normFound := strings.ToLower(strings.TrimSpace(foundTitle))
+
+	// Exact match
+	if normExpected == normFound {
+		return true
+	}
+
+	// Check if one contains the other
+	if strings.Contains(normExpected, normFound) || strings.Contains(normFound, normExpected) {
+		return true
+	}
+
+	// Clean BOTH titles and compare (removes suffixes like remaster, remix, etc)
+	cleanExpected := qobuzCleanTitle(normExpected)
+	cleanFound := qobuzCleanTitle(normFound)
+
+	if cleanExpected == cleanFound {
+		return true
+	}
+
+	// Check if cleaned versions contain each other
+	if cleanExpected != "" && cleanFound != "" {
+		if strings.Contains(cleanExpected, cleanFound) || strings.Contains(cleanFound, cleanExpected) {
+			return true
+		}
+	}
+
+	// Extract core title (before any parentheses/brackets)
+	coreExpected := qobuzExtractCoreTitle(normExpected)
+	coreFound := qobuzExtractCoreTitle(normFound)
+
+	if coreExpected != "" && coreFound != "" && coreExpected == coreFound {
+		return true
+	}
+
+	// If scripts are TRULY different (Latin vs CJK/Arabic/Cyrillic), assume match (transliteration)
+	// Don't treat Latin Extended (Polish, French, etc.) as different script
+	expectedLatin := qobuzIsLatinScript(expectedTitle)
+	foundLatin := qobuzIsLatinScript(foundTitle)
+	if expectedLatin != foundLatin {
+		GoLog("[Qobuz] Titles in different scripts, assuming match: '%s' vs '%s'\n", expectedTitle, foundTitle)
+		return true
+	}
+
+	return false
+}
+
+// qobuzExtractCoreTitle extracts the main title before any parentheses or brackets
+func qobuzExtractCoreTitle(title string) string {
+	// Find first occurrence of ( or [
+	parenIdx := strings.Index(title, "(")
+	bracketIdx := strings.Index(title, "[")
+	dashIdx := strings.Index(title, " - ")
+
+	cutIdx := len(title)
+	if parenIdx > 0 && parenIdx < cutIdx {
+		cutIdx = parenIdx
+	}
+	if bracketIdx > 0 && bracketIdx < cutIdx {
+		cutIdx = bracketIdx
+	}
+	if dashIdx > 0 && dashIdx < cutIdx {
+		cutIdx = dashIdx
+	}
+
+	return strings.TrimSpace(title[:cutIdx])
+}
+
+// qobuzCleanTitle removes common suffixes from track titles for comparison
+func qobuzCleanTitle(title string) string {
+	cleaned := title
+
+	// Remove content in parentheses/brackets that are version indicators
+	// This helps match "Song (Remastered)" with "Song" or "Song (2024 Remaster)"
+	versionPatterns := []string{
+		"remaster", "remastered", "deluxe", "bonus", "single",
+		"album version", "radio edit", "original mix", "extended",
+		"club mix", "remix", "live", "acoustic", "demo",
+	}
+
+	// Remove parenthetical content if it contains version indicators
+	for {
+		startParen := strings.LastIndex(cleaned, "(")
+		endParen := strings.LastIndex(cleaned, ")")
+		if startParen >= 0 && endParen > startParen {
+			content := strings.ToLower(cleaned[startParen+1 : endParen])
+			isVersionIndicator := false
+			for _, pattern := range versionPatterns {
+				if strings.Contains(content, pattern) {
+					isVersionIndicator = true
+					break
+				}
+			}
+			if isVersionIndicator {
+				cleaned = strings.TrimSpace(cleaned[:startParen]) + cleaned[endParen+1:]
+				continue
+			}
+		}
+		break
+	}
+
+	// Same for brackets
+	for {
+		startBracket := strings.LastIndex(cleaned, "[")
+		endBracket := strings.LastIndex(cleaned, "]")
+		if startBracket >= 0 && endBracket > startBracket {
+			content := strings.ToLower(cleaned[startBracket+1 : endBracket])
+			isVersionIndicator := false
+			for _, pattern := range versionPatterns {
+				if strings.Contains(content, pattern) {
+					isVersionIndicator = true
+					break
+				}
+			}
+			if isVersionIndicator {
+				cleaned = strings.TrimSpace(cleaned[:startBracket]) + cleaned[endBracket+1:]
+				continue
+			}
+		}
+		break
+	}
+
+	// Remove trailing " - version" patterns
+	dashPatterns := []string{
+		" - remaster", " - remastered", " - single version", " - radio edit",
+		" - live", " - acoustic", " - demo", " - remix",
+	}
+	for _, pattern := range dashPatterns {
+		if strings.HasSuffix(strings.ToLower(cleaned), pattern) {
+			cleaned = cleaned[:len(cleaned)-len(pattern)]
+		}
+	}
+
+	// Remove multiple spaces
+	for strings.Contains(cleaned, "  ") {
+		cleaned = strings.ReplaceAll(cleaned, "  ", " ")
+	}
+
+	return strings.TrimSpace(cleaned)
+}
+
+// qobuzIsLatinScript checks if a string is primarily Latin script
+// Returns true for ASCII and Latin Extended characters (European languages)
+// Returns false for CJK, Arabic, Cyrillic, etc.
+func qobuzIsLatinScript(s string) bool {
 	for _, r := range s {
-		if r > 127 {
+		// Skip common punctuation and numbers
+		if r < 128 {
+			continue
+		}
+		// Latin Extended-A: U+0100 to U+017F (Polish, Czech, etc.)
+		// Latin Extended-B: U+0180 to U+024F
+		// Latin Extended Additional: U+1E00 to U+1EFF
+		// Latin Extended-C/D/E: various ranges
+		if (r >= 0x0100 && r <= 0x024F) || // Latin Extended A & B
+			(r >= 0x1E00 && r <= 0x1EFF) || // Latin Extended Additional
+			(r >= 0x00C0 && r <= 0x00FF) { // Latin-1 Supplement (accented chars)
+			continue
+		}
+		// CJK ranges - definitely different script
+		if (r >= 0x4E00 && r <= 0x9FFF) || // CJK Unified Ideographs
+			(r >= 0x3040 && r <= 0x309F) || // Hiragana
+			(r >= 0x30A0 && r <= 0x30FF) || // Katakana
+			(r >= 0xAC00 && r <= 0xD7AF) || // Hangul (Korean)
+			(r >= 0x0600 && r <= 0x06FF) || // Arabic
+			(r >= 0x0400 && r <= 0x04FF) { // Cyrillic
 			return false
 		}
 	}
 	return true
 }

+// qobuzIsASCIIString checks if a string contains only ASCII characters
+// Kept for potential future use
+// func qobuzIsASCIIString(s string) bool {
+// 	for _, r := range s {
+// 		if r > 127 {
+// 			return false
+// 		}
+// 	}
+// 	return true
+// }
+
+// containsQueryQobuz checks if a query already exists in the list
+func containsQueryQobuz(queries []string, query string) bool {
+	for _, q := range queries {
+		if q == query {
+			return true
+		}
+	}
+	return false
+}
+
 // NewQobuzDownloader creates a new Qobuz downloader (returns singleton for connection reuse)
 func NewQobuzDownloader() *QobuzDownloader {
 	qobuzDownloaderOnce.Do(func() {
@@ -122,8 +308,8 @@ func (q *QobuzDownloader) GetAvailableAPIs() []string {
 	// Same APIs as PC version (referensi/backend/qobuz.go)
 	// Primary: dab.yeet.su, Fallback: dabmusic.xyz
 	encodedAPIs := []string{
-		"ZGFiLnllZXQuc3UvYXBpL3N0cmVhbT90cmFja0lkPQ==",     // dab.yeet.su/api/stream?trackId= (PRIMARY - same as PC)
-		"ZGFibXVzaWMueHl6L2FwaS9zdHJlYW0/dHJhY2tJZD0=",     // dabmusic.xyz/api/stream?trackId= (FALLBACK - same as PC)
+		"ZGFiLnllZXQuc3UvYXBpL3N0cmVhbT90cmFja0lkPQ==", // dab.yeet.su/api/stream?trackId= (PRIMARY - same as PC)
+		"ZGFibXVzaWMueHl6L2FwaS9zdHJlYW0/dHJhY2tJZD0=", // dabmusic.xyz/api/stream?trackId= (FALLBACK - same as PC)
 	}

 	var apis []string
@@ -184,6 +370,8 @@ func (q *QobuzDownloader) SearchTrackByISRC(isrc string) (*QobuzTrack, error) {
 // SearchTrackByISRCWithTitle searches for a track by ISRC with duration verification
 // expectedDurationSec is the expected duration in seconds (0 to skip verification)
 func (q *QobuzDownloader) SearchTrackByISRCWithDuration(isrc string, expectedDurationSec int) (*QobuzTrack, error) {
+	GoLog("[Qobuz] Searching by ISRC: %s\n", isrc)
+
 	apiBase, _ := base64.StdEncoding.DecodeString("aHR0cHM6Ly93d3cucW9idXouY29tL2FwaS5qc29uLzAuMi90cmFjay9zZWFyY2g/cXVlcnk9")
 	searchURL := fmt.Sprintf("%s%s&limit=50&app_id=%s", string(apiBase), url.QueryEscape(isrc), q.appID)

@@ -211,6 +399,8 @@ func (q *QobuzDownloader) SearchTrackByISRCWithDuration(isrc string, expectedDur
 		return nil, err
 	}

+	GoLog("[Qobuz] ISRC search returned %d results\n", len(result.Tracks.Items))
+
 	// Find ISRC matches
 	var isrcMatches []*QobuzTrack
 	for i := range result.Tracks.Items {
@@ -219,6 +409,8 @@ func (q *QobuzDownloader) SearchTrackByISRCWithDuration(isrc string, expectedDur
 		}
 	}

+	GoLog("[Qobuz] Found %d exact ISRC matches\n", len(isrcMatches))
+
 	if len(isrcMatches) > 0 {
 		// Verify duration if provided
 		if expectedDurationSec > 0 {
@@ -228,27 +420,27 @@ func (q *QobuzDownloader) SearchTrackByISRCWithDuration(isrc string, expectedDur
 				if durationDiff < 0 {
 					durationDiff = -durationDiff
 				}
-				// Allow 30 seconds tolerance
-				if durationDiff <= 30 {
+				// Allow 10 seconds tolerance
+				if durationDiff <= 10 {
 					durationVerifiedMatches = append(durationVerifiedMatches, track)
 				}
 			}
-			
+
 			if len(durationVerifiedMatches) > 0 {
-				fmt.Printf("[Qobuz] ISRC match with duration verification: '%s' (expected %ds, found %ds)\n", 
+				GoLog("[Qobuz] ISRC match with duration verification: '%s' (expected %ds, found %ds)\n",
 					durationVerifiedMatches[0].Title, expectedDurationSec, durationVerifiedMatches[0].Duration)
 				return durationVerifiedMatches[0], nil
 			}
-			
+
 			// ISRC matches but duration doesn't
-			fmt.Printf("[Qobuz] WARNING: ISRC %s found but duration mismatch. Expected=%ds, Found=%ds. Rejecting.\n", 
+			GoLog("[Qobuz] WARNING: ISRC %s found but duration mismatch. Expected=%ds, Found=%ds. Rejecting.\n",
 				isrc, expectedDurationSec, isrcMatches[0].Duration)
-			return nil, fmt.Errorf("ISRC found but duration mismatch: expected %ds, found %ds (likely different version)", 
+			return nil, fmt.Errorf("ISRC found but duration mismatch: expected %ds, found %ds (likely different version)",
 				expectedDurationSec, isrcMatches[0].Duration)
 		}
-		
+
 		// No duration to verify, return first match
-		fmt.Printf("[Qobuz] ISRC match (no duration verification): '%s'\n", isrcMatches[0].Title)
+		GoLog("[Qobuz] ISRC match (no duration verification): '%s'\n", isrcMatches[0].Title)
 		return isrcMatches[0], nil
 	}

@@ -270,10 +462,12 @@ func (q *QobuzDownloader) SearchTrackByMetadata(trackName, artistName string) (*
 }

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

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

 	// Strategy 1: Artist + Track name
@@ -286,10 +480,54 @@ func (q *QobuzDownloader) SearchTrackByMetadataWithDuration(trackName, artistNam
 		queries = append(queries, trackName)
 	}

+	// Strategy 3: Romaji versions if Japanese detected
+	if ContainsJapanese(trackName) || ContainsJapanese(artistName) {
+		// Convert to romaji (hiragana/katakana only, kanji stays)
+		romajiTrack := JapaneseToRomaji(trackName)
+		romajiArtist := JapaneseToRomaji(artistName)
+
+		// Clean and remove ALL non-ASCII characters (including kanji)
+		cleanRomajiTrack := CleanToASCII(romajiTrack)
+		cleanRomajiArtist := CleanToASCII(romajiArtist)
+
+		// Artist + Track romaji (cleaned to ASCII only)
+		if cleanRomajiArtist != "" && cleanRomajiTrack != "" {
+			romajiQuery := cleanRomajiArtist + " " + cleanRomajiTrack
+			if !containsQueryQobuz(queries, romajiQuery) {
+				queries = append(queries, romajiQuery)
+				GoLog("[Qobuz] Japanese detected, adding romaji query: %s\n", romajiQuery)
+			}
+		}
+
+		// Track romaji only (cleaned)
+		if cleanRomajiTrack != "" && cleanRomajiTrack != trackName {
+			if !containsQueryQobuz(queries, cleanRomajiTrack) {
+				queries = append(queries, cleanRomajiTrack)
+			}
+		}
+	}
+
+	// Strategy 4: Artist only as last resort
+	if artistName != "" {
+		artistOnly := CleanToASCII(JapaneseToRomaji(artistName))
+		if artistOnly != "" && !containsQueryQobuz(queries, artistOnly) {
+			queries = append(queries, artistOnly)
+		}
+	}
+
 	var allTracks []QobuzTrack
+	searchedQueries := make(map[string]bool)

 	for _, query := range queries {
-		searchURL := fmt.Sprintf("%s%s&limit=50&app_id=%s", string(apiBase), url.QueryEscape(query), q.appID)
+		cleanQuery := strings.TrimSpace(query)
+		if cleanQuery == "" || searchedQueries[cleanQuery] {
+			continue
+		}
+		searchedQueries[cleanQuery] = true
+
+		GoLog("[Qobuz] Searching for: %s\n", cleanQuery)
+
+		searchURL := fmt.Sprintf("%s%s&limit=50&app_id=%s", string(apiBase), url.QueryEscape(cleanQuery), q.appID)

 		req, err := http.NewRequest("GET", searchURL, nil)
 		if err != nil {
@@ -298,6 +536,7 @@ func (q *QobuzDownloader) SearchTrackByMetadataWithDuration(trackName, artistNam

 		resp, err := DoRequestWithUserAgent(q.client, req)
 		if err != nil {
+			GoLog("[Qobuz] Search error for '%s': %v\n", cleanQuery, err)
 			continue
 		}

@@ -318,6 +557,7 @@ func (q *QobuzDownloader) SearchTrackByMetadataWithDuration(trackName, artistNam
 		resp.Body.Close()

 		if len(result.Tracks.Items) > 0 {
+			GoLog("[Qobuz] Found %d results for '%s'\n", len(result.Tracks.Items), cleanQuery)
 			allTracks = append(allTracks, result.Tracks.Items...)
 		}
 	}
@@ -326,16 +566,35 @@ func (q *QobuzDownloader) SearchTrackByMetadataWithDuration(trackName, artistNam
 		return nil, fmt.Errorf("no tracks found for: %s - %s", artistName, trackName)
 	}

+	// Filter by title match first (NEW - like Tidal)
+	var titleMatches []*QobuzTrack
+	for i := range allTracks {
+		track := &allTracks[i]
+		if qobuzTitlesMatch(trackName, track.Title) {
+			titleMatches = append(titleMatches, track)
+		}
+	}
+
+	GoLog("[Qobuz] Title matches: %d out of %d results\n", len(titleMatches), len(allTracks))
+
+	// If no title matches, log warning but continue with all tracks
+	tracksToCheck := titleMatches
+	if len(titleMatches) == 0 {
+		GoLog("[Qobuz] WARNING: No title matches for '%s', checking all %d results\n", trackName, len(allTracks))
+		for i := range allTracks {
+			tracksToCheck = append(tracksToCheck, &allTracks[i])
+		}
+	}
+
 	// If duration verification is requested
 	if expectedDurationSec > 0 {
 		var durationMatches []*QobuzTrack
-		for i := range allTracks {
-			track := &allTracks[i]
+		for _, track := range tracksToCheck {
 			durationDiff := track.Duration - expectedDurationSec
 			if durationDiff < 0 {
 				durationDiff = -durationDiff
 			}
-			if durationDiff <= 30 {
+			if durationDiff <= 10 {
 				durationMatches = append(durationMatches, track)
 			}
 		}
@@ -344,24 +603,36 @@ func (q *QobuzDownloader) SearchTrackByMetadataWithDuration(trackName, artistNam
 			// Return best quality among duration matches
 			for _, track := range durationMatches {
 				if track.MaximumBitDepth >= 24 {
+					GoLog("[Qobuz] ✓ Match found: '%s' by '%s' (title+duration verified, hi-res)\n",
+						track.Title, track.Performer.Name)
 					return track, nil
 				}
 			}
+			GoLog("[Qobuz] ✓ Match found: '%s' by '%s' (title+duration verified)\n",
+				durationMatches[0].Title, durationMatches[0].Performer.Name)
 			return durationMatches[0], nil
 		}

 		// No duration match found
-		return nil, fmt.Errorf("no tracks found with matching duration (expected %ds)", expectedDurationSec)
+		return nil, fmt.Errorf("no tracks found with matching title and duration (expected '%s', %ds)", trackName, expectedDurationSec)
 	}

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

 // getQobuzDownloadURLSequential requests download URL from APIs sequentially
@@ -380,7 +651,7 @@ func getQobuzDownloadURLSequential(apis []string, trackID int64, quality string)
 		// The apiURL already includes the path, just append trackID and quality
 		reqURL := fmt.Sprintf("%s%d&quality=%s", apiURL, trackID, quality)

-		fmt.Printf("[Qobuz] Trying: %s\n", reqURL)
+		GoLog("[Qobuz] Trying: %s\n", reqURL)

 		req, err := http.NewRequest("GET", reqURL, nil)
 		if err != nil {
@@ -425,7 +696,7 @@ func getQobuzDownloadURLSequential(apis []string, trackID int64, quality string)
 		}

 		if result.URL != "" {
-			fmt.Printf("[Qobuz] Got download URL from: %s\n", apiURL)
+			GoLog("[Qobuz] Got download URL from: %s\n", apiURL)
 			return apiURL, result.URL, nil
 		}

@@ -473,37 +744,69 @@ func (q *QobuzDownloader) DownloadFile(downloadURL, outputPath, itemID string) e
 		return fmt.Errorf("download failed: HTTP %d", resp.StatusCode)
 	}

+	expectedSize := resp.ContentLength
 	// Set total bytes if available
-	if resp.ContentLength > 0 && itemID != "" {
-		SetItemBytesTotal(itemID, resp.ContentLength)
+	if expectedSize > 0 && itemID != "" {
+		SetItemBytesTotal(itemID, expectedSize)
 	}

 	out, err := os.Create(outputPath)
 	if err != nil {
 		return err
 	}
-	defer out.Close()

 	// Use buffered writer for better performance (256KB buffer)
 	bufWriter := bufio.NewWriterSize(out, 256*1024)
-	defer bufWriter.Flush()

 	// Use item progress writer with buffered output
+	var written int64
 	if itemID != "" {
 		progressWriter := NewItemProgressWriter(bufWriter, itemID)
-		_, err = io.Copy(progressWriter, resp.Body)
+		written, err = io.Copy(progressWriter, resp.Body)
 	} else {
 		// Fallback: direct copy without progress tracking
-		_, err = io.Copy(bufWriter, resp.Body)
+		written, err = io.Copy(bufWriter, resp.Body)
 	}
-	return err
+
+	// Flush buffer before checking for errors
+	flushErr := bufWriter.Flush()
+	closeErr := out.Close()
+
+	// Check for any errors
+	if err != nil {
+		os.Remove(outputPath)
+		return fmt.Errorf("download interrupted: %w", err)
+	}
+	if flushErr != nil {
+		os.Remove(outputPath)
+		return fmt.Errorf("failed to flush buffer: %w", flushErr)
+	}
+	if closeErr != nil {
+		os.Remove(outputPath)
+		return fmt.Errorf("failed to close file: %w", closeErr)
+	}
+
+	// Verify file size if Content-Length was provided
+	if expectedSize > 0 && written != expectedSize {
+		os.Remove(outputPath)
+		return fmt.Errorf("incomplete download: expected %d bytes, got %d bytes", expectedSize, written)
+	}
+
+	return nil
 }

 // QobuzDownloadResult contains download result with quality info
 type QobuzDownloadResult struct {
-	FilePath   string
-	BitDepth   int
-	SampleRate int
+	FilePath    string
+	BitDepth    int
+	SampleRate  int
+	Title       string
+	Artist      string
+	Album       string
+	ReleaseDate string
+	TrackNumber int
+	DiscNumber  int
+	ISRC        string
 }

 // downloadFromQobuz downloads a track using the request parameters
@@ -524,11 +827,11 @@ func downloadFromQobuz(req DownloadRequest) (QobuzDownloadResult, error) {
 	// OPTIMIZATION: Check cache first for track ID
 	if req.ISRC != "" {
 		if cached := GetTrackIDCache().Get(req.ISRC); cached != nil && cached.QobuzTrackID > 0 {
-			fmt.Printf("[Qobuz] Cache hit! Using cached track ID: %d\n", cached.QobuzTrackID)
+			GoLog("[Qobuz] Cache hit! Using cached track ID: %d\n", cached.QobuzTrackID)
 			// For Qobuz we need to search again to get full track info, but we can use the ID
 			track, err = downloader.SearchTrackByISRC(req.ISRC)
 			if err != nil {
-				fmt.Printf("[Qobuz] Cache hit but search failed: %v\n", err)
+				GoLog("[Qobuz] Cache hit but search failed: %v\n", err)
 				track = nil
 			}
 		}
@@ -536,21 +839,28 @@ func downloadFromQobuz(req DownloadRequest) (QobuzDownloadResult, error) {

 	// Strategy 1: Search by ISRC with duration verification
 	if track == nil && req.ISRC != "" {
+		GoLog("[Qobuz] Trying ISRC search: %s\n", req.ISRC)
 		track, err = downloader.SearchTrackByISRCWithDuration(req.ISRC, expectedDurationSec)
-		// Verify artist
-		if track != nil && !qobuzArtistsMatch(req.ArtistName, track.Performer.Name) {
-			fmt.Printf("[Qobuz] Artist mismatch from ISRC search: expected '%s', got '%s'. Rejecting.\n", 
-				req.ArtistName, track.Performer.Name)
-			track = nil
+		// Verify artist AND title
+		if track != nil {
+			if !qobuzArtistsMatch(req.ArtistName, track.Performer.Name) {
+				GoLog("[Qobuz] Artist mismatch from ISRC search: expected '%s', got '%s'. Rejecting.\n",
+					req.ArtistName, track.Performer.Name)
+				track = nil
+			} else if !qobuzTitlesMatch(req.TrackName, track.Title) {
+				GoLog("[Qobuz] Title mismatch from ISRC search: expected '%s', got '%s'. Rejecting.\n",
+					req.TrackName, track.Title)
+				track = nil
+			}
 		}
 	}

-	// Strategy 2: Search by metadata with duration verification
+	// Strategy 2: Search by metadata with duration verification (includes title verification)
 	if track == nil {
 		track, err = downloader.SearchTrackByMetadataWithDuration(req.TrackName, req.ArtistName, expectedDurationSec)
-		// Verify artist
+		// Verify artist (title already verified in SearchTrackByMetadataWithDuration)
 		if track != nil && !qobuzArtistsMatch(req.ArtistName, track.Performer.Name) {
-			fmt.Printf("[Qobuz] Artist mismatch from metadata search: expected '%s', got '%s'. Rejecting.\n", 
+			GoLog("[Qobuz] Artist mismatch from metadata search: expected '%s', got '%s'. Rejecting.\n",
 				req.ArtistName, track.Performer.Name)
 			track = nil
 		}
@@ -565,7 +875,7 @@ func downloadFromQobuz(req DownloadRequest) (QobuzDownloadResult, error) {
 	}

 	// Log match found and cache the track ID
-	fmt.Printf("[Qobuz] Match found: '%s' by '%s' (duration: %ds)\n", track.Title, track.Performer.Name, track.Duration)
+	GoLog("[Qobuz] Match found: '%s' by '%s' (duration: %ds)\n", track.Title, track.Performer.Name, track.Duration)
 	if req.ISRC != "" {
 		GetTrackIDCache().SetQobuz(req.ISRC, track.ID)
 	}
@@ -599,12 +909,12 @@ func downloadFromQobuz(req DownloadRequest) (QobuzDownloadResult, error) {
 	case "HI_RES_LOSSLESS":
 		qobuzQuality = "27" // 24-bit 192kHz
 	}
-	fmt.Printf("[Qobuz] Using quality: %s (mapped from %s)\n", qobuzQuality, req.Quality)
+	GoLog("[Qobuz] Using quality: %s (mapped from %s)\n", qobuzQuality, req.Quality)

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

 	// Get download URL using parallel API requests
 	downloadURL, err := downloader.GetDownloadURL(track.ID, qobuzQuality)
@@ -643,23 +953,30 @@ func downloadFromQobuz(req DownloadRequest) (QobuzDownloadResult, error) {
 	}

 	// Embed metadata using parallel-fetched cover data
+	// Use metadata from the actual Qobuz track found (more accurate than request) but prefer
+	// requested Album Name to avoid ISRC version mismatches (e.g. Compilations vs Original)
+	albumName := track.Album.Title
+	if req.AlbumName != "" {
+		albumName = req.AlbumName
+	}
+
 	metadata := Metadata{
-		Title:       req.TrackName,
-		Artist:      req.ArtistName,
-		Album:       req.AlbumName,
-		AlbumArtist: req.AlbumArtist,
-		Date:        req.ReleaseDate,
-		TrackNumber: req.TrackNumber,
+		Title:       track.Title,
+		Artist:      track.Performer.Name,
+		Album:       albumName,
+		AlbumArtist: req.AlbumArtist, // Qobuz track struct might not have this handy, keep req or check album struct
+		Date:        track.Album.ReleaseDate,
+		TrackNumber: track.TrackNumber,
 		TotalTracks: req.TotalTracks,
-		DiscNumber:  req.DiscNumber,
-		ISRC:        req.ISRC,
+		DiscNumber:  req.DiscNumber, // QobuzTrack struct usually doesn't have disc info in simple search result
+		ISRC:        track.ISRC,
 	}

 	// Use cover data from parallel fetch
 	var coverData []byte
 	if parallelResult != nil && parallelResult.CoverData != nil {
 		coverData = parallelResult.CoverData
-		fmt.Printf("[Qobuz] Using parallel-fetched cover (%d bytes)\n", len(coverData))
+		GoLog("[Qobuz] Using parallel-fetched cover (%d bytes)\n", len(coverData))
 	}

 	if err := EmbedMetadataWithCoverData(outputPath, metadata, coverData); err != nil {
@@ -668,9 +985,9 @@ func downloadFromQobuz(req DownloadRequest) (QobuzDownloadResult, error) {

 	// Embed lyrics from parallel fetch
 	if req.EmbedLyrics && parallelResult != nil && parallelResult.LyricsLRC != "" {
-		fmt.Printf("[Qobuz] Embedding parallel-fetched lyrics (%d lines)...\n", len(parallelResult.LyricsData.Lines))
+		GoLog("[Qobuz] Embedding parallel-fetched lyrics (%d lines)...\n", len(parallelResult.LyricsData.Lines))
 		if embedErr := EmbedLyrics(outputPath, parallelResult.LyricsLRC); embedErr != nil {
-			fmt.Printf("[Qobuz] Warning: failed to embed lyrics: %v\n", embedErr)
+			GoLog("[Qobuz] Warning: failed to embed lyrics: %v\n", embedErr)
 		} else {
 			fmt.Println("[Qobuz] Lyrics embedded successfully")
 		}
@@ -678,9 +995,19 @@ func downloadFromQobuz(req DownloadRequest) (QobuzDownloadResult, error) {
 		fmt.Println("[Qobuz] No lyrics available from parallel fetch")
 	}

+	// Add to ISRC index for fast duplicate checking
+	AddToISRCIndex(req.OutputDir, req.ISRC, outputPath)
+
 	return QobuzDownloadResult{
-		FilePath:   outputPath,
-		BitDepth:   actualBitDepth,
-		SampleRate: actualSampleRate,
+		FilePath:    outputPath,
+		BitDepth:    actualBitDepth,
+		SampleRate:  actualSampleRate,
+		Title:       track.Title,
+		Artist:      track.Performer.Name,
+		Album:       track.Album.Title,
+		ReleaseDate: track.Album.ReleaseDate,
+		TrackNumber: track.TrackNumber,
+		DiscNumber:  req.DiscNumber, // Qobuz track struct limitations
+		ISRC:        track.ISRC,
 	}, nil
 }
@@ -0,0 +1,222 @@
+package gobackend
+
+import (
+	"strings"
+	"unicode"
+)
+
+// Hiragana to Romaji mapping
+var hiraganaToRomaji = map[rune]string{
+	'あ': "a", 'い': "i", 'う': "u", 'え': "e", 'お': "o",
+	'か': "ka", 'き': "ki", 'く': "ku", 'け': "ke", 'こ': "ko",
+	'さ': "sa", 'し': "shi", 'す': "su", 'せ': "se", 'そ': "so",
+	'た': "ta", 'ち': "chi", 'つ': "tsu", 'て': "te", 'と': "to",
+	'な': "na", 'に': "ni", 'ぬ': "nu", 'ね': "ne", 'の': "no",
+	'は': "ha", 'ひ': "hi", 'ふ': "fu", 'へ': "he", 'ほ': "ho",
+	'ま': "ma", 'み': "mi", 'む': "mu", 'め': "me", 'も': "mo",
+	'や': "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",
+}
+
+// Katakana to Romaji mapping
+var katakanaToRomaji = map[rune]string{
+	'ア': "a", 'イ': "i", 'ウ': "u", 'エ': "e", 'オ': "o",
+	'カ': "ka", 'キ': "ki", 'ク': "ku", 'ケ': "ke", 'コ': "ko",
+	'サ': "sa", 'シ': "shi", 'ス': "su", 'セ': "se", 'ソ': "so",
+	'タ': "ta", 'チ': "chi", 'ツ': "tsu", 'テ': "te", 'ト': "to",
+	'ナ': "na", 'ニ': "ni", 'ヌ': "nu", 'ネ': "ne", 'ノ': "no",
+	'ハ': "ha", 'ヒ': "hi", 'フ': "fu", 'ヘ': "he", 'ホ': "ho",
+	'マ': "ma", 'ミ': "mi", 'ム': "mu", 'メ': "me", 'モ': "mo",
+	'ヤ': "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",
+}
+
+// Combination mappings for きゃ, しゃ, etc.
+var combinationHiragana = map[string]string{
+	"きゃ": "kya", "きゅ": "kyu", "きょ": "kyo",
+	"しゃ": "sha", "しゅ": "shu", "しょ": "sho",
+	"ちゃ": "cha", "ちゅ": "chu", "ちょ": "cho",
+	"にゃ": "nya", "にゅ": "nyu", "にょ": "nyo",
+	"ひゃ": "hya", "ひゅ": "hyu", "ひょ": "hyo",
+	"みゃ": "mya", "みゅ": "myu", "みょ": "myo",
+	"りゃ": "rya", "りゅ": "ryu", "りょ": "ryo",
+	"ぎゃ": "gya", "ぎゅ": "gyu", "ぎょ": "gyo",
+	"じゃ": "ja", "じゅ": "ju", "じょ": "jo",
+	"びゃ": "bya", "びゅ": "byu", "びょ": "byo",
+	"ぴゃ": "pya", "ぴゅ": "pyu", "ぴょ": "pyo",
+}
+
+var combinationKatakana = map[string]string{
+	"キャ": "kya", "キュ": "kyu", "キョ": "kyo",
+	"シャ": "sha", "シュ": "shu", "ショ": "sho",
+	"チャ": "cha", "チュ": "chu", "チョ": "cho",
+	"ニャ": "nya", "ニュ": "nyu", "ニョ": "nyo",
+	"ヒャ": "hya", "ヒュ": "hyu", "ヒョ": "hyo",
+	"ミャ": "mya", "ミュ": "myu", "ミョ": "myo",
+	"リャ": "rya", "リュ": "ryu", "リョ": "ryo",
+	"ギャ": "gya", "ギュ": "gyu", "ギョ": "gyo",
+	"ジャ": "ja", "ジュ": "ju", "ジョ": "jo",
+	"ビャ": "bya", "ビュ": "byu", "ビョ": "byo",
+	"ピャ": "pya", "ピュ": "pyu", "ピョ": "pyo",
+	// Extended combinations
+	"ティ": "ti", "ディ": "di", "トゥ": "tu", "ドゥ": "du",
+	"ファ": "fa", "フィ": "fi", "フェ": "fe", "フォ": "fo",
+	"ウィ": "wi", "ウェ": "we", "ウォ": "wo",
+}
+
+// ContainsJapanese checks if a string contains Japanese characters
+func ContainsJapanese(s string) bool {
+	for _, r := range s {
+		if isHiragana(r) || isKatakana(r) || isKanji(r) {
+			return true
+		}
+	}
+	return false
+}
+
+func isHiragana(r rune) bool {
+	return r >= 0x3040 && r <= 0x309F
+}
+
+func isKatakana(r rune) bool {
+	return r >= 0x30A0 && r <= 0x30FF
+}
+
+func isKanji(r rune) bool {
+	return (r >= 0x4E00 && r <= 0x9FFF) || // CJK Unified Ideographs
+		(r >= 0x3400 && r <= 0x4DBF) // CJK Unified Ideographs Extension A
+}
+
+// JapaneseToRomaji converts Japanese text (hiragana/katakana) to romaji
+// Note: Kanji cannot be converted without a dictionary, so they are kept as-is
+func JapaneseToRomaji(text string) string {
+	if !ContainsJapanese(text) {
+		return text
+	}
+
+	var result strings.Builder
+	runes := []rune(text)
+	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 {
+				nextRomaji = romaji
+			} else if romaji, ok := katakanaToRomaji[runes[i+1]]; ok {
+				nextRomaji = romaji
+			}
+			if len(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 {
+				result.WriteString(romaji)
+				i += 2
+				continue
+			}
+			if romaji, ok := combinationKatakana[combo]; ok {
+				result.WriteString(romaji)
+				i += 2
+				continue
+			}
+		}
+
+		// 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++
+	}
+
+	return result.String()
+}
+
+// BuildSearchQuery creates a search query from track name and artist
+// Converts Japanese to romaji if present
+func BuildSearchQuery(trackName, artistName string) string {
+	// Convert Japanese to romaji
+	trackRomaji := JapaneseToRomaji(trackName)
+	artistRomaji := JapaneseToRomaji(artistName)
+
+	// Clean up the query - remove special characters that might interfere with search
+	trackClean := cleanSearchQuery(trackRomaji)
+	artistClean := cleanSearchQuery(artistRomaji)
+
+	return strings.TrimSpace(artistClean + " " + trackClean)
+}
+
+// cleanSearchQuery removes special characters that might interfere with search
+func cleanSearchQuery(s string) string {
+	var result strings.Builder
+	for _, r := range s {
+		if unicode.IsLetter(r) || unicode.IsNumber(r) || unicode.IsSpace(r) {
+			result.WriteRune(r)
+		} else if r == '-' || r == '\'' {
+			result.WriteRune(r)
+		}
+	}
+	return strings.TrimSpace(result.String())
+}
+
+// CleanToASCII removes all non-ASCII characters and keeps only letters, numbers, spaces
+// This is useful for creating search queries that work better with Tidal's search
+func CleanToASCII(s string) string {
+	var result strings.Builder
+	for _, r := range s {
+		// Keep only ASCII letters, numbers, spaces, and basic punctuation
+		if (r >= 'a' && r <= 'z') || (r >= 'A' && r <= 'Z') ||
+			(r >= '0' && r <= '9') || r == ' ' || r == '-' || r == '\'' {
+			result.WriteRune(r)
+		} else if r == ',' || r == '.' {
+			// Convert punctuation to space
+			result.WriteRune(' ')
+		}
+	}
+	// Clean up multiple spaces
+	cleaned := strings.Join(strings.Fields(result.String()), " ")
+	return strings.TrimSpace(cleaned)
+}
@@ -6,6 +6,7 @@ import (
 	"fmt"
 	"net/http"
 	"net/url"
+	"strings"
 	"sync"
 	"time"
 )
@@ -21,9 +22,12 @@ type TrackAvailability struct {
 	Tidal     bool   `json:"tidal"`
 	Amazon    bool   `json:"amazon"`
 	Qobuz     bool   `json:"qobuz"`
+	Deezer    bool   `json:"deezer"`
 	TidalURL  string `json:"tidal_url,omitempty"`
 	AmazonURL string `json:"amazon_url,omitempty"`
 	QobuzURL  string `json:"qobuz_url,omitempty"`
+	DeezerURL string `json:"deezer_url,omitempty"`
+	DeezerID  string `json:"deezer_id,omitempty"`
 }

 var (
@@ -44,6 +48,11 @@ func NewSongLinkClient() *SongLinkClient {

 // CheckTrackAvailability checks track availability on streaming platforms
 func (s *SongLinkClient) CheckTrackAvailability(spotifyTrackID string, isrc string) (*TrackAvailability, error) {
+	// Validate Spotify ID format (should be 22 characters alphanumeric)
+	if spotifyTrackID == "" {
+		return nil, fmt.Errorf("spotify track ID is empty")
+	}
+	
 	// Use global rate limiter - blocks until request is allowed
 	songLinkRateLimiter.WaitForSlot()

@@ -67,8 +76,18 @@ func (s *SongLinkClient) CheckTrackAvailability(spotifyTrackID string, isrc stri
 	}
 	defer resp.Body.Close()

+	// Handle specific error codes
+	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("API returned status %d", resp.StatusCode)
+		return nil, fmt.Errorf("SongLink API returned status %d", resp.StatusCode)
 	}

 	body, err := ReadResponseBody(resp)
@@ -102,7 +121,15 @@ func (s *SongLinkClient) CheckTrackAvailability(spotifyTrackID string, isrc stri
 		availability.AmazonURL = amazonLink.URL
 	}

-	// Check Qobuz using ISRC
+	// Check Deezer
+	if deezerLink, ok := songLinkResp.LinksByPlatform["deezer"]; ok && deezerLink.URL != "" {
+		availability.Deezer = true
+		availability.DeezerURL = deezerLink.URL
+		// Extract Deezer ID from URL (e.g., https://www.deezer.com/track/123456)
+		availability.DeezerID = extractDeezerIDFromURL(deezerLink.URL)
+	}
+
+	// Check Qobuz using ISRC (SongLink doesn't support Qobuz directly)
 	if isrc != "" {
 		availability.Qobuz = checkQobuzAvailability(isrc)
 	}
@@ -161,3 +188,357 @@ func checkQobuzAvailability(isrc string) bool {

 	return searchResp.Tracks.Total > 0
 }
+
+// extractDeezerIDFromURL extracts Deezer track/album/artist ID from URL
+func extractDeezerIDFromURL(deezerURL string) string {
+	// URL format: https://www.deezer.com/track/123456 or https://www.deezer.com/en/track/123456
+	parts := strings.Split(deezerURL, "/")
+	if len(parts) > 0 {
+		// Get the last part which should be the ID
+		lastPart := parts[len(parts)-1]
+		// Remove any query parameters
+		if idx := strings.Index(lastPart, "?"); idx > 0 {
+			lastPart = lastPart[:idx]
+		}
+		return lastPart
+	}
+	return ""
+}
+
+// GetDeezerIDFromSpotify converts a Spotify track ID to Deezer track ID using SongLink
+func (s *SongLinkClient) GetDeezerIDFromSpotify(spotifyTrackID string) (string, error) {
+	availability, err := s.CheckTrackAvailability(spotifyTrackID, "")
+	if err != nil {
+		return "", err
+	}
+	
+	if !availability.Deezer || availability.DeezerID == "" {
+		return "", fmt.Errorf("track not found on Deezer")
+	}
+	
+	return availability.DeezerID, nil
+}
+
+// AlbumAvailability represents album availability on different platforms
+type AlbumAvailability struct {
+	SpotifyID string `json:"spotify_id"`
+	Deezer    bool   `json:"deezer"`
+	DeezerURL string `json:"deezer_url,omitempty"`
+	DeezerID  string `json:"deezer_id,omitempty"`
+}
+
+// CheckAlbumAvailability checks album availability on streaming platforms using SongLink
+func (s *SongLinkClient) CheckAlbumAvailability(spotifyAlbumID string) (*AlbumAvailability, error) {
+	// Use global rate limiter
+	songLinkRateLimiter.WaitForSlot()
+
+	// Build API URL for album
+	spotifyBase, _ := base64.StdEncoding.DecodeString("aHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLw==")
+	spotifyURL := fmt.Sprintf("%s%s", string(spotifyBase), spotifyAlbumID)
+
+	apiBase, _ := base64.StdEncoding.DecodeString("aHR0cHM6Ly9hcGkuc29uZy5saW5rL3YxLWFscGhhLjEvbGlua3M/dXJsPQ==")
+	apiURL := fmt.Sprintf("%s%s", string(apiBase), url.QueryEscape(spotifyURL))
+
+	req, err := http.NewRequest("GET", apiURL, nil)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create request: %w", err)
+	}
+
+	retryConfig := DefaultRetryConfig()
+	resp, err := DoRequestWithRetry(s.client, req, retryConfig)
+	if err != nil {
+		return nil, fmt.Errorf("failed to check 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,
+	}
+
+	// Check Deezer
+	if deezerLink, ok := songLinkResp.LinksByPlatform["deezer"]; ok && deezerLink.URL != "" {
+		availability.Deezer = true
+		availability.DeezerURL = deezerLink.URL
+		availability.DeezerID = extractDeezerIDFromURL(deezerLink.URL)
+	}
+
+	return availability, nil
+}
+
+// GetDeezerAlbumIDFromSpotify converts a Spotify album ID to Deezer album ID using SongLink
+func (s *SongLinkClient) GetDeezerAlbumIDFromSpotify(spotifyAlbumID string) (string, error) {
+	availability, err := s.CheckAlbumAvailability(spotifyAlbumID)
+	if err != nil {
+		return "", err
+	}
+	
+	if !availability.Deezer || availability.DeezerID == "" {
+		return "", fmt.Errorf("album not found on Deezer")
+	}
+	
+	return availability.DeezerID, nil
+}
+
+// ========================================
+// Deezer ID Support - Query SongLink using Deezer as source
+// ========================================
+
+// CheckAvailabilityFromDeezer checks track availability using Deezer track ID as source
+// This is useful when we have Deezer metadata and want to find the track on other platforms
+func (s *SongLinkClient) CheckAvailabilityFromDeezer(deezerTrackID string) (*TrackAvailability, error) {
+	if deezerTrackID == "" {
+		return nil, fmt.Errorf("deezer track ID is empty")
+	}
+	
+	// Use global rate limiter
+	songLinkRateLimiter.WaitForSlot()
+
+	// Build Deezer URL
+	deezerURL := fmt.Sprintf("https://www.deezer.com/track/%s", deezerTrackID)
+
+	// Build API URL using Deezer URL as source
+	apiBase, _ := base64.StdEncoding.DecodeString("aHR0cHM6Ly9hcGkuc29uZy5saW5rL3YxLWFscGhhLjEvbGlua3M/dXJsPQ==")
+	apiURL := fmt.Sprintf("%s%s&userCountry=US", string(apiBase), url.QueryEscape(deezerURL))
+
+	req, err := http.NewRequest("GET", apiURL, nil)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create request: %w", err)
+	}
+
+	retryConfig := DefaultRetryConfig()
+	resp, err := DoRequestWithRetry(s.client, req, retryConfig)
+	if err != nil {
+		return nil, fmt.Errorf("failed to check availability: %w", err)
+	}
+	defer resp.Body.Close()
+
+	// Handle specific error codes
+	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,
+	}
+
+	// Check Spotify
+	if spotifyLink, ok := songLinkResp.LinksByPlatform["spotify"]; ok && spotifyLink.URL != "" {
+		// Extract Spotify ID from URL
+		availability.SpotifyID = extractSpotifyIDFromURL(spotifyLink.URL)
+	}
+
+	// Check Tidal
+	if tidalLink, ok := songLinkResp.LinksByPlatform["tidal"]; ok && tidalLink.URL != "" {
+		availability.Tidal = true
+		availability.TidalURL = tidalLink.URL
+	}
+
+	// Check Amazon
+	if amazonLink, ok := songLinkResp.LinksByPlatform["amazonMusic"]; ok && amazonLink.URL != "" {
+		availability.Amazon = true
+		availability.AmazonURL = amazonLink.URL
+	}
+
+	// Check Deezer URL
+	if deezerLink, ok := songLinkResp.LinksByPlatform["deezer"]; ok && deezerLink.URL != "" {
+		availability.DeezerURL = deezerLink.URL
+	}
+
+	return availability, nil
+}
+
+// CheckAvailabilityByPlatform checks track availability using any supported platform
+// platform: "spotify", "deezer", "tidal", "amazonMusic", "appleMusic", "youtube", etc.
+// entityType: "song" or "album"
+// entityID: the ID on that platform
+func (s *SongLinkClient) CheckAvailabilityByPlatform(platform, entityType, entityID string) (*TrackAvailability, error) {
+	if entityID == "" {
+		return nil, fmt.Errorf("%s ID is empty", platform)
+	}
+	
+	// Use global rate limiter
+	songLinkRateLimiter.WaitForSlot()
+
+	// Build API URL using platform, type, and id parameters (as per API docs)
+	// https://api.song.link/v1-alpha.1/links?platform=deezer&type=song&id=123456
+	apiURL := fmt.Sprintf("https://api.song.link/v1-alpha.1/links?platform=%s&type=%s&id=%s&userCountry=US",
+		url.QueryEscape(platform),
+		url.QueryEscape(entityType),
+		url.QueryEscape(entityID))
+
+	req, err := http.NewRequest("GET", apiURL, nil)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create request: %w", err)
+	}
+
+	retryConfig := DefaultRetryConfig()
+	resp, err := DoRequestWithRetry(s.client, req, retryConfig)
+	if err != nil {
+		return nil, fmt.Errorf("failed to check availability: %w", err)
+	}
+	defer resp.Body.Close()
+
+	// Handle specific error codes
+	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)
+	}
+
+	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{}
+
+	// Check Spotify
+	if spotifyLink, ok := songLinkResp.LinksByPlatform["spotify"]; ok && spotifyLink.URL != "" {
+		availability.SpotifyID = extractSpotifyIDFromURL(spotifyLink.URL)
+	}
+
+	// Check Tidal
+	if tidalLink, ok := songLinkResp.LinksByPlatform["tidal"]; ok && tidalLink.URL != "" {
+		availability.Tidal = true
+		availability.TidalURL = tidalLink.URL
+	}
+
+	// Check Amazon
+	if amazonLink, ok := songLinkResp.LinksByPlatform["amazonMusic"]; ok && amazonLink.URL != "" {
+		availability.Amazon = true
+		availability.AmazonURL = amazonLink.URL
+	}
+
+	// Check Deezer
+	if deezerLink, ok := songLinkResp.LinksByPlatform["deezer"]; ok && deezerLink.URL != "" {
+		availability.Deezer = true
+		availability.DeezerURL = deezerLink.URL
+		availability.DeezerID = extractDeezerIDFromURL(deezerLink.URL)
+	}
+
+	return availability, nil
+}
+
+// extractSpotifyIDFromURL extracts Spotify track ID from URL
+func extractSpotifyIDFromURL(spotifyURL string) string {
+	// URL format: https://open.spotify.com/track/0Jcij1eWd5bDMU5iPbxe2i
+	parts := strings.Split(spotifyURL, "/track/")
+	if len(parts) > 1 {
+		// Get the ID part and remove any query parameters
+		idPart := parts[1]
+		if idx := strings.Index(idPart, "?"); idx > 0 {
+			idPart = idPart[:idx]
+		}
+		return idPart
+	}
+	return ""
+}
+
+// GetSpotifyIDFromDeezer converts a Deezer track ID to Spotify track ID using SongLink
+func (s *SongLinkClient) GetSpotifyIDFromDeezer(deezerTrackID string) (string, error) {
+	availability, err := s.CheckAvailabilityFromDeezer(deezerTrackID)
+	if err != nil {
+		return "", err
+	}
+	
+	if availability.SpotifyID == "" {
+		return "", fmt.Errorf("track not found on Spotify")
+	}
+	
+	return availability.SpotifyID, nil
+}
+
+// GetTidalURLFromDeezer converts a Deezer track ID to Tidal URL using SongLink
+func (s *SongLinkClient) GetTidalURLFromDeezer(deezerTrackID string) (string, error) {
+	availability, err := s.CheckAvailabilityFromDeezer(deezerTrackID)
+	if err != nil {
+		return "", err
+	}
+	
+	if !availability.Tidal || availability.TidalURL == "" {
+		return "", fmt.Errorf("track not found on Tidal")
+	}
+	
+	return availability.TidalURL, nil
+}
+
+// GetAmazonURLFromDeezer converts a Deezer track ID to Amazon Music URL using SongLink
+func (s *SongLinkClient) GetAmazonURLFromDeezer(deezerTrackID string) (string, error) {
+	availability, err := s.CheckAvailabilityFromDeezer(deezerTrackID)
+	if err != nil {
+		return "", err
+	}
+	
+	if !availability.Amazon || availability.AmazonURL == "" {
+		return "", fmt.Errorf("track not found on Amazon Music")
+	}
+	
+	return availability.AmazonURL, nil
+}
@@ -2,7 +2,6 @@ package gobackend

 import (
 	"context"
-	"encoding/base64"
 	"encoding/json"
 	"errors"
 	"fmt"
@@ -17,14 +16,14 @@ import (
 )

 const (
-	spotifyTokenURL     = "https://accounts.spotify.com/api/token"
-	playlistBaseURL     = "https://api.spotify.com/v1/playlists/%s"
-	albumBaseURL        = "https://api.spotify.com/v1/albums/%s"
-	trackBaseURL        = "https://api.spotify.com/v1/tracks/%s"
-	artistBaseURL       = "https://api.spotify.com/v1/artists/%s"
-	artistAlbumsURL     = "https://api.spotify.com/v1/artists/%s/albums"
-	searchBaseURL       = "https://api.spotify.com/v1/search"
-	
+	spotifyTokenURL = "https://accounts.spotify.com/api/token"
+	playlistBaseURL = "https://api.spotify.com/v1/playlists/%s"
+	albumBaseURL    = "https://api.spotify.com/v1/albums/%s"
+	trackBaseURL    = "https://api.spotify.com/v1/tracks/%s"
+	artistBaseURL   = "https://api.spotify.com/v1/artists/%s"
+	artistAlbumsURL = "https://api.spotify.com/v1/artists/%s/albums"
+	searchBaseURL   = "https://api.spotify.com/v1/search"
+
 	// Cache TTL settings
 	artistCacheTTL = 10 * time.Minute
 	searchCacheTTL = 5 * time.Minute
@@ -54,7 +53,7 @@ type SpotifyMetadataClient struct {
 	rng            *rand.Rand
 	rngMu          sync.Mutex
 	userAgent      string
-	
+
 	// Caches to reduce API calls
 	artistCache map[string]*cacheEntry // key: artistID
 	searchCache map[string]*cacheEntry // key: query+type
@@ -69,8 +68,10 @@ var (
 	credentialsMu      sync.RWMutex
 )

+// ErrNoSpotifyCredentials is returned when Spotify credentials are not configured
+var ErrNoSpotifyCredentials = errors.New("Spotify credentials not configured. Please set your own Client ID and Secret in Settings, or use Deezer as metadata source (free, no credentials required)")
+
 // SetSpotifyCredentials sets custom Spotify API credentials
-// Pass empty strings to use default credentials
 func SetSpotifyCredentials(clientID, clientSecret string) {
 	credentialsMu.Lock()
 	defer credentialsMu.Unlock()
@@ -78,39 +79,56 @@ func SetSpotifyCredentials(clientID, clientSecret string) {
 	customClientSecret = clientSecret
 }

-// getCredentials returns the current credentials (custom or default)
-func getCredentials() (string, string) {
+// HasSpotifyCredentials checks if Spotify credentials are configured
+func HasSpotifyCredentials() bool {
 	credentialsMu.RLock()
 	defer credentialsMu.RUnlock()
-	
+
+	// Check custom credentials first
 	if customClientID != "" && customClientSecret != "" {
-		return customClientID, customClientSecret
-	}
-	
-	// Fall back to default credentials
-	clientID := os.Getenv("SPOTIFY_CLIENT_ID")
-	if clientID == "" {
-		if decoded, err := base64.StdEncoding.DecodeString("NWY1NzNjOTYyMDQ5NGJhZTg3ODkwYzBmMDhhNjAyOTM="); err == nil {
-			clientID = string(decoded)
-		}
+		return true
 	}

-	clientSecret := os.Getenv("SPOTIFY_CLIENT_SECRET")
-	if clientSecret == "" {
-		if decoded, err := base64.StdEncoding.DecodeString("MjEyNDc2ZDliMGYzNDcyZWFhNzYyZDkwYjE5YjBiYTg="); err == nil {
-			clientSecret = string(decoded)
-		}
+	// Check environment variables
+	if os.Getenv("SPOTIFY_CLIENT_ID") != "" && os.Getenv("SPOTIFY_CLIENT_SECRET") != "" {
+		return true
 	}
-	
-	return clientID, clientSecret
+
+	return false
+}
+
+// getCredentials returns the current credentials or error if not configured
+func getCredentials() (string, string, error) {
+	credentialsMu.RLock()
+	defer credentialsMu.RUnlock()
+
+	// Check custom credentials first
+	if customClientID != "" && customClientSecret != "" {
+		return customClientID, customClientSecret, nil
+	}
+
+	// Check environment variables
+	clientID := os.Getenv("SPOTIFY_CLIENT_ID")
+	clientSecret := os.Getenv("SPOTIFY_CLIENT_SECRET")
+
+	if clientID != "" && clientSecret != "" {
+		return clientID, clientSecret, nil
+	}
+
+	// No credentials available
+	return "", "", ErrNoSpotifyCredentials
 }

 // NewSpotifyMetadataClient creates a new Spotify client
-func NewSpotifyMetadataClient() *SpotifyMetadataClient {
-	src := rand.NewSource(time.Now().UnixNano())
+// Returns error if credentials are not configured
+func NewSpotifyMetadataClient() (*SpotifyMetadataClient, error) {
+	// Get credentials - will error if not configured
+	clientID, clientSecret, err := getCredentials()
+	if err != nil {
+		return nil, err
+	}

-	// Get credentials (custom or default)
-	clientID, clientSecret := getCredentials()
+	src := rand.NewSource(time.Now().UnixNano())

 	c := &SpotifyMetadataClient{
 		httpClient:   NewHTTPClientWithTimeout(15 * time.Second), // Use shared transport for connection pooling
@@ -122,7 +140,7 @@ func NewSpotifyMetadataClient() *SpotifyMetadataClient {
 		albumCache:   make(map[string]*cacheEntry),
 	}
 	c.userAgent = c.randomUserAgent()
-	return c
+	return c, nil
 }

 // TrackMetadata represents track information
@@ -331,14 +349,14 @@ func (c *SpotifyMetadataClient) SearchTracks(ctx context.Context, query string,
 	}

 	searchURL := fmt.Sprintf("%s?q=%s&type=track&limit=%d", searchBaseURL, url.QueryEscape(query), limit)
-	
+
 	var response struct {
 		Tracks struct {
 			Items []trackFull `json:"items"`
 			Total int         `json:"total"`
 		} `json:"tracks"`
 	}
-	
+
 	if err := c.getJSON(ctx, searchURL, token, &response); err != nil {
 		return nil, err
 	}
@@ -373,7 +391,7 @@ func (c *SpotifyMetadataClient) SearchTracks(ctx context.Context, query string,
 func (c *SpotifyMetadataClient) SearchAll(ctx context.Context, query string, trackLimit, artistLimit int) (*SearchAllResult, error) {
 	// Create cache key
 	cacheKey := fmt.Sprintf("all:%s:%d:%d", query, trackLimit, artistLimit)
-	
+
 	// Check cache first
 	c.cacheMu.RLock()
 	if entry, ok := c.searchCache[cacheKey]; ok && !entry.isExpired() {
@@ -388,24 +406,24 @@ func (c *SpotifyMetadataClient) SearchAll(ctx context.Context, query string, tra
 	}

 	searchURL := fmt.Sprintf("%s?q=%s&type=track,artist&limit=%d", searchBaseURL, url.QueryEscape(query), trackLimit)
-	
+
 	var response struct {
 		Tracks struct {
 			Items []trackFull `json:"items"`
 		} `json:"tracks"`
 		Artists struct {
 			Items []struct {
-				ID         string  `json:"id"`
-				Name       string  `json:"name"`
-				Images     []image `json:"images"`
-				Followers  struct {
+				ID        string  `json:"id"`
+				Name      string  `json:"name"`
+				Images    []image `json:"images"`
+				Followers struct {
 					Total int `json:"total"`
 				} `json:"followers"`
 				Popularity int `json:"popularity"`
 			} `json:"items"`
 		} `json:"artists"`
 	}
-	
+
 	if err := c.getJSON(ctx, searchURL, token, &response); err != nil {
 		return nil, err
 	}
@@ -438,7 +456,7 @@ func (c *SpotifyMetadataClient) SearchAll(ctx context.Context, query string, tra
 	if artistCount > artistLimit {
 		artistCount = artistLimit
 	}
-	
+
 	for i := 0; i < artistCount; i++ {
 		artist := response.Artists.Items[i]
 		result.Artists = append(result.Artists, SearchArtistResult{
@@ -495,6 +513,17 @@ func (c *SpotifyMetadataClient) fetchAlbum(ctx context.Context, albumID, token s
 	}
 	c.cacheMu.RUnlock()

+	// Track item structure for pagination
+	type trackItem struct {
+		ID          string      `json:"id"`
+		Name        string      `json:"name"`
+		DurationMS  int         `json:"duration_ms"`
+		TrackNumber int         `json:"track_number"`
+		DiscNumber  int         `json:"disc_number"`
+		ExternalURL externalURL `json:"external_urls"`
+		Artists     []artist    `json:"artists"`
+	}
+
 	var data struct {
 		Name        string   `json:"name"`
 		ReleaseDate string   `json:"release_date"`
@@ -502,15 +531,8 @@ func (c *SpotifyMetadataClient) fetchAlbum(ctx context.Context, albumID, token s
 		Images      []image  `json:"images"`
 		Artists     []artist `json:"artists"`
 		Tracks      struct {
-			Items []struct {
-				ID          string      `json:"id"`
-				Name        string      `json:"name"`
-				DurationMS  int         `json:"duration_ms"`
-				TrackNumber int         `json:"track_number"`
-				DiscNumber  int         `json:"disc_number"`
-				ExternalURL externalURL `json:"external_urls"`
-				Artists     []artist    `json:"artists"`
-			} `json:"items"`
+			Items []trackItem `json:"items"`
+			Next  string      `json:"next"`
 		} `json:"tracks"`
 	}

@@ -527,11 +549,39 @@ func (c *SpotifyMetadataClient) fetchAlbum(ctx context.Context, albumID, token s
 		Images:      albumImage,
 	}

-	tracks := make([]AlbumTrackMetadata, 0, len(data.Tracks.Items))
-	for _, item := range data.Tracks.Items {
-		// Fetch ISRC for each track
-		isrc := c.fetchTrackISRC(ctx, item.ID, token)
-		
+	// Collect all tracks (including paginated)
+	allTrackItems := data.Tracks.Items
+	nextURL := data.Tracks.Next
+
+	// Fetch remaining tracks using pagination (no limit)
+	for nextURL != "" {
+		var pageData struct {
+			Items []trackItem `json:"items"`
+			Next  string      `json:"next"`
+		}
+		if err := c.getJSON(ctx, nextURL, token, &pageData); err != nil {
+			fmt.Printf("[Spotify] Warning: failed to fetch album tracks page: %v\n", err)
+			break
+		}
+		allTrackItems = append(allTrackItems, pageData.Items...)
+		nextURL = pageData.Next
+	}
+
+	fmt.Printf("[Spotify] Album has %d tracks (total: %d)\n", len(allTrackItems), data.TotalTracks)
+
+	// Collect track IDs for parallel ISRC fetching
+	trackIDs := make([]string, len(allTrackItems))
+	for i, item := range allTrackItems {
+		trackIDs[i] = item.ID
+	}
+
+	// Fetch ISRCs in parallel for ALL tracks (like Deezer implementation)
+	isrcMap := c.fetchISRCsParallel(ctx, trackIDs, token)
+
+	tracks := make([]AlbumTrackMetadata, 0, len(allTrackItems))
+	for _, item := range allTrackItems {
+		isrc := isrcMap[item.ID]
+
 		tracks = append(tracks, AlbumTrackMetadata{
 			SpotifyID:   item.ID,
 			Artists:     joinArtists(item.Artists),
@@ -566,6 +616,47 @@ func (c *SpotifyMetadataClient) fetchAlbum(ctx context.Context, albumID, token s
 	return result, nil
 }

+// fetchISRCsParallel fetches ISRCs for multiple tracks in parallel
+// Similar to Deezer implementation for consistency
+func (c *SpotifyMetadataClient) fetchISRCsParallel(ctx context.Context, trackIDs []string, token string) map[string]string {
+	const maxParallelISRC = 10 // Max concurrent ISRC fetches
+
+	result := make(map[string]string)
+	var resultMu sync.Mutex
+
+	if len(trackIDs) == 0 {
+		return result
+	}
+
+	// Use semaphore to limit concurrent requests
+	sem := make(chan struct{}, maxParallelISRC)
+	var wg sync.WaitGroup
+
+	for _, trackID := range trackIDs {
+		wg.Add(1)
+		go func(id string) {
+			defer wg.Done()
+
+			// Acquire semaphore
+			select {
+			case sem <- struct{}{}:
+				defer func() { <-sem }()
+			case <-ctx.Done():
+				return
+			}
+
+			isrc := c.fetchTrackISRC(ctx, id, token)
+
+			resultMu.Lock()
+			result[id] = isrc
+			resultMu.Unlock()
+		}(trackID)
+	}
+
+	wg.Wait()
+	return result
+}
+
 func (c *SpotifyMetadataClient) fetchPlaylist(ctx context.Context, playlistID, token string) (*PlaylistResponsePayload, error) {
 	// First request to get playlist info and first batch of tracks
 	var data struct {
@@ -595,7 +686,7 @@ func (c *SpotifyMetadataClient) fetchPlaylist(ctx context.Context, playlistID, t

 	// Pre-allocate with expected capacity
 	tracks := make([]AlbumTrackMetadata, 0, data.Tracks.Total)
-	
+
 	// Add first batch of tracks
 	for _, item := range data.Tracks.Items {
 		if item.Track == nil {
@@ -620,11 +711,10 @@ func (c *SpotifyMetadataClient) fetchPlaylist(ctx context.Context, playlistID, t
 		})
 	}

-	// Fetch remaining tracks using pagination (up to 1000 tracks max)
+	// Fetch remaining tracks using pagination (NO LIMIT - fetch all tracks)
 	nextURL := data.Tracks.Next
-	maxTracks := 1000
-	
-	for nextURL != "" && len(tracks) < maxTracks {
+
+	for nextURL != "" {
 		var pageData struct {
 			Items []struct {
 				Track *trackFull `json:"track"`
@@ -642,9 +732,6 @@ func (c *SpotifyMetadataClient) fetchPlaylist(ctx context.Context, playlistID, t
 			if item.Track == nil {
 				continue
 			}
-			if len(tracks) >= maxTracks {
-				break
-			}
 			tracks = append(tracks, AlbumTrackMetadata{
 				SpotifyID:   item.Track.ID,
 				Artists:     joinArtists(item.Track.Artists),
@@ -686,10 +773,10 @@ func (c *SpotifyMetadataClient) fetchArtist(ctx context.Context, artistID, token

 	// Fetch artist info
 	var artistData struct {
-		ID         string  `json:"id"`
-		Name       string  `json:"name"`
-		Images     []image `json:"images"`
-		Followers  struct {
+		ID        string  `json:"id"`
+		Name      string  `json:"name"`
+		Images    []image `json:"images"`
+		Followers struct {
 			Total int `json:"total"`
 		} `json:"followers"`
 		Popularity int `json:"popularity"`
@@ -835,8 +922,16 @@ func (c *SpotifyMetadataClient) getJSON(ctx context.Context, endpoint, token str
 		return err
 	}

+	// Set headers (same as PC version baseHeaders)
 	req.Header.Set("User-Agent", c.userAgent)
 	req.Header.Set("Accept", "application/json")
+	req.Header.Set("Accept-Language", "en-US,en;q=0.9")
+	req.Header.Set("sec-ch-ua-platform", "\"Windows\"")
+	req.Header.Set("sec-fetch-dest", "empty")
+	req.Header.Set("sec-fetch-mode", "cors")
+	req.Header.Set("sec-fetch-site", "same-origin")
+	req.Header.Set("Referer", "https://open.spotify.com/")
+	req.Header.Set("Origin", "https://open.spotify.com")
 	if token != "" {
 		req.Header.Set("Authorization", "Bearer "+token)
 	}
@@ -863,13 +958,23 @@ func (c *SpotifyMetadataClient) randomUserAgent() string {
 	c.rngMu.Lock()
 	defer c.rngMu.Unlock()

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

 	return fmt.Sprintf(
-		"Mozilla/5.0 (Linux; Android 12) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/%d.0.%d.%d Mobile Safari/537.36",
+		"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_%d_%d) AppleWebKit/%d.%d (KHTML, like Gecko) Chrome/%d.0.%d.%d Safari/%d.%d",
+		macMajor, macMinor,
+		webkitMajor, webkitMinor,
 		chromeMajor, chromeBuild, chromePatch,
+		safariMajor, safariMinor,
 	)
 }

@@ -427,7 +427,7 @@
 			isa = XCBuildConfiguration;
 			buildSettings = {
 				ALWAYS_SEARCH_USER_PATHS = NO;
-				ASSETCATALOG_COMPILER_GENERATE_SWIFT_ASSET_SYMBOL_EXTENSIONS = YES;
+				ASSETCATALOG_COMPILER_GENERATE_SWIFT_ASSET_SYMBOL_EXTENSIONS = AppIcon;
 				CLANG_ANALYZER_NONNULL = YES;
 				CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x";
 				CLANG_CXX_LIBRARY = "libc++";
@@ -484,7 +484,7 @@
 			isa = XCBuildConfiguration;
 			buildSettings = {
 				ALWAYS_SEARCH_USER_PATHS = NO;
-				ASSETCATALOG_COMPILER_GENERATE_SWIFT_ASSET_SYMBOL_EXTENSIONS = YES;
+				ASSETCATALOG_COMPILER_GENERATE_SWIFT_ASSET_SYMBOL_EXTENSIONS = AppIcon;
 				CLANG_ANALYZER_NONNULL = YES;
 				CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x";
 				CLANG_CXX_LIBRARY = "libc++";
@@ -181,6 +181,323 @@ import Gobackend  // Import Go framework
            GobackendCleanupConnections()
            return nil
            
+        case "readFileMetadata":
+            let args = call.arguments as! [String: Any]
+            let filePath = args["file_path"] as! String
+            let response = GobackendReadFileMetadata(filePath, &error)
+            if let error = error { throw error }
+            return response
+            
+        case "searchDeezerAll":
+            let args = call.arguments as! [String: Any]
+            let query = args["query"] as! String
+            let trackLimit = args["track_limit"] as? Int ?? 15
+            let artistLimit = args["artist_limit"] as? Int ?? 3
+            let response = GobackendSearchDeezerAll(query, Int(trackLimit), Int(artistLimit), &error)
+            if let error = error { throw error }
+            return response
+
+        case "getDeezerMetadata":
+            let args = call.arguments as! [String: Any]
+            let resourceType = args["resource_type"] as! String
+            let resourceId = args["resource_id"] as! String
+            let response = GobackendGetDeezerMetadata(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
+            let response = GobackendParseDeezerURLExport(url, &error)
+            if let error = error { throw error }
+            return response
+
+        case "searchDeezerByISRC":
+            let args = call.arguments as! [String: Any]
+            let isrc = args["isrc"] as! String
+            let response = GobackendSearchDeezerByISRC(isrc, &error)
+            if let error = error { throw error }
+            return response
+
+        case "convertSpotifyToDeezer":
+            let args = call.arguments as! [String: Any]
+            let resourceType = args["resource_type"] as! String
+            let spotifyId = args["spotify_id"] as! String
+            let response = GobackendConvertSpotifyToDeezer(resourceType, spotifyId, &error)
+            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 "preWarmTrackCache":
+            let args = call.arguments as! [String: Any]
+            let tracksJson = args["tracks"] as! String
+            let _ = GobackendPreWarmTrackCacheJSON(tracksJson, &error)
+            if let error = error { throw error }
+            return nil
+            
+        case "getTrackCacheSize":
+            let response = GobackendGetTrackCacheSize()
+            return response
+            
+        case "clearTrackCache":
+            GobackendClearTrackCache()
+            return nil
+            
+        case "setSpotifyCredentials":
+            let args = call.arguments as! [String: Any]
+            let clientId = args["client_id"] as! String
+            let clientSecret = args["client_secret"] as! String
+            GobackendSetSpotifyAPICredentials(clientId, clientSecret)
+            return nil
+            
+        case "hasSpotifyCredentials":
+            let hasCredentials = GobackendCheckSpotifyCredentials()
+            return hasCredentials
+            
+        // Log methods
+        case "getLogs":
+            let response = GobackendGetLogs()
+            return response
+            
+        case "getLogsSince":
+            let args = call.arguments as! [String: Any]
+            let index = args["index"] as? Int ?? 0
+            let response = GobackendGetLogsSince(Int(index))
+            return response
+            
+        case "clearLogs":
+            GobackendClearLogs()
+            return nil
+            
+        case "getLogCount":
+            let response = GobackendGetLogCount()
+            return response
+            
+        case "setLoggingEnabled":
+            let args = call.arguments as! [String: Any]
+            let enabled = args["enabled"] as? Bool ?? false
+            GobackendSetLoggingEnabled(enabled)
+            return nil
+            
+        // Extension System methods
+        case "initExtensionSystem":
+            let args = call.arguments as! [String: Any]
+            let extensionsDir = args["extensions_dir"] as! String
+            let dataDir = args["data_dir"] as! String
+            GobackendInitExtensionSystem(extensionsDir, dataDir, &error)
+            if let error = error { throw error }
+            return nil
+            
+        case "loadExtensionsFromDir":
+            let args = call.arguments as! [String: Any]
+            let dirPath = args["dir_path"] as! String
+            let response = GobackendLoadExtensionsFromDir(dirPath, &error)
+            if let error = error { throw error }
+            return response
+            
+        case "loadExtensionFromPath":
+            let args = call.arguments as! [String: Any]
+            let filePath = args["file_path"] as! String
+            let response = GobackendLoadExtensionFromPath(filePath, &error)
+            if let error = error { throw error }
+            return response
+            
+        case "unloadExtension":
+            let args = call.arguments as! [String: Any]
+            let extensionId = args["extension_id"] as! String
+            GobackendUnloadExtensionByID(extensionId, &error)
+            if let error = error { throw error }
+            return nil
+            
+        case "getInstalledExtensions":
+            let response = GobackendGetInstalledExtensions(&error)
+            if let error = error { throw error }
+            return response
+            
+        case "setExtensionEnabled":
+            let args = call.arguments as! [String: Any]
+            let extensionId = args["extension_id"] as! String
+            let enabled = args["enabled"] as? Bool ?? false
+            GobackendSetExtensionEnabledByID(extensionId, enabled, &error)
+            if let error = error { throw error }
+            return nil
+            
+        case "setProviderPriority":
+            let args = call.arguments as! [String: Any]
+            let priorityJson = args["priority"] as! String
+            GobackendSetProviderPriorityJSON(priorityJson, &error)
+            if let error = error { throw error }
+            return nil
+            
+        case "getProviderPriority":
+            let response = GobackendGetProviderPriorityJSON(&error)
+            if let error = error { throw error }
+            return response
+            
+        case "setMetadataProviderPriority":
+            let args = call.arguments as! [String: Any]
+            let priorityJson = args["priority"] as! String
+            GobackendSetMetadataProviderPriorityJSON(priorityJson, &error)
+            if let error = error { throw error }
+            return nil
+            
+        case "getMetadataProviderPriority":
+            let response = GobackendGetMetadataProviderPriorityJSON(&error)
+            if let error = error { throw error }
+            return response
+            
+        case "getExtensionSettings":
+            let args = call.arguments as! [String: Any]
+            let extensionId = args["extension_id"] as! String
+            let response = GobackendGetExtensionSettingsJSON(extensionId, &error)
+            if let error = error { throw error }
+            return response
+            
+        case "setExtensionSettings":
+            let args = call.arguments as! [String: Any]
+            let extensionId = args["extension_id"] as! String
+            let settingsJson = args["settings"] as! String
+            GobackendSetExtensionSettingsJSON(extensionId, settingsJson, &error)
+            if let error = error { throw error }
+            return nil
+            
+        case "searchTracksWithExtensions":
+            let args = call.arguments as! [String: Any]
+            let query = args["query"] as! String
+            let limit = args["limit"] as? Int ?? 20
+            let response = GobackendSearchTracksWithExtensionsJSON(query, Int(limit), &error)
+            if let error = error { throw error }
+            return response
+            
+        case "downloadWithExtensions":
+            let requestJson = call.arguments as! String
+            let response = GobackendDownloadWithExtensionsJSON(requestJson, &error)
+            if let error = error { throw error }
+            return response
+            
+        case "removeExtension":
+            let args = call.arguments as! [String: Any]
+            let extensionId = args["extension_id"] as! String
+            GobackendRemoveExtensionByID(extensionId, &error)
+            if let error = error { throw error }
+            return nil
+            
+        case "upgradeExtension":
+            let args = call.arguments as! [String: Any]
+            let filePath = args["file_path"] as! String
+            let response = GobackendUpgradeExtensionFromPath(filePath, &error)
+            if let error = error { throw error }
+            return response
+            
+        case "checkExtensionUpgrade":
+            let args = call.arguments as! [String: Any]
+            let filePath = args["file_path"] as! String
+            let response = GobackendCheckExtensionUpgradeFromPath(filePath, &error)
+            if let error = error { throw error }
+            return response
+            
+        case "cleanupExtensions":
+            GobackendCleanupExtensions()
+            return nil
+            
+        // Extension Auth API
+        case "getExtensionPendingAuth":
+            let args = call.arguments as! [String: Any]
+            let extensionId = args["extension_id"] as! String
+            let response = GobackendGetExtensionPendingAuthJSON(extensionId, &error)
+            if let error = error { throw error }
+            return response
+            
+        case "setExtensionAuthCode":
+            let args = call.arguments as! [String: Any]
+            let extensionId = args["extension_id"] as! String
+            let authCode = args["auth_code"] as! String
+            GobackendSetExtensionAuthCodeByID(extensionId, authCode)
+            return nil
+            
+        case "setExtensionTokens":
+            let args = call.arguments as! [String: Any]
+            let extensionId = args["extension_id"] as! String
+            let accessToken = args["access_token"] as! String
+            let refreshToken = args["refresh_token"] as? String ?? ""
+            let expiresIn = args["expires_in"] as? Int ?? 0
+            GobackendSetExtensionTokensByID(extensionId, accessToken, refreshToken, Int(expiresIn))
+            return nil
+            
+        case "clearExtensionPendingAuth":
+            let args = call.arguments as! [String: Any]
+            let extensionId = args["extension_id"] as! String
+            GobackendClearExtensionPendingAuthByID(extensionId)
+            return nil
+            
+        case "isExtensionAuthenticated":
+            let args = call.arguments as! [String: Any]
+            let extensionId = args["extension_id"] as! String
+            let response = GobackendIsExtensionAuthenticatedByID(extensionId)
+            return response
+            
+        case "getAllPendingAuthRequests":
+            let response = GobackendGetAllPendingAuthRequestsJSON(&error)
+            if let error = error { throw error }
+            return response
+            
+        // Extension FFmpeg API
+        case "getPendingFFmpegCommand":
+            let args = call.arguments as! [String: Any]
+            let commandId = args["command_id"] as! String
+            let response = GobackendGetPendingFFmpegCommandJSON(commandId, &error)
+            if let error = error { throw error }
+            return response
+            
+        case "setFFmpegCommandResult":
+            let args = call.arguments as! [String: Any]
+            let commandId = args["command_id"] as! String
+            let success = args["success"] as? Bool ?? false
+            let output = args["output"] as? String ?? ""
+            let errorMsg = args["error"] as? String ?? ""
+            GobackendSetFFmpegCommandResult(commandId, success, output, errorMsg)
+            return nil
+            
+        case "getAllPendingFFmpegCommands":
+            let response = GobackendGetAllPendingFFmpegCommandsJSON(&error)
+            if let error = error { throw error }
+            return response
+            
+        // Extension Custom Search API
+        case "customSearchWithExtension":
+            let args = call.arguments as! [String: Any]
+            let extensionId = args["extension_id"] as! String
+            let query = args["query"] as! String
+            let optionsJson = args["options"] as? String ?? ""
+            let response = GobackendCustomSearchWithExtensionJSON(extensionId, query, optionsJson, &error)
+            if let error = error { throw error }
+            return response
+            
+        case "getSearchProviders":
+            let response = GobackendGetSearchProvidersJSON(&error)
+            if let error = error { throw error }
+            return response
+            
+        // Extension Post-Processing API
+        case "runPostProcessing":
+            let args = call.arguments as! [String: Any]
+            let filePath = args["file_path"] as! String
+            let metadataJson = args["metadata"] as? String ?? ""
+            let response = GobackendRunPostProcessingJSON(filePath, metadataJson, &error)
+            if let error = error { throw error }
+            return response
+            
+        case "getPostProcessingProviders":
+            let response = GobackendGetPostProcessingProvidersJSON(&error)
+            if let error = error { throw error }
+            return response
+            
        default:
            throw NSError(
                domain: "SpotiFLAC",
@@ -1,122 +1 @@
-{
-  "images" : [
-    {
-      "size" : "20x20",
-      "idiom" : "iphone",
-      "filename" : "Icon-App-20x20@2x.png",
-      "scale" : "2x"
-    },
-    {
-      "size" : "20x20",
-      "idiom" : "iphone",
-      "filename" : "Icon-App-20x20@3x.png",
-      "scale" : "3x"
-    },
-    {
-      "size" : "29x29",
-      "idiom" : "iphone",
-      "filename" : "Icon-App-29x29@1x.png",
-      "scale" : "1x"
-    },
-    {
-      "size" : "29x29",
-      "idiom" : "iphone",
-      "filename" : "Icon-App-29x29@2x.png",
-      "scale" : "2x"
-    },
-    {
-      "size" : "29x29",
-      "idiom" : "iphone",
-      "filename" : "Icon-App-29x29@3x.png",
-      "scale" : "3x"
-    },
-    {
-      "size" : "40x40",
-      "idiom" : "iphone",
-      "filename" : "Icon-App-40x40@2x.png",
-      "scale" : "2x"
-    },
-    {
-      "size" : "40x40",
-      "idiom" : "iphone",
-      "filename" : "Icon-App-40x40@3x.png",
-      "scale" : "3x"
-    },
-    {
-      "size" : "60x60",
-      "idiom" : "iphone",
-      "filename" : "Icon-App-60x60@2x.png",
-      "scale" : "2x"
-    },
-    {
-      "size" : "60x60",
-      "idiom" : "iphone",
-      "filename" : "Icon-App-60x60@3x.png",
-      "scale" : "3x"
-    },
-    {
-      "size" : "20x20",
-      "idiom" : "ipad",
-      "filename" : "Icon-App-20x20@1x.png",
-      "scale" : "1x"
-    },
-    {
-      "size" : "20x20",
-      "idiom" : "ipad",
-      "filename" : "Icon-App-20x20@2x.png",
-      "scale" : "2x"
-    },
-    {
-      "size" : "29x29",
-      "idiom" : "ipad",
-      "filename" : "Icon-App-29x29@1x.png",
-      "scale" : "1x"
-    },
-    {
-      "size" : "29x29",
-      "idiom" : "ipad",
-      "filename" : "Icon-App-29x29@2x.png",
-      "scale" : "2x"
-    },
-    {
-      "size" : "40x40",
-      "idiom" : "ipad",
-      "filename" : "Icon-App-40x40@1x.png",
-      "scale" : "1x"
-    },
-    {
-      "size" : "40x40",
-      "idiom" : "ipad",
-      "filename" : "Icon-App-40x40@2x.png",
-      "scale" : "2x"
-    },
-    {
-      "size" : "76x76",
-      "idiom" : "ipad",
-      "filename" : "Icon-App-76x76@1x.png",
-      "scale" : "1x"
-    },
-    {
-      "size" : "76x76",
-      "idiom" : "ipad",
-      "filename" : "Icon-App-76x76@2x.png",
-      "scale" : "2x"
-    },
-    {
-      "size" : "83.5x83.5",
-      "idiom" : "ipad",
-      "filename" : "Icon-App-83.5x83.5@2x.png",
-      "scale" : "2x"
-    },
-    {
-      "size" : "1024x1024",
-      "idiom" : "ios-marketing",
-      "filename" : "Icon-App-1024x1024@1x.png",
-      "scale" : "1x"
-    }
-  ],
-  "info" : {
-    "version" : 1,
-    "author" : "xcode"
-  }
-}
+{"images":[{"size":"20x20","idiom":"iphone","filename":"Icon-App-20x20@2x.png","scale":"2x"},{"size":"20x20","idiom":"iphone","filename":"Icon-App-20x20@3x.png","scale":"3x"},{"size":"29x29","idiom":"iphone","filename":"Icon-App-29x29@1x.png","scale":"1x"},{"size":"29x29","idiom":"iphone","filename":"Icon-App-29x29@2x.png","scale":"2x"},{"size":"29x29","idiom":"iphone","filename":"Icon-App-29x29@3x.png","scale":"3x"},{"size":"40x40","idiom":"iphone","filename":"Icon-App-40x40@2x.png","scale":"2x"},{"size":"40x40","idiom":"iphone","filename":"Icon-App-40x40@3x.png","scale":"3x"},{"size":"57x57","idiom":"iphone","filename":"Icon-App-57x57@1x.png","scale":"1x"},{"size":"57x57","idiom":"iphone","filename":"Icon-App-57x57@2x.png","scale":"2x"},{"size":"60x60","idiom":"iphone","filename":"Icon-App-60x60@2x.png","scale":"2x"},{"size":"60x60","idiom":"iphone","filename":"Icon-App-60x60@3x.png","scale":"3x"},{"size":"20x20","idiom":"ipad","filename":"Icon-App-20x20@1x.png","scale":"1x"},{"size":"20x20","idiom":"ipad","filename":"Icon-App-20x20@2x.png","scale":"2x"},{"size":"29x29","idiom":"ipad","filename":"Icon-App-29x29@1x.png","scale":"1x"},{"size":"29x29","idiom":"ipad","filename":"Icon-App-29x29@2x.png","scale":"2x"},{"size":"40x40","idiom":"ipad","filename":"Icon-App-40x40@1x.png","scale":"1x"},{"size":"40x40","idiom":"ipad","filename":"Icon-App-40x40@2x.png","scale":"2x"},{"size":"50x50","idiom":"ipad","filename":"Icon-App-50x50@1x.png","scale":"1x"},{"size":"50x50","idiom":"ipad","filename":"Icon-App-50x50@2x.png","scale":"2x"},{"size":"72x72","idiom":"ipad","filename":"Icon-App-72x72@1x.png","scale":"1x"},{"size":"72x72","idiom":"ipad","filename":"Icon-App-72x72@2x.png","scale":"2x"},{"size":"76x76","idiom":"ipad","filename":"Icon-App-76x76@1x.png","scale":"1x"},{"size":"76x76","idiom":"ipad","filename":"Icon-App-76x76@2x.png","scale":"2x"},{"size":"83.5x83.5","idiom":"ipad","filename":"Icon-App-83.5x83.5@2x.png","scale":"2x"},{"size":"1024x1024","idiom":"ios-marketing","filename":"Icon-App-1024x1024@1x.png","scale":"1x"}],"info":{"version":1,"author":"xcode"}}
@@ -1,8 +1,8 @@
 /// App version and info constants
 /// Update version here only - all other files will reference this
 class AppInfo {
-  static const String version = '2.1.0';
-  static const String buildNumber = '41';
+  static const String version = '3.0.0-alpha.2';
+  static const String buildNumber = '51';
  static const String fullVersion = '$version+$buildNumber';
  
  
@@ -1,7 +1,10 @@
+import 'dart:io';
 import 'package:flutter/material.dart';
 import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:path_provider/path_provider.dart';
 import 'package:spotiflac_android/app.dart';
 import 'package:spotiflac_android/providers/download_queue_provider.dart';
+import 'package:spotiflac_android/providers/extension_provider.dart';
 import 'package:spotiflac_android/services/notification_service.dart';
 import 'package:spotiflac_android/services/share_intent_service.dart';

@@ -24,14 +27,42 @@ void main() async {
 }

 /// Widget to eagerly initialize providers that need to load data on startup
-class _EagerInitialization extends ConsumerWidget {
+class _EagerInitialization extends ConsumerStatefulWidget {
  const _EagerInitialization({required this.child});
  final Widget child;

  @override
-  Widget build(BuildContext context, WidgetRef ref) {
+  ConsumerState<_EagerInitialization> createState() => _EagerInitializationState();
+}
+
+class _EagerInitializationState extends ConsumerState<_EagerInitialization> {
+  @override
+  void initState() {
+    super.initState();
+    _initializeExtensions();
+  }
+
+  Future<void> _initializeExtensions() async {
+    try {
+      final appDir = await getApplicationDocumentsDirectory();
+      final extensionsDir = '${appDir.path}/extensions';
+      final dataDir = '${appDir.path}/extension_data';
+      
+      // Create directories if needed
+      await Directory(extensionsDir).create(recursive: true);
+      await Directory(dataDir).create(recursive: true);
+      
+      // Initialize extension system
+      await ref.read(extensionProvider.notifier).initialize(extensionsDir, dataDir);
+    } catch (e) {
+      debugPrint('Failed to initialize extensions: $e');
+    }
+  }
+
+  @override
+  Widget build(BuildContext context) {
    // Eagerly initialize download history provider to load from storage
    ref.watch(downloadHistoryProvider);
-    return child;
+    return widget.child;
  }
 }
@@ -13,6 +13,14 @@ enum DownloadStatus {
  skipped,
 }

+/// Error type enum for better error handling
+enum DownloadErrorType {
+  unknown,
+  notFound,    // Track not found on any service
+  rateLimit,   // Rate limited by service
+  network,     // Network/connection error
+}
+
@JsonSerializable()
 class DownloadItem {
  final String id;
@@ -20,8 +28,10 @@ class DownloadItem {
  final String service;
  final DownloadStatus status;
  final double progress;
+  final double speedMBps; // Download speed in MB/s
  final String? filePath;
  final String? error;
+  final DownloadErrorType? errorType;
  final DateTime createdAt;
  final String? qualityOverride; // Override quality for this specific download

@@ -31,8 +41,10 @@ class DownloadItem {
    required this.service,
    this.status = DownloadStatus.queued,
    this.progress = 0.0,
+    this.speedMBps = 0.0,
    this.filePath,
    this.error,
+    this.errorType,
    required this.createdAt,
    this.qualityOverride,
  });
@@ -43,8 +55,10 @@ class DownloadItem {
    String? service,
    DownloadStatus? status,
    double? progress,
+    double? speedMBps,
    String? filePath,
    String? error,
+    DownloadErrorType? errorType,
    DateTime? createdAt,
    String? qualityOverride,
  }) {
@@ -54,13 +68,31 @@ class DownloadItem {
      service: service ?? this.service,
      status: status ?? this.status,
      progress: progress ?? this.progress,
+      speedMBps: speedMBps ?? this.speedMBps,
      filePath: filePath ?? this.filePath,
      error: error ?? this.error,
+      errorType: errorType ?? this.errorType,
      createdAt: createdAt ?? this.createdAt,
      qualityOverride: qualityOverride ?? this.qualityOverride,
    );
  }

+  /// Get user-friendly error message based on error type
+  String get errorMessage {
+    if (error == null) return '';
+    
+    switch (errorType) {
+      case DownloadErrorType.notFound:
+        return 'Song not found on any service';
+      case DownloadErrorType.rateLimit:
+        return 'Rate limit reached, try again later';
+      case DownloadErrorType.network:
+        return 'Connection failed, check your internet';
+      default:
+        return error ?? 'An error occurred';
+    }
+  }
+
  factory DownloadItem.fromJson(Map<String, dynamic> json) =>
      _$DownloadItemFromJson(json);
  Map<String, dynamic> toJson() => _$DownloadItemToJson(this);
@@ -14,8 +14,10 @@ DownloadItem _$DownloadItemFromJson(Map<String, dynamic> json) => DownloadItem(
      $enumDecodeNullable(_$DownloadStatusEnumMap, json['status']) ??
      DownloadStatus.queued,
  progress: (json['progress'] as num?)?.toDouble() ?? 0.0,
+  speedMBps: (json['speedMBps'] as num?)?.toDouble() ?? 0.0,
  filePath: json['filePath'] as String?,
  error: json['error'] as String?,
+  errorType: $enumDecodeNullable(_$DownloadErrorTypeEnumMap, json['errorType']),
  createdAt: DateTime.parse(json['createdAt'] as String),
  qualityOverride: json['qualityOverride'] as String?,
 );
@@ -27,8 +29,10 @@ Map<String, dynamic> _$DownloadItemToJson(DownloadItem instance) =>
      'service': instance.service,
      'status': _$DownloadStatusEnumMap[instance.status]!,
      'progress': instance.progress,
+      'speedMBps': instance.speedMBps,
      'filePath': instance.filePath,
      'error': instance.error,
+      'errorType': _$DownloadErrorTypeEnumMap[instance.errorType],
      'createdAt': instance.createdAt.toIso8601String(),
      'qualityOverride': instance.qualityOverride,
    };
@@ -41,3 +45,10 @@ const _$DownloadStatusEnumMap = {
  DownloadStatus.failed: 'failed',
  DownloadStatus.skipped: 'skipped',
 };
+
+const _$DownloadErrorTypeEnumMap = {
+  DownloadErrorType.unknown: 'unknown',
+  DownloadErrorType.notFound: 'notFound',
+  DownloadErrorType.rateLimit: 'rateLimit',
+  DownloadErrorType.network: 'network',
+};
@@ -18,10 +18,15 @@ class AppSettings {
  final bool hasSearchedBefore; // Hide helper text after first search
  final String folderOrganization; // none, artist, album, artist_album
  final String historyViewMode; // list, grid
+  final String historyFilterMode; // all, albums, singles
  final bool askQualityBeforeDownload; // Show quality picker before each download
  final String spotifyClientId; // Custom Spotify client ID (empty = use default)
  final String spotifyClientSecret; // Custom Spotify client secret (empty = use default)
  final bool useCustomSpotifyCredentials; // Whether to use custom credentials (if set)
+  final String metadataSource; // spotify, deezer - source for search and metadata
+  final bool enableLogging; // Enable detailed logging for debugging
+  final bool useExtensionProviders; // Use extension providers for downloads when available
+  final String? searchProvider; // null/empty = default (Deezer/Spotify), otherwise extension ID

  const AppSettings({
    this.defaultService = 'tidal',
@@ -38,10 +43,15 @@ class AppSettings {
    this.hasSearchedBefore = false, // Default: show helper text
    this.folderOrganization = 'none', // Default: no folder organization
    this.historyViewMode = 'grid', // Default: grid view
+    this.historyFilterMode = 'all', // Default: show all
    this.askQualityBeforeDownload = true, // Default: ask quality before download
    this.spotifyClientId = '', // Default: use built-in credentials
    this.spotifyClientSecret = '', // Default: use built-in credentials
    this.useCustomSpotifyCredentials = true, // Default: use custom if set
+    this.metadataSource = 'deezer', // Default: Deezer (no rate limit)
+    this.enableLogging = false, // Default: disabled for performance
+    this.useExtensionProviders = true, // Default: use extensions when available
+    this.searchProvider, // Default: null (use Deezer/Spotify)
  });

  AppSettings copyWith({
@@ -59,10 +69,15 @@ class AppSettings {
    bool? hasSearchedBefore,
    String? folderOrganization,
    String? historyViewMode,
+    String? historyFilterMode,
    bool? askQualityBeforeDownload,
    String? spotifyClientId,
    String? spotifyClientSecret,
    bool? useCustomSpotifyCredentials,
+    String? metadataSource,
+    bool? enableLogging,
+    bool? useExtensionProviders,
+    String? searchProvider,
  }) {
    return AppSettings(
      defaultService: defaultService ?? this.defaultService,
@@ -79,10 +94,15 @@ class AppSettings {
      hasSearchedBefore: hasSearchedBefore ?? this.hasSearchedBefore,
      folderOrganization: folderOrganization ?? this.folderOrganization,
      historyViewMode: historyViewMode ?? this.historyViewMode,
+      historyFilterMode: historyFilterMode ?? this.historyFilterMode,
      askQualityBeforeDownload: askQualityBeforeDownload ?? this.askQualityBeforeDownload,
      spotifyClientId: spotifyClientId ?? this.spotifyClientId,
      spotifyClientSecret: spotifyClientSecret ?? this.spotifyClientSecret,
      useCustomSpotifyCredentials: useCustomSpotifyCredentials ?? this.useCustomSpotifyCredentials,
+      metadataSource: metadataSource ?? this.metadataSource,
+      enableLogging: enableLogging ?? this.enableLogging,
+      useExtensionProviders: useExtensionProviders ?? this.useExtensionProviders,
+      searchProvider: searchProvider ?? this.searchProvider,
    );
  }

@@ -21,11 +21,16 @@ AppSettings _$AppSettingsFromJson(Map<String, dynamic> json) => AppSettings(
  hasSearchedBefore: json['hasSearchedBefore'] as bool? ?? false,
  folderOrganization: json['folderOrganization'] as String? ?? 'none',
  historyViewMode: json['historyViewMode'] as String? ?? 'grid',
+  historyFilterMode: json['historyFilterMode'] as String? ?? 'all',
  askQualityBeforeDownload: json['askQualityBeforeDownload'] as bool? ?? true,
  spotifyClientId: json['spotifyClientId'] as String? ?? '',
  spotifyClientSecret: json['spotifyClientSecret'] as String? ?? '',
  useCustomSpotifyCredentials:
      json['useCustomSpotifyCredentials'] as bool? ?? true,
+  metadataSource: json['metadataSource'] as String? ?? 'deezer',
+  enableLogging: json['enableLogging'] as bool? ?? false,
+  useExtensionProviders: json['useExtensionProviders'] as bool? ?? true,
+  searchProvider: json['searchProvider'] as String?,
 );

 Map<String, dynamic> _$AppSettingsToJson(AppSettings instance) =>
@@ -44,8 +49,13 @@ Map<String, dynamic> _$AppSettingsToJson(AppSettings instance) =>
      'hasSearchedBefore': instance.hasSearchedBefore,
      'folderOrganization': instance.folderOrganization,
      'historyViewMode': instance.historyViewMode,
+      'historyFilterMode': instance.historyFilterMode,
      'askQualityBeforeDownload': instance.askQualityBeforeDownload,
      'spotifyClientId': instance.spotifyClientId,
      'spotifyClientSecret': instance.spotifyClientSecret,
      'useCustomSpotifyCredentials': instance.useCustomSpotifyCredentials,
+      'metadataSource': instance.metadataSource,
+      'enableLogging': instance.enableLogging,
+      'useExtensionProviders': instance.useExtensionProviders,
+      'searchProvider': instance.searchProvider,
    };
@@ -16,7 +16,9 @@ class Track {
  final int? trackNumber;
  final int? discNumber;
  final String? releaseDate;
+  final String? deezerId;
  final ServiceAvailability? availability;
+  final String? source; // Extension ID that provided this track (null for built-in sources)

  const Track({
    required this.id,
@@ -30,11 +32,16 @@ class Track {
    this.trackNumber,
    this.discNumber,
    this.releaseDate,
+    this.deezerId,
    this.availability,
+    this.source,
  });

  factory Track.fromJson(Map<String, dynamic> json) => _$TrackFromJson(json);
  Map<String, dynamic> toJson() => _$TrackToJson(this);
+  
+  /// Check if this track is from an extension
+  bool get isFromExtension => source != null && source!.isNotEmpty;
 }

@JsonSerializable()
@@ -42,17 +49,23 @@ class ServiceAvailability {
  final bool tidal;
  final bool qobuz;
  final bool amazon;
+  final bool deezer;
  final String? tidalUrl;
  final String? qobuzUrl;
  final String? amazonUrl;
+  final String? deezerUrl;
+  final String? deezerId;

  const ServiceAvailability({
    this.tidal = false,
    this.qobuz = false,
    this.amazon = false,
+    this.deezer = false,
    this.tidalUrl,
    this.qobuzUrl,
    this.amazonUrl,
+    this.deezerUrl,
+    this.deezerId,
  });

  factory ServiceAvailability.fromJson(Map<String, dynamic> json) =>
@@ -18,11 +18,13 @@ Track _$TrackFromJson(Map<String, dynamic> json) => Track(
  trackNumber: (json['trackNumber'] as num?)?.toInt(),
  discNumber: (json['discNumber'] as num?)?.toInt(),
  releaseDate: json['releaseDate'] as String?,
+  deezerId: json['deezerId'] as String?,
  availability: json['availability'] == null
      ? null
      : ServiceAvailability.fromJson(
          json['availability'] as Map<String, dynamic>,
        ),
+  source: json['source'] as String?,
 );

 Map<String, dynamic> _$TrackToJson(Track instance) => <String, dynamic>{
@@ -37,7 +39,9 @@ Map<String, dynamic> _$TrackToJson(Track instance) => <String, dynamic>{
  'trackNumber': instance.trackNumber,
  'discNumber': instance.discNumber,
  'releaseDate': instance.releaseDate,
+  'deezerId': instance.deezerId,
  'availability': instance.availability,
+  'source': instance.source,
 };

 ServiceAvailability _$ServiceAvailabilityFromJson(Map<String, dynamic> json) =>
@@ -45,9 +49,12 @@ ServiceAvailability _$ServiceAvailabilityFromJson(Map<String, dynamic> json) =>
      tidal: json['tidal'] as bool? ?? false,
      qobuz: json['qobuz'] as bool? ?? false,
      amazon: json['amazon'] as bool? ?? false,
+      deezer: json['deezer'] as bool? ?? false,
      tidalUrl: json['tidalUrl'] as String?,
      qobuzUrl: json['qobuzUrl'] as String?,
      amazonUrl: json['amazonUrl'] as String?,
+      deezerUrl: json['deezerUrl'] as String?,
+      deezerId: json['deezerId'] as String?,
    );

 Map<String, dynamic> _$ServiceAvailabilityToJson(
@@ -56,7 +63,10 @@ Map<String, dynamic> _$ServiceAvailabilityToJson(
  'tidal': instance.tidal,
  'qobuz': instance.qobuz,
  'amazon': instance.amazon,
+  'deezer': instance.deezer,
  'tidalUrl': instance.tidalUrl,
  'qobuzUrl': instance.qobuzUrl,
  'amazonUrl': instance.amazonUrl,
+  'deezerUrl': instance.deezerUrl,
+  'deezerId': instance.deezerId,
 };
@@ -0,0 +1,677 @@
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:spotiflac_android/services/platform_bridge.dart';
+import 'package:spotiflac_android/utils/logger.dart';
+import 'package:spotiflac_android/providers/settings_provider.dart';
+
+final _log = AppLogger('ExtensionProvider');
+
+/// Represents an installed extension
+class Extension {
+  final String id;
+  final String name;
+  final String displayName;
+  final String version;
+  final String author;
+  final String description;
+  final bool enabled;
+  final String status; // 'loaded', 'error', 'disabled'
+  final String? errorMessage;
+  final String? iconPath; // Path to extension icon
+  final List<String> permissions;
+  final List<ExtensionSetting> settings;
+  final List<QualityOption> qualityOptions; // Custom quality options for download providers
+  final bool hasMetadataProvider;
+  final bool hasDownloadProvider;
+  final bool skipMetadataEnrichment; // If true, use metadata from extension instead of enriching
+  final SearchBehavior? searchBehavior; // Custom search behavior
+  final TrackMatching? trackMatching; // Custom track matching
+  final PostProcessing? postProcessing; // Post-processing hooks
+
+  const Extension({
+    required this.id,
+    required this.name,
+    required this.displayName,
+    required this.version,
+    required this.author,
+    required this.description,
+    required this.enabled,
+    required this.status,
+    this.errorMessage,
+    this.iconPath,
+    this.permissions = const [],
+    this.settings = const [],
+    this.qualityOptions = const [],
+    this.hasMetadataProvider = false,
+    this.hasDownloadProvider = false,
+    this.skipMetadataEnrichment = false,
+    this.searchBehavior,
+    this.trackMatching,
+    this.postProcessing,
+  });
+
+  factory Extension.fromJson(Map<String, dynamic> json) {
+    return Extension(
+      id: json['id'] as String? ?? '',
+      name: json['name'] as String? ?? '',
+      displayName: json['display_name'] as String? ?? json['name'] as String? ?? '',
+      version: json['version'] as String? ?? '0.0.0',
+      author: json['author'] as String? ?? 'Unknown',
+      description: json['description'] as String? ?? '',
+      enabled: json['enabled'] as bool? ?? false,
+      status: json['status'] as String? ?? 'loaded',
+      errorMessage: json['error_message'] as String?,
+      iconPath: json['icon_path'] as String?,
+      permissions: (json['permissions'] as List<dynamic>?)?.cast<String>() ?? [],
+      settings: (json['settings'] as List<dynamic>?)
+          ?.map((s) => ExtensionSetting.fromJson(s as Map<String, dynamic>))
+          .toList() ?? [],
+      qualityOptions: (json['quality_options'] as List<dynamic>?)
+          ?.map((q) => QualityOption.fromJson(q as Map<String, dynamic>))
+          .toList() ?? [],
+      hasMetadataProvider: json['has_metadata_provider'] as bool? ?? false,
+      hasDownloadProvider: json['has_download_provider'] as bool? ?? false,
+      skipMetadataEnrichment: json['skip_metadata_enrichment'] as bool? ?? false,
+      searchBehavior: json['search_behavior'] != null 
+          ? SearchBehavior.fromJson(json['search_behavior'] as Map<String, dynamic>)
+          : null,
+      trackMatching: json['track_matching'] != null
+          ? TrackMatching.fromJson(json['track_matching'] as Map<String, dynamic>)
+          : null,
+      postProcessing: json['post_processing'] != null
+          ? PostProcessing.fromJson(json['post_processing'] as Map<String, dynamic>)
+          : null,
+    );
+  }
+
+  Extension copyWith({
+    String? id,
+    String? name,
+    String? displayName,
+    String? version,
+    String? author,
+    String? description,
+    bool? enabled,
+    String? status,
+    String? errorMessage,
+    String? iconPath,
+    List<String>? permissions,
+    List<ExtensionSetting>? settings,
+    List<QualityOption>? qualityOptions,
+    bool? hasMetadataProvider,
+    bool? hasDownloadProvider,
+    bool? skipMetadataEnrichment,
+    SearchBehavior? searchBehavior,
+    TrackMatching? trackMatching,
+    PostProcessing? postProcessing,
+  }) {
+    return Extension(
+      id: id ?? this.id,
+      name: name ?? this.name,
+      displayName: displayName ?? this.displayName,
+      version: version ?? this.version,
+      author: author ?? this.author,
+      description: description ?? this.description,
+      enabled: enabled ?? this.enabled,
+      status: status ?? this.status,
+      errorMessage: errorMessage ?? this.errorMessage,
+      iconPath: iconPath ?? this.iconPath,
+      permissions: permissions ?? this.permissions,
+      settings: settings ?? this.settings,
+      qualityOptions: qualityOptions ?? this.qualityOptions,
+      hasMetadataProvider: hasMetadataProvider ?? this.hasMetadataProvider,
+      hasDownloadProvider: hasDownloadProvider ?? this.hasDownloadProvider,
+      skipMetadataEnrichment: skipMetadataEnrichment ?? this.skipMetadataEnrichment,
+      searchBehavior: searchBehavior ?? this.searchBehavior,
+      trackMatching: trackMatching ?? this.trackMatching,
+      postProcessing: postProcessing ?? this.postProcessing,
+    );
+  }
+
+  bool get hasCustomSearch => searchBehavior?.enabled ?? false;
+  bool get hasCustomMatching => trackMatching?.customMatching ?? false;
+  bool get hasPostProcessing => postProcessing?.enabled ?? false;
+}
+
+/// Custom search behavior configuration
+class SearchBehavior {
+  final bool enabled;
+  final String? placeholder;
+  final bool primary;
+  final String? icon;
+  final String? thumbnailRatio; // "square" (1:1), "wide" (16:9), "portrait" (2:3)
+  final int? thumbnailWidth;
+  final int? thumbnailHeight;
+
+  const SearchBehavior({
+    required this.enabled,
+    this.placeholder,
+    this.primary = false,
+    this.icon,
+    this.thumbnailRatio,
+    this.thumbnailWidth,
+    this.thumbnailHeight,
+  });
+
+  factory SearchBehavior.fromJson(Map<String, dynamic> json) {
+    return SearchBehavior(
+      enabled: json['enabled'] as bool? ?? false,
+      placeholder: json['placeholder'] as String?,
+      primary: json['primary'] as bool? ?? false,
+      icon: json['icon'] as String?,
+      thumbnailRatio: json['thumbnailRatio'] as String?,
+      thumbnailWidth: json['thumbnailWidth'] as int?,
+      thumbnailHeight: json['thumbnailHeight'] as int?,
+    );
+  }
+
+  /// Get thumbnail size based on configuration
+  /// Returns (width, height) tuple
+  (double, double) getThumbnailSize({double defaultSize = 56}) {
+    // If custom dimensions specified, use them
+    if (thumbnailWidth != null && thumbnailHeight != null) {
+      return (thumbnailWidth!.toDouble(), thumbnailHeight!.toDouble());
+    }
+    
+    // Otherwise use ratio presets
+    switch (thumbnailRatio) {
+      case 'wide': // 16:9 - YouTube style
+        return (defaultSize * 16 / 9, defaultSize);
+      case 'portrait': // 2:3 - Poster style
+        return (defaultSize * 2 / 3, defaultSize);
+      case 'square': // 1:1 - Album art style
+      default:
+        return (defaultSize, defaultSize);
+    }
+  }
+}
+
+/// Custom track matching configuration
+class TrackMatching {
+  final bool customMatching;
+  final String? strategy; // "isrc", "name", "duration", "custom"
+  final int durationTolerance; // in seconds
+
+  const TrackMatching({
+    required this.customMatching,
+    this.strategy,
+    this.durationTolerance = 3,
+  });
+
+  factory TrackMatching.fromJson(Map<String, dynamic> json) {
+    return TrackMatching(
+      customMatching: json['customMatching'] as bool? ?? false,
+      strategy: json['strategy'] as String?,
+      durationTolerance: json['durationTolerance'] as int? ?? 3,
+    );
+  }
+}
+
+/// Post-processing configuration
+class PostProcessing {
+  final bool enabled;
+  final List<PostProcessingHook> hooks;
+
+  const PostProcessing({
+    required this.enabled,
+    this.hooks = const [],
+  });
+
+  factory PostProcessing.fromJson(Map<String, dynamic> json) {
+    return PostProcessing(
+      enabled: json['enabled'] as bool? ?? false,
+      hooks: (json['hooks'] as List<dynamic>?)
+          ?.map((h) => PostProcessingHook.fromJson(h as Map<String, dynamic>))
+          .toList() ?? [],
+    );
+  }
+}
+
+/// A post-processing hook
+class PostProcessingHook {
+  final String id;
+  final String name;
+  final String? description;
+  final bool defaultEnabled;
+  final List<String> supportedFormats;
+
+  const PostProcessingHook({
+    required this.id,
+    required this.name,
+    this.description,
+    this.defaultEnabled = false,
+    this.supportedFormats = const [],
+  });
+
+  factory PostProcessingHook.fromJson(Map<String, dynamic> json) {
+    return PostProcessingHook(
+      id: json['id'] as String? ?? '',
+      name: json['name'] as String? ?? '',
+      description: json['description'] as String?,
+      defaultEnabled: json['defaultEnabled'] as bool? ?? false,
+      supportedFormats: (json['supportedFormats'] as List<dynamic>?)?.cast<String>() ?? [],
+    );
+  }
+}
+
+/// Represents a quality option for download providers
+class QualityOption {
+  final String id;
+  final String label;
+  final String? description;
+  final List<QualitySpecificSetting> settings; // Quality-specific settings
+
+  const QualityOption({
+    required this.id,
+    required this.label,
+    this.description,
+    this.settings = const [],
+  });
+
+  factory QualityOption.fromJson(Map<String, dynamic> json) {
+    return QualityOption(
+      id: json['id'] as String? ?? '',
+      label: json['label'] as String? ?? '',
+      description: json['description'] as String?,
+      settings: (json['settings'] as List<dynamic>?)
+          ?.map((s) => QualitySpecificSetting.fromJson(s as Map<String, dynamic>))
+          .toList() ?? [],
+    );
+  }
+}
+
+/// Represents a setting that's specific to a quality option
+class QualitySpecificSetting {
+  final String key;
+  final String label;
+  final String type; // 'string', 'number', 'boolean', 'select'
+  final dynamic defaultValue;
+  final String? description;
+  final List<String>? options; // For select type
+  final bool required;
+  final bool secret;
+
+  const QualitySpecificSetting({
+    required this.key,
+    required this.label,
+    required this.type,
+    this.defaultValue,
+    this.description,
+    this.options,
+    this.required = false,
+    this.secret = false,
+  });
+
+  factory QualitySpecificSetting.fromJson(Map<String, dynamic> json) {
+    return QualitySpecificSetting(
+      key: json['key'] as String? ?? '',
+      label: json['label'] as String? ?? '',
+      type: json['type'] as String? ?? 'string',
+      defaultValue: json['default'],
+      description: json['description'] as String?,
+      options: (json['options'] as List<dynamic>?)?.cast<String>(),
+      required: json['required'] as bool? ?? false,
+      secret: json['secret'] as bool? ?? false,
+    );
+  }
+}
+
+/// Represents a setting field for an extension
+class ExtensionSetting {
+  final String key;
+  final String label;
+  final String type; // 'string', 'number', 'boolean', 'select'
+  final dynamic defaultValue;
+  final String? description;
+  final List<String>? options; // For select type
+  final bool required;
+
+  const ExtensionSetting({
+    required this.key,
+    required this.label,
+    required this.type,
+    this.defaultValue,
+    this.description,
+    this.options,
+    this.required = false,
+  });
+
+  factory ExtensionSetting.fromJson(Map<String, dynamic> json) {
+    return ExtensionSetting(
+      key: json['key'] as String? ?? '',
+      label: json['label'] as String? ?? '',
+      type: json['type'] as String? ?? 'string',
+      defaultValue: json['default'],
+      description: json['description'] as String?,
+      options: (json['options'] as List<dynamic>?)?.cast<String>(),
+      required: json['required'] as bool? ?? false,
+    );
+  }
+}
+
+/// State for extension management
+class ExtensionState {
+  final List<Extension> extensions;
+  final List<String> providerPriority;
+  final List<String> metadataProviderPriority;
+  final bool isLoading;
+  final String? error;
+  final bool isInitialized;
+
+  const ExtensionState({
+    this.extensions = const [],
+    this.providerPriority = const [],
+    this.metadataProviderPriority = const [],
+    this.isLoading = false,
+    this.error,
+    this.isInitialized = false,
+  });
+
+  ExtensionState copyWith({
+    List<Extension>? extensions,
+    List<String>? providerPriority,
+    List<String>? metadataProviderPriority,
+    bool? isLoading,
+    String? error,
+    bool? isInitialized,
+  }) {
+    return ExtensionState(
+      extensions: extensions ?? this.extensions,
+      providerPriority: providerPriority ?? this.providerPriority,
+      metadataProviderPriority: metadataProviderPriority ?? this.metadataProviderPriority,
+      isLoading: isLoading ?? this.isLoading,
+      error: error,
+      isInitialized: isInitialized ?? this.isInitialized,
+    );
+  }
+}
+
+
+/// Provider for managing extensions
+class ExtensionNotifier extends Notifier<ExtensionState> {
+  @override
+  ExtensionState build() {
+    return const ExtensionState();
+  }
+
+  /// Initialize the extension system
+  Future<void> initialize(String extensionsDir, String dataDir) async {
+    if (state.isInitialized) return;
+    
+    state = state.copyWith(isLoading: true, error: null);
+    
+    try {
+      await PlatformBridge.initExtensionSystem(extensionsDir, dataDir);
+      await loadExtensions(extensionsDir);
+      await loadProviderPriority();
+      await loadMetadataProviderPriority();
+      state = state.copyWith(isInitialized: true, isLoading: false);
+      _log.i('Extension system initialized');
+    } catch (e) {
+      _log.e('Failed to initialize extension system: $e');
+      state = state.copyWith(isLoading: false, error: e.toString());
+    }
+  }
+
+  /// Load all extensions from directory
+  Future<void> loadExtensions(String dirPath) async {
+    state = state.copyWith(isLoading: true, error: null);
+    
+    try {
+      final result = await PlatformBridge.loadExtensionsFromDir(dirPath);
+      _log.d('Load extensions result: $result');
+      await refreshExtensions();
+      state = state.copyWith(isLoading: false);
+    } catch (e) {
+      _log.e('Failed to load extensions: $e');
+      state = state.copyWith(isLoading: false, error: e.toString());
+    }
+  }
+
+  /// Refresh the list of installed extensions
+  Future<void> refreshExtensions() async {
+    try {
+      final list = await PlatformBridge.getInstalledExtensions();
+      final extensions = list.map((e) => Extension.fromJson(e)).toList();
+      state = state.copyWith(extensions: extensions);
+      _log.d('Loaded ${extensions.length} extensions');
+      
+      // Log search behavior for extensions that have it
+      for (final ext in extensions) {
+        if (ext.searchBehavior != null) {
+          _log.d('Extension ${ext.id}: thumbnailRatio=${ext.searchBehavior!.thumbnailRatio}');
+        }
+      }
+    } catch (e) {
+      _log.e('Failed to refresh extensions: $e');
+      state = state.copyWith(error: e.toString());
+    }
+  }
+
+  /// Clear any error state
+  void clearError() {
+    state = state.copyWith(error: null);
+  }
+
+  /// Install extension from file (auto-upgrades if already installed with newer version)
+  Future<bool> installExtension(String filePath) async {
+    state = state.copyWith(isLoading: true, error: null);
+    
+    try {
+      final result = await PlatformBridge.loadExtensionFromPath(filePath);
+      _log.i('Installed extension: ${result['name']}');
+      await refreshExtensions();
+      state = state.copyWith(isLoading: false);
+      return true;
+    } catch (e) {
+      _log.e('Failed to install extension: $e');
+      state = state.copyWith(isLoading: false, error: e.toString());
+      return false;
+    }
+  }
+
+  /// Check if a package file is an upgrade for an existing extension
+  /// Returns: {extension_id, current_version, new_version, can_upgrade, is_installed}
+  Future<Map<String, dynamic>> checkExtensionUpgrade(String filePath) async {
+    try {
+      return await PlatformBridge.checkExtensionUpgrade(filePath);
+    } catch (e) {
+      _log.e('Failed to check extension upgrade: $e');
+      return {'error': e.toString()};
+    }
+  }
+
+  /// Upgrade an existing extension from a new package file
+  Future<bool> upgradeExtension(String filePath) async {
+    state = state.copyWith(isLoading: true, error: null);
+    
+    try {
+      final result = await PlatformBridge.upgradeExtension(filePath);
+      _log.i('Upgraded extension: ${result['display_name']} to v${result['version']}');
+      await refreshExtensions();
+      state = state.copyWith(isLoading: false);
+      return true;
+    } catch (e) {
+      _log.e('Failed to upgrade extension: $e');
+      state = state.copyWith(isLoading: false, error: e.toString());
+      return false;
+    }
+  }
+
+  /// Uninstall/remove an extension
+  Future<bool> removeExtension(String extensionId) async {
+    state = state.copyWith(isLoading: true, error: null);
+    
+    try {
+      await PlatformBridge.removeExtension(extensionId);
+      _log.i('Removed extension: $extensionId');
+      await refreshExtensions();
+      state = state.copyWith(isLoading: false);
+      return true;
+    } catch (e) {
+      _log.e('Failed to remove extension: $e');
+      state = state.copyWith(isLoading: false, error: e.toString());
+      return false;
+    }
+  }
+
+  /// Enable or disable an extension
+  Future<void> setExtensionEnabled(String extensionId, bool enabled) async {
+    try {
+      await PlatformBridge.setExtensionEnabled(extensionId, enabled);
+      _log.d('Set extension $extensionId enabled: $enabled');
+      
+      // Get extension info before updating state
+      final ext = state.extensions.where((e) => e.id == extensionId).firstOrNull;
+      
+      // Update local state
+      final extensions = state.extensions.map((e) {
+        if (e.id == extensionId) {
+          return e.copyWith(enabled: enabled);
+        }
+        return e;
+      }).toList();
+      
+      state = state.copyWith(extensions: extensions);
+      
+      // If disabling an extension, reset related settings
+      if (!enabled && ext != null) {
+        final settings = ref.read(settingsProvider);
+        
+        // If this extension was the search provider, clear it and reset to Deezer
+        if (settings.searchProvider == extensionId) {
+          ref.read(settingsProvider.notifier).setSearchProvider(null);
+          ref.read(settingsProvider.notifier).setMetadataSource('deezer');
+          _log.d('Cleared search provider and reset to Deezer because extension $extensionId was disabled');
+        }
+        
+        // If this extension was the default download service, reset to Tidal
+        if (ext.hasDownloadProvider && settings.defaultService == extensionId) {
+          ref.read(settingsProvider.notifier).setDefaultService('tidal');
+          _log.d('Reset default service to Tidal because extension $extensionId was disabled');
+        }
+      }
+    } catch (e) {
+      _log.e('Failed to set extension enabled: $e');
+      state = state.copyWith(error: e.toString());
+    }
+  }
+
+  /// Get settings for an extension
+  Future<Map<String, dynamic>> getExtensionSettings(String extensionId) async {
+    try {
+      return await PlatformBridge.getExtensionSettings(extensionId);
+    } catch (e) {
+      _log.e('Failed to get extension settings: $e');
+      return {};
+    }
+  }
+
+  /// Update settings for an extension
+  Future<void> setExtensionSettings(String extensionId, Map<String, dynamic> settings) async {
+    try {
+      await PlatformBridge.setExtensionSettings(extensionId, settings);
+      _log.d('Updated settings for extension: $extensionId');
+    } catch (e) {
+      _log.e('Failed to set extension settings: $e');
+      state = state.copyWith(error: e.toString());
+    }
+  }
+
+  /// Load provider priority order
+  Future<void> loadProviderPriority() async {
+    try {
+      final priority = await PlatformBridge.getProviderPriority();
+      state = state.copyWith(providerPriority: priority);
+    } catch (e) {
+      _log.e('Failed to load provider priority: $e');
+    }
+  }
+
+  /// Set provider priority order
+  Future<void> setProviderPriority(List<String> priority) async {
+    try {
+      await PlatformBridge.setProviderPriority(priority);
+      state = state.copyWith(providerPriority: priority);
+      _log.d('Updated provider priority: $priority');
+    } catch (e) {
+      _log.e('Failed to set provider priority: $e');
+      state = state.copyWith(error: e.toString());
+    }
+  }
+
+  /// Load metadata provider priority order
+  Future<void> loadMetadataProviderPriority() async {
+    try {
+      final priority = await PlatformBridge.getMetadataProviderPriority();
+      state = state.copyWith(metadataProviderPriority: priority);
+    } catch (e) {
+      _log.e('Failed to load metadata provider priority: $e');
+    }
+  }
+
+  /// Set metadata provider priority order
+  Future<void> setMetadataProviderPriority(List<String> priority) async {
+    try {
+      await PlatformBridge.setMetadataProviderPriority(priority);
+      state = state.copyWith(metadataProviderPriority: priority);
+      _log.d('Updated metadata provider priority: $priority');
+    } catch (e) {
+      _log.e('Failed to set metadata provider priority: $e');
+      state = state.copyWith(error: e.toString());
+    }
+  }
+
+  /// Cleanup all extensions (call on app close)
+  Future<void> cleanup() async {
+    try {
+      await PlatformBridge.cleanupExtensions();
+      _log.d('Extensions cleaned up');
+    } catch (e) {
+      _log.e('Failed to cleanup extensions: $e');
+    }
+  }
+
+  /// Get extension by ID
+  Extension? getExtension(String extensionId) {
+    try {
+      return state.extensions.firstWhere((ext) => ext.id == extensionId);
+    } catch (_) {
+      return null;
+    }
+  }
+
+  /// Get all enabled extensions
+  List<Extension> get enabledExtensions {
+    return state.extensions.where((ext) => ext.enabled).toList();
+  }
+
+  /// Get all download providers (built-in + extensions)
+  List<String> getAllDownloadProviders() {
+    final providers = ['tidal', 'qobuz', 'amazon'];
+    for (final ext in state.extensions) {
+      if (ext.enabled && ext.hasDownloadProvider) {
+        providers.add(ext.id);
+      }
+    }
+    return providers;
+  }
+
+  /// Get all metadata providers (built-in + extensions)
+  List<String> getAllMetadataProviders() {
+    final providers = ['deezer', 'spotify'];
+    for (final ext in state.extensions) {
+      if (ext.enabled && ext.hasMetadataProvider) {
+        providers.add(ext.id);
+      }
+    }
+    return providers;
+  }
+  /// Get all extensions that provide custom search
+  List<Extension> get searchProviders {
+    return state.extensions.where((ext) => ext.enabled && ext.hasCustomSearch).toList();
+  }
+}
+
+final extensionProvider = NotifierProvider<ExtensionNotifier, ExtensionState>(
+  ExtensionNotifier.new,
+);
@@ -3,8 +3,11 @@ import 'package:flutter_riverpod/flutter_riverpod.dart';
 import 'package:shared_preferences/shared_preferences.dart';
 import 'package:spotiflac_android/models/settings.dart';
 import 'package:spotiflac_android/services/platform_bridge.dart';
+import 'package:spotiflac_android/utils/logger.dart';

 const _settingsKey = 'app_settings';
+const _migrationVersionKey = 'settings_migration_version';
+const _currentMigrationVersion = 1;

 class SettingsNotifier extends Notifier<AppSettings> {
  @override
@@ -18,8 +21,35 @@ class SettingsNotifier extends Notifier<AppSettings> {
    final json = prefs.getString(_settingsKey);
    if (json != null) {
      state = AppSettings.fromJson(jsonDecode(json));
+      
+      // Run migrations if needed
+      await _runMigrations(prefs);
+      
      // Apply Spotify credentials to Go backend on load
      _applySpotifyCredentials();
+      
+      // Sync logging state
+      LogBuffer.loggingEnabled = state.enableLogging;
+    }
+  }
+
+  /// Run one-time migrations for settings
+  Future<void> _runMigrations(SharedPreferences prefs) async {
+    final lastMigration = prefs.getInt(_migrationVersionKey) ?? 0;
+    
+    if (lastMigration < 1) {
+      // Migration 1: Set metadataSource to 'deezer' for existing users
+      // Only apply if user hasn't enabled custom Spotify credentials
+      // (users with custom credentials likely prefer Spotify)
+      if (!state.useCustomSpotifyCredentials) {
+        state = state.copyWith(metadataSource: 'deezer');
+        await _saveSettings();
+      }
+    }
+    
+    // Save current migration version
+    if (lastMigration < _currentMigrationVersion) {
+      await prefs.setInt(_migrationVersionKey, _currentMigrationVersion);
    }
  }

@@ -30,18 +60,16 @@ class SettingsNotifier extends Notifier<AppSettings> {

  /// Apply current Spotify credentials to Go backend
  Future<void> _applySpotifyCredentials() async {
-    // Only apply custom credentials if enabled and both fields are set
-    if (state.useCustomSpotifyCredentials && 
-        state.spotifyClientId.isNotEmpty && 
+    // Only apply if both fields are set
+    if (state.spotifyClientId.isNotEmpty && 
        state.spotifyClientSecret.isNotEmpty) {
      await PlatformBridge.setSpotifyCredentials(
        state.spotifyClientId,
        state.spotifyClientSecret,
      );
-    } else {
-      // Clear to use default
-      await PlatformBridge.setSpotifyCredentials('', '');
    }
+    // Note: If credentials are empty, Spotify API will return error
+    // User should use Deezer as metadata source instead
  }

  void setDefaultService(String service) {
@@ -118,6 +146,11 @@ class SettingsNotifier extends Notifier<AppSettings> {
    _saveSettings();
  }

+  void setHistoryFilterMode(String mode) {
+    state = state.copyWith(historyFilterMode: mode);
+    _saveSettings();
+  }
+
  void setAskQualityBeforeDownload(bool enabled) {
    state = state.copyWith(askQualityBeforeDownload: enabled);
    _saveSettings();
@@ -156,6 +189,28 @@ class SettingsNotifier extends Notifier<AppSettings> {
    _saveSettings();
    _applySpotifyCredentials();
  }
+
+  void setMetadataSource(String source) {
+    state = state.copyWith(metadataSource: source);
+    _saveSettings();
+  }
+
+  void setSearchProvider(String? provider) {
+    state = state.copyWith(searchProvider: provider);
+    _saveSettings();
+  }
+
+  void setEnableLogging(bool enabled) {
+    state = state.copyWith(enableLogging: enabled);
+    _saveSettings();
+    // Sync logging state to LogBuffer
+    LogBuffer.loggingEnabled = enabled;
+  }
+
+  void setUseExtensionProviders(bool enabled) {
+    state = state.copyWith(useExtensionProviders: enabled);
+    _saveSettings();
+  }
 }

 final settingsProvider = NotifierProvider<SettingsNotifier, AppSettings>(
@@ -1,6 +1,11 @@
 import 'package:flutter_riverpod/flutter_riverpod.dart';
 import 'package:spotiflac_android/models/track.dart';
 import 'package:spotiflac_android/services/platform_bridge.dart';
+import 'package:spotiflac_android/utils/logger.dart';
+import 'package:spotiflac_android/providers/settings_provider.dart';
+import 'package:spotiflac_android/providers/extension_provider.dart';
+
+final _log = AppLogger('TrackProvider');

 class TrackState {
  final List<Track> tracks;
@@ -15,6 +20,7 @@ class TrackState {
  final List<ArtistAlbum>? artistAlbums; // For artist page
  final List<SearchArtist>? searchArtists; // For search results
  final bool hasSearchText; // For back button handling
+  final String? searchExtensionId; // Extension ID used for current search results

  const TrackState({
    this.tracks = const [],
@@ -29,6 +35,7 @@ class TrackState {
    this.artistAlbums,
    this.searchArtists,
    this.hasSearchText = false,
+    this.searchExtensionId,
  });

  bool get hasContent => tracks.isNotEmpty || artistAlbums != null || (searchArtists != null && searchArtists!.isNotEmpty);
@@ -46,6 +53,7 @@ class TrackState {
    List<ArtistAlbum>? artistAlbums,
    List<SearchArtist>? searchArtists,
    bool? hasSearchText,
+    String? searchExtensionId,
  }) {
    return TrackState(
      tracks: tracks ?? this.tracks,
@@ -60,6 +68,7 @@ class TrackState {
      artistAlbums: artistAlbums ?? this.artistAlbums,
      searchArtists: searchArtists ?? this.searchArtists,
      hasSearchText: hasSearchText ?? this.hasSearchText,
+      searchExtensionId: searchExtensionId,
    );
  }
 }
@@ -114,7 +123,7 @@ class TrackNotifier extends Notifier<TrackState> {
  /// Check if request is still valid (not cancelled by newer request)
  bool _isRequestValid(int requestId) => requestId == _currentRequestId;

-  Future<void> fetchFromUrl(String url) async {
+  Future<void> fetchFromUrl(String url, {bool useDeezerFallback = true}) async {
    // Increment request ID to cancel any pending requests
    final requestId = ++_currentRequestId;

@@ -127,7 +136,22 @@ class TrackNotifier extends Notifier<TrackState> {
      
      final type = parsed['type'] as String;

-      final metadata = await PlatformBridge.getSpotifyMetadata(url);
+      // Use the new fallback-enabled method
+      Map<String, dynamic> metadata;
+      
+      try {
+        // ignore: avoid_print
+        print('[FetchURL] Fetching $type with Deezer fallback enabled...');
+        metadata = await PlatformBridge.getSpotifyMetadataWithFallback(url);
+        // ignore: avoid_print
+        print('[FetchURL] Metadata fetch success');
+      } catch (e) {
+        // If fallback also fails, show error
+        // ignore: avoid_print
+        print('[FetchURL] Metadata fetch failed: $e');
+        rethrow;
+      }
+      
      if (!_isRequestValid(requestId)) return; // Request cancelled

      if (type == 'track') {
@@ -184,7 +208,7 @@ class TrackNotifier extends Notifier<TrackState> {
    }
  }

-  Future<void> search(String query) async {
+  Future<void> search(String query, {String? metadataSource}) async {
    // Increment request ID to cancel any pending requests
    final requestId = ++_currentRequestId;

@@ -192,14 +216,109 @@ class TrackNotifier extends Notifier<TrackState> {
    state = TrackState(isLoading: true, hasSearchText: state.hasSearchText);

    try {
-      final results = await PlatformBridge.searchSpotifyAll(query, trackLimit: 20, artistLimit: 5);
-      if (!_isRequestValid(requestId)) return; // Request cancelled
+      // Check if extension providers should be used for search
+      final settings = ref.read(settingsProvider);
+      final extensionState = ref.read(extensionProvider);
+      final hasActiveMetadataExtensions = extensionState.extensions.any(
+        (e) => e.enabled && e.hasMetadataProvider,
+      );
+      final useExtensions = settings.useExtensionProviders && hasActiveMetadataExtensions;
+
+      // Use Deezer or Spotify based on settings
+      final source = metadataSource ?? 'deezer';
+      
+      _log.i('Search started: source=$source, query="$query", useExtensions=$useExtensions');
+      
+      Map<String, dynamic> results;
+      List<Track> extensionTracks = [];
+      
+      // Try extension providers first if enabled
+      if (useExtensions) {
+        try {
+          _log.d('Calling extension search API...');
+          final extResults = await PlatformBridge.searchTracksWithExtensions(query, limit: 20);
+          _log.i('Extensions returned ${extResults.length} tracks');
+          
+          // Parse extension results
+          for (final t in extResults) {
+            try {
+              extensionTracks.add(_parseSearchTrack(t));
+            } catch (e) {
+              _log.e('Failed to parse extension track: $e', e);
+            }
+          }
+        } catch (e) {
+          _log.w('Extension search failed, falling back to built-in: $e');
+        }
+      }
+      
+      // Also search with built-in providers
+      if (source == 'deezer') {
+        _log.d('Calling Deezer search API...');
+        results = await PlatformBridge.searchDeezerAll(query, trackLimit: 20, artistLimit: 5);
+        _log.i('Deezer returned ${(results['tracks'] as List?)?.length ?? 0} tracks, ${(results['artists'] as List?)?.length ?? 0} artists');
+      } else {
+        _log.d('Calling Spotify search API...');
+        results = await PlatformBridge.searchSpotifyAll(query, trackLimit: 20, artistLimit: 5);
+        _log.i('Spotify returned ${(results['tracks'] as List?)?.length ?? 0} tracks, ${(results['artists'] as List?)?.length ?? 0} artists');
+      }
+      
+      if (!_isRequestValid(requestId)) {
+        _log.w('Search request cancelled (requestId=$requestId)');
+        return;
+      }
      
      final trackList = results['tracks'] as List<dynamic>? ?? [];
      final artistList = results['artists'] as List<dynamic>? ?? [];
      
-      final tracks = trackList.map((t) => _parseSearchTrack(t as Map<String, dynamic>)).toList();
-      final artists = artistList.map((a) => _parseSearchArtist(a as Map<String, dynamic>)).toList();
+      _log.d('Raw results: ${trackList.length} tracks, ${artistList.length} artists');
+      
+      // Parse tracks with error handling per item
+      final tracks = <Track>[];
+      
+      // Add extension tracks first (they have priority)
+      tracks.addAll(extensionTracks);
+      
+      // Add built-in provider tracks, avoiding duplicates by ISRC
+      final existingIsrcs = extensionTracks
+          .where((t) => t.isrc != null && t.isrc!.isNotEmpty)
+          .map((t) => t.isrc!)
+          .toSet();
+      
+      for (int i = 0; i < trackList.length; i++) {
+        final t = trackList[i];
+        try {
+          if (t is Map<String, dynamic>) {
+            final track = _parseSearchTrack(t);
+            // Skip if we already have this track from extensions
+            if (track.isrc != null && existingIsrcs.contains(track.isrc)) {
+              continue;
+            }
+            tracks.add(track);
+          } else {
+            _log.w('Track[$i] is not a Map: ${t.runtimeType}');
+          }
+        } catch (e) {
+          _log.e('Failed to parse track[$i]: $e', e);
+        }
+      }
+      
+      // Parse artists with error handling per item
+      final artists = <SearchArtist>[];
+      for (int i = 0; i < artistList.length; i++) {
+        final a = artistList[i];
+        try {
+          if (a is Map<String, dynamic>) {
+            artists.add(_parseSearchArtist(a));
+          } else {
+            _log.w('Artist[$i] is not a Map: ${a.runtimeType}');
+          }
+        } catch (e) {
+          _log.e('Failed to parse artist[$i]: $e', e);
+        }
+      }
+      
+      _log.i('Search complete: ${tracks.length} tracks (${extensionTracks.length} from extensions), ${artists.length} artists parsed successfully');
      
      state = TrackState(
        tracks: tracks,
@@ -207,9 +326,56 @@ class TrackNotifier extends Notifier<TrackState> {
        isLoading: false,
        hasSearchText: state.hasSearchText,
      );
-    } catch (e) {
-      if (!_isRequestValid(requestId)) return; // Request cancelled
-      // Preserve hasSearchText on error so user stays on search screen
+    } catch (e, stackTrace) {
+      if (!_isRequestValid(requestId)) return;
+      _log.e('Search failed: $e', e, stackTrace);
+      state = TrackState(isLoading: false, error: e.toString(), hasSearchText: state.hasSearchText);
+    }
+  }
+
+  /// Perform custom search using a specific extension
+  Future<void> customSearch(String extensionId, String query, {Map<String, dynamic>? options}) async {
+    // Increment request ID to cancel any pending requests
+    final requestId = ++_currentRequestId;
+
+    // Preserve hasSearchText during search
+    state = TrackState(isLoading: true, hasSearchText: state.hasSearchText);
+
+    try {
+      _log.i('Custom search started: extension=$extensionId, query="$query"');
+      
+      final results = await PlatformBridge.customSearchWithExtension(extensionId, query, options: options);
+      
+      if (!_isRequestValid(requestId)) {
+        _log.w('Custom search request cancelled (requestId=$requestId)');
+        return;
+      }
+      
+      _log.i('Custom search returned ${results.length} tracks');
+      
+      // Parse tracks with error handling per item, setting source to extension ID
+      final tracks = <Track>[];
+      for (int i = 0; i < results.length; i++) {
+        final t = results[i];
+        try {
+          tracks.add(_parseSearchTrack(t, source: extensionId));
+        } catch (e) {
+          _log.e('Failed to parse custom search track[$i]: $e', e);
+        }
+      }
+      
+      _log.i('Custom search complete: ${tracks.length} tracks parsed (source=$extensionId)');
+      
+      state = TrackState(
+        tracks: tracks,
+        searchArtists: [], // Custom search doesn't return artists
+        isLoading: false,
+        hasSearchText: state.hasSearchText,
+        searchExtensionId: extensionId, // Store which extension was used
+      );
+    } catch (e, stackTrace) {
+      if (!_isRequestValid(requestId)) return;
+      _log.e('Custom search failed: $e', e, stackTrace);
      state = TrackState(isLoading: false, error: e.toString(), hasSearchText: state.hasSearchText);
    }
  }
@@ -277,19 +443,29 @@ class TrackNotifier extends Notifier<TrackState> {
    );
  }

-  Track _parseSearchTrack(Map<String, dynamic> data) {
+  Track _parseSearchTrack(Map<String, dynamic> data, {String? source}) {
+    // Handle duration_ms which might be int or double
+    int durationMs = 0;
+    final durationValue = data['duration_ms'];
+    if (durationValue is int) {
+      durationMs = durationValue;
+    } else if (durationValue is double) {
+      durationMs = durationValue.toInt();
+    }
+    
    return Track(
-      id: data['spotify_id'] as String? ?? '',
-      name: data['name'] as String? ?? '',
-      artistName: data['artists'] as String? ?? '',
-      albumName: data['album_name'] as String? ?? '',
-      albumArtist: data['album_artist'] as String?,
-      coverUrl: data['images'] as String?,
-      isrc: data['isrc'] as String?,
-      duration: ((data['duration_ms'] as int? ?? 0) / 1000).round(),
+      id: (data['spotify_id'] ?? data['id'] ?? '').toString(),
+      name: (data['name'] ?? '').toString(),
+      artistName: (data['artists'] ?? data['artist'] ?? '').toString(),
+      albumName: (data['album_name'] ?? data['album'] ?? '').toString(),
+      albumArtist: data['album_artist']?.toString(),
+      coverUrl: data['images']?.toString(),
+      isrc: data['isrc']?.toString(),
+      duration: (durationMs / 1000).round(),
      trackNumber: data['track_number'] as int?,
      discNumber: data['disc_number'] as int?,
-      releaseDate: data['release_date'] as String?,
+      releaseDate: data['release_date']?.toString(),
+      source: source ?? data['source']?.toString() ?? data['provider_id']?.toString(),
    );
  }

@@ -7,6 +7,7 @@ import 'package:spotiflac_android/models/download_item.dart';
 import 'package:spotiflac_android/providers/download_queue_provider.dart';
 import 'package:spotiflac_android/providers/settings_provider.dart';
 import 'package:spotiflac_android/services/platform_bridge.dart';
+import 'package:spotiflac_android/widgets/download_service_picker.dart';

 /// Simple in-memory cache for album tracks
 class _AlbumCache {
@@ -71,8 +72,22 @@ class _AlbumScreenState extends ConsumerState<AlbumScreen> {
  Future<void> _fetchTracks() async {
    setState(() => _isLoading = true);
    try {
-      final url = 'https://open.spotify.com/album/${widget.albumId}';
-      final metadata = await PlatformBridge.getSpotifyMetadata(url);
+      Map<String, dynamic> metadata;
+      
+      // Check if this is a Deezer album ID (format: "deezer:123456")
+      if (widget.albumId.startsWith('deezer:')) {
+        final deezerAlbumId = widget.albumId.replaceFirst('deezer:', '');
+        // ignore: avoid_print
+        print('[AlbumScreen] Fetching from Deezer: $deezerAlbumId');
+        metadata = await PlatformBridge.getDeezerMetadata('album', deezerAlbumId);
+      } else {
+        // Spotify album - use fallback method
+        // ignore: avoid_print
+        print('[AlbumScreen] Fetching from Spotify with fallback: ${widget.albumId}');
+        final url = 'https://open.spotify.com/album/${widget.albumId}';
+        metadata = await PlatformBridge.getSpotifyMetadataWithFallback(url);
+      }
+      
      final trackList = metadata['track_list'] as List<dynamic>;
      final tracks = trackList.map((t) => _parseTrack(t as Map<String, dynamic>)).toList();
      
@@ -302,10 +317,16 @@ class _AlbumScreenState extends ConsumerState<AlbumScreen> {
  void _downloadTrack(BuildContext context, Track track) {
    final settings = ref.read(settingsProvider);
    if (settings.askQualityBeforeDownload) {
-      _showQualityPicker(context, (quality, service) {
-        ref.read(downloadQueueProvider.notifier).addToQueue(track, service, qualityOverride: quality);
-        ScaffoldMessenger.of(context).showSnackBar(SnackBar(content: Text('Added "${track.name}" to queue')));
-      }, trackName: track.name, artistName: track.artistName, coverUrl: track.coverUrl);
+      DownloadServicePicker.show(
+        context,
+        trackName: track.name,
+        artistName: track.artistName,
+        coverUrl: track.coverUrl,
+        onSelect: (quality, service) {
+          ref.read(downloadQueueProvider.notifier).addToQueue(track, service, qualityOverride: quality);
+          ScaffoldMessenger.of(context).showSnackBar(SnackBar(content: Text('Added "${track.name}" to queue')));
+        },
+      );
    } else {
      ref.read(downloadQueueProvider.notifier).addToQueue(track, settings.defaultService);
      ScaffoldMessenger.of(context).showSnackBar(SnackBar(content: Text('Added "${track.name}" to queue')));
@@ -317,84 +338,21 @@ class _AlbumScreenState extends ConsumerState<AlbumScreen> {
    if (tracks == null || tracks.isEmpty) return;
    final settings = ref.read(settingsProvider);
    if (settings.askQualityBeforeDownload) {
-      _showQualityPicker(context, (quality, service) {
-        ref.read(downloadQueueProvider.notifier).addMultipleToQueue(tracks, service, qualityOverride: quality);
-        ScaffoldMessenger.of(context).showSnackBar(SnackBar(content: Text('Added ${tracks.length} tracks to queue')));
-      }, trackName: '${tracks.length} tracks', artistName: widget.albumName);
+      DownloadServicePicker.show(
+        context,
+        trackName: '${tracks.length} tracks',
+        artistName: widget.albumName,
+        onSelect: (quality, service) {
+          ref.read(downloadQueueProvider.notifier).addMultipleToQueue(tracks, service, qualityOverride: quality);
+          ScaffoldMessenger.of(context).showSnackBar(SnackBar(content: Text('Added ${tracks.length} tracks to queue')));
+        },
+      );
    } else {
      ref.read(downloadQueueProvider.notifier).addMultipleToQueue(tracks, settings.defaultService);
      ScaffoldMessenger.of(context).showSnackBar(SnackBar(content: Text('Added ${tracks.length} tracks to queue')));
    }
  }

-  void _showQualityPicker(BuildContext context, void Function(String quality, String service) onSelect, {String? trackName, String? artistName, String? coverUrl}) {
-    final colorScheme = Theme.of(context).colorScheme;
-    final settings = ref.read(settingsProvider);
-    String selectedService = settings.defaultService;
-    
-    showModalBottomSheet(
-      context: context,
-      backgroundColor: colorScheme.surfaceContainerHigh,
-      shape: const RoundedRectangleBorder(borderRadius: BorderRadius.vertical(top: Radius.circular(28))),
-      isScrollControlled: true,
-      builder: (context) => StatefulBuilder(
-        builder: (context, setModalState) => SafeArea(
-          child: SingleChildScrollView(
-            child: Column(
-              mainAxisSize: MainAxisSize.min,
-              crossAxisAlignment: CrossAxisAlignment.start,
-              children: [
-                if (trackName != null) ...[
-                  _TrackInfoHeader(trackName: trackName, artistName: artistName, coverUrl: coverUrl),
-                  Divider(height: 1, color: colorScheme.outlineVariant.withValues(alpha: 0.5)),
-                ] else ...[
-                  const SizedBox(height: 8),
-                  Center(child: Container(width: 40, height: 4, decoration: BoxDecoration(color: colorScheme.onSurfaceVariant.withValues(alpha: 0.4), borderRadius: BorderRadius.circular(2)))),
-                ],
-                // Service selector
-                Padding(
-                  padding: const EdgeInsets.fromLTRB(24, 16, 24, 8),
-                  child: Text('Download From', style: Theme.of(context).textTheme.titleMedium?.copyWith(fontWeight: FontWeight.bold)),
-                ),
-                Padding(
-                  padding: const EdgeInsets.symmetric(horizontal: 20),
-                  child: Row(
-                    children: [
-                      _ServiceChip(label: 'Tidal', isSelected: selectedService == 'tidal', onTap: () => setModalState(() => selectedService = 'tidal')),
-                      const SizedBox(width: 8),
-                      _ServiceChip(label: 'Qobuz', isSelected: selectedService == 'qobuz', onTap: () => setModalState(() => selectedService = 'qobuz')),
-                      const SizedBox(width: 8),
-                      _ServiceChip(label: 'Amazon', isSelected: selectedService == 'amazon', onTap: () => setModalState(() => selectedService = 'amazon')),
-                    ],
-                  ),
-                ),
-                Padding(
-                  padding: const EdgeInsets.fromLTRB(24, 16, 24, 8),
-                  child: Text('Select Quality', style: Theme.of(context).textTheme.titleMedium?.copyWith(fontWeight: FontWeight.bold)),
-                ),
-                // Disclaimer
-                Padding(
-                  padding: const EdgeInsets.fromLTRB(24, 0, 24, 12),
-                  child: Text(
-                    'Actual quality depends on track availability. Hi-Res may not be available for all tracks.',
-                    style: Theme.of(context).textTheme.bodySmall?.copyWith(
-                      color: colorScheme.onSurfaceVariant,
-                      fontStyle: FontStyle.italic,
-                    ),
-                  ),
-                ),
-                _QualityOption(title: 'FLAC Lossless', subtitle: '16-bit / 44.1kHz', icon: Icons.music_note, onTap: () { Navigator.pop(context); onSelect('LOSSLESS', selectedService); }),
-                _QualityOption(title: 'Hi-Res FLAC', subtitle: '24-bit / up to 96kHz', icon: Icons.high_quality, onTap: () { Navigator.pop(context); onSelect('HI_RES', selectedService); }),
-                _QualityOption(title: 'Hi-Res FLAC Max', subtitle: '24-bit / up to 192kHz', icon: Icons.four_k, onTap: () { Navigator.pop(context); onSelect('HI_RES_LOSSLESS', selectedService); }),
-                const SizedBox(height: 16),
-              ],
-            ),
-          ),
-        ),
-      ),
-    );
-  }
-
  /// Build error widget with special handling for rate limit (429)
  Widget _buildErrorWidget(String error, ColorScheme colorScheme) {
    final isRateLimit = error.contains('429') || 
@@ -459,148 +417,6 @@ class _AlbumScreenState extends ConsumerState<AlbumScreen> {
  }
 }

-class _QualityOption extends StatelessWidget {
-  final String title;
-  final String subtitle;
-  final IconData icon;
-  final VoidCallback onTap;
-
-  const _QualityOption({required this.title, required this.subtitle, required this.icon, required this.onTap});
-
-  @override
-  Widget build(BuildContext context) {
-    final colorScheme = Theme.of(context).colorScheme;
-    return ListTile(
-      contentPadding: const EdgeInsets.symmetric(horizontal: 24, vertical: 4),
-      leading: Container(padding: const EdgeInsets.all(10), decoration: BoxDecoration(color: colorScheme.primaryContainer, borderRadius: BorderRadius.circular(12)), child: Icon(icon, color: colorScheme.onPrimaryContainer, size: 20)),
-      title: Text(title, style: const TextStyle(fontWeight: FontWeight.w500)),
-      subtitle: Text(subtitle, style: TextStyle(color: colorScheme.onSurfaceVariant)),
-      onTap: onTap,
-    );
-  }
-}
-
-class _ServiceChip extends StatelessWidget {
-  final String label;
-  final bool isSelected;
-  final VoidCallback onTap;
-  const _ServiceChip({required this.label, required this.isSelected, required this.onTap});
-
-  @override
-  Widget build(BuildContext context) {
-    final colorScheme = Theme.of(context).colorScheme;
-    return Expanded(
-      child: GestureDetector(
-        onTap: onTap,
-        child: AnimatedContainer(
-          duration: const Duration(milliseconds: 200),
-          padding: const EdgeInsets.symmetric(vertical: 10),
-          decoration: BoxDecoration(
-            color: isSelected ? colorScheme.primaryContainer : colorScheme.surfaceContainerHighest,
-            borderRadius: BorderRadius.circular(12),
-            border: isSelected ? null : Border.all(color: colorScheme.outlineVariant.withValues(alpha: 0.5)),
-          ),
-          child: Text(
-            label,
-            textAlign: TextAlign.center,
-            style: TextStyle(
-              fontWeight: isSelected ? FontWeight.w600 : FontWeight.normal,
-              color: isSelected ? colorScheme.onPrimaryContainer : colorScheme.onSurfaceVariant,
-            ),
-          ),
-        ),
-      ),
-    );
-  }
-}
-
-class _TrackInfoHeader extends StatefulWidget {
-  final String trackName;
-  final String? artistName;
-  final String? coverUrl;
-  const _TrackInfoHeader({required this.trackName, this.artistName, this.coverUrl});
-
-  @override
-  State<_TrackInfoHeader> createState() => _TrackInfoHeaderState();
-}
-
-class _TrackInfoHeaderState extends State<_TrackInfoHeader> {
-  bool _expanded = false;
-  bool _isOverflowing = false;
-
-  @override
-  Widget build(BuildContext context) {
-    final colorScheme = Theme.of(context).colorScheme;
-    return Material(
-      color: Colors.transparent,
-      child: InkWell(
-        onTap: _isOverflowing ? () => setState(() => _expanded = !_expanded) : null,
-        borderRadius: const BorderRadius.only(topLeft: Radius.circular(28), topRight: Radius.circular(28)),
-        child: Column(
-          children: [
-            const SizedBox(height: 8),
-            Container(width: 40, height: 4, decoration: BoxDecoration(color: colorScheme.onSurfaceVariant.withValues(alpha: 0.4), borderRadius: BorderRadius.circular(2))),
-            Padding(
-              padding: const EdgeInsets.fromLTRB(16, 12, 16, 12),
-              child: Row(
-                children: [
-                  ClipRRect(
-                    borderRadius: BorderRadius.circular(8),
-                    child: widget.coverUrl != null
-                        ? Image.network(widget.coverUrl!, width: 56, height: 56, fit: BoxFit.cover,
-                            errorBuilder: (_, e, s) => Container(width: 56, height: 56, color: colorScheme.surfaceContainerHighest, child: Icon(Icons.music_note, color: colorScheme.onSurfaceVariant)))
-                        : Container(width: 56, height: 56, color: colorScheme.surfaceContainerHighest, child: Icon(Icons.music_note, color: colorScheme.onSurfaceVariant)),
-                  ),
-                  const SizedBox(width: 12),
-                  Expanded(
-                    child: LayoutBuilder(
-                      builder: (context, constraints) {
-                        final titleStyle = Theme.of(context).textTheme.titleMedium?.copyWith(fontWeight: FontWeight.w600);
-                        final titleSpan = TextSpan(text: widget.trackName, style: titleStyle);
-                        final titlePainter = TextPainter(text: titleSpan, maxLines: 1, textDirection: TextDirection.ltr)..layout(maxWidth: constraints.maxWidth);
-                        final titleOverflows = titlePainter.didExceedMaxLines;
-                        
-                        WidgetsBinding.instance.addPostFrameCallback((_) {
-                          if (mounted && _isOverflowing != titleOverflows) {
-                            setState(() => _isOverflowing = titleOverflows);
-                          }
-                        });
-                        
-                        return Column(
-                          crossAxisAlignment: CrossAxisAlignment.start,
-                          children: [
-                            Text(
-                              widget.trackName,
-                              style: titleStyle,
-                              maxLines: _expanded ? 10 : 1,
-                              overflow: _expanded ? TextOverflow.visible : TextOverflow.ellipsis,
-                            ),
-                            if (widget.artistName != null) ...[
-                              const SizedBox(height: 2),
-                              Text(
-                                widget.artistName!,
-                                style: Theme.of(context).textTheme.bodyMedium?.copyWith(color: colorScheme.onSurfaceVariant),
-                                maxLines: _expanded ? 3 : 1,
-                                overflow: _expanded ? TextOverflow.visible : TextOverflow.ellipsis,
-                              ),
-                            ],
-                          ],
-                        );
-                      },
-                    ),
-                  ),
-                  if (_isOverflowing || _expanded)
-                    Icon(_expanded ? Icons.expand_less : Icons.expand_more, color: colorScheme.onSurfaceVariant, size: 20),
-                ],
-              ),
-            ),
-          ],
-        ),
-      ),
-    );
-  }
-}
-
 /// Separate Consumer widget for each track - only rebuilds when this specific track's status changes
 class _AlbumTrackItem extends ConsumerWidget {
  final Track track;
@@ -69,10 +69,25 @@ class _ArtistScreenState extends ConsumerState<ArtistScreen> {
  Future<void> _fetchDiscography() async {
    setState(() => _isLoadingDiscography = true);
    try {
-      final url = 'https://open.spotify.com/artist/${widget.artistId}';
-      final metadata = await PlatformBridge.getSpotifyMetadata(url);
-      final albumsList = metadata['albums'] as List<dynamic>;
-      final albums = albumsList.map((a) => _parseArtistAlbum(a as Map<String, dynamic>)).toList();
+      List<ArtistAlbum> albums;
+      
+      // Check if this is a Deezer artist ID (format: "deezer:123456")
+      if (widget.artistId.startsWith('deezer:')) {
+        final deezerArtistId = widget.artistId.replaceFirst('deezer:', '');
+        // ignore: avoid_print
+        print('[ArtistScreen] Fetching from Deezer: $deezerArtistId');
+        final metadata = await PlatformBridge.getDeezerMetadata('artist', deezerArtistId);
+        final albumsList = metadata['albums'] as List<dynamic>;
+        albums = albumsList.map((a) => _parseArtistAlbum(a as Map<String, dynamic>)).toList();
+      } else {
+        // Spotify artist - use fallback method
+        // ignore: avoid_print
+        print('[ArtistScreen] Fetching from Spotify with fallback: ${widget.artistId}');
+        final url = 'https://open.spotify.com/artist/${widget.artistId}';
+        final metadata = await PlatformBridge.getSpotifyMetadataWithFallback(url);
+        final albumsList = metadata['albums'] as List<dynamic>;
+        albums = albumsList.map((a) => _parseArtistAlbum(a as Map<String, dynamic>)).toList();
+      }
      
      // Store in cache
      _ArtistCache.set(widget.artistId, albums);
@@ -144,6 +159,11 @@ class _ArtistScreenState extends ConsumerState<ArtistScreen> {
  }

  Widget _buildAppBar(BuildContext context, ColorScheme colorScheme) {
+    // Validate image URL - must be non-null, non-empty, and have a valid host
+    final hasValidImage = widget.coverUrl != null && 
+                          widget.coverUrl!.isNotEmpty &&
+                          Uri.tryParse(widget.coverUrl!)?.hasAuthority == true;
+    
    return SliverAppBar(
      expandedHeight: 280,
      pinned: true,
@@ -154,8 +174,15 @@ class _ArtistScreenState extends ConsumerState<ArtistScreen> {
        background: Stack(
          fit: StackFit.expand,
          children: [
-            if (widget.coverUrl != null)
-              CachedNetworkImage(imageUrl: widget.coverUrl!, fit: BoxFit.cover, color: Colors.black.withValues(alpha: 0.5), colorBlendMode: BlendMode.darken, memCacheWidth: 600),
+            if (hasValidImage)
+              CachedNetworkImage(
+                imageUrl: widget.coverUrl!, 
+                fit: BoxFit.cover, 
+                color: Colors.black.withValues(alpha: 0.5), 
+                colorBlendMode: BlendMode.darken, 
+                memCacheWidth: 600,
+                errorWidget: (context, url, error) => Container(color: colorScheme.surfaceContainerHighest),
+              ),
            Container(
              decoration: BoxDecoration(
                gradient: LinearGradient(
@@ -177,8 +204,16 @@ class _ArtistScreenState extends ConsumerState<ArtistScreen> {
                    boxShadow: [BoxShadow(color: Colors.black.withValues(alpha: 0.3), blurRadius: 20, offset: const Offset(0, 10))],
                  ),
                  child: ClipOval(
-                    child: widget.coverUrl != null
-                        ? CachedNetworkImage(imageUrl: widget.coverUrl!, fit: BoxFit.cover, memCacheWidth: 280)
+                    child: hasValidImage
+                        ? CachedNetworkImage(
+                            imageUrl: widget.coverUrl!, 
+                            fit: BoxFit.cover, 
+                            memCacheWidth: 280,
+                            errorWidget: (context, url, error) => Container(
+                              color: colorScheme.surfaceContainerHighest, 
+                              child: Icon(Icons.person, size: 48, color: colorScheme.onSurfaceVariant),
+                            ),
+                          )
                        : Container(color: colorScheme.surfaceContainerHighest, child: Icon(Icons.person, size: 48, color: colorScheme.onSurfaceVariant)),
                  ),
                ),
@@ -290,7 +325,9 @@ class _ArtistScreenState extends ConsumerState<ArtistScreen> {
                      Text(album.name, style: Theme.of(context).textTheme.bodySmall?.copyWith(fontWeight: FontWeight.w600), maxLines: 2, overflow: TextOverflow.ellipsis),
                      const Spacer(),
                      Text(
-                        '${album.releaseDate.length >= 4 ? album.releaseDate.substring(0, 4) : album.releaseDate} • ${album.totalTracks} tracks',
+                        album.totalTracks > 0 
+                            ? '${album.releaseDate.length >= 4 ? album.releaseDate.substring(0, 4) : album.releaseDate} • ${album.totalTracks} tracks'
+                            : album.releaseDate.length >= 4 ? album.releaseDate.substring(0, 4) : album.releaseDate,
                        style: Theme.of(context).textTheme.bodySmall?.copyWith(color: colorScheme.onSurfaceVariant, fontSize: 11),
                        maxLines: 1,
                        overflow: TextOverflow.ellipsis,
@@ -0,0 +1,573 @@
+import 'dart:io';
+import 'package:flutter/material.dart';
+import 'package:flutter/services.dart';
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:cached_network_image/cached_network_image.dart';
+import 'package:open_filex/open_filex.dart';
+import 'package:spotiflac_android/providers/download_queue_provider.dart';
+import 'package:spotiflac_android/screens/track_metadata_screen.dart';
+
+/// Screen to display downloaded tracks from a specific album
+class DownloadedAlbumScreen extends ConsumerStatefulWidget {
+  final String albumName;
+  final String artistName;
+  final String? coverUrl;
+
+  const DownloadedAlbumScreen({
+    super.key,
+    required this.albumName,
+    required this.artistName,
+    this.coverUrl,
+  });
+
+  @override
+  ConsumerState<DownloadedAlbumScreen> createState() => _DownloadedAlbumScreenState();
+}
+
+class _DownloadedAlbumScreenState extends ConsumerState<DownloadedAlbumScreen> {
+  // Multi-select state
+  bool _isSelectionMode = false;
+  final Set<String> _selectedIds = {};
+
+  /// Get tracks for this album from history provider (reactive)
+  List<DownloadHistoryItem> _getAlbumTracks(List<DownloadHistoryItem> allItems) {
+    return allItems.where((item) {
+      final itemKey = '${item.albumName}|${item.albumArtist ?? item.artistName}';
+      final albumKey = '${widget.albumName}|${widget.artistName}';
+      return itemKey == albumKey;
+    }).toList()
+      ..sort((a, b) {
+        final aNum = a.trackNumber ?? 999;
+        final bNum = b.trackNumber ?? 999;
+        if (aNum != bNum) return aNum.compareTo(bNum);
+        return a.trackName.compareTo(b.trackName);
+      });
+  }
+
+  void _enterSelectionMode(String itemId) {
+    HapticFeedback.mediumImpact();
+    setState(() {
+      _isSelectionMode = true;
+      _selectedIds.add(itemId);
+    });
+  }
+
+  void _exitSelectionMode() {
+    setState(() {
+      _isSelectionMode = false;
+      _selectedIds.clear();
+    });
+  }
+
+  void _toggleSelection(String itemId) {
+    setState(() {
+      if (_selectedIds.contains(itemId)) {
+        _selectedIds.remove(itemId);
+        if (_selectedIds.isEmpty) {
+          _isSelectionMode = false;
+        }
+      } else {
+        _selectedIds.add(itemId);
+      }
+    });
+  }
+
+  void _selectAll(List<DownloadHistoryItem> tracks) {
+    setState(() {
+      _selectedIds.addAll(tracks.map((e) => e.id));
+    });
+  }
+
+  Future<void> _deleteSelected(List<DownloadHistoryItem> currentTracks) async {
+    final count = _selectedIds.length;
+    final confirmed = await showDialog<bool>(
+      context: context,
+      builder: (ctx) => AlertDialog(
+        title: const Text('Delete Selected'),
+        content: Text('Delete $count ${count == 1 ? 'track' : 'tracks'} from this album?\n\nThis will also delete the files from storage.'),
+        actions: [
+          TextButton(
+            onPressed: () => Navigator.pop(ctx, false),
+            child: const Text('Cancel'),
+          ),
+          FilledButton(
+            onPressed: () => Navigator.pop(ctx, true),
+            style: FilledButton.styleFrom(
+              backgroundColor: Theme.of(context).colorScheme.error,
+            ),
+            child: const Text('Delete'),
+          ),
+        ],
+      ),
+    );
+
+    if (confirmed == true && mounted) {
+      final historyNotifier = ref.read(downloadHistoryProvider.notifier);
+      final idsToDelete = _selectedIds.toList();
+      
+      int deletedCount = 0;
+      for (final id in idsToDelete) {
+        final item = currentTracks.where((e) => e.id == id).firstOrNull;
+        if (item != null) {
+          try {
+            final file = File(item.filePath);
+            if (await file.exists()) {
+              await file.delete();
+            }
+          } catch (_) {}
+          historyNotifier.removeFromHistory(id);
+          deletedCount++;
+        }
+      }
+      
+      _exitSelectionMode();
+      
+      if (mounted) {
+        ScaffoldMessenger.of(context).showSnackBar(
+          SnackBar(content: Text('Deleted $deletedCount ${deletedCount == 1 ? 'track' : 'tracks'}')),
+        );
+      }
+    }
+  }
+
+  Future<void> _openFile(String filePath) async {
+    try {
+      await OpenFilex.open(filePath);
+    } catch (e) {
+      if (mounted) {
+        ScaffoldMessenger.of(context).showSnackBar(
+          SnackBar(content: Text('Cannot open file: $e')),
+        );
+      }
+    }
+  }
+
+  void _navigateToMetadataScreen(DownloadHistoryItem item) {
+    Navigator.push(context, PageRouteBuilder(
+      transitionDuration: const Duration(milliseconds: 300),
+      reverseTransitionDuration: const Duration(milliseconds: 250),
+      pageBuilder: (context, animation, secondaryAnimation) => TrackMetadataScreen(item: item),
+      transitionsBuilder: (context, animation, secondaryAnimation, child) => FadeTransition(opacity: animation, child: child),
+    ));
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    final colorScheme = Theme.of(context).colorScheme;
+    final bottomPadding = MediaQuery.of(context).padding.bottom;
+    
+    // Watch history and get tracks for this album (reactive!)
+    final allHistoryItems = ref.watch(downloadHistoryProvider.select((s) => s.items));
+    final tracks = _getAlbumTracks(allHistoryItems);
+    
+    // Auto-pop if album has less than 2 tracks (no longer an "album")
+    if (tracks.length < 2) {
+      WidgetsBinding.instance.addPostFrameCallback((_) {
+        if (mounted) Navigator.pop(context);
+      });
+      return const SizedBox.shrink();
+    }
+    
+    // Clean up selected IDs that no longer exist
+    final validIds = tracks.map((t) => t.id).toSet();
+    _selectedIds.removeWhere((id) => !validIds.contains(id));
+    if (_selectedIds.isEmpty && _isSelectionMode) {
+      WidgetsBinding.instance.addPostFrameCallback((_) {
+        if (mounted) setState(() => _isSelectionMode = false);
+      });
+    }
+
+    return PopScope(
+      canPop: !_isSelectionMode,
+      onPopInvokedWithResult: (didPop, result) {
+        if (!didPop && _isSelectionMode) {
+          _exitSelectionMode();
+        }
+      },
+      child: Scaffold(
+        body: Stack(
+          children: [
+            CustomScrollView(
+              slivers: [
+                _buildAppBar(context, colorScheme),
+                _buildInfoCard(context, colorScheme, tracks),
+                _buildTrackListHeader(context, colorScheme, tracks),
+                _buildTrackList(context, colorScheme, tracks),
+                SliverToBoxAdapter(child: SizedBox(height: _isSelectionMode ? 120 : 32)),
+              ],
+            ),
+            
+            // Bottom Selection Action Bar
+            AnimatedPositioned(
+              duration: const Duration(milliseconds: 250),
+              curve: Curves.easeOutCubic,
+              left: 0,
+              right: 0,
+              bottom: _isSelectionMode ? 0 : -(200 + bottomPadding),
+              child: _buildSelectionBottomBar(context, colorScheme, tracks, bottomPadding),
+            ),
+          ],
+        ),
+      ),
+    );
+  }
+
+  Widget _buildAppBar(BuildContext context, ColorScheme colorScheme) {
+    return SliverAppBar(
+      expandedHeight: 280,
+      pinned: true,
+      stretch: true,
+      backgroundColor: colorScheme.surface,
+      surfaceTintColor: Colors.transparent,
+      flexibleSpace: FlexibleSpaceBar(
+        background: Stack(
+          fit: StackFit.expand,
+          children: [
+            if (widget.coverUrl != null)
+              CachedNetworkImage(
+                imageUrl: widget.coverUrl!,
+                fit: BoxFit.cover,
+                color: Colors.black.withValues(alpha: 0.5),
+                colorBlendMode: BlendMode.darken,
+                memCacheWidth: 600,
+              ),
+            Container(
+              decoration: BoxDecoration(
+                gradient: LinearGradient(
+                  begin: Alignment.topCenter,
+                  end: Alignment.bottomCenter,
+                  colors: [
+                    Colors.transparent,
+                    colorScheme.surface.withValues(alpha: 0.8),
+                    colorScheme.surface,
+                  ],
+                  stops: const [0.0, 0.7, 1.0],
+                ),
+              ),
+            ),
+            Center(
+              child: Padding(
+                padding: const EdgeInsets.only(top: 60),
+                child: Container(
+                  width: 140,
+                  height: 140,
+                  decoration: BoxDecoration(
+                    borderRadius: BorderRadius.circular(16),
+                    boxShadow: [
+                      BoxShadow(
+                        color: Colors.black.withValues(alpha: 0.3),
+                        blurRadius: 20,
+                        offset: const Offset(0, 10),
+                      ),
+                    ],
+                  ),
+                  child: ClipRRect(
+                    borderRadius: BorderRadius.circular(16),
+                    child: widget.coverUrl != null
+                        ? CachedNetworkImage(imageUrl: widget.coverUrl!, fit: BoxFit.cover, memCacheWidth: 280)
+                        : Container(
+                            color: colorScheme.surfaceContainerHighest,
+                            child: Icon(Icons.album, size: 48, color: colorScheme.onSurfaceVariant),
+                          ),
+                  ),
+                ),
+              ),
+            ),
+          ],
+        ),
+        stretchModes: const [StretchMode.zoomBackground, StretchMode.blurBackground],
+      ),
+      leading: IconButton(
+        icon: Container(
+          padding: const EdgeInsets.all(8),
+          decoration: BoxDecoration(color: colorScheme.surface.withValues(alpha: 0.8), shape: BoxShape.circle),
+          child: Icon(Icons.arrow_back, color: colorScheme.onSurface),
+        ),
+        onPressed: () => Navigator.pop(context),
+      ),
+    );
+  }
+
+  Widget _buildInfoCard(BuildContext context, ColorScheme colorScheme, List<DownloadHistoryItem> tracks) {
+    return SliverToBoxAdapter(
+      child: Padding(
+        padding: const EdgeInsets.all(16),
+        child: Card(
+          elevation: 0,
+          color: colorScheme.surfaceContainerLow,
+          shape: RoundedRectangleBorder(borderRadius: BorderRadius.circular(20)),
+          child: Padding(
+            padding: const EdgeInsets.all(20),
+            child: Column(
+              crossAxisAlignment: CrossAxisAlignment.start,
+              children: [
+                Text(
+                  widget.albumName,
+                  style: Theme.of(context).textTheme.headlineSmall?.copyWith(fontWeight: FontWeight.bold, color: colorScheme.onSurface),
+                ),
+                const SizedBox(height: 4),
+                Text(
+                  widget.artistName,
+                  style: Theme.of(context).textTheme.bodyLarge?.copyWith(color: colorScheme.onSurfaceVariant),
+                ),
+                const SizedBox(height: 12),
+                Row(
+                  children: [
+                    Container(
+                      padding: const EdgeInsets.symmetric(horizontal: 12, vertical: 6),
+                      decoration: BoxDecoration(color: colorScheme.primaryContainer, borderRadius: BorderRadius.circular(20)),
+                      child: Row(
+                        mainAxisSize: MainAxisSize.min,
+                        children: [
+                          Icon(Icons.download_done, size: 14, color: colorScheme.onPrimaryContainer),
+                          const SizedBox(width: 4),
+                          Text('${tracks.length} downloaded', style: TextStyle(color: colorScheme.onPrimaryContainer, fontWeight: FontWeight.w600, fontSize: 12)),
+                        ],
+                      ),
+                    ),
+                    const SizedBox(width: 8),
+                    if (_getCommonQuality(tracks) != null)
+                      Container(
+                        padding: const EdgeInsets.symmetric(horizontal: 12, vertical: 6),
+                        decoration: BoxDecoration(
+                          color: _getCommonQuality(tracks)!.startsWith('24') 
+                              ? colorScheme.tertiaryContainer 
+                              : colorScheme.surfaceContainerHighest,
+                          borderRadius: BorderRadius.circular(20),
+                        ),
+                        child: Text(
+                          _getCommonQuality(tracks)!,
+                          style: TextStyle(
+                            color: _getCommonQuality(tracks)!.startsWith('24') 
+                                ? colorScheme.onTertiaryContainer 
+                                : colorScheme.onSurfaceVariant,
+                            fontWeight: FontWeight.w600,
+                            fontSize: 12,
+                          ),
+                        ),
+                      ),
+                  ],
+                ),
+              ],
+            ),
+          ),
+        ),
+      ),
+    );
+  }
+
+  String? _getCommonQuality(List<DownloadHistoryItem> tracks) {
+    if (tracks.isEmpty) return null;
+    final firstQuality = tracks.first.quality;
+    if (firstQuality == null) return null;
+    for (final track in tracks) {
+      if (track.quality != firstQuality) return null;
+    }
+    return firstQuality;
+  }
+
+  Widget _buildTrackListHeader(BuildContext context, ColorScheme colorScheme, List<DownloadHistoryItem> tracks) {
+    return SliverToBoxAdapter(
+      child: Padding(
+        padding: const EdgeInsets.fromLTRB(20, 8, 20, 8),
+        child: Row(
+          children: [
+            Icon(Icons.queue_music, size: 20, color: colorScheme.primary),
+            const SizedBox(width: 8),
+            Text('Tracks', style: Theme.of(context).textTheme.titleMedium?.copyWith(fontWeight: FontWeight.w600, color: colorScheme.onSurface)),
+            const Spacer(),
+            if (!_isSelectionMode)
+              TextButton.icon(
+                onPressed: tracks.isNotEmpty ? () => _enterSelectionMode(tracks.first.id) : null,
+                icon: const Icon(Icons.checklist, size: 18),
+                label: const Text('Select'),
+                style: TextButton.styleFrom(visualDensity: VisualDensity.compact),
+              ),
+          ],
+        ),
+      ),
+    );
+  }
+
+  Widget _buildTrackList(BuildContext context, ColorScheme colorScheme, List<DownloadHistoryItem> tracks) {
+    return SliverList(
+      delegate: SliverChildBuilderDelegate(
+        (context, index) {
+          final track = tracks[index];
+          return KeyedSubtree(
+            key: ValueKey(track.id),
+            child: _buildTrackItem(context, colorScheme, track),
+          );
+        },
+        childCount: tracks.length,
+      ),
+    );
+  }
+
+  Widget _buildTrackItem(BuildContext context, ColorScheme colorScheme, DownloadHistoryItem track) {
+    final isSelected = _selectedIds.contains(track.id);
+    
+    return Padding(
+      padding: const EdgeInsets.symmetric(horizontal: 8),
+      child: Card(
+        elevation: 0,
+        color: isSelected ? colorScheme.primaryContainer.withValues(alpha: 0.3) : Colors.transparent,
+        margin: const EdgeInsets.symmetric(vertical: 2),
+        child: ListTile(
+          shape: RoundedRectangleBorder(borderRadius: BorderRadius.circular(12)),
+          onTap: _isSelectionMode 
+              ? () => _toggleSelection(track.id)
+              : () => _navigateToMetadataScreen(track),
+          onLongPress: _isSelectionMode ? null : () => _enterSelectionMode(track.id),
+          leading: Row(
+            mainAxisSize: MainAxisSize.min,
+            children: [
+              if (_isSelectionMode) ...[
+                Container(
+                  width: 24,
+                  height: 24,
+                  decoration: BoxDecoration(
+                    color: isSelected ? colorScheme.primary : Colors.transparent,
+                    shape: BoxShape.circle,
+                    border: Border.all(color: isSelected ? colorScheme.primary : colorScheme.outline, width: 2),
+                  ),
+                  child: isSelected 
+                      ? Icon(Icons.check, color: colorScheme.onPrimary, size: 16)
+                      : null,
+                ),
+                const SizedBox(width: 12),
+              ],
+              SizedBox(
+                width: 24,
+                child: Text(
+                  track.trackNumber?.toString() ?? '-',
+                  style: Theme.of(context).textTheme.bodyMedium?.copyWith(
+                    color: colorScheme.onSurfaceVariant,
+                    fontWeight: FontWeight.w500,
+                  ),
+                  textAlign: TextAlign.center,
+                ),
+              ),
+            ],
+          ),
+          title: Text(
+            track.trackName,
+            maxLines: 1,
+            overflow: TextOverflow.ellipsis,
+            style: Theme.of(context).textTheme.bodyLarge?.copyWith(fontWeight: FontWeight.w500),
+          ),
+          subtitle: Text(
+            track.artistName,
+            maxLines: 1,
+            overflow: TextOverflow.ellipsis,
+            style: TextStyle(color: colorScheme.onSurfaceVariant),
+          ),
+          trailing: _isSelectionMode ? null : IconButton(
+            onPressed: () => _openFile(track.filePath),
+            icon: Icon(Icons.play_arrow, color: colorScheme.primary),
+            style: IconButton.styleFrom(
+              backgroundColor: colorScheme.primaryContainer.withValues(alpha: 0.3),
+            ),
+          ),
+        ),
+      ),
+    );
+  }
+
+  Widget _buildSelectionBottomBar(BuildContext context, ColorScheme colorScheme, List<DownloadHistoryItem> tracks, double bottomPadding) {
+    final selectedCount = _selectedIds.length;
+    final allSelected = selectedCount == tracks.length && tracks.isNotEmpty;
+    
+    return Container(
+      decoration: BoxDecoration(
+        color: colorScheme.surfaceContainerHigh,
+        borderRadius: const BorderRadius.vertical(top: Radius.circular(28)),
+        boxShadow: [
+          BoxShadow(
+            color: Colors.black.withValues(alpha: 0.15),
+            blurRadius: 12,
+            offset: const Offset(0, -4),
+          ),
+        ],
+      ),
+      child: SafeArea(
+        top: false,
+        child: Padding(
+          padding: EdgeInsets.fromLTRB(16, 16, 16, bottomPadding > 0 ? 8 : 16),
+          child: Column(
+            mainAxisSize: MainAxisSize.min,
+            children: [
+              Container(
+                width: 32,
+                height: 4,
+                margin: const EdgeInsets.only(bottom: 16),
+                decoration: BoxDecoration(
+                  color: colorScheme.outlineVariant,
+                  borderRadius: BorderRadius.circular(2),
+                ),
+              ),
+              Row(
+                children: [
+                  IconButton.filledTonal(
+                    onPressed: _exitSelectionMode,
+                    icon: const Icon(Icons.close),
+                    style: IconButton.styleFrom(
+                      backgroundColor: colorScheme.surfaceContainerHighest,
+                    ),
+                  ),
+                  const SizedBox(width: 12),
+                  Expanded(
+                    child: Column(
+                      crossAxisAlignment: CrossAxisAlignment.start,
+                      children: [
+                        Text(
+                          '$selectedCount selected',
+                          style: Theme.of(context).textTheme.titleMedium?.copyWith(fontWeight: FontWeight.bold),
+                        ),
+                        Text(
+                          allSelected ? 'All tracks selected' : 'Tap tracks to select',
+                          style: Theme.of(context).textTheme.bodySmall?.copyWith(color: colorScheme.onSurfaceVariant),
+                        ),
+                      ],
+                    ),
+                  ),
+                  TextButton.icon(
+                    onPressed: () {
+                      if (allSelected) {
+                        _exitSelectionMode();
+                      } else {
+                        _selectAll(tracks);
+                      }
+                    },
+                    icon: Icon(allSelected ? Icons.deselect : Icons.select_all, size: 20),
+                    label: Text(allSelected ? 'Deselect' : 'Select All'),
+                    style: TextButton.styleFrom(foregroundColor: colorScheme.primary),
+                  ),
+                ],
+              ),
+              const SizedBox(height: 16),
+              SizedBox(
+                width: double.infinity,
+                child: FilledButton.icon(
+                  onPressed: selectedCount > 0 ? () => _deleteSelected(tracks) : null,
+                  icon: const Icon(Icons.delete_outline),
+                  label: Text(
+                    selectedCount > 0 
+                        ? 'Delete $selectedCount ${selectedCount == 1 ? 'track' : 'tracks'}'
+                        : 'Select tracks to delete',
+                  ),
+                  style: FilledButton.styleFrom(
+                    backgroundColor: selectedCount > 0 ? colorScheme.error : colorScheme.surfaceContainerHighest,
+                    foregroundColor: selectedCount > 0 ? colorScheme.onError : colorScheme.onSurfaceVariant,
+                    padding: const EdgeInsets.symmetric(vertical: 16),
+                    shape: RoundedRectangleBorder(borderRadius: BorderRadius.circular(16)),
+                  ),
+                ),
+              ),
+            ],
+          ),
+        ),
+      ),
+    );
+  }
+}
@@ -38,7 +38,8 @@ class _HomeScreenState extends ConsumerState<HomeScreen> {
    if (url.startsWith('http') || url.startsWith('spotify:')) {
      await ref.read(trackProvider.notifier).fetchFromUrl(url);
    } else {
-      await ref.read(trackProvider.notifier).search(url);
+      final settings = ref.read(settingsProvider);
+      await ref.read(trackProvider.notifier).search(url, metadataSource: settings.metadataSource);
    }
  }

@@ -8,11 +8,14 @@ import 'package:spotiflac_android/models/track.dart';
 import 'package:spotiflac_android/providers/track_provider.dart';
 import 'package:spotiflac_android/providers/download_queue_provider.dart';
 import 'package:spotiflac_android/providers/settings_provider.dart';
+import 'package:spotiflac_android/providers/extension_provider.dart';
 import 'package:spotiflac_android/screens/track_metadata_screen.dart';
 import 'package:spotiflac_android/screens/album_screen.dart';
 import 'package:spotiflac_android/screens/artist_screen.dart';
+import 'package:spotiflac_android/services/csv_import_service.dart';
 import 'package:spotiflac_android/screens/playlist_screen.dart';
 import 'package:spotiflac_android/models/download_item.dart';
+import 'package:spotiflac_android/widgets/download_service_picker.dart';

 class HomeTab extends ConsumerStatefulWidget {
  const HomeTab({super.key});
@@ -77,11 +80,21 @@ class _HomeTabState extends ConsumerState<HomeTab> with AutomaticKeepAliveClient
  }

  Future<void> _performSearch(String query) async {
-    // Skip if same query already searched
-    if (_lastSearchQuery == query) return;
-    _lastSearchQuery = query;
+    final settings = ref.read(settingsProvider);
+    final searchProvider = settings.searchProvider;
    
-    await ref.read(trackProvider.notifier).search(query);
+    // Skip if same query already searched with same provider
+    final searchKey = '${searchProvider ?? 'default'}:$query';
+    if (_lastSearchQuery == searchKey) return;
+    _lastSearchQuery = searchKey;
+    
+    if (searchProvider != null && searchProvider.isNotEmpty) {
+      // Use custom search from extension
+      await ref.read(trackProvider.notifier).customSearch(searchProvider, query);
+    } else {
+      // Use default search (Deezer/Spotify)
+      await ref.read(trackProvider.notifier).search(query, metadataSource: settings.metadataSource);
+    }
    ref.read(settingsProvider.notifier).setHasSearchedBefore();
  }

@@ -112,7 +125,8 @@ class _HomeTabState extends ConsumerState<HomeTab> with AutomaticKeepAliveClient
      await ref.read(trackProvider.notifier).fetchFromUrl(url);
      _navigateToDetailIfNeeded();
    } else {
-      await ref.read(trackProvider.notifier).search(url);
+      final settings = ref.read(settingsProvider);
+      await ref.read(trackProvider.notifier).search(url, metadataSource: settings.metadataSource);
    }
    ref.read(settingsProvider.notifier).setHasSearchedBefore();
  }
@@ -170,10 +184,16 @@ class _HomeTabState extends ConsumerState<HomeTab> with AutomaticKeepAliveClient
      final settings = ref.read(settingsProvider);
      
      if (settings.askQualityBeforeDownload) {
-        _showQualityPicker(context, (quality, service) {
-          ref.read(downloadQueueProvider.notifier).addToQueue(track, service, qualityOverride: quality);
-          ScaffoldMessenger.of(context).showSnackBar(SnackBar(content: Text('Added "${track.name}" to queue')));
-        }, trackName: track.name, artistName: track.artistName, coverUrl: track.coverUrl);
+        DownloadServicePicker.show(
+          context,
+          trackName: track.name,
+          artistName: track.artistName,
+          coverUrl: track.coverUrl,
+          onSelect: (quality, service) {
+            ref.read(downloadQueueProvider.notifier).addToQueue(track, service, qualityOverride: quality);
+            ScaffoldMessenger.of(context).showSnackBar(SnackBar(content: Text('Added "${track.name}" to queue')));
+          },
+        );
      } else {
        ref.read(downloadQueueProvider.notifier).addToQueue(track, settings.defaultService);
        ScaffoldMessenger.of(context).showSnackBar(SnackBar(content: Text('Added "${track.name}" to queue')));
@@ -181,87 +201,103 @@ class _HomeTabState extends ConsumerState<HomeTab> with AutomaticKeepAliveClient
    }
  }

-  void _showQualityPicker(BuildContext context, void Function(String quality, String service) onSelect, {String? trackName, String? artistName, String? coverUrl}) {
-    final colorScheme = Theme.of(context).colorScheme;
-    final settings = ref.read(settingsProvider);
-    String selectedService = settings.defaultService;
+  Future<void> _importCsv(BuildContext context, WidgetRef ref) async {
+    // Show loading dialog with progress
+    int currentProgress = 0;
+    int totalTracks = 0;
    
-    showModalBottomSheet(
-      context: context,
-      backgroundColor: colorScheme.surfaceContainerHigh,
-      shape: const RoundedRectangleBorder(borderRadius: BorderRadius.vertical(top: Radius.circular(28))),
-      isScrollControlled: true,
-      builder: (context) => StatefulBuilder(
-        builder: (context, setModalState) => SafeArea(
-          child: SingleChildScrollView(
-            child: Column(
-              mainAxisSize: MainAxisSize.min,
-              crossAxisAlignment: CrossAxisAlignment.start,
-              children: [
-                if (trackName != null) ...[
-                  _TrackInfoHeader(trackName: trackName, artistName: artistName, coverUrl: coverUrl),
-                  Divider(height: 1, color: colorScheme.outlineVariant.withValues(alpha: 0.5)),
-                ] else ...[
-                  const SizedBox(height: 8),
-                  Center(child: Container(width: 40, height: 4, decoration: BoxDecoration(color: colorScheme.onSurfaceVariant.withValues(alpha: 0.4), borderRadius: BorderRadius.circular(2)))),
+    // Use StatefulBuilder to update dialog content
+    bool dialogShown = false;
+    StateSetter? setDialogState;
+    
+    void showProgressDialog() {
+      if (dialogShown || !mounted) return;
+      dialogShown = true;
+      showDialog(
+        context: this.context,
+        barrierDismissible: false,
+        builder: (dialogCtx) => StatefulBuilder(
+          builder: (dialogCtx, setState) {
+            setDialogState = setState;
+            return AlertDialog(
+              content: Column(
+                mainAxisSize: MainAxisSize.min,
+                children: [
+                  const CircularProgressIndicator(),
+                  const SizedBox(height: 16),
+                  Text(
+                    totalTracks > 0 
+                        ? 'Fetching metadata... $currentProgress/$totalTracks'
+                        : 'Reading CSV...',
+                  ),
                ],
-                // Service selector
-                Padding(
-                  padding: const EdgeInsets.fromLTRB(24, 16, 24, 8),
-                  child: Text('Download From', style: Theme.of(context).textTheme.titleMedium?.copyWith(fontWeight: FontWeight.bold)),
-                ),
-                Padding(
-                  padding: const EdgeInsets.symmetric(horizontal: 20),
-                  child: Row(
-                    children: [
-                      _ServiceChip(label: 'Tidal', isSelected: selectedService == 'tidal', onTap: () => setModalState(() => selectedService = 'tidal')),
-                      const SizedBox(width: 8),
-                      _ServiceChip(label: 'Qobuz', isSelected: selectedService == 'qobuz', onTap: () => setModalState(() => selectedService = 'qobuz')),
-                      const SizedBox(width: 8),
-                      _ServiceChip(label: 'Amazon', isSelected: selectedService == 'amazon', onTap: () => setModalState(() => selectedService = 'amazon')),
-                    ],
-                  ),
-                ),
-                Padding(
-                  padding: const EdgeInsets.fromLTRB(24, 16, 24, 8),
-                  child: Text('Select Quality', style: Theme.of(context).textTheme.titleMedium?.copyWith(fontWeight: FontWeight.bold)),
-                ),
-                // Disclaimer
-                Padding(
-                  padding: const EdgeInsets.fromLTRB(24, 0, 24, 12),
-                  child: Text(
-                    'Actual quality depends on track availability. Hi-Res may not be available for all tracks.',
-                    style: Theme.of(context).textTheme.bodySmall?.copyWith(
-                      color: colorScheme.onSurfaceVariant,
-                      fontStyle: FontStyle.italic,
-                    ),
-                  ),
-                ),
-                _QualityPickerOption(
-                  title: 'FLAC Lossless',
-                  subtitle: '16-bit / 44.1kHz',
-                  icon: Icons.music_note,
-                  onTap: () { Navigator.pop(context); onSelect('LOSSLESS', selectedService); },
-                ),
-                _QualityPickerOption(
-                  title: 'Hi-Res FLAC',
-                  subtitle: '24-bit / up to 96kHz',
-                  icon: Icons.high_quality,
-                  onTap: () { Navigator.pop(context); onSelect('HI_RES', selectedService); },
-                ),
-                _QualityPickerOption(
-                  title: 'Hi-Res FLAC Max',
-                  subtitle: '24-bit / up to 192kHz',
-                  icon: Icons.four_k,
-                  onTap: () { Navigator.pop(context); onSelect('HI_RES_LOSSLESS', selectedService); },
-                ),
-                const SizedBox(height: 16),
-              ],
-            ),
-          ),
+              ),
+            );
+          },
        ),
-      ),
+      );
+    }
+    
+    final tracks = await CsvImportService.pickAndParseCsv(
+      onProgress: (current, total) {
+        currentProgress = current;
+        totalTracks = total;
+        if (!dialogShown && total > 0) {
+          showProgressDialog();
+        }
+        setDialogState?.call(() {});
+      },
    );
+    
+    // Close progress dialog
+    if (dialogShown && mounted) {
+      Navigator.of(this.context).pop();
+    }
+    
+    if (tracks.isNotEmpty) {
+      final settings = ref.read(settingsProvider);
+      
+      if (!mounted) return;
+      
+      // Optionally show confirmation dialog
+      final confirmed = await showDialog<bool>(
+        context: this.context,
+        builder: (dialogCtx) => AlertDialog(
+          title: const Text('Import Playlist'),
+          content: Text('Found ${tracks.length} tracks in CSV. Add them to download queue?'),
+          actions: [
+            TextButton(
+              onPressed: () => Navigator.pop(dialogCtx, false),
+              child: const Text('Cancel'),
+            ),
+            FilledButton(
+              onPressed: () => Navigator.pop(dialogCtx, true),
+              child: const Text('Import'),
+            ),
+          ],
+        ),
+      );
+
+      if (confirmed == true) {
+        ref.read(downloadQueueProvider.notifier).addMultipleToQueue(tracks, settings.defaultService);
+        if (mounted) {
+           ScaffoldMessenger.of(this.context).showSnackBar(
+            SnackBar(
+              content: Text('Added ${tracks.length} tracks to queue'),
+              action: SnackBarAction(
+                label: 'View Queue',
+                onPressed: () {
+                   // Navigate to queue tab (handled by main_shell index)
+                   // We don't have direct access to set index here easily without provider
+                },
+              ),
+            ),
+          );
+        }
+      }
+    } else {
+       // Only show error if pick was not cancelled (handled inside service logging usually, but maybe show snackbar if file empty)
+    }
  }

  @override
@@ -284,9 +320,14 @@ class _HomeTabState extends ConsumerState<HomeTab> with AutomaticKeepAliveClient
    final error = ref.watch(trackProvider.select((s) => s.error));
    final hasSearchedBefore = ref.watch(settingsProvider.select((s) => s.hasSearchedBefore));
    
+    // Watch extension state to update search hint when extensions load/change
+    ref.watch(extensionProvider.select((s) => s.isInitialized));
+    ref.watch(extensionProvider.select((s) => s.extensions));
+    
    final colorScheme = Theme.of(context).colorScheme;
    final hasResults = _isTyping || tracks.isNotEmpty || (searchArtists != null && searchArtists.isNotEmpty) || isLoading;
    final screenHeight = MediaQuery.of(context).size.height;
+    final topPadding = MediaQuery.of(context).padding.top;
    final historyItems = ref.watch(downloadHistoryProvider.select((s) => s.items));

    return Scaffold(
@@ -295,24 +336,32 @@ class _HomeTabState extends ConsumerState<HomeTab> with AutomaticKeepAliveClient
        slivers: [
          // App Bar - always present
          SliverAppBar(
-            expandedHeight: 130,
+            expandedHeight: 120 + topPadding,
            collapsedHeight: kToolbarHeight,
            floating: false,
            pinned: true,
            backgroundColor: colorScheme.surface,
            surfaceTintColor: Colors.transparent,
            automaticallyImplyLeading: false,
-            flexibleSpace: FlexibleSpaceBar(
-              expandedTitleScale: 1.3,
-              titlePadding: const EdgeInsets.only(left: 24, bottom: 16),
-              title: Text(
-                'Home',
-                style: TextStyle(
-                  fontSize: 28,
-                  fontWeight: FontWeight.bold,
-                  color: colorScheme.onSurface,
-                ),
-              ),
+            flexibleSpace: LayoutBuilder(
+              builder: (context, constraints) {
+                final maxHeight = 120 + topPadding;
+                final minHeight = kToolbarHeight + topPadding;
+                final expandRatio = ((constraints.maxHeight - minHeight) / (maxHeight - minHeight)).clamp(0.0, 1.0);
+                
+                return FlexibleSpaceBar(
+                  expandedTitleScale: 1.0,
+                  titlePadding: const EdgeInsets.only(left: 24, bottom: 16),
+                  title: Text(
+                    'Home',
+                    style: TextStyle(
+                      fontSize: 20 + (14 * expandRatio), // 20 -> 34
+                      fontWeight: FontWeight.bold,
+                      color: colorScheme.onSurface,
+                    ),
+                  ),
+                );
+              },
            ),
          ),
          
@@ -327,12 +376,27 @@ class _HomeTabState extends ConsumerState<HomeTab> with AutomaticKeepAliveClient
                      children: [
                        SizedBox(height: screenHeight * 0.06),
                        Container(
-                          padding: const EdgeInsets.all(24),
+                          width: 96,
+                          height: 96,
                          decoration: BoxDecoration(
-                            color: colorScheme.primaryContainer.withValues(alpha: 0.3),
+                            color: colorScheme.primary,
                            shape: BoxShape.circle,
                          ),
-                          child: Icon(Icons.music_note, size: 48, color: colorScheme.primary),
+                          child: Image.asset(
+                            'assets/images/logo-transparant.png',
+                            color: colorScheme.onPrimary, // Tint with onPrimary color
+                            fit: BoxFit.contain,
+                            errorBuilder: (_, _, _) => ClipRRect(
+                              // Fallback to original logo if transparent one is missing
+                              borderRadius: BorderRadius.circular(24),
+                              child: Image.asset(
+                                'assets/images/logo.png',
+                                width: 96,
+                                height: 96,
+                                fit: BoxFit.cover,
+                              ),
+                            ),
+                          ),
                        ),
                        const SizedBox(height: 16),
                        Text(
@@ -649,6 +713,11 @@ class _HomeTabState extends ConsumerState<HomeTab> with AutomaticKeepAliveClient
  }

  Widget _buildArtistCard(SearchArtist artist, ColorScheme colorScheme) {
+    // Validate image URL - must be non-null, non-empty, and have a valid host
+    final hasValidImage = artist.imageUrl != null && 
+                          artist.imageUrl!.isNotEmpty &&
+                          Uri.tryParse(artist.imageUrl!)?.hasAuthority == true;
+    
    return GestureDetector(
      onTap: () => _navigateToArtist(artist.id, artist.name, artist.imageUrl),
      child: Container(
@@ -664,12 +733,17 @@ class _HomeTabState extends ConsumerState<HomeTab> with AutomaticKeepAliveClient
                color: colorScheme.surfaceContainerHighest,
              ),
              child: ClipOval(
-                child: artist.imageUrl != null
+                child: hasValidImage
                    ? CachedNetworkImage(
                        imageUrl: artist.imageUrl!,
                        fit: BoxFit.cover,
                        memCacheWidth: 200,
                        memCacheHeight: 200,
+                        errorWidget: (context, url, error) => Icon(
+                          Icons.person,
+                          color: colorScheme.onSurfaceVariant,
+                          size: 44,
+                        ),
                      )
                    : Icon(Icons.person, color: colorScheme.onSurfaceVariant, size: 44),
              ),
@@ -701,6 +775,32 @@ class _HomeTabState extends ConsumerState<HomeTab> with AutomaticKeepAliveClient
    ));
  }

+  /// Get search hint based on selected provider
+  String _getSearchHint() {
+    final settings = ref.read(settingsProvider);
+    final searchProvider = settings.searchProvider;
+    final extState = ref.read(extensionProvider);
+    
+    // If extension system not initialized yet, show default hint
+    if (!extState.isInitialized) {
+      return 'Paste Spotify URL or search...';
+    }
+    
+    if (searchProvider != null && searchProvider.isNotEmpty) {
+      final ext = extState.extensions.where((e) => e.id == searchProvider).firstOrNull;
+      // Only show extension placeholder if extension exists AND is enabled
+      if (ext != null && ext.enabled) {
+        if (ext.searchBehavior?.placeholder != null) {
+          return ext.searchBehavior!.placeholder!;
+        }
+        return 'Search with ${ext.displayName}...';
+      }
+      // Extension not found or disabled - clear the search provider setting
+      // and return default hint
+    }
+    return 'Paste Spotify URL or search...';
+  }
+
  Widget _buildSearchBar(ColorScheme colorScheme) {
    final hasText = _urlController.text.isNotEmpty;
    
@@ -709,7 +809,7 @@ class _HomeTabState extends ConsumerState<HomeTab> with AutomaticKeepAliveClient
      focusNode: _searchFocusNode,
      autofocus: false,
      decoration: InputDecoration(
-        hintText: 'Paste Spotify URL or search...',
+        hintText: _getSearchHint(),
        filled: true,
        fillColor: colorScheme.surfaceContainerHighest,
        border: OutlineInputBorder(
@@ -734,12 +834,18 @@ class _HomeTabState extends ConsumerState<HomeTab> with AutomaticKeepAliveClient
                onPressed: _clearAndRefresh,
                tooltip: 'Clear',
              )
-            else
+            else ...[
+              IconButton(
+                icon: const Icon(Icons.file_upload_outlined),
+                onPressed: () => _importCsv(context, ref),
+                tooltip: 'Import CSV',
+              ),
              IconButton(
                icon: const Icon(Icons.paste),
                onPressed: _pasteFromClipboard,
                tooltip: 'Paste',
              ),
+            ],
          ],
        ),
        contentPadding: const EdgeInsets.symmetric(horizontal: 20, vertical: 16),
@@ -769,147 +875,6 @@ class _HomeTabState extends ConsumerState<HomeTab> with AutomaticKeepAliveClient

 }

-class _QualityPickerOption extends StatelessWidget {
-  final String title;
-  final String subtitle;
-  final IconData icon;
-  final VoidCallback onTap;
-  const _QualityPickerOption({required this.title, required this.subtitle, required this.icon, required this.onTap});
-
-  @override
-  Widget build(BuildContext context) {
-    final colorScheme = Theme.of(context).colorScheme;
-    return ListTile(
-      contentPadding: const EdgeInsets.symmetric(horizontal: 24, vertical: 4),
-      leading: Container(padding: const EdgeInsets.all(10), decoration: BoxDecoration(color: colorScheme.primaryContainer, borderRadius: BorderRadius.circular(12)), child: Icon(icon, color: colorScheme.onPrimaryContainer, size: 20)),
-      title: Text(title, style: const TextStyle(fontWeight: FontWeight.w500)),
-      subtitle: Text(subtitle, style: TextStyle(color: colorScheme.onSurfaceVariant)),
-      onTap: onTap,
-    );
-  }
-}
-
-class _ServiceChip extends StatelessWidget {
-  final String label;
-  final bool isSelected;
-  final VoidCallback onTap;
-  const _ServiceChip({required this.label, required this.isSelected, required this.onTap});
-
-  @override
-  Widget build(BuildContext context) {
-    final colorScheme = Theme.of(context).colorScheme;
-    return Expanded(
-      child: GestureDetector(
-        onTap: onTap,
-        child: AnimatedContainer(
-          duration: const Duration(milliseconds: 200),
-          padding: const EdgeInsets.symmetric(vertical: 10),
-          decoration: BoxDecoration(
-            color: isSelected ? colorScheme.primaryContainer : colorScheme.surfaceContainerHighest,
-            borderRadius: BorderRadius.circular(12),
-            border: isSelected ? null : Border.all(color: colorScheme.outlineVariant.withValues(alpha: 0.5)),
-          ),
-          child: Text(
-            label,
-            textAlign: TextAlign.center,
-            style: TextStyle(
-              fontWeight: isSelected ? FontWeight.w600 : FontWeight.normal,
-              color: isSelected ? colorScheme.onPrimaryContainer : colorScheme.onSurfaceVariant,
-            ),
-          ),
-        ),
-      ),
-    );
-  }
-}
-
-class _TrackInfoHeader extends StatefulWidget {
-  final String trackName;
-  final String? artistName;
-  final String? coverUrl;
-  const _TrackInfoHeader({required this.trackName, this.artistName, this.coverUrl});
-
-  @override
-  State<_TrackInfoHeader> createState() => _TrackInfoHeaderState();
-}
-
-class _TrackInfoHeaderState extends State<_TrackInfoHeader> {
-  bool _expanded = false;
-  bool _isOverflowing = false;
-
-  @override
-  Widget build(BuildContext context) {
-    final colorScheme = Theme.of(context).colorScheme;
-    return Material(
-      color: Colors.transparent,
-      child: InkWell(
-        onTap: _isOverflowing ? () => setState(() => _expanded = !_expanded) : null,
-        borderRadius: const BorderRadius.only(topLeft: Radius.circular(28), topRight: Radius.circular(28)),
-        child: Column(
-          children: [
-            const SizedBox(height: 8),
-            Container(width: 40, height: 4, decoration: BoxDecoration(color: colorScheme.onSurfaceVariant.withValues(alpha: 0.4), borderRadius: BorderRadius.circular(2))),
-            Padding(
-              padding: const EdgeInsets.fromLTRB(16, 12, 16, 12),
-              child: Row(
-                children: [
-                  ClipRRect(
-                    borderRadius: BorderRadius.circular(8),
-                    child: widget.coverUrl != null
-                        ? Image.network(widget.coverUrl!, width: 56, height: 56, fit: BoxFit.cover,
-                            errorBuilder: (_, e, s) => Container(width: 56, height: 56, color: colorScheme.surfaceContainerHighest, child: Icon(Icons.music_note, color: colorScheme.onSurfaceVariant)))
-                        : Container(width: 56, height: 56, color: colorScheme.surfaceContainerHighest, child: Icon(Icons.music_note, color: colorScheme.onSurfaceVariant)),
-                  ),
-                  const SizedBox(width: 12),
-                  Expanded(
-                    child: LayoutBuilder(
-                      builder: (context, constraints) {
-                        final titleStyle = Theme.of(context).textTheme.titleMedium?.copyWith(fontWeight: FontWeight.w600);
-                        final titleSpan = TextSpan(text: widget.trackName, style: titleStyle);
-                        final titlePainter = TextPainter(text: titleSpan, maxLines: 1, textDirection: TextDirection.ltr)..layout(maxWidth: constraints.maxWidth);
-                        final titleOverflows = titlePainter.didExceedMaxLines;
-                        
-                        WidgetsBinding.instance.addPostFrameCallback((_) {
-                          if (mounted && _isOverflowing != titleOverflows) {
-                            setState(() => _isOverflowing = titleOverflows);
-                          }
-                        });
-                        
-                        return Column(
-                          crossAxisAlignment: CrossAxisAlignment.start,
-                          children: [
-                            Text(
-                              widget.trackName,
-                              style: titleStyle,
-                              maxLines: _expanded ? 10 : 1,
-                              overflow: _expanded ? TextOverflow.visible : TextOverflow.ellipsis,
-                            ),
-                            if (widget.artistName != null) ...[
-                              const SizedBox(height: 2),
-                              Text(
-                                widget.artistName!,
-                                style: Theme.of(context).textTheme.bodyMedium?.copyWith(color: colorScheme.onSurfaceVariant),
-                                maxLines: _expanded ? 3 : 1,
-                                overflow: _expanded ? TextOverflow.visible : TextOverflow.ellipsis,
-                              ),
-                            ],
-                          ],
-                        );
-                      },
-                    ),
-                  ),
-                  if (_isOverflowing || _expanded)
-                    Icon(_expanded ? Icons.expand_less : Icons.expand_more, color: colorScheme.onSurfaceVariant, size: 20),
-                ],
-              ),
-            ),
-          ],
-        ),
-      ),
-    );
-  }
-}
-
 /// Separate Consumer widget for each track item - only rebuilds when this specific track's status changes
 class _TrackItemWithStatus extends ConsumerWidget {
  final Track track;
@@ -939,6 +904,28 @@ class _TrackItemWithStatus extends ConsumerWidget {
      return state.isDownloaded(track.id);
    }));
    
+    // Get thumbnail size from extension if track is from extension
+    double thumbWidth = 56;
+    double thumbHeight = 56;
+    
+    // Get extension ID from track.source or from TrackState.searchExtensionId
+    final trackState = ref.watch(trackProvider);
+    final extensionId = track.source ?? trackState.searchExtensionId;
+    
+    if (extensionId != null && extensionId.isNotEmpty) {
+      final extState = ref.watch(extensionProvider);
+      final extension = extState.extensions.where((e) => e.id == extensionId).firstOrNull;
+      if (extension?.searchBehavior != null) {
+        final size = extension!.searchBehavior!.getThumbnailSize(defaultSize: 56);
+        thumbWidth = size.$1;
+        thumbHeight = size.$2;
+        // Debug: log only when using custom size
+        if (thumbWidth != 56 || thumbHeight != 56) {
+          debugPrint('[Thumbnail] ${track.name}: using ${thumbWidth.toInt()}x${thumbHeight.toInt()} from ${extension.id}');
+        }
+      }
+    }
+    
    final isQueued = queueItem != null;
    final isDownloading = queueItem?.status == DownloadStatus.downloading;
    final isFinalizing = queueItem?.status == DownloadStatus.finalizing;
@@ -959,21 +946,21 @@ class _TrackItemWithStatus extends ConsumerWidget {
            padding: const EdgeInsets.symmetric(horizontal: 12, vertical: 10),
            child: Row(
              children: [
-                // Album art
+                // Album art with dynamic size based on extension config
                ClipRRect(
                  borderRadius: BorderRadius.circular(10),
                  child: track.coverUrl != null
                      ? CachedNetworkImage(
                          imageUrl: track.coverUrl!,
-                          width: 56,
-                          height: 56,
+                          width: thumbWidth,
+                          height: thumbHeight,
                          fit: BoxFit.cover,
-                          memCacheWidth: 112,
-                          memCacheHeight: 112,
+                          memCacheWidth: (thumbWidth * 2).toInt(),
+                          memCacheHeight: (thumbHeight * 2).toInt(),
                        )
                      : Container(
-                          width: 56,
-                          height: 56,
+                          width: thumbWidth,
+                          height: thumbHeight,
                          color: colorScheme.surfaceContainerHighest,
                          child: Icon(Icons.music_note, color: colorScheme.onSurfaceVariant),
                        ),
@@ -1010,7 +997,7 @@ class _TrackItemWithStatus extends ConsumerWidget {
          Divider(
            height: 1,
            thickness: 1,
-            indent: 80,
+            indent: thumbWidth + 24, // Adjust divider indent based on thumbnail width
            endIndent: 12,
            color: colorScheme.outlineVariant.withValues(alpha: 0.3),
          ),
@@ -62,6 +62,9 @@ class _MainShellState extends ConsumerState<MainShell> {
  }

  void _handleSharedUrl(String url) {
+    // Pop any existing screens (Album, Artist, Settings sub-pages) to return to root
+    Navigator.of(context).popUntil((route) => route.isFirst);
+    
    // Navigate to Home tab
    if (_currentIndex != 0) {
      _onNavTap(0);
@@ -6,6 +6,7 @@ import 'package:spotiflac_android/models/track.dart';
 import 'package:spotiflac_android/models/download_item.dart';
 import 'package:spotiflac_android/providers/download_queue_provider.dart';
 import 'package:spotiflac_android/providers/settings_provider.dart';
+import 'package:spotiflac_android/widgets/download_service_picker.dart';

 /// Playlist detail screen with Material Expressive 3 design
 class PlaylistScreen extends ConsumerWidget {
@@ -168,10 +169,16 @@ class PlaylistScreen extends ConsumerWidget {
  void _downloadTrack(BuildContext context, WidgetRef ref, Track track) {
    final settings = ref.read(settingsProvider);
    if (settings.askQualityBeforeDownload) {
-      _showQualityPicker(context, ref, (quality, service) {
-        ref.read(downloadQueueProvider.notifier).addToQueue(track, service, qualityOverride: quality);
-        ScaffoldMessenger.of(context).showSnackBar(SnackBar(content: Text('Added "${track.name}" to queue')));
-      }, trackName: track.name, artistName: track.artistName, coverUrl: track.coverUrl);
+      DownloadServicePicker.show(
+        context,
+        trackName: track.name,
+        artistName: track.artistName,
+        coverUrl: track.coverUrl,
+        onSelect: (quality, service) {
+          ref.read(downloadQueueProvider.notifier).addToQueue(track, service, qualityOverride: quality);
+          ScaffoldMessenger.of(context).showSnackBar(SnackBar(content: Text('Added "${track.name}" to queue')));
+        },
+      );
    } else {
      ref.read(downloadQueueProvider.notifier).addToQueue(track, settings.defaultService);
      ScaffoldMessenger.of(context).showSnackBar(SnackBar(content: Text('Added "${track.name}" to queue')));
@@ -182,222 +189,20 @@ class PlaylistScreen extends ConsumerWidget {
    if (tracks.isEmpty) return;
    final settings = ref.read(settingsProvider);
    if (settings.askQualityBeforeDownload) {
-      _showQualityPicker(context, ref, (quality, service) {
-        ref.read(downloadQueueProvider.notifier).addMultipleToQueue(tracks, service, qualityOverride: quality);
-        ScaffoldMessenger.of(context).showSnackBar(SnackBar(content: Text('Added ${tracks.length} tracks to queue')));
-      }, trackName: '${tracks.length} tracks', artistName: playlistName);
+      DownloadServicePicker.show(
+        context,
+        trackName: '${tracks.length} tracks',
+        artistName: playlistName,
+        onSelect: (quality, service) {
+          ref.read(downloadQueueProvider.notifier).addMultipleToQueue(tracks, service, qualityOverride: quality);
+          ScaffoldMessenger.of(context).showSnackBar(SnackBar(content: Text('Added ${tracks.length} tracks to queue')));
+        },
+      );
    } else {
      ref.read(downloadQueueProvider.notifier).addMultipleToQueue(tracks, settings.defaultService);
      ScaffoldMessenger.of(context).showSnackBar(SnackBar(content: Text('Added ${tracks.length} tracks to queue')));
    }
  }
-
-  void _showQualityPicker(BuildContext context, WidgetRef ref, void Function(String quality, String service) onSelect, {String? trackName, String? artistName, String? coverUrl}) {
-    final colorScheme = Theme.of(context).colorScheme;
-    final settings = ref.read(settingsProvider);
-    String selectedService = settings.defaultService;
-    
-    showModalBottomSheet(
-      context: context,
-      backgroundColor: colorScheme.surfaceContainerHigh,
-      shape: const RoundedRectangleBorder(borderRadius: BorderRadius.vertical(top: Radius.circular(28))),
-      isScrollControlled: true,
-      builder: (context) => StatefulBuilder(
-        builder: (context, setModalState) => SafeArea(
-          child: SingleChildScrollView(
-            child: Column(
-              mainAxisSize: MainAxisSize.min,
-              crossAxisAlignment: CrossAxisAlignment.start,
-              children: [
-                if (trackName != null) ...[
-                  _TrackInfoHeader(trackName: trackName, artistName: artistName, coverUrl: coverUrl),
-                  Divider(height: 1, color: colorScheme.outlineVariant.withValues(alpha: 0.5)),
-                ] else ...[
-                  const SizedBox(height: 8),
-                  Center(child: Container(width: 40, height: 4, decoration: BoxDecoration(color: colorScheme.onSurfaceVariant.withValues(alpha: 0.4), borderRadius: BorderRadius.circular(2)))),
-                ],
-                // Service selector
-                Padding(
-                  padding: const EdgeInsets.fromLTRB(24, 16, 24, 8),
-                  child: Text('Download From', style: Theme.of(context).textTheme.titleMedium?.copyWith(fontWeight: FontWeight.bold)),
-                ),
-                Padding(
-                  padding: const EdgeInsets.symmetric(horizontal: 20),
-                  child: Row(
-                    children: [
-                      _ServiceChip(label: 'Tidal', isSelected: selectedService == 'tidal', onTap: () => setModalState(() => selectedService = 'tidal')),
-                      const SizedBox(width: 8),
-                      _ServiceChip(label: 'Qobuz', isSelected: selectedService == 'qobuz', onTap: () => setModalState(() => selectedService = 'qobuz')),
-                      const SizedBox(width: 8),
-                      _ServiceChip(label: 'Amazon', isSelected: selectedService == 'amazon', onTap: () => setModalState(() => selectedService = 'amazon')),
-                    ],
-                  ),
-                ),
-                Padding(padding: const EdgeInsets.fromLTRB(24, 16, 24, 8), child: Text('Select Quality', style: Theme.of(context).textTheme.titleMedium?.copyWith(fontWeight: FontWeight.bold))),
-                // Disclaimer
-                Padding(
-                  padding: const EdgeInsets.fromLTRB(24, 0, 24, 12),
-                  child: Text(
-                    'Actual quality depends on track availability. Hi-Res may not be available for all tracks.',
-                    style: Theme.of(context).textTheme.bodySmall?.copyWith(
-                      color: colorScheme.onSurfaceVariant,
-                      fontStyle: FontStyle.italic,
-                    ),
-                  ),
-                ),
-                _QualityOption(title: 'FLAC Lossless', subtitle: '16-bit / 44.1kHz', icon: Icons.music_note, onTap: () { Navigator.pop(context); onSelect('LOSSLESS', selectedService); }),
-                _QualityOption(title: 'Hi-Res FLAC', subtitle: '24-bit / up to 96kHz', icon: Icons.high_quality, onTap: () { Navigator.pop(context); onSelect('HI_RES', selectedService); }),
-                _QualityOption(title: 'Hi-Res FLAC Max', subtitle: '24-bit / up to 192kHz', icon: Icons.four_k, onTap: () { Navigator.pop(context); onSelect('HI_RES_LOSSLESS', selectedService); }),
-                const SizedBox(height: 16),
-              ],
-            ),
-          ),
-        ),
-      ),
-    );
-  }
-}
-
-class _QualityOption extends StatelessWidget {
-  final String title;
-  final String subtitle;
-  final IconData icon;
-  final VoidCallback onTap;
-
-  const _QualityOption({required this.title, required this.subtitle, required this.icon, required this.onTap});
-
-  @override
-  Widget build(BuildContext context) {
-    final colorScheme = Theme.of(context).colorScheme;
-    return ListTile(
-      contentPadding: const EdgeInsets.symmetric(horizontal: 24, vertical: 4),
-      leading: Container(padding: const EdgeInsets.all(10), decoration: BoxDecoration(color: colorScheme.primaryContainer, borderRadius: BorderRadius.circular(12)), child: Icon(icon, color: colorScheme.onPrimaryContainer, size: 20)),
-      title: Text(title, style: const TextStyle(fontWeight: FontWeight.w500)),
-      subtitle: Text(subtitle, style: TextStyle(color: colorScheme.onSurfaceVariant)),
-      onTap: onTap,
-    );
-  }
-}
-
-class _ServiceChip extends StatelessWidget {
-  final String label;
-  final bool isSelected;
-  final VoidCallback onTap;
-  const _ServiceChip({required this.label, required this.isSelected, required this.onTap});
-
-  @override
-  Widget build(BuildContext context) {
-    final colorScheme = Theme.of(context).colorScheme;
-    return Expanded(
-      child: GestureDetector(
-        onTap: onTap,
-        child: AnimatedContainer(
-          duration: const Duration(milliseconds: 200),
-          padding: const EdgeInsets.symmetric(vertical: 10),
-          decoration: BoxDecoration(
-            color: isSelected ? colorScheme.primaryContainer : colorScheme.surfaceContainerHighest,
-            borderRadius: BorderRadius.circular(12),
-            border: isSelected ? null : Border.all(color: colorScheme.outlineVariant.withValues(alpha: 0.5)),
-          ),
-          child: Text(
-            label,
-            textAlign: TextAlign.center,
-            style: TextStyle(
-              fontWeight: isSelected ? FontWeight.w600 : FontWeight.normal,
-              color: isSelected ? colorScheme.onPrimaryContainer : colorScheme.onSurfaceVariant,
-            ),
-          ),
-        ),
-      ),
-    );
-  }
-}
-
-class _TrackInfoHeader extends StatefulWidget {
-  final String trackName;
-  final String? artistName;
-  final String? coverUrl;
-  const _TrackInfoHeader({required this.trackName, this.artistName, this.coverUrl});
-
-  @override
-  State<_TrackInfoHeader> createState() => _TrackInfoHeaderState();
-}
-
-class _TrackInfoHeaderState extends State<_TrackInfoHeader> {
-  bool _expanded = false;
-  bool _isOverflowing = false;
-
-  @override
-  Widget build(BuildContext context) {
-    final colorScheme = Theme.of(context).colorScheme;
-    return Material(
-      color: Colors.transparent,
-      child: InkWell(
-        onTap: _isOverflowing ? () => setState(() => _expanded = !_expanded) : null,
-        borderRadius: const BorderRadius.only(topLeft: Radius.circular(28), topRight: Radius.circular(28)),
-        child: Column(
-          children: [
-            const SizedBox(height: 8),
-            Container(width: 40, height: 4, decoration: BoxDecoration(color: colorScheme.onSurfaceVariant.withValues(alpha: 0.4), borderRadius: BorderRadius.circular(2))),
-            Padding(
-              padding: const EdgeInsets.fromLTRB(16, 12, 16, 12),
-              child: Row(
-                children: [
-                  ClipRRect(
-                    borderRadius: BorderRadius.circular(8),
-                    child: widget.coverUrl != null
-                        ? Image.network(widget.coverUrl!, width: 56, height: 56, fit: BoxFit.cover,
-                            errorBuilder: (_, e, s) => Container(width: 56, height: 56, color: colorScheme.surfaceContainerHighest, child: Icon(Icons.music_note, color: colorScheme.onSurfaceVariant)))
-                        : Container(width: 56, height: 56, color: colorScheme.surfaceContainerHighest, child: Icon(Icons.music_note, color: colorScheme.onSurfaceVariant)),
-                  ),
-                  const SizedBox(width: 12),
-                  Expanded(
-                    child: LayoutBuilder(
-                      builder: (context, constraints) {
-                        final titleStyle = Theme.of(context).textTheme.titleMedium?.copyWith(fontWeight: FontWeight.w600);
-                        final titleSpan = TextSpan(text: widget.trackName, style: titleStyle);
-                        final titlePainter = TextPainter(text: titleSpan, maxLines: 1, textDirection: TextDirection.ltr)..layout(maxWidth: constraints.maxWidth);
-                        final titleOverflows = titlePainter.didExceedMaxLines;
-                        
-                        WidgetsBinding.instance.addPostFrameCallback((_) {
-                          if (mounted && _isOverflowing != titleOverflows) {
-                            setState(() => _isOverflowing = titleOverflows);
-                          }
-                        });
-                        
-                        return Column(
-                          crossAxisAlignment: CrossAxisAlignment.start,
-                          children: [
-                            Text(
-                              widget.trackName,
-                              style: titleStyle,
-                              maxLines: _expanded ? 10 : 1,
-                              overflow: _expanded ? TextOverflow.visible : TextOverflow.ellipsis,
-                            ),
-                            if (widget.artistName != null) ...[
-                              const SizedBox(height: 2),
-                              Text(
-                                widget.artistName!,
-                                style: Theme.of(context).textTheme.bodyMedium?.copyWith(color: colorScheme.onSurfaceVariant),
-                                maxLines: _expanded ? 3 : 1,
-                                overflow: _expanded ? TextOverflow.visible : TextOverflow.ellipsis,
-                              ),
-                            ],
-                          ],
-                        );
-                      },
-                    ),
-                  ),
-                  if (_isOverflowing || _expanded)
-                    Icon(_expanded ? Icons.expand_less : Icons.expand_more, color: colorScheme.onSurfaceVariant, size: 20),
-                ],
-              ),
-            ),
-          ],
-        ),
-      ),
-    );
-  }
 }

 /// Separate Consumer widget for each track - only rebuilds when this specific track's status changes
@@ -23,7 +23,8 @@ class _SearchScreenState extends ConsumerState<SearchScreen> {
    _searchController = TextEditingController(text: widget.query);
    if (widget.query.isNotEmpty) {
      WidgetsBinding.instance.addPostFrameCallback((_) {
-        ref.read(trackProvider.notifier).search(widget.query);
+        final settings = ref.read(settingsProvider);
+        ref.read(trackProvider.notifier).search(widget.query, metadataSource: settings.metadataSource);
      });
    }
  }
@@ -37,7 +38,8 @@ class _SearchScreenState extends ConsumerState<SearchScreen> {
  void _search() {
    final query = _searchController.text.trim();
    if (query.isNotEmpty) {
-      ref.read(trackProvider.notifier).search(query);
+      final settings = ref.read(settingsProvider);
+      ref.read(trackProvider.notifier).search(query, metadataSource: settings.metadataSource);
    }
  }

@@ -78,6 +78,49 @@ class AboutPage extends StatelessWidget {
                  name: AppInfo.originalAuthor,
                  description: 'Creator of the original SpotiFLAC',
                  githubUsername: AppInfo.originalAuthor,
+                  showDivider: true,
+                ),
+                _ContributorItem(
+                  name: 'Amonoman',
+                  description: 'The talented artist who created our beautiful app logo!',
+                  githubUsername: 'Amonoman',
+                  showDivider: false,
+                ),
+              ],
+            ),
+          ),
+
+          // Special Thanks section
+          const SliverToBoxAdapter(
+            child: SettingsSectionHeader(title: 'Special Thanks'),
+          ),
+          SliverToBoxAdapter(
+            child: SettingsGroup(
+              children: [
+                _ContributorItem(
+                  name: 'uimaxbai',
+                  description: 'The creator of QQDL & HiFi API. Without this API, Tidal downloads wouldn\'t exist!',
+                  githubUsername: 'uimaxbai',
+                  showDivider: true,
+                ),
+                _ContributorItem(
+                  name: 'sachinsenal0x64',
+                  description: 'The original HiFi project creator. The foundation of Tidal integration!',
+                  githubUsername: 'sachinsenal0x64',
+                  showDivider: true,
+                ),
+                _AboutSettingsItem(
+                  icon: Icons.cloud_outlined,
+                  title: 'DoubleDouble',
+                  subtitle: 'Amazing API for Amazon Music downloads. Thank you for making it free!',
+                  onTap: () => _launchUrl('https://doubledouble.top'),
+                  showDivider: true,
+                ),
+                _AboutSettingsItem(
+                  icon: Icons.music_note_outlined,
+                  title: 'DAB Music',
+                  subtitle: 'The best Qobuz streaming API. Hi-Res downloads wouldn\'t be possible without this!',
+                  onTap: () => _launchUrl('https://dabmusic.xyz'),
                  showDivider: false,
                ),
              ],
@@ -206,30 +249,26 @@ class _AppHeaderCard extends StatelessWidget {
      padding: const EdgeInsets.all(24),
      child: Column(
        children: [
+          // App logo
          // App logo
          Container(
            width: 88,
            height: 88,
            decoration: BoxDecoration(
-              color: colorScheme.primaryContainer,
-              borderRadius: BorderRadius.circular(24),
-              boxShadow: [
-                BoxShadow(
-                  color: colorScheme.primary.withValues(alpha: 0.2),
-                  blurRadius: 16,
-                  offset: const Offset(0, 4),
-                ),
-              ],
+              color: colorScheme.primary,
+              shape: BoxShape.circle,
            ),
-            child: ClipRRect(
-              borderRadius: BorderRadius.circular(24),
-              child: Image.asset(
-                'assets/images/logo.png',
-                fit: BoxFit.cover,
-                errorBuilder: (_, _, _) => Icon(
-                  Icons.music_note,
-                  size: 48,
-                  color: colorScheme.onPrimaryContainer,
+            child: Image.asset(
+              'assets/images/logo-transparant.png',
+              color: colorScheme.onPrimary, // Tint with onPrimary color
+              fit: BoxFit.contain,
+              errorBuilder: (_, _, _) => ClipRRect(
+                borderRadius: BorderRadius.circular(24),
+                child: Image.asset(
+                  'assets/images/logo.png',
+                  width: 88,
+                  height: 88,
+                  fit: BoxFit.cover,
                ),
              ),
            ),
@@ -374,3 +413,80 @@ class _ContributorItem extends StatelessWidget {
    await launchUrl(uri, mode: LaunchMode.inAppBrowserView);
  }
 }
+
+/// Settings item with 40x40 icon area to align with contributor avatars
+class _AboutSettingsItem extends StatelessWidget {
+  final IconData icon;
+  final String title;
+  final String? subtitle;
+  final VoidCallback? onTap;
+  final bool showDivider;
+
+  const _AboutSettingsItem({
+    required this.icon,
+    required this.title,
+    this.subtitle,
+    this.onTap,
+    this.showDivider = true,
+  });
+
+  @override
+  Widget build(BuildContext context) {
+    final colorScheme = Theme.of(context).colorScheme;
+    
+    return Column(
+      mainAxisSize: MainAxisSize.min,
+      children: [
+        InkWell(
+          onTap: onTap,
+          splashColor: colorScheme.primary.withValues(alpha: 0.12),
+          highlightColor: colorScheme.primary.withValues(alpha: 0.08),
+          child: Padding(
+            padding: const EdgeInsets.symmetric(horizontal: 20, vertical: 12),
+            child: Row(
+              children: [
+                // Icon with 40x40 size to match avatar
+                SizedBox(
+                  width: 40,
+                  height: 40,
+                  child: Icon(icon, color: colorScheme.onSurfaceVariant, size: 24),
+                ),
+                const SizedBox(width: 16),
+                Expanded(
+                  child: Column(
+                    crossAxisAlignment: CrossAxisAlignment.start,
+                    children: [
+                      Text(
+                        title,
+                        style: Theme.of(context).textTheme.bodyLarge,
+                      ),
+                      if (subtitle != null) ...[
+                        const SizedBox(height: 2),
+                        Text(
+                          subtitle!,
+                          style: Theme.of(context).textTheme.bodyMedium?.copyWith(
+                            color: colorScheme.onSurfaceVariant,
+                          ),
+                        ),
+                      ],
+                    ],
+                  ),
+                ),
+                if (onTap != null)
+                  Icon(Icons.chevron_right, color: colorScheme.onSurfaceVariant),
+              ],
+            ),
+          ),
+        ),
+        if (showDivider)
+          Divider(
+            height: 1,
+            thickness: 1,
+            indent: 76, // 20 + 40 + 16 = 76 (same as contributor item)
+            endIndent: 20,
+            color: colorScheme.outlineVariant.withValues(alpha: 0.3),
+          ),
+      ],
+    );
+  }
+}
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
zarzet	35532b0c73	feat(extension): Enhanced HTTP API for YouTube Music support - Add http.put(), http.delete(), http.patch() shortcut methods - Add persistent cookie jar per extension - Add http.clearCookies() to clear session - Fix User-Agent header respect (no longer overwritten) - Return multi-value headers as arrays (Set-Cookie support) - Auto-stringify objects in POST/PUT/PATCH body - Add response.ok and response.status properties - Update documentation with YouTube Music example	2026-01-12 06:37:18 +07:00
zarzet	4c09b988e4	Merge main into dev (sync v2.2.8 features)	2026-01-12 06:22:22 +07:00
zarzet	c673581c32	feat: multi-select batch delete and album grouping in history - Add multi-select mode with long-press to select tracks - Add bottom action bar for selection (Material 3 style) - Add filter tabs: All/Albums/Singles - Add album grouping view when Albums filter selected - Add DownloadedAlbumScreen for viewing tracks in an album - Reactive UI updates when tracks deleted - Auto-pop when album has <2 tracks - Update issue templates with (Stable Version) text - Bump version to 2.2.8	2026-01-12 06:18:32 +07:00
zarzet	bcd718b178	fix: reset settings when extension is disabled - Reset metadata source to Deezer when search provider extension is disabled - Reset default service to Tidal when download provider extension is disabled - Check extension enabled state in Options page (Primary Provider) - Check extension enabled state in Download Settings (Service selector) - Show extension download providers in service selector when enabled	2026-01-12 02:26:18 +07:00
zarzet	2b9357cb6d	feat: remove default Spotify credentials, require user's own API key - Remove hardcoded Spotify client ID/secret from Go backend - Spotify now requires user to provide their own credentials - Deezer remains free (no credentials required) - Update UI to show 'Free' badge for Deezer, 'API Key' for Spotify - Show warning card when Spotify selected without credentials - Add hasSpotifyCredentials check to platform bridge	2026-01-12 02:10:40 +07:00
zarzet	26d84041c7	fix: initialize extension system at app start for proper search hint - Move extension system initialization to main.dart _EagerInitialization - Show default search hint until extension system is initialized - Watch extension state changes to update search hint dynamically	2026-01-12 01:58:44 +07:00
zarzet	93b4047143	fix: persist extension enabled state and clear search provider when disabled - Save enabled state to settings store when extension is enabled/disabled - Restore enabled state from settings store when extension is loaded - Clear searchProvider setting when the extension is disabled - Update search hint to check if extension is still enabled	2026-01-12 01:56:16 +07:00
zarzet	a6d488696b	chore: add extension API feature request template and ignore docs folder	2026-01-12 01:22:23 +07:00
zarzet	3dbd131e49	fix: iOS extension auth function names (use ByID suffix)	2026-01-12 01:02:16 +07:00
zarzet	57cb575483	feat: add extension system with skipBuiltInFallback support - Add extension manager, manifest, runtime, providers, settings - Add extension provider and UI pages (extensions, detail, priority) - Add download service picker widget - Add metadata provider priority page - Add source field to Track model for extension tracking - Add skipBuiltInFallback manifest option to skip built-in providers - Update download queue to use source extension first - Add extension upgrade support without data loss	2026-01-12 00:17:52 +07:00
zarzet	24ef66be4c	Merge branch 'main' of https://github.com/zarzet/SpotiFLAC-Mobile	2026-01-11 06:41:54 +07:00
zarzet	d07a49f605	UI modernization: Global theme update, redesigned Options/Download settings, and smart filename editor	2026-01-11 06:41:34 +07:00
zarzet	4eba28db7a	v2.2.7: CSV import metadata enrichment with Deezer fallback	2026-01-11 06:09:48 +07:00
zarzet	b73a3f8912	Add CSV import and optimize Appearance settings	2026-01-11 05:56:30 +07:00
zarzet	9f47f2ce85	UI Modernization: Unified app bars, updated logos, improved settings & Deezer support	2026-01-11 04:28:41 +07:00
zarzet	f2aca734a3	fix: improve logging for release builds and UI improvements - Fix Flutter logs not appearing in release mode by bypassing Logger package - Add detailed logging for Deezer search API calls - Replace music_note icon with app logo on home screen - Remove shadow/border from logo in About and Home screens - Align icon size (40x40) with avatar in About page for consistent layout	2026-01-11 02:27:26 +07:00
Zarz Eleutherius	09cb637a86	Update VirusTotal link in README.md	2026-01-10 19:27:48 +07:00
zarzet	11e7034cec	v2.2.5: In-app logging, ISP blocking detection, Latin script fix	2026-01-10 19:03:39 +07:00
zarzet	f12c18d76b	Add issue templates, update workflow SDK, fix about logo	2026-01-10 16:53:41 +07:00
zarzet	0da39a1b8b	chore: update NDK to r27d LTS (27.3.13750724) for 16KB page size support	2026-01-10 16:48:52 +07:00
Zarz Eleutherius	f29fe5054c	Updated VirusTotal badge link in README Updated VirusTotal badge link to the latest report.	2026-01-10 16:09:39 +07:00
zarzet	c8c0164964	chore: update targetSdk to 36 (Android 16) with timeout handler	2026-01-10 04:51:15 +07:00
zarzet	52dd657913	fix: improve search result parsing robustness for edge cases	2026-01-10 04:48:32 +07:00
zarzet	c30f9fe412	fix(ios): add setSpotifyCredentials method to AppDelegate	2026-01-10 04:36:28 +07:00
zarzet	bea5dd1d4a	v2.2.0: Default to Tidal, faster ISRC matching, ISRC enrichment for search	2026-01-10 04:33:05 +07:00
Zarz Eleutherius	8726a0858a	Update VirusTotal link in README.md	2026-01-09 19:03:36 +07:00
zarzet	74bc747599	chore: update to v2.1.7 with new icons	2026-01-09 17:54:50 +07:00
zarzet	cbc8fdcb0c	feat: add download badges to release page	2026-01-09 17:25:01 +07:00
zarzet	3b79b4f1ca	fix: use absolute path for IPA creation	2026-01-09 02:41:19 +07:00
zarzet	5692a76650	Fix: iOS embedMetadata method + Android APK path detection	2026-01-09 02:31:01 +07:00
zarzet	7a009ad0af	Fix R8: add dontwarn for Play Core and javax.xml.stream	2026-01-09 02:19:37 +07:00
zarzet	e5e75e7092	Fix iOS build: use xcodebuild with CODE_SIGNING_ALLOWED=NO	2026-01-09 02:18:54 +07:00
zarzet	01b8fd2480	Fix metadata consistency (Go->Flutter) and build optimization - Backend: Return full metadata (Track, Disc, Year) from Tidal/Qobuz/Amazon download results - Flutter: Use backend metadata for tagging converted M4A and history entries - Fix: Duplicate convertTrack method in deezer.go - Fix: Better error message for Deezer fallback failure - Changed: Default service fallback to Tidal -> Qobuz -> Amazon - Build: Re-enabled resource shrinking and minification for release build	2026-01-09 02:12:24 +07:00
Zarz Eleutherius	ee807a44cc	Update instructions for using Spotify API	2026-01-08 13:36:10 +07:00
Zarz Eleutherius	c9b905eb18	Update VirusTotal badge link in README.md	2026-01-08 01:08:32 +07:00
zarzet	e9c7bf830e	Update changelog for v2.1.5	2026-01-08 00:53:38 +07:00
zarzet	8bc97d5bd3	v2.1.5: Deezer API 2.0, Qobuz default, fetch ISRC for search results	2026-01-08 00:52:24 +07:00
zarzet	f2c241c323	Fix .tmp permission issue on Android Music folder	2026-01-08 00:26:49 +07:00
zarzet	9c512ffe28	Add migration for Deezer default (skip if custom Spotify enabled)	2026-01-07 23:19:04 +07:00
zarzet	53a1da6249	v2.1.5: Fix progress bar and incomplete downloads - Fix progress bar jumping from 1% to 100% (threshold-based updates) - Fix incomplete downloads with temp file + size validation - Applies to Tidal, Qobuz, and Amazon services	2026-01-07 23:15:48 +07:00
Zarz Eleutherius	d4274e8ca8	Include setup instructions for Spotify API usage Added detailed instructions for setting up Spotify as a search source, including steps for creating a developer account and entering credentials.	2026-01-07 13:55:31 +07:00
Zarz Eleutherius	49a9f12841	Simplify README by removing Spotify setup details Removed detailed instructions for using Spotify and support section.	2026-01-07 13:53:30 +07:00
zarzet	d7fa040e3c	fix: Deezer artist/album screen improvements - Fix album_screen to support Deezer album IDs (deezer:xxx format) - Use getSpotifyMetadataWithFallback for Spotify albums - Hide track count in artist discography when not available from Deezer API - Deezer /artist/{id}/albums endpoint doesn't return nb_tracks	2026-01-07 04:25:35 +07:00
zarzet	9baa1e2088	fix: Replace android-actions/setup-android with direct SDK setup	2026-01-07 03:38:00 +07:00
zarzet	482457205a	feat: Add Deezer as alternative metadata source with auto-fallback - Add Deezer API client (no auth required, rate limit per user IP) - Add search source selector in Settings (Deezer/Spotify) - Default to Deezer for better reliability - Auto-fallback to Deezer when Spotify API is rate limited (429) - Support fallback for tracks and albums via SongLink API - Update README with metadata source documentation - Version 2.1.5-preview (build 42)	2026-01-07 03:25:14 +07:00
zarzet	3b2ec319e2	Fix pubspec version to 2.1.0+41	2026-01-07 00:19:53 +07:00
zarzet	a0f7e75a9a	Update VirusTotal badge to 2.1.0	2026-01-07 00:15:43 +07:00