chore: bump version to 3.0.0-alpha.3

- Add fetch() API with json(), text(), arrayBuffer() methods
- Add atob()/btoa() global Base64 functions
- Add TextEncoder/TextDecoder classes for UTF-8 encoding
- Add URL/URLSearchParams classes for URL parsing
- Update documentation with polyfill usage examples
- All polyfills work within sandbox security model

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -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...

.github/ISSUE_TEMPLATE/config.yml

@@ -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

.github/ISSUE_TEMPLATE/download_issue.yml

@@ -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...

.github/ISSUE_TEMPLATE/extension_feature_request.yml

@@ -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: ..."

.github/ISSUE_TEMPLATE/feature_request.yml

@@ -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...

.github/workflows/release.yml

@@ -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
@@ -89,15 +89,16 @@ jobs:
           # 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 (required for gomobile)
-          $ANDROID_HOME/cmdline-tools/latest/bin/sdkmanager "ndk;25.2.9519653" "platforms;android-34" "build-tools;34.0.0"
-          
+
+          # 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/25.2.9519653" >> $GITHUB_ENV
+          echo "ANDROID_NDK_HOME=$ANDROID_HOME/ndk/27.3.13750724" >> $GITHUB_ENV
 
       - name: Install gomobile
         run: |
@@ -115,7 +116,7 @@ jobs:
       - name: Setup Flutter
         uses: subosito/flutter-action@v2
         with:
-          channel: 'stable'
+          channel: "stable"
           cache: true
 
       - name: Get Flutter dependencies
@@ -125,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
@@ -137,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: |
@@ -157,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
@@ -166,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
@@ -194,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)
@@ -265,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:
@@ -288,7 +322,7 @@ jobs:
     needs: [get-version, build-android, build-ios]
     permissions:
       contents: write
-    
+
     steps:
       - name: Checkout repository
         uses: actions/checkout@v4
@@ -298,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"
@@ -312,7 +346,7 @@ jobs:
           else
             echo "Found changelog content"
           fi
-          
+
           # Save to file for multiline support
           echo "$CHANGELOG" > /tmp/changelog.txt
           echo "Extracted changelog:"
@@ -334,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
 

.gitignore

@@ -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/
 

README.md

@@ -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/9092dd9300289ceadd8e70cd71706a3ba32225d9cb2ae8b12648611d31814708)
+[![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">
 
@@ -32,30 +32,46 @@ SpotiFLAC supports two metadata sources for searching tracks:
 | **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 Deezer (Recommended)
-Works out of the box. No setup required.
-
 ### 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 > Custom Credentials**
+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
 
-> **Note**: Spotify URLs (track, album) are always supported regardless of your search source setting. The app will automatically fall back to Deezer if Spotify API is rate limited.
+## Extensions (Alpha)
 
-## Support
+> **Alpha Feature**: Extensions are now available in alpha. Some features may be unstable or change in future releases.
 
-If you find this app useful, consider supporting the development:
+SpotiFLAC supports extensions to add custom metadata and download providers. Extensions are written in JavaScript and run in a secure sandbox.
 
-[![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)
+### 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!

android/app/build.gradle.kts

@@ -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")
 }

android/app/proguard-rules.pro

@@ -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>;

android/app/src/main/kotlin/com/zarz/spotiflac/DownloadService.kt

@@ -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(

android/app/src/main/kotlin/com/zarz/spotiflac/MainActivity.kt

@@ -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) {
@@ -277,6 +290,282 @@ class MainActivity: FlutterActivity() {
                             }
                             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) {

build_assets/ffmpeg_service_ios.dart

@@ -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 {

go_backend/amazon.go

@@ -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
 }

go_backend/deezer.go

@@ -13,13 +13,17 @@ import (
 )
 
 const (
-	deezerSearchURL  = "https://api.deezer.com/search"
-	deezerTrackURL   = "https://api.deezer.com/track/%s"
-	deezerAlbumURL   = "https://api.deezer.com/album/%s"
-	deezerArtistURL  = "https://api.deezer.com/artist/%s"
-	deezerPlaylistURL = "https://api.deezer.com/playlist/%s"
-	
+	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)
@@ -28,6 +32,7 @@ type DeezerClient struct {
 	searchCache map[string]*cacheEntry
 	albumCache  map[string]*cacheEntry
 	artistCache map[string]*cacheEntry
+	isrcCache   map[string]string // trackID -> ISRC cache
 	cacheMu     sync.RWMutex
 }
 
@@ -45,6 +50,7 @@ func GetDeezerClient() *DeezerClient {
 			searchCache: make(map[string]*cacheEntry),
 			albumCache:  make(map[string]*cacheEntry),
 			artistCache: make(map[string]*cacheEntry),
+			isrcCache:   make(map[string]string),
 		}
 	})
 	return deezerClient
@@ -52,26 +58,27 @@ func GetDeezerClient() *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"`
-	Artist         deezerArtist `json:"artist"`
-	Album          deezerAlbumSimple `json:"album"`
-	Contributors   []deezerArtist `json:"contributors"`
+	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"`
+	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"`
+	NbFan         int    `json:"nb_fan"`
 }
 
 type deezerAlbumSimple struct {
@@ -81,20 +88,68 @@ type deezerAlbumSimple struct {
 	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"`
+	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"`
+	RecordType   string         `json:"record_type"` // album, single, ep, compile
+	Artist       deezerArtist   `json:"artist"`
 	Contributors []deezerArtist `json:"contributors"`
-	Tracks      struct {
+	Tracks       struct {
 		Data []deezerTrack `json:"data"`
 	} `json:"tracks"`
 }
@@ -111,28 +166,32 @@ type deezerArtistFull struct {
 }
 
 type deezerPlaylistFull struct {
-	ID          int64  `json:"id"`
-	Title       string `json:"title"`
-	Picture     string `json:"picture"`
+	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 {
+	NbTracks      int    `json:"nb_tracks"`
+	Creator       struct {
 		Name string `json:"name"`
 	} `json:"creator"`
-	Tracks      struct {
+	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()
@@ -142,36 +201,68 @@ func (c *DeezerClient) SearchAll(ctx context.Context, query string, trackLimit,
 		Artists: make([]SearchArtistResult, 0),
 	}
 
-	// Search tracks
+	// 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"`
+		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"`
+		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 {
-		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,
-			})
+		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{
@@ -186,7 +277,7 @@ func (c *DeezerClient) SearchAll(ctx context.Context, query string, trackLimit,
 // 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
@@ -198,6 +289,7 @@ func (c *DeezerClient) GetTrack(ctx context.Context, trackID string) (*TrackResp
 }
 
 // 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() {
@@ -207,7 +299,7 @@ func (c *DeezerClient) GetAlbum(ctx context.Context, albumID string) (*AlbumResp
 	c.cacheMu.RUnlock()
 
 	albumURL := fmt.Sprintf(deezerAlbumURL, albumID)
-	
+
 	var album deezerAlbumFull
 	if err := c.getJSON(ctx, albumURL, &album); err != nil {
 		return nil, err
@@ -231,14 +323,19 @@ func (c *DeezerClient) GetAlbum(ctx context.Context, albumID string) (*AlbumResp
 		Images:      albumImage,
 	}
 
+	// Fetch ISRCs in parallel
+	isrcMap := c.fetchISRCsParallel(ctx, album.Tracks.Data)
+
 	tracks := make([]AlbumTrackMetadata, 0, len(album.Tracks.Data))
+	// Normalize record_type (Deezer uses "compile" instead of "compilation")
+	albumType := album.RecordType
+	if albumType == "compile" {
+		albumType = "compilation"
+	}
+
 	for _, track := range album.Tracks.Data {
-		// Need to fetch full track info for ISRC
-		fullTrack, _ := c.fetchFullTrack(ctx, fmt.Sprintf("%d", track.ID))
-		isrc := ""
-		if fullTrack != nil {
-			isrc = fullTrack.ISRC
-		}
+		trackIDStr := fmt.Sprintf("%d", track.ID)
+		isrc := isrcMap[trackIDStr]
 
 		tracks = append(tracks, AlbumTrackMetadata{
 			SpotifyID:   fmt.Sprintf("deezer:%d", track.ID),
@@ -255,6 +352,7 @@ func (c *DeezerClient) GetAlbum(ctx context.Context, albumID string) (*AlbumResp
 			ExternalURL: track.Link,
 			ISRC:        isrc,
 			AlbumID:     fmt.Sprintf("deezer:%d", album.ID),
+			AlbumType:   albumType,
 		})
 	}
 
@@ -320,7 +418,7 @@ func (c *DeezerClient) GetArtist(ctx context.Context, artistID string) (*ArtistR
 			if albumType == "compile" {
 				albumType = "compilation"
 			}
-			
+
 			coverURL := album.CoverXL
 			if coverURL == "" {
 				coverURL = album.CoverBig
@@ -360,9 +458,10 @@ func (c *DeezerClient) GetArtist(ctx context.Context, artistID string) (*ArtistR
 }
 
 // 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
@@ -382,6 +481,9 @@ func (c *DeezerClient) GetPlaylist(ctx context.Context, playlistID string) (*Pla
 	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
@@ -392,13 +494,8 @@ func (c *DeezerClient) GetPlaylist(ctx context.Context, playlistID string) (*Pla
 			albumImage = track.Album.CoverMedium
 		}
 
-		// Fetch full track for ISRC
-		fullTrack, _ := c.fetchFullTrack(ctx, fmt.Sprintf("%d", track.ID))
-		isrc := ""
-		releaseDate := ""
-		if fullTrack != nil {
-			isrc = fullTrack.ISRC
-		}
+		trackIDStr := fmt.Sprintf("%d", track.ID)
+		isrc := isrcMap[trackIDStr]
 
 		tracks = append(tracks, AlbumTrackMetadata{
 			SpotifyID:   fmt.Sprintf("deezer:%d", track.ID),
@@ -408,7 +505,7 @@ func (c *DeezerClient) GetPlaylist(ctx context.Context, playlistID string) (*Pla
 			AlbumArtist: track.Artist.Name,
 			DurationMS:  track.Duration * 1000,
 			Images:      albumImage,
-			ReleaseDate: releaseDate,
+			ReleaseDate: "",
 			TrackNumber: track.TrackPosition,
 			DiscNumber:  track.DiskNumber,
 			ExternalURL: track.Link,
@@ -423,23 +520,36 @@ func (c *DeezerClient) GetPlaylist(ctx context.Context, playlistID string) (*Pla
 	}, nil
 }
 
-// SearchByISRC searches for a track by ISRC
+// SearchByISRC searches for a track by ISRC using direct endpoint
 func (c *DeezerClient) SearchByISRC(ctx context.Context, isrc string) (*TrackMetadata, error) {
-	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
+	// 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
 	}
 
-	if len(resp.Data) == 0 {
+	// Check if we got a valid response (ID > 0)
+	if track.ID == 0 {
 		return nil, fmt.Errorf("no track found for ISRC: %s", isrc)
 	}
 
-	track := c.convertTrack(resp.Data[0])
-	return &track, nil
+	result := c.convertTrack(track)
+	return &result, nil
 }
 
 func (c *DeezerClient) fetchFullTrack(ctx context.Context, trackID string) (*deezerTrack, error) {
@@ -451,40 +561,89 @@ func (c *DeezerClient) fetchFullTrack(ctx context.Context, trackID string) (*dee
 	return &track, nil
 }
 
-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
+// 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)
 		}
-		artistName = strings.Join(names, ", ")
+	}
+	c.cacheMu.RUnlock()
+
+	if len(tracksToFetch) == 0 {
+		return result
 	}
 
-	albumImage := track.Album.CoverXL
-	if albumImage == "" {
-		albumImage = track.Album.CoverBig
-	}
-	if albumImage == "" {
-		albumImage = track.Album.CoverMedium
-	}
-	if albumImage == "" {
-		albumImage = track.Album.Cover
+	// 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)
 	}
 
-	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,
-		TrackNumber: track.TrackPosition,
-		DiscNumber:  track.DiskNumber,
-		ExternalURL: track.Link,
-		ISRC:        track.ISRC,
+	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 {
@@ -569,7 +728,7 @@ func parseDeezerURL(input string) (string, string, error) {
 	}
 
 	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:]

go_backend/duplicate.go

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

go_backend/extension_manager.go

@@ -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")
+}

go_backend/extension_manifest.go

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

go_backend/extension_settings.go

@@ -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
+}

go_backend/extension_test.go

@@ -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")
+	}
+}

go_backend/go.mod

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

go_backend/go.sum

@@ -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=

go_backend/httputil.go

@@ -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
+}

go_backend/logbuffer.go

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

go_backend/lyrics.go

@@ -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")
 		}

go_backend/metadata.go

@@ -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")
 }

go_backend/parallel.go

@@ -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
 }

go_backend/progress.go

@@ -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
 }

go_backend/qobuz.go

@@ -12,6 +12,7 @@ import (
 	"path/filepath"
 	"strings"
 	"sync"
+	"time"
 )
 
 // QobuzDownloader handles Qobuz downloads
@@ -52,59 +53,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 +309,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 +371,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 +400,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 +410,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 +421,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 +463,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 +481,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 +537,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 +558,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 +567,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 +604,155 @@ 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)
+}
+
+// qobuzAPIResult holds the result from a parallel API request
+type qobuzAPIResult struct {
+	apiURL      string
+	downloadURL string
+	err         error
+	duration    time.Duration
+}
+
+// getQobuzDownloadURLParallel requests download URL from all APIs in parallel
+// "Siapa cepat dia dapat" - first successful response wins
+func getQobuzDownloadURLParallel(apis []string, trackID int64, quality string) (string, string, error) {
+	if len(apis) == 0 {
+		return "", "", fmt.Errorf("no APIs available")
+	}
+
+	GoLog("[Qobuz] Requesting download URL from %d APIs in parallel...\n", len(apis))
+
+	resultChan := make(chan qobuzAPIResult, len(apis))
+	startTime := time.Now()
+
+	// Start all requests in parallel
+	for _, apiURL := range apis {
+		go func(api string) {
+			reqStart := time.Now()
+
+			client := &http.Client{
+				Timeout: 15 * time.Second,
+			}
+
+			reqURL := fmt.Sprintf("%s%d&quality=%s", api, trackID, quality)
+
+			req, err := http.NewRequest("GET", reqURL, nil)
+			if err != nil {
+				resultChan <- qobuzAPIResult{apiURL: api, err: err, duration: time.Since(reqStart)}
+				return
+			}
+
+			resp, err := client.Do(req)
+			if err != nil {
+				resultChan <- qobuzAPIResult{apiURL: api, err: err, duration: time.Since(reqStart)}
+				return
+			}
+			defer resp.Body.Close()
+
+			if resp.StatusCode != 200 {
+				resultChan <- qobuzAPIResult{apiURL: api, err: fmt.Errorf("HTTP %d", resp.StatusCode), duration: time.Since(reqStart)}
+				return
+			}
+
+			body, err := io.ReadAll(resp.Body)
+			if err != nil {
+				resultChan <- qobuzAPIResult{apiURL: api, err: err, duration: time.Since(reqStart)}
+				return
+			}
+
+			// Check if response is HTML (error page)
+			if len(body) > 0 && body[0] == '<' {
+				resultChan <- qobuzAPIResult{apiURL: api, err: fmt.Errorf("received HTML instead of JSON"), duration: time.Since(reqStart)}
+				return
+			}
+
+			// Check for error in JSON response
+			var errorResp struct {
+				Error string `json:"error"`
+			}
+			if json.Unmarshal(body, &errorResp) == nil && errorResp.Error != "" {
+				resultChan <- qobuzAPIResult{apiURL: api, err: fmt.Errorf(errorResp.Error), duration: time.Since(reqStart)}
+				return
+			}
+
+			var result struct {
+				URL string `json:"url"`
+			}
+			if err := json.Unmarshal(body, &result); err != nil {
+				resultChan <- qobuzAPIResult{apiURL: api, err: fmt.Errorf("invalid JSON: %v", err), duration: time.Since(reqStart)}
+				return
+			}
+
+			if result.URL != "" {
+				resultChan <- qobuzAPIResult{apiURL: api, downloadURL: result.URL, err: nil, duration: time.Since(reqStart)}
+				return
+			}
+
+			resultChan <- qobuzAPIResult{apiURL: api, err: fmt.Errorf("no download URL in response"), duration: time.Since(reqStart)}
+		}(apiURL)
+	}
+
+	// Collect results - return first success
+	var errors []string
+	var firstSuccess *qobuzAPIResult
+
+	for i := 0; i < len(apis); i++ {
+		result := <-resultChan
+		if result.err == nil && firstSuccess == nil {
+			firstSuccess = &result
+			GoLog("[Qobuz] [Parallel] ✓ Got response from %s in %v\n", result.apiURL, result.duration)
+
+			// Drain remaining results to avoid goroutine leaks
+			go func(remaining int) {
+				for j := 0; j < remaining; j++ {
+					<-resultChan
+				}
+			}(len(apis) - i - 1)
+
+			GoLog("[Qobuz] [Parallel] Total time: %v (first success)\n", time.Since(startTime))
+			return firstSuccess.apiURL, firstSuccess.downloadURL, nil
+		} else if result.err != nil {
+			errMsg := result.err.Error()
+			if len(errMsg) > 50 {
+				errMsg = errMsg[:50] + "..."
+			}
+			errors = append(errors, fmt.Sprintf("%s: %s", result.apiURL, errMsg))
+		}
+	}
+
+	GoLog("[Qobuz] [Parallel] All %d APIs failed in %v\n", len(apis), time.Since(startTime))
+	return "", "", fmt.Errorf("all %d Qobuz APIs failed. Errors: %v", len(apis), errors)
 }
 
 // getQobuzDownloadURLSequential requests download URL from APIs sequentially
@@ -380,7 +771,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 +816,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
 		}
 
@@ -435,14 +826,16 @@ func getQobuzDownloadURLSequential(apis []string, trackID int64, quality string)
 	return "", "", fmt.Errorf("all %d Qobuz APIs failed. Errors: %v", len(apis), errors)
 }
 
-// GetDownloadURL gets download URL for a track - tries APIs sequentially
+// GetDownloadURL gets download URL for a track - tries ALL APIs in parallel
+// "Siapa cepat dia dapat" - first successful response wins
 func (q *QobuzDownloader) GetDownloadURL(trackID int64, quality string) (string, error) {
 	apis := q.GetAvailableAPIs()
 	if len(apis) == 0 {
 		return "", fmt.Errorf("no Qobuz API available")
 	}
 
-	_, downloadURL, err := getQobuzDownloadURLSequential(apis, trackID, quality)
+	// Use parallel approach - request from all APIs simultaneously
+	_, downloadURL, err := getQobuzDownloadURLParallel(apis, trackID, quality)
 	if err != nil {
 		return "", err
 	}
@@ -473,37 +866,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 +949,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 +961,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 +997,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 +1031,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 +1075,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 +1107,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 +1117,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
 }

go_backend/romaji.go

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

go_backend/songlink.go

@@ -48,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()
 
@@ -71,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)
@@ -114,7 +129,7 @@ func (s *SongLinkClient) CheckTrackAvailability(spotifyTrackID string, isrc stri
 		availability.DeezerID = extractDeezerIDFromURL(deezerLink.URL)
 	}
 
-	// Check Qobuz using ISRC
+	// Check Qobuz using ISRC (SongLink doesn't support Qobuz directly)
 	if isrc != "" {
 		availability.Qobuz = checkQobuzAvailability(isrc)
 	}
@@ -282,3 +297,248 @@ func (s *SongLinkClient) GetDeezerAlbumIDFromSpotify(spotifyAlbumID string) (str
 	
 	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
+}

go_backend/spotify.go

@@ -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
@@ -140,6 +158,7 @@ type TrackMetadata struct {
 	DiscNumber  int    `json:"disc_number,omitempty"`
 	ExternalURL string `json:"external_urls"`
 	ISRC        string `json:"isrc"`
+	AlbumType   string `json:"album_type,omitempty"` // album, single, ep, compilation
 }
 
 // AlbumTrackMetadata holds per-track info for album/playlist
@@ -159,6 +178,7 @@ type AlbumTrackMetadata struct {
 	ISRC        string `json:"isrc"`
 	AlbumID     string `json:"album_id,omitempty"`
 	AlbumURL    string `json:"album_url,omitempty"`
+	AlbumType   string `json:"album_type,omitempty"` // album, single, ep, compilation
 }
 
 // AlbumInfoMetadata holds album information
@@ -283,6 +303,7 @@ type albumSimplified struct {
 	Images      []image     `json:"images"`
 	ExternalURL externalURL `json:"external_urls"`
 	Artists     []artist    `json:"artists"`
+	AlbumType   string      `json:"album_type"` // album, single, compilation
 }
 
 type trackFull struct {
@@ -331,14 +352,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
 	}
@@ -363,6 +384,7 @@ func (c *SpotifyMetadataClient) SearchTracks(ctx context.Context, query string,
 			DiscNumber:  track.DiscNumber,
 			ExternalURL: track.ExternalURL.Spotify,
 			ISRC:        track.ExternalID.ISRC,
+			AlbumType:   track.Album.AlbumType,
 		})
 	}
 
@@ -373,7 +395,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 +410,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
 	}
@@ -430,6 +452,7 @@ func (c *SpotifyMetadataClient) SearchAll(ctx context.Context, query string, tra
 			DiscNumber:  track.DiscNumber,
 			ExternalURL: track.ExternalURL.Spotify,
 			ISRC:        track.ExternalID.ISRC,
+			AlbumType:   track.Album.AlbumType,
 		})
 	}
 
@@ -438,7 +461,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 +518,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 +536,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 +554,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 +621,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 +691,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 +716,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 +737,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 +778,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 +927,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 +963,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,
 	)
 }
 

ios/Runner.xcodeproj/project.pbxproj

@@ -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++";

ios/Runner/AppDelegate.swift

@@ -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",

ios/Runner/Assets.xcassets/AppIcon.appiconset/Contents.json

@@ -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"}}

lib/constants/app_info.dart

@@ -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.5-preview';
-  static const String buildNumber = '42';
+  static const String version = '3.0.0-alpha.3';
+  static const String buildNumber = '52';
   static const String fullVersion = '$version+$buildNumber';
   
   

lib/main.dart

@@ -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;
   }
 }

lib/models/download_item.dart

@@ -13,6 +13,15 @@ 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
+  permission,  // File/folder permission error
+}
+
 @JsonSerializable()
 class DownloadItem {
   final String id;
@@ -20,8 +29,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 +42,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 +56,10 @@ class DownloadItem {
     String? service,
     DownloadStatus? status,
     double? progress,
+    double? speedMBps,
     String? filePath,
     String? error,
+    DownloadErrorType? errorType,
     DateTime? createdAt,
     String? qualityOverride,
   }) {
@@ -54,13 +69,33 @@ 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';
+      case DownloadErrorType.permission:
+        return 'Cannot write to folder, check storage permission';
+      default:
+        return error ?? 'An error occurred';
+    }
+  }
+
   factory DownloadItem.fromJson(Map<String, dynamic> json) =>
       _$DownloadItemFromJson(json);
   Map<String, dynamic> toJson() => _$DownloadItemToJson(this);

lib/models/download_item.g.dart

@@ -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,11 @@ const _$DownloadStatusEnumMap = {
   DownloadStatus.failed: 'failed',
   DownloadStatus.skipped: 'skipped',
 };
+
+const _$DownloadErrorTypeEnumMap = {
+  DownloadErrorType.unknown: 'unknown',
+  DownloadErrorType.notFound: 'notFound',
+  DownloadErrorType.rateLimit: 'rateLimit',
+  DownloadErrorType.network: 'network',
+  DownloadErrorType.permission: 'permission',
+};

lib/models/settings.dart

@@ -18,11 +18,16 @@ 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
+  final bool separateSingles; // Separate singles/EPs into their own folder
 
   const AppSettings({
     this.defaultService = 'tidal',
@@ -39,11 +44,16 @@ 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)
+    this.separateSingles = false, // Default: disabled
   });
 
   AppSettings copyWith({
@@ -61,11 +71,16 @@ 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,
+    bool? separateSingles,
   }) {
     return AppSettings(
       defaultService: defaultService ?? this.defaultService,
@@ -82,11 +97,16 @@ 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,
+      separateSingles: separateSingles ?? this.separateSingles,
     );
   }
 

lib/models/settings.g.dart

@@ -21,12 +21,17 @@ 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?,
+  separateSingles: json['separateSingles'] as bool? ?? false,
 );
 
 Map<String, dynamic> _$AppSettingsToJson(AppSettings instance) =>
@@ -45,9 +50,14 @@ 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,
+      'separateSingles': instance.separateSingles,
     };

lib/models/track.dart

@@ -16,7 +16,10 @@ 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)
+  final String? albumType; // album, single, ep, compilation (from metadata API)
 
   const Track({
     required this.id,
@@ -30,11 +33,20 @@ class Track {
     this.trackNumber,
     this.discNumber,
     this.releaseDate,
+    this.deezerId,
     this.availability,
+    this.source,
+    this.albumType,
   });
 
+  /// Check if this track is a single (based on album_type metadata)
+  bool get isSingle => albumType == 'single' || albumType == 'ep';
+
   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 +54,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) =>

lib/models/track.g.dart

@@ -18,11 +18,14 @@ 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?,
+  albumType: json['albumType'] as String?,
 );
 
 Map<String, dynamic> _$TrackToJson(Track instance) => <String, dynamic>{
@@ -37,7 +40,10 @@ 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,
+  'albumType': instance.albumType,
 };
 
 ServiceAvailability _$ServiceAvailabilityFromJson(Map<String, dynamic> json) =>
@@ -45,9 +51,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 +65,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,
 };

lib/providers/extension_provider.dart

@@ -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,
+);

lib/providers/settings_provider.dart

@@ -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();
@@ -161,6 +194,28 @@ class SettingsNotifier extends Notifier<AppSettings> {
     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();
+  }
+
+  void setSeparateSingles(bool enabled) {
+    state = state.copyWith(separateSingles: enabled);
+    _saveSettings();
+  }
 }
 
 final settingsProvider = NotifierProvider<SettingsNotifier, AppSettings>(

lib/providers/track_provider.dart

@@ -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,
     );
   }
 }
@@ -207,31 +216,109 @@ class TrackNotifier extends Notifier<TrackState> {
     state = TrackState(isLoading: true, hasSearchText: state.hasSearchText);
 
     try {
+      // 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';
       
-      // Debug log to show which source is being used
-      // ignore: avoid_print
-      print('[Search] Using metadata source: $source for query: "$query"');
+      _log.i('Search started: source=$source, query="$query", useExtensions=$useExtensions');
       
       Map<String, dynamic> results;
-      if (source == 'deezer') {
-        results = await PlatformBridge.searchDeezerAll(query, trackLimit: 20, artistLimit: 5);
-        // ignore: avoid_print
-        print('[Search] Deezer returned ${(results['tracks'] as List?)?.length ?? 0} tracks');
-      } else {
-        results = await PlatformBridge.searchSpotifyAll(query, trackLimit: 20, artistLimit: 5);
-        // ignore: avoid_print
-        print('[Search] Spotify returned ${(results['tracks'] as List?)?.length ?? 0} tracks');
+      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');
+        }
       }
       
-      if (!_isRequestValid(requestId)) return; // Request cancelled
+      // 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,
@@ -239,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);
     }
   }
@@ -309,19 +443,30 @@ 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(),
+      albumType: data['album_type']?.toString(),
     );
   }
 

lib/screens/album_screen.dart

@@ -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 {
@@ -316,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')));
@@ -331,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') || 
@@ -473,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;

lib/screens/artist_screen.dart

@@ -159,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,
@@ -169,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(
@@ -192,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)),
                   ),
                 ),

lib/screens/downloaded_album_screen.dart

@@ -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)),
+                  ),
+                ),
+              ),
+            ],
+          ),
+        ),
+      ),
+    );
+  }
+}

lib/screens/home_tab.dart

@@ -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,12 +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);
-    await ref.read(trackProvider.notifier).search(query, metadataSource: settings.metadataSource);
+    final searchProvider = settings.searchProvider;
+    
+    // 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();
   }
 
@@ -172,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')));
@@ -183,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
@@ -286,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(
@@ -297,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,
+                    ),
+                  ),
+                );
+              },
             ),
           ),
           
@@ -329,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(
@@ -651,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(
@@ -666,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),
               ),
@@ -703,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;
     
@@ -711,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(
@@ -736,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),
@@ -771,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;
@@ -941,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;
@@ -961,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),
                         ),
@@ -1012,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),
           ),

lib/screens/main_shell.dart

@@ -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);

lib/screens/playlist_screen.dart

@@ -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

lib/screens/settings/about_page.dart

@@ -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),
+          ),
+      ],
+    );
+  }
+}

lib/screens/settings/appearance_settings_page.dart

@@ -27,68 +27,108 @@ class AppearanceSettingsPage extends ConsumerWidget {
               pinned: true,
               backgroundColor: colorScheme.surface,
               surfaceTintColor: Colors.transparent,
-              leading: IconButton(icon: const Icon(Icons.arrow_back), onPressed: () => Navigator.pop(context)),
-              flexibleSpace: _AppBarTitle(title: 'Appearance', topPadding: topPadding),
+              leading: IconButton(
+                icon: const Icon(Icons.arrow_back),
+                onPressed: () => Navigator.pop(context),
+              ),
+              flexibleSpace: _AppBarTitle(
+                title: 'Appearance',
+                topPadding: topPadding,
+              ),
+            ),
+
+            // Preview Section
+            SliverToBoxAdapter(
+              child: Padding(
+                padding: const EdgeInsets.symmetric(
+                  horizontal: 16,
+                  vertical: 8,
+                ),
+                child: _ThemePreviewCard(),
+              ),
+            ),
+
+            // Color section
+            const SliverToBoxAdapter(
+              child: SettingsSectionHeader(title: 'Color'),
             ),
 
-            // Theme section
-            const SliverToBoxAdapter(child: SettingsSectionHeader(title: 'Theme')),
             SliverToBoxAdapter(
               child: SettingsGroup(
                 children: [
-                  _ThemeModeSelector(
-                    currentMode: themeSettings.themeMode,
-                    onChanged: (mode) => ref.read(themeProvider.notifier).setThemeMode(mode),
-                  ),
                   SettingsSwitchItem(
-                    icon: Icons.brightness_2,
-                    title: 'AMOLED Dark',
-                    subtitle: 'Pure black background for OLED screens',
-                    value: themeSettings.useAmoled,
-                    onChanged: (value) => ref.read(themeProvider.notifier).setUseAmoled(value),
+                    icon: Icons.wallpaper,
+                    title: 'Dynamic Color',
+                    subtitle: 'Use colors from your wallpaper',
+                    value: themeSettings.useDynamicColor,
+                    onChanged: (value) => ref
+                        .read(themeProvider.notifier)
+                        .setUseDynamicColor(value),
                     showDivider: false,
                   ),
                 ],
               ),
             ),
+            if (!themeSettings.useDynamicColor)
+              SliverToBoxAdapter(
+                child: Padding(
+                  padding: const EdgeInsets.fromLTRB(16, 12, 16, 0),
+                  child: _ColorPalettePicker(
+                    currentColor: themeSettings.seedColorValue,
+                    onColorSelected: (color) =>
+                        ref.read(themeProvider.notifier).setSeedColor(color),
+                  ),
+                ),
+              ),
 
-            // Color section
-            const SliverToBoxAdapter(child: SettingsSectionHeader(title: 'Color')),
+            // Theme section
+            const SliverToBoxAdapter(
+              child: SettingsSectionHeader(title: 'Theme'),
+            ),
             SliverToBoxAdapter(
               child: SettingsGroup(
                 children: [
-                  SettingsSwitchItem(
-                    icon: Icons.auto_awesome,
-                    title: 'Dynamic Color',
-                    subtitle: 'Use colors from your wallpaper',
-                    value: themeSettings.useDynamicColor,
-                    onChanged: (value) => ref.read(themeProvider.notifier).setUseDynamicColor(value),
-                    showDivider: !themeSettings.useDynamicColor,
+                  _ThemeModeSelector(
+                    currentMode: themeSettings.themeMode,
+                    onChanged: (mode) =>
+                        ref.read(themeProvider.notifier).setThemeMode(mode),
                   ),
-                  if (!themeSettings.useDynamicColor)
-                    _ColorPicker(
-                      currentColor: themeSettings.seedColorValue,
-                      onColorSelected: (color) => ref.read(themeProvider.notifier).setSeedColor(color),
+                  if (Theme.of(context).brightness == Brightness.dark)
+                    SettingsSwitchItem(
+                      icon: Icons.brightness_2,
+                      title: 'AMOLED Dark',
+                      subtitle: 'Pure black background',
+                      value: themeSettings.useAmoled,
+                      onChanged: (value) =>
+                          ref.read(themeProvider.notifier).setUseAmoled(value),
+                      showDivider: false,
                     ),
                 ],
               ),
             ),
 
             // Layout section
-            const SliverToBoxAdapter(child: SettingsSectionHeader(title: 'Layout')),
+            const SliverToBoxAdapter(
+              child: SettingsSectionHeader(title: 'Layout'),
+            ),
             SliverToBoxAdapter(
               child: SettingsGroup(
                 children: [
                   _HistoryViewSelector(
                     currentMode: settings.historyViewMode,
-                    onChanged: (mode) => ref.read(settingsProvider.notifier).setHistoryViewMode(mode),
+                    onChanged: (mode) => ref
+                        .read(settingsProvider.notifier)
+                        .setHistoryViewMode(mode),
                   ),
                 ],
               ),
             ),
 
             // Fill remaining for scroll
-            const SliverFillRemaining(hasScrollBody: false, child: SizedBox()),
+            const SliverFillRemaining(
+              hasScrollBody: false,
+              child: SizedBox(height: 32),
+            ),
           ],
         ),
       ),
@@ -96,11 +136,275 @@ class AppearanceSettingsPage extends ConsumerWidget {
   }
 }
 
+/// A simplified preview of how the app looks with current settings
+class _ThemePreviewCard extends StatelessWidget {
+  @override
+  Widget build(BuildContext context) {
+    final colorScheme = Theme.of(context).colorScheme;
+    final isDark = Theme.of(context).brightness == Brightness.dark;
+
+    return RepaintBoundary(
+      child: Container(
+        height: 200,
+        width: double.infinity,
+        decoration: BoxDecoration(
+          color: colorScheme
+              .surfaceContainerHighest, // Background similar to reference
+          borderRadius: BorderRadius.circular(28),
+        ),
+        clipBehavior: Clip.antiAlias,
+        child: Stack(
+          children: [
+            // Decorative background blobs
+            Positioned(
+              top: -50,
+              right: -50,
+              child: Container(
+                width: 200,
+                height: 200,
+                decoration: BoxDecoration(
+                  shape: BoxShape.circle,
+                  color: colorScheme.primaryContainer.withValues(alpha: 0.5),
+                ),
+              ),
+            ),
+            Positioned(
+              bottom: -30,
+              left: -30,
+              child: Container(
+                width: 150,
+                height: 150,
+                decoration: BoxDecoration(
+                  shape: BoxShape.circle,
+                  color: colorScheme.tertiaryContainer.withValues(alpha: 0.5),
+                ),
+              ),
+            ),
+
+            // Foreground "fake UI"
+            Center(
+              child: Container(
+                width: 260,
+                height: 140,
+                padding: const EdgeInsets.all(16),
+                decoration: BoxDecoration(
+                  color: colorScheme.surface,
+                  borderRadius: BorderRadius.circular(20),
+                  boxShadow: [
+                    BoxShadow(
+                      color: Colors.black.withValues(alpha: 0.1),
+                      blurRadius: 12, // Reduced from 20 for performance
+                      offset: const Offset(0, 8),
+                    ),
+                  ],
+                ),
+                child: Row(
+                  children: [
+                    // Fake Album Art
+                    Container(
+                      width: 108,
+                      height: 108,
+                      decoration: BoxDecoration(
+                        color: colorScheme.primary,
+                        borderRadius: BorderRadius.circular(16),
+                      ),
+                      child: Icon(
+                        Icons.music_note,
+                        color: colorScheme.onPrimary,
+                        size: 48,
+                      ),
+                    ),
+                    const SizedBox(width: 16),
+
+                    // Fake Text Info
+                    Expanded(
+                      child: Column(
+                        crossAxisAlignment: CrossAxisAlignment.start,
+                        mainAxisAlignment: MainAxisAlignment.center,
+                        children: [
+                          Container(
+                            width: double.infinity,
+                            height: 14,
+                            decoration: BoxDecoration(
+                              color: colorScheme.onSurface,
+                              borderRadius: BorderRadius.circular(4),
+                            ),
+                          ),
+                          const SizedBox(height: 8),
+                          Container(
+                            width: 80,
+                            height: 10,
+                            decoration: BoxDecoration(
+                              color: colorScheme.primary,
+                              borderRadius: BorderRadius.circular(4),
+                            ),
+                          ),
+                          const SizedBox(height: 24),
+                          Row(
+                            children: [
+                              Icon(
+                                Icons.skip_previous,
+                                size: 24,
+                                color: colorScheme.onSurfaceVariant,
+                              ),
+                              const SizedBox(width: 12),
+                              Icon(
+                                Icons.play_circle_fill,
+                                size: 32,
+                                color: colorScheme.primary,
+                              ),
+                              const SizedBox(width: 12),
+                              Icon(
+                                Icons.skip_next,
+                                size: 24,
+                                color: colorScheme.onSurfaceVariant,
+                              ),
+                            ],
+                          ),
+                        ],
+                      ),
+                    ),
+                  ],
+                ),
+              ),
+            ),
+
+            // Label badge
+            Positioned(
+              bottom: 12,
+              right: 12,
+              child: Container(
+                padding: const EdgeInsets.symmetric(
+                  horizontal: 10,
+                  vertical: 4,
+                ),
+                decoration: BoxDecoration(
+                  color: Colors.black.withValues(alpha: 0.6),
+                  borderRadius: BorderRadius.circular(20),
+                ),
+                child: Text(
+                  isDark ? 'Dark Mode' : 'Light Mode',
+                  style: const TextStyle(
+                    color: Colors.white,
+                    fontSize: 10,
+                    fontWeight: FontWeight.bold,
+                  ),
+                ),
+              ),
+            ),
+          ],
+        ),
+      ),
+    );
+  }
+}
+
+class _ColorPalettePicker extends StatelessWidget {
+  final int currentColor;
+  final ValueChanged<Color> onColorSelected;
+  const _ColorPalettePicker({
+    required this.currentColor,
+    required this.onColorSelected,
+  });
+
+  static const _colors = [
+    Color(0xFF1DB954),
+    Color(0xFF6750A4),
+    Color(0xFF0061A4),
+    Color(0xFF006E1C),
+    Color(0xFFBA1A1A),
+    Color(0xFF984061),
+    Color(0xFF7D5260),
+    Color(0xFF006874),
+  ];
+
+  @override
+  Widget build(BuildContext context) {
+    return SingleChildScrollView(
+      scrollDirection: Axis.horizontal,
+      child: Row(
+        children: _colors.map((color) {
+          final isSelected = color.toARGB32() == currentColor;
+          return Padding(
+            padding: const EdgeInsets.only(right: 12),
+            child: GestureDetector(
+              onTap: () => onColorSelected(color),
+              child: _ColorPaletteItem(color: color, isSelected: isSelected),
+            ),
+          );
+        }).toList(),
+      ),
+    );
+  }
+}
+
+class _ColorPaletteItem extends StatelessWidget {
+  final Color color;
+  final bool isSelected;
+
+  const _ColorPaletteItem({required this.color, required this.isSelected});
+
+  @override
+  Widget build(BuildContext context) {
+    final scheme = ColorScheme.fromSeed(
+      seedColor: color,
+      brightness: Theme.of(context).brightness,
+    );
+    final size = 64.0;
+
+    return Stack(
+      children: [
+        Container(
+          width: size,
+          height: size,
+          decoration: BoxDecoration(borderRadius: BorderRadius.circular(20)),
+          clipBehavior: Clip.antiAlias,
+          child: Column(
+            children: [
+              Expanded(
+                child: Row(
+                  children: [
+                    Expanded(child: Container(color: scheme.primaryContainer)),
+                    Expanded(child: Container(color: scheme.tertiaryContainer)),
+                  ],
+                ),
+              ),
+              Expanded(
+                child: Row(
+                  children: [
+                    Expanded(
+                      child: Container(color: scheme.secondaryContainer),
+                    ),
+                    Expanded(child: Container(color: scheme.surfaceContainer)),
+                  ],
+                ),
+              ),
+            ],
+          ),
+        ),
+        if (isSelected)
+          Positioned.fill(
+            child: Center(
+              child: Container(
+                padding: const EdgeInsets.all(4),
+                decoration: const BoxDecoration(
+                  color: Colors.white,
+                  shape: BoxShape.circle,
+                ),
+                child: Icon(Icons.check, size: 16, color: scheme.primary),
+              ),
+            ),
+          ),
+      ],
+    );
+  }
+}
+
 /// Optimized app bar title with animation
 class _AppBarTitle extends StatelessWidget {
   final String title;
   final double topPadding;
-  
+
   const _AppBarTitle({required this.title, required this.topPadding});
 
   @override
@@ -110,7 +414,9 @@ class _AppBarTitle extends StatelessWidget {
       builder: (context, constraints) {
         final maxHeight = 120 + topPadding;
         final minHeight = kToolbarHeight + topPadding;
-        final expandRatio = ((constraints.maxHeight - minHeight) / (maxHeight - minHeight)).clamp(0.0, 1.0);
+        final expandRatio =
+            ((constraints.maxHeight - minHeight) / (maxHeight - minHeight))
+                .clamp(0.0, 1.0);
         final leftPadding = 56 - (32 * expandRatio); // 56 -> 24
         return FlexibleSpaceBar(
           expandedTitleScale: 1.0,
@@ -132,19 +438,39 @@ class _AppBarTitle extends StatelessWidget {
 class _ThemeModeSelector extends StatelessWidget {
   final ThemeMode currentMode;
   final ValueChanged<ThemeMode> onChanged;
-  const _ThemeModeSelector({required this.currentMode, required this.onChanged});
+  const _ThemeModeSelector({
+    required this.currentMode,
+    required this.onChanged,
+  });
 
   @override
   Widget build(BuildContext context) {
     return Padding(
       padding: const EdgeInsets.all(12),
-      child: Row(children: [
-        _ThemeModeChip(icon: Icons.brightness_auto, label: 'System', isSelected: currentMode == ThemeMode.system, onTap: () => onChanged(ThemeMode.system)),
-        const SizedBox(width: 8),
-        _ThemeModeChip(icon: Icons.light_mode, label: 'Light', isSelected: currentMode == ThemeMode.light, onTap: () => onChanged(ThemeMode.light)),
-        const SizedBox(width: 8),
-        _ThemeModeChip(icon: Icons.dark_mode, label: 'Dark', isSelected: currentMode == ThemeMode.dark, onTap: () => onChanged(ThemeMode.dark)),
-      ]),
+      child: Row(
+        children: [
+          _ThemeModeChip(
+            icon: Icons.brightness_auto,
+            label: 'System',
+            isSelected: currentMode == ThemeMode.system,
+            onTap: () => onChanged(ThemeMode.system),
+          ),
+          const SizedBox(width: 8),
+          _ThemeModeChip(
+            icon: Icons.light_mode,
+            label: 'Light',
+            isSelected: currentMode == ThemeMode.light,
+            onTap: () => onChanged(ThemeMode.light),
+          ),
+          const SizedBox(width: 8),
+          _ThemeModeChip(
+            icon: Icons.dark_mode,
+            label: 'Dark',
+            isSelected: currentMode == ThemeMode.dark,
+            onTap: () => onChanged(ThemeMode.dark),
+          ),
+        ],
+      ),
     );
   }
 }
@@ -154,27 +480,41 @@ class _ThemeModeChip extends StatelessWidget {
   final String label;
   final bool isSelected;
   final VoidCallback onTap;
-  const _ThemeModeChip({required this.icon, required this.label, required this.isSelected, required this.onTap});
+  const _ThemeModeChip({
+    required this.icon,
+    required this.label,
+    required this.isSelected,
+    required this.onTap,
+  });
 
   @override
   Widget build(BuildContext context) {
     final colorScheme = Theme.of(context).colorScheme;
     final isDark = Theme.of(context).brightness == Brightness.dark;
-    
+
     // Unselected chips need contrast with card background
     // Card uses: dark = white 8% overlay, light = surfaceContainerHighest
     // So chips use: dark = white 5% overlay (darker), light = black 5% overlay (darker than card)
-    final unselectedColor = isDark 
-        ? Color.alphaBlend(Colors.white.withValues(alpha: 0.05), colorScheme.surface)
-        : Color.alphaBlend(Colors.black.withValues(alpha: 0.05), colorScheme.surfaceContainerHighest);
-    
+    final unselectedColor = isDark
+        ? Color.alphaBlend(
+            Colors.white.withValues(alpha: 0.05),
+            colorScheme.surface,
+          )
+        : Color.alphaBlend(
+            Colors.black.withValues(alpha: 0.05),
+            colorScheme.surfaceContainerHighest,
+          );
+
     return Expanded(
       child: Container(
         decoration: BoxDecoration(
           color: isSelected ? colorScheme.primaryContainer : unselectedColor,
           borderRadius: BorderRadius.circular(12),
-          border: !isDark && !isSelected 
-              ? Border.all(color: colorScheme.outlineVariant.withValues(alpha: 0.5), width: 1)
+          border: !isDark && !isSelected
+              ? Border.all(
+                  color: colorScheme.outlineVariant.withValues(alpha: 0.5),
+                  width: 1,
+                )
               : null,
         ),
         child: Material(
@@ -185,13 +525,29 @@ class _ThemeModeChip extends StatelessWidget {
             borderRadius: BorderRadius.circular(12),
             child: Padding(
               padding: const EdgeInsets.symmetric(vertical: 14),
-              child: Column(children: [
-                Icon(icon, color: isSelected ? colorScheme.onPrimaryContainer : colorScheme.onSurfaceVariant),
-                const SizedBox(height: 6),
-                Text(label, style: TextStyle(fontSize: 12,
-                  fontWeight: isSelected ? FontWeight.w600 : FontWeight.normal,
-                  color: isSelected ? colorScheme.onPrimaryContainer : colorScheme.onSurfaceVariant)),
-              ]),
+              child: Column(
+                children: [
+                  Icon(
+                    icon,
+                    color: isSelected
+                        ? colorScheme.onPrimaryContainer
+                        : colorScheme.onSurfaceVariant,
+                  ),
+                  const SizedBox(height: 6),
+                  Text(
+                    label,
+                    style: TextStyle(
+                      fontSize: 12,
+                      fontWeight: isSelected
+                          ? FontWeight.w600
+                          : FontWeight.normal,
+                      color: isSelected
+                          ? colorScheme.onPrimaryContainer
+                          : colorScheme.onSurfaceVariant,
+                    ),
+                  ),
+                ],
+              ),
             ),
           ),
         ),
@@ -200,49 +556,13 @@ class _ThemeModeChip extends StatelessWidget {
   }
 }
 
-class _ColorPicker extends StatelessWidget {
-  final int currentColor;
-  final ValueChanged<Color> onColorSelected;
-  const _ColorPicker({required this.currentColor, required this.onColorSelected});
-
-  static const _colors = [
-    Color(0xFF1DB954), Color(0xFF6750A4), Color(0xFF0061A4), Color(0xFF006E1C),
-    Color(0xFFBA1A1A), Color(0xFF984061), Color(0xFF7D5260), Color(0xFF006874), Color(0xFFFF6F00),
-  ];
-
-  @override
-  Widget build(BuildContext context) {
-    final colorScheme = Theme.of(context).colorScheme;
-    return Padding(
-      padding: const EdgeInsets.fromLTRB(20, 8, 20, 16),
-      child: Column(crossAxisAlignment: CrossAxisAlignment.start, children: [
-        Text('Accent Color', style: Theme.of(context).textTheme.bodyMedium?.copyWith(color: colorScheme.onSurfaceVariant)),
-        const SizedBox(height: 12),
-        Wrap(spacing: 12, runSpacing: 12, children: _colors.map((color) {
-          final isSelected = color.toARGB32() == currentColor;
-          return GestureDetector(
-            onTap: () => onColorSelected(color),
-            child: AnimatedContainer(
-              duration: const Duration(milliseconds: 200),
-              width: 44, height: 44,
-              decoration: BoxDecoration(
-                color: color, shape: BoxShape.circle,
-                border: isSelected ? Border.all(color: colorScheme.onSurface, width: 3) : null,
-                boxShadow: isSelected ? [BoxShadow(color: color.withValues(alpha: 0.4), blurRadius: 8, spreadRadius: 2)] : null,
-              ),
-              child: isSelected ? const Icon(Icons.check, color: Colors.white, size: 20) : null,
-            ),
-          );
-        }).toList()),
-      ]),
-    );
-  }
-}
-
 class _HistoryViewSelector extends StatelessWidget {
   final String currentMode;
   final ValueChanged<String> onChanged;
-  const _HistoryViewSelector({required this.currentMode, required this.onChanged});
+  const _HistoryViewSelector({
+    required this.currentMode,
+    required this.onChanged,
+  });
 
   @override
   Widget build(BuildContext context) {
@@ -254,13 +574,30 @@ class _HistoryViewSelector extends StatelessWidget {
         children: [
           Padding(
             padding: const EdgeInsets.only(left: 8, bottom: 8),
-            child: Text('History View', style: Theme.of(context).textTheme.bodyMedium?.copyWith(color: colorScheme.onSurfaceVariant)),
+            child: Text(
+              'History View',
+              style: Theme.of(context).textTheme.bodyMedium?.copyWith(
+                color: colorScheme.onSurfaceVariant,
+              ),
+            ),
+          ),
+          Row(
+            children: [
+              _ViewModeChip(
+                icon: Icons.view_list,
+                label: 'List',
+                isSelected: currentMode == 'list',
+                onTap: () => onChanged('list'),
+              ),
+              const SizedBox(width: 8),
+              _ViewModeChip(
+                icon: Icons.grid_view,
+                label: 'Grid',
+                isSelected: currentMode == 'grid',
+                onTap: () => onChanged('grid'),
+              ),
+            ],
           ),
-          Row(children: [
-            _ViewModeChip(icon: Icons.view_list, label: 'List', isSelected: currentMode == 'list', onTap: () => onChanged('list')),
-            const SizedBox(width: 8),
-            _ViewModeChip(icon: Icons.grid_view, label: 'Grid', isSelected: currentMode == 'grid', onTap: () => onChanged('grid')),
-          ]),
         ],
       ),
     );
@@ -272,25 +609,39 @@ class _ViewModeChip extends StatelessWidget {
   final String label;
   final bool isSelected;
   final VoidCallback onTap;
-  const _ViewModeChip({required this.icon, required this.label, required this.isSelected, required this.onTap});
+  const _ViewModeChip({
+    required this.icon,
+    required this.label,
+    required this.isSelected,
+    required this.onTap,
+  });
 
   @override
   Widget build(BuildContext context) {
     final colorScheme = Theme.of(context).colorScheme;
     final isDark = Theme.of(context).brightness == Brightness.dark;
-    
+
     // Unselected chips need contrast with card background
-    final unselectedColor = isDark 
-        ? Color.alphaBlend(Colors.white.withValues(alpha: 0.05), colorScheme.surface)
-        : Color.alphaBlend(Colors.black.withValues(alpha: 0.05), colorScheme.surfaceContainerHighest);
-    
+    final unselectedColor = isDark
+        ? Color.alphaBlend(
+            Colors.white.withValues(alpha: 0.05),
+            colorScheme.surface,
+          )
+        : Color.alphaBlend(
+            Colors.black.withValues(alpha: 0.05),
+            colorScheme.surfaceContainerHighest,
+          );
+
     return Expanded(
       child: Container(
         decoration: BoxDecoration(
           color: isSelected ? colorScheme.primaryContainer : unselectedColor,
           borderRadius: BorderRadius.circular(12),
-          border: !isDark && !isSelected 
-              ? Border.all(color: colorScheme.outlineVariant.withValues(alpha: 0.5), width: 1)
+          border: !isDark && !isSelected
+              ? Border.all(
+                  color: colorScheme.outlineVariant.withValues(alpha: 0.5),
+                  width: 1,
+                )
               : null,
         ),
         child: Material(
@@ -301,13 +652,29 @@ class _ViewModeChip extends StatelessWidget {
             borderRadius: BorderRadius.circular(12),
             child: Padding(
               padding: const EdgeInsets.symmetric(vertical: 14),
-              child: Column(children: [
-                Icon(icon, color: isSelected ? colorScheme.onPrimaryContainer : colorScheme.onSurfaceVariant),
-                const SizedBox(height: 6),
-                Text(label, style: TextStyle(fontSize: 12,
-                  fontWeight: isSelected ? FontWeight.w600 : FontWeight.normal,
-                  color: isSelected ? colorScheme.onPrimaryContainer : colorScheme.onSurfaceVariant)),
-              ]),
+              child: Column(
+                children: [
+                  Icon(
+                    icon,
+                    color: isSelected
+                        ? colorScheme.onPrimaryContainer
+                        : colorScheme.onSurfaceVariant,
+                  ),
+                  const SizedBox(height: 6),
+                  Text(
+                    label,
+                    style: TextStyle(
+                      fontSize: 12,
+                      fontWeight: isSelected
+                          ? FontWeight.w600
+                          : FontWeight.normal,
+                      color: isSelected
+                          ? colorScheme.onPrimaryContainer
+                          : colorScheme.onSurfaceVariant,
+                    ),
+                  ),
+                ],
+              ),
             ),
           ),
         ),

lib/screens/settings/download_settings_page.dart

@@ -4,16 +4,23 @@ import 'package:flutter_riverpod/flutter_riverpod.dart';
 import 'package:file_picker/file_picker.dart';
 import 'package:path_provider/path_provider.dart';
 import 'package:spotiflac_android/providers/settings_provider.dart';
+import 'package:spotiflac_android/providers/extension_provider.dart';
 import 'package:spotiflac_android/widgets/settings_group.dart';
 
 class DownloadSettingsPage extends ConsumerWidget {
   const DownloadSettingsPage({super.key});
+  
+  // Built-in services that support quality options
+  static const _builtInServices = ['tidal', 'qobuz', 'amazon'];
 
   @override
   Widget build(BuildContext context, WidgetRef ref) {
     final settings = ref.watch(settingsProvider);
     final colorScheme = Theme.of(context).colorScheme;
     final topPadding = MediaQuery.of(context).padding.top;
+    
+    // Check if current service is built-in (supports quality options)
+    final isBuiltInService = _builtInServices.contains(settings.defaultService);
 
     return PopScope(
       canPop: true,
@@ -28,16 +35,25 @@ class DownloadSettingsPage extends ConsumerWidget {
               pinned: true,
               backgroundColor: colorScheme.surface,
               surfaceTintColor: Colors.transparent,
-              leading: IconButton(icon: const Icon(Icons.arrow_back), onPressed: () => Navigator.pop(context)),
+              leading: IconButton(
+                icon: const Icon(Icons.arrow_back),
+                onPressed: () => Navigator.pop(context),
+              ),
               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);
+                  final expandRatio =
+                      ((constraints.maxHeight - minHeight) /
+                              (maxHeight - minHeight))
+                          .clamp(0.0, 1.0);
                   final leftPadding = 56 - (32 * expandRatio); // 56 -> 24
                   return FlexibleSpaceBar(
                     expandedTitleScale: 1.0,
-                    titlePadding: EdgeInsets.only(left: leftPadding, bottom: 16),
+                    titlePadding: EdgeInsets.only(
+                      left: leftPadding,
+                      bottom: 16,
+                    ),
                     title: Text(
                       'Download',
                       style: TextStyle(
@@ -51,89 +67,156 @@ class DownloadSettingsPage extends ConsumerWidget {
               ),
             ),
 
-          // Service section
-          const SliverToBoxAdapter(child: SettingsSectionHeader(title: 'Service')),
-          SliverToBoxAdapter(
-            child: SettingsGroup(
-              children: [
-                _ServiceSelector(
-                  currentService: settings.defaultService,
-                  onChanged: (service) => ref.read(settingsProvider.notifier).setDefaultService(service),
-                ),
-              ],
+            // Service section
+            const SliverToBoxAdapter(
+              child: SettingsSectionHeader(title: 'Service'),
             ),
-          ),
-
-          // Quality section
-          const SliverToBoxAdapter(child: SettingsSectionHeader(title: 'Audio Quality')),
-          SliverToBoxAdapter(
-            child: SettingsGroup(
-              children: [
-                SettingsSwitchItem(
-                  icon: Icons.tune,
-                  title: 'Ask Before Download',
-                  subtitle: 'Choose quality for each download',
-                  value: settings.askQualityBeforeDownload,
-                  onChanged: (value) => ref.read(settingsProvider.notifier).setAskQualityBeforeDownload(value),
-                ),
-                if (!settings.askQualityBeforeDownload) ...[
-                  _QualityOption(
-                    title: 'FLAC Lossless',
-                    subtitle: '16-bit / 44.1kHz',
-                    isSelected: settings.audioQuality == 'LOSSLESS',
-                    onTap: () => ref.read(settingsProvider.notifier).setAudioQuality('LOSSLESS'),
-                  ),
-                  _QualityOption(
-                    title: 'Hi-Res FLAC',
-                    subtitle: '24-bit / up to 96kHz',
-                    isSelected: settings.audioQuality == 'HI_RES',
-                    onTap: () => ref.read(settingsProvider.notifier).setAudioQuality('HI_RES'),
-                  ),
-                  _QualityOption(
-                    title: 'Hi-Res FLAC Max',
-                    subtitle: '24-bit / up to 192kHz',
-                    isSelected: settings.audioQuality == 'HI_RES_LOSSLESS',
-                    onTap: () => ref.read(settingsProvider.notifier).setAudioQuality('HI_RES_LOSSLESS'),
-                    showDivider: false,
+            SliverToBoxAdapter(
+              child: SettingsGroup(
+                children: [
+                  _ServiceSelector(
+                    currentService: settings.defaultService,
+                    onChanged: (service) => ref
+                        .read(settingsProvider.notifier)
+                        .setDefaultService(service),
                   ),
                 ],
-              ],
+              ),
             ),
-          ),
 
-          // File settings section
-          const SliverToBoxAdapter(child: SettingsSectionHeader(title: 'File Settings')),
-          SliverToBoxAdapter(
-            child: SettingsGroup(
-              children: [
-                SettingsItem(
-                  icon: Icons.text_fields,
-                  title: 'Filename Format',
-                  subtitle: settings.filenameFormat,
-                  onTap: () => _showFormatEditor(context, ref, settings.filenameFormat),
-                ),
-                SettingsItem(
-                  icon: Icons.folder_outlined,
-                  title: 'Download Directory',
-                  subtitle: settings.downloadDirectory.isEmpty 
-                      ? (Platform.isIOS ? 'App Documents Folder' : 'Music/SpotiFLAC') 
-                      : settings.downloadDirectory,
-                  onTap: () => _pickDirectory(context, ref),
-                ),
-                SettingsItem(
-                  icon: Icons.create_new_folder_outlined,
-                  title: 'Folder Organization',
-                  subtitle: _getFolderOrganizationLabel(settings.folderOrganization),
-                  onTap: () => _showFolderOrganizationPicker(context, ref, settings.folderOrganization),
-                  showDivider: false,
-                ),
-              ],
+            // Quality section
+            const SliverToBoxAdapter(
+              child: SettingsSectionHeader(title: 'Audio Quality'),
+            ),
+            SliverToBoxAdapter(
+              child: SettingsGroup(
+                children: [
+                  SettingsSwitchItem(
+                    icon: Icons.tune,
+                    title: 'Ask Before Download',
+                    subtitle: isBuiltInService 
+                        ? 'Choose quality for each download'
+                        : 'Select a built-in service to enable',
+                    value: settings.askQualityBeforeDownload,
+                    // Not selected visually if extension is active
+                    enabled: isBuiltInService,
+                    onChanged: (value) => ref
+                        .read(settingsProvider.notifier)
+                        .setAskQualityBeforeDownload(value),
+                  ),
+                  if (!settings.askQualityBeforeDownload && isBuiltInService) ...[
+                    _QualityOption(
+                      title: 'FLAC Lossless',
+                      subtitle: '16-bit / 44.1kHz',
+                      isSelected: settings.audioQuality == 'LOSSLESS',
+                      onTap: () => ref
+                          .read(settingsProvider.notifier)
+                          .setAudioQuality('LOSSLESS'),
+                    ),
+                    _QualityOption(
+                      title: 'Hi-Res FLAC',
+                      subtitle: '24-bit / up to 96kHz',
+                      isSelected: settings.audioQuality == 'HI_RES',
+                      onTap: () => ref
+                          .read(settingsProvider.notifier)
+                          .setAudioQuality('HI_RES'),
+                    ),
+                    _QualityOption(
+                      title: 'Hi-Res FLAC Max',
+                      subtitle: '24-bit / up to 192kHz',
+                      isSelected: settings.audioQuality == 'HI_RES_LOSSLESS',
+                      onTap: () => ref
+                          .read(settingsProvider.notifier)
+                          .setAudioQuality('HI_RES_LOSSLESS'),
+                      showDivider: false,
+                    ),
+                  ],
+                  if (!isBuiltInService) ...[
+                    Padding(
+                      padding: const EdgeInsets.fromLTRB(16, 8, 16, 16),
+                      child: Row(
+                        children: [
+                          Icon(
+                            Icons.info_outline,
+                            size: 16,
+                            color: colorScheme.onSurfaceVariant,
+                          ),
+                          const SizedBox(width: 8),
+                          Expanded(
+                            child: Text(
+                              'Select Tidal, Qobuz, or Amazon above to configure quality',
+                              style: Theme.of(context).textTheme.bodySmall?.copyWith(
+                                color: colorScheme.onSurfaceVariant,
+                              ),
+                            ),
+                          ),
+                        ],
+                      ),
+                    ),
+                  ],
+                ],
+              ),
             ),
-          ),
 
-          const SliverToBoxAdapter(child: SizedBox(height: 32)),
-        ],
-      ),
+            // File settings section
+            const SliverToBoxAdapter(
+              child: SettingsSectionHeader(title: 'File Settings'),
+            ),
+            SliverToBoxAdapter(
+              child: SettingsGroup(
+                children: [
+                  SettingsItem(
+                    icon: Icons.text_fields,
+                    title: 'Filename Format',
+                    subtitle: settings.filenameFormat,
+                    onTap: () => _showFormatEditor(
+                      context,
+                      ref,
+                      settings.filenameFormat,
+                    ),
+                  ),
+                  SettingsItem(
+                    icon: Icons.folder_outlined,
+                    title: 'Download Directory',
+                    subtitle: settings.downloadDirectory.isEmpty
+                        ? (Platform.isIOS
+                              ? 'App Documents Folder'
+                              : 'Music/SpotiFLAC')
+                        : settings.downloadDirectory,
+                    onTap: () => _pickDirectory(context, ref),
+                  ),
+                  SettingsSwitchItem(
+                    icon: Icons.library_music_outlined,
+                    title: 'Separate Singles Folder',
+                    subtitle: settings.separateSingles
+                        ? 'Albums/ and Singles/ folders'
+                        : 'All files in same structure',
+                    value: settings.separateSingles,
+                    onChanged: (value) => ref
+                        .read(settingsProvider.notifier)
+                        .setSeparateSingles(value),
+                  ),
+                  if (!settings.separateSingles)
+                    SettingsItem(
+                      icon: Icons.create_new_folder_outlined,
+                      title: 'Folder Organization',
+                      subtitle: _getFolderOrganizationLabel(
+                        settings.folderOrganization,
+                      ),
+                      onTap: () => _showFolderOrganizationPicker(
+                        context,
+                        ref,
+                        settings.folderOrganization,
+                      ),
+                      showDivider: false,
+                    ),
+                ],
+              ),
+            ),
+
+            const SliverToBoxAdapter(child: SizedBox(height: 32)),
+          ],
+        ),
       ),
     );
   }
@@ -141,26 +224,176 @@ class DownloadSettingsPage extends ConsumerWidget {
   void _showFormatEditor(BuildContext context, WidgetRef ref, String current) {
     final controller = TextEditingController(text: current);
     final colorScheme = Theme.of(context).colorScheme;
+
+    final tags = [
+      '{artist}',
+      '{title}',
+      '{album}',
+      '{track}',
+      '{year}',
+      '{disc}',
+    ];
+
+    void insertTag(String tag) {
+      final text = controller.text;
+      final selection = controller.selection;
+      final start = selection.start >= 0 ? selection.start : text.length;
+      final end = selection.end >= 0 ? selection.end : text.length;
+
+      String insertion = tag;
+      if (start > 0) {
+        final before = text.substring(0, start);
+        // Smart separator: if not starting a file and no hyphen separator exists, add " - "
+        if (!before.trim().endsWith('-')) {
+          insertion = ' - $tag';
+        } else if (before.trim().endsWith('-') && !before.endsWith(' ')) {
+          // If ends with '-' but no space, add space
+          insertion = ' $tag';
+        }
+      }
+
+      final newText = text.replaceRange(start, end, insertion);
+      controller.value = TextEditingValue(
+        text: newText,
+        selection: TextSelection.collapsed(offset: start + insertion.length),
+      );
+    }
+
     showModalBottomSheet(
-      context: context, isScrollControlled: true,
-      backgroundColor: colorScheme.surfaceContainerHigh,
-      shape: const RoundedRectangleBorder(borderRadius: BorderRadius.vertical(top: Radius.circular(28))),
+      context: context,
+      isScrollControlled: true,
+      backgroundColor: colorScheme.surface,
+      shape: const RoundedRectangleBorder(
+        borderRadius: BorderRadius.vertical(top: Radius.circular(28)),
+      ),
       builder: (context) => Padding(
-        padding: EdgeInsets.fromLTRB(24, 24, 24, MediaQuery.of(context).viewInsets.bottom + 24),
-        child: Column(mainAxisSize: MainAxisSize.min, crossAxisAlignment: CrossAxisAlignment.start, children: [
-          Text('Filename Format', style: Theme.of(context).textTheme.titleLarge?.copyWith(fontWeight: FontWeight.bold)),
-          const SizedBox(height: 16),
-          TextField(controller: controller, decoration: const InputDecoration(hintText: '{artist} - {title}'), autofocus: true),
-          const SizedBox(height: 16),
-          Text('Available: {title}, {artist}, {album}, {track}, {year}, {disc}',
-            style: Theme.of(context).textTheme.bodySmall?.copyWith(color: colorScheme.onSurfaceVariant)),
-          const SizedBox(height: 24),
-          Row(mainAxisAlignment: MainAxisAlignment.end, children: [
-            TextButton(onPressed: () => Navigator.pop(context), child: const Text('Cancel')),
-            const SizedBox(width: 8),
-            FilledButton(onPressed: () { ref.read(settingsProvider.notifier).setFilenameFormat(controller.text); Navigator.pop(context); }, child: const Text('Save')),
-          ]),
-        ]),
+        padding: EdgeInsets.only(
+          bottom: MediaQuery.of(context).viewInsets.bottom,
+        ),
+        child: SingleChildScrollView(
+          child: SafeArea(
+            child: Padding(
+              padding: const EdgeInsets.all(24),
+              child: Column(
+                mainAxisSize: MainAxisSize.min,
+                crossAxisAlignment: CrossAxisAlignment.stretch,
+                children: [
+                  Center(
+                    child: Container(
+                      width: 32,
+                      height: 4,
+                      margin: const EdgeInsets.only(bottom: 24),
+                      decoration: BoxDecoration(
+                        color: colorScheme.outlineVariant,
+                        borderRadius: BorderRadius.circular(2),
+                      ),
+                    ),
+                  ),
+                  Text(
+                    'Filename Format',
+                    style: Theme.of(context).textTheme.headlineSmall?.copyWith(
+                      fontWeight: FontWeight.bold,
+                    ),
+                    textAlign: TextAlign.center,
+                  ),
+                  const SizedBox(height: 8),
+                  Text(
+                    'Customize how your files are named.',
+                    style: Theme.of(context).textTheme.bodyMedium?.copyWith(
+                      color: colorScheme.onSurfaceVariant,
+                    ),
+                    textAlign: TextAlign.center,
+                  ),
+                  const SizedBox(height: 24),
+
+                  TextField(
+                    controller: controller,
+                    decoration: InputDecoration(
+                      hintText: '{artist} - {title}',
+                      filled: true,
+                      fillColor: colorScheme.surfaceContainerHighest.withValues(
+                        alpha: 0.3,
+                      ),
+                      border: OutlineInputBorder(
+                        borderRadius: BorderRadius.circular(16),
+                        borderSide: BorderSide.none,
+                      ),
+                    ),
+                    autofocus: true,
+                  ),
+                  const SizedBox(height: 24),
+
+                  Text(
+                    'Tap to insert tag:',
+                    style: Theme.of(context).textTheme.titleSmall?.copyWith(
+                      fontWeight: FontWeight.bold,
+                    ),
+                  ),
+                  const SizedBox(height: 12),
+                  Wrap(
+                    spacing: 8,
+                    runSpacing: 8,
+                    children: tags.map((tag) {
+                      return ActionChip(
+                        label: Text(tag),
+                        onPressed: () => insertTag(tag),
+                        backgroundColor: colorScheme.surfaceContainerHighest
+                            .withValues(alpha: 0.5),
+                        side: BorderSide.none,
+                        shape: RoundedRectangleBorder(
+                          borderRadius: BorderRadius.circular(12),
+                        ),
+                        labelStyle: TextStyle(
+                          color: colorScheme.onSurface,
+                          fontWeight: FontWeight.w500,
+                        ),
+                      );
+                    }).toList(),
+                  ),
+
+                  const SizedBox(height: 32),
+
+                  Row(
+                    children: [
+                      Expanded(
+                        child: TextButton(
+                          onPressed: () => Navigator.pop(context),
+                          style: TextButton.styleFrom(
+                            padding: const EdgeInsets.symmetric(vertical: 16),
+                            shape: RoundedRectangleBorder(
+                              borderRadius: BorderRadius.circular(16),
+                            ),
+                          ),
+                          child: const Text('Cancel'),
+                        ),
+                      ),
+                      const SizedBox(width: 12),
+                      Expanded(
+                        flex: 2,
+                        child: FilledButton(
+                          onPressed: () {
+                            ref
+                                .read(settingsProvider.notifier)
+                                .setFilenameFormat(controller.text);
+                            Navigator.pop(context);
+                          },
+                          style: FilledButton.styleFrom(
+                            padding: const EdgeInsets.symmetric(vertical: 16),
+                            shape: RoundedRectangleBorder(
+                              borderRadius: BorderRadius.circular(16),
+                            ),
+                          ),
+                          child: const Text('Save Format'),
+                        ),
+                      ),
+                    ],
+                  ),
+                  const SizedBox(height: 8),
+                ],
+              ),
+            ),
+          ),
+        ),
       ),
     );
   }
@@ -172,7 +405,9 @@ class DownloadSettingsPage extends ConsumerWidget {
     } else {
       // Android: Use file picker
       final result = await FilePicker.platform.getDirectoryPath();
-      if (result != null) ref.read(settingsProvider.notifier).setDownloadDirectory(result);
+      if (result != null) {
+        ref.read(settingsProvider.notifier).setDownloadDirectory(result);
+      }
     }
   }
 
@@ -181,7 +416,9 @@ class DownloadSettingsPage extends ConsumerWidget {
     showModalBottomSheet(
       context: context,
       backgroundColor: colorScheme.surfaceContainerHigh,
-      shape: const RoundedRectangleBorder(borderRadius: BorderRadius.vertical(top: Radius.circular(28))),
+      shape: const RoundedRectangleBorder(
+        borderRadius: BorderRadius.vertical(top: Radius.circular(28)),
+      ),
       builder: (ctx) => SafeArea(
         child: Column(
           mainAxisSize: MainAxisSize.min,
@@ -189,13 +426,20 @@ class DownloadSettingsPage extends ConsumerWidget {
           children: [
             Padding(
               padding: const EdgeInsets.fromLTRB(24, 24, 24, 8),
-              child: Text('Download Location', style: Theme.of(context).textTheme.titleLarge?.copyWith(fontWeight: FontWeight.bold)),
+              child: Text(
+                'Download Location',
+                style: Theme.of(
+                  context,
+                ).textTheme.titleLarge?.copyWith(fontWeight: FontWeight.bold),
+              ),
             ),
             Padding(
               padding: const EdgeInsets.fromLTRB(24, 0, 24, 16),
               child: Text(
                 'On iOS, downloads are saved to the app\'s Documents folder which is accessible via the Files app.',
-                style: Theme.of(context).textTheme.bodyMedium?.copyWith(color: colorScheme.onSurfaceVariant),
+                style: Theme.of(context).textTheme.bodyMedium?.copyWith(
+                  color: colorScheme.onSurfaceVariant,
+                ),
               ),
             ),
             ListTile(
@@ -205,7 +449,9 @@ class DownloadSettingsPage extends ConsumerWidget {
               trailing: Icon(Icons.check_circle, color: colorScheme.primary),
               onTap: () async {
                 final dir = await getApplicationDocumentsDirectory();
-                ref.read(settingsProvider.notifier).setDownloadDirectory(dir.path);
+                ref
+                    .read(settingsProvider.notifier)
+                    .setDownloadDirectory(dir.path);
                 if (ctx.mounted) Navigator.pop(ctx);
               },
             ),
@@ -218,7 +464,9 @@ class DownloadSettingsPage extends ConsumerWidget {
                 // Note: iOS requires folder to have at least one file to be selectable
                 final result = await FilePicker.platform.getDirectoryPath();
                 if (result != null) {
-                  ref.read(settingsProvider.notifier).setDownloadDirectory(result);
+                  ref
+                      .read(settingsProvider.notifier)
+                      .setDownloadDirectory(result);
                 }
               },
             ),
@@ -232,12 +480,18 @@ class DownloadSettingsPage extends ConsumerWidget {
                 ),
                 child: Row(
                   children: [
-                    Icon(Icons.info_outline, size: 20, color: colorScheme.tertiary),
+                    Icon(
+                      Icons.info_outline,
+                      size: 20,
+                      color: colorScheme.tertiary,
+                    ),
                     const SizedBox(width: 12),
                     Expanded(
                       child: Text(
                         'iOS limitation: Empty folders cannot be selected. Create a file inside first or use App Documents.',
-                        style: Theme.of(context).textTheme.bodySmall?.copyWith(color: colorScheme.onTertiaryContainer),
+                        style: Theme.of(context).textTheme.bodySmall?.copyWith(
+                          color: colorScheme.onTertiaryContainer,
+                        ),
                       ),
                     ),
                   ],
@@ -264,12 +518,18 @@ class DownloadSettingsPage extends ConsumerWidget {
     }
   }
 
-  void _showFolderOrganizationPicker(BuildContext context, WidgetRef ref, String current) {
+  void _showFolderOrganizationPicker(
+    BuildContext context,
+    WidgetRef ref,
+    String current,
+  ) {
     final colorScheme = Theme.of(context).colorScheme;
     showModalBottomSheet(
       context: context,
       backgroundColor: colorScheme.surfaceContainerHigh,
-      shape: const RoundedRectangleBorder(borderRadius: BorderRadius.vertical(top: Radius.circular(28))),
+      shape: const RoundedRectangleBorder(
+        borderRadius: BorderRadius.vertical(top: Radius.circular(28)),
+      ),
       builder: (context) => SafeArea(
         child: Column(
           mainAxisSize: MainAxisSize.min,
@@ -277,39 +537,61 @@ class DownloadSettingsPage extends ConsumerWidget {
           children: [
             Padding(
               padding: const EdgeInsets.fromLTRB(24, 24, 24, 8),
-              child: Text('Folder Organization', style: Theme.of(context).textTheme.titleLarge?.copyWith(fontWeight: FontWeight.bold)),
+              child: Text(
+                'Folder Organization',
+                style: Theme.of(
+                  context,
+                ).textTheme.titleLarge?.copyWith(fontWeight: FontWeight.bold),
+              ),
             ),
             Padding(
               padding: const EdgeInsets.fromLTRB(24, 0, 24, 16),
-              child: Text('Organize downloaded files into folders', style: Theme.of(context).textTheme.bodyMedium?.copyWith(color: colorScheme.onSurfaceVariant)),
+              child: Text(
+                'Organize downloaded files into folders',
+                style: Theme.of(context).textTheme.bodyMedium?.copyWith(
+                  color: colorScheme.onSurfaceVariant,
+                ),
+              ),
             ),
             _FolderOption(
               title: 'None',
               subtitle: 'All files in download folder',
               example: 'SpotiFLAC/Track.flac',
               isSelected: current == 'none',
-              onTap: () { ref.read(settingsProvider.notifier).setFolderOrganization('none'); Navigator.pop(context); },
+              onTap: () {
+                ref.read(settingsProvider.notifier).setFolderOrganization('none');
+                Navigator.pop(context);
+              },
             ),
             _FolderOption(
               title: 'By Artist',
               subtitle: 'Separate folder for each artist',
               example: 'SpotiFLAC/Artist Name/Track.flac',
               isSelected: current == 'artist',
-              onTap: () { ref.read(settingsProvider.notifier).setFolderOrganization('artist'); Navigator.pop(context); },
+              onTap: () {
+                ref.read(settingsProvider.notifier).setFolderOrganization('artist');
+                Navigator.pop(context);
+              },
             ),
             _FolderOption(
               title: 'By Album',
               subtitle: 'Separate folder for each album',
               example: 'SpotiFLAC/Album Name/Track.flac',
               isSelected: current == 'album',
-              onTap: () { ref.read(settingsProvider.notifier).setFolderOrganization('album'); Navigator.pop(context); },
+              onTap: () {
+                ref.read(settingsProvider.notifier).setFolderOrganization('album');
+                Navigator.pop(context);
+              },
             ),
             _FolderOption(
               title: 'By Artist & Album',
               subtitle: 'Nested folders for artist and album',
               example: 'SpotiFLAC/Artist/Album/Track.flac',
               isSelected: current == 'artist_album',
-              onTap: () { ref.read(settingsProvider.notifier).setFolderOrganization('artist_album'); Navigator.pop(context); },
+              onTap: () {
+                ref.read(settingsProvider.notifier).setFolderOrganization('artist_album');
+                Navigator.pop(context);
+              },
             ),
             const SizedBox(height: 16),
           ],
@@ -319,22 +601,86 @@ class DownloadSettingsPage extends ConsumerWidget {
   }
 }
 
-class _ServiceSelector extends StatelessWidget {
+class _ServiceSelector extends ConsumerWidget {
   final String currentService;
   final ValueChanged<String> onChanged;
-  const _ServiceSelector({required this.currentService, required this.onChanged});
+  const _ServiceSelector({
+    required this.currentService,
+    required this.onChanged,
+  });
 
   @override
-  Widget build(BuildContext context) {
+  Widget build(BuildContext context, WidgetRef ref) {
+    final extState = ref.watch(extensionProvider);
+    
+    // Get enabled extension download providers
+    final extensionProviders = extState.extensions
+        .where((e) => e.enabled && e.hasDownloadProvider)
+        .toList();
+    
+    // Check if current service is an extension that's now disabled
+    final isExtensionService = !['tidal', 'qobuz', 'amazon'].contains(currentService);
+    final isCurrentExtensionEnabled = isExtensionService 
+        ? extensionProviders.any((e) => e.id == currentService)
+        : true;
+    
+    // If current extension is disabled, show it as not selected
+    final effectiveService = isCurrentExtensionEnabled ? currentService : '';
+    
     return Padding(
       padding: const EdgeInsets.all(12),
-      child: Row(children: [
-        _ServiceChip(icon: Icons.music_note, label: 'Tidal', isSelected: currentService == 'tidal', onTap: () => onChanged('tidal')),
-        const SizedBox(width: 8),
-        _ServiceChip(icon: Icons.album, label: 'Qobuz', isSelected: currentService == 'qobuz', onTap: () => onChanged('qobuz')),
-        const SizedBox(width: 8),
-        _ServiceChip(icon: Icons.shopping_bag, label: 'Amazon', isSelected: currentService == 'amazon', onTap: () => onChanged('amazon')),
-      ]),
+      child: Column(
+        children: [
+          Row(
+            children: [
+              _ServiceChip(
+                icon: Icons.music_note,
+                label: 'Tidal',
+                isSelected: effectiveService == 'tidal',
+                onTap: () => onChanged('tidal'),
+              ),
+              const SizedBox(width: 8),
+              _ServiceChip(
+                icon: Icons.album,
+                label: 'Qobuz',
+                isSelected: effectiveService == 'qobuz',
+                onTap: () => onChanged('qobuz'),
+              ),
+              const SizedBox(width: 8),
+              _ServiceChip(
+                icon: Icons.shopping_bag,
+                label: 'Amazon',
+                isSelected: effectiveService == 'amazon',
+                onTap: () => onChanged('amazon'),
+              ),
+            ],
+          ),
+          // Show extension download providers if any
+          if (extensionProviders.isNotEmpty) ...[
+            const SizedBox(height: 8),
+            Row(
+              children: [
+                for (int i = 0; i < extensionProviders.length; i++) ...[
+                  if (i > 0) const SizedBox(width: 8),
+                  Expanded(
+                    child: _ServiceChip(
+                      icon: Icons.extension,
+                      label: extensionProviders[i].displayName,
+                      isSelected: effectiveService == extensionProviders[i].id,
+                      onTap: () => onChanged(extensionProviders[i].id),
+                    ),
+                  ),
+                ],
+                // Fill remaining space if less than 3 extensions
+                for (int i = extensionProviders.length; i < 3; i++) ...[
+                  const SizedBox(width: 8),
+                  const Expanded(child: SizedBox()),
+                ],
+              ],
+            ),
+          ],
+        ],
+      ),
     );
   }
 }
@@ -344,17 +690,25 @@ class _ServiceChip extends StatelessWidget {
   final String label;
   final bool isSelected;
   final VoidCallback onTap;
-  const _ServiceChip({required this.icon, required this.label, required this.isSelected, required this.onTap});
+  const _ServiceChip({
+    required this.icon,
+    required this.label,
+    required this.isSelected,
+    required this.onTap,
+  });
 
   @override
   Widget build(BuildContext context) {
     final colorScheme = Theme.of(context).colorScheme;
     final isDark = Theme.of(context).brightness == Brightness.dark;
-    
-    final unselectedColor = isDark 
-        ? Color.alphaBlend(Colors.white.withValues(alpha: 0.05), colorScheme.surface)
+
+    final unselectedColor = isDark
+        ? Color.alphaBlend(
+            Colors.white.withValues(alpha: 0.05),
+            colorScheme.surface,
+          )
         : colorScheme.surfaceContainerHigh;
-    
+
     return Expanded(
       child: Material(
         color: isSelected ? colorScheme.primaryContainer : unselectedColor,
@@ -364,13 +718,29 @@ class _ServiceChip extends StatelessWidget {
           borderRadius: BorderRadius.circular(12),
           child: Padding(
             padding: const EdgeInsets.symmetric(vertical: 14),
-            child: Column(children: [
-              Icon(icon, color: isSelected ? colorScheme.onPrimaryContainer : colorScheme.onSurfaceVariant),
-              const SizedBox(height: 6),
-              Text(label, style: TextStyle(fontSize: 12,
-                fontWeight: isSelected ? FontWeight.w600 : FontWeight.normal,
-                color: isSelected ? colorScheme.onPrimaryContainer : colorScheme.onSurfaceVariant)),
-            ]),
+            child: Column(
+              children: [
+                Icon(
+                  icon,
+                  color: isSelected
+                      ? colorScheme.onPrimaryContainer
+                      : colorScheme.onSurfaceVariant,
+                ),
+                const SizedBox(height: 6),
+                Text(
+                  label,
+                  style: TextStyle(
+                    fontSize: 12,
+                    fontWeight: isSelected
+                        ? FontWeight.w600
+                        : FontWeight.normal,
+                    color: isSelected
+                        ? colorScheme.onPrimaryContainer
+                        : colorScheme.onSurfaceVariant,
+                  ),
+                ),
+              ],
+            ),
           ),
         ),
       ),
@@ -384,7 +754,13 @@ class _QualityOption extends StatelessWidget {
   final bool isSelected;
   final VoidCallback onTap;
   final bool showDivider;
-  const _QualityOption({required this.title, required this.subtitle, required this.isSelected, required this.onTap, this.showDivider = true});
+  const _QualityOption({
+    required this.title,
+    required this.subtitle,
+    required this.isSelected,
+    required this.onTap,
+    this.showDivider = true,
+  });
 
   @override
   Widget build(BuildContext context) {
@@ -404,11 +780,16 @@ class _QualityOption extends StatelessWidget {
                     children: [
                       Text(title, style: Theme.of(context).textTheme.bodyLarge),
                       const SizedBox(height: 2),
-                      Text(subtitle, style: Theme.of(context).textTheme.bodyMedium?.copyWith(color: colorScheme.onSurfaceVariant)),
+                      Text(
+                        subtitle,
+                        style: Theme.of(context).textTheme.bodyMedium?.copyWith(
+                          color: colorScheme.onSurfaceVariant,
+                        ),
+                      ),
                     ],
                   ),
                 ),
-                isSelected 
+                isSelected
                     ? Icon(Icons.check_circle, color: colorScheme.primary)
                     : Icon(Icons.circle_outlined, color: colorScheme.outline),
               ],
@@ -434,7 +815,13 @@ class _FolderOption extends StatelessWidget {
   final String example;
   final bool isSelected;
   final VoidCallback onTap;
-  const _FolderOption({required this.title, required this.subtitle, required this.example, required this.isSelected, required this.onTap});
+  const _FolderOption({
+    required this.title,
+    required this.subtitle,
+    required this.example,
+    required this.isSelected,
+    required this.onTap,
+  });
 
   @override
   Widget build(BuildContext context) {
@@ -447,10 +834,19 @@ class _FolderOption extends StatelessWidget {
         children: [
           Text(subtitle),
           const SizedBox(height: 4),
-          Text(example, style: TextStyle(fontFamily: 'monospace', fontSize: 11, color: colorScheme.primary)),
+          Text(
+            example,
+            style: TextStyle(
+              fontFamily: 'monospace',
+              fontSize: 11,
+              color: colorScheme.primary,
+            ),
+          ),
         ],
       ),
-      trailing: isSelected ? Icon(Icons.check_circle, color: colorScheme.primary) : Icon(Icons.circle_outlined, color: colorScheme.outline),
+      trailing: isSelected
+          ? Icon(Icons.check_circle, color: colorScheme.primary)
+          : Icon(Icons.circle_outlined, color: colorScheme.outline),
       onTap: onTap,
     );
   }