fix: use HTML parse mode for Telegram notifications to handle special chars

fix: discography download context issue after quality picker closes
feat: add missing platform bridge functions for batch duplicate check and cross-platform IDs
2026-07-03 03:15:51 +02:00 · 2026-01-21 13:30:35 +07:00 · 2026-01-21 13:04:48 +07:00 · 2026-01-21 12:22:46 +07:00 · 2026-01-21 12:07:50 +07:00 · 2026-01-21 10:28:17 +07:00
200 changed files with 118430 additions and 5255 deletions
@@ -0,0 +1,4 @@
 github: zarzet
 ko_fi: zarzet
 buy_me_a_coffee: zarzet
@@ -0,0 +1,123 @@
 name: Bug Report
 description: Report a bug or unexpected behavior
 title: "[Bug]: "
 labels: ["bug"]
 body:
  - type: markdown
    attributes:
      value: |
        Thanks for taking the time to report a bug! Please fill out the form below.
  - type: checkboxes
    id: checklist
    attributes:
      label: Checklist
      description: Please confirm the following before submitting
      options:
        - label: I have searched existing issues and this bug hasn't been reported yet
          required: true
        - label: I am using the latest version of SpotiFLAC (Stable Version)
          required: true
  - type: textarea
    id: description
    attributes:
      label: Bug Description
      description: A clear and concise description of what the bug is
      placeholder: Describe the bug...
    validations:
      required: true
  - type: textarea
    id: steps
    attributes:
      label: Steps to Reproduce
      description: Steps to reproduce the behavior
      placeholder: |
        1. Go to '...'
        2. Click on '...'
        3. See error
    validations:
      required: true
  - type: textarea
    id: expected
    attributes:
      label: Expected Behavior
      description: What did you expect to happen?
      placeholder: Describe what you expected...
    validations:
      required: true
  - type: textarea
    id: actual
    attributes:
      label: Actual Behavior
      description: What actually happened?
      placeholder: Describe what actually happened...
    validations:
      required: true
  - type: input
    id: version
    attributes:
      label: App Version
      description: Which version of SpotiFLAC are you using? (Check in Settings > About)
      placeholder: "e.g., v2.2.0"
    validations:
      required: true
  - type: dropdown
    id: platform
    attributes:
      label: Platform
      description: Which platform are you using?
      options:
        - Android
        - iOS
    validations:
      required: true
  - type: input
    id: device
    attributes:
      label: Device & OS Version
      description: What device and OS version are you using?
      placeholder: "e.g., Samsung Galaxy S24, Android 14"
    validations:
      required: true
  - type: dropdown
    id: download-service
    attributes:
      label: Download Service
      description: Which download service were you using when the bug occurred?
      options:
        - Tidal
        - Qobuz
        - Amazon Music
        - Deezer (search only)
        - Not applicable
    validations:
      required: true
  - type: textarea
    id: logs
    attributes:
      label: Logs / Screenshots
      description: |
        If applicable, add logs or screenshots to help explain your problem.
        **To get logs:**
        1. Go to Settings > Options > Detailed Logging (turn ON)
        2. Reproduce the bug
        3. Go to Settings > Logs
        4. Tap Share button to export logs
      placeholder: Paste logs or drag & drop screenshots here...
  - type: textarea
    id: additional
    attributes:
      label: Additional Context
      description: Any other context about the problem
      placeholder: Add any other context...
@@ -0,0 +1,8 @@
 blank_issues_enabled: false
 contact_links:
  - name: README
    url: https://github.com/zarzet/SpotiFLAC-Mobile#readme
    about: Check the README for setup instructions and FAQ
  - name: Extension Development Guide
    url: https://zarz.moe/docs
    about: Documentation for building SpotiFLAC extensions
@@ -0,0 +1,111 @@
 name: Download Issue
 description: Report issues with downloading specific tracks or albums
 title: "[Download]: "
 labels: ["download-issue"]
 body:
  - type: markdown
    attributes:
      value: |
        Having trouble downloading a specific track or album? Please provide details below.
  - type: checkboxes
    id: checklist
    attributes:
      label: Checklist
      description: Please confirm the following before submitting
      options:
        - label: I have tried downloading with a different service (Tidal/Qobuz/Amazon)
          required: true
        - label: I am using the latest version of SpotiFLAC (Stable Version)
          required: true
  - type: dropdown
    id: issue-type
    attributes:
      label: Issue Type
      description: What kind of download issue are you experiencing?
      options:
        - Track not found on service
        - Wrong track downloaded
        - Download fails/errors
        - Metadata incorrect
        - Audio quality issue
        - Other
    validations:
      required: true
  - type: input
    id: spotify-url
    attributes:
      label: Spotify URL
      description: The Spotify URL of the track/album you're trying to download
      placeholder: "https://open.spotify.com/track/..."
    validations:
      required: true
  - type: input
    id: track-info
    attributes:
      label: Track Info
      description: Artist name and track title
      placeholder: "Artist - Track Title"
    validations:
      required: true
  - type: dropdown
    id: download-service
    attributes:
      label: Download Service
      description: Which service did you try to download from?
      options:
        - Tidal
        - Qobuz
        - Amazon Music
        - All services
    validations:
      required: true
  - type: dropdown
    id: search-service
    attributes:
      label: Search Service
      description: Which search service are you using?
      options:
        - Spotify
        - Deezer
    validations:
      required: true
  - type: textarea
    id: description
    attributes:
      label: Description
      description: Describe the issue in detail
      placeholder: |
        What happened? What did you expect?
        If wrong track was downloaded, what track was downloaded instead?
    validations:
      required: true
  - type: input
    id: version
    attributes:
      label: App Version
      description: Which version of SpotiFLAC are you using?
      placeholder: "e.g., v2.2.0"
    validations:
      required: true
  - type: textarea
    id: screenshots
    attributes:
      label: Screenshots / Logs
      description: |
        If applicable, add screenshots or logs.
        **To get logs:**
        1. Go to Settings > Options > Detailed Logging (turn ON)
        2. Try downloading the track again
        3. Go to Settings > Logs
        4. Tap Share button to export logs
      placeholder: Drag & drop screenshots or paste logs here...
@@ -0,0 +1,117 @@
 name: Extension API Feature Request
 description: Request new API features or capabilities for extension development
 title: "[Extension API]: "
 labels: ["enhancement", "extension-api"]
 body:
  - type: markdown
    attributes:
      value: |
        Thanks for helping improve the SpotiFLAC Extension API! 
        This form is for extension developers who need new features or capabilities that don't exist yet.
  - type: checkboxes
    id: checklist
    attributes:
      label: Checklist
      description: Please confirm the following before submitting
      options:
        - label: I have read the [Extension Development Guide](https://github.com/zarzet/SpotiFLAC-Mobile/blob/main/docs/EXTENSION_DEVELOPMENT.md)
          required: true
        - label: I have searched existing issues and this API feature hasn't been requested yet
          required: true
  - type: textarea
    id: extension_goal
    attributes:
      label: What are you trying to build?
      description: Describe the extension or feature you're developing
      placeholder: "I'm building an extension that downloads from [service name] / provides metadata from [source]..."
    validations:
      required: true
  - type: textarea
    id: current_limitation
    attributes:
      label: Current API Limitation
      description: What's missing or limiting in the current extension API?
      placeholder: |
        The current API doesn't support:
        - [missing feature 1]
        - [missing feature 2]
        This prevents me from...
    validations:
      required: true
  - type: textarea
    id: proposed_api
    attributes:
      label: Proposed API / Feature
      description: Describe the API or feature you'd like to see added
      placeholder: |
        I would like to have:
        - A new function `api.newFeature()` that does X
        - A new manifest field `newOption` that enables Y
        - Access to Z capability...
    validations:
      required: true
  - type: textarea
    id: use_case
    attributes:
      label: Use Case Example
      description: Provide a code example of how you would use this feature
      placeholder: |
        ```javascript
        // Example usage in extension code
        function download(request, progressCallback) {
          const result = api.proposedFeature(params);
          // ...
        }
        ```
    validations:
      required: false
  - type: dropdown
    id: api_category
    attributes:
      label: API Category
      description: What category does this feature fall under?
      options:
        - HTTP/Network API
        - File System API
        - Storage API
        - FFmpeg/Audio Processing
        - Manifest Options
        - Runtime Functions
        - UI Integration
        - Authentication
        - Other
    validations:
      required: true
  - type: dropdown
    id: priority
    attributes:
      label: How critical is this for your extension?
      options:
        - Blocker - Cannot build my extension without this
        - High - Major functionality depends on this
        - Medium - Would significantly improve my extension
        - Low - Nice to have
    validations:
      required: true
  - type: textarea
    id: workaround
    attributes:
      label: Current Workaround
      description: Are you using any workaround currently? If so, describe it.
      placeholder: "Currently I'm working around this by..."
  - type: textarea
    id: additional
    attributes:
      label: Additional Context
      description: Add any other context, links to similar APIs, or examples from other platforms
      placeholder: "Similar feature in other platforms: ..."
@@ -0,0 +1,66 @@
 name: Feature Request
 description: Suggest a new feature or improvement
 title: "[Feature]: "
 labels: ["enhancement"]
 body:
  - type: markdown
    attributes:
      value: |
        Thanks for suggesting a feature! Please fill out the form below.
  - type: checkboxes
    id: checklist
    attributes:
      label: Checklist
      description: Please confirm the following before submitting
      options:
        - label: I have searched existing issues and this feature hasn't been requested yet
          required: true
  - type: textarea
    id: problem
    attributes:
      label: Problem / Motivation
      description: Is your feature request related to a problem? Please describe.
      placeholder: "A clear description of what the problem is. Ex: I'm always frustrated when..."
    validations:
      required: true
  - type: textarea
    id: solution
    attributes:
      label: Proposed Solution
      description: Describe the solution you'd like
      placeholder: A clear description of what you want to happen...
    validations:
      required: true
  - type: textarea
    id: alternatives
    attributes:
      label: Alternatives Considered
      description: Describe any alternative solutions or features you've considered
      placeholder: Other approaches you've thought about...
  - type: dropdown
    id: category
    attributes:
      label: Category
      description: What category does this feature fall under?
      options:
        - UI/UX Improvement
        - Download Feature
        - New Service Integration
        - Metadata/Tagging
        - Performance
        - Settings/Configuration
        - Other
    validations:
      required: true
  - type: textarea
    id: additional
    attributes:
      label: Additional Context
      description: Add any other context, mockups, or screenshots about the feature request
      placeholder: Add any other context or screenshots...
@@ -3,13 +3,13 @@ name: Release
 on:
  push:
    tags:
-      - 'v*'
+      - "v*"
  workflow_dispatch:
    inputs:
      version:
-        description: 'Version tag (e.g., v1.0.0)'
+        description: "Version tag (e.g., v1.0.0)"
        required: true
-        default: 'v1.0.0'
+        default: "v1.0.0"
 jobs:
  # Get version first (quick job)
@@ -28,7 +28,7 @@ jobs:
            VERSION="${GITHUB_REF#refs/tags/}"
          fi
          echo "version=$VERSION" >> $GITHUB_OUTPUT
-          
+
          # Check if version contains -preview, -beta, -rc, or -alpha (NOT -hotfix)
          VERSION_LOWER=$(echo "$VERSION" | tr '[:upper:]' '[:lower:]')
          if [[ "$VERSION_LOWER" == *"-preview"* ]] || [[ "$VERSION_LOWER" == *"-beta"* ]] || [[ "$VERSION_LOWER" == *"-rc"* ]] || [[ "$VERSION_LOWER" == *"-alpha"* ]]; then
@@ -43,7 +43,7 @@ jobs:
  build-android:
    runs-on: ubuntu-latest
    needs: get-version
-    
+
    steps:
      - name: Free disk space
        run: |
@@ -65,13 +65,13 @@ jobs:
      - name: Setup Java
        uses: actions/setup-java@v4
        with:
-          distribution: 'temurin'
+          distribution: "temurin"
-          java-version: '17'
+          java-version: "17"
      - name: Setup Go
        uses: actions/setup-go@v5
        with:
-          go-version: '1.21'
+          go-version: "1.21"
          cache-dependency-path: go_backend/go.sum
      # Cache Gradle for faster builds
@@ -85,7 +85,20 @@ jobs:
          restore-keys: gradle-${{ runner.os }}-
      - name: Install Android SDK & NDK
-        uses: android-actions/setup-android@v3
+        run: |
          # Use pre-installed Android SDK on GitHub runners
          echo "ANDROID_HOME=$ANDROID_HOME"
          echo "ANDROID_SDK_ROOT=$ANDROID_SDK_ROOT"
          # Accept licenses
          yes | $ANDROID_HOME/cmdline-tools/latest/bin/sdkmanager --licenses || true
          # Install NDK r27d LTS (required for 16KB page size support on Android 15+)
          # Platform android-36 and build-tools 36.0.0 for targetSdk 36 (Android 16)
          $ANDROID_HOME/cmdline-tools/latest/bin/sdkmanager "ndk;27.3.13750724" "platforms;android-36" "build-tools;36.0.0"
          # Set NDK path
          echo "ANDROID_NDK_HOME=$ANDROID_HOME/ndk/27.3.13750724" >> $GITHUB_ENV
      - name: Install gomobile
        run: |
@@ -103,7 +116,7 @@ jobs:
      - name: Setup Flutter
        uses: subosito/flutter-action@v2
        with:
-          channel: 'stable'
+          channel: "stable"
          cache: true
      - name: Get Flutter dependencies
@@ -113,7 +126,14 @@ jobs:
        run: dart run flutter_launcher_icons
      - name: Build APK (Release - unsigned)
-        run: flutter build apk --release --split-per-abi
+        run: |
          flutter build apk --release --split-per-abi || true
          # Verify APKs were created
          ls -la build/app/outputs/flutter-apk/
          if [ ! -f "build/app/outputs/flutter-apk/app-arm64-v8a-release.apk" ]; then
            echo "ERROR: APK not found!"
            exit 1
          fi
      - name: Sign APKs
        uses: r0adkll/sign-android-release@v1
@@ -125,7 +145,7 @@ jobs:
          keyStorePassword: ${{ secrets.KEYSTORE_PASSWORD }}
          keyPassword: ${{ secrets.KEY_PASSWORD }}
        env:
-          BUILD_TOOLS_VERSION: "34.0.0"
+          BUILD_TOOLS_VERSION: "36.0.0"
      - name: Rename APKs
        run: |
@@ -145,8 +165,8 @@ jobs:
  build-ios:
    runs-on: macos-latest
-    needs: get-version  # Only depends on version, NOT android build!
+    needs: get-version # Only depends on version, NOT android build!
-    
+
    steps:
      - name: Checkout repository
        uses: actions/checkout@v4
@@ -154,7 +174,7 @@ jobs:
      - name: Setup Go
        uses: actions/setup-go@v5
        with:
-          go-version: '1.21'
+          go-version: "1.21"
          cache-dependency-path: go_backend/go.sum
      # Cache CocoaPods
@@ -182,53 +202,70 @@ 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)
      - name: Use iOS pubspec with FFmpeg plugin
        run: |
          cp pubspec.yaml pubspec_android_backup.yaml
          cp pubspec_ios.yaml pubspec.yaml
          echo "Swapped to iOS pubspec with ffmpeg_kit_flutter"
      # Swap FFmpeg service for iOS
      - name: Use iOS FFmpeg service
        run: |
          cp lib/services/ffmpeg_service.dart lib/services/ffmpeg_service_android.dart
          cp build_assets/ffmpeg_service_ios.dart lib/services/ffmpeg_service.dart
          # Update class name in the swapped file
          sed -i '' 's/FFmpegServiceIOS/FFmpegService/g' lib/services/ffmpeg_service.dart
          sed -i '' 's/FFmpegResultIOS/FFmpegResult/g' lib/services/ffmpeg_service.dart
          echo "Swapped to iOS FFmpeg service"
      - name: Get Flutter dependencies
        run: flutter pub get
@@ -236,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:
@@ -259,7 +322,7 @@ jobs:
    needs: [get-version, build-android, build-ios]
    permissions:
      contents: write
-    
+
    steps:
      - name: Checkout repository
        uses: actions/checkout@v4
@@ -269,21 +332,23 @@ 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"
            CHANGELOG="See CHANGELOG.md for details."
          else
            echo "Found changelog content"
            # Remove trailing --- separator if present (CHANGELOG uses --- between versions)
            CHANGELOG=$(echo "$CHANGELOG" | sed '/^---$/d')
          fi
-          
+
          # Save to file for multiline support
          echo "$CHANGELOG" > /tmp/changelog.txt
          echo "Extracted changelog:"
@@ -305,32 +370,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
@@ -345,3 +412,125 @@ jobs:
          prerelease: ${{ needs.get-version.outputs.is_prerelease == 'true' }}
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
  notify-telegram:
    runs-on: ubuntu-latest
    needs: [get-version, create-release]
    if: ${{ needs.get-version.outputs.is_prerelease != 'true' }}
    steps:
      - name: Checkout repository
        uses: actions/checkout@v4
      - name: Download Android APK
        uses: actions/download-artifact@v4
        with:
          name: android-apk
          path: ./release
      - name: Download iOS IPA
        uses: actions/download-artifact@v4
        with:
          name: ios-ipa
          path: ./release
      - name: Extract changelog for version
        id: changelog
        run: |
          VERSION=${{ needs.get-version.outputs.version }}
          VERSION_NUM=${VERSION#v}
          # Extract changelog, limit to ~2500 chars for Telegram (4096 limit minus message overhead)
          FULL_CHANGELOG=$(sed -n "/^## \[$VERSION_NUM\]/,/^## \[/{ /^## \[$VERSION_NUM\]/d; /^## \[/d; p; }" CHANGELOG.md | sed '/^---$/d')
          if [ -z "$FULL_CHANGELOG" ]; then
            CHANGELOG="See release notes on GitHub for details."
          else
            # Convert GitHub Markdown to Telegram HTML:
            # - **text** → <b>text</b>
            # - `code` → <code>code</code>
            # - ### Header → <b>Header</b>
            # - Escape HTML special chars first
            CHANGELOG=$(echo "$FULL_CHANGELOG" | \
              sed 's/&/\&amp;/g' | \
              sed 's/</\&lt;/g' | \
              sed 's/>/\&gt;/g' | \
              sed 's/`\([^`]*\)`/<code>\1<\/code>/g' | \
              sed 's/\*\*\([^*]*\)\*\*/<b>\1<\/b>/g' | \
              sed 's/^### \(.*\)$/<b>\1<\/b>/g' | \
              sed 's/^## \(.*\)$/<b>\1<\/b>/g' | \
              sed 's/^- /• /g' | \
              sed 's/^  - /  ◦ /g')
            # Take first 2500 characters, then cut at last complete line
            CHANGELOG=$(echo "$CHANGELOG" | head -c 2500 | sed '$d')
            # Check if truncated
            FULL_LEN=${#FULL_CHANGELOG}
            if [ $FULL_LEN -gt 2500 ]; then
              CHANGELOG="${CHANGELOG}"$'\n\n... (see full changelog on GitHub)'
            fi
          fi
          echo "$CHANGELOG" > /tmp/changelog.txt
      - name: Send to Telegram Channel
        env:
          TELEGRAM_BOT_TOKEN: ${{ secrets.TELEGRAM_BOT_TOKEN }}
          TELEGRAM_CHANNEL_ID: ${{ secrets.TELEGRAM_CHANNEL_ID }}
        run: |
          VERSION=${{ needs.get-version.outputs.version }}
          CHANGELOG=$(cat /tmp/changelog.txt)
          # Find APK files
          ARM64_APK=$(find ./release -name "*arm64*.apk" | head -1)
          ARM32_APK=$(find ./release -name "*arm32*.apk" | head -1)
          # Prepare message with changelog (HTML format)
          printf '%s\n' \
            "<b>SpotiFLAC Mobile ${VERSION} Released!</b>" \
            "" \
            "<b>What's New:</b>" \
            "${CHANGELOG}" \
            "" \
            "<a href=\"https://github.com/${{ github.repository }}/releases/tag/${VERSION}\">View Release Notes</a>" \
            > /tmp/telegram_message.txt
          MESSAGE=$(cat /tmp/telegram_message.txt)
          # Send message first (using HTML parse mode)
          curl -s -X POST "https://api.telegram.org/bot${TELEGRAM_BOT_TOKEN}/sendMessage" \
            -d chat_id="${TELEGRAM_CHANNEL_ID}" \
            -d text="${MESSAGE}" \
            -d parse_mode="HTML" \
            -d disable_web_page_preview="true"
          # Upload arm64 APK to channel
          if [ -f "$ARM64_APK" ]; then
            echo "Uploading arm64 APK to Telegram..."
            curl -s -X POST "https://api.telegram.org/bot${TELEGRAM_BOT_TOKEN}/sendDocument" \
              -F chat_id="${TELEGRAM_CHANNEL_ID}" \
              -F document=@"${ARM64_APK}" \
              -F caption="SpotiFLAC ${VERSION} - arm64 (recommended)"
          fi
          # Upload arm32 APK to channel
          if [ -f "$ARM32_APK" ]; then
            echo "Uploading arm32 APK to Telegram..."
            curl -s -X POST "https://api.telegram.org/bot${TELEGRAM_BOT_TOKEN}/sendDocument" \
              -F chat_id="${TELEGRAM_CHANNEL_ID}" \
              -F document=@"${ARM32_APK}" \
              -F caption="SpotiFLAC ${VERSION} - arm32"
          fi
          # Upload iOS IPA to channel
          IOS_IPA=$(find ./release -name "*ios*.ipa" | head -1)
          if [ -f "$IOS_IPA" ]; then
            echo "Uploading iOS IPA to Telegram..."
            curl -s -X POST "https://api.telegram.org/bot${TELEGRAM_BOT_TOKEN}/sendDocument" \
              -F chat_id="${TELEGRAM_CHANNEL_ID}" \
              -F document=@"${IOS_IPA}" \
              -F caption="SpotiFLAC ${VERSION} - iOS (unsigned, sideload required)"
          fi
          echo "Telegram notification sent!"
@@ -6,6 +6,8 @@ Thumbs.db
 .idea/
 .vscode/
 *.iml
 .cursorignore
 .cursorrules
 # Kiro specs (development only)
 .kiro/
@@ -13,8 +15,8 @@ Thumbs.db
 # Reference folder (development only)
 referensi/
-# Development notes
+# Documentation (development only, published separately)
-COMPARISON_PC_vs_ANDROID.md
+docs/
 # Old spotiflac_android folder (moved to root)
 spotiflac_android/
@@ -38,7 +40,7 @@ go_backend/*.xcframework/
 # Android
 android/.gradle/
-android/app/libs/
+android/app/libs/gobackend.aar
 android/local.properties
 android/*.iml
 android/key.properties
@@ -52,3 +54,21 @@ ios/Pods/
 ios/.symlinks/
 ios/Flutter/Flutter.framework/
 ios/Flutter/Flutter.podspec
 android/app/libs/gobackend-sources.jar
 # Extension folder
 extension/
 # Agent instructions
 AGENTS.md
 # Temp/misc
 nul
 # Log files
 *.log
 hs_err_*.log
 flutter_*.log
 # Development tools
 tool/
@@ -1,482 +1,400 @@
 # Changelog
-## [2.0.6] - 2026-01-05
+## [3.2.0] - 2026-01-22
-### Fixed
+> **Note:** Starting from v3.2.0, changelogs will be concise.
 - **Duration Display Bug**: Fixed duration showing incorrect values like "4135:53" instead of "4:14"
  - `duration_ms` (milliseconds) was being stored directly without conversion to seconds
  - Now properly converts milliseconds to seconds before display
 - **Audio Quality from File**: Quality info (bit depth/sample rate) now read from actual FLAC file instead of trusting API
  - More accurate quality display for all services (Tidal, Qobuz, Amazon)
  - Also reads quality from existing files when skipping duplicates
 - **Artist Verification for Downloads**: Added artist name verification to prevent downloading wrong tracks
  - Verifies artist matches between Spotify metadata and streaming service
  - Handles different scripts (Japanese/Chinese vs Latin) as same artist with different transliteration
  - Applied to Tidal, Qobuz, and Amazon downloads
 - **Metadata Case-Sensitivity**: Fixed FLAC metadata not being properly overwritten when downloaded file has lowercase tags
  - Now uses case-insensitive comparison when replacing existing Vorbis comments
  - Fixes issue where Amazon downloads could have duplicate metadata tags
 - **Settings Navigation Freeze**: Fixed app freezing when navigating back from settings sub-menus on some devices
  - Added proper PopScope handling for predictive back gesture on Android 14+
-## [2.0.5] - 2026-01-05
+### Highlights
 - **Discography Download** (Highly Requested): Download entire artist discography with album selection mode
 - **Home Feed / Explore**: Personalized sections from spotify-web and ytmusic extensions
 - **SQLite History Database**: O(1) lookups, non-blocking writes
 ### Added
 - **Large Playlist Support**: Playlists with up to 1000 tracks are now fully fetched (was limited to 100)
-### Fixed
+- Discography download with options: All, Albums Only, Singles Only, or Select Albums
- **Wrong Track Download**: Fixed issue where tracks with same ISRC but different versions (e.g., short/instrumental vs full version) would download the wrong track. Now verifies duration matches before downloading (30 second tolerance).
+- Artist navigation from album screen (tap artist name)
-
+- Home feed sections with pull-to-refresh
-## [2.0.4] - 2026-01-04
+- YT Music Quick Picks swipeable UI
-
+- `gobackend.getLocalTime()` API for extensions
-### Fixed
+- Track duration in home feed items
- **Android 11 Storage Permission**: Fixed "Permission denied" error on Android 11 (API 30) devices
+- Release date badge in album info card
  - Added `MANAGE_EXTERNAL_STORAGE` permission for Android 11-12
  - Shows explanation dialog before opening system settings
 ## [2.0.3] - 2026-01-03
 ### Added
 - **Custom Spotify API Credentials**: Set your own Spotify Client ID and Secret in Settings > Options to avoid rate limiting
  - Toggle to enable/disable custom credentials without deleting them
  - Material Expressive 3 bottom sheet UI for entering credentials
 - **Keyboard Dismiss on Scroll**: Keyboard now automatically dismisses when scrolling search results
 - **Rate Limit Error UI**: Shows friendly error card when API rate limit (429) is hit on Home, Artist, and Album screens
 ### Changed
 - **Search on Enter Only**: Removed auto-search debounce, now only searches when pressing Enter key (saves API calls)
 ### Fixed
 - **Download Cancel**: Fixed cancelled downloads still completing in background and appearing in history. Cancelled files are now properly deleted.
 - **Search Keyboard Dismiss**: Fixed keyboard randomly dismissing and navigating back when starting to search
 - **Back Button During Search**: Back button now properly dismisses keyboard first before clearing search
 - **Search Error Navigation**: Fixed pressing Enter during search (when loading or error) navigating back to home instead of staying on search screen
 - **Duplicate Search on Enter**: Enter key no longer triggers duplicate search if results already loaded
 ## [2.0.2] - 2026-01-03
 ### Added
 - **Actual Quality Display**: Shows real audio quality (bit depth/sample rate) after download
  - Quality badge on download history items (e.g., "24-bit", "16-bit")
  - Full quality info in Track Metadata screen (e.g., "24-bit/96kHz")
  - Tertiary color highlight for Hi-Res (24-bit) downloads
 - **Quality Disclaimer**: Added note in quality picker explaining that actual quality depends on track availability
 - **Instant Lyrics Loading**: Lyrics now load from embedded file first (instant) before falling back to internet fetch
 ### Fixed
 - **Fallback Service Display**: Fixed download history showing wrong service when fallback occurs (e.g., showing "TIDAL" when actually downloaded from "QOBUZ")
 - **Open in Spotify**: Fixed "Open in Spotify" button not opening Spotify app correctly
 ### Removed
 - **Romaji Conversion**: Removed Japanese lyrics to romaji conversion feature (Kanji not supported, results were incomplete)
 ### Technical
 - Go backend now returns `actual_bit_depth` and `actual_sample_rate` in download response
 - Go backend now returns `service` field indicating actual service used (important for fallback)
 - Tidal API v2 response provides exact quality info
 - Qobuz uses track metadata for quality info
 - Amazon now reads quality from downloaded FLAC file (previously returned unknown)
 ## [2.0.1] - 2026-01-03
 ### Added
 - **Quality Picker Track Info**: Shows track name, artist, and cover in quality picker
  - Tap to expand long track titles
  - Expand icon only shows when title is truncated
  - Ripple effect follows rounded corners including drag handle
 ### Changed
 - **Unified Progress Tracking System**: Deprecated legacy single-download progress
  - All downloads now use item-based progress tracking
  - Fixes duplicate notification bug when finalizing
  - Cleaner codebase with single progress system
 ### Fixed
 - **Duplicate Notification Bug**: Fixed issue where "Finalizing" and "Downloading" notifications appeared simultaneously
 - **Update Notification Stuck**: Fixed notification staying at 100% after download completes
 - **Quality Picker Consistency**: Unified quality picker UI across all screens (Home, Album, Playlist)
  - Container with `primaryContainer` background for each option
  - Distinct icons: music_note (Lossless), high_quality (Hi-Res), four_k (Max)
 ## [2.0.0] - 2026-01-03
 ### Added
 - **Artist Search Results**: Search now shows artists alongside tracks
  - Horizontal scrollable artist cards with circular avatars
  - Tap artist to view their discography
 - **Multi-Layer Caching System**: Aggressive caching to minimize API calls
  - Go backend cache: Artist (10 min), Album (10 min), Search (5 min)
  - Flutter memory cache: Instant navigation for previously viewed artists/albums
  - Duplicate search prevention: Same query won't trigger new API call
 - **Real-time Download Status**: Track items show live download progress
  - Queued: Hourglass icon
  - Downloading: Circular progress with percentage
  - Completed: Check icon
  - Works in Home search, Album, and Playlist screens
 - **Downloaded Track Indicator**: Tracks already in history show check mark
  - Lazy file verification: Only checks file existence when tapped
  - Auto-removes from history if file was deleted, allowing re-download
  - Prevents accidental duplicate downloads
 - **Pre-release Support**: GitHub Actions auto-detects preview/beta/rc/alpha tags
  - Stable users won't receive update notifications for preview versions
 ### Changed
 - **Instant Navigation UX**: Navigate to Artist/Album screens immediately
  - Header (name, cover) shows instantly from available data
  - Content (albums/tracks) loads in background inside the screen
  - Second visit to same artist/album is instant from Flutter cache
 - **Search Results UI Redesign**: 
  - Removed "Download All" button from search results
  - Added "Songs" section header (matches "Artists" header style)
  - Track list now in grouped card with rounded corners (like Settings)
  - Track items with dividers and InkWell ripple effect
 - **Larger UI Elements**: Improved touch targets and visual hierarchy
  - Recent downloads: Album art 56→100px, section height 80→130px
  - Artist cards: Avatar 72→88px, container 90→100px
  - Track items: Album art 48→56px
 - **Optimized Search**: Pressing Enter with same query no longer triggers duplicate search
 - **Smoother Progress Animation**: Progress jumps to 100% after download completes
  - Embedding (cover, metadata, lyrics) happens in background without blocking UI
 - **Finalizing Status**: Shows "Finalizing" indicator while embedding metadata
  - Distinct icon (edit_note) with tertiary color
  - User knows download is complete, just processing metadata
 - **Consistent Download Button Sizes**: All download/status buttons now 44x44px
 - **Better Dynamic Color Contrast**: Improved visibility for cards and chips with dynamic color
  - Settings cards use overlay colors for better contrast
  - Theme/view mode chips have visible borders in light mode
 - **Navigation Bar Styling**: Distinct background color from content area
 - **Ask Before Download Default**: Now enabled by default for better UX
 ### Fixed
 - **Artist Profile Images**: Fixed artist images not showing in search results (field name mismatch)
 - **Album Card Overflow**: Fixed 5px overflow in artist discography album cards
 - **Optimized Rebuilds**: Each track item only rebuilds when its own status changes
  - Uses Riverpod `select()` for granular state watching
  - Prevents entire list rebuild on progress updates
 - **Update Notification Stuck**: Fixed notification staying at 100% after download complete
 ## [1.6.3] - 2026-01-03
 ### Added
 - **Predictive Back Navigation**: Support for Android 14+ predictive back gesture with smooth animations
 - **Separate Detail Screens**: Album, Artist, and Playlist now open as dedicated screens with Material Expressive 3 design
  - Collapsing header with cover art and gradient overlay
  - Card-based info section with rounded corners (20px radius)
  - Tonal download buttons with circular shape
  - Quality picker bottom sheet with drag handle
 - **Double-Tap to Exit**: Press back twice to exit app when at home screen (replaces exit dialog)
 ### Changed
 - **Navigation Architecture**: Refactored from state-based to screen-based navigation
  - Album/Artist/Playlist URLs navigate to dedicated screens via `Navigator.push()`
  - Enables native predictive back gesture animations
  - Search results stay on Home tab for quick downloads
 - **Simplified State Management**: Removed `previousState` chain from TrackProvider since Navigator handles back navigation
 ## [1.6.2] - 2026-01-02
 ### Added
 - **HTTPS-Only Downloads**: APK downloads and update checks now enforce HTTPS-only connections for security
 ### Changed
 - **Home Tab Rename**: Renamed "Search" tab to "Home" with home icon
 - **Branding**: Changed idle screen title from "Search Music" to "SpotiFLAC"
 - **About Page Redesign**: New Material Expressive 3 grouped layout with app header, contributors section with GitHub avatars, and organized links
 ### Fixed
 - **Play Button Flash**: Fixed play button briefly showing red error icon on app start (now uses optimistic rendering)
 ### Performance
 - **Optimized State Management**: Use `.select()` for Riverpod providers to prevent unnecessary widget rebuilds
 - **List Keys**: Added keys to all list builders for efficient list updates and reordering
 - **Request Cancellation**: Outdated API requests are ignored when new search/fetch is triggered
 - **Debounced URL Fetches**: All network requests now debounced to prevent rapid duplicate calls
 - **Bounded File Cache**: File existence cache now limited to 500 entries to prevent memory leak
 - **Timer Cleanup**: Progress polling timer properly disposed when provider is destroyed
 - **Stream Error Handling**: Share intent stream now has proper error handling
 ## [1.6.1] - 2026-01-02
 ### Added
 - **Background Download Service**: Downloads now continue running when app is in background
  - Foreground service with wake lock prevents Android from killing downloads
  - Persistent notification shows download progress
  - No more "connection abort" errors when switching apps
 ### Fixed
 - **Share Intent App Restart**: Fixed download queue being lost when sharing from Spotify while downloads are in progress
  - Download queue is now persisted to storage and automatically restored on app restart
  - Interrupted downloads (marked as "downloading") are reset to "queued" and auto-resumed
  - Changed launch mode to `singleTask` to reuse existing activity instead of restarting
  - Added `onNewIntent` handler to properly receive new share intents
 - **Back Button During Loading**: Back button no longer clears state while loading shared URL
 ### Changed
 - **Kotlin**: Upgraded from 2.2.20 to 2.3.0 for better plugin compatibility
 ## [1.6.0] - 2026-01-02
 ### Added
 - **Manual Quality Selection**: New option to choose audio quality before each download
  - Toggle "Ask Before Download" in Download Settings
  - When enabled, shows quality picker (Lossless, Hi-Res, Hi-Res Max) before downloading
  - Works for both single track and batch downloads
 - **Live Search**: Search results appear as you type with 400ms debounce
  - Animated search bar moves from center to top when typing
  - Keyboard stays open during transition
  - Back button navigates through search history (album → artist → idle)
  - Clear button to reset search
  - URLs still require manual submit
 - **Search Tab Header**: Added collapsing app bar to centered search view for consistent UI across all tabs
 - **Share Audio File**: Share downloaded tracks to other apps from Track Metadata screen
 ### Fixed
 - **Update Checker**: Fixed version comparison for versions with suffix (e.g., `1.5.0-hotfix6`)
  - Users on hotfix versions now properly receive update notifications
  - Handles `-hotfix`, `-beta`, `-rc` suffixes correctly
 - **Settings Ripple Effect**: Fixed splash/ripple effect to properly clip within rounded card corners
 ### Changed
 - **Settings UI Redesign**: New Android-style grouped settings with connected cards
  - Items in same group are connected with rounded card container
  - Section headers outside cards for clear visual hierarchy
  - Better contrast with white overlay for dark mode dynamic colors
 - **Larger Tab Titles**: Increased app bar title size (28px) and height (130px) for better visibility
 - **Consistent Header Position**: Fixed Search tab header alignment to match History and Settings tabs
 ### Improved
 - **Code Quality**: Replaced all `print()` statements with structured logging using `logger` package
 - **Dependencies Updated**:
  - `share_plus`: 10.1.4 → 12.0.1
  - `flutter_local_notifications`: 18.0.1 → 19.0.0
  - `build_runner`: 2.4.15 → 2.10.4
-## [1.5.5] - 2026-01-02
+- Album track list shows track number instead of cover image
 - Download buttons with more rounded corners
 - Downloaded songs in Recent show primary-colored subtitle
 ### Fixed
 - Home feed timezone detection
 - Track duration 0:00 when downloading from home feed
 ### Extensions
 - spotify-web v1.8.1: Home feed, artist_id support
 - ytmusic v1.6.1: Home feed, artist_id support
 ---
 ## [3.1.3] - 2026-01-19
 ### Added
 - **Share to App**: Share Spotify links directly from Spotify app or browser to SpotiFLAC
  - Supports track, album, playlist, and artist URLs
  - Auto-fetches metadata when link is shared
  - Works with both `open.spotify.com` URLs and `spotify:` URIs
 - **Lyrics Viewer**: View lyrics for downloaded tracks in Track Metadata screen
  - Fetches lyrics from LRCLIB on-demand
  - Clean display without timestamps
  - Copy lyrics to clipboard
 - **Artist URL Support**: Paste artist URL to browse their discography
  - Shows all albums, singles, and compilations
  - Horizontal scrollable album cards grouped by type
  - Tap any album to view and download its tracks
 - **Folder Organization**: Organize downloads into folders by artist or album
  - Options: None, By Artist, By Album, By Artist & Album
  - Configurable in Settings > Download
 - **Japanese Lyrics to Romaji**: Auto-convert Hiragana/Katakana lyrics to romaji
  - Useful for non-Japanese speakers who want to sing along
  - Toggle in Settings > Options > Lyrics
  - Kanji characters are preserved (requires dictionary lookup)
 - **History View Mode**: Choose between grid or list view for download history
  - Grid view shows album art in a 3-column layout (default)
  - List view shows detailed track info with date
  - Configurable in Settings > Appearance > Layout
 - **Exit Confirmation**: Dialog prompt when pressing back to exit app (only at root)
-### Changed
+- **External LRC Lyrics File Support**: Option to save lyrics as separate .lrc files for compatibility with external music players
- **Downloads Tab Renamed to History**: Better reflects the tab's purpose
+  - New "Lyrics Mode" setting in Settings > Download > Lyrics section
-  - Shows download queue at top when active
+  - Three modes available:
-  - Completed downloads auto-move to history section
+    - **Embed in file** (default): Lyrics stored inside FLAC metadata
-  - Cleaner separation between active downloads and history
+    - **External .lrc file**: Save lyrics as separate .lrc file next to audio file
- **Smarter Back Navigation**: Back button now navigates properly
+    - **Both**: Embed and save external .lrc file
-  - Goes back through search history (album → artist → empty)
+  - Perfect for players like Samsung Music that prefer external .lrc files
-  - Returns to Search tab from other tabs
+  - LRC files include metadata headers (title, artist, by:SpotiFLAC-Mobile)
-  - Only shows exit dialog when truly at root
+  - Works with all download services (Tidal, Qobuz, Amazon)
 - **CSV Import Quality Selection**: Choose audio quality when importing CSV playlists
  - Quality picker now appears before adding CSV tracks to download queue
  - Select between FLAC qualities (Lossless, Hi-Res, Hi-Res Max) or MP3
  - Respects "Ask quality before download" setting - uses default quality if disabled
  - **Persistent Cover Image Cache**: Album/track cover images now cached to persistent storage instead of temporary directory
  - Cover images no longer disappear when app is closed or device restarts
  - Cache stored in `app_flutter/cover_cache/` directory (not cleared by system)
  - Maximum 1000 images cached for up to 365 days
  - Covers are cached when displayed in History, Home, Album, Artist, or any other screen
  - New `CoverCacheManager` service with `clearCache()` and `getStats()` methods for future cache management
 - **Extended Metadata from Deezer Enrichment**: Track downloads now include label, copyright, and genre metadata from Deezer
  - New fields in `ExtTrackMetadata`: `label`, `copyright`, `genre`
  - Metadata fetched during `enrichTrack()` via Deezer album API
  - Embedded as FLAC Vorbis comments: `GENRE`, `ORGANIZATION` (label), `COPYRIGHT`
  - Works for both extension downloads and built-in provider downloads (Tidal, Qobuz, Amazon)
 - **Track Metadata Screen Extended Info**: Genre, label, and copyright now displayed in track metadata screen
  - Added `genre`, `label`, `copyright` fields to `DownloadHistoryItem` model
  - Metadata is stored in download history and persists across app restarts
  - New localization strings: `trackGenre`, `trackLabel`, `trackCopyright`
 - **`utils.randomUserAgent()` for Extensions**: New utility function for extensions to get random browser User-Agent strings
  - Returns modern Chrome User-Agent format: `Chrome/{120-145}.0.{6000-7499}.{100-299}` with `Windows NT 10.0`
  - Useful for extensions that need to rotate User-Agents to avoid detection
 ### Fixed
 - **Download Progress**: Fixed progress stuck at 0% when using item-based progress tracking (affected sequential downloads after multi-download feature was added)
 - **Artist View State**: Fixed UI state not clearing properly when switching between artist and album views
 - **Share Intent Timing**: Fixed shared URLs not being processed when app was cold-started from share intent
-### Improved
+- **Portuguese Language Bug**: Fixed locale parsing for languages with country codes (e.g., pt_PT, es_ES)
- **Cleaner UI for Returning Users**: Helper text "Supports: Track, Album, Playlist URLs" now only shows for new users and hides after first search
+  - App now correctly loads Portuguese and Spanish translations
- **Cleaner Home Tab**: Removed redundant "Recent Downloads" section, renamed to "Search" tab
+  - Updated Portuguese label to "Português (Brasil)"
 - **Centered Search Bar**: Search bar now appears centered on screen when empty, moves to top when results are shown - easier to reach on large phones
 - **Back Navigation**: Android back button now works as expected - returns to previous view (album → artist → empty search)
-## [1.5.0-hotfix6] - 2026-01-02
+- **VM Race Condition Panic**: Fixed `panic during execution: runtime error: index out of range [-2]` crash when switching search providers
  - Root cause: Goja VM was being accessed concurrently by multiple goroutines without synchronization
  - Added `VMMu sync.Mutex` to `LoadedExtension` struct
  - Added mutex lock/unlock to ALL `ExtensionProviderWrapper` methods:
    - `SearchTracks`, `GetTrack`, `GetAlbum`, `GetArtist`
    - `EnrichTrack`, `CheckAvailability`, `GetDownloadURL`, `Download`
    - `CustomSearch`, `HandleURL`, `MatchTrack`, `PostProcess`
  - Prevents race conditions when rapidly switching between extension search providers
-### Fixed
+- **Tidal Release Date Fallback**: Fixed missing release date in FLAC metadata when downloading from Tidal
- **App Signing**: Use r0adkll/sign-android-release GitHub Action for reliable signing
+  - Now uses Tidal API's release date when `req.ReleaseDate` is empty
  - Ensures release date is always embedded in downloaded files
-## [1.5.0-hotfix5] - 2026-01-02
+- **Extended Metadata for M4A→FLAC Conversion**: Fixed genre, label, and copyright not being embedded when converting Amazon M4A to FLAC
  - Flutter now extracts extended metadata from Go backend response
  - Passes `genre`, `label`, `copyright` parameters to `_embedMetadataAndCover()`
  - Tags correctly embedded during FFmpeg conversion
-### Fixed
+- **Extended Metadata for MP3 Conversion**: Genre, label, and copyright now embedded in MP3 files when converting from FLAC
- **App Signing**: Use key.properties as per Flutter official documentation
+  - Added `genre`, `label`, `copyright` parameters to `_embedMetadataToMp3()`
  - Tags embedded as ID3v2: `GENRE`, `ORGANIZATION` (label), `COPYRIGHT`
-## [1.5.0-hotfix4] - 2026-01-02
+### Extensions
-### Fixed
+- **spotify-web Extension**: Updated to v1.7.0
- **App Signing**: Create keystore.properties in workflow for Gradle
+  - Added `getMetadataFromDeezer()` function to fetch extended metadata:
-
+    - ISRC from track
-## [1.5.0-hotfix] - 2026-01-02
+    - Label from album
-
+    - Copyright (generated as "YEAR LABEL")
-### Important Notice
+    - Genre from album genres
-We apologize for the inconvenience. Previous releases were signed with different keys, causing "package conflicts" errors when upgrading. Starting from this version, all releases will use a consistent signing key.
+    - Release date
-
+  - `enrichTrack()` now returns all extended metadata to Go backend
-**If you're upgrading from v1.5.0 or earlier, please uninstall the app first before installing this version.** This is a one-time requirement. Future updates will work seamlessly without uninstalling.
+  - Replaced all hardcoded User-Agent strings with `utils.randomUserAgent()`
 ### Added
 - **In-App Update**: Download and install updates directly from the app
  - Progress bar shows download status
  - Automatic device architecture detection (arm64/arm32)
  - Downloads correct APK for your device
 - **Consistent App Signing**: All future releases will use the same signing key
 ### Fixed
 - **Update Checker**: Now downloads APK directly instead of opening browser
 ## [1.5.0] - 2026-01-02
 ### Added
 - **Download Progress Notification**: Shows notification with download progress percentage while downloading
  - Progress bar in notification during download
  - Completion notification when track finishes
  - Summary notification when all downloads complete
 - **Notification Permission in Setup**: Android 13+ users will be prompted for notification permission during initial setup
  - New step in setup wizard for notification permission
  - Option to skip if user doesn't want notifications
 - **Per-Item Queue Controls**: Each track in download queue now has individual controls
  - Cancel button for queued items
  - Stop button for currently downloading items
  - Retry and Remove buttons for failed/skipped items
  - Visual progress bar with percentage for each downloading track
 - **Pull-to-Refresh on Home**: Swipe down to clear URL input and fetched tracks
  - No need to exit app to clear current search/fetch
 - **Multi-Progress Tracking for Concurrent Downloads**: Each concurrent download now shows individual progress percentage
  - Previously concurrent downloads jumped from 0% to 100%
  - Now each track shows real-time progress when downloading in parallel
 - **In-App Update**: Download and install updates directly from the app
  - Progress bar shows download status
  - Automatic device architecture detection (arm64/arm32)
  - Downloads correct APK for your device
 ### Changed
 - **Recent Downloads**: Now shows up to 10 items (was 5) for better scrolling
 - **Queue UI Redesign**: Card-based layout with clearer status indicators
  - Removed global pause/resume in favor of per-item controls
  - Better visual hierarchy with cover art, track info, and action buttons
 - **Settings UI**: Redesigned with category-based navigation (One UI style)
  - Main settings tab with 4 categories: Appearance, Download, Options, About
  - Each category opens a detail page
  - Large title at top with menu items below
  - One-handed friendly layout
 - **Collapsing Toolbar**: Implemented One UI style collapsing header for all tabs
  - Title animates from 28px (expanded) to 20px (collapsed)
  - Back button only on settings detail pages
  - Consistent across Home, Downloads, and Settings tabs
 - **Home Search Bar Redesign**: More prominent and user-friendly input
  - Larger card-style search bar with border outline
  - Tap to open bottom sheet with full input experience
  - Paste and Search buttons clearly visible
  - Helper text showing supported URL types
 - **Empty State Improved**: Better onboarding for new users
  - "Ready to Download" title with icon
  - Clear instructions on how to use the app
  - "Add Music" button for quick access
 ### Technical
 - Added `flutter_local_notifications` package for notifications
 - Added notification permission request in setup screen for Android 13+
 - Enabled core library desugaring for all Android subprojects
 - Added multi-progress tracking in Go backend (`ItemProgress`, `ItemProgressWriter`)
 - Added `GetAllDownloadProgress`, `InitItemProgress`, `FinishItemProgress`, `ClearItemProgress` exports
 - Updated platform channel handlers for both Android (Kotlin) and iOS (Swift)
 ### Performance
 - Optimized SliverAppBar: Removed LayoutBuilder that was called every frame during scroll
 - Optimized image caching: Added `memCacheWidth/Height` to CachedNetworkImage for memory efficiency
 - Optimized state management: Use `select()` to only rebuild when specific state changes
 - Smoother animations: Changed to `BouncingScrollPhysics` and `Curves.easeOutCubic`
-## [1.2.0] - 2026-01-02
+- **Faster App Startup**: Notification, Share Intent, and Cover Cache Manager initialization now run in parallel
 - **Download Queue Polling**: Batched progress updates reduce rebuilds and list allocations during active downloads
 - **Queue Item Updates**: Status/progress updates now skip no-op changes and update by index for fewer allocations
 - **Directory Creation**: Download output folders are created once per path, reducing repeated I/O for albums/singles
 - **Search Results Rendering**: Single-pass filtering avoids repeated `indexOf` calls for large result sets
 - **Queue Lookups in UI**: O(1) lookup for queue status in Home/Album/Playlist/Artist track lists
 - **History Filtering**: Album/single counts and grouping are computed once per build
 - **Downloaded Album View**: Tracks are grouped by disc in one pass to reduce filtering overhead
 - **Track Metadata Screen**:
  - Palette extraction deferred until after transition; reduced sample size for smoother navigation
  - File stat uses a single syscall and only triggers state updates on change
  - Static regex/month table avoids repeated allocations
  - Cover precached before opening metadata from history/queue/recents
 - **Flutter Provider Optimizations**:
  - Cache `SharedPreferences` instance in `DownloadHistoryNotifier` and `DownloadQueueNotifier` to avoid repeated `getInstance()` calls
  - Precompile regex for folder name sanitization and year extraction (top-level `final`)
  - Use `indexWhere` instead of `firstWhere` with placeholder object to reduce allocations in queue processing
 - **Flutter UI Optimizations**:
  - Selective `ref.watch()` for `downloadQueueProvider` (watch only `queuedCount` or `items` instead of entire state)
  - Pass `Track` directly to `_buildTrackTile()` instead of index lookup inside builder
  - Pass `historyItems` as parameter to `_buildRecentAccess()` to avoid `ref.read()` inside method
 - **M4A Metadata Embedding**: Streaming implementation reduces memory usage for large files
  - Uses `os.Open()` + `ReadAt` instead of `os.ReadFile()` (no full file load into memory)
  - Atomic file replacement via temp file + rename for safer writes
  - New helper functions: `findAtomInRange()`, `readAtomHeaderAt()`, `copyRange()`
 ### Backend
 - **Deezer ISRC Fetching**: Uses ISRCs already present in payloads and caches them, cutting extra API calls
 - **SearchAll Allocation**: Preallocated slices to reduce allocations during Deezer search
 - **HTTP Client Helper**: Refactored HTTP client creation to use `NewHTTPClientWithTimeout()` helper function across `lyrics.go`, `qobuz.go`, `tidal.go`
 ### Technical
 - **Go Backend Changes**:
  - `go_backend/extension_providers.go`: Added `Label`, `Copyright`, `Genre` fields to `ExtTrackMetadata`; added mutex locks to all provider methods
  - `go_backend/extension_manager.go`: Added `VMMu sync.Mutex` to `LoadedExtension` struct
  - `go_backend/extension_runtime.go`: Added `utils.randomUserAgent` function
  - `go_backend/extension_runtime_utils.go`: Added `randomUserAgent()` implementation
  - `go_backend/httputil.go`: Updated `getRandomUserAgent()` to use modern Chrome versions
  - `go_backend/tidal.go`: Added release date fallback logic
  - `go_backend/exports.go`: Added `Genre`, `Label`, `Copyright` fields to `DownloadResponse`
 - **Flutter Changes**:
  - `lib/services/cover_cache_manager.dart`: New persistent cache manager for cover images (365 days, 1000 images max)
  - `lib/widgets/cached_cover_image.dart`: Wrapper widget for CachedNetworkImage with persistent cache
  - `lib/main.dart`: Added `CoverCacheManager.initialize()` to app startup
  - `lib/screens/*.dart`: All 11 screens updated to use persistent cache manager for CachedNetworkImage
  - `lib/providers/download_queue_provider.dart`: Updated `_embedMetadataAndCover()` to accept and embed genre, label, copyright; added `genre`, `label`, `copyright` fields to `DownloadHistoryItem`
  - `lib/screens/track_metadata_screen.dart`: Display genre, label, copyright in metadata grid
  - `lib/l10n/arb/app_en.arb`: Added `trackGenre`, `trackLabel`, `trackCopyright` localization strings
 ### Dependencies
 - Added `flutter_cache_manager: ^3.4.1` (explicit dependency for persistent cache)
 - Added `path: ^1.9.0` (for cache directory path handling)
 ---
 ## [3.1.2] - 2026-01-19
 ### Added
 - **Track Metadata Screen**: New detailed metadata view when tapping on downloaded tracks
  - Material Expressive 3 design with cover art header and gradient
  - Hero animation from list to detail view
  - Displays: track name, artist, album artist, album, track number, disc number, duration, release date, ISRC, Spotify ID, quality, service, download date
  - File info: format (FLAC/M4A), file size, quality badge, service badge with colors
  - Tap to copy ISRC and Spotify ID
  - "Open in Spotify" button to open track in Spotify app/browser
  - File path display with copy functionality
  - Play and Delete action buttons
 - **Hi-Res Lossless MAX**: New highest quality option for maximum audio fidelity
-### Fixed
+- **New Languages**: Added Spanish (es) and Portuguese (pt) translations
- **Hi-Res Quality Bug**: Fixed issue where Hi-Res downloads were stuck at Lossless quality
+  - Spanish: Credits 125 ([@credits125](https://crowdin.com/profile/credits125))
-  - Users on previous versions are recommended to upgrade to get proper Hi-Res downloads
+  - Portuguese: Pedro Marcondes ([@justapedro](https://crowdin.com/profile/justapedro))
- **Settings Navigation Bug**: Fixed issue where changing settings (like audio quality) would navigate back to Home tab
+  - Russian: Владислав ([@odinokiy_kot](https://crowdin.com/profile/odinokiy_kot))
- **Tidal Badge Color**: Fixed unreadable Tidal service badge (was too bright cyan, now darker blue)
+
 - **Quick Search Provider Switcher** ([#76](https://github.com/zarzet/SpotiFLAC-Mobile/issues/76)): Dropdown menu in search bar for instant provider switching
  - Tap the search icon to reveal a dropdown menu with all available search providers
  - Shows default provider (Deezer based on metadata source setting) at the top
  - Lists all enabled extensions with custom search capability
  - Displays extension icons when available
  - Checkmark indicates currently selected provider
  - Search hint text updates immediately when switching providers
  - Re-triggers search automatically if there's existing text in the search bar
  - Eliminates need to navigate to Settings > Extensions > Search Provider
 - **Extension Button Setting Type** ([#74](https://github.com/zarzet/SpotiFLAC-Mobile/issues/74)): New setting type for extension actions
  - Extensions can define `button` type in manifest settings
  - Triggers JavaScript function when tapped (e.g., start OAuth flow)
  - Useful for authentication, manual sync, or any custom action
 - **Genre & Label Metadata** ([#75](https://github.com/zarzet/SpotiFLAC-Mobile/issues/75)): Downloaded tracks now include genre and record label information
  - Fetches genre and label from Deezer album API for each track
  - Embeds GENRE, ORGANIZATION (label), and COPYRIGHT tags into FLAC files
  - Works automatically when Deezer track ID is available (via ISRC matching)
  - Supports all download services (Tidal, Qobuz, Amazon) and extension downloads
 - **MP3 Quality Option** ([#69](https://github.com/zarzet/SpotiFLAC-Mobile/issues/69)): Optional MP3 download format with FLAC-to-MP3 conversion
  - New "Enable MP3 Option" toggle in Settings > Download > Audio Quality
  - When enabled, MP3 (320kbps) appears as a quality option alongside FLAC options
  - Available in both the quality picker dialog and default quality settings
  - Works with all services (Tidal, Qobuz, Amazon) and extensions
 - **MP3 Metadata Embedding**: Full metadata support for MP3 files
  - Cover art embedded using ID3v2 tags
  - Synced lyrics embedded (fetched from lrclib.net)
  - All metadata preserved: title, artist, album, album artist, track/disc number, date, ISRC
  - Automatic tag conversion from Vorbis comments (FLAC) to ID3v2 (MP3)
 - **Dominant Color Header**: Album, Playlist, Downloaded Album, and Track Metadata screens now feature dynamic header backgrounds
  - Extracts dominant color from cover art using `palette_generator`
  - Creates a gradient from dominant color to theme surface color
  - Smooth 500ms color transition animation
 - **Larger Cover Art**: Cover images on detail screens are now 50% of screen width (previously 140px fixed)
  - More prominent album artwork display
  - Larger shadow and rounded corners (20px radius)
  - Higher resolution cover caching
 - **Sticky Title**: Title appears in AppBar when scrolling past the info card
  - Smooth fade-in animation (200ms) when scrolling down
  - Title hidden when header is expanded (shows in info card instead)
  - AppBar uses theme color (surface) for clean, native look
  - Works on Album, Playlist, Downloaded Album, Track Metadata, and Artist screens
 - **Artist Name in Album Screen**: Album info card now displays artist name below album title
  - Extracted from first track's artist metadata
  - Styled with `onSurfaceVariant` color for visual hierarchy
 - **Disc Separation for Multi-Disc Albums** ([#70](https://github.com/zarzet/SpotiFLAC-Mobile/issues/70)): Downloaded albums with multiple discs now display tracks grouped by disc
  - Visual disc separator header showing "Disc 1", "Disc 2", etc.
  - Tracks sorted by disc number first, then by track number
  - Single-disc albums display normally without separators
  - Fixes confusion when albums have duplicate track numbers across discs
 - **Album Grouping in Recents** ([#70](https://github.com/zarzet/SpotiFLAC-Mobile/issues/70)): Downloads now show as albums instead of individual tracks in the Recent section
  - Prevents flooding the recents list when downloading full albums
  - Groups tracks by album name and artist
  - Tapping navigates directly to the downloaded album screen
  - Shows the most recent download time for each album
 ### Changed
 - **Recent Downloads**: Tapping on a track now opens metadata screen instead of playing directly
  - Play button still available for quick playback
 - **Download History Model**: Extended with additional metadata fields (albumArtist, isrc, spotifyId, trackNumber, discNumber, duration, releaseDate, quality)
 - Removed unused `history_screen.dart` and `history_tab.dart` files
-## [1.1.2] - 2026-01-01
+- **FFmpeg FLAC-to-MP3 Conversion**: Improved conversion process
  - MP3 files now saved in the same folder as FLAC (no separate MP3 subfolder)
  - Original FLAC file automatically deleted after successful conversion
  - New `embedMetadataToMp3()` method for MP3-specific tag embedding
 - **Sticky Header Theme Integration**: AppBar background uses `colorScheme.surface` instead of dominant color when collapsed
  - Dark theme: Black background with white text
  - Light theme: White background with black text
  - Matches modern app behavior for better readability
 ### Fixed
 - **MP3 Quality Display in Track Metadata**: Fixed incorrect quality display for MP3 files
  - MP3 files now show "320kbps" instead of FLAC's bit depth/sample rate
  - History no longer stores FLAC audio specs for converted MP3 files
  - Both File Info badges and metadata grid show correct MP3 quality
 - **Empty Catch Blocks**: Fixed analyzer warnings for empty catch blocks
  - `download_queue_provider.dart`: Added comments explaining why polling errors are silently ignored
  - `track_provider.dart`: Added comments explaining why availability check errors are silently ignored
  - `ffmpeg_service.dart`: Added proper error logging for temp file cleanup failures
 - **Russian Plural Forms**: Fixed ICU syntax warnings in Russian localization
  - Removed redundant `=1` clauses that were overriding `one` plural category
  - Affected 10 plural strings including track counts and delete confirmations
  - Plurals now correctly handle Russian grammar (1 трек, 2 трека, 5 треков)
 ### Dependencies
 - Added `palette_generator: ^0.3.3+4` for cover art color extraction
 ---
 ## [3.1.1] - 2026-01-17
 ### Added
 - **Update Checker**: Automatic check for new versions from GitHub releases
  - Shows changelog in update dialog
  - Option to disable update notifications
 - **Release Changelog**: GitHub releases now include full changelog
-### Changed
+- **Lyrics Caching**: Lyrics are now cached for 24 hours to reduce API calls and improve performance
- Updated version to 1.1.2
+  - Thread-safe cache with automatic expiration
  - Cache key based on artist, track, and duration
  - Log indicator shows "(cached)" when lyrics are served from cache
-## [1.1.1] - 2026-01-01
+- **Lyrics Duration Matching**: Improved lyrics accuracy with duration-based matching
  - Compares track duration with lrclib.net results
  - 10-second tolerance to handle version differences (radio edit, remaster, etc.)
  - Prioritizes synced lyrics over plain text when duration matches
  - Falls back gracefully if no duration match found
 - **Deezer Cover Art Upgrade**: Cover art from Deezer CDN now automatically upgraded to maximum quality
  - Detects Deezer CDN URLs (`cdn-images.dzcdn.net`)
  - Upgrades cover resolution to 1800x1800 (max available)
  - Works alongside existing cover upgrade
 - **Live Search for Extensions**: Search-as-you-type functionality for extension search
  - 800ms debounce delay to prevent excessive API calls
  - Minimum 3 characters required before searching
  - Concurrency control to prevent race conditions in extension runtime
  - Queues pending searches if a search is already in progress
 - **Russian Language Support**: Added Russian (Русский) translation - 99% complete
  - Translated via Crowdin community contributions
  - Covers all UI elements, settings, and error messages
 ### Fixed
 - **About Dialog**: Custom About dialog with cleaner layout
 - **Setup Screen**: Fixed step indicator line alignment
 - **Warning Text**: Fixed parallel downloads warning to use Material theme colors
 - **Copyright Year**: Updated to 2026
-### Changed
+- **ISRC Index Race Condition**: Fixed repeated index rebuilding during parallel downloads
- Removed Theme Preview from Settings
+  - Added per-directory build lock using `sync.Map` and `sync.Mutex`
- Added MIT License
+  - Double-check locking pattern ensures index is built only once
  - Significantly improves performance during CSV import with many tracks
 - **Queue Tab Scroll Exception**: Fixed Flutter rendering exception with NestedScrollView
  - Disabled Material 3 stretch overscroll indicator that caused `_StretchController` assertion
  - Wrapped NestedScrollView with ScrollConfiguration to prevent `setState during build` errors
  - Issue was especially noticeable during rapid queue updates (CSV import)
-## [1.1.0] - 2026-01-01
+- **CSV Import**: Fixed CSV export not being parsed correctly
  - Added support for `Artist Name(s)` header (with parentheses)
  - Added support for `Track URI` header for track IDs
  - Added `artists` and `track_id` as alternative header names
  - Now correctly parses "Liked Songs" and playlist exports
 ---
 ## [3.1.0] - 2026-01-16
 ### Added
 - **Parallel Downloads**: Download up to 3 tracks simultaneously (configurable in Settings)
  - Default: Sequential (1 at a time) for stability
  - Options: 1, 2, or 3 concurrent downloads
  - Warning about potential rate limiting from streaming services
 - **Download Progress Tracking**: Real-time progress for BTS manifest downloads from Tidal
 - **History Persistence**: Download history now persists across app restarts using SharedPreferences
 - **Connection Pooling**: Shared HTTP transport to prevent TCP connection exhaustion during large batch downloads
 - **Connection Cleanup**: Automatic cleanup of idle connections every 50 downloads and at queue end
-### Fixed
+- **Recent Access History**: Quick access to recently visited content when tapping the search bar
- **Download Progress Bug**: Fixed 0% → 100% jump by adding proper progress tracking for BTS format downloads
+- **Artist Screen Redesign**: Full-width header, monthly listeners, top tracks section
- **TCP Connection Exhaustion**: Fixed slow downloads after ~300 tracks by implementing connection pooling and periodic cleanup
+- **Extension Store Update Badge**: Badge indicator showing available extension updates
- **Trailing Space in Names**: Fixed download failures when playlist/album/track names have trailing spaces
+- **Extension Compatibility Warning**: Warning for extensions requiring newer app version
- **History Loss on Debug**: History no longer disappears when sideloading via `flutter run --debug`
+- **Year in Album Folder Name**: New folder structure options with release year
 - **Extension Album/Playlist/Artist Support**: Extensions can now return collections in search
 - **Odesli Integration**: YouTube Music extension can now match tracks to Deezer/Tidal/Qobuz
 - **Download Cancel**: Properly stops in-flight downloads
 ### Changed
 - Updated version to 1.1.0
-### Technical Details
+- Search bar behavior improved with recent access history
 - Added `concurrentDownloads` field to `AppSettings` model (default: 1, max: 3)
 - Implemented worker pool pattern in `DownloadQueueNotifier` for parallel processing
 - Added `SetCurrentFile()`, `SetBytesTotal()`, and `ProgressWriter` for BTS downloads in Go backend
 - Added `strings.TrimSpace()` to all string fields in `DownloadTrack()` and `DownloadWithFallback()`
 - Added shared `http.Transport` with connection pooling in `httputil.go`
 - Added `CleanupConnections()` export for Flutter to call via method channel
-## [1.0.5] - Previous Release
+### Fixed
- Material Expressive 3 UI
+
- Dynamic color support
+- Multiple extension-related fixes for artist, album, and playlist handling
- Swipe navigation with PageView
+- UI fixes for search, settings, and navigation
- Settings as bottom navigation tab
+
- APK size optimization
+---
 ## [3.0.0] - 2026-01-14
 ### Extension System (Major Feature)
 SpotiFLAC 3.0 introduces a powerful extension system that allows third-party integrations for metadata, downloads, and more.
 - **Extension Store**: Browse and install extensions directly from the app
 - **Web Extension**: Metadata provider for personalized playlists
 - **Extension Capabilities**: Custom search, URL handlers, thumbnail ratios, post-processing
 - **Extension APIs**: Full HTTP, storage, file, and crypto support
 - **Security**: Sandboxed JavaScript runtime with permission-based access
 ### Added
 - Album folder structure settings
 - Separate singles folder option
 - Year in album folder name
 - Parallel API calls for faster downloads
 - Swipeable history filters
 ### Fixed
 - Tab edge overscroll
 - Extension duplicate load error
 - Settings item highlight on swipe
 - Back gesture freeze on Android 13+
 - Bottom overflow in dialogs
 - Japanese artist name matching
 - Multi-artist matching
 - Max resolution cover download
 - Various extension-related fixes
 ---
 *For older versions, see [GitHub Releases](https://github.com/zarzet/SpotiFLAC-Mobile/releases)*
@@ -0,0 +1,133 @@
 # Contributor Covenant Code of Conduct
 ## Our Pledge
 We as members, contributors, and leaders pledge to make participation in our
 community a harassment-free experience for everyone, regardless of age, body
 size, visible or invisible disability, ethnicity, sex characteristics, gender
 identity and expression, level of experience, education, socio-economic status,
 nationality, personal appearance, race, caste, color, religion, or sexual
 identity and orientation.
 We pledge to act and interact in ways that contribute to an open, welcoming,
 diverse, inclusive, and healthy community.
 ## Our Standards
 Examples of behavior that contributes to a positive environment for our
 community include:
 * Demonstrating empathy and kindness toward other people
 * Being respectful of differing opinions, viewpoints, and experiences
 * Giving and gracefully accepting constructive feedback
 * Accepting responsibility and apologizing to those affected by our mistakes,
  and learning from the experience
 * Focusing on what is best not just for us as individuals, but for the overall
  community
 Examples of unacceptable behavior include:
 * The use of sexualized language or imagery, and sexual attention or advances of
  any kind
 * Trolling, insulting or derogatory comments, and personal or political attacks
 * Public or private harassment
 * Publishing others' private information, such as a physical or email address,
  without their explicit permission
 * Other conduct which could reasonably be considered inappropriate in a
  professional setting
 ## Enforcement Responsibilities
 Community leaders are responsible for clarifying and enforcing our standards of
 acceptable behavior and will take appropriate and fair corrective action in
 response to any behavior that they deem inappropriate, threatening, offensive,
 or harmful.
 Community leaders have the right and responsibility to remove, edit, or reject
 comments, commits, code, wiki edits, issues, and other contributions that are
 not aligned to this Code of Conduct, and will communicate reasons for moderation
 decisions when appropriate.
 ## Scope
 This Code of Conduct applies within all community spaces, and also applies when
 an individual is officially representing the community in public spaces.
 Examples of representing our community include using an official email address,
 posting via an official social media account, or acting as an appointed
 representative at an online or offline event.
 ## Enforcement
 Instances of abusive, harassing, or otherwise unacceptable behavior may be
 reported to the community leaders responsible for enforcement at
 **[zarzet](https://github.com/zarzet)**.
 All complaints will be reviewed and investigated promptly and fairly.
 All community leaders are obligated to respect the privacy and security of the
 reporter of any incident.
 ## Enforcement Guidelines
 Community leaders will follow these Community Impact Guidelines in determining
 the consequences for any action they deem in violation of this Code of Conduct:
 ### 1. Correction
 **Community Impact**: Use of inappropriate language or other behavior deemed
 unprofessional or unwelcome in the community.
 **Consequence**: A private, written warning from community leaders, providing
 clarity around the nature of the violation and an explanation of why the
 behavior was inappropriate. A public apology may be requested.
 ### 2. Warning
 **Community Impact**: A violation through a single incident or series of
 actions.
 **Consequence**: A warning with consequences for continued behavior. No
 interaction with the people involved, including unsolicited interaction with
 those enforcing the Code of Conduct, for a specified period of time. This
 includes avoiding interactions in community spaces as well as external channels
 like social media. Violating these terms may lead to a temporary or permanent
 ban.
 ### 3. Temporary Ban
 **Community Impact**: A serious violation of community standards, including
 sustained inappropriate behavior.
 **Consequence**: A temporary ban from any sort of interaction or public
 communication with the community for a specified period of time. No public or
 private interaction with the people involved, including unsolicited interaction
 with those enforcing the Code of Conduct, is allowed during this period.
 Violating these terms may lead to a permanent ban.
 ### 4. Permanent Ban
 **Community Impact**: Demonstrating a pattern of violation of community
 standards, including sustained inappropriate behavior, harassment of an
 individual, or aggression toward or disparagement of classes of individuals.
 **Consequence**: A permanent ban from any sort of public interaction within the
 community.
 ## Attribution
 This Code of Conduct is adapted from the [Contributor Covenant][homepage],
 version 2.1, available at
 [https://www.contributor-covenant.org/version/2/1/code_of_conduct.html][v2.1].
 Community Impact Guidelines were inspired by
 [Mozilla's code of conduct enforcement ladder][Mozilla CoC].
 For answers to common questions about this code of conduct, see the FAQ at
 [https://www.contributor-covenant.org/faq][FAQ]. Translations are available at
 [https://www.contributor-covenant.org/translations][translations].
 [homepage]: https://www.contributor-covenant.org
 [v2.1]: https://www.contributor-covenant.org/version/2/1/code_of_conduct.html
 [Mozilla CoC]: https://github.com/mozilla/diversity
 [FAQ]: https://www.contributor-covenant.org/faq
 [translations]: https://www.contributor-covenant.org/translations
@@ -0,0 +1,268 @@
 # Contributing to SpotiFLAC
 First off, thank you for considering contributing to SpotiFLAC! 🎉
 This document provides guidelines and steps for contributing. Following these guidelines helps maintain code quality and ensures a smooth collaboration process.
 ## Table of Contents
 - [Code of Conduct](#code-of-conduct)
 - [How Can I Contribute?](#how-can-i-contribute)
  - [Reporting Bugs](#reporting-bugs)
  - [Suggesting Features](#suggesting-features)
  - [Code Contributions](#code-contributions)
  - [Translations](#translations)
 - [Development Setup](#development-setup)
 - [Project Structure](#project-structure)
 - [Coding Guidelines](#coding-guidelines)
 - [Commit Guidelines](#commit-guidelines)
 - [Pull Request Process](#pull-request-process)
 ## Code of Conduct
 This project and everyone participating in it is governed by our [Code of Conduct](CODE_OF_CONDUCT.md). By participating, you are expected to uphold this code. Please report unacceptable behavior to the project maintainers.
 ## How Can I Contribute?
 ### Reporting Bugs
 Before creating bug reports, please check the [existing issues](https://github.com/zarzet/SpotiFLAC-Mobile/issues) to avoid duplicates.
 When creating a bug report, please use the bug report template and include:
 - **Clear and descriptive title**
 - **Steps to reproduce** the issue
 - **Expected behavior** vs **actual behavior**
 - **Screenshots or screen recordings** if applicable
 - **Device information** (model, OS version)
 - **App version**
 - **Logs** from Settings > About > View Logs
 ### Suggesting Features
 Feature requests are welcome! Please use the feature request template and:
 - **Check existing issues** to avoid duplicates
 - **Describe the feature** clearly
 - **Explain the use case** - why would this be useful?
 - **Consider the scope** - is this a small enhancement or a major feature?
 ### Code Contributions
 1. **Fork the repository** and create your branch from `dev`
 2. **Make your changes** following our coding guidelines
 3. **Test your changes** thoroughly
 4. **Submit a pull request** to the `dev` branch
 ### Translations
 We use [Crowdin](https://crowdin.com/project/spotiflac-mobile) for translations. To contribute:
 1. Visit our [Crowdin project](https://crowdin.com/project/spotiflac-mobile)
 2. Select your language or request a new one
 3. Start translating!
 Translation files are located in `lib/l10n/arb/`.
 ## Development Setup
 ### Prerequisites
 - **Flutter SDK** 3.10.0 or higher
 - **Dart SDK** 3.10.0 or higher
 - **Android Studio** or **VS Code** with Flutter extensions
 - **Git**
 ### Getting Started
 1. **Clone your fork**
   ```bash
   git clone https://github.com/YOUR_USERNAME/SpotiFLAC-Mobile.git
   cd SpotiFLAC-Mobile
   ```
 2. **Add upstream remote**
   ```bash
   git remote add upstream https://github.com/zarzet/SpotiFLAC-Mobile.git
   ```
 3. **Install dependencies**
   ```bash
   flutter pub get
   ```
 4. **Generate code** (for Riverpod, JSON serialization, etc.)
   ```bash
   dart run build_runner build --delete-conflicting-outputs
   ```
 5. **Run the app**
   ```bash
   flutter run
   ```
 ### Building
 ```bash
 # Debug build
 flutter build apk --debug
 # Release build
 flutter build apk --release
 ```
 ## Project Structure
 ```
 lib/
 ├── l10n/               # Localization files
 │   └── arb/            # ARB translation files
 ├── models/             # Data models
 ├── providers/          # Riverpod providers
 ├── screens/            # UI screens
 │   └── settings/       # Settings sub-screens
 ├── services/           # Business logic services
 ├── theme/              # App theming
 ├── utils/              # Utility functions
 ├── widgets/            # Reusable widgets
 ├── app.dart            # App configuration
 └── main.dart           # Entry point
 ```
 ## Coding Guidelines
 ### General
 - Follow [Effective Dart](https://dart.dev/effective-dart) guidelines
 - Use meaningful variable and function names
 - Keep functions small and focused
 - Add comments for complex logic
 ### Formatting
 - Use `dart format` before committing
 - Maximum line length: 80 characters
 - Use trailing commas for better formatting
 ```bash
 dart format .
 ```
 ### Linting
 Ensure your code passes all lints:
 ```bash
 flutter analyze
 ```
 ### State Management
 We use **Riverpod** for state management. Follow these patterns:
 ```dart
 // Use code generation with riverpod_annotation
@riverpod
 class MyNotifier extends _$MyNotifier {
  @override
  MyState build() => MyState();
  // Methods to update state
 }
 ```
 ### Localization
 All user-facing strings should be localized:
 ```dart
 // Good
 Text(AppLocalizations.of(context)!.downloadComplete)
 // Bad
 Text('Download Complete')
 ```
 To add new strings:
 1. Add the key to `lib/l10n/arb/app_en.arb`
 2. Run `flutter gen-l10n`
 ## Commit Guidelines
 We follow [Conventional Commits](https://www.conventionalcommits.org/):
 ```
 <type>(<scope>): <description>
 [optional body]
 [optional footer(s)]
 ```
 ### Types
 - `feat`: New feature
 - `fix`: Bug fix
 - `docs`: Documentation changes
 - `style`: Code style changes (formatting, etc.)
 - `refactor`: Code refactoring
 - `perf`: Performance improvements
 - `test`: Adding or updating tests
 - `chore`: Maintenance tasks
 ### Examples
 ```
 feat(download): add batch download support
 fix(ui): resolve overflow on small screens
 docs: update contributing guidelines
 chore(deps): update flutter_riverpod to 3.1.0
 ```
 ## Pull Request Process
 1. **Update your fork**
   ```bash
   git fetch upstream
   git rebase upstream/dev
   ```
 2. **Create a feature branch**
   ```bash
   git checkout -b feat/my-new-feature
   ```
 3. **Make your changes** and commit following our guidelines
 4. **Push to your fork**
   ```bash
   git push origin feat/my-new-feature
   ```
 5. **Create a Pull Request**
   - Target the `dev` branch
   - Fill in the PR template
   - Link related issues
 6. **Address review feedback**
   - Make requested changes
   - Push additional commits
   - Request re-review when ready
 ### PR Requirements
 - [ ] Code follows project conventions
 - [ ] All tests pass
 - [ ] No new linting errors
 - [ ] Documentation updated (if needed)
 - [ ] Commit messages follow guidelines
 - [ ] PR description is clear and complete
 ## Questions?
 If you have questions, feel free to:
 - Open a [Discussion](https://github.com/zarzet/SpotiFLAC-Mobile/discussions)
 - Check existing [Issues](https://github.com/zarzet/SpotiFLAC-Mobile/issues)
 Thank you for contributing! 💚
@@ -1,10 +1,12 @@
 [![GitHub All Releases](https://img.shields.io/github/downloads/zarzet/SpotiFLAC-Mobile/total?style=for-the-badge)](https://github.com/zarzet/SpotiFLAC-Mobile/releases)
 [![VirusTotal](https://img.shields.io/badge/VirusTotal-Safe-brightgreen?style=for-the-badge&logo=virustotal)](https://www.virustotal.com/gui/file/3257155286587a3596ad5d4380d4576a684aa3d37a5b19a615914a845fbe57f3)
 [![Crowdin](https://img.shields.io/badge/HELP%20TRANSLATE%20ON-CROWDIN-%2321252b?style=for-the-badge&logo=crowdin)](https://crowdin.com/project/spotiflac-mobile)
 <div align="center">
 <img src="icon.png" width="128" />
-Get Spotify tracks in true FLAC from Tidal, Qobuz & Amazon Music — no account required.
+Download music in true lossless FLAC from Tidal, Qobuz & Amazon Music — no account required.
 ![Android](https://img.shields.io/badge/Android-7.0%2B-3DDC84?style=for-the-badge&logo=android&logoColor=white)
 ![iOS](https://img.shields.io/badge/iOS-14.0%2B-000000?style=for-the-badge&logo=apple&logoColor=white)
@@ -22,18 +24,75 @@ Get Spotify tracks in true FLAC from Tidal, Qobuz & Amazon Music — no account
  <img src="assets/images/4.jpg?v=2" width="200" />
 </p>
 ## Search Source
 SpotiFLAC supports multiple search sources for finding music metadata:
 | Source | Setup |
 |--------|-------|
 | **Deezer** (Default) | No setup required |
 | **Extensions** | Install additional search providers from the Store |
 ## Extensions
 Extensions allow the community to add new music sources and features without waiting for app updates. When a streaming service API changes or a new source becomes available, extensions can be updated independently.
 ### Installing Extensions
 1. Go to **Store** tab in the app
 2. Browse and install extensions with one tap
 3. Or download a `.spotiflac-ext` file and install manually via **Settings > Extensions**
 4. Configure extension settings if needed
 5. Set provider priority in **Settings > Extensions > Provider Priority**
 ### Developing Extensions
 Want to create your own extension? Check out the [Extension Development Guide](https://zarz.moe/docs) for complete documentation.
 ## Other project
 ### [SpotiFLAC (Desktop)](https://github.com/afkarxyz/SpotiFLAC)
-Get Spotify tracks in true FLAC from Tidal, Qobuz & Amazon Music for Windows, macOS & Linux
+Download music in true lossless FLAC from Tidal, Qobuz & Amazon Music for Windows, macOS & Linux
 > **Note:** Currently unavailable because the GitHub account is suspended. Alternatively, use [SpotiFLAC-Next](https://github.com/spotiverse/SpotiFLAC-Next) until the original is restored.
 ## Telegram
 <p align="center">
  <a href="https://t.me/spotiflac">
    <img src="https://img.shields.io/badge/Telegram-Channel-2CA5E0?style=for-the-badge&logo=telegram&logoColor=white" alt="Telegram Channel">
  </a>
  <a href="https://t.me/spotiflacchat">
    <img src="https://img.shields.io/badge/Telegram-Community-2CA5E0?style=for-the-badge&logo=telegram&logoColor=white" alt="Telegram Community">
  </a>
 </p>
 ## FAQ
 **Q: Why is my download failing with "Song not found"?**  
 A: The track may not be available on Tidal, Qobuz, or Amazon Music. Try enabling more download services in Settings > Download > Provider Priority, or install additional extensions from the Store.
 **Q: Why are some tracks downloading in lower quality?**  
 A: Quality depends on what's available from the streaming service. Tidal offers up to 24-bit/192kHz, Qobuz up to 24-bit/192kHz, and Amazon up to 24-bit/48kHz. The app automatically selects the best available quality.
 **Q: Can I download playlists?**  
 A: Yes! Just paste the playlist URL in the search bar. The app will fetch all tracks and queue them for download.
 **Q: Why do I need to grant storage permission?**  
 A: The app needs permission to save downloaded files to your device. On Android 13+, you may need to grant "All files access" in Settings > Apps > SpotiFLAC > Permissions.
 **Q: Is this app safe?**  
 A: Yes, the app is open source and you can verify the code yourself. Each release is scanned with VirusTotal (see badge at top of README).
 **Q: Why is download not working in my country?**  
 A: Some countries have restricted access to certain streaming service APIs. If downloads are failing, try using a VPN to connect through a different region.
 ## 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!
 This project is for **educational and private use only**. The developer does not condone or encourage copyright infringement.
-**SpotiFLAC** is a third-party tool and is not affiliated with, endorsed by, or connected to Spotify, Tidal, Qobuz, Amazon Music, or any other streaming service.
+**SpotiFLAC** is a third-party tool and is not affiliated with, endorsed by, or connected to Tidal, Qobuz, Amazon Music, Deezer, or any other streaming service.
 The application is purely a user interface that facilitates communication between your device and existing third-party services.
 You are solely responsible for:
 1. Ensuring your use of this software complies with your local laws.
@@ -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
+                keyAlias = keystoreProperties.getProperty("keyAlias")
-                keyPassword = keystoreProperties["keyPassword"] as String
+                keyPassword = keystoreProperties.getProperty("keyPassword")
-                storeFile = file(keystoreProperties["storeFile"] as String)
+                storeFile = file(keystoreProperties.getProperty("storeFile"))
-                storePassword = keystoreProperties["storePassword"] as String
+                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,7 +97,10 @@ repositories {
 dependencies {
    coreLibraryDesugaring("com.android.tools:desugar_jdk_libs:2.1.4")
-    implementation(files("libs/gobackend.aar"))
+    
    // Include all AAR and JAR files from libs folder
    implementation(fileTree(mapOf("dir" to "libs", "include" to listOf("*.jar", "*.aar"))))
    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-android:1.7.3")
    implementation("androidx.lifecycle:lifecycle-runtime-ktx:2.7.0")
 }
@@ -6,6 +6,14 @@
 -keep class io.flutter.** { *; }
 -keep class io.flutter.plugins.** { *; }
 # Ignore missing Play Core classes (not used, but referenced by Flutter)
 -dontwarn com.google.android.play.core.splitcompat.**
 -dontwarn com.google.android.play.core.splitinstall.**
 -dontwarn com.google.android.play.core.tasks.**
 # Ignore missing javax.xml.stream (not used on Android)
 -dontwarn javax.xml.stream.**
 # Go backend (gobackend.aar)
 -keep class gobackend.** { *; }
 -keep class go.** { *; }
@@ -14,6 +22,9 @@
 -keep class com.arthenica.ffmpegkit.** { *; }
 -keep class com.arthenica.smartexception.** { *; }
 # Apache Tika (if used by FFmpeg)
 -dontwarn org.apache.tika.**
 # Keep native methods
 -keepclasseswithmembernames class * {
    native <methods>;
@@ -15,6 +15,9 @@ import androidx.core.app.NotificationCompat
 /**
 * Foreground service to keep downloads running when app is in background.
 * This prevents Android from killing the download process or throttling network.
 * 
 * Note: Android 15+ (API 35+) has a 6-hour timeout for dataSync foreground services.
 * The service will be stopped automatically after 6 hours of cumulative runtime in 24 hours.
 */
 class DownloadService : Service() {
@@ -106,6 +109,19 @@ class DownloadService : Service() {
    override fun onBind(intent: Intent?): IBinder? = null
    /**
     * Called when the foreground service timeout is reached (Android 15+, API 35+).
     * dataSync services have a 6-hour limit in a 24-hour period.
     * We must call stopSelf() within a few seconds to avoid a crash.
     */
    override fun onTimeout(startId: Int, fgsType: Int) {
        // Log the timeout for debugging
        android.util.Log.w("DownloadService", "Foreground service timeout reached (6 hours limit). Stopping service.")
        // Gracefully stop the service
        stopForegroundService()
    }
    private fun createNotificationChannel() {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
            val channel = NotificationChannel(
@@ -5,6 +5,8 @@ import io.flutter.embedding.android.FlutterActivity
 import io.flutter.embedding.engine.FlutterEngine
 import io.flutter.plugin.common.MethodChannel
 import gobackend.Gobackend
 import com.arthenica.ffmpegkit.FFmpegKit
 import com.arthenica.ffmpegkit.ReturnCode
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.SupervisorJob
@@ -13,6 +15,7 @@ import kotlinx.coroutines.withContext
 class MainActivity: FlutterActivity() {
    private val CHANNEL = "com.zarz.spotiflac/backend"
    private val FFMPEG_CHANNEL = "com.zarz.spotiflac/ffmpeg"
    private val scope = CoroutineScope(SupervisorJob() + Dispatchers.Main)
    override fun onNewIntent(intent: Intent) {
@@ -114,6 +117,13 @@ class MainActivity: FlutterActivity() {
                            }
                            result.success(null)
                        }
                        "cancelDownload" -> {
                            val itemId = call.argument<String>("item_id") ?: ""
                            withContext(Dispatchers.IO) {
                                Gobackend.cancelDownload(itemId)
                            }
                            result.success(null)
                        }
                        "setDownloadDirectory" -> {
                            val path = call.argument<String>("path") ?: ""
                            withContext(Dispatchers.IO) {
@@ -129,6 +139,28 @@ class MainActivity: FlutterActivity() {
                            }
                            result.success(response)
                        }
                        "checkDuplicatesBatch" -> {
                            val outputDir = call.argument<String>("output_dir") ?: ""
                            val tracksJson = call.argument<String>("tracks") ?: "[]"
                            val response = withContext(Dispatchers.IO) {
                                Gobackend.checkDuplicatesBatch(outputDir, tracksJson)
                            }
                            result.success(response)
                        }
                        "preBuildDuplicateIndex" -> {
                            val outputDir = call.argument<String>("output_dir") ?: ""
                            withContext(Dispatchers.IO) {
                                Gobackend.preBuildDuplicateIndex(outputDir)
                            }
                            result.success(null)
                        }
                        "invalidateDuplicateIndex" -> {
                            val outputDir = call.argument<String>("output_dir") ?: ""
                            withContext(Dispatchers.IO) {
                                Gobackend.invalidateDuplicateIndex(outputDir)
                            }
                            result.success(null)
                        }
                        "buildFilename" -> {
                            val template = call.argument<String>("template") ?: ""
                            val metadata = call.argument<String>("metadata") ?: "{}"
@@ -148,8 +180,9 @@ class MainActivity: FlutterActivity() {
                            val spotifyId = call.argument<String>("spotify_id") ?: ""
                            val trackName = call.argument<String>("track_name") ?: ""
                            val artistName = call.argument<String>("artist_name") ?: ""
                            val durationMs = call.argument<Int>("duration_ms")?.toLong() ?: 0L
                            val response = withContext(Dispatchers.IO) {
-                                Gobackend.fetchLyrics(spotifyId, trackName, artistName)
+                                Gobackend.fetchLyrics(spotifyId, trackName, artistName, durationMs)
                            }
                            result.success(response)
                        }
@@ -158,8 +191,9 @@ class MainActivity: FlutterActivity() {
                            val trackName = call.argument<String>("track_name") ?: ""
                            val artistName = call.argument<String>("artist_name") ?: ""
                            val filePath = call.argument<String>("file_path") ?: ""
                            val durationMs = call.argument<Int>("duration_ms")?.toLong() ?: 0L
                            val response = withContext(Dispatchers.IO) {
-                                Gobackend.getLyricsLRC(spotifyId, trackName, artistName, filePath)
+                                Gobackend.getLyricsLRC(spotifyId, trackName, artistName, filePath, durationMs)
                            }
                            result.success(response)
                        }
@@ -177,6 +211,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") ?: ""
@@ -208,6 +249,517 @@ 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) {
                                Gobackend.preWarmTrackCacheJSON(tracksJson)
                            }
                            result.success(null)
                        }
                        "getTrackCacheSize" -> {
                            val size = withContext(Dispatchers.IO) {
                                Gobackend.getTrackCacheSize()
                            }
                            result.success(size.toInt())
                        }
                        "clearTrackCache" -> {
                            withContext(Dispatchers.IO) {
                                Gobackend.clearTrackIDCache()
                            }
                            result.success(null)
                        }
                        // Deezer API methods
                        "searchDeezerAll" -> {
                            val query = call.argument<String>("query") ?: ""
                            val trackLimit = call.argument<Int>("track_limit") ?: 15
                            val artistLimit = call.argument<Int>("artist_limit") ?: 3
                            val response = withContext(Dispatchers.IO) {
                                Gobackend.searchDeezerAll(query, trackLimit.toLong(), artistLimit.toLong())
                            }
                            result.success(response)
                        }
                        "getDeezerMetadata" -> {
                            val resourceType = call.argument<String>("resource_type") ?: ""
                            val resourceId = call.argument<String>("resource_id") ?: ""
                            val response = withContext(Dispatchers.IO) {
                                Gobackend.getDeezerMetadata(resourceType, resourceId)
                            }
                            result.success(response)
                        }
                        "parseDeezerUrl" -> {
                            val url = call.argument<String>("url") ?: ""
                            val response = withContext(Dispatchers.IO) {
                                Gobackend.parseDeezerURLExport(url)
                            }
                            result.success(response)
                        }
                        "searchDeezerByISRC" -> {
                            val isrc = call.argument<String>("isrc") ?: ""
                            val response = withContext(Dispatchers.IO) {
                                Gobackend.searchDeezerByISRC(isrc)
                            }
                            result.success(response)
                        }
                        "getDeezerExtendedMetadata" -> {
                            val trackId = call.argument<String>("track_id") ?: ""
                            val response = withContext(Dispatchers.IO) {
                                Gobackend.getDeezerExtendedMetadata(trackId)
                            }
                            result.success(response)
                        }
                        "convertSpotifyToDeezer" -> {
                            val resourceType = call.argument<String>("resource_type") ?: ""
                            val spotifyId = call.argument<String>("spotify_id") ?: ""
                            val response = withContext(Dispatchers.IO) {
                                Gobackend.convertSpotifyToDeezer(resourceType, spotifyId)
                            }
                            result.success(response)
                        }
                        "getSpotifyMetadataWithFallback" -> {
                            val url = call.argument<String>("url") ?: ""
                            val response = withContext(Dispatchers.IO) {
                                Gobackend.getSpotifyMetadataWithDeezerFallback(url)
                            }
                            result.success(response)
                        }
                        "checkAvailabilityFromDeezerID" -> {
                            val deezerTrackId = call.argument<String>("deezer_track_id") ?: ""
                            val response = withContext(Dispatchers.IO) {
                                Gobackend.checkAvailabilityFromDeezerID(deezerTrackId)
                            }
                            result.success(response)
                        }
                        "checkAvailabilityByPlatformID" -> {
                            val platform = call.argument<String>("platform") ?: ""
                            val entityType = call.argument<String>("entity_type") ?: ""
                            val entityId = call.argument<String>("entity_id") ?: ""
                            val response = withContext(Dispatchers.IO) {
                                Gobackend.checkAvailabilityByPlatformID(platform, entityType, entityId)
                            }
                            result.success(response)
                        }
                        "getSpotifyIDFromDeezerTrack" -> {
                            val deezerTrackId = call.argument<String>("deezer_track_id") ?: ""
                            val response = withContext(Dispatchers.IO) {
                                Gobackend.getSpotifyIDFromDeezerTrack(deezerTrackId)
                            }
                            result.success(response)
                        }
                        "getTidalURLFromDeezerTrack" -> {
                            val deezerTrackId = call.argument<String>("deezer_track_id") ?: ""
                            val response = withContext(Dispatchers.IO) {
                                Gobackend.getTidalURLFromDeezerTrack(deezerTrackId)
                            }
                            result.success(response)
                        }
                        "getAmazonURLFromDeezerTrack" -> {
                            val deezerTrackId = call.argument<String>("deezer_track_id") ?: ""
                            val response = withContext(Dispatchers.IO) {
                                Gobackend.getAmazonURLFromDeezerTrack(deezerTrackId)
                            }
                            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)
                        }
                        "invokeExtensionAction" -> {
                            val extensionId = call.argument<String>("extension_id") ?: ""
                            val actionName = call.argument<String>("action") ?: ""
                            val response = withContext(Dispatchers.IO) {
                                Gobackend.invokeExtensionActionJSON(extensionId, actionName)
                            }
                            result.success(response)
                        }
                        "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)
                        }
                        "enrichTrackWithExtension" -> {
                            val extensionId = call.argument<String>("extension_id") ?: ""
                            val trackJson = call.argument<String>("track") ?: "{}"
                            val response = withContext(Dispatchers.IO) {
                                Gobackend.enrichTrackWithExtensionJSON(extensionId, trackJson)
                            }
                            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 URL Handler API
                        "handleURLWithExtension" -> {
                            val url = call.argument<String>("url") ?: ""
                            val response = withContext(Dispatchers.IO) {
                                Gobackend.handleURLWithExtensionJSON(url)
                            }
                            result.success(response)
                        }
                        "findURLHandler" -> {
                            val url = call.argument<String>("url") ?: ""
                            val response = withContext(Dispatchers.IO) {
                                Gobackend.findURLHandlerJSON(url)
                            }
                            result.success(response)
                        }
                        "getURLHandlers" -> {
                            val response = withContext(Dispatchers.IO) {
                                Gobackend.getURLHandlersJSON()
                            }
                            result.success(response)
                        }
                        "getAlbumWithExtension" -> {
                            val extensionId = call.argument<String>("extension_id") ?: ""
                            val albumId = call.argument<String>("album_id") ?: ""
                            val response = withContext(Dispatchers.IO) {
                                Gobackend.getAlbumWithExtensionJSON(extensionId, albumId)
                            }
                            result.success(response)
                        }
                        "getPlaylistWithExtension" -> {
                            val extensionId = call.argument<String>("extension_id") ?: ""
                            val playlistId = call.argument<String>("playlist_id") ?: ""
                            val response = withContext(Dispatchers.IO) {
                                Gobackend.getPlaylistWithExtensionJSON(extensionId, playlistId)
                            }
                            result.success(response)
                        }
                        "getArtistWithExtension" -> {
                            val extensionId = call.argument<String>("extension_id") ?: ""
                            val artistId = call.argument<String>("artist_id") ?: ""
                            val response = withContext(Dispatchers.IO) {
                                Gobackend.getArtistWithExtensionJSON(extensionId, artistId)
                            }
                            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)
                        }
                        // Extension Store
                        "initExtensionStore" -> {
                            val cacheDir = call.argument<String>("cache_dir") ?: ""
                            withContext(Dispatchers.IO) {
                                Gobackend.initExtensionStoreJSON(cacheDir)
                            }
                            result.success(null)
                        }
                        "getStoreExtensions" -> {
                            val forceRefresh = call.argument<Boolean>("force_refresh") ?: false
                            val response = withContext(Dispatchers.IO) {
                                Gobackend.getStoreExtensionsJSON(forceRefresh)
                            }
                            result.success(response)
                        }
                        "searchStoreExtensions" -> {
                            val query = call.argument<String>("query") ?: ""
                            val category = call.argument<String>("category") ?: ""
                            val response = withContext(Dispatchers.IO) {
                                Gobackend.searchStoreExtensionsJSON(query, category)
                            }
                            result.success(response)
                        }
                        "getStoreCategories" -> {
                            val response = withContext(Dispatchers.IO) {
                                Gobackend.getStoreCategoriesJSON()
                            }
                            result.success(response)
                        }
                        "downloadStoreExtension" -> {
                            val extensionId = call.argument<String>("extension_id") ?: ""
                            val destDir = call.argument<String>("dest_dir") ?: ""
                            val response = withContext(Dispatchers.IO) {
                                Gobackend.downloadStoreExtensionJSON(extensionId, destDir)
                            }
                            result.success(response)
                        }
                        "clearStoreCache" -> {
                            withContext(Dispatchers.IO) {
                                Gobackend.clearStoreCacheJSON()
                            }
                            result.success(null)
                        }
                        // Extension Home Feed (Explore)
                        "getExtensionHomeFeed" -> {
                            val extensionId = call.argument<String>("extension_id") ?: ""
                            val response = withContext(Dispatchers.IO) {
                                Gobackend.getExtensionHomeFeedJSON(extensionId)
                            }
                            result.success(response)
                        }
                        "getExtensionBrowseCategories" -> {
                            val extensionId = call.argument<String>("extension_id") ?: ""
                            val response = withContext(Dispatchers.IO) {
                                Gobackend.getExtensionBrowseCategoriesJSON(extensionId)
                            }
                            result.success(response)
                        }
                        else -> result.notImplemented()
                    }
                } catch (e: Exception) {
@@ -215,5 +767,37 @@ class MainActivity: FlutterActivity() {
                }
            }
        }
        // FFmpeg method channel
        MethodChannel(flutterEngine.dartExecutor.binaryMessenger, FFMPEG_CHANNEL).setMethodCallHandler { call, result ->
            scope.launch {
                try {
                    when (call.method) {
                        "execute" -> {
                            val command = call.argument<String>("command") ?: ""
                            val session = withContext(Dispatchers.IO) {
                                FFmpegKit.execute(command)
                            }
                            val returnCode = session.returnCode
                            val output = session.output ?: ""
                            result.success(mapOf(
                                "success" to ReturnCode.isSuccess(returnCode),
                                "returnCode" to (returnCode?.value ?: -1),
                                "output" to output
                            ))
                        }
                        "getVersion" -> {
                            val session = withContext(Dispatchers.IO) {
                                FFmpegKit.execute("-version")
                            }
                            result.success(session.output ?: "unknown")
                        }
                        else -> result.notImplemented()
                    }
                } catch (e: Exception) {
                    result.error("FFMPEG_ERROR", e.message, null)
                }
            }
        }
    }
 }
@@ -0,0 +1,335 @@
 import 'dart:io';
 import 'package:ffmpeg_kit_flutter_new_audio/ffmpeg_kit.dart';
 import 'package:ffmpeg_kit_flutter_new_audio/return_code.dart';
 import 'package:spotiflac_android/utils/logger.dart';
 final _log = AppLogger('FFmpeg');
 /// FFmpeg service for iOS using ffmpeg_kit_flutter plugin
 class FFmpegServiceIOS {
  /// Execute FFmpeg command and return result
  static Future<FFmpegResultIOS> _execute(String command) async {
    try {
      final session = await FFmpegKit.execute(command);
      final returnCode = await session.getReturnCode();
      final output = await session.getOutput() ?? '';
      return FFmpegResultIOS(
        success: ReturnCode.isSuccess(returnCode),
        returnCode: returnCode?.getValue() ?? -1,
        output: output,
      );
    } catch (e) {
      _log.e('FFmpeg execute error: $e');
      return FFmpegResultIOS(success: false, returnCode: -1, output: e.toString());
    }
  }
  /// Convert M4A (DASH segments) to FLAC
  static Future<String?> convertM4aToFlac(String inputPath) async {
    final outputPath = inputPath.replaceAll('.m4a', '.flac');
    final command = '-i "$inputPath" -c:a flac -compression_level 8 "$outputPath" -y';
    final result = await _execute(command);
    if (result.success) {
      try {
        await File(inputPath).delete();
      } catch (_) {}
      return outputPath;
    }
    _log.e('M4A to FLAC conversion failed: ${result.output}');
    return null;
  }
  /// Convert FLAC to MP3
  /// If deleteOriginal is true, deletes the FLAC file after conversion
  static Future<String?> convertFlacToMp3(
    String inputPath, {
    String bitrate = '320k',
    bool deleteOriginal = true,
  }) async {
    // Convert in same folder, just change extension
    final outputPath = inputPath.replaceAll('.flac', '.mp3');
    final command = '-i "$inputPath" -codec:a libmp3lame -b:a $bitrate -map 0:a -map_metadata 0 -id3v2_version 3 "$outputPath" -y';
    final result = await _execute(command);
    if (result.success) {
      // Delete original FLAC if requested
      if (deleteOriginal) {
        try {
          await File(inputPath).delete();
        } catch (_) {}
      }
      return outputPath;
    }
    _log.e('FLAC to MP3 conversion failed: ${result.output}');
    return null;
  }
  /// Convert FLAC to M4A
  static Future<String?> convertFlacToM4a(String inputPath, {String codec = 'aac', String bitrate = '256k'}) async {
    final dir = File(inputPath).parent.path;
    final baseName = inputPath.split(Platform.pathSeparator).last.replaceAll('.flac', '');
    final outputDir = '$dir${Platform.pathSeparator}M4A';
    await Directory(outputDir).create(recursive: true);
    final outputPath = '$outputDir${Platform.pathSeparator}$baseName.m4a';
    String command;
    if (codec == 'alac') {
      command = '-i "$inputPath" -codec:a alac -map 0:a -map_metadata 0 "$outputPath" -y';
    } else {
      command = '-i "$inputPath" -codec:a aac -b:a $bitrate -map 0:a -map_metadata 0 "$outputPath" -y';
    }
    final result = await _execute(command);
    if (result.success) return outputPath;
    _log.e('FLAC to M4A conversion failed: ${result.output}');
    return null;
  }
  /// Embed cover art to FLAC file
  static Future<String?> embedCover(String flacPath, String coverPath) async {
    final tempOutput = '$flacPath.tmp';
    final command = '-i "$flacPath" -i "$coverPath" -map 0:a -map 1:0 -c copy -metadata:s:v title="Album cover" -metadata:s:v comment="Cover (front)" -disposition:v attached_pic "$tempOutput" -y';
    final result = await _execute(command);
    if (result.success) {
      try {
        await File(flacPath).delete();
        await File(tempOutput).rename(flacPath);
        return flacPath;
      } catch (e) {
        _log.e('Failed to replace file after cover embed: $e');
        return null;
      }
    }
    try {
      final tempFile = File(tempOutput);
      if (await tempFile.exists()) await tempFile.delete();
    } catch (_) {}
    _log.e('Cover embed failed: ${result.output}');
    return null;
  }
  /// Embed metadata and cover art to FLAC file
  /// Returns the file path on success, null on failure
  static Future<String?> embedMetadata({
    required String flacPath,
    String? coverPath,
    Map<String, String>? metadata,
  }) async {
    final tempOutput = '$flacPath.tmp';
    // Construct command
    final StringBuffer cmdBuffer = StringBuffer();
    cmdBuffer.write('-i "$flacPath" ');
    // Add cover input if available
    if (coverPath != null) {
      cmdBuffer.write('-i "$coverPath" ');
    }
    // Map audio stream
    cmdBuffer.write('-map 0:a ');
    // Map cover stream if available
    if (coverPath != null) {
      cmdBuffer.write('-map 1:0 ');
      cmdBuffer.write('-c:v copy ');
      cmdBuffer.write('-disposition:v attached_pic ');
      cmdBuffer.write('-metadata:s:v title="Album cover" ');
      cmdBuffer.write('-metadata:s:v comment="Cover (front)" ');
    }
    // Copy audio codec (don't re-encode)
    cmdBuffer.write('-c:a copy ');
    // Add text metadata
    if (metadata != null) {
      metadata.forEach((key, value) {
        // Sanitize value: escape double quotes
        final sanitizedValue = value.replaceAll('"', '\\"');
        cmdBuffer.write('-metadata $key="$sanitizedValue" ');
      });
    }
    cmdBuffer.write('"$tempOutput" -y');
    final command = cmdBuffer.toString();
    _log.d('Executing FFmpeg command: $command');
    final result = await _execute(command);
    if (result.success) {
      try {
        await File(flacPath).delete();
        await File(tempOutput).rename(flacPath);
        return flacPath;
      } catch (e) {
        _log.e('Failed to replace file after metadata embed: $e');
        return null;
      }
    }
    // Clean up temp file if exists
    try {
      final tempFile = File(tempOutput);
      if (await tempFile.exists()) {
        await tempFile.delete();
      }
    } catch (_) {}
    _log.e('Metadata/Cover embed failed: ${result.output}');
    return null;
  }
  /// Embed metadata and cover art to MP3 file using ID3v2 tags
  /// Returns the file path on success, null on failure
  static Future<String?> embedMetadataToMp3({
    required String mp3Path,
    String? coverPath,
    Map<String, String>? metadata,
  }) async {
    final tempOutput = '$mp3Path.tmp';
    final StringBuffer cmdBuffer = StringBuffer();
    cmdBuffer.write('-i "$mp3Path" ');
    if (coverPath != null) {
      cmdBuffer.write('-i "$coverPath" ');
    }
    cmdBuffer.write('-map 0:a ');
    if (coverPath != null) {
      cmdBuffer.write('-map 1:0 ');
      cmdBuffer.write('-c:v:0 copy ');
      cmdBuffer.write('-id3v2_version 3 ');
      cmdBuffer.write('-metadata:s:v title="Album cover" ');
      cmdBuffer.write('-metadata:s:v comment="Cover (front)" ');
    }
    cmdBuffer.write('-c:a copy ');
    if (metadata != null) {
      // Convert FLAC/Vorbis tags to ID3v2 tags for MP3
      final id3Metadata = _convertToId3Tags(metadata);
      id3Metadata.forEach((key, value) {
        final sanitizedValue = value.replaceAll('"', '\\"');
        cmdBuffer.write('-metadata $key="$sanitizedValue" ');
      });
    }
    cmdBuffer.write('-id3v2_version 3 "$tempOutput" -y');
    final command = cmdBuffer.toString();
    _log.d('Executing FFmpeg MP3 embed command: $command');
    final result = await _execute(command);
    if (result.success) {
      try {
        await File(mp3Path).delete();
        await File(tempOutput).rename(mp3Path);
        _log.d('MP3 metadata embedded successfully');
        return mp3Path;
      } catch (e) {
        _log.e('Failed to replace MP3 file after metadata embed: $e');
        return null;
      }
    }
    try {
      final tempFile = File(tempOutput);
      if (await tempFile.exists()) {
        await tempFile.delete();
      }
    } catch (_) {}
    _log.e('MP3 Metadata/Cover embed failed: ${result.output}');
    return null;
  }
  /// Convert FLAC/Vorbis comment tags to ID3v2 compatible tags
  static Map<String, String> _convertToId3Tags(Map<String, String> vorbisMetadata) {
    final id3Map = <String, String>{};
    for (final entry in vorbisMetadata.entries) {
      final key = entry.key.toUpperCase();
      final value = entry.value;
      // Map Vorbis comments to ID3v2 frame names
      switch (key) {
        case 'TITLE':
          id3Map['title'] = value;
          break;
        case 'ARTIST':
          id3Map['artist'] = value;
          break;
        case 'ALBUM':
          id3Map['album'] = value;
          break;
        case 'ALBUMARTIST':
          id3Map['album_artist'] = value;
          break;
        case 'TRACKNUMBER':
        case 'TRACK':
          id3Map['track'] = value;
          break;
        case 'DISCNUMBER':
        case 'DISC':
          id3Map['disc'] = value;
          break;
        case 'DATE':
        case 'YEAR':
          id3Map['date'] = value;
          break;
        case 'ISRC':
          id3Map['TSRC'] = value; // ID3v2 ISRC frame
          break;
        case 'LYRICS':
        case 'UNSYNCEDLYRICS':
          id3Map['lyrics'] = value;
          break;
        default:
          // Pass through other tags as-is
          id3Map[key.toLowerCase()] = value;
      }
    }
    return id3Map;
  }
  /// Check if FFmpeg is available
  static Future<bool> isAvailable() async {
    try {
      final session = await FFmpegKit.execute('-version');
      final returnCode = await session.getReturnCode();
      return ReturnCode.isSuccess(returnCode);
    } catch (e) {
      return false;
    }
  }
  /// Get FFmpeg version info
  static Future<String?> getVersion() async {
    try {
      final session = await FFmpegKit.execute('-version');
      return await session.getOutput();
    } catch (e) {
      return null;
    }
  }
 }
 class FFmpegResultIOS {
  final bool success;
  final int returnCode;
  final String output;
  FFmpegResultIOS({required this.success, required this.returnCode, required this.output});
 }
@@ -0,0 +1,19 @@
 files:
  - source: /lib/l10n/arb/app_en.arb
    translation: /lib/l10n/arb/app_%locale%.arb
    languages_mapping:
      locale:
        # Short codes for single-variant languages
        de: de
        es: es
        fr: fr
        hi: hi
        id: id
        ja: ja
        ko: ko
        nl: nl
        pt: pt
        ru: ru
        # Full codes for Chinese variants
        zh-CN: zh_CN
        zh-TW: zh_TW
@@ -1,8 +1,11 @@
 package gobackend
 import (
 	"bufio"
 	"context"
 	"encoding/base64"
 	"encoding/json"
 	"errors"
 	"fmt"
 	"io"
 	"net/http"
@@ -10,22 +13,30 @@ import (
 	"os"
 	"path/filepath"
 	"strings"
 	"sync"
 	"time"
 )
 // AmazonDownloader handles Amazon Music downloads using DoubleDouble service (same as PC)
 type AmazonDownloader struct {
-	client  *http.Client
+	client           *http.Client
-	regions []string // us, eu regions for DoubleDouble service
+	regions          []string
 	lastAPICallTime  time.Time
 	apiCallCount     int
 	apiCallResetTime time.Time
 }
 var (
 	globalAmazonDownloader *AmazonDownloader
 	amazonDownloaderOnce   sync.Once
 	amazonRateLimitMu      sync.Mutex
 )
 // DoubleDoubleSubmitResponse is the response from DoubleDouble submit endpoint
 type DoubleDoubleSubmitResponse struct {
 	Success bool   `json:"success"`
 	ID      string `json:"id"`
 }
 // DoubleDoubleStatusResponse is the response from DoubleDouble status endpoint
 type DoubleDoubleStatusResponse struct {
 	Status         string `json:"status"`
 	FriendlyStatus string `json:"friendlyStatus"`
@@ -36,54 +47,46 @@ type DoubleDoubleStatusResponse struct {
 	} `json:"current"`
 }
 // amazonArtistsMatch checks if the artist names are similar enough
 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
 }
 // amazonIsASCIIString checks if a string contains only ASCII characters
 func amazonIsASCIIString(s string) bool {
 	for _, r := range s {
 		if r > 127 {
@@ -93,15 +96,53 @@ func amazonIsASCIIString(s string) bool {
 	return true
 }
 // NewAmazonDownloader creates a new Amazon downloader using DoubleDouble service
 func NewAmazonDownloader() *AmazonDownloader {
-	return &AmazonDownloader{
+	amazonDownloaderOnce.Do(func() {
-		client:  NewHTTPClientWithTimeout(120 * time.Second), // 120s timeout like PC
+		globalAmazonDownloader = &AmazonDownloader{
-		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
 func (a *AmazonDownloader) waitForRateLimit() {
 	amazonRateLimitMu.Lock()
 	defer amazonRateLimitMu.Unlock()
 	now := time.Now()
 	if now.Sub(a.apiCallResetTime) >= time.Minute {
 		a.apiCallCount = 0
 		a.apiCallResetTime = now
 	}
 	if a.apiCallCount >= 9 {
 		waitTime := time.Minute - now.Sub(a.apiCallResetTime)
 		if waitTime > 0 {
 			GoLog("[Amazon] Rate limit reached, waiting %v...\n", waitTime.Round(time.Second))
 			time.Sleep(waitTime)
 			a.apiCallCount = 0
 			a.apiCallResetTime = time.Now()
 		}
 	}
 	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)
 		}
 	}
 	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 {
 	// DoubleDouble service regions (same as PC)
@@ -113,26 +154,24 @@ 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
+		serviceBase, _ := base64.StdEncoding.DecodeString("aHR0cHM6Ly8=")               // https://
 		// Decode base64 service URL (same as PC)
 		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
 		encodedURL := url.QueryEscape(amazonURL)
 		submitURL := fmt.Sprintf("%s/dl?url=%s", baseURL, encodedURL)
 		a.waitForRateLimit()
 		req, err := http.NewRequest("GET", submitURL, nil)
 		if err != nil {
 			lastError = fmt.Errorf("failed to create request: %w", err)
@@ -142,15 +181,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 {
+		// Retry logic for 429 errors (like PC version: 3 retries with 15s wait)
-			lastError = fmt.Errorf("failed to submit request: %w", err)
+		var resp *http.Response
-			continue
+		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 {
+		if err != nil || lastError != nil {
-			resp.Body.Close()
+			if resp != nil {
-			lastError = fmt.Errorf("submit failed with status %d", resp.StatusCode)
+				resp.Body.Close()
 			}
 			continue
 		}
@@ -168,7 +235,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)
@@ -212,7 +279,6 @@ func (a *AmazonDownloader) downloadFromDoubleDoubleService(amazonURL, outputDir
 			if status.Status == "done" {
 				fmt.Println("\n[Amazon] Download ready!")
 				// Build download URL
 				fileURL := status.URL
 				if strings.HasPrefix(fileURL, "./") {
 					fileURL = fmt.Sprintf("%s/%s", baseURL, fileURL[2:])
@@ -223,7 +289,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" {
@@ -257,16 +323,22 @@ 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 {
 	ctx := context.Background()
 	// Initialize item progress (required for all downloads)
 	if itemID != "" {
 		StartItemProgress(itemID)
 		defer CompleteItemProgress(itemID)
 		ctx = initDownloadCancel(itemID)
 		defer clearDownloadCancel(itemID)
 	}
-	req, err := http.NewRequest("GET", downloadURL, nil)
+	if isDownloadCancelled(itemID) {
 		return ErrDownloadCancelled
 	}
 	req, err := http.NewRequestWithContext(ctx, "GET", downloadURL, nil)
 	if err != nil {
 		return fmt.Errorf("failed to create request: %w", err)
 	}
@@ -275,6 +347,9 @@ func (a *AmazonDownloader) DownloadFile(downloadURL, outputPath, itemID string)
 	resp, err := a.client.Do(req)
 	if err != nil {
 		if isDownloadCancelled(itemID) {
 			return ErrDownloadCancelled
 		}
 		return err
 	}
 	defer resp.Body.Close()
@@ -283,54 +358,92 @@ func (a *AmazonDownloader) DownloadFile(downloadURL, outputPath, itemID string)
 		return fmt.Errorf("download failed: HTTP %d", resp.StatusCode)
 	}
-	// Set total bytes if available
+	expectedSize := resp.ContentLength
-	if resp.ContentLength > 0 && itemID != "" {
+	if expectedSize > 0 && itemID != "" {
-		SetItemBytesTotal(itemID, resp.ContentLength)
+		SetItemBytesTotal(itemID, expectedSize)
 	}
 	out, err := os.Create(outputPath)
 	if err != nil {
 		return err
 	}
 	defer out.Close()
-	// Use item progress writer
+	bufWriter := bufio.NewWriterSize(out, 256*1024)
-	var bytesWritten int64
+
 	var written int64
 	if itemID != "" {
-		pw := NewItemProgressWriter(out, 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
+		written, err = io.Copy(bufWriter, resp.Body)
 		bytesWritten, err = io.Copy(out, resp.Body)
 	}
 	if err != nil {
 		return fmt.Errorf("failed to write file: %w", err)
 	}
-	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()
 	if err != nil {
 		os.Remove(outputPath)
 		if isDownloadCancelled(itemID) {
 			return ErrDownloadCancelled
 		}
 		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
+	FilePath    string
-	BitDepth   int
+	BitDepth    int
-	SampleRate 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
 // Uses DoubleDouble service (same as PC version)
 func downloadFromAmazon(req DownloadRequest) (AmazonDownloadResult, error) {
 	downloader := NewAmazonDownloader()
 	// Check for existing file first
 	if existingFile, exists := checkISRCExistsInternal(req.OutputDir, req.ISRC); exists {
 		return AmazonDownloadResult{FilePath: "EXISTS:" + existingFile}, nil
 	}
 	// Get Amazon URL from SongLink
 	songlink := NewSongLinkClient()
-	availability, err := songlink.CheckTrackAvailability(req.SpotifyID, req.ISRC)
+	var availability *TrackAvailability
 	var err error
 	if strings.HasPrefix(req.SpotifyID, "deezer:") {
 		deezerID := strings.TrimPrefix(req.SpotifyID, "deezer:")
 		GoLog("[Amazon] Using Deezer ID for SongLink lookup: %s\n", deezerID)
 		availability, err = songlink.CheckAvailabilityFromDeezer(deezerID)
 	} else if req.SpotifyID != "" {
 		availability, err = songlink.CheckTrackAvailability(req.SpotifyID, req.ISRC)
 	} else {
 		return AmazonDownloadResult{}, fmt.Errorf("no valid Spotify or Deezer ID provided for Amazon lookup")
 	}
 	if err != nil {
 		return AmazonDownloadResult{}, fmt.Errorf("failed to check Amazon availability via SongLink: %w", err)
 	}
@@ -339,7 +452,6 @@ func downloadFromAmazon(req DownloadRequest) (AmazonDownloadResult, error) {
 		return AmazonDownloadResult{}, fmt.Errorf("track not available on Amazon Music (SongLink returned no Amazon URL)")
 	}
 	// Create output directory if needed
 	if req.OutputDir != "." {
 		if err := os.MkdirAll(req.OutputDir, 0755); err != nil {
 			return AmazonDownloadResult{}, fmt.Errorf("failed to create output directory: %w", err)
@@ -354,14 +466,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
+	GoLog("[Amazon] Match found: '%s' by '%s'\n", trackName, artistName)
 	fmt.Printf("[Amazon] Match found: '%s' by '%s'\n", trackName, artistName)
 	// Build filename using Spotify metadata (more accurate)
 	filename := buildFilenameFromTemplate(req.FilenameFormat, map[string]interface{}{
 		"title":  req.TrackName,
 		"artist": req.ArtistName,
@@ -373,18 +483,37 @@ func downloadFromAmazon(req DownloadRequest) (AmazonDownloadResult, error) {
 	filename = sanitizeFilename(filename) + ".flac"
 	outputPath := filepath.Join(req.OutputDir, filename)
 	// Check if file already exists
 	if fileInfo, statErr := os.Stat(outputPath); statErr == nil && fileInfo.Size() > 0 {
 		return AmazonDownloadResult{FilePath: "EXISTS:" + outputPath}, nil
 	}
-	// Download file with item ID for progress tracking
+	// START PARALLEL: Fetch cover and lyrics while downloading audio
 	var parallelResult *ParallelDownloadResult
 	parallelDone := make(chan struct{})
 	go func() {
 		defer close(parallelDone)
 		parallelResult = FetchCoverAndLyricsParallel(
 			req.CoverURL,
 			req.EmbedMaxQualityCover,
 			req.SpotifyID,
 			req.TrackName,
 			req.ArtistName,
 			req.EmbedLyrics,
 			int64(req.DurationMS),
 		)
 	}()
 	// Download audio file with item ID for progress tracking
 	if err := downloader.DownloadFile(downloadURL, outputPath, req.ItemID); err != nil {
 		if errors.Is(err, ErrDownloadCancelled) {
 			return AmazonDownloadResult{}, ErrDownloadCancelled
 		}
 		return AmazonDownloadResult{}, fmt.Errorf("download failed: %w", err)
 	}
-	// Set progress to 100% and status to finalizing (before embedding)
+	// Wait for parallel operations to complete
-	// This makes the UI show "Finalizing..." while embedding happens
+	<-parallelDone
 	if req.ItemID != "" {
 		SetItemProgress(req.ItemID, 1.0, 0, 0)
 		SetItemFinalizing(req.ItemID)
@@ -392,78 +521,119 @@ 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)
 	}
 	existingMeta, metaErr := ReadMetadata(outputPath)
 	actualTrackNum := req.TrackNumber
 	actualDiscNum := req.DiscNumber
 	if metaErr == nil && existingMeta != nil {
 		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,
 		Genre:       req.Genre,     // From Deezer album metadata
 		Label:       req.Label,     // From Deezer album metadata
 		Copyright:   req.Copyright, // From Deezer album metadata
 	}
-	// Download cover to memory (avoids file permission issues on Android)
+	// Use cover data from parallel fetch
 	var coverData []byte
-	if req.CoverURL != "" {
+	if parallelResult != nil && parallelResult.CoverData != nil {
-		fmt.Println("[Amazon] Downloading cover to memory...")
+		coverData = parallelResult.CoverData
-		data, err := downloadCoverToMemory(req.CoverURL, req.EmbedMaxQualityCover)
+		GoLog("[Amazon] Using parallel-fetched cover (%d bytes)\n", len(coverData))
 		if err == nil {
 			coverData = data
 			fmt.Printf("[Amazon] Cover downloaded successfully (%d bytes)\n", len(coverData))
 		} else {
 			fmt.Printf("[Amazon] Warning: failed to download cover: %v\n", err)
 		}
 	}
 	if err := EmbedMetadataWithCoverData(outputPath, metadata, coverData); err != nil {
 		fmt.Printf("Warning: failed to embed metadata: %v\n", err)
 	}
-	// Embed lyrics if enabled
+	if req.EmbedLyrics && parallelResult != nil && parallelResult.LyricsLRC != "" {
-	if req.EmbedLyrics {
+		lyricsMode := req.LyricsMode
-		fmt.Println("[Amazon] Fetching lyrics...")
+		if lyricsMode == "" {
-		lyricsClient := NewLyricsClient()
+			lyricsMode = "embed" // default
-		lyrics, lyricsErr := lyricsClient.FetchLyricsAllSources(req.SpotifyID, req.TrackName, req.ArtistName)
+		}
-		if lyricsErr != nil {
+
-			fmt.Printf("[Amazon] Warning: lyrics fetch error: %v\n", lyricsErr)
+		if lyricsMode == "external" || lyricsMode == "both" {
-		} else if lyrics == nil || len(lyrics.Lines) == 0 {
+			GoLog("[Amazon] Saving external LRC file...\n")
-			fmt.Println("[Amazon] No lyrics found for this track")
+			if lrcPath, lrcErr := SaveLRCFile(outputPath, parallelResult.LyricsLRC); lrcErr != nil {
-		} else {
+				GoLog("[Amazon] Warning: failed to save LRC file: %v\n", lrcErr)
-			fmt.Printf("[Amazon] Lyrics found (%d lines), embedding...\n", len(lyrics.Lines))
+			} else {
-			lrcContent := convertToLRC(lyrics)
+				GoLog("[Amazon] LRC file saved: %s\n", lrcPath)
-			if embedErr := EmbedLyrics(outputPath, lrcContent); embedErr != nil {
+			}
-				fmt.Printf("[Amazon] Warning: failed to embed lyrics: %v\n", embedErr)
+		}
 		if lyricsMode == "embed" || lyricsMode == "both" {
 			GoLog("[Amazon] Embedding parallel-fetched lyrics (%d lines)...\n", len(parallelResult.LyricsData.Lines))
 			if embedErr := EmbedLyrics(outputPath, parallelResult.LyricsLRC); embedErr != nil {
 				GoLog("[Amazon] Warning: failed to embed lyrics: %v\n", embedErr)
 			} else {
 				fmt.Println("[Amazon] Lyrics embedded successfully")
 			}
 		}
 	} else if req.EmbedLyrics {
 		fmt.Println("[Amazon] No lyrics available from parallel fetch")
 	}
 	fmt.Println("[Amazon] ✓ Downloaded successfully from Amazon Music")
-	
+
 	// 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)
+		GoLog("[Amazon] Warning: couldn't read quality from file: %v\n", err)
-		// Return 0 to indicate unknown quality
+	} else {
-		return AmazonDownloadResult{
+		GoLog("[Amazon] Actual quality: %d-bit/%dHz\n", quality.BitDepth, quality.SampleRate)
 			FilePath:   outputPath,
 			BitDepth:   0,
 			SampleRate: 0,
 		}, nil
 	}
-	
+
-	fmt.Printf("[Amazon] Actual quality: %d-bit/%dHz\n", quality.BitDepth, quality.SampleRate)
+	finalMeta, metaReadErr := ReadMetadata(outputPath)
 	if metaReadErr == nil && finalMeta != nil {
 		GoLog("[Amazon] Final metadata from file - Track: %d, Disc: %d, Date: %s\n",
 			finalMeta.TrackNumber, finalMeta.DiscNumber, finalMeta.Date)
 		actualTrackNum = finalMeta.TrackNumber
 		actualDiscNum = finalMeta.DiscNumber
 		if finalMeta.Date != "" {
 			req.ReleaseDate = finalMeta.Date
 		}
 	}
 	// Add to ISRC index for fast duplicate checking
 	AddToISRCIndex(req.OutputDir, req.ISRC, outputPath)
 	bitDepth := 0
 	sampleRate := 0
 	if err == nil {
 		bitDepth = quality.BitDepth
 		sampleRate = quality.SampleRate
 	}
 	return AmazonDownloadResult{
-		FilePath:   outputPath,
+		FilePath:    outputPath,
-		BitDepth:   quality.BitDepth,
+		BitDepth:    bitDepth,
-		SampleRate: quality.SampleRate,
+		SampleRate:  sampleRate,
 		Title:       req.TrackName,
 		Artist:      req.ArtistName,
 		Album:       req.AlbumName,
 		ReleaseDate: req.ReleaseDate,
 		TrackNumber: actualTrackNum,
 		DiscNumber:  actualDiscNum,
 		ISRC:        req.ISRC,
 	}, nil
 }
@@ -0,0 +1,78 @@
 package gobackend
 import (
 	"context"
 	"errors"
 	"sync"
 )
 // ErrDownloadCancelled is returned when a download is cancelled by the user.
 var ErrDownloadCancelled = errors.New("download cancelled")
 type cancelEntry struct {
 	cancel   context.CancelFunc
 	canceled bool
 }
 var (
 	cancelMu  sync.Mutex
 	cancelMap = make(map[string]*cancelEntry)
 )
 func initDownloadCancel(itemID string) context.Context {
 	if itemID == "" {
 		return context.Background()
 	}
 	cancelMu.Lock()
 	defer cancelMu.Unlock()
 	ctx, cancel := context.WithCancel(context.Background())
 	cancelMap[itemID] = &cancelEntry{
 		cancel:   cancel,
 		canceled: false,
 	}
 	return ctx
 }
 func cancelDownload(itemID string) {
 	if itemID == "" {
 		return
 	}
 	cancelMu.Lock()
 	entry, ok := cancelMap[itemID]
 	if ok {
 		entry.canceled = true
 		if entry.cancel != nil {
 			entry.cancel()
 		}
 	} else {
 		cancelMap[itemID] = &cancelEntry{canceled: true}
 	}
 	cancelMu.Unlock()
 	RemoveItemProgress(itemID)
 }
 func isDownloadCancelled(itemID string) bool {
 	if itemID == "" {
 		return false
 	}
 	cancelMu.Lock()
 	entry, ok := cancelMap[itemID]
 	canceled := ok && entry.canceled
 	cancelMu.Unlock()
 	return canceled
 }
 func clearDownloadCancel(itemID string) {
 	if itemID == "" {
 		return
 	}
 	cancelMu.Lock()
 	delete(cancelMap, itemID)
 	cancelMu.Unlock()
 }
@@ -4,36 +4,53 @@ import (
 	"fmt"
 	"io"
 	"net/http"
 	"regexp"
 	"strings"
 )
 // Spotify image size codes (same as PC version)
 const (
-	spotifySize640 = "ab67616d0000b273" // 640x640
+	spotifySize300 = "ab67616d00001e02"
-	spotifySizeMax = "ab67616d000082c1" // Max resolution (~2000x2000)
+	spotifySize640 = "ab67616d0000b273"
 	spotifySizeMax = "ab67616d000082c1"
 )
-// downloadCoverToMemory downloads cover art and returns as bytes (no file creation)
+// Deezer CDN supports these sizes: 56, 250, 500, 1000, 1400, 1800
-// This avoids file permission issues on Android
+var deezerSizeRegex = regexp.MustCompile(`/(\d+)x(\d+)-\d+-\d+-\d+-\d+\.jpg$`)
 func convertSmallToMedium(imageURL string) string {
 	if strings.Contains(imageURL, spotifySize300) {
 		return strings.Replace(imageURL, spotifySize300, spotifySize640, 1)
 	}
 	return imageURL
 }
 func downloadCoverToMemory(coverURL string, maxQuality bool) ([]byte, error) {
 	if coverURL == "" {
 		return nil, fmt.Errorf("no cover URL provided")
 	}
-	fmt.Printf("[Cover] Downloading cover from: %s\n", coverURL)
+	GoLog("[Cover] Original URL: %s", coverURL)
 	downloadURL := convertSmallToMedium(coverURL)
 	if downloadURL != coverURL {
 		GoLog("[Cover] Upgraded 300x300 → 640x640")
 	}
 	// Upgrade to max quality if requested
 	downloadURL := coverURL
 	if maxQuality {
-		downloadURL = upgradeToMaxQuality(coverURL)
+		maxURL := upgradeToMaxQuality(downloadURL)
-		if downloadURL != coverURL {
+		if maxURL != downloadURL {
-			fmt.Printf("[Cover] Upgraded to max quality URL: %s\n", downloadURL)
+			downloadURL = maxURL
 			// Log already printed by upgradeToMaxQuality for Deezer
 			if strings.Contains(coverURL, "scdn.co") || strings.Contains(coverURL, "spotifycdn") {
 				GoLog("[Cover] Spotify: upgraded to max resolution (~2000x2000)")
 			}
 		}
 	}
 	GoLog("[Cover] Final URL: %s", downloadURL)
 	client := NewHTTPClientWithTimeout(DefaultTimeout)
 	// Create request with User-Agent (required by Spotify CDN)
 	req, err := http.NewRequest("GET", downloadURL, nil)
 	if err != nil {
 		return nil, fmt.Errorf("failed to create request: %w", err)
@@ -54,48 +71,58 @@ func downloadCoverToMemory(coverURL string, maxQuality bool) ([]byte, error) {
 		return nil, fmt.Errorf("failed to read cover data: %w", err)
 	}
-	fmt.Printf("[Cover] Downloaded %d bytes\n", len(data))
+	sizeKB := len(data) / 1024
 	var resolution string
 	if sizeKB > 200 {
 		resolution = "~2000x2000 (hi-res)"
 	} else if sizeKB > 50 {
 		resolution = "~640x640"
 	} else {
 		resolution = "~300x300"
 	}
 	GoLog("[Cover] Downloaded %d KB (%s)", sizeKB, resolution)
 	return data, nil
 }
 // upgradeToMaxQuality upgrades Spotify cover URL to maximum quality
 // Uses same logic as PC version - replaces 640x640 size code with max resolution
 func upgradeToMaxQuality(coverURL string) string {
-	// Spotify image URLs can be upgraded by changing the size parameter
+	// Spotify CDN upgrade
 	// Format: https://i.scdn.co/image/ab67616d0000b273...
 	// ab67616d0000b273 = 640x640
 	// ab67616d000082c1 = Max resolution (~2000x2000)
 	if strings.Contains(coverURL, spotifySize640) {
-		// Try max resolution first
+		return strings.Replace(coverURL, spotifySize640, spotifySizeMax, 1)
-		maxURL := strings.Replace(coverURL, spotifySize640, spotifySizeMax, 1)
+	}
-		// Verify max resolution URL is available
+	// Deezer CDN upgrade
-		client := NewHTTPClientWithTimeout(DefaultTimeout)
+	if strings.Contains(coverURL, "cdn-images.dzcdn.net") {
-		req, err := http.NewRequest("HEAD", maxURL, nil)
+		return upgradeDeezerCover(coverURL)
 		if err == nil {
 			resp, err := DoRequestWithUserAgent(client, req)
 			if err == nil {
 				resp.Body.Close()
 				if resp.StatusCode == http.StatusOK {
 					return maxURL
 				}
 			}
 		}
 	}
 	return coverURL
 }
-// GetCoverFromSpotify gets cover URL from Spotify metadata
+func upgradeDeezerCover(coverURL string) string {
 	if !strings.Contains(coverURL, "cdn-images.dzcdn.net") {
 		return coverURL
 	}
 	// Replace any size pattern with 1800x1800
 	upgraded := deezerSizeRegex.ReplaceAllString(coverURL, "/1800x1800-000000-80-0-0.jpg")
 	if upgraded != coverURL {
 		GoLog("[Cover] Deezer: upgraded to 1800x1800")
 	}
 	return upgraded
 }
 func GetCoverFromSpotify(imageURL string, maxQuality bool) string {
 	if imageURL == "" {
 		return ""
 	}
 	// Always upgrade small to medium first
 	result := convertSmallToMedium(imageURL)
 	if maxQuality {
-		return upgradeToMaxQuality(imageURL)
+		result = upgradeToMaxQuality(result)
 	}
-	return imageURL
+	return result
 }
@@ -0,0 +1,857 @@
 package gobackend
 import (
 	"context"
 	"encoding/json"
 	"fmt"
 	"io"
 	"net/http"
 	"net/url"
 	"strings"
 	"sync"
 	"time"
 )
 const (
 	deezerBaseURL     = "https://api.deezer.com/2.0"
 	deezerSearchURL   = deezerBaseURL + "/search"
 	deezerTrackURL    = deezerBaseURL + "/track/%s"
 	deezerAlbumURL    = deezerBaseURL + "/album/%s"
 	deezerArtistURL   = deezerBaseURL + "/artist/%s"
 	deezerPlaylistURL = deezerBaseURL + "/playlist/%s"
 	deezerCacheTTL = 10 * time.Minute
 	deezerMaxParallelISRC = 10
 )
 type DeezerClient struct {
 	httpClient  *http.Client
 	searchCache map[string]*cacheEntry
 	albumCache  map[string]*cacheEntry
 	artistCache map[string]*cacheEntry
 	isrcCache   map[string]string
 	cacheMu     sync.RWMutex
 }
 var (
 	deezerClient     *DeezerClient
 	deezerClientOnce sync.Once
 )
 func GetDeezerClient() *DeezerClient {
 	deezerClientOnce.Do(func() {
 		deezerClient = &DeezerClient{
 			httpClient:  NewHTTPClientWithTimeout(15 * time.Second),
 			searchCache: make(map[string]*cacheEntry),
 			albumCache:  make(map[string]*cacheEntry),
 			artistCache: make(map[string]*cacheEntry),
 			isrcCache:   make(map[string]string),
 		}
 	})
 	return deezerClient
 }
 type deezerTrack struct {
 	ID            int64             `json:"id"`
 	Title         string            `json:"title"`
 	Duration      int               `json:"duration"` // in seconds
 	TrackPosition int               `json:"track_position"`
 	DiskNumber    int               `json:"disk_number"`
 	ISRC          string            `json:"isrc"`
 	Link          string            `json:"link"`
 	ReleaseDate   string            `json:"release_date"`
 	Artist        deezerArtist      `json:"artist"`
 	Album         deezerAlbumSimple `json:"album"`
 	Contributors  []deezerArtist    `json:"contributors"`
 }
 type deezerArtist struct {
 	ID            int64  `json:"id"`
 	Name          string `json:"name"`
 	Picture       string `json:"picture"`
 	PictureMedium string `json:"picture_medium"`
 	PictureBig    string `json:"picture_big"`
 	PictureXL     string `json:"picture_xl"`
 	NbFan         int    `json:"nb_fan"`
 }
 type deezerAlbumSimple struct {
 	ID          int64  `json:"id"`
 	Title       string `json:"title"`
 	Cover       string `json:"cover"`
 	CoverMedium string `json:"cover_medium"`
 	CoverBig    string `json:"cover_big"`
 	CoverXL     string `json:"cover_xl"`
 	ReleaseDate string `json:"release_date"`
 	RecordType  string `json:"record_type"`
 }
 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
 	}
 	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 deezerGenre struct {
 	ID   int    `json:"id"`
 	Name string `json:"name"`
 }
 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"`
 	RecordType  string `json:"record_type"`
 	Label       string `json:"label"`
 	Genres      struct {
 		Data []deezerGenre `json:"data"`
 	} `json:"genres"`
 	Artist       deezerArtist   `json:"artist"`
 	Contributors []deezerArtist `json:"contributors"`
 	Tracks       struct {
 		Data []deezerTrack `json:"data"`
 	} `json:"tracks"`
 }
 type deezerArtistFull struct {
 	ID            int64  `json:"id"`
 	Name          string `json:"name"`
 	Picture       string `json:"picture"`
 	PictureMedium string `json:"picture_medium"`
 	PictureBig    string `json:"picture_big"`
 	PictureXL     string `json:"picture_xl"`
 	NbFan         int    `json:"nb_fan"`
 	NbAlbum       int    `json:"nb_album"`
 }
 type deezerPlaylistFull struct {
 	ID            int64  `json:"id"`
 	Title         string `json:"title"`
 	Picture       string `json:"picture"`
 	PictureMedium string `json:"picture_medium"`
 	PictureBig    string `json:"picture_big"`
 	PictureXL     string `json:"picture_xl"`
 	NbTracks      int    `json:"nb_tracks"`
 	Creator       struct {
 		Name string `json:"name"`
 	} `json:"creator"`
 	Tracks struct {
 		Data []deezerTrack `json:"data"`
 	} `json:"tracks"`
 }
 // NOTE: ISRC is NOT fetched during search for performance - use GetTrackISRC when needed for download
 func (c *DeezerClient) SearchAll(ctx context.Context, query string, trackLimit, artistLimit int) (*SearchAllResult, error) {
 	GoLog("[Deezer] SearchAll: query=%q, trackLimit=%d, artistLimit=%d\n", query, trackLimit, artistLimit)
 	cacheKey := fmt.Sprintf("deezer:all:%s:%d:%d", query, trackLimit, artistLimit)
 	c.cacheMu.RLock()
 	if entry, ok := c.searchCache[cacheKey]; ok && !entry.isExpired() {
 		c.cacheMu.RUnlock()
 		GoLog("[Deezer] SearchAll: returning cached result\n")
 		return entry.data.(*SearchAllResult), nil
 	}
 	c.cacheMu.RUnlock()
 	result := &SearchAllResult{
 		Tracks:  make([]TrackMetadata, 0, trackLimit),
 		Artists: make([]SearchArtistResult, 0, artistLimit),
 	}
 	// Search tracks - NO ISRC fetch for performance
 	trackURL := fmt.Sprintf("%s/track?q=%s&limit=%d", deezerSearchURL, url.QueryEscape(query), trackLimit)
 	GoLog("[Deezer] Fetching tracks from: %s\n", trackURL)
 	var trackResp struct {
 		Data  []deezerTrack `json:"data"`
 		Error *struct {
 			Type    string `json:"type"`
 			Message string `json:"message"`
 			Code    int    `json:"code"`
 		} `json:"error"`
 	}
 	if err := c.getJSON(ctx, trackURL, &trackResp); err != nil {
 		GoLog("[Deezer] Track search failed: %v\n", err)
 		return nil, fmt.Errorf("deezer track search failed: %w", err)
 	}
 	if trackResp.Error != nil {
 		GoLog("[Deezer] API error: type=%s, code=%d, message=%s\n", trackResp.Error.Type, trackResp.Error.Code, trackResp.Error.Message)
 		return nil, fmt.Errorf("deezer API error: %s (code %d)", trackResp.Error.Message, trackResp.Error.Code)
 	}
 	GoLog("[Deezer] Got %d tracks from API\n", len(trackResp.Data))
 	for _, track := range trackResp.Data {
 		result.Tracks = append(result.Tracks, c.convertTrack(track))
 	}
 	artistURL := fmt.Sprintf("%s/artist?q=%s&limit=%d", deezerSearchURL, url.QueryEscape(query), artistLimit)
 	GoLog("[Deezer] Fetching artists from: %s\n", artistURL)
 	var artistResp struct {
 		Data  []deezerArtist `json:"data"`
 		Error *struct {
 			Type    string `json:"type"`
 			Message string `json:"message"`
 			Code    int    `json:"code"`
 		} `json:"error"`
 	}
 	if err := c.getJSON(ctx, artistURL, &artistResp); err == nil {
 		if artistResp.Error != nil {
 			GoLog("[Deezer] Artist API error: type=%s, code=%d, message=%s\n", artistResp.Error.Type, artistResp.Error.Code, artistResp.Error.Message)
 		} else {
 			GoLog("[Deezer] Got %d artists from API\n", len(artistResp.Data))
 			for _, artist := range artistResp.Data {
 				result.Artists = append(result.Artists, SearchArtistResult{
 					ID:         fmt.Sprintf("deezer:%d", artist.ID),
 					Name:       artist.Name,
 					Images:     c.getBestArtistImage(artist),
 					Followers:  artist.NbFan,
 					Popularity: 0,
 				})
 			}
 		}
 	} else {
 		GoLog("[Deezer] Artist search failed: %v\n", err)
 	}
 	GoLog("[Deezer] SearchAll complete: %d tracks, %d artists\n", len(result.Tracks), len(result.Artists))
 	c.cacheMu.Lock()
 	c.searchCache[cacheKey] = &cacheEntry{
 		data:      result,
 		expiresAt: time.Now().Add(deezerCacheTTL),
 	}
 	c.cacheMu.Unlock()
 	return result, nil
 }
 // GetTrack fetches a single track by Deezer ID
 func (c *DeezerClient) GetTrack(ctx context.Context, trackID string) (*TrackResponse, error) {
 	trackURL := fmt.Sprintf(deezerTrackURL, trackID)
 	var track deezerTrack
 	if err := c.getJSON(ctx, trackURL, &track); err != nil {
 		return nil, err
 	}
 	return &TrackResponse{
 		Track: c.convertTrack(track),
 	}, nil
 }
 // ISRC is fetched in parallel for better performance
 func (c *DeezerClient) GetAlbum(ctx context.Context, albumID string) (*AlbumResponsePayload, error) {
 	c.cacheMu.RLock()
 	if entry, ok := c.albumCache[albumID]; ok && !entry.isExpired() {
 		c.cacheMu.RUnlock()
 		return entry.data.(*AlbumResponsePayload), nil
 	}
 	c.cacheMu.RUnlock()
 	albumURL := fmt.Sprintf(deezerAlbumURL, albumID)
 	var album deezerAlbumFull
 	if err := c.getJSON(ctx, albumURL, &album); err != nil {
 		return nil, err
 	}
 	albumImage := c.getBestAlbumImage(album)
 	artistName := album.Artist.Name
 	if len(album.Contributors) > 0 {
 		names := make([]string, len(album.Contributors))
 		for i, a := range album.Contributors {
 			names[i] = a.Name
 		}
 		artistName = strings.Join(names, ", ")
 	}
 	// Extract genres as comma-separated string
 	var genres []string
 	for _, g := range album.Genres.Data {
 		if g.Name != "" {
 			genres = append(genres, g.Name)
 		}
 	}
 	genreStr := strings.Join(genres, ", ")
 	info := AlbumInfoMetadata{
 		TotalTracks: album.NbTracks,
 		Name:        album.Title,
 		ReleaseDate: album.ReleaseDate,
 		Artists:     artistName,
 		ArtistId:    fmt.Sprintf("deezer:%d", album.Artist.ID),
 		Images:      albumImage,
 		Genre:       genreStr,    // From Deezer album
 		Label:       album.Label, // From Deezer album
 	}
 	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 {
 		trackIDStr := fmt.Sprintf("%d", track.ID)
 		isrc := isrcMap[trackIDStr]
 		tracks = append(tracks, AlbumTrackMetadata{
 			SpotifyID:   fmt.Sprintf("deezer:%d", track.ID),
 			Artists:     track.Artist.Name,
 			Name:        track.Title,
 			AlbumName:   album.Title,
 			AlbumArtist: artistName,
 			DurationMS:  track.Duration * 1000,
 			Images:      albumImage,
 			ReleaseDate: album.ReleaseDate,
 			TrackNumber: track.TrackPosition,
 			TotalTracks: album.NbTracks,
 			DiscNumber:  track.DiskNumber,
 			ExternalURL: track.Link,
 			ISRC:        isrc,
 			AlbumID:     fmt.Sprintf("deezer:%d", album.ID),
 			AlbumType:   albumType,
 		})
 	}
 	result := &AlbumResponsePayload{
 		AlbumInfo: info,
 		TrackList: tracks,
 	}
 	c.cacheMu.Lock()
 	c.albumCache[albumID] = &cacheEntry{
 		data:      result,
 		expiresAt: time.Now().Add(deezerCacheTTL),
 	}
 	c.cacheMu.Unlock()
 	return result, nil
 }
 func (c *DeezerClient) GetArtist(ctx context.Context, artistID string) (*ArtistResponsePayload, error) {
 	c.cacheMu.RLock()
 	if entry, ok := c.artistCache[artistID]; ok && !entry.isExpired() {
 		c.cacheMu.RUnlock()
 		return entry.data.(*ArtistResponsePayload), nil
 	}
 	c.cacheMu.RUnlock()
 	// Fetch artist info
 	artistURL := fmt.Sprintf(deezerArtistURL, artistID)
 	var artist deezerArtistFull
 	if err := c.getJSON(ctx, artistURL, &artist); err != nil {
 		return nil, err
 	}
 	artistInfo := ArtistInfoMetadata{
 		ID:         fmt.Sprintf("deezer:%d", artist.ID),
 		Name:       artist.Name,
 		Images:     c.getBestArtistImageFull(artist),
 		Followers:  artist.NbFan,
 		Popularity: 0,
 	}
 	// Fetch artist albums
 	albumsURL := fmt.Sprintf("%s/albums?limit=100", fmt.Sprintf(deezerArtistURL, artistID))
 	var albumsResp struct {
 		Data []struct {
 			ID          int64  `json:"id"`
 			Title       string `json:"title"`
 			ReleaseDate string `json:"release_date"`
 			NbTracks    int    `json:"nb_tracks"`
 			Cover       string `json:"cover"`
 			CoverMedium string `json:"cover_medium"`
 			CoverBig    string `json:"cover_big"`
 			CoverXL     string `json:"cover_xl"`
 			RecordType  string `json:"record_type"` // album, single, ep, compile
 		} `json:"data"`
 	}
 	albums := make([]ArtistAlbumMetadata, 0)
 	if err := c.getJSON(ctx, albumsURL, &albumsResp); err == nil {
 		for _, album := range albumsResp.Data {
 			albumType := album.RecordType
 			if albumType == "compile" {
 				albumType = "compilation"
 			}
 			coverURL := album.CoverXL
 			if coverURL == "" {
 				coverURL = album.CoverBig
 			}
 			if coverURL == "" {
 				coverURL = album.CoverMedium
 			}
 			if coverURL == "" {
 				coverURL = album.Cover
 			}
 			albums = append(albums, ArtistAlbumMetadata{
 				ID:          fmt.Sprintf("deezer:%d", album.ID),
 				Name:        album.Title,
 				ReleaseDate: album.ReleaseDate,
 				TotalTracks: album.NbTracks,
 				Images:      coverURL,
 				AlbumType:   albumType,
 				Artists:     artist.Name,
 			})
 		}
 	}
 	result := &ArtistResponsePayload{
 		ArtistInfo: artistInfo,
 		Albums:     albums,
 	}
 	c.cacheMu.Lock()
 	c.artistCache[artistID] = &cacheEntry{
 		data:      result,
 		expiresAt: time.Now().Add(deezerCacheTTL),
 	}
 	c.cacheMu.Unlock()
 	return result, nil
 }
 func (c *DeezerClient) GetPlaylist(ctx context.Context, playlistID string) (*PlaylistResponsePayload, error) {
 	playlistURL := fmt.Sprintf(deezerPlaylistURL, playlistID)
 	var playlist deezerPlaylistFull
 	if err := c.getJSON(ctx, playlistURL, &playlist); err != nil {
 		return nil, err
 	}
 	playlistImage := playlist.PictureXL
 	if playlistImage == "" {
 		playlistImage = playlist.PictureBig
 	}
 	if playlistImage == "" {
 		playlistImage = playlist.PictureMedium
 	}
 	var info PlaylistInfoMetadata
 	info.Tracks.Total = playlist.NbTracks
 	info.Owner.DisplayName = playlist.Creator.Name
 	info.Owner.Name = playlist.Title
 	info.Owner.Images = playlistImage
 	isrcMap := c.fetchISRCsParallel(ctx, playlist.Tracks.Data)
 	tracks := make([]AlbumTrackMetadata, 0, len(playlist.Tracks.Data))
 	for _, track := range playlist.Tracks.Data {
 		albumImage := track.Album.CoverXL
 		if albumImage == "" {
 			albumImage = track.Album.CoverBig
 		}
 		if albumImage == "" {
 			albumImage = track.Album.CoverMedium
 		}
 		trackIDStr := fmt.Sprintf("%d", track.ID)
 		isrc := isrcMap[trackIDStr]
 		tracks = append(tracks, AlbumTrackMetadata{
 			SpotifyID:   fmt.Sprintf("deezer:%d", track.ID),
 			Artists:     track.Artist.Name,
 			Name:        track.Title,
 			AlbumName:   track.Album.Title,
 			AlbumArtist: track.Artist.Name,
 			DurationMS:  track.Duration * 1000,
 			Images:      albumImage,
 			ReleaseDate: "",
 			TrackNumber: track.TrackPosition,
 			DiscNumber:  track.DiskNumber,
 			ExternalURL: track.Link,
 			ISRC:        isrc,
 			AlbumID:     fmt.Sprintf("deezer:%d", track.Album.ID),
 		})
 	}
 	return &PlaylistResponsePayload{
 		PlaylistInfo: info,
 		TrackList:    tracks,
 	}, nil
 }
 func (c *DeezerClient) SearchByISRC(ctx context.Context, isrc string) (*TrackMetadata, error) {
 	directURL := fmt.Sprintf("%s/track/isrc:%s", deezerBaseURL, isrc)
 	var track deezerTrack
 	if err := c.getJSON(ctx, directURL, &track); err != nil {
 		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 track.ID == 0 {
 		return nil, fmt.Errorf("no track found for ISRC: %s", isrc)
 	}
 	result := c.convertTrack(track)
 	return &result, nil
 }
 func (c *DeezerClient) fetchFullTrack(ctx context.Context, trackID string) (*deezerTrack, error) {
 	trackURL := fmt.Sprintf(deezerTrackURL, trackID)
 	var track deezerTrack
 	if err := c.getJSON(ctx, trackURL, &track); err != nil {
 		return nil, err
 	}
 	return &track, nil
 }
 // fetchISRCsParallel fetches ISRCs for multiple tracks in parallel with caching
 func (c *DeezerClient) fetchISRCsParallel(ctx context.Context, tracks []deezerTrack) map[string]string {
 	result := make(map[string]string, len(tracks))
 	var resultMu sync.Mutex
 	var tracksToFetch []deezerTrack
 	var directISRCs map[string]string
 	c.cacheMu.RLock()
 	for _, track := range tracks {
 		trackIDStr := fmt.Sprintf("%d", track.ID)
 		if track.ISRC != "" {
 			result[trackIDStr] = track.ISRC
 			if _, ok := c.isrcCache[trackIDStr]; !ok {
 				if directISRCs == nil {
 					directISRCs = make(map[string]string)
 				}
 				directISRCs[trackIDStr] = track.ISRC
 			}
 			continue
 		}
 		if isrc, ok := c.isrcCache[trackIDStr]; ok {
 			result[trackIDStr] = isrc
 		} else {
 			tracksToFetch = append(tracksToFetch, track)
 		}
 	}
 	c.cacheMu.RUnlock()
 	if len(directISRCs) > 0 {
 		c.cacheMu.Lock()
 		for trackIDStr, isrc := range directISRCs {
 			c.isrcCache[trackIDStr] = isrc
 		}
 		c.cacheMu.Unlock()
 	}
 	if len(tracksToFetch) == 0 {
 		return result
 	}
 	// Use semaphore to limit concurrent requests
 	sem := make(chan struct{}, deezerMaxParallelISRC)
 	var wg sync.WaitGroup
 	for _, track := range tracksToFetch {
 		wg.Add(1)
 		go func(t deezerTrack) {
 			defer wg.Done()
 			select {
 			case sem <- struct{}{}:
 				defer func() { <-sem }()
 			case <-ctx.Done():
 				return
 			}
 			trackIDStr := fmt.Sprintf("%d", t.ID)
 			fullTrack, err := c.fetchFullTrack(ctx, trackIDStr)
 			if err != nil || fullTrack == nil {
 				return
 			}
 			// Store in result and cache
 			resultMu.Lock()
 			result[trackIDStr] = fullTrack.ISRC
 			resultMu.Unlock()
 			c.cacheMu.Lock()
 			c.isrcCache[trackIDStr] = fullTrack.ISRC
 			c.cacheMu.Unlock()
 		}(track)
 	}
 	wg.Wait()
 	return result
 }
 // Use this when you need ISRC for download
 func (c *DeezerClient) GetTrackISRC(ctx context.Context, trackID string) (string, error) {
 	c.cacheMu.RLock()
 	if isrc, ok := c.isrcCache[trackID]; ok {
 		c.cacheMu.RUnlock()
 		return isrc, nil
 	}
 	c.cacheMu.RUnlock()
 	fullTrack, err := c.fetchFullTrack(ctx, trackID)
 	if err != nil {
 		return "", err
 	}
 	c.cacheMu.Lock()
 	c.isrcCache[trackID] = fullTrack.ISRC
 	c.cacheMu.Unlock()
 	return fullTrack.ISRC, nil
 }
 func (c *DeezerClient) getBestArtistImage(artist deezerArtist) string {
 	if artist.PictureXL != "" {
 		return artist.PictureXL
 	}
 	if artist.PictureBig != "" {
 		return artist.PictureBig
 	}
 	if artist.PictureMedium != "" {
 		return artist.PictureMedium
 	}
 	return artist.Picture
 }
 func (c *DeezerClient) getBestArtistImageFull(artist deezerArtistFull) string {
 	if artist.PictureXL != "" {
 		return artist.PictureXL
 	}
 	if artist.PictureBig != "" {
 		return artist.PictureBig
 	}
 	if artist.PictureMedium != "" {
 		return artist.PictureMedium
 	}
 	return artist.Picture
 }
 func (c *DeezerClient) getBestAlbumImage(album deezerAlbumFull) string {
 	if album.CoverXL != "" {
 		return album.CoverXL
 	}
 	if album.CoverBig != "" {
 		return album.CoverBig
 	}
 	if album.CoverMedium != "" {
 		return album.CoverMedium
 	}
 	return album.Cover
 }
 type AlbumExtendedMetadata struct {
 	Genre string // Comma-separated list of genres
 	Label string // Record label name
 }
 // Uses the album ID from a track to fetch extended metadata
 func (c *DeezerClient) GetAlbumExtendedMetadata(ctx context.Context, albumID string) (*AlbumExtendedMetadata, error) {
 	if albumID == "" {
 		return nil, fmt.Errorf("empty album ID")
 	}
 	cacheKey := fmt.Sprintf("album_meta:%s", albumID)
 	c.cacheMu.RLock()
 	if entry, ok := c.searchCache[cacheKey]; ok && !entry.isExpired() {
 		c.cacheMu.RUnlock()
 		return entry.data.(*AlbumExtendedMetadata), nil
 	}
 	c.cacheMu.RUnlock()
 	albumURL := fmt.Sprintf(deezerAlbumURL, albumID)
 	var album deezerAlbumFull
 	if err := c.getJSON(ctx, albumURL, &album); err != nil {
 		return nil, fmt.Errorf("failed to fetch album: %w", err)
 	}
 	var genres []string
 	for _, g := range album.Genres.Data {
 		if g.Name != "" {
 			genres = append(genres, g.Name)
 		}
 	}
 	result := &AlbumExtendedMetadata{
 		Genre: strings.Join(genres, ", "),
 		Label: album.Label,
 	}
 	c.cacheMu.Lock()
 	c.searchCache[cacheKey] = &cacheEntry{
 		data:      result,
 		expiresAt: time.Now().Add(deezerCacheTTL),
 	}
 	c.cacheMu.Unlock()
 	GoLog("[Deezer] Album metadata fetched - Genre: %s, Label: %s\n", result.Genre, result.Label)
 	return result, nil
 }
 // GetTrackAlbumID fetches the album ID for a Deezer track
 func (c *DeezerClient) GetTrackAlbumID(ctx context.Context, trackID string) (string, error) {
 	trackURL := fmt.Sprintf(deezerTrackURL, trackID)
 	var track deezerTrack
 	if err := c.getJSON(ctx, trackURL, &track); err != nil {
 		return "", err
 	}
 	return fmt.Sprintf("%d", track.Album.ID), nil
 }
 // This is a convenience function that first gets the album ID, then fetches album metadata
 func (c *DeezerClient) GetExtendedMetadataByTrackID(ctx context.Context, trackID string) (*AlbumExtendedMetadata, error) {
 	albumID, err := c.GetTrackAlbumID(ctx, trackID)
 	if err != nil {
 		return nil, fmt.Errorf("failed to get album ID: %w", err)
 	}
 	return c.GetAlbumExtendedMetadata(ctx, albumID)
 }
 // GetExtendedMetadataByISRC searches for a track by ISRC and fetches extended metadata (genre, label)
 func (c *DeezerClient) GetExtendedMetadataByISRC(ctx context.Context, isrc string) (*AlbumExtendedMetadata, error) {
 	if isrc == "" {
 		return nil, fmt.Errorf("empty ISRC")
 	}
 	// First, search for track by ISRC
 	track, err := c.SearchByISRC(ctx, isrc)
 	if err != nil {
 		return nil, fmt.Errorf("failed to find track by ISRC: %w", err)
 	}
 	// SpotifyID contains "deezer:123" format, extract the ID
 	deezerID := track.SpotifyID
 	if strings.HasPrefix(deezerID, "deezer:") {
 		deezerID = strings.TrimPrefix(deezerID, "deezer:")
 	}
 	if deezerID == "" {
 		return nil, fmt.Errorf("track found but no Deezer ID")
 	}
 	// Then fetch extended metadata using the Deezer track ID
 	return c.GetExtendedMetadataByTrackID(ctx, deezerID)
 }
 func (c *DeezerClient) getJSON(ctx context.Context, endpoint string, dst interface{}) error {
 	req, err := http.NewRequestWithContext(ctx, http.MethodGet, endpoint, nil)
 	if err != nil {
 		return err
 	}
 	req.Header.Set("Accept", "application/json")
 	resp, err := c.httpClient.Do(req)
 	if err != nil {
 		return err
 	}
 	defer resp.Body.Close()
 	body, err := io.ReadAll(resp.Body)
 	if err != nil {
 		return err
 	}
 	if resp.StatusCode != http.StatusOK {
 		return fmt.Errorf("deezer API returned status %d: %s", resp.StatusCode, string(body))
 	}
 	return json.Unmarshal(body, dst)
 }
 // parseDeezerURL is internal function, returns type and ID
 func parseDeezerURL(input string) (string, string, error) {
 	trimmed := strings.TrimSpace(input)
 	if trimmed == "" {
 		return "", "", fmt.Errorf("empty URL")
 	}
 	parsed, err := url.Parse(trimmed)
 	if err != nil {
 		return "", "", err
 	}
 	if parsed.Host != "www.deezer.com" && parsed.Host != "deezer.com" && parsed.Host != "deezer.page.link" {
 		return "", "", fmt.Errorf("not a Deezer URL")
 	}
 	parts := strings.Split(strings.Trim(parsed.Path, "/"), "/")
 	if len(parts) > 0 && len(parts[0]) == 2 {
 		parts = parts[1:]
 	}
 	if len(parts) < 2 {
 		return "", "", fmt.Errorf("invalid Deezer URL format")
 	}
 	resourceType := parts[0]
 	resourceID := parts[1]
 	switch resourceType {
 	case "track", "album", "artist", "playlist":
 		return resourceType, resourceID, nil
 	default:
 		return "", "", fmt.Errorf("unsupported Deezer resource type: %s", resourceType)
 	}
 }
@@ -1,53 +1,179 @@
 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
 }
 var (
 	isrcIndexCache   = make(map[string]*ISRCIndex)
 	isrcIndexCacheMu sync.RWMutex
 	isrcBuildingMu   sync.Map // Per-directory build lock to prevent concurrent builds
 	isrcIndexTTL     = 5 * time.Minute
 )
 // GetISRCIndex returns or builds an ISRC index for the given directory
 // Uses per-directory mutex to prevent concurrent builds (race condition fix)
 func GetISRCIndex(outputDir string) *ISRCIndex {
 	// Fast path: check cache first
 	isrcIndexCacheMu.RLock()
 	idx, exists := isrcIndexCache[outputDir]
 	isrcIndexCacheMu.RUnlock()
 	if exists && time.Since(idx.buildTime) < isrcIndexTTL {
 		return idx
 	}
 	// Slow path: need to build index
 	// Use per-directory mutex to prevent multiple goroutines from building simultaneously
 	buildLock, _ := isrcBuildingMu.LoadOrStore(outputDir, &sync.Mutex{})
 	mu := buildLock.(*sync.Mutex)
 	mu.Lock()
 	defer mu.Unlock()
 	// Double-check cache after acquiring lock (another goroutine may have built it)
 	isrcIndexCacheMu.RLock()
 	idx, exists = isrcIndexCache[outputDir]
 	isrcIndexCacheMu.RUnlock()
 	if exists && time.Since(idx.buildTime) < isrcIndexTTL {
 		return idx
 	}
 	return buildISRCIndex(outputDir)
 }
 // buildISRCIndex scans a directory and builds a map of ISRC -> file path
 func buildISRCIndex(outputDir string) *ISRCIndex {
 	idx := &ISRCIndex{
 		index:     make(map[string]string),
 		outputDir: outputDir,
 		buildTime: time.Now(),
 	}
 	if outputDir == "" {
 		return idx
 	}
 	startTime := time.Now()
 	fileCount := 0
 	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
 		}
 		metadata, err := ReadMetadata(path)
 		if err != nil || metadata.ISRC == "" {
 			return nil
 		}
 		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))
 	isrcIndexCacheMu.Lock()
 	isrcIndexCache[outputDir] = idx
 	isrcIndexCacheMu.Unlock()
 	return idx
 }
 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
 }
 // remove deletes an ISRC entry from the index (internal use)
 func (idx *ISRCIndex) remove(isrc string) {
 	if isrc == "" {
 		return
 	}
 	idx.mu.Lock()
 	defer idx.mu.Unlock()
 	delete(idx.index, strings.ToUpper(isrc))
 }
 // Lookup checks if an ISRC exists in the index (gomobile compatible)
 // Returns filepath if found, empty string if not found
 func (idx *ISRCIndex) Lookup(isrc string) (string, error) {
 	path, _ := idx.lookup(isrc)
 	return path, nil
 }
 // Add adds a new ISRC to the index (call after successful download)
 func (idx *ISRCIndex) Add(isrc, filePath string) {
 	if isrc == "" || filePath == "" {
 		return
 	}
 	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
+	idx := GetISRCIndex(outputDir)
-	var foundFile string
+	filePath, exists := idx.lookup(isrc)
-	filepath.Walk(outputDir, func(path string, info os.FileInfo, err error) error {
+	if !exists {
-		if err != nil {
+		return "", false
 			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
+	if !CheckFileExists(filePath) {
 		// Stale index entry; remove it and return not found.
 		idx.remove(isrc)
 		return "", false
 	}
 	return filePath, true
 }
 // CheckISRCExists is the exported version for gomobile (returns string, error)
 // Returns the filepath if exists, empty string if not
 func CheckISRCExists(outputDir, isrc string) (string, error) {
 	filepath, _ := checkISRCExistsInternal(outputDir, isrc)
 	return filepath, nil
@@ -61,3 +187,90 @@ 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"`
 }
 func CheckFilesExistParallel(outputDir string, tracksJSON string) (string, error) {
 	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))
 	isrcIdx := GetISRCIndex(outputDir)
 	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()
 	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
 func AddToISRCIndex(outputDir, isrc, filePath string) {
 	if outputDir == "" || isrc == "" || filePath == "" {
 		return
 	}
 	isrcIndexCacheMu.RLock()
 	idx, exists := isrcIndexCache[outputDir]
 	isrcIndexCacheMu.RUnlock()
 	if exists {
 		idx.Add(isrc, filePath)
 	}
 }
@@ -0,0 +1,997 @@
 package gobackend
 import (
 	"archive/zip"
 	"encoding/json"
 	"fmt"
 	"io"
 	"os"
 	"path/filepath"
 	"strconv"
 	"strings"
 	"sync"
 	"github.com/dop251/goja"
 )
 func compareVersions(v1, v2 string) int {
 	parts1 := strings.Split(strings.TrimPrefix(v1, "v"), ".")
 	parts2 := strings.Split(strings.TrimPrefix(v2, "v"), ".")
 	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
 }
 type LoadedExtension struct {
 	ID        string             `json:"id"`
 	Manifest  *ExtensionManifest `json:"manifest"`
 	VM        *goja.Runtime      `json:"-"`
 	VMMu      sync.Mutex         `json:"-"` // Mutex to prevent concurrent VM access
 	Enabled   bool               `json:"enabled"`
 	Error     string             `json:"error,omitempty"`
 	DataDir   string             `json:"data_dir"`
 	SourceDir string             `json:"source_dir"`
 	IconPath  string             `json:"icon_path"`
 }
 // ExtensionManager manages all loaded extensions
 type ExtensionManager struct {
 	mu            sync.RWMutex
 	extensions    map[string]*LoadedExtension
 	extensionsDir string // Base directory for extensions
 	dataDir       string // Base directory for extension data
 }
 var (
 	globalExtManager     *ExtensionManager
 	globalExtManagerOnce sync.Once
 )
 func GetExtensionManager() *ExtensionManager {
 	globalExtManagerOnce.Do(func() {
 		globalExtManager = &ExtensionManager{
 			extensions: make(map[string]*LoadedExtension),
 		}
 	})
 	return globalExtManager
 }
 func (m *ExtensionManager) SetDirectories(extensionsDir, dataDir string) error {
 	m.mu.Lock()
 	defer m.mu.Unlock()
 	m.extensionsDir = extensionsDir
 	m.dataDir = dataDir
 	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
 }
 func (m *ExtensionManager) LoadExtensionFromFile(filePath string) (*LoadedExtension, error) {
 	if !strings.HasSuffix(strings.ToLower(filePath), ".spotiflac-ext") {
 		return nil, fmt.Errorf("Invalid file format. Please select a .spotiflac-ext file")
 	}
 	// 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()
 	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")
 	}
 	manifest, err := ParseManifest(manifestData)
 	if err != nil {
 		return nil, fmt.Errorf("Invalid extension manifest: %w", err)
 	}
 	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 {
 		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)
 		}
 	}
 	m.mu.Lock()
 	defer m.mu.Unlock()
 	if _, exists := m.extensions[manifest.Name]; exists {
 		return nil, fmt.Errorf("Extension '%s' was installed by another process", manifest.DisplayName)
 	}
 	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)
 	}
 	for _, file := range zipReader.File {
 		if file.FileInfo().IsDir() {
 			continue
 		}
 		relPath := filepath.Clean(file.Name)
 		if strings.HasPrefix(relPath, "..") || filepath.IsAbs(relPath) {
 			GoLog("[Extension] Skipping unsafe path in archive: %s\n", file.Name)
 			continue
 		}
 		destPath := filepath.Join(extDir, relPath)
 		destDir := filepath.Dir(destPath)
 		if err := os.MkdirAll(destDir, 0755); err != nil {
 			return nil, fmt.Errorf("failed to create directory %s: %w", destDir, err)
 		}
 		destFile, err := os.Create(destPath)
 		if err != nil {
 			return nil, fmt.Errorf("failed to create file %s: %w", destPath, err)
 		}
 		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)
 		}
 	}
 	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)
 	}
 	ext := &LoadedExtension{
 		ID:        manifest.Name,
 		Manifest:  manifest,
 		Enabled:   false, // New extensions start disabled
 		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
 }
 func (m *ExtensionManager) initializeVM(ext *LoadedExtension) error {
 	vm := goja.New()
 	ext.VM = vm
 	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)
 	}
 	runtime := NewExtensionRuntime(ext)
 	runtime.RegisterAPIs(vm)
 	runtime.RegisterGoBackendAPIs(vm)
 	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)
 	var registeredExtension goja.Value
 	vm.Set("registerExtension", func(call goja.FunctionCall) goja.Value {
 		if len(call.Arguments) > 0 {
 			registeredExtension = call.Arguments[0]
 			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
 }
 // 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
 }
 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() {
 			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") {
 			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
 }
 func (m *ExtensionManager) loadExtensionFromDirectory(dirPath string) (*LoadedExtension, error) {
 	m.mu.Lock()
 	defer m.mu.Unlock()
 	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)
 	}
 	indexPath := filepath.Join(dirPath, "index.js")
 	if _, err := os.Stat(indexPath); os.IsNotExist(err) {
 		return nil, fmt.Errorf("Extension is missing index.js file")
 	}
 	if existing, exists := m.extensions[manifest.Name]; exists {
 		GoLog("[Extension] Extension '%s' already loaded, skipping\n", manifest.DisplayName)
 		return existing, nil
 	}
 	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)
 	}
 	ext := &LoadedExtension{
 		ID:        manifest.Name,
 		Manifest:  manifest,
 		Enabled:   false, // Will be restored from settings store
 		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
 }
 // 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()
 	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")
 	}
 	newManifest, err := ParseManifest(manifestData)
 	if err != nil {
 		return nil, fmt.Errorf("Invalid extension manifest: %w", err)
 	}
 	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 and enabled state (we want to preserve them)
 	extDataDir := existing.DataDir
 	extDir := existing.SourceDir
 	wasEnabled := existing.Enabled
 	// Cleanup and unload existing extension
 	m.CleanupExtension(existing.ID)
 	m.UnloadExtension(existing.ID)
 	// Remove old source files but keep data directory
 	if extDir != "" {
 		if err := os.RemoveAll(extDir); err != nil {
 			GoLog("[Extension] Warning: failed to remove old source dir: %v\n", err)
 		}
 	}
 	if err := os.MkdirAll(extDir, 0755); err != nil {
 		return nil, fmt.Errorf("failed to create extension directory: %w", err)
 	}
 	for _, file := range zipReader.File {
 		if file.FileInfo().IsDir() {
 			continue
 		}
 		relPath := filepath.Clean(file.Name)
 		if strings.HasPrefix(relPath, "..") || filepath.IsAbs(relPath) {
 			GoLog("[Extension] Skipping unsafe path in archive: %s\n", file.Name)
 			continue
 		}
 		destPath := filepath.Join(extDir, relPath)
 		destDir := filepath.Dir(destPath)
 		if err := os.MkdirAll(destDir, 0755); err != nil {
 			return nil, fmt.Errorf("failed to create directory %s: %w", destDir, err)
 		}
 		destFile, err := os.Create(destPath)
 		if err != nil {
 			return nil, fmt.Errorf("failed to create file %s: %w", destPath, err)
 		}
 		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)
 		}
 	}
 	ext := &LoadedExtension{
 		ID:        newManifest.Name,
 		Manifest:  newManifest,
 		Enabled:   wasEnabled, // Preserve enabled state from before upgrade
 		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
 }
 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()
 	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")
 	}
 	newManifest, err := ParseManifest(manifestData)
 	if err != nil {
 		return nil, fmt.Errorf("Invalid manifest: %w", err)
 	}
 	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 {
 		info.CurrentVersion = existing.Manifest.Version
 		info.CanUpgrade = compareVersions(newManifest.Version, existing.Manifest.Version) > 0
 	}
 	return info, nil
 }
 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"`
 		Capabilities           map[string]interface{} `json:"capabilities,omitempty"`
 	}
 	infos := make([]ExtensionInfo, len(extensions))
 	for i, ext := range extensions {
 		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"
 		}
 		iconPath := ""
 		if ext.Manifest.Icon != "" && ext.SourceDir != "" {
 			possibleIcon := filepath.Join(ext.SourceDir, ext.Manifest.Icon)
 			if _, err := os.Stat(possibleIcon); err == nil {
 				iconPath = possibleIcon
 			}
 		}
 		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,
 			Capabilities:           ext.Manifest.Capabilities,
 		}
 	}
 	jsonBytes, err := json.Marshal(infos)
 	if err != nil {
 		return "", err
 	}
 	return string(jsonBytes), nil
 }
 // ==================== Extension Lifecycle ====================
 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")
 	}
 	settingsJSON, err := json.Marshal(settings)
 	if err != nil {
 		return fmt.Errorf("Failed to save settings")
 	}
 	script := fmt.Sprintf(`
 		(function() {
 			var settings = %s;
 			if (typeof extension !== 'undefined' && typeof extension.initialize === 'function') {
 				try {
 					extension.initialize(settings);
 					return { success: true };
 				} catch (e) {
 					return { success: false, error: e.toString() };
 				}
 			}
 			return { success: true, message: 'no initialize function' };
 		})()
 	`, string(settingsJSON))
 	result, err := ext.VM.RunString(script)
 	if err != nil {
 		ext.Error = fmt.Sprintf("initialize failed: %v", err)
 		ext.Enabled = false
 		GoLog("[Extension] Initialize error for %s: %v\n", extensionID, err)
 		return err
 	}
 	if result != nil && !goja.IsUndefined(result) {
 		exported := result.Export()
 		if resultMap, ok := exported.(map[string]interface{}); ok {
 			if success, ok := resultMap["success"].(bool); ok && !success {
 				errMsg := "unknown error"
 				if e, ok := resultMap["error"].(string); ok {
 					errMsg = e
 				}
 				ext.Error = errMsg
 				ext.Enabled = false
 				GoLog("[Extension] Initialize failed for %s: %s\n", extensionID, errMsg)
 				return fmt.Errorf("initialize failed: %s", errMsg)
 			}
 		}
 	}
 	GoLog("[Extension] Initialized %s\n", extensionID)
 	return nil
 }
 func (m *ExtensionManager) CleanupExtension(extensionID string) error {
 	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
 	}
 	script := `
 		(function() {
 			if (typeof extension !== 'undefined' && typeof extension.cleanup === 'function') {
 				try {
 					extension.cleanup();
 					return { success: true };
 				} catch (e) {
 					return { success: false, error: e.toString() };
 				}
 			}
 			return { success: true, message: 'no cleanup function' };
 		})()
 	`
 	result, err := ext.VM.RunString(script)
 	if err != nil {
 		GoLog("[Extension] Cleanup error for %s: %v\n", extensionID, err)
 		return err
 	}
 	if result != nil && !goja.IsUndefined(result) {
 		exported := result.Export()
 		if resultMap, ok := exported.(map[string]interface{}); ok {
 			if success, ok := resultMap["success"].(bool); ok && !success {
 				errMsg := "unknown error"
 				if e, ok := resultMap["error"].(string); ok {
 					errMsg = e
 				}
 				GoLog("[Extension] Cleanup failed for %s: %s\n", extensionID, errMsg)
 				return fmt.Errorf("cleanup failed: %s", errMsg)
 			}
 		}
 	}
 	GoLog("[Extension] Cleaned up %s\n", extensionID)
 	return nil
 }
 // 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 {
 		m.CleanupExtension(id)
 		m.UnloadExtension(id)
 	}
 	GoLog("[Extension] All extensions unloaded\n")
 }
 // The function is called as extension.<actionName>() and can return a result
 func (m *ExtensionManager) InvokeAction(extensionID string, actionName string) (map[string]interface{}, error) {
 	m.mu.Lock()
 	defer m.mu.Unlock()
 	ext, exists := m.extensions[extensionID]
 	if !exists {
 		return nil, fmt.Errorf("extension not found: %s", extensionID)
 	}
 	if ext.VM == nil {
 		return nil, fmt.Errorf("extension VM not initialized")
 	}
 	if !ext.Enabled {
 		return nil, fmt.Errorf("extension is disabled")
 	}
 	// Call the action function on the extension object
 	script := fmt.Sprintf(`
 		(function() {
 			if (typeof extension !== 'undefined' && typeof extension.%s === 'function') {
 				try {
 					var result = extension.%s();
 					if (result && typeof result.then === 'function') {
 						// Handle promise - return pending status
 						return { success: true, pending: true, message: 'Action started' };
 					}
 					return { success: true, result: result };
 				} catch (e) {
 					return { success: false, error: e.toString() };
 				}
 			}
 			return { success: false, error: 'Action function not found: %s' };
 		})()
 	`, actionName, actionName, actionName)
 	result, err := RunWithTimeoutAndRecover(ext.VM, script, DefaultJSTimeout)
 	if err != nil {
 		GoLog("[Extension] InvokeAction error for %s.%s: %v\n", extensionID, actionName, err)
 		return nil, fmt.Errorf("action failed: %v", err)
 	}
 	if result == nil || goja.IsUndefined(result) {
 		return map[string]interface{}{"success": true}, nil
 	}
 	exported := result.Export()
 	if resultMap, ok := exported.(map[string]interface{}); ok {
 		GoLog("[Extension] InvokeAction %s.%s result: %v\n", extensionID, actionName, resultMap)
 		return resultMap, nil
 	}
 	return map[string]interface{}{"success": true, "result": exported}, nil
 }
@@ -0,0 +1,307 @@
 // 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"
 	SettingTypeButton SettingType = "button" // Action button that calls a JS function
 )
 // ExtensionPermissions defines what resources an extension can access
 type ExtensionPermissions struct {
 	Network []string `json:"network"` // List of allowed domains
 	Storage bool     `json:"storage"` // Whether extension can use storage API
 	File    bool     `json:"file"`    // Whether extension can use file API
 }
 // 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
 	Action      string      `json:"action,omitempty"`  // For button type: JS function name to call (e.g., "startLogin")
 }
 // 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
 }
 // URLHandlerConfig defines custom URL handling for an extension
 type URLHandlerConfig struct {
 	Enabled  bool     `json:"enabled"`            // Whether extension handles URLs
 	Patterns []string `json:"patterns,omitempty"` // URL patterns to match (e.g., "music.youtube.com", "soundcloud.com")
 }
 // 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
 	URLHandler             *URLHandlerConfig      `json:"urlHandler,omitempty"`             // Custom URL handling
 	TrackMatching          *TrackMatchingConfig   `json:"trackMatching,omitempty"`          // Custom track matching
 	PostProcessing         *PostProcessingConfig  `json:"postProcessing,omitempty"`         // Post-processing hooks
 	Capabilities           map[string]interface{} `json:"capabilities,omitempty"`           // Extension capabilities (homeFeed, browseCategories, etc.)
 }
 // 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
 }
 func (m *ExtensionManifest) Validate() error {
 	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"}
 	}
 	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",
 			}
 		}
 		// 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",
 			}
 		}
 		if setting.Type == SettingTypeButton && setting.Action == "" {
 			return &ManifestValidationError{
 				Field:   fmt.Sprintf("settings[%d].action", i),
 				Message: "button type requires action (JS function name)",
 			}
 		}
 	}
 	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
 }
 // HasURLHandler returns true if extension handles custom URLs
 func (m *ExtensionManifest) HasURLHandler() bool {
 	return m.URLHandler != nil && m.URLHandler.Enabled && len(m.URLHandler.Patterns) > 0
 }
 // MatchesURL checks if a URL matches any of the extension's URL patterns
 func (m *ExtensionManifest) MatchesURL(urlStr string) bool {
 	if !m.HasURLHandler() {
 		return false
 	}
 	urlStr = strings.ToLower(strings.TrimSpace(urlStr))
 	for _, pattern := range m.URLHandler.Patterns {
 		pattern = strings.ToLower(strings.TrimSpace(pattern))
 		// Check if URL contains the pattern (host match)
 		if strings.Contains(urlStr, pattern) {
 			return true
 		}
 	}
 	return false
 }
 // GetPostProcessingHooks returns all post-processing hooks
 func (m *ExtensionManifest) GetPostProcessingHooks() []PostProcessingHook {
 	if m.PostProcessing == nil {
 		return nil
 	}
 	return m.PostProcessing.Hooks
 }
 // ToJSON serializes the manifest to JSON
 func (m *ExtensionManifest) ToJSON() ([]byte, error) {
 	return json.Marshal(m)
 }
@@ -0,0 +1,315 @@
 package gobackend
 import (
 	"net/http"
 	"net/url"
 	"sync"
 	"time"
 	"github.com/dop251/goja"
 )
 const DefaultJSTimeout = 30 * time.Second
 var (
 	extensionAuthState   = make(map[string]*ExtensionAuthState)
 	extensionAuthStateMu sync.RWMutex
 )
 type ExtensionAuthState struct {
 	PendingAuthURL  string
 	AuthCode        string
 	AccessToken     string
 	RefreshToken    string
 	ExpiresAt       time.Time
 	IsAuthenticated bool
 	// PKCE support
 	PKCEVerifier  string
 	PKCEChallenge string
 }
 type PendingAuthRequest struct {
 	ExtensionID string
 	AuthURL     string
 	CallbackURL string
 }
 var (
 	pendingAuthRequests   = make(map[string]*PendingAuthRequest)
 	pendingAuthRequestsMu sync.RWMutex
 )
 // GetPendingAuthRequest returns pending auth request for an extension (called from Flutter)
 func GetPendingAuthRequest(extensionID string) *PendingAuthRequest {
 	pendingAuthRequestsMu.RLock()
 	defer pendingAuthRequestsMu.RUnlock()
 	return pendingAuthRequests[extensionID]
 }
 func ClearPendingAuthRequest(extensionID string) {
 	pendingAuthRequestsMu.Lock()
 	defer pendingAuthRequestsMu.Unlock()
 	delete(pendingAuthRequests, extensionID)
 }
 func SetExtensionAuthCode(extensionID string, authCode string) {
 	extensionAuthStateMu.Lock()
 	defer extensionAuthStateMu.Unlock()
 	state, exists := extensionAuthState[extensionID]
 	if !exists {
 		state = &ExtensionAuthState{}
 		extensionAuthState[extensionID] = state
 	}
 	state.AuthCode = authCode
 }
 func SetExtensionTokens(extensionID string, accessToken, refreshToken string, expiresAt time.Time) {
 	extensionAuthStateMu.Lock()
 	defer extensionAuthStateMu.Unlock()
 	state, exists := extensionAuthState[extensionID]
 	if !exists {
 		state = &ExtensionAuthState{}
 		extensionAuthState[extensionID] = state
 	}
 	state.AccessToken = accessToken
 	state.RefreshToken = refreshToken
 	state.ExpiresAt = expiresAt
 	state.IsAuthenticated = accessToken != ""
 }
 type ExtensionRuntime struct {
 	extensionID string
 	manifest    *ExtensionManifest
 	settings    map[string]interface{}
 	httpClient  *http.Client
 	cookieJar   http.CookieJar
 	dataDir     string
 	vm          *goja.Runtime
 }
 func NewExtensionRuntime(ext *LoadedExtension) *ExtensionRuntime {
 	jar, _ := newSimpleCookieJar()
 	runtime := &ExtensionRuntime{
 		extensionID: ext.ID,
 		manifest:    ext.Manifest,
 		settings:    make(map[string]interface{}),
 		cookieJar:   jar,
 		dataDir:     ext.DataDir,
 		vm:          ext.VM,
 	}
 	client := &http.Client{
 		Timeout: 30 * time.Second,
 		Jar:     jar,
 		CheckRedirect: func(req *http.Request, via []*http.Request) error {
 			// Validate redirect target domain against allowed domains
 			domain := req.URL.Hostname()
 			if !ext.Manifest.IsDomainAllowed(domain) {
 				GoLog("[Extension:%s] Redirect blocked: domain '%s' not in allowed list\n", ext.ID, domain)
 				return &RedirectBlockedError{Domain: domain}
 			}
 			if isPrivateIP(domain) {
 				GoLog("[Extension:%s] Redirect blocked: private IP '%s'\n", ext.ID, domain)
 				return &RedirectBlockedError{Domain: domain, IsPrivate: true}
 			}
 			// Default redirect limit (10)
 			if len(via) >= 10 {
 				return http.ErrUseLastResponse
 			}
 			return nil
 		},
 	}
 	runtime.httpClient = client
 	return runtime
 }
 type RedirectBlockedError struct {
 	Domain    string
 	IsPrivate bool
 }
 func (e *RedirectBlockedError) Error() string {
 	if e.IsPrivate {
 		return "redirect blocked: private/local network access denied"
 	}
 	return "redirect blocked: domain '" + e.Domain + "' not in allowed list"
 }
 // isPrivateIP checks if a hostname resolves to a private/local IP address
 func isPrivateIP(host string) bool {
 	// Block common private network patterns
 	// This is a simple check - for production, consider DNS resolution
 	privatePatterns := []string{
 		"localhost",
 		"127.",
 		"10.",
 		"172.16.", "172.17.", "172.18.", "172.19.",
 		"172.20.", "172.21.", "172.22.", "172.23.",
 		"172.24.", "172.25.", "172.26.", "172.27.",
 		"172.28.", "172.29.", "172.30.", "172.31.",
 		"192.168.",
 		"169.254.",
 		"::1",
 		"fc00:",
 		"fe80:",
 	}
 	hostLower := host
 	for _, pattern := range privatePatterns {
 		if hostLower == pattern || len(hostLower) > len(pattern) && hostLower[:len(pattern)] == pattern {
 			return true
 		}
 	}
 	// Also block .local domains
 	if len(host) > 6 && host[len(host)-6:] == ".local" {
 		return true
 	}
 	return false
 }
 type simpleCookieJar struct {
 	cookies map[string][]*http.Cookie
 	mu      sync.RWMutex
 }
 func newSimpleCookieJar() (*simpleCookieJar, error) {
 	return &simpleCookieJar{
 		cookies: make(map[string][]*http.Cookie),
 	}, nil
 }
 func (j *simpleCookieJar) SetCookies(u *url.URL, cookies []*http.Cookie) {
 	j.mu.Lock()
 	defer j.mu.Unlock()
 	key := u.Host
 	j.cookies[key] = append(j.cookies[key], cookies...)
 }
 func (j *simpleCookieJar) Cookies(u *url.URL) []*http.Cookie {
 	j.mu.RLock()
 	defer j.mu.RUnlock()
 	return j.cookies[u.Host]
 }
 func (r *ExtensionRuntime) SetSettings(settings map[string]interface{}) {
 	r.settings = settings
 }
 // RegisterAPIs registers all sandboxed APIs to the Goja VM
 func (r *ExtensionRuntime) RegisterAPIs(vm *goja.Runtime) {
 	r.vm = vm
 	// HTTP client (sandboxed to allowed domains)
 	httpObj := vm.NewObject()
 	httpObj.Set("get", r.httpGet)
 	httpObj.Set("post", r.httpPost)
 	httpObj.Set("put", r.httpPut)
 	httpObj.Set("delete", r.httpDelete)
 	httpObj.Set("patch", r.httpPatch)
 	httpObj.Set("request", r.httpRequest) // Generic HTTP request (GET, POST, PUT, DELETE, etc.)
 	httpObj.Set("clearCookies", r.httpClearCookies)
 	vm.Set("http", httpObj)
 	storageObj := vm.NewObject()
 	storageObj.Set("get", r.storageGet)
 	storageObj.Set("set", r.storageSet)
 	storageObj.Set("remove", r.storageRemove)
 	vm.Set("storage", storageObj)
 	// Secure Credentials API (encrypted storage for sensitive data)
 	credentialsObj := vm.NewObject()
 	credentialsObj.Set("store", r.credentialsStore)
 	credentialsObj.Set("get", r.credentialsGet)
 	credentialsObj.Set("remove", r.credentialsRemove)
 	credentialsObj.Set("has", r.credentialsHas)
 	vm.Set("credentials", credentialsObj)
 	authObj := vm.NewObject()
 	authObj.Set("openAuthUrl", r.authOpenUrl)
 	authObj.Set("getAuthCode", r.authGetCode)
 	authObj.Set("setAuthCode", r.authSetCode)
 	authObj.Set("clearAuth", r.authClear)
 	authObj.Set("isAuthenticated", r.authIsAuthenticated)
 	authObj.Set("getTokens", r.authGetTokens)
 	// PKCE support
 	authObj.Set("generatePKCE", r.authGeneratePKCE)
 	authObj.Set("getPKCE", r.authGetPKCE)
 	authObj.Set("startOAuthWithPKCE", r.authStartOAuthWithPKCE)
 	authObj.Set("exchangeCodeWithPKCE", r.authExchangeCodeWithPKCE)
 	vm.Set("auth", authObj)
 	// File operations (sandboxed)
 	fileObj := vm.NewObject()
 	fileObj.Set("download", r.fileDownload)
 	fileObj.Set("exists", r.fileExists)
 	fileObj.Set("delete", r.fileDelete)
 	fileObj.Set("read", r.fileRead)
 	fileObj.Set("write", r.fileWrite)
 	fileObj.Set("copy", r.fileCopy)
 	fileObj.Set("move", r.fileMove)
 	fileObj.Set("getSize", r.fileGetSize)
 	vm.Set("file", fileObj)
 	ffmpegObj := vm.NewObject()
 	ffmpegObj.Set("execute", r.ffmpegExecute)
 	ffmpegObj.Set("getInfo", r.ffmpegGetInfo)
 	ffmpegObj.Set("convert", r.ffmpegConvert)
 	vm.Set("ffmpeg", ffmpegObj)
 	// Track matching API
 	matchingObj := vm.NewObject()
 	matchingObj.Set("compareStrings", r.matchingCompareStrings)
 	matchingObj.Set("compareDuration", r.matchingCompareDuration)
 	matchingObj.Set("normalizeString", r.matchingNormalizeString)
 	vm.Set("matching", matchingObj)
 	utilsObj := vm.NewObject()
 	utilsObj.Set("base64Encode", r.base64Encode)
 	utilsObj.Set("base64Decode", r.base64Decode)
 	utilsObj.Set("md5", r.md5Hash)
 	utilsObj.Set("sha256", r.sha256Hash)
 	utilsObj.Set("hmacSHA256", r.hmacSHA256)
 	utilsObj.Set("hmacSHA256Base64", r.hmacSHA256Base64)
 	utilsObj.Set("hmacSHA1", r.hmacSHA1)
 	utilsObj.Set("parseJSON", r.parseJSON)
 	utilsObj.Set("stringifyJSON", r.stringifyJSON)
 	// Crypto utilities for developers
 	utilsObj.Set("encrypt", r.cryptoEncrypt)
 	utilsObj.Set("decrypt", r.cryptoDecrypt)
 	utilsObj.Set("generateKey", r.cryptoGenerateKey)
 	utilsObj.Set("randomUserAgent", r.randomUserAgent)
 	vm.Set("utils", utilsObj)
 	// Log object (already set in extension_manager.go, but we can enhance it)
 	logObj := vm.NewObject()
 	logObj.Set("debug", r.logDebug)
 	logObj.Set("info", r.logInfo)
 	logObj.Set("warn", r.logWarn)
 	logObj.Set("error", r.logError)
 	vm.Set("log", logObj)
 	gobackendObj := vm.NewObject()
 	gobackendObj.Set("sanitizeFilename", r.sanitizeFilenameWrapper)
 	vm.Set("gobackend", gobackendObj)
 	// ==================== Browser-like Polyfills ====================
 	// These make porting browser/Node.js libraries easier
 	// Global fetch() - Promise-style HTTP API (browser-compatible)
 	vm.Set("fetch", r.fetchPolyfill)
 	vm.Set("atob", r.atobPolyfill)
 	vm.Set("btoa", r.btoaPolyfill)
 	r.registerTextEncoderDecoder(vm)
 	r.registerURLClass(vm)
 	r.registerJSONGlobal(vm)
 }
@@ -0,0 +1,520 @@
 // Package gobackend provides Auth API and PKCE support for extension runtime
 package gobackend
 import (
 	"crypto/rand"
 	"crypto/sha256"
 	"encoding/base64"
 	"encoding/json"
 	"fmt"
 	"io"
 	"net/http"
 	"net/url"
 	"strings"
 	"time"
 	"github.com/dop251/goja"
 )
 // ==================== Auth API (OAuth Support) ====================
 func (r *ExtensionRuntime) authOpenUrl(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 1 {
 		return r.vm.ToValue(map[string]interface{}{
 			"success": false,
 			"error":   "auth URL is required",
 		})
 	}
 	authURL := call.Arguments[0].String()
 	callbackURL := ""
 	if len(call.Arguments) > 1 && !goja.IsUndefined(call.Arguments[1]) {
 		callbackURL = call.Arguments[1].String()
 	}
 	pendingAuthRequestsMu.Lock()
 	pendingAuthRequests[r.extensionID] = &PendingAuthRequest{
 		ExtensionID: r.extensionID,
 		AuthURL:     authURL,
 		CallbackURL: callbackURL,
 	}
 	pendingAuthRequestsMu.Unlock()
 	extensionAuthStateMu.Lock()
 	state, exists := extensionAuthState[r.extensionID]
 	if !exists {
 		state = &ExtensionAuthState{}
 		extensionAuthState[r.extensionID] = state
 	}
 	state.PendingAuthURL = authURL
 	state.AuthCode = ""
 	extensionAuthStateMu.Unlock()
 	GoLog("[Extension:%s] Auth URL requested: %s\n", r.extensionID, authURL)
 	return r.vm.ToValue(map[string]interface{}{
 		"success": true,
 		"message": "Auth URL will be opened by the app",
 	})
 }
 func (r *ExtensionRuntime) authGetCode(call goja.FunctionCall) goja.Value {
 	extensionAuthStateMu.RLock()
 	defer extensionAuthStateMu.RUnlock()
 	state, exists := extensionAuthState[r.extensionID]
 	if !exists || state.AuthCode == "" {
 		return goja.Undefined()
 	}
 	return r.vm.ToValue(state.AuthCode)
 }
 // authSetCode sets auth code and tokens (can be called by extension after token exchange)
 func (r *ExtensionRuntime) authSetCode(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 1 {
 		return r.vm.ToValue(false)
 	}
 	// Can accept either just auth code or an object with tokens
 	arg := call.Arguments[0].Export()
 	extensionAuthStateMu.Lock()
 	defer extensionAuthStateMu.Unlock()
 	state, exists := extensionAuthState[r.extensionID]
 	if !exists {
 		state = &ExtensionAuthState{}
 		extensionAuthState[r.extensionID] = state
 	}
 	switch v := arg.(type) {
 	case string:
 		state.AuthCode = v
 	case map[string]interface{}:
 		if code, ok := v["code"].(string); ok {
 			state.AuthCode = code
 		}
 		if accessToken, ok := v["access_token"].(string); ok {
 			state.AccessToken = accessToken
 			state.IsAuthenticated = true
 		}
 		if refreshToken, ok := v["refresh_token"].(string); ok {
 			state.RefreshToken = refreshToken
 		}
 		if expiresIn, ok := v["expires_in"].(float64); ok {
 			state.ExpiresAt = time.Now().Add(time.Duration(expiresIn) * time.Second)
 		}
 	}
 	return r.vm.ToValue(true)
 }
 func (r *ExtensionRuntime) authClear(call goja.FunctionCall) goja.Value {
 	extensionAuthStateMu.Lock()
 	delete(extensionAuthState, r.extensionID)
 	extensionAuthStateMu.Unlock()
 	pendingAuthRequestsMu.Lock()
 	delete(pendingAuthRequests, r.extensionID)
 	pendingAuthRequestsMu.Unlock()
 	GoLog("[Extension:%s] Auth state cleared\n", r.extensionID)
 	return r.vm.ToValue(true)
 }
 // authIsAuthenticated checks if extension has valid auth
 func (r *ExtensionRuntime) authIsAuthenticated(call goja.FunctionCall) goja.Value {
 	extensionAuthStateMu.RLock()
 	defer extensionAuthStateMu.RUnlock()
 	state, exists := extensionAuthState[r.extensionID]
 	if !exists {
 		return r.vm.ToValue(false)
 	}
 	if state.IsAuthenticated && !state.ExpiresAt.IsZero() && time.Now().After(state.ExpiresAt) {
 		return r.vm.ToValue(false)
 	}
 	return r.vm.ToValue(state.IsAuthenticated)
 }
 func (r *ExtensionRuntime) authGetTokens(call goja.FunctionCall) goja.Value {
 	extensionAuthStateMu.RLock()
 	defer extensionAuthStateMu.RUnlock()
 	state, exists := extensionAuthState[r.extensionID]
 	if !exists {
 		return r.vm.ToValue(map[string]interface{}{})
 	}
 	result := map[string]interface{}{
 		"access_token":     state.AccessToken,
 		"refresh_token":    state.RefreshToken,
 		"is_authenticated": state.IsAuthenticated,
 	}
 	if !state.ExpiresAt.IsZero() {
 		result["expires_at"] = state.ExpiresAt.Unix()
 		result["is_expired"] = time.Now().After(state.ExpiresAt)
 	}
 	return r.vm.ToValue(result)
 }
 // ==================== PKCE Support ====================
 // generatePKCEVerifier generates a cryptographically random code verifier
 // Length should be between 43-128 characters (RFC 7636)
 func generatePKCEVerifier(length int) (string, error) {
 	if length < 43 {
 		length = 43
 	}
 	if length > 128 {
 		length = 128
 	}
 	bytes := make([]byte, length)
 	if _, err := rand.Read(bytes); err != nil {
 		return "", err
 	}
 	verifier := base64.RawURLEncoding.EncodeToString(bytes)
 	if len(verifier) > length {
 		verifier = verifier[:length]
 	}
 	return verifier, nil
 }
 func generatePKCEChallenge(verifier string) string {
 	hash := sha256.Sum256([]byte(verifier))
 	// Base64url encode without padding (RFC 7636)
 	return base64.RawURLEncoding.EncodeToString(hash[:])
 }
 func (r *ExtensionRuntime) authGeneratePKCE(call goja.FunctionCall) goja.Value {
 	// Default length is 64 characters
 	length := 64
 	if len(call.Arguments) > 0 && !goja.IsUndefined(call.Arguments[0]) {
 		if l, ok := call.Arguments[0].Export().(float64); ok && l >= 43 && l <= 128 {
 			length = int(l)
 		}
 	}
 	verifier, err := generatePKCEVerifier(length)
 	if err != nil {
 		GoLog("[Extension:%s] PKCE generation error: %v\n", r.extensionID, err)
 		return r.vm.ToValue(map[string]interface{}{
 			"error": err.Error(),
 		})
 	}
 	challenge := generatePKCEChallenge(verifier)
 	extensionAuthStateMu.Lock()
 	state, exists := extensionAuthState[r.extensionID]
 	if !exists {
 		state = &ExtensionAuthState{}
 		extensionAuthState[r.extensionID] = state
 	}
 	state.PKCEVerifier = verifier
 	state.PKCEChallenge = challenge
 	extensionAuthStateMu.Unlock()
 	GoLog("[Extension:%s] PKCE generated (verifier length: %d)\n", r.extensionID, len(verifier))
 	return r.vm.ToValue(map[string]interface{}{
 		"verifier":  verifier,
 		"challenge": challenge,
 		"method":    "S256",
 	})
 }
 func (r *ExtensionRuntime) authGetPKCE(call goja.FunctionCall) goja.Value {
 	extensionAuthStateMu.RLock()
 	defer extensionAuthStateMu.RUnlock()
 	state, exists := extensionAuthState[r.extensionID]
 	if !exists || state.PKCEVerifier == "" {
 		return r.vm.ToValue(map[string]interface{}{})
 	}
 	return r.vm.ToValue(map[string]interface{}{
 		"verifier":  state.PKCEVerifier,
 		"challenge": state.PKCEChallenge,
 		"method":    "S256",
 	})
 }
 // authStartOAuthWithPKCE is a high-level helper that generates PKCE and opens OAuth URL
 // config: { authUrl, clientId, redirectUri, scope, extraParams }
 // Returns: { success, authUrl, pkce: { verifier, challenge } }
 func (r *ExtensionRuntime) authStartOAuthWithPKCE(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 1 {
 		return r.vm.ToValue(map[string]interface{}{
 			"success": false,
 			"error":   "config object is required",
 		})
 	}
 	configObj := call.Arguments[0].Export()
 	config, ok := configObj.(map[string]interface{})
 	if !ok {
 		return r.vm.ToValue(map[string]interface{}{
 			"success": false,
 			"error":   "config must be an object",
 		})
 	}
 	// Required fields
 	authURL, _ := config["authUrl"].(string)
 	clientID, _ := config["clientId"].(string)
 	redirectURI, _ := config["redirectUri"].(string)
 	if authURL == "" || clientID == "" || redirectURI == "" {
 		return r.vm.ToValue(map[string]interface{}{
 			"success": false,
 			"error":   "authUrl, clientId, and redirectUri are required",
 		})
 	}
 	// Optional fields
 	scope, _ := config["scope"].(string)
 	extraParams, _ := config["extraParams"].(map[string]interface{})
 	// Generate PKCE
 	verifier, err := generatePKCEVerifier(64)
 	if err != nil {
 		return r.vm.ToValue(map[string]interface{}{
 			"success": false,
 			"error":   fmt.Sprintf("failed to generate PKCE: %v", err),
 		})
 	}
 	challenge := generatePKCEChallenge(verifier)
 	// Store PKCE in auth state
 	extensionAuthStateMu.Lock()
 	state, exists := extensionAuthState[r.extensionID]
 	if !exists {
 		state = &ExtensionAuthState{}
 		extensionAuthState[r.extensionID] = state
 	}
 	state.PKCEVerifier = verifier
 	state.PKCEChallenge = challenge
 	state.AuthCode = "" // Clear any previous auth code
 	extensionAuthStateMu.Unlock()
 	// Build OAuth URL with PKCE parameters
 	parsedURL, err := url.Parse(authURL)
 	if err != nil {
 		return r.vm.ToValue(map[string]interface{}{
 			"success": false,
 			"error":   fmt.Sprintf("invalid authUrl: %v", err),
 		})
 	}
 	query := parsedURL.Query()
 	query.Set("client_id", clientID)
 	query.Set("redirect_uri", redirectURI)
 	query.Set("response_type", "code")
 	query.Set("code_challenge", challenge)
 	query.Set("code_challenge_method", "S256")
 	if scope != "" {
 		query.Set("scope", scope)
 	}
 	// Add extra params
 	for k, v := range extraParams {
 		query.Set(k, fmt.Sprintf("%v", v))
 	}
 	parsedURL.RawQuery = query.Encode()
 	fullAuthURL := parsedURL.String()
 	// Store pending auth request for Flutter
 	pendingAuthRequestsMu.Lock()
 	pendingAuthRequests[r.extensionID] = &PendingAuthRequest{
 		ExtensionID: r.extensionID,
 		AuthURL:     fullAuthURL,
 		CallbackURL: redirectURI,
 	}
 	pendingAuthRequestsMu.Unlock()
 	GoLog("[Extension:%s] PKCE OAuth started: %s\n", r.extensionID, fullAuthURL)
 	return r.vm.ToValue(map[string]interface{}{
 		"success": true,
 		"authUrl": fullAuthURL,
 		"pkce": map[string]interface{}{
 			"verifier":  verifier,
 			"challenge": challenge,
 			"method":    "S256",
 		},
 	})
 }
 // authExchangeCodeWithPKCE exchanges auth code for tokens using PKCE
 // config: { tokenUrl, clientId, redirectUri, code, extraParams }
 // Uses the stored PKCE verifier automatically
 func (r *ExtensionRuntime) authExchangeCodeWithPKCE(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 1 {
 		return r.vm.ToValue(map[string]interface{}{
 			"success": false,
 			"error":   "config object is required",
 		})
 	}
 	configObj := call.Arguments[0].Export()
 	config, ok := configObj.(map[string]interface{})
 	if !ok {
 		return r.vm.ToValue(map[string]interface{}{
 			"success": false,
 			"error":   "config must be an object",
 		})
 	}
 	// Required fields
 	tokenURL, _ := config["tokenUrl"].(string)
 	clientID, _ := config["clientId"].(string)
 	redirectURI, _ := config["redirectUri"].(string)
 	code, _ := config["code"].(string)
 	if tokenURL == "" || clientID == "" || code == "" {
 		return r.vm.ToValue(map[string]interface{}{
 			"success": false,
 			"error":   "tokenUrl, clientId, and code are required",
 		})
 	}
 	extensionAuthStateMu.RLock()
 	state, exists := extensionAuthState[r.extensionID]
 	var verifier string
 	if exists {
 		verifier = state.PKCEVerifier
 	}
 	extensionAuthStateMu.RUnlock()
 	if verifier == "" {
 		return r.vm.ToValue(map[string]interface{}{
 			"success": false,
 			"error":   "no PKCE verifier found - call generatePKCE or startOAuthWithPKCE first",
 		})
 	}
 	if err := r.validateDomain(tokenURL); err != nil {
 		return r.vm.ToValue(map[string]interface{}{
 			"success": false,
 			"error":   err.Error(),
 		})
 	}
 	formData := url.Values{}
 	formData.Set("grant_type", "authorization_code")
 	formData.Set("client_id", clientID)
 	formData.Set("code", code)
 	formData.Set("code_verifier", verifier)
 	if redirectURI != "" {
 		formData.Set("redirect_uri", redirectURI)
 	}
 	if extraParams, ok := config["extraParams"].(map[string]interface{}); ok {
 		for k, v := range extraParams {
 			formData.Set(k, fmt.Sprintf("%v", v))
 		}
 	}
 	req, err := http.NewRequest("POST", tokenURL, strings.NewReader(formData.Encode()))
 	if err != nil {
 		return r.vm.ToValue(map[string]interface{}{
 			"success": false,
 			"error":   err.Error(),
 		})
 	}
 	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
 	req.Header.Set("User-Agent", "SpotiFLAC-Extension/1.0")
 	resp, err := r.httpClient.Do(req)
 	if err != nil {
 		return r.vm.ToValue(map[string]interface{}{
 			"success": false,
 			"error":   err.Error(),
 		})
 	}
 	defer resp.Body.Close()
 	body, err := io.ReadAll(resp.Body)
 	if err != nil {
 		return r.vm.ToValue(map[string]interface{}{
 			"success": false,
 			"error":   err.Error(),
 		})
 	}
 	var tokenResp map[string]interface{}
 	if err := json.Unmarshal(body, &tokenResp); err != nil {
 		return r.vm.ToValue(map[string]interface{}{
 			"success": false,
 			"error":   fmt.Sprintf("failed to parse token response: %v", err),
 			"body":    string(body),
 		})
 	}
 	if errMsg, ok := tokenResp["error"].(string); ok {
 		errDesc, _ := tokenResp["error_description"].(string)
 		return r.vm.ToValue(map[string]interface{}{
 			"success":           false,
 			"error":             errMsg,
 			"error_description": errDesc,
 		})
 	}
 	accessToken, _ := tokenResp["access_token"].(string)
 	refreshToken, _ := tokenResp["refresh_token"].(string)
 	expiresIn, _ := tokenResp["expires_in"].(float64)
 	if accessToken == "" {
 		return r.vm.ToValue(map[string]interface{}{
 			"success": false,
 			"error":   "no access_token in response",
 			"body":    string(body),
 		})
 	}
 	extensionAuthStateMu.Lock()
 	state, exists = extensionAuthState[r.extensionID]
 	if !exists {
 		state = &ExtensionAuthState{}
 		extensionAuthState[r.extensionID] = state
 	}
 	state.AccessToken = accessToken
 	state.RefreshToken = refreshToken
 	state.IsAuthenticated = true
 	if expiresIn > 0 {
 		state.ExpiresAt = time.Now().Add(time.Duration(expiresIn) * time.Second)
 	}
 	state.PKCEVerifier = ""
 	state.PKCEChallenge = ""
 	extensionAuthStateMu.Unlock()
 	GoLog("[Extension:%s] PKCE token exchange successful\n", r.extensionID)
 	result := map[string]interface{}{
 		"success":       true,
 		"access_token":  accessToken,
 		"refresh_token": refreshToken,
 		"token_type":    tokenResp["token_type"],
 	}
 	if expiresIn > 0 {
 		result["expires_in"] = expiresIn
 	}
 	if scope, ok := tokenResp["scope"].(string); ok {
 		result["scope"] = scope
 	}
 	return r.vm.ToValue(result)
 }
@@ -0,0 +1,198 @@
 // Package gobackend provides FFmpeg API for extension runtime
 package gobackend
 import (
 	"fmt"
 	"strings"
 	"sync"
 	"time"
 	"github.com/dop251/goja"
 )
 // ==================== FFmpeg API (Post-Processing) ====================
 // FFmpegCommand holds a pending FFmpeg command for Flutter to execute
 type FFmpegCommand struct {
 	ExtensionID string
 	Command     string
 	InputPath   string
 	OutputPath  string
 	Completed   bool
 	Success     bool
 	Error       string
 	Output      string
 }
 // Global FFmpeg command queue
 var (
 	ffmpegCommands   = make(map[string]*FFmpegCommand)
 	ffmpegCommandsMu sync.RWMutex
 	ffmpegCommandID  int64
 )
 func GetPendingFFmpegCommand(commandID string) *FFmpegCommand {
 	ffmpegCommandsMu.RLock()
 	defer ffmpegCommandsMu.RUnlock()
 	return ffmpegCommands[commandID]
 }
 func SetFFmpegCommandResult(commandID string, success bool, output, errorMsg string) {
 	ffmpegCommandsMu.Lock()
 	defer ffmpegCommandsMu.Unlock()
 	if cmd, exists := ffmpegCommands[commandID]; exists {
 		cmd.Completed = true
 		cmd.Success = success
 		cmd.Output = output
 		cmd.Error = errorMsg
 	}
 }
 func ClearFFmpegCommand(commandID string) {
 	ffmpegCommandsMu.Lock()
 	defer ffmpegCommandsMu.Unlock()
 	delete(ffmpegCommands, commandID)
 }
 func (r *ExtensionRuntime) ffmpegExecute(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 1 {
 		return r.vm.ToValue(map[string]interface{}{
 			"success": false,
 			"error":   "command is required",
 		})
 	}
 	command := call.Arguments[0].String()
 	// Generate unique command ID
 	ffmpegCommandsMu.Lock()
 	ffmpegCommandID++
 	cmdID := fmt.Sprintf("%s_%d", r.extensionID, ffmpegCommandID)
 	ffmpegCommands[cmdID] = &FFmpegCommand{
 		ExtensionID: r.extensionID,
 		Command:     command,
 		Completed:   false,
 	}
 	ffmpegCommandsMu.Unlock()
 	GoLog("[Extension:%s] FFmpeg command queued: %s\n", r.extensionID, cmdID)
 	// Wait for completion (with timeout)
 	timeout := 5 * time.Minute
 	start := time.Now()
 	for {
 		ffmpegCommandsMu.RLock()
 		cmd := ffmpegCommands[cmdID]
 		completed := cmd != nil && cmd.Completed
 		ffmpegCommandsMu.RUnlock()
 		if completed {
 			ffmpegCommandsMu.RLock()
 			result := map[string]interface{}{
 				"success": cmd.Success,
 				"output":  cmd.Output,
 			}
 			if cmd.Error != "" {
 				result["error"] = cmd.Error
 			}
 			ffmpegCommandsMu.RUnlock()
 			// Cleanup
 			ClearFFmpegCommand(cmdID)
 			return r.vm.ToValue(result)
 		}
 		if time.Since(start) > timeout {
 			ClearFFmpegCommand(cmdID)
 			return r.vm.ToValue(map[string]interface{}{
 				"success": false,
 				"error":   "FFmpeg command timed out",
 			})
 		}
 		time.Sleep(100 * time.Millisecond)
 	}
 }
 func (r *ExtensionRuntime) ffmpegGetInfo(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 1 {
 		return r.vm.ToValue(map[string]interface{}{
 			"success": false,
 			"error":   "file path is required",
 		})
 	}
 	filePath := call.Arguments[0].String()
 	// Use Go's built-in audio quality function
 	quality, err := GetAudioQuality(filePath)
 	if err != nil {
 		return r.vm.ToValue(map[string]interface{}{
 			"success": false,
 			"error":   err.Error(),
 		})
 	}
 	return r.vm.ToValue(map[string]interface{}{
 		"success":       true,
 		"bit_depth":     quality.BitDepth,
 		"sample_rate":   quality.SampleRate,
 		"total_samples": quality.TotalSamples,
 		"duration":      float64(quality.TotalSamples) / float64(quality.SampleRate),
 	})
 }
 func (r *ExtensionRuntime) ffmpegConvert(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 2 {
 		return r.vm.ToValue(map[string]interface{}{
 			"success": false,
 			"error":   "input and output paths are required",
 		})
 	}
 	inputPath := call.Arguments[0].String()
 	outputPath := call.Arguments[1].String()
 	// Get options if provided
 	options := map[string]interface{}{}
 	if len(call.Arguments) > 2 && !goja.IsUndefined(call.Arguments[2]) && !goja.IsNull(call.Arguments[2]) {
 		if opts, ok := call.Arguments[2].Export().(map[string]interface{}); ok {
 			options = opts
 		}
 	}
 	// Build FFmpeg command
 	var cmdParts []string
 	cmdParts = append(cmdParts, "-i", fmt.Sprintf("%q", inputPath))
 	// Audio codec
 	if codec, ok := options["codec"].(string); ok {
 		cmdParts = append(cmdParts, "-c:a", codec)
 	}
 	// Bitrate
 	if bitrate, ok := options["bitrate"].(string); ok {
 		cmdParts = append(cmdParts, "-b:a", bitrate)
 	}
 	// Sample rate
 	if sampleRate, ok := options["sample_rate"].(float64); ok {
 		cmdParts = append(cmdParts, "-ar", fmt.Sprintf("%d", int(sampleRate)))
 	}
 	// Channels
 	if channels, ok := options["channels"].(float64); ok {
 		cmdParts = append(cmdParts, "-ac", fmt.Sprintf("%d", int(channels)))
 	}
 	// Overwrite output
 	cmdParts = append(cmdParts, "-y", fmt.Sprintf("%q", outputPath))
 	command := strings.Join(cmdParts, " ")
 	// Execute via ffmpegExecute
 	execCall := goja.FunctionCall{
 		Arguments: []goja.Value{r.vm.ToValue(command)},
 	}
 	return r.ffmpegExecute(execCall)
 }
@@ -0,0 +1,485 @@
 // Package gobackend provides File API for extension runtime
 package gobackend
 import (
 	"fmt"
 	"io"
 	"net/http"
 	"os"
 	"path/filepath"
 	"strings"
 	"sync"
 	"github.com/dop251/goja"
 )
 // ==================== File API (Sandboxed) ====================
 // List of allowed directories for file operations (set by Go backend for download operations)
 var (
 	allowedDownloadDirs   []string
 	allowedDownloadDirsMu sync.RWMutex
 )
 func SetAllowedDownloadDirs(dirs []string) {
 	allowedDownloadDirsMu.Lock()
 	defer allowedDownloadDirsMu.Unlock()
 	allowedDownloadDirs = dirs
 	GoLog("[Extension] Allowed download directories set: %v\n", dirs)
 }
 func AddAllowedDownloadDir(dir string) {
 	allowedDownloadDirsMu.Lock()
 	defer allowedDownloadDirsMu.Unlock()
 	absDir, err := filepath.Abs(dir)
 	if err == nil {
 		allowedDownloadDirs = append(allowedDownloadDirs, absDir)
 	}
 }
 func isPathInAllowedDirs(absPath string) bool {
 	allowedDownloadDirsMu.RLock()
 	defer allowedDownloadDirsMu.RUnlock()
 	for _, allowedDir := range allowedDownloadDirs {
 		if strings.HasPrefix(absPath, allowedDir) {
 			return true
 		}
 	}
 	return false
 }
 // validatePath checks if the path is within the extension's sandbox
 // Security: Absolute paths are BLOCKED unless they're in allowed download directories
 // Extensions should use relative paths for their own data storage
 func (r *ExtensionRuntime) validatePath(path string) (string, error) {
 	// Check if extension has file permission
 	if !r.manifest.Permissions.File {
 		return "", fmt.Errorf("file access denied: extension does not have 'file' permission")
 	}
 	cleanPath := filepath.Clean(path)
 	if filepath.IsAbs(cleanPath) {
 		absPath, err := filepath.Abs(cleanPath)
 		if err != nil {
 			return "", fmt.Errorf("invalid path: %w", err)
 		}
 		if isPathInAllowedDirs(absPath) {
 			return absPath, nil
 		}
 		return "", fmt.Errorf("file access denied: absolute paths are not allowed. Use relative paths within extension sandbox")
 	}
 	fullPath := filepath.Join(r.dataDir, cleanPath)
 	absPath, err := filepath.Abs(fullPath)
 	if err != nil {
 		return "", fmt.Errorf("invalid path: %w", err)
 	}
 	absDataDir, _ := filepath.Abs(r.dataDir)
 	if !strings.HasPrefix(absPath, absDataDir) {
 		return "", fmt.Errorf("file access denied: path '%s' is outside sandbox", path)
 	}
 	return absPath, nil
 }
 func (r *ExtensionRuntime) fileDownload(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 2 {
 		return r.vm.ToValue(map[string]interface{}{
 			"success": false,
 			"error":   "URL and output path are required",
 		})
 	}
 	urlStr := call.Arguments[0].String()
 	outputPath := call.Arguments[1].String()
 	if err := r.validateDomain(urlStr); err != nil {
 		return r.vm.ToValue(map[string]interface{}{
 			"success": false,
 			"error":   err.Error(),
 		})
 	}
 	fullPath, err := r.validatePath(outputPath)
 	if err != nil {
 		return r.vm.ToValue(map[string]interface{}{
 			"success": false,
 			"error":   err.Error(),
 		})
 	}
 	var onProgress goja.Callable
 	var headers map[string]string
 	if len(call.Arguments) > 2 && !goja.IsUndefined(call.Arguments[2]) && !goja.IsNull(call.Arguments[2]) {
 		optionsObj := call.Arguments[2].Export()
 		if opts, ok := optionsObj.(map[string]interface{}); ok {
 			if h, ok := opts["headers"].(map[string]interface{}); ok {
 				headers = make(map[string]string)
 				for k, v := range h {
 					headers[k] = fmt.Sprintf("%v", v)
 				}
 			}
 			if progressVal, ok := opts["onProgress"]; ok {
 				if callable, ok := goja.AssertFunction(r.vm.ToValue(progressVal)); ok {
 					onProgress = callable
 				}
 			}
 		}
 	}
 	dir := filepath.Dir(fullPath)
 	if err := os.MkdirAll(dir, 0755); err != nil {
 		return r.vm.ToValue(map[string]interface{}{
 			"success": false,
 			"error":   fmt.Sprintf("failed to create directory: %v", err),
 		})
 	}
 	req, err := http.NewRequest("GET", urlStr, nil)
 	if err != nil {
 		return r.vm.ToValue(map[string]interface{}{
 			"success": false,
 			"error":   err.Error(),
 		})
 	}
 	for k, v := range headers {
 		req.Header.Set(k, v)
 	}
 	if req.Header.Get("User-Agent") == "" {
 		req.Header.Set("User-Agent", "SpotiFLAC-Extension/1.0")
 	}
 	resp, err := r.httpClient.Do(req)
 	if err != nil {
 		return r.vm.ToValue(map[string]interface{}{
 			"success": false,
 			"error":   err.Error(),
 		})
 	}
 	defer resp.Body.Close()
 	if resp.StatusCode != 200 {
 		return r.vm.ToValue(map[string]interface{}{
 			"success": false,
 			"error":   fmt.Sprintf("HTTP error: %d", resp.StatusCode),
 		})
 	}
 	out, err := os.Create(fullPath)
 	if err != nil {
 		return r.vm.ToValue(map[string]interface{}{
 			"success": false,
 			"error":   fmt.Sprintf("failed to create file: %v", err),
 		})
 	}
 	defer out.Close()
 	contentLength := resp.ContentLength
 	var written int64
 	buf := make([]byte, 32*1024)
 	for {
 		nr, er := resp.Body.Read(buf)
 		if nr > 0 {
 			nw, ew := out.Write(buf[0:nr])
 			if nw < 0 || nr < nw {
 				nw = 0
 				if ew == nil {
 					ew = fmt.Errorf("invalid write result")
 				}
 			}
 			written += int64(nw)
 			if ew != nil {
 				return r.vm.ToValue(map[string]interface{}{
 					"success": false,
 					"error":   fmt.Sprintf("failed to write file: %v", ew),
 				})
 			}
 			if nr != nw {
 				return r.vm.ToValue(map[string]interface{}{
 					"success": false,
 					"error":   "short write",
 				})
 			}
 			if onProgress != nil && contentLength > 0 {
 				_, _ = onProgress(goja.Undefined(), r.vm.ToValue(written), r.vm.ToValue(contentLength))
 			}
 		}
 		if er != nil {
 			if er != io.EOF {
 				return r.vm.ToValue(map[string]interface{}{
 					"success": false,
 					"error":   fmt.Sprintf("failed to read response: %v", er),
 				})
 			}
 			break
 		}
 	}
 	GoLog("[Extension:%s] Downloaded %d bytes to %s\n", r.extensionID, written, fullPath)
 	return r.vm.ToValue(map[string]interface{}{
 		"success": true,
 		"path":    fullPath,
 		"size":    written,
 	})
 }
 func (r *ExtensionRuntime) fileExists(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 1 {
 		return r.vm.ToValue(false)
 	}
 	path := call.Arguments[0].String()
 	fullPath, err := r.validatePath(path)
 	if err != nil {
 		return r.vm.ToValue(false)
 	}
 	_, err = os.Stat(fullPath)
 	return r.vm.ToValue(err == nil)
 }
 func (r *ExtensionRuntime) fileDelete(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 1 {
 		return r.vm.ToValue(map[string]interface{}{
 			"success": false,
 			"error":   "path is required",
 		})
 	}
 	path := call.Arguments[0].String()
 	fullPath, err := r.validatePath(path)
 	if err != nil {
 		return r.vm.ToValue(map[string]interface{}{
 			"success": false,
 			"error":   err.Error(),
 		})
 	}
 	if err := os.Remove(fullPath); err != nil {
 		return r.vm.ToValue(map[string]interface{}{
 			"success": false,
 			"error":   err.Error(),
 		})
 	}
 	return r.vm.ToValue(map[string]interface{}{
 		"success": true,
 	})
 }
 func (r *ExtensionRuntime) fileRead(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 1 {
 		return r.vm.ToValue(map[string]interface{}{
 			"success": false,
 			"error":   "path is required",
 		})
 	}
 	path := call.Arguments[0].String()
 	fullPath, err := r.validatePath(path)
 	if err != nil {
 		return r.vm.ToValue(map[string]interface{}{
 			"success": false,
 			"error":   err.Error(),
 		})
 	}
 	data, err := os.ReadFile(fullPath)
 	if err != nil {
 		return r.vm.ToValue(map[string]interface{}{
 			"success": false,
 			"error":   err.Error(),
 		})
 	}
 	return r.vm.ToValue(map[string]interface{}{
 		"success": true,
 		"data":    string(data),
 	})
 }
 func (r *ExtensionRuntime) fileWrite(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 2 {
 		return r.vm.ToValue(map[string]interface{}{
 			"success": false,
 			"error":   "path and data are required",
 		})
 	}
 	path := call.Arguments[0].String()
 	data := call.Arguments[1].String()
 	fullPath, err := r.validatePath(path)
 	if err != nil {
 		return r.vm.ToValue(map[string]interface{}{
 			"success": false,
 			"error":   err.Error(),
 		})
 	}
 	// Create directory if needed
 	dir := filepath.Dir(fullPath)
 	if err := os.MkdirAll(dir, 0755); err != nil {
 		return r.vm.ToValue(map[string]interface{}{
 			"success": false,
 			"error":   fmt.Sprintf("failed to create directory: %v", err),
 		})
 	}
 	if err := os.WriteFile(fullPath, []byte(data), 0644); err != nil {
 		return r.vm.ToValue(map[string]interface{}{
 			"success": false,
 			"error":   err.Error(),
 		})
 	}
 	return r.vm.ToValue(map[string]interface{}{
 		"success": true,
 		"path":    fullPath,
 	})
 }
 func (r *ExtensionRuntime) fileCopy(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 2 {
 		return r.vm.ToValue(map[string]interface{}{
 			"success": false,
 			"error":   "source and destination paths are required",
 		})
 	}
 	srcPath := call.Arguments[0].String()
 	dstPath := call.Arguments[1].String()
 	fullSrc, err := r.validatePath(srcPath)
 	if err != nil {
 		return r.vm.ToValue(map[string]interface{}{
 			"success": false,
 			"error":   err.Error(),
 		})
 	}
 	fullDst, err := r.validatePath(dstPath)
 	if err != nil {
 		return r.vm.ToValue(map[string]interface{}{
 			"success": false,
 			"error":   err.Error(),
 		})
 	}
 	data, err := os.ReadFile(fullSrc)
 	if err != nil {
 		return r.vm.ToValue(map[string]interface{}{
 			"success": false,
 			"error":   fmt.Sprintf("failed to read source: %v", err),
 		})
 	}
 	dir := filepath.Dir(fullDst)
 	if err := os.MkdirAll(dir, 0755); err != nil {
 		return r.vm.ToValue(map[string]interface{}{
 			"success": false,
 			"error":   fmt.Sprintf("failed to create directory: %v", err),
 		})
 	}
 	if err := os.WriteFile(fullDst, data, 0644); err != nil {
 		return r.vm.ToValue(map[string]interface{}{
 			"success": false,
 			"error":   fmt.Sprintf("failed to write destination: %v", err),
 		})
 	}
 	return r.vm.ToValue(map[string]interface{}{
 		"success": true,
 		"path":    fullDst,
 	})
 }
 func (r *ExtensionRuntime) fileMove(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 2 {
 		return r.vm.ToValue(map[string]interface{}{
 			"success": false,
 			"error":   "source and destination paths are required",
 		})
 	}
 	srcPath := call.Arguments[0].String()
 	dstPath := call.Arguments[1].String()
 	fullSrc, err := r.validatePath(srcPath)
 	if err != nil {
 		return r.vm.ToValue(map[string]interface{}{
 			"success": false,
 			"error":   err.Error(),
 		})
 	}
 	fullDst, err := r.validatePath(dstPath)
 	if err != nil {
 		return r.vm.ToValue(map[string]interface{}{
 			"success": false,
 			"error":   err.Error(),
 		})
 	}
 	dir := filepath.Dir(fullDst)
 	if err := os.MkdirAll(dir, 0755); err != nil {
 		return r.vm.ToValue(map[string]interface{}{
 			"success": false,
 			"error":   fmt.Sprintf("failed to create directory: %v", err),
 		})
 	}
 	if err := os.Rename(fullSrc, fullDst); err != nil {
 		return r.vm.ToValue(map[string]interface{}{
 			"success": false,
 			"error":   fmt.Sprintf("failed to move file: %v", err),
 		})
 	}
 	return r.vm.ToValue(map[string]interface{}{
 		"success": true,
 		"path":    fullDst,
 	})
 }
 func (r *ExtensionRuntime) fileGetSize(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 1 {
 		return r.vm.ToValue(map[string]interface{}{
 			"success": false,
 			"error":   "path is required",
 		})
 	}
 	path := call.Arguments[0].String()
 	fullPath, err := r.validatePath(path)
 	if err != nil {
 		return r.vm.ToValue(map[string]interface{}{
 			"success": false,
 			"error":   err.Error(),
 		})
 	}
 	info, err := os.Stat(fullPath)
 	if err != nil {
 		return r.vm.ToValue(map[string]interface{}{
 			"success": false,
 			"error":   err.Error(),
 		})
 	}
 	return r.vm.ToValue(map[string]interface{}{
 		"success": true,
 		"size":    info.Size(),
 	})
 }
@@ -0,0 +1,489 @@
 // Package gobackend provides HTTP API for extension runtime
 package gobackend
 import (
 	"encoding/json"
 	"fmt"
 	"io"
 	"net/http"
 	"net/url"
 	"strings"
 	"github.com/dop251/goja"
 )
 // ==================== HTTP API (Sandboxed) ====================
 // HTTPResponse represents the response from an HTTP request
 type HTTPResponse struct {
 	StatusCode int               `json:"statusCode"`
 	Body       string            `json:"body"`
 	Headers    map[string]string `json:"headers"`
 }
 // validateDomain checks if the domain is allowed by the extension's permissions
 func (r *ExtensionRuntime) validateDomain(urlStr string) error {
 	parsed, err := url.Parse(urlStr)
 	if err != nil {
 		return fmt.Errorf("invalid URL: %w", err)
 	}
 	domain := parsed.Hostname()
 	// Block private/local network access (SSRF protection)
 	if isPrivateIP(domain) {
 		return fmt.Errorf("network access denied: private/local network '%s' not allowed", domain)
 	}
 	if !r.manifest.IsDomainAllowed(domain) {
 		return fmt.Errorf("network access denied: domain '%s' not in allowed list", domain)
 	}
 	return nil
 }
 // httpGet performs a GET request (sandboxed)
 func (r *ExtensionRuntime) httpGet(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 1 {
 		return r.vm.ToValue(map[string]interface{}{
 			"error": "URL is required",
 		})
 	}
 	urlStr := call.Arguments[0].String()
 	if err := r.validateDomain(urlStr); err != nil {
 		GoLog("[Extension:%s] HTTP blocked: %v\n", r.extensionID, err)
 		return r.vm.ToValue(map[string]interface{}{
 			"error": err.Error(),
 		})
 	}
 	headers := make(map[string]string)
 	if len(call.Arguments) > 1 && !goja.IsUndefined(call.Arguments[1]) && !goja.IsNull(call.Arguments[1]) {
 		headersObj := call.Arguments[1].Export()
 		if h, ok := headersObj.(map[string]interface{}); ok {
 			for k, v := range h {
 				headers[k] = fmt.Sprintf("%v", v)
 			}
 		}
 	}
 	req, err := http.NewRequest("GET", urlStr, nil)
 	if err != nil {
 		return r.vm.ToValue(map[string]interface{}{
 			"error": err.Error(),
 		})
 	}
 	// Set headers - user headers first
 	for k, v := range headers {
 		req.Header.Set(k, v)
 	}
 	// Only set default User-Agent if not provided by extension
 	if req.Header.Get("User-Agent") == "" {
 		req.Header.Set("User-Agent", "Spotiflac-Extension/1.0")
 	}
 	// Execute request
 	resp, err := r.httpClient.Do(req)
 	if err != nil {
 		return r.vm.ToValue(map[string]interface{}{
 			"error": err.Error(),
 		})
 	}
 	defer resp.Body.Close()
 	body, err := io.ReadAll(resp.Body)
 	if err != nil {
 		return r.vm.ToValue(map[string]interface{}{
 			"error": err.Error(),
 		})
 	}
 	// Extract response headers - return all values as arrays for multi-value headers (cookies, etc.)
 	respHeaders := make(map[string]interface{})
 	for k, v := range resp.Header {
 		if len(v) == 1 {
 			respHeaders[k] = v[0]
 		} else {
 			respHeaders[k] = v // Return as array if multiple values
 		}
 	}
 	return r.vm.ToValue(map[string]interface{}{
 		"statusCode": resp.StatusCode,
 		"status":     resp.StatusCode, // Alias for convenience
 		"ok":         resp.StatusCode >= 200 && resp.StatusCode < 300,
 		"body":       string(body),
 		"headers":    respHeaders,
 	})
 }
 // httpPost performs a POST request (sandboxed)
 func (r *ExtensionRuntime) httpPost(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 1 {
 		return r.vm.ToValue(map[string]interface{}{
 			"error": "URL is required",
 		})
 	}
 	urlStr := call.Arguments[0].String()
 	if err := r.validateDomain(urlStr); err != nil {
 		GoLog("[Extension:%s] HTTP blocked: %v\n", r.extensionID, err)
 		return r.vm.ToValue(map[string]interface{}{
 			"error": err.Error(),
 		})
 	}
 	// Get body if provided - support both string and object
 	var bodyStr string
 	if len(call.Arguments) > 1 && !goja.IsUndefined(call.Arguments[1]) && !goja.IsNull(call.Arguments[1]) {
 		bodyArg := call.Arguments[1].Export()
 		switch v := bodyArg.(type) {
 		case string:
 			bodyStr = v
 		case map[string]interface{}, []interface{}:
 			// Auto-stringify objects and arrays to JSON
 			jsonBytes, err := json.Marshal(v)
 			if err != nil {
 				return r.vm.ToValue(map[string]interface{}{
 					"error": fmt.Sprintf("failed to stringify body: %v", err),
 				})
 			}
 			bodyStr = string(jsonBytes)
 		default:
 			// Fallback to string conversion
 			bodyStr = call.Arguments[1].String()
 		}
 	}
 	// Get headers if provided
 	headers := make(map[string]string)
 	if len(call.Arguments) > 2 && !goja.IsUndefined(call.Arguments[2]) && !goja.IsNull(call.Arguments[2]) {
 		headersObj := call.Arguments[2].Export()
 		if h, ok := headersObj.(map[string]interface{}); ok {
 			for k, v := range h {
 				headers[k] = fmt.Sprintf("%v", v)
 			}
 		}
 	}
 	req, err := http.NewRequest("POST", urlStr, strings.NewReader(bodyStr))
 	if err != nil {
 		return r.vm.ToValue(map[string]interface{}{
 			"error": err.Error(),
 		})
 	}
 	// Set headers - user headers first
 	for k, v := range headers {
 		req.Header.Set(k, v)
 	}
 	// Only set defaults if not provided by extension
 	if req.Header.Get("User-Agent") == "" {
 		req.Header.Set("User-Agent", "Spotiflac-Extension/1.0")
 	}
 	if req.Header.Get("Content-Type") == "" {
 		req.Header.Set("Content-Type", "application/json")
 	}
 	// Execute request
 	resp, err := r.httpClient.Do(req)
 	if err != nil {
 		return r.vm.ToValue(map[string]interface{}{
 			"error": err.Error(),
 		})
 	}
 	defer resp.Body.Close()
 	body, err := io.ReadAll(resp.Body)
 	if err != nil {
 		return r.vm.ToValue(map[string]interface{}{
 			"error": err.Error(),
 		})
 	}
 	// Extract response headers - return all values as arrays for multi-value headers
 	respHeaders := make(map[string]interface{})
 	for k, v := range resp.Header {
 		if len(v) == 1 {
 			respHeaders[k] = v[0]
 		} else {
 			respHeaders[k] = v // Return as array if multiple values
 		}
 	}
 	return r.vm.ToValue(map[string]interface{}{
 		"statusCode": resp.StatusCode,
 		"status":     resp.StatusCode, // Alias for convenience
 		"ok":         resp.StatusCode >= 200 && resp.StatusCode < 300,
 		"body":       string(body),
 		"headers":    respHeaders,
 	})
 }
 func (r *ExtensionRuntime) httpRequest(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 1 {
 		return r.vm.ToValue(map[string]interface{}{
 			"error": "URL is required",
 		})
 	}
 	urlStr := call.Arguments[0].String()
 	if err := r.validateDomain(urlStr); err != nil {
 		GoLog("[Extension:%s] HTTP blocked: %v\n", r.extensionID, err)
 		return r.vm.ToValue(map[string]interface{}{
 			"error": err.Error(),
 		})
 	}
 	// Default options
 	method := "GET"
 	var bodyStr string
 	headers := make(map[string]string)
 	// Parse options if provided
 	if len(call.Arguments) > 1 && !goja.IsUndefined(call.Arguments[1]) && !goja.IsNull(call.Arguments[1]) {
 		optionsObj := call.Arguments[1].Export()
 		if opts, ok := optionsObj.(map[string]interface{}); ok {
 			// Get method
 			if m, ok := opts["method"].(string); ok {
 				method = strings.ToUpper(m)
 			}
 			// Get body - support both string and object
 			if bodyArg, ok := opts["body"]; ok && bodyArg != nil {
 				switch v := bodyArg.(type) {
 				case string:
 					bodyStr = v
 				case map[string]interface{}, []interface{}:
 					// Auto-stringify objects and arrays to JSON
 					jsonBytes, err := json.Marshal(v)
 					if err != nil {
 						return r.vm.ToValue(map[string]interface{}{
 							"error": fmt.Sprintf("failed to stringify body: %v", err),
 						})
 					}
 					bodyStr = string(jsonBytes)
 				default:
 					bodyStr = fmt.Sprintf("%v", v)
 				}
 			}
 			// Get headers
 			if h, ok := opts["headers"].(map[string]interface{}); ok {
 				for k, v := range h {
 					headers[k] = fmt.Sprintf("%v", v)
 				}
 			}
 		}
 	}
 	// Create request
 	var reqBody io.Reader
 	if bodyStr != "" {
 		reqBody = strings.NewReader(bodyStr)
 	}
 	req, err := http.NewRequest(method, urlStr, reqBody)
 	if err != nil {
 		return r.vm.ToValue(map[string]interface{}{
 			"error": err.Error(),
 		})
 	}
 	// Set headers - user headers first
 	for k, v := range headers {
 		req.Header.Set(k, v)
 	}
 	// Only set defaults if not provided by extension
 	if req.Header.Get("User-Agent") == "" {
 		req.Header.Set("User-Agent", "Spotiflac-Extension/1.0")
 	}
 	if bodyStr != "" && req.Header.Get("Content-Type") == "" {
 		req.Header.Set("Content-Type", "application/json")
 	}
 	// Execute request
 	resp, err := r.httpClient.Do(req)
 	if err != nil {
 		return r.vm.ToValue(map[string]interface{}{
 			"error": err.Error(),
 		})
 	}
 	defer resp.Body.Close()
 	body, err := io.ReadAll(resp.Body)
 	if err != nil {
 		return r.vm.ToValue(map[string]interface{}{
 			"error": err.Error(),
 		})
 	}
 	// Extract response headers - return all values as arrays for multi-value headers
 	respHeaders := make(map[string]interface{})
 	for k, v := range resp.Header {
 		if len(v) == 1 {
 			respHeaders[k] = v[0]
 		} else {
 			respHeaders[k] = v // Return as array if multiple values
 		}
 	}
 	// Return response with helper properties
 	return r.vm.ToValue(map[string]interface{}{
 		"statusCode": resp.StatusCode,
 		"status":     resp.StatusCode, // Alias for convenience
 		"ok":         resp.StatusCode >= 200 && resp.StatusCode < 300,
 		"body":       string(body),
 		"headers":    respHeaders,
 	})
 }
 func (r *ExtensionRuntime) httpPut(call goja.FunctionCall) goja.Value {
 	return r.httpMethodShortcut("PUT", call)
 }
 // httpDelete performs a DELETE request (shortcut for http.request with method: "DELETE")
 func (r *ExtensionRuntime) httpDelete(call goja.FunctionCall) goja.Value {
 	return r.httpMethodShortcut("DELETE", call)
 }
 func (r *ExtensionRuntime) httpPatch(call goja.FunctionCall) goja.Value {
 	return r.httpMethodShortcut("PATCH", call)
 }
 // httpMethodShortcut is a helper for PUT/DELETE/PATCH shortcuts
 // Signature: http.put(url, body, headers) / http.delete(url, headers) / http.patch(url, body, headers)
 func (r *ExtensionRuntime) httpMethodShortcut(method string, call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 1 {
 		return r.vm.ToValue(map[string]interface{}{
 			"error": "URL is required",
 		})
 	}
 	urlStr := call.Arguments[0].String()
 	if err := r.validateDomain(urlStr); err != nil {
 		GoLog("[Extension:%s] HTTP blocked: %v\n", r.extensionID, err)
 		return r.vm.ToValue(map[string]interface{}{
 			"error": err.Error(),
 		})
 	}
 	var bodyStr string
 	headers := make(map[string]string)
 	// For DELETE, second arg is headers; for PUT/PATCH, second arg is body
 	if method == "DELETE" {
 		// http.delete(url, headers)
 		if len(call.Arguments) > 1 && !goja.IsUndefined(call.Arguments[1]) && !goja.IsNull(call.Arguments[1]) {
 			headersObj := call.Arguments[1].Export()
 			if h, ok := headersObj.(map[string]interface{}); ok {
 				for k, v := range h {
 					headers[k] = fmt.Sprintf("%v", v)
 				}
 			}
 		}
 	} else {
 		// http.put(url, body, headers) / http.patch(url, body, headers)
 		if len(call.Arguments) > 1 && !goja.IsUndefined(call.Arguments[1]) && !goja.IsNull(call.Arguments[1]) {
 			bodyArg := call.Arguments[1].Export()
 			switch v := bodyArg.(type) {
 			case string:
 				bodyStr = v
 			case map[string]interface{}, []interface{}:
 				jsonBytes, err := json.Marshal(v)
 				if err != nil {
 					return r.vm.ToValue(map[string]interface{}{
 						"error": fmt.Sprintf("failed to stringify body: %v", err),
 					})
 				}
 				bodyStr = string(jsonBytes)
 			default:
 				bodyStr = call.Arguments[1].String()
 			}
 		}
 		if len(call.Arguments) > 2 && !goja.IsUndefined(call.Arguments[2]) && !goja.IsNull(call.Arguments[2]) {
 			headersObj := call.Arguments[2].Export()
 			if h, ok := headersObj.(map[string]interface{}); ok {
 				for k, v := range h {
 					headers[k] = fmt.Sprintf("%v", v)
 				}
 			}
 		}
 	}
 	// Create request
 	var reqBody io.Reader
 	if bodyStr != "" {
 		reqBody = strings.NewReader(bodyStr)
 	}
 	req, err := http.NewRequest(method, urlStr, reqBody)
 	if err != nil {
 		return r.vm.ToValue(map[string]interface{}{
 			"error": err.Error(),
 		})
 	}
 	// Set headers - user headers first
 	for k, v := range headers {
 		req.Header.Set(k, v)
 	}
 	if req.Header.Get("User-Agent") == "" {
 		req.Header.Set("User-Agent", "Spotiflac-Extension/1.0")
 	}
 	if bodyStr != "" && req.Header.Get("Content-Type") == "" {
 		req.Header.Set("Content-Type", "application/json")
 	}
 	// Execute request
 	resp, err := r.httpClient.Do(req)
 	if err != nil {
 		return r.vm.ToValue(map[string]interface{}{
 			"error": err.Error(),
 		})
 	}
 	defer resp.Body.Close()
 	body, err := io.ReadAll(resp.Body)
 	if err != nil {
 		return r.vm.ToValue(map[string]interface{}{
 			"error": err.Error(),
 		})
 	}
 	// Extract response headers
 	respHeaders := make(map[string]interface{})
 	for k, v := range resp.Header {
 		if len(v) == 1 {
 			respHeaders[k] = v[0]
 		} else {
 			respHeaders[k] = v
 		}
 	}
 	return r.vm.ToValue(map[string]interface{}{
 		"statusCode": resp.StatusCode,
 		"status":     resp.StatusCode,
 		"ok":         resp.StatusCode >= 200 && resp.StatusCode < 300,
 		"body":       string(body),
 		"headers":    respHeaders,
 	})
 }
 func (r *ExtensionRuntime) httpClearCookies(call goja.FunctionCall) goja.Value {
 	if jar, ok := r.cookieJar.(*simpleCookieJar); ok {
 		jar.mu.Lock()
 		jar.cookies = make(map[string][]*http.Cookie)
 		jar.mu.Unlock()
 		GoLog("[Extension:%s] Cookies cleared\n", r.extensionID)
 		return r.vm.ToValue(true)
 	}
 	return r.vm.ToValue(false)
 }
@@ -0,0 +1,151 @@
 // Package gobackend provides Track Matching API for extension runtime
 package gobackend
 import (
 	"strings"
 	"github.com/dop251/goja"
 )
 // ==================== Track Matching API ====================
 // matchingCompareStrings compares two strings with fuzzy matching
 func (r *ExtensionRuntime) matchingCompareStrings(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 2 {
 		return r.vm.ToValue(0.0)
 	}
 	str1 := strings.ToLower(strings.TrimSpace(call.Arguments[0].String()))
 	str2 := strings.ToLower(strings.TrimSpace(call.Arguments[1].String()))
 	if str1 == str2 {
 		return r.vm.ToValue(1.0)
 	}
 	// Calculate Levenshtein distance-based similarity
 	similarity := calculateStringSimilarity(str1, str2)
 	return r.vm.ToValue(similarity)
 }
 // matchingCompareDuration compares two durations with tolerance
 func (r *ExtensionRuntime) matchingCompareDuration(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 2 {
 		return r.vm.ToValue(false)
 	}
 	dur1 := int(call.Arguments[0].ToInteger())
 	dur2 := int(call.Arguments[1].ToInteger())
 	// Default tolerance: 3 seconds
 	tolerance := 3000 // milliseconds
 	if len(call.Arguments) > 2 && !goja.IsUndefined(call.Arguments[2]) {
 		tolerance = int(call.Arguments[2].ToInteger())
 	}
 	diff := dur1 - dur2
 	if diff < 0 {
 		diff = -diff
 	}
 	return r.vm.ToValue(diff <= tolerance)
 }
 // matchingNormalizeString normalizes a string for comparison
 func (r *ExtensionRuntime) matchingNormalizeString(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 1 {
 		return r.vm.ToValue("")
 	}
 	str := call.Arguments[0].String()
 	normalized := normalizeStringForMatching(str)
 	return r.vm.ToValue(normalized)
 }
 // calculateStringSimilarity calculates similarity between two strings (0-1)
 func calculateStringSimilarity(s1, s2 string) float64 {
 	if len(s1) == 0 && len(s2) == 0 {
 		return 1.0
 	}
 	if len(s1) == 0 || len(s2) == 0 {
 		return 0.0
 	}
 	// Use Levenshtein distance
 	distance := levenshteinDistance(s1, s2)
 	maxLen := len(s1)
 	if len(s2) > maxLen {
 		maxLen = len(s2)
 	}
 	return 1.0 - float64(distance)/float64(maxLen)
 }
 // levenshteinDistance calculates the Levenshtein distance between two strings
 func levenshteinDistance(s1, s2 string) int {
 	if len(s1) == 0 {
 		return len(s2)
 	}
 	if len(s2) == 0 {
 		return len(s1)
 	}
 	// Create matrix
 	matrix := make([][]int, len(s1)+1)
 	for i := range matrix {
 		matrix[i] = make([]int, len(s2)+1)
 		matrix[i][0] = i
 	}
 	for j := range matrix[0] {
 		matrix[0][j] = j
 	}
 	// Fill matrix
 	for i := 1; i <= len(s1); i++ {
 		for j := 1; j <= len(s2); j++ {
 			cost := 1
 			if s1[i-1] == s2[j-1] {
 				cost = 0
 			}
 			matrix[i][j] = min(
 				matrix[i-1][j]+1,      // deletion
 				matrix[i][j-1]+1,      // insertion
 				matrix[i-1][j-1]+cost, // substitution
 			)
 		}
 	}
 	return matrix[len(s1)][len(s2)]
 }
 // normalizeStringForMatching normalizes a string for comparison
 func normalizeStringForMatching(s string) string {
 	// Convert to lowercase
 	s = strings.ToLower(s)
 	// Remove common suffixes/prefixes
 	suffixes := []string{
 		" (remastered)", " (remaster)", " - remastered", " - remaster",
 		" (deluxe)", " (deluxe edition)", " - deluxe", " - deluxe edition",
 		" (explicit)", " (clean)", " [explicit]", " [clean]",
 		" (album version)", " (single version)", " (radio edit)",
 		" (feat.", " (ft.", " feat.", " ft.",
 	}
 	for _, suffix := range suffixes {
 		if idx := strings.Index(s, suffix); idx != -1 {
 			s = s[:idx]
 		}
 	}
 	// Remove special characters
 	var result strings.Builder
 	for _, r := range s {
 		if (r >= 'a' && r <= 'z') || (r >= '0' && r <= '9') || r == ' ' {
 			result.WriteRune(r)
 		}
 	}
 	// Collapse multiple spaces
 	s = strings.Join(strings.Fields(result.String()), " ")
 	return strings.TrimSpace(s)
 }
@@ -0,0 +1,488 @@
 // Package gobackend provides Browser-like Polyfills for extension runtime
 package gobackend
 import (
 	"encoding/base64"
 	"encoding/json"
 	"fmt"
 	"io"
 	"net/http"
 	"net/url"
 	"strings"
 	"github.com/dop251/goja"
 )
 // ==================== Browser-like Polyfills ====================
 // These polyfills make porting browser/Node.js libraries easier
 // without compromising sandbox security
 // fetchPolyfill implements browser-compatible fetch() API
 // Returns a Promise-like object with json(), text() methods
 func (r *ExtensionRuntime) fetchPolyfill(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 1 {
 		return r.createFetchError("URL is required")
 	}
 	urlStr := call.Arguments[0].String()
 	// Validate domain
 	if err := r.validateDomain(urlStr); err != nil {
 		GoLog("[Extension:%s] fetch blocked: %v\n", r.extensionID, err)
 		return r.createFetchError(err.Error())
 	}
 	// Parse options
 	method := "GET"
 	var bodyStr string
 	headers := make(map[string]string)
 	if len(call.Arguments) > 1 && !goja.IsUndefined(call.Arguments[1]) && !goja.IsNull(call.Arguments[1]) {
 		optionsObj := call.Arguments[1].Export()
 		if opts, ok := optionsObj.(map[string]interface{}); ok {
 			// Method
 			if m, ok := opts["method"].(string); ok {
 				method = strings.ToUpper(m)
 			}
 			// Body - support string, object (auto-stringify), or nil
 			if bodyArg, ok := opts["body"]; ok && bodyArg != nil {
 				switch v := bodyArg.(type) {
 				case string:
 					bodyStr = v
 				case map[string]interface{}, []interface{}:
 					jsonBytes, err := json.Marshal(v)
 					if err != nil {
 						return r.createFetchError(fmt.Sprintf("failed to stringify body: %v", err))
 					}
 					bodyStr = string(jsonBytes)
 				default:
 					bodyStr = fmt.Sprintf("%v", v)
 				}
 			}
 			// Headers
 			if h, ok := opts["headers"]; ok && h != nil {
 				switch hv := h.(type) {
 				case map[string]interface{}:
 					for k, v := range hv {
 						headers[k] = fmt.Sprintf("%v", v)
 					}
 				}
 			}
 		}
 	}
 	// Create HTTP request
 	var reqBody io.Reader
 	if bodyStr != "" {
 		reqBody = strings.NewReader(bodyStr)
 	}
 	req, err := http.NewRequest(method, urlStr, reqBody)
 	if err != nil {
 		return r.createFetchError(err.Error())
 	}
 	// Set headers - user headers first
 	for k, v := range headers {
 		req.Header.Set(k, v)
 	}
 	// Set defaults if not provided
 	if req.Header.Get("User-Agent") == "" {
 		req.Header.Set("User-Agent", "SpotiFLAC-Extension/1.0")
 	}
 	if bodyStr != "" && req.Header.Get("Content-Type") == "" {
 		req.Header.Set("Content-Type", "application/json")
 	}
 	// Execute request
 	resp, err := r.httpClient.Do(req)
 	if err != nil {
 		return r.createFetchError(err.Error())
 	}
 	defer resp.Body.Close()
 	// Read body
 	body, err := io.ReadAll(resp.Body)
 	if err != nil {
 		return r.createFetchError(err.Error())
 	}
 	// Extract response headers
 	respHeaders := make(map[string]interface{})
 	for k, v := range resp.Header {
 		if len(v) == 1 {
 			respHeaders[k] = v[0]
 		} else {
 			respHeaders[k] = v
 		}
 	}
 	// Create Response object (browser-compatible)
 	responseObj := r.vm.NewObject()
 	responseObj.Set("ok", resp.StatusCode >= 200 && resp.StatusCode < 300)
 	responseObj.Set("status", resp.StatusCode)
 	responseObj.Set("statusText", http.StatusText(resp.StatusCode))
 	responseObj.Set("headers", respHeaders)
 	responseObj.Set("url", urlStr)
 	// Store body for methods
 	bodyString := string(body)
 	// text() method - returns body as string
 	responseObj.Set("text", func(call goja.FunctionCall) goja.Value {
 		return r.vm.ToValue(bodyString)
 	})
 	// json() method - parses body as JSON
 	responseObj.Set("json", func(call goja.FunctionCall) goja.Value {
 		var result interface{}
 		if err := json.Unmarshal(body, &result); err != nil {
 			GoLog("[Extension:%s] fetch json() parse error: %v\n", r.extensionID, err)
 			return goja.Undefined()
 		}
 		return r.vm.ToValue(result)
 	})
 	// arrayBuffer() method - returns body as array (simplified)
 	responseObj.Set("arrayBuffer", func(call goja.FunctionCall) goja.Value {
 		// Return as array of bytes
 		byteArray := make([]interface{}, len(body))
 		for i, b := range body {
 			byteArray[i] = int(b)
 		}
 		return r.vm.ToValue(byteArray)
 	})
 	return responseObj
 }
 // createFetchError creates a fetch error response
 func (r *ExtensionRuntime) createFetchError(message string) goja.Value {
 	errorObj := r.vm.NewObject()
 	errorObj.Set("ok", false)
 	errorObj.Set("status", 0)
 	errorObj.Set("statusText", "Network Error")
 	errorObj.Set("error", message)
 	errorObj.Set("text", func(call goja.FunctionCall) goja.Value {
 		return r.vm.ToValue("")
 	})
 	errorObj.Set("json", func(call goja.FunctionCall) goja.Value {
 		return goja.Undefined()
 	})
 	return errorObj
 }
 // atobPolyfill implements browser atob() - decode base64 to string
 func (r *ExtensionRuntime) atobPolyfill(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 1 {
 		return r.vm.ToValue("")
 	}
 	input := call.Arguments[0].String()
 	decoded, err := base64.StdEncoding.DecodeString(input)
 	if err != nil {
 		// Try URL-safe base64
 		decoded, err = base64.URLEncoding.DecodeString(input)
 		if err != nil {
 			GoLog("[Extension:%s] atob decode error: %v\n", r.extensionID, err)
 			return r.vm.ToValue("")
 		}
 	}
 	return r.vm.ToValue(string(decoded))
 }
 // btoaPolyfill implements browser btoa() - encode string to base64
 func (r *ExtensionRuntime) btoaPolyfill(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 1 {
 		return r.vm.ToValue("")
 	}
 	input := call.Arguments[0].String()
 	return r.vm.ToValue(base64.StdEncoding.EncodeToString([]byte(input)))
 }
 // registerTextEncoderDecoder registers TextEncoder and TextDecoder classes
 func (r *ExtensionRuntime) registerTextEncoderDecoder(vm *goja.Runtime) {
 	// TextEncoder constructor
 	vm.Set("TextEncoder", func(call goja.ConstructorCall) *goja.Object {
 		encoder := call.This
 		encoder.Set("encoding", "utf-8")
 		// encode() method - string to Uint8Array
 		encoder.Set("encode", func(call goja.FunctionCall) goja.Value {
 			if len(call.Arguments) < 1 {
 				return vm.ToValue([]byte{})
 			}
 			input := call.Arguments[0].String()
 			bytes := []byte(input)
 			// Return as array (Uint8Array-like)
 			result := make([]interface{}, len(bytes))
 			for i, b := range bytes {
 				result[i] = int(b)
 			}
 			return vm.ToValue(result)
 		})
 		// encodeInto() method
 		encoder.Set("encodeInto", func(call goja.FunctionCall) goja.Value {
 			// Simplified implementation
 			if len(call.Arguments) < 2 {
 				return vm.ToValue(map[string]interface{}{"read": 0, "written": 0})
 			}
 			input := call.Arguments[0].String()
 			return vm.ToValue(map[string]interface{}{
 				"read":    len(input),
 				"written": len([]byte(input)),
 			})
 		})
 		return nil
 	})
 	// TextDecoder constructor
 	vm.Set("TextDecoder", func(call goja.ConstructorCall) *goja.Object {
 		decoder := call.This
 		// Get encoding from arguments (default: utf-8)
 		encoding := "utf-8"
 		if len(call.Arguments) > 0 && !goja.IsUndefined(call.Arguments[0]) {
 			encoding = call.Arguments[0].String()
 		}
 		decoder.Set("encoding", encoding)
 		decoder.Set("fatal", false)
 		decoder.Set("ignoreBOM", false)
 		// decode() method - Uint8Array to string
 		decoder.Set("decode", func(call goja.FunctionCall) goja.Value {
 			if len(call.Arguments) < 1 {
 				return vm.ToValue("")
 			}
 			// Handle different input types
 			input := call.Arguments[0].Export()
 			var bytes []byte
 			switch v := input.(type) {
 			case []byte:
 				bytes = v
 			case []interface{}:
 				bytes = make([]byte, len(v))
 				for i, val := range v {
 					switch n := val.(type) {
 					case int64:
 						bytes[i] = byte(n)
 					case float64:
 						bytes[i] = byte(n)
 					case int:
 						bytes[i] = byte(n)
 					}
 				}
 			case string:
 				// Already a string, just return it
 				return vm.ToValue(v)
 			default:
 				return vm.ToValue("")
 			}
 			return vm.ToValue(string(bytes))
 		})
 		return nil
 	})
 }
 // registerURLClass registers the URL class for URL parsing
 func (r *ExtensionRuntime) registerURLClass(vm *goja.Runtime) {
 	vm.Set("URL", func(call goja.ConstructorCall) *goja.Object {
 		urlObj := call.This
 		if len(call.Arguments) < 1 {
 			urlObj.Set("href", "")
 			return nil
 		}
 		urlStr := call.Arguments[0].String()
 		// Handle relative URLs with base
 		if len(call.Arguments) > 1 && !goja.IsUndefined(call.Arguments[1]) {
 			baseStr := call.Arguments[1].String()
 			baseURL, err := url.Parse(baseStr)
 			if err == nil {
 				relURL, err := url.Parse(urlStr)
 				if err == nil {
 					urlStr = baseURL.ResolveReference(relURL).String()
 				}
 			}
 		}
 		parsed, err := url.Parse(urlStr)
 		if err != nil {
 			urlObj.Set("href", urlStr)
 			return nil
 		}
 		// Set URL properties
 		urlObj.Set("href", parsed.String())
 		urlObj.Set("protocol", parsed.Scheme+":")
 		urlObj.Set("host", parsed.Host)
 		urlObj.Set("hostname", parsed.Hostname())
 		urlObj.Set("port", parsed.Port())
 		urlObj.Set("pathname", parsed.Path)
 		urlObj.Set("search", "")
 		if parsed.RawQuery != "" {
 			urlObj.Set("search", "?"+parsed.RawQuery)
 		}
 		urlObj.Set("hash", "")
 		if parsed.Fragment != "" {
 			urlObj.Set("hash", "#"+parsed.Fragment)
 		}
 		urlObj.Set("origin", parsed.Scheme+"://"+parsed.Host)
 		urlObj.Set("username", parsed.User.Username())
 		password, _ := parsed.User.Password()
 		urlObj.Set("password", password)
 		// searchParams object
 		searchParams := vm.NewObject()
 		queryValues := parsed.Query()
 		searchParams.Set("get", func(call goja.FunctionCall) goja.Value {
 			if len(call.Arguments) < 1 {
 				return goja.Null()
 			}
 			key := call.Arguments[0].String()
 			if val := queryValues.Get(key); val != "" {
 				return vm.ToValue(val)
 			}
 			return goja.Null()
 		})
 		searchParams.Set("getAll", func(call goja.FunctionCall) goja.Value {
 			if len(call.Arguments) < 1 {
 				return vm.ToValue([]string{})
 			}
 			key := call.Arguments[0].String()
 			return vm.ToValue(queryValues[key])
 		})
 		searchParams.Set("has", func(call goja.FunctionCall) goja.Value {
 			if len(call.Arguments) < 1 {
 				return vm.ToValue(false)
 			}
 			key := call.Arguments[0].String()
 			return vm.ToValue(queryValues.Has(key))
 		})
 		searchParams.Set("toString", func(call goja.FunctionCall) goja.Value {
 			return vm.ToValue(queryValues.Encode())
 		})
 		urlObj.Set("searchParams", searchParams)
 		// toString method
 		urlObj.Set("toString", func(call goja.FunctionCall) goja.Value {
 			return vm.ToValue(parsed.String())
 		})
 		// toJSON method
 		urlObj.Set("toJSON", func(call goja.FunctionCall) goja.Value {
 			return vm.ToValue(parsed.String())
 		})
 		return nil
 	})
 	// URLSearchParams constructor
 	vm.Set("URLSearchParams", func(call goja.ConstructorCall) *goja.Object {
 		paramsObj := call.This
 		values := url.Values{}
 		// Parse initial value if provided
 		if len(call.Arguments) > 0 && !goja.IsUndefined(call.Arguments[0]) {
 			init := call.Arguments[0].Export()
 			switch v := init.(type) {
 			case string:
 				// Parse query string
 				parsed, _ := url.ParseQuery(strings.TrimPrefix(v, "?"))
 				values = parsed
 			case map[string]interface{}:
 				for k, val := range v {
 					values.Set(k, fmt.Sprintf("%v", val))
 				}
 			}
 		}
 		paramsObj.Set("append", func(call goja.FunctionCall) goja.Value {
 			if len(call.Arguments) >= 2 {
 				values.Add(call.Arguments[0].String(), call.Arguments[1].String())
 			}
 			return goja.Undefined()
 		})
 		paramsObj.Set("delete", func(call goja.FunctionCall) goja.Value {
 			if len(call.Arguments) >= 1 {
 				values.Del(call.Arguments[0].String())
 			}
 			return goja.Undefined()
 		})
 		paramsObj.Set("get", func(call goja.FunctionCall) goja.Value {
 			if len(call.Arguments) < 1 {
 				return goja.Null()
 			}
 			if val := values.Get(call.Arguments[0].String()); val != "" {
 				return vm.ToValue(val)
 			}
 			return goja.Null()
 		})
 		paramsObj.Set("getAll", func(call goja.FunctionCall) goja.Value {
 			if len(call.Arguments) < 1 {
 				return vm.ToValue([]string{})
 			}
 			return vm.ToValue(values[call.Arguments[0].String()])
 		})
 		paramsObj.Set("has", func(call goja.FunctionCall) goja.Value {
 			if len(call.Arguments) < 1 {
 				return vm.ToValue(false)
 			}
 			return vm.ToValue(values.Has(call.Arguments[0].String()))
 		})
 		paramsObj.Set("set", func(call goja.FunctionCall) goja.Value {
 			if len(call.Arguments) >= 2 {
 				values.Set(call.Arguments[0].String(), call.Arguments[1].String())
 			}
 			return goja.Undefined()
 		})
 		paramsObj.Set("toString", func(call goja.FunctionCall) goja.Value {
 			return vm.ToValue(values.Encode())
 		})
 		return nil
 	})
 }
 // registerJSONGlobal ensures JSON global is properly set up
 func (r *ExtensionRuntime) registerJSONGlobal(vm *goja.Runtime) {
 	// JSON is already built-in to Goja, but we can enhance it
 	// This ensures JSON.parse and JSON.stringify work as expected
 	// The built-in JSON object should already work, but let's verify
 	// and add any missing functionality if needed
 	jsonScript := `
 		if (typeof JSON === 'undefined') {
 			var JSON = {
 				parse: function(text) {
 					return utils.parseJSON(text);
 				},
 				stringify: function(value, replacer, space) {
 					return utils.stringifyJSON(value);
 				}
 			};
 		}
 	`
 	_, _ = vm.RunString(jsonScript)
 }
@@ -0,0 +1,377 @@
 // Package gobackend provides Storage and Credentials API for extension runtime
 package gobackend
 import (
 	"crypto/aes"
 	"crypto/cipher"
 	"crypto/rand"
 	"crypto/sha256"
 	"encoding/json"
 	"fmt"
 	"io"
 	"os"
 	"path/filepath"
 	"github.com/dop251/goja"
 )
 // ==================== Storage API ====================
 // getStoragePath returns the path to the extension's storage file
 func (r *ExtensionRuntime) getStoragePath() string {
 	return filepath.Join(r.dataDir, "storage.json")
 }
 // loadStorage loads the storage data from disk
 func (r *ExtensionRuntime) loadStorage() (map[string]interface{}, error) {
 	storagePath := r.getStoragePath()
 	data, err := os.ReadFile(storagePath)
 	if err != nil {
 		if os.IsNotExist(err) {
 			return make(map[string]interface{}), nil
 		}
 		return nil, err
 	}
 	var storage map[string]interface{}
 	if err := json.Unmarshal(data, &storage); err != nil {
 		return nil, err
 	}
 	return storage, nil
 }
 // saveStorage saves the storage data to disk
 func (r *ExtensionRuntime) saveStorage(storage map[string]interface{}) error {
 	storagePath := r.getStoragePath()
 	data, err := json.MarshalIndent(storage, "", "  ")
 	if err != nil {
 		return err
 	}
 	return os.WriteFile(storagePath, data, 0644)
 }
 // storageGet retrieves a value from storage
 func (r *ExtensionRuntime) storageGet(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 1 {
 		return goja.Undefined()
 	}
 	key := call.Arguments[0].String()
 	storage, err := r.loadStorage()
 	if err != nil {
 		GoLog("[Extension:%s] Storage load error: %v\n", r.extensionID, err)
 		return goja.Undefined()
 	}
 	value, exists := storage[key]
 	if !exists {
 		// Return default value if provided
 		if len(call.Arguments) > 1 {
 			return call.Arguments[1]
 		}
 		return goja.Undefined()
 	}
 	return r.vm.ToValue(value)
 }
 // storageSet stores a value in storage
 func (r *ExtensionRuntime) storageSet(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 2 {
 		return r.vm.ToValue(false)
 	}
 	key := call.Arguments[0].String()
 	value := call.Arguments[1].Export()
 	storage, err := r.loadStorage()
 	if err != nil {
 		GoLog("[Extension:%s] Storage load error: %v\n", r.extensionID, err)
 		return r.vm.ToValue(false)
 	}
 	storage[key] = value
 	if err := r.saveStorage(storage); err != nil {
 		GoLog("[Extension:%s] Storage save error: %v\n", r.extensionID, err)
 		return r.vm.ToValue(false)
 	}
 	return r.vm.ToValue(true)
 }
 // storageRemove removes a value from storage
 func (r *ExtensionRuntime) storageRemove(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 1 {
 		return r.vm.ToValue(false)
 	}
 	key := call.Arguments[0].String()
 	storage, err := r.loadStorage()
 	if err != nil {
 		GoLog("[Extension:%s] Storage load error: %v\n", r.extensionID, err)
 		return r.vm.ToValue(false)
 	}
 	delete(storage, key)
 	if err := r.saveStorage(storage); err != nil {
 		GoLog("[Extension:%s] Storage save error: %v\n", r.extensionID, err)
 		return r.vm.ToValue(false)
 	}
 	return r.vm.ToValue(true)
 }
 // ==================== Credentials API (Encrypted Storage) ====================
 // getCredentialsPath returns the path to the extension's encrypted credentials file
 func (r *ExtensionRuntime) getCredentialsPath() string {
 	return filepath.Join(r.dataDir, ".credentials.enc")
 }
 // getSaltPath returns the path to the extension's encryption salt file
 func (r *ExtensionRuntime) getSaltPath() string {
 	return filepath.Join(r.dataDir, ".cred_salt")
 }
 // getOrCreateSalt gets existing salt or creates a new random one
 func (r *ExtensionRuntime) getOrCreateSalt() ([]byte, error) {
 	saltPath := r.getSaltPath()
 	salt, err := os.ReadFile(saltPath)
 	if err == nil && len(salt) == 32 {
 		return salt, nil
 	}
 	salt = make([]byte, 32)
 	if _, err := io.ReadFull(rand.Reader, salt); err != nil {
 		return nil, fmt.Errorf("failed to generate salt: %w", err)
 	}
 	if err := os.WriteFile(saltPath, salt, 0600); err != nil {
 		return nil, fmt.Errorf("failed to save salt: %w", err)
 	}
 	return salt, nil
 }
 // getEncryptionKey derives an encryption key from extension ID + random salt
 func (r *ExtensionRuntime) getEncryptionKey() ([]byte, error) {
 	// Get or create per-installation random salt
 	salt, err := r.getOrCreateSalt()
 	if err != nil {
 		return nil, err
 	}
 	// Combine extension ID + random salt for key derivation
 	// This makes each installation unique, preventing mass decryption attacks
 	combined := append([]byte(r.extensionID), salt...)
 	hash := sha256.Sum256(combined)
 	return hash[:], nil
 }
 // loadCredentials loads and decrypts credentials from disk
 func (r *ExtensionRuntime) loadCredentials() (map[string]interface{}, error) {
 	credPath := r.getCredentialsPath()
 	data, err := os.ReadFile(credPath)
 	if err != nil {
 		if os.IsNotExist(err) {
 			return make(map[string]interface{}), nil
 		}
 		return nil, err
 	}
 	// Decrypt the data
 	key, err := r.getEncryptionKey()
 	if err != nil {
 		return nil, fmt.Errorf("failed to get encryption key: %w", err)
 	}
 	decrypted, err := decryptAES(data, key)
 	if err != nil {
 		return nil, fmt.Errorf("failed to decrypt credentials: %w", err)
 	}
 	var creds map[string]interface{}
 	if err := json.Unmarshal(decrypted, &creds); err != nil {
 		return nil, err
 	}
 	return creds, nil
 }
 // saveCredentials encrypts and saves credentials to disk
 func (r *ExtensionRuntime) saveCredentials(creds map[string]interface{}) error {
 	data, err := json.Marshal(creds)
 	if err != nil {
 		return err
 	}
 	key, err := r.getEncryptionKey()
 	if err != nil {
 		return fmt.Errorf("failed to get encryption key: %w", err)
 	}
 	encrypted, err := encryptAES(data, key)
 	if err != nil {
 		return fmt.Errorf("failed to encrypt credentials: %w", err)
 	}
 	credPath := r.getCredentialsPath()
 	return os.WriteFile(credPath, encrypted, 0600) // Restrictive permissions
 }
 // credentialsStore stores an encrypted credential
 func (r *ExtensionRuntime) credentialsStore(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 2 {
 		return r.vm.ToValue(map[string]interface{}{
 			"success": false,
 			"error":   "key and value are required",
 		})
 	}
 	key := call.Arguments[0].String()
 	value := call.Arguments[1].Export()
 	creds, err := r.loadCredentials()
 	if err != nil {
 		GoLog("[Extension:%s] Credentials load error: %v\n", r.extensionID, err)
 		return r.vm.ToValue(map[string]interface{}{
 			"success": false,
 			"error":   err.Error(),
 		})
 	}
 	creds[key] = value
 	if err := r.saveCredentials(creds); err != nil {
 		GoLog("[Extension:%s] Credentials save error: %v\n", r.extensionID, err)
 		return r.vm.ToValue(map[string]interface{}{
 			"success": false,
 			"error":   err.Error(),
 		})
 	}
 	return r.vm.ToValue(map[string]interface{}{
 		"success": true,
 	})
 }
 // credentialsGet retrieves a decrypted credential
 func (r *ExtensionRuntime) credentialsGet(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 1 {
 		return goja.Undefined()
 	}
 	key := call.Arguments[0].String()
 	creds, err := r.loadCredentials()
 	if err != nil {
 		GoLog("[Extension:%s] Credentials load error: %v\n", r.extensionID, err)
 		return goja.Undefined()
 	}
 	value, exists := creds[key]
 	if !exists {
 		// Return default value if provided
 		if len(call.Arguments) > 1 {
 			return call.Arguments[1]
 		}
 		return goja.Undefined()
 	}
 	return r.vm.ToValue(value)
 }
 // credentialsRemove removes a credential
 func (r *ExtensionRuntime) credentialsRemove(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 1 {
 		return r.vm.ToValue(false)
 	}
 	key := call.Arguments[0].String()
 	creds, err := r.loadCredentials()
 	if err != nil {
 		GoLog("[Extension:%s] Credentials load error: %v\n", r.extensionID, err)
 		return r.vm.ToValue(false)
 	}
 	delete(creds, key)
 	if err := r.saveCredentials(creds); err != nil {
 		GoLog("[Extension:%s] Credentials save error: %v\n", r.extensionID, err)
 		return r.vm.ToValue(false)
 	}
 	return r.vm.ToValue(true)
 }
 // credentialsHas checks if a credential exists
 func (r *ExtensionRuntime) credentialsHas(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 1 {
 		return r.vm.ToValue(false)
 	}
 	key := call.Arguments[0].String()
 	creds, err := r.loadCredentials()
 	if err != nil {
 		return r.vm.ToValue(false)
 	}
 	_, exists := creds[key]
 	return r.vm.ToValue(exists)
 }
 // ==================== Crypto Utilities ====================
 // encryptAES encrypts data using AES-GCM
 func encryptAES(plaintext []byte, key []byte) ([]byte, error) {
 	block, err := aes.NewCipher(key)
 	if err != nil {
 		return nil, err
 	}
 	gcm, err := cipher.NewGCM(block)
 	if err != nil {
 		return nil, err
 	}
 	nonce := make([]byte, gcm.NonceSize())
 	if _, err := io.ReadFull(rand.Reader, nonce); err != nil {
 		return nil, err
 	}
 	ciphertext := gcm.Seal(nonce, nonce, plaintext, nil)
 	return ciphertext, nil
 }
 // decryptAES decrypts data using AES-GCM
 func decryptAES(ciphertext []byte, key []byte) ([]byte, error) {
 	block, err := aes.NewCipher(key)
 	if err != nil {
 		return nil, err
 	}
 	gcm, err := cipher.NewGCM(block)
 	if err != nil {
 		return nil, err
 	}
 	nonceSize := gcm.NonceSize()
 	if len(ciphertext) < nonceSize {
 		return nil, fmt.Errorf("ciphertext too short")
 	}
 	nonce, ciphertext := ciphertext[:nonceSize], ciphertext[nonceSize:]
 	plaintext, err := gcm.Open(nil, nonce, ciphertext, nil)
 	if err != nil {
 		return nil, err
 	}
 	return plaintext, nil
 }
@@ -0,0 +1,395 @@
 // Package gobackend provides Utility functions for extension runtime
 package gobackend
 import (
 	"crypto/hmac"
 	"crypto/md5"
 	"crypto/rand"
 	"crypto/sha1"
 	"crypto/sha256"
 	"encoding/base64"
 	"encoding/hex"
 	"encoding/json"
 	"fmt"
 	"strings"
 	"time"
 	"github.com/dop251/goja"
 )
 // ==================== Utility Functions ====================
 // base64Encode encodes a string to base64
 func (r *ExtensionRuntime) base64Encode(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 1 {
 		return r.vm.ToValue("")
 	}
 	input := call.Arguments[0].String()
 	return r.vm.ToValue(base64.StdEncoding.EncodeToString([]byte(input)))
 }
 // base64Decode decodes a base64 string
 func (r *ExtensionRuntime) base64Decode(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 1 {
 		return r.vm.ToValue("")
 	}
 	input := call.Arguments[0].String()
 	decoded, err := base64.StdEncoding.DecodeString(input)
 	if err != nil {
 		return r.vm.ToValue("")
 	}
 	return r.vm.ToValue(string(decoded))
 }
 // md5Hash computes MD5 hash of a string
 func (r *ExtensionRuntime) md5Hash(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 1 {
 		return r.vm.ToValue("")
 	}
 	input := call.Arguments[0].String()
 	hash := md5.Sum([]byte(input))
 	return r.vm.ToValue(hex.EncodeToString(hash[:]))
 }
 // sha256Hash computes SHA256 hash of a string
 func (r *ExtensionRuntime) sha256Hash(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 1 {
 		return r.vm.ToValue("")
 	}
 	input := call.Arguments[0].String()
 	hash := sha256.Sum256([]byte(input))
 	return r.vm.ToValue(hex.EncodeToString(hash[:]))
 }
 // hmacSHA256 computes HMAC-SHA256 of a message with a key
 func (r *ExtensionRuntime) hmacSHA256(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 2 {
 		return r.vm.ToValue("")
 	}
 	message := call.Arguments[0].String()
 	key := call.Arguments[1].String()
 	mac := hmac.New(sha256.New, []byte(key))
 	mac.Write([]byte(message))
 	return r.vm.ToValue(hex.EncodeToString(mac.Sum(nil)))
 }
 // hmacSHA256Base64 computes HMAC-SHA256 and returns base64 encoded result
 func (r *ExtensionRuntime) hmacSHA256Base64(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 2 {
 		return r.vm.ToValue("")
 	}
 	message := call.Arguments[0].String()
 	key := call.Arguments[1].String()
 	mac := hmac.New(sha256.New, []byte(key))
 	mac.Write([]byte(message))
 	return r.vm.ToValue(base64.StdEncoding.EncodeToString(mac.Sum(nil)))
 }
 // hmacSHA1 computes HMAC-SHA1 of a message with a key (for TOTP)
 // Arguments: message (string or array of bytes), key (string or array of bytes)
 // Returns: array of bytes (for TOTP dynamic truncation)
 func (r *ExtensionRuntime) hmacSHA1(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 2 {
 		return r.vm.ToValue([]byte{})
 	}
 	var keyBytes []byte
 	keyArg := call.Arguments[0].Export()
 	switch k := keyArg.(type) {
 	case string:
 		keyBytes = []byte(k)
 	case []interface{}:
 		keyBytes = make([]byte, len(k))
 		for i, v := range k {
 			if num, ok := v.(int64); ok {
 				keyBytes[i] = byte(num)
 			} else if num, ok := v.(float64); ok {
 				keyBytes[i] = byte(int(num))
 			}
 		}
 	default:
 		return r.vm.ToValue([]byte{})
 	}
 	var msgBytes []byte
 	msgArg := call.Arguments[1].Export()
 	switch m := msgArg.(type) {
 	case string:
 		msgBytes = []byte(m)
 	case []interface{}:
 		msgBytes = make([]byte, len(m))
 		for i, v := range m {
 			if num, ok := v.(int64); ok {
 				msgBytes[i] = byte(num)
 			} else if num, ok := v.(float64); ok {
 				msgBytes[i] = byte(int(num))
 			}
 		}
 	default:
 		return r.vm.ToValue([]byte{})
 	}
 	mac := hmac.New(sha1.New, keyBytes)
 	mac.Write(msgBytes)
 	result := mac.Sum(nil)
 	jsArray := make([]interface{}, len(result))
 	for i, b := range result {
 		jsArray[i] = int(b)
 	}
 	return r.vm.ToValue(jsArray)
 }
 // parseJSON parses a JSON string
 func (r *ExtensionRuntime) parseJSON(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 1 {
 		return goja.Undefined()
 	}
 	input := call.Arguments[0].String()
 	var result interface{}
 	if err := json.Unmarshal([]byte(input), &result); err != nil {
 		GoLog("[Extension:%s] JSON parse error: %v\n", r.extensionID, err)
 		return goja.Undefined()
 	}
 	return r.vm.ToValue(result)
 }
 // stringifyJSON converts a value to JSON string
 func (r *ExtensionRuntime) stringifyJSON(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 1 {
 		return r.vm.ToValue("")
 	}
 	input := call.Arguments[0].Export()
 	data, err := json.Marshal(input)
 	if err != nil {
 		GoLog("[Extension:%s] JSON stringify error: %v\n", r.extensionID, err)
 		return r.vm.ToValue("")
 	}
 	return r.vm.ToValue(string(data))
 }
 // ==================== Crypto Utilities for Extensions ====================
 // cryptoEncrypt encrypts a string using AES-GCM (for extension use)
 func (r *ExtensionRuntime) cryptoEncrypt(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 2 {
 		return r.vm.ToValue(map[string]interface{}{
 			"success": false,
 			"error":   "plaintext and key are required",
 		})
 	}
 	plaintext := call.Arguments[0].String()
 	keyStr := call.Arguments[1].String()
 	// Derive 32-byte key from provided key string
 	keyHash := sha256.Sum256([]byte(keyStr))
 	encrypted, err := encryptAES([]byte(plaintext), keyHash[:])
 	if err != nil {
 		return r.vm.ToValue(map[string]interface{}{
 			"success": false,
 			"error":   err.Error(),
 		})
 	}
 	return r.vm.ToValue(map[string]interface{}{
 		"success": true,
 		"data":    base64.StdEncoding.EncodeToString(encrypted),
 	})
 }
 // cryptoDecrypt decrypts a string using AES-GCM (for extension use)
 func (r *ExtensionRuntime) cryptoDecrypt(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 2 {
 		return r.vm.ToValue(map[string]interface{}{
 			"success": false,
 			"error":   "ciphertext and key are required",
 		})
 	}
 	ciphertextB64 := call.Arguments[0].String()
 	keyStr := call.Arguments[1].String()
 	ciphertext, err := base64.StdEncoding.DecodeString(ciphertextB64)
 	if err != nil {
 		return r.vm.ToValue(map[string]interface{}{
 			"success": false,
 			"error":   "invalid base64 ciphertext",
 		})
 	}
 	// Derive 32-byte key from provided key string
 	keyHash := sha256.Sum256([]byte(keyStr))
 	decrypted, err := decryptAES(ciphertext, keyHash[:])
 	if err != nil {
 		return r.vm.ToValue(map[string]interface{}{
 			"success": false,
 			"error":   err.Error(),
 		})
 	}
 	return r.vm.ToValue(map[string]interface{}{
 		"success": true,
 		"data":    string(decrypted),
 	})
 }
 // cryptoGenerateKey generates a random encryption key
 func (r *ExtensionRuntime) cryptoGenerateKey(call goja.FunctionCall) goja.Value {
 	length := 32 // Default 256-bit key
 	if len(call.Arguments) > 0 && !goja.IsUndefined(call.Arguments[0]) {
 		if l, ok := call.Arguments[0].Export().(float64); ok {
 			length = int(l)
 		}
 	}
 	key := make([]byte, length)
 	if _, err := rand.Read(key); err != nil {
 		return r.vm.ToValue(map[string]interface{}{
 			"success": false,
 			"error":   err.Error(),
 		})
 	}
 	return r.vm.ToValue(map[string]interface{}{
 		"success": true,
 		"key":     base64.StdEncoding.EncodeToString(key),
 		"hex":     hex.EncodeToString(key),
 	})
 }
 // randomUserAgent returns a random Chrome User-Agent string
 func (r *ExtensionRuntime) randomUserAgent(call goja.FunctionCall) goja.Value {
 	return r.vm.ToValue(getRandomUserAgent())
 }
 // ==================== Logging Functions ====================
 func (r *ExtensionRuntime) logDebug(call goja.FunctionCall) goja.Value {
 	msg := r.formatLogArgs(call.Arguments)
 	GoLog("[Extension:%s:DEBUG] %s\n", r.extensionID, msg)
 	return goja.Undefined()
 }
 func (r *ExtensionRuntime) logInfo(call goja.FunctionCall) goja.Value {
 	msg := r.formatLogArgs(call.Arguments)
 	GoLog("[Extension:%s:INFO] %s\n", r.extensionID, msg)
 	return goja.Undefined()
 }
 func (r *ExtensionRuntime) logWarn(call goja.FunctionCall) goja.Value {
 	msg := r.formatLogArgs(call.Arguments)
 	GoLog("[Extension:%s:WARN] %s\n", r.extensionID, msg)
 	return goja.Undefined()
 }
 func (r *ExtensionRuntime) logError(call goja.FunctionCall) goja.Value {
 	msg := r.formatLogArgs(call.Arguments)
 	GoLog("[Extension:%s:ERROR] %s\n", r.extensionID, msg)
 	return goja.Undefined()
 }
 func (r *ExtensionRuntime) formatLogArgs(args []goja.Value) string {
 	parts := make([]string, len(args))
 	for i, arg := range args {
 		parts[i] = fmt.Sprintf("%v", arg.Export())
 	}
 	return strings.Join(parts, " ")
 }
 // ==================== Go Backend Wrappers ====================
 func (r *ExtensionRuntime) sanitizeFilenameWrapper(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 1 {
 		return r.vm.ToValue("")
 	}
 	input := call.Arguments[0].String()
 	return r.vm.ToValue(sanitizeFilename(input))
 }
 // RegisterGoBackendAPIs adds more Go backend functions to the VM
 func (r *ExtensionRuntime) RegisterGoBackendAPIs(vm *goja.Runtime) {
 	gobackendObj := vm.Get("gobackend")
 	if gobackendObj == nil || goja.IsUndefined(gobackendObj) {
 		gobackendObj = vm.NewObject()
 		vm.Set("gobackend", gobackendObj)
 	}
 	obj := gobackendObj.(*goja.Object)
 	// Expose sanitizeFilename
 	obj.Set("sanitizeFilename", func(call goja.FunctionCall) goja.Value {
 		if len(call.Arguments) < 1 {
 			return vm.ToValue("")
 		}
 		return vm.ToValue(sanitizeFilename(call.Arguments[0].String()))
 	})
 	// Expose getAudioQuality
 	obj.Set("getAudioQuality", func(call goja.FunctionCall) goja.Value {
 		if len(call.Arguments) < 1 {
 			return vm.ToValue(map[string]interface{}{
 				"error": "file path is required",
 			})
 		}
 		filePath := call.Arguments[0].String()
 		quality, err := GetAudioQuality(filePath)
 		if err != nil {
 			return vm.ToValue(map[string]interface{}{
 				"error": err.Error(),
 			})
 		}
 		return vm.ToValue(map[string]interface{}{
 			"bitDepth":     quality.BitDepth,
 			"sampleRate":   quality.SampleRate,
 			"totalSamples": quality.TotalSamples,
 		})
 	})
 	// Expose buildFilename
 	obj.Set("buildFilename", func(call goja.FunctionCall) goja.Value {
 		if len(call.Arguments) < 2 {
 			return vm.ToValue("")
 		}
 		template := call.Arguments[0].String()
 		metadataObj := call.Arguments[1].Export()
 		metadata, ok := metadataObj.(map[string]interface{})
 		if !ok {
 			return vm.ToValue("")
 		}
 		return vm.ToValue(buildFilenameFromTemplate(template, metadata))
 	})
 	// Expose getLocalTime - returns device local time info
 	obj.Set("getLocalTime", func(call goja.FunctionCall) goja.Value {
 		now := time.Now()
 		_, offsetSeconds := now.Zone()
 		offsetMinutes := offsetSeconds / 60
 		return vm.ToValue(map[string]interface{}{
 			"year":          now.Year(),
 			"month":         int(now.Month()),
 			"day":           now.Day(),
 			"hour":          now.Hour(),
 			"minute":        now.Minute(),
 			"second":        now.Second(),
 			"weekday":       int(now.Weekday()),
 			"offsetMinutes": -offsetMinutes, // JS convention: negative for east of UTC
 			"timezone":      now.Location().String(),
 			"timestamp":     now.Unix(),
 		})
 	})
 }
@@ -0,0 +1,217 @@
 // 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)
 	}
 	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)
 	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
 	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)
 	settingsPath := s.getSettingsPath(extensionID)
 	if err := os.Remove(settingsPath); err != nil && !os.IsNotExist(err) {
 		return err
 	}
 	return nil
 }
 // GetAllExtensionSettings returns settings for all extensions as JSON
 func (s *ExtensionSettingsStore) GetAllExtensionSettingsJSON() (string, error) {
 	s.mu.RLock()
 	defer s.mu.RUnlock()
 	data, err := json.Marshal(s.settings)
 	if err != nil {
 		return "", err
 	}
 	return string(data), nil
 }
@@ -0,0 +1,451 @@
 package gobackend
 import (
 	"encoding/json"
 	"fmt"
 	"io"
 	"net/http"
 	"os"
 	"path/filepath"
 	"sync"
 	"time"
 )
 // Extension categories
 const (
 	CategoryMetadata    = "metadata"
 	CategoryDownload    = "download"
 	CategoryUtility     = "utility"
 	CategoryLyrics      = "lyrics"
 	CategoryIntegration = "integration"
 )
 // StoreExtension represents an extension in the store
 type StoreExtension struct {
 	ID            string   `json:"id"`
 	Name          string   `json:"name"`
 	DisplayName   string   `json:"display_name,omitempty"`
 	Version       string   `json:"version"`
 	Author        string   `json:"author"`
 	Description   string   `json:"description"`
 	DownloadURL   string   `json:"download_url,omitempty"`
 	IconURL       string   `json:"icon_url,omitempty"`
 	Category      string   `json:"category"`
 	Tags          []string `json:"tags,omitempty"`
 	Downloads     int      `json:"downloads"`
 	UpdatedAt     string   `json:"updated_at"`
 	MinAppVersion string   `json:"min_app_version,omitempty"`
 	DisplayNameAlt   string `json:"displayName,omitempty"`
 	DownloadURLAlt   string `json:"downloadUrl,omitempty"`
 	IconURLAlt       string `json:"iconUrl,omitempty"`
 	MinAppVersionAlt string `json:"minAppVersion,omitempty"`
 }
 // getDisplayName returns display name, falling back to name (private to avoid gomobile conflict)
 func (e *StoreExtension) getDisplayName() string {
 	if e.DisplayName != "" {
 		return e.DisplayName
 	}
 	if e.DisplayNameAlt != "" {
 		return e.DisplayNameAlt
 	}
 	return e.Name
 }
 // getDownloadURL returns download URL from either field (private to avoid gomobile conflict)
 func (e *StoreExtension) getDownloadURL() string {
 	if e.DownloadURL != "" {
 		return e.DownloadURL
 	}
 	return e.DownloadURLAlt
 }
 // getIconURL returns icon URL from either field (private to avoid gomobile conflict)
 func (e *StoreExtension) getIconURL() string {
 	if e.IconURL != "" {
 		return e.IconURL
 	}
 	return e.IconURLAlt
 }
 // getMinAppVersion returns min app version from either field (private to avoid gomobile conflict)
 func (e *StoreExtension) getMinAppVersion() string {
 	if e.MinAppVersion != "" {
 		return e.MinAppVersion
 	}
 	return e.MinAppVersionAlt
 }
 // StoreRegistry represents the extension registry
 type StoreRegistry struct {
 	Version    int              `json:"version"`
 	UpdatedAt  string           `json:"updated_at"`
 	Extensions []StoreExtension `json:"extensions"`
 }
 // StoreExtensionResponse is the normalized response sent to Flutter
 type StoreExtensionResponse 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"`
 	DownloadURL      string   `json:"download_url"`
 	IconURL          string   `json:"icon_url,omitempty"`
 	Category         string   `json:"category"`
 	Tags             []string `json:"tags,omitempty"`
 	Downloads        int      `json:"downloads"`
 	UpdatedAt        string   `json:"updated_at"`
 	MinAppVersion    string   `json:"min_app_version,omitempty"`
 	IsInstalled      bool     `json:"is_installed"`
 	InstalledVersion string   `json:"installed_version,omitempty"`
 	HasUpdate        bool     `json:"has_update"`
 }
 // ToResponse converts StoreExtension to normalized response
 func (e *StoreExtension) ToResponse() StoreExtensionResponse {
 	return StoreExtensionResponse{
 		ID:            e.ID,
 		Name:          e.Name,
 		DisplayName:   e.getDisplayName(),
 		Version:       e.Version,
 		Author:        e.Author,
 		Description:   e.Description,
 		DownloadURL:   e.getDownloadURL(),
 		IconURL:       e.getIconURL(),
 		Category:      e.Category,
 		Tags:          e.Tags,
 		Downloads:     e.Downloads,
 		UpdatedAt:     e.UpdatedAt,
 		MinAppVersion: e.getMinAppVersion(),
 	}
 }
 // ExtensionStore manages the extension store
 type ExtensionStore struct {
 	registryURL string
 	cacheDir    string
 	cache       *StoreRegistry
 	cacheMu     sync.RWMutex
 	cacheTime   time.Time
 	cacheTTL    time.Duration
 }
 var (
 	extensionStore   *ExtensionStore
 	extensionStoreMu sync.Mutex
 )
 const (
 	defaultRegistryURL = "https://raw.githubusercontent.com/zarzet/SpotiFLAC-Extension/main/registry.json"
 	cacheTTL           = 30 * time.Minute
 	cacheFileName      = "store_cache.json"
 )
 // InitExtensionStore initializes the extension store
 func InitExtensionStore(cacheDir string) *ExtensionStore {
 	extensionStoreMu.Lock()
 	defer extensionStoreMu.Unlock()
 	if extensionStore == nil {
 		extensionStore = &ExtensionStore{
 			registryURL: defaultRegistryURL,
 			cacheDir:    cacheDir,
 			cacheTTL:    cacheTTL,
 		}
 		// Try to load from disk cache
 		extensionStore.loadDiskCache()
 	}
 	return extensionStore
 }
 // GetExtensionStore returns the singleton store instance
 func GetExtensionStore() *ExtensionStore {
 	extensionStoreMu.Lock()
 	defer extensionStoreMu.Unlock()
 	return extensionStore
 }
 // loadDiskCache loads cached registry from disk
 func (s *ExtensionStore) loadDiskCache() {
 	if s.cacheDir == "" {
 		return
 	}
 	cachePath := filepath.Join(s.cacheDir, cacheFileName)
 	data, err := os.ReadFile(cachePath)
 	if err != nil {
 		return
 	}
 	var cacheData struct {
 		Registry  StoreRegistry `json:"registry"`
 		CacheTime int64         `json:"cache_time"`
 	}
 	if err := json.Unmarshal(data, &cacheData); err != nil {
 		return
 	}
 	s.cache = &cacheData.Registry
 	s.cacheTime = time.Unix(cacheData.CacheTime, 0)
 	LogDebug("ExtensionStore", "Loaded %d extensions from disk cache", len(s.cache.Extensions))
 }
 // saveDiskCache saves registry to disk cache
 func (s *ExtensionStore) saveDiskCache() {
 	if s.cacheDir == "" || s.cache == nil {
 		return
 	}
 	cacheData := struct {
 		Registry  StoreRegistry `json:"registry"`
 		CacheTime int64         `json:"cache_time"`
 	}{
 		Registry:  *s.cache,
 		CacheTime: s.cacheTime.Unix(),
 	}
 	data, err := json.Marshal(cacheData)
 	if err != nil {
 		return
 	}
 	cachePath := filepath.Join(s.cacheDir, cacheFileName)
 	os.WriteFile(cachePath, data, 0644)
 }
 // FetchRegistry fetches the extension registry from GitHub
 func (s *ExtensionStore) FetchRegistry(forceRefresh bool) (*StoreRegistry, error) {
 	s.cacheMu.Lock()
 	defer s.cacheMu.Unlock()
 	// Return cached if valid and not forcing refresh
 	if !forceRefresh && s.cache != nil && time.Since(s.cacheTime) < s.cacheTTL {
 		LogDebug("ExtensionStore", "Using cached registry (%d extensions)", len(s.cache.Extensions))
 		return s.cache, nil
 	}
 	LogInfo("ExtensionStore", "Fetching registry from %s", s.registryURL)
 	client := &http.Client{Timeout: 30 * time.Second}
 	resp, err := client.Get(s.registryURL)
 	if err != nil {
 		// Return cached data if available on network error
 		if s.cache != nil {
 			LogWarn("ExtensionStore", "Network error, using cached registry: %v", err)
 			return s.cache, nil
 		}
 		return nil, fmt.Errorf("failed to fetch registry: %w", err)
 	}
 	defer resp.Body.Close()
 	if resp.StatusCode != http.StatusOK {
 		if s.cache != nil {
 			LogWarn("ExtensionStore", "HTTP %d, using cached registry", resp.StatusCode)
 			return s.cache, nil
 		}
 		return nil, fmt.Errorf("registry returned HTTP %d", resp.StatusCode)
 	}
 	body, err := io.ReadAll(resp.Body)
 	if err != nil {
 		return nil, fmt.Errorf("failed to read registry: %w", err)
 	}
 	var registry StoreRegistry
 	if err := json.Unmarshal(body, &registry); err != nil {
 		return nil, fmt.Errorf("failed to parse registry: %w", err)
 	}
 	s.cache = &registry
 	s.cacheTime = time.Now()
 	s.saveDiskCache()
 	LogInfo("ExtensionStore", "Fetched %d extensions from registry", len(registry.Extensions))
 	return &registry, nil
 }
 // GetExtensionsWithStatus returns extensions with installation status
 func (s *ExtensionStore) GetExtensionsWithStatus() ([]StoreExtensionResponse, error) {
 	registry, err := s.FetchRegistry(false)
 	if err != nil {
 		return nil, err
 	}
 	manager := GetExtensionManager()
 	installed := make(map[string]string) // id -> version
 	if manager != nil {
 		for _, ext := range manager.GetAllExtensions() {
 			installed[ext.ID] = ext.Manifest.Version
 		}
 	}
 	result := make([]StoreExtensionResponse, len(registry.Extensions))
 	for i, ext := range registry.Extensions {
 		resp := ext.ToResponse()
 		if installedVersion, ok := installed[ext.ID]; ok {
 			resp.IsInstalled = true
 			resp.InstalledVersion = installedVersion
 			resp.HasUpdate = compareVersions(ext.Version, installedVersion) > 0
 		}
 		result[i] = resp
 	}
 	return result, nil
 }
 // DownloadExtension downloads an extension package to the specified path
 func (s *ExtensionStore) DownloadExtension(extensionID string, destPath string) error {
 	registry, err := s.FetchRegistry(false)
 	if err != nil {
 		return err
 	}
 	var ext *StoreExtension
 	for _, e := range registry.Extensions {
 		if e.ID == extensionID {
 			ext = &e
 			break
 		}
 	}
 	if ext == nil {
 		return fmt.Errorf("extension %s not found in store", extensionID)
 	}
 	LogInfo("ExtensionStore", "Downloading %s from %s", ext.getDisplayName(), ext.getDownloadURL())
 	client := &http.Client{Timeout: 5 * time.Minute}
 	resp, err := client.Get(ext.getDownloadURL())
 	if err != nil {
 		return fmt.Errorf("failed to download: %w", err)
 	}
 	defer resp.Body.Close()
 	if resp.StatusCode != http.StatusOK {
 		return fmt.Errorf("download returned HTTP %d", resp.StatusCode)
 	}
 	out, err := os.Create(destPath)
 	if err != nil {
 		return fmt.Errorf("failed to create file: %w", err)
 	}
 	defer out.Close()
 	_, err = io.Copy(out, resp.Body)
 	if err != nil {
 		os.Remove(destPath)
 		return fmt.Errorf("failed to write file: %w", err)
 	}
 	LogInfo("ExtensionStore", "Downloaded %s to %s", ext.getDisplayName(), destPath)
 	return nil
 }
 // GetCategories returns all available categories
 func (s *ExtensionStore) GetCategories() []string {
 	return []string{
 		CategoryMetadata,
 		CategoryDownload,
 		CategoryUtility,
 		CategoryLyrics,
 		CategoryIntegration,
 	}
 }
 // SearchExtensions searches extensions by query
 func (s *ExtensionStore) SearchExtensions(query string, category string) ([]StoreExtensionResponse, error) {
 	extensions, err := s.GetExtensionsWithStatus()
 	if err != nil {
 		return nil, err
 	}
 	if query == "" && category == "" {
 		return extensions, nil
 	}
 	var result []StoreExtensionResponse
 	queryLower := toLower(query)
 	for _, ext := range extensions {
 		// Filter by category
 		if category != "" && ext.Category != category {
 			continue
 		}
 		// Filter by query
 		if query != "" {
 			if !containsIgnoreCase(ext.Name, queryLower) &&
 				!containsIgnoreCase(ext.DisplayName, queryLower) &&
 				!containsIgnoreCase(ext.Description, queryLower) &&
 				!containsIgnoreCase(ext.Author, queryLower) {
 				// Check tags
 				found := false
 				for _, tag := range ext.Tags {
 					if containsIgnoreCase(tag, queryLower) {
 						found = true
 						break
 					}
 				}
 				if !found {
 					continue
 				}
 			}
 		}
 		result = append(result, ext)
 	}
 	return result, nil
 }
 // ClearCache clears the in-memory and disk cache
 func (s *ExtensionStore) ClearCache() {
 	s.cacheMu.Lock()
 	defer s.cacheMu.Unlock()
 	s.cache = nil
 	s.cacheTime = time.Time{}
 	if s.cacheDir != "" {
 		cachePath := filepath.Join(s.cacheDir, cacheFileName)
 		os.Remove(cachePath)
 	}
 	LogInfo("ExtensionStore", "Cache cleared")
 }
 // Helper: case-insensitive contains
 func containsIgnoreCase(s, substr string) bool {
 	return containsStr(toLower(s), substr)
 }
 func toLower(s string) string {
 	result := make([]byte, len(s))
 	for i := 0; i < len(s); i++ {
 		c := s[i]
 		if c >= 'A' && c <= 'Z' {
 			c += 'a' - 'A'
 		}
 		result[i] = c
 	}
 	return string(result)
 }
 func containsStr(s, substr string) bool {
 	return len(substr) == 0 || (len(s) >= len(substr) && findSubstring(s, substr) >= 0)
 }
 func findSubstring(s, substr string) int {
 	for i := 0; i <= len(s)-len(substr); i++ {
 		if s[i:i+len(substr)] == substr {
 			return i
 		}
 	}
 	return -1
 }
@@ -0,0 +1,329 @@
 package gobackend
 import (
 	"path/filepath"
 	"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",
 			Permissions: ExtensionPermissions{
 				File: true, // Enable file permission for test
 			},
 		},
 		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")
 	}
 	// Test absolute path should be blocked (security fix)
 	// Use platform-appropriate absolute path
 	var absPath string
 	if filepath.IsAbs("C:\\Windows\\System32") {
 		absPath = "C:\\Windows\\System32\\test.txt" // Windows
 	} else {
 		absPath = "/etc/passwd" // Unix
 	}
 	_, err = runtime.validatePath(absPath)
 	if err == nil {
 		t.Error("Expected absolute path to be blocked")
 	}
 	// Test that extension without file permission is blocked
 	extNoFile := &LoadedExtension{
 		ID: "test-ext-no-file",
 		Manifest: &ExtensionManifest{
 			Name: "test-ext-no-file",
 			Permissions: ExtensionPermissions{
 				File: false, // No file permission
 			},
 		},
 		DataDir: tempDir,
 	}
 	runtimeNoFile := NewExtensionRuntime(extNoFile)
 	_, err = runtimeNoFile.validatePath("test.txt")
 	if err == nil {
 		t.Error("Expected file access to be denied without file permission")
 	}
 }
 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")
 	}
 }
 func TestExtensionRuntime_SSRFProtection(t *testing.T) {
 	// Create extension with limited network permissions
 	ext := &LoadedExtension{
 		ID: "test-ext",
 		Manifest: &ExtensionManifest{
 			Name: "test-ext",
 			Permissions: ExtensionPermissions{
 				Network: []string{"api.example.com"},
 			},
 		},
 		DataDir: t.TempDir(),
 	}
 	runtime := NewExtensionRuntime(ext)
 	// Test that private IPs are blocked (SSRF protection)
 	privateIPs := []string{
 		"http://localhost/admin",
 		"http://127.0.0.1/admin",
 		"http://192.168.1.1/admin",
 		"http://10.0.0.1/admin",
 		"http://172.16.0.1/admin",
 		"http://169.254.169.254/latest/meta-data/", // AWS metadata
 		"http://router.local/admin",
 	}
 	for _, url := range privateIPs {
 		err := runtime.validateDomain(url)
 		if err == nil {
 			t.Errorf("Expected private IP/host '%s' to be blocked", url)
 		}
 	}
 	// Test that allowed public domain still works
 	if err := runtime.validateDomain("https://api.example.com/path"); err != nil {
 		t.Errorf("Expected api.example.com to be allowed, got error: %v", err)
 	}
 }
 func TestIsPrivateIP(t *testing.T) {
 	tests := []struct {
 		host     string
 		expected bool
 	}{
 		// Private IPs should be blocked
 		{"localhost", true},
 		{"127.0.0.1", true},
 		{"127.0.0.2", true},
 		{"10.0.0.1", true},
 		{"10.255.255.255", true},
 		{"172.16.0.1", true},
 		{"172.31.255.255", true},
 		{"192.168.0.1", true},
 		{"192.168.255.255", true},
 		{"169.254.169.254", true}, // AWS metadata
 		{"router.local", true},
 		{"mydevice.local", true},
 		// Public IPs should be allowed
 		{"8.8.8.8", false},
 		{"1.1.1.1", false},
 		{"api.example.com", false},
 		{"google.com", false},
 		{"172.15.0.1", false},  // Just outside 172.16-31 range
 		{"172.32.0.1", false},  // Just outside 172.16-31 range
 		{"192.167.0.1", false}, // Not 192.168.x.x
 	}
 	for _, tt := range tests {
 		result := isPrivateIP(tt.host)
 		if result != tt.expected {
 			t.Errorf("isPrivateIP(%s) = %v, expected %v", tt.host, result, tt.expected)
 		}
 	}
 }
@@ -0,0 +1,118 @@
 // Package gobackend provides timeout execution for extension JS code
 package gobackend
 import (
 	"context"
 	"fmt"
 	"sync"
 	"time"
 	"github.com/dop251/goja"
 )
 // JSExecutionError represents an error during JS execution
 type JSExecutionError struct {
 	Message   string
 	IsTimeout bool
 }
 func (e *JSExecutionError) Error() string {
 	return e.Message
 }
 // RunWithTimeout executes JavaScript code with a timeout
 // Returns the result value and any error (including timeout)
 func RunWithTimeout(vm *goja.Runtime, script string, timeout time.Duration) (goja.Value, error) {
 	if timeout <= 0 {
 		timeout = DefaultJSTimeout
 	}
 	ctx, cancel := context.WithTimeout(context.Background(), timeout)
 	defer cancel()
 	// Channel to receive result
 	type result struct {
 		value goja.Value
 		err   error
 	}
 	resultCh := make(chan result, 1)
 	// Track if we've interrupted
 	var interrupted bool
 	var interruptMu sync.Mutex
 	// Run script in goroutine
 	go func() {
 		defer func() {
 			if r := recover(); r != nil {
 				// Check if this was our interrupt
 				interruptMu.Lock()
 				wasInterrupted := interrupted
 				interruptMu.Unlock()
 				if wasInterrupted {
 					resultCh <- result{nil, &JSExecutionError{
 						Message:   "execution timeout exceeded",
 						IsTimeout: true,
 					}}
 				} else {
 					resultCh <- result{nil, fmt.Errorf("panic during execution: %v", r)}
 				}
 			}
 		}()
 		val, err := vm.RunString(script)
 		resultCh <- result{val, err}
 	}()
 	// Wait for result or timeout
 	select {
 	case res := <-resultCh:
 		return res.value, res.err
 	case <-ctx.Done():
 		// Timeout - interrupt the VM
 		interruptMu.Lock()
 		interrupted = true
 		interruptMu.Unlock()
 		vm.Interrupt("execution timeout")
 		// Wait a bit for the goroutine to finish
 		select {
 		case res := <-resultCh:
 			// If we got a result after interrupt, it might be the timeout error
 			if res.err != nil {
 				return nil, res.err
 			}
 			return nil, &JSExecutionError{
 				Message:   "execution timeout exceeded",
 				IsTimeout: true,
 			}
 		case <-time.After(1 * time.Second):
 			// Force return timeout error
 			return nil, &JSExecutionError{
 				Message:   "execution timeout exceeded (force)",
 				IsTimeout: true,
 			}
 		}
 	}
 }
 // RunWithTimeoutAndRecover runs JS with timeout and clears interrupt state after
 // This should be used when you want to continue using the VM after a timeout
 func RunWithTimeoutAndRecover(vm *goja.Runtime, script string, timeout time.Duration) (goja.Value, error) {
 	result, err := RunWithTimeout(vm, script, timeout)
 	// Clear any interrupt state so VM can be reused
 	vm.ClearInterrupt()
 	return result, err
 }
 // IsTimeoutError checks if an error is a timeout error
 func IsTimeoutError(err error) bool {
 	if jsErr, ok := err.(*JSExecutionError); ok {
 		return jsErr.IsTimeout
 	}
 	return false
 }
@@ -6,28 +6,21 @@ import (
 	"strings"
 )
 // Invalid filename characters for Android/Windows/Linux
 var invalidChars = regexp.MustCompile(`[<>:"/\\|?*\x00-\x1f]`)
 // sanitizeFilename removes invalid characters from filename
 func sanitizeFilename(filename string) string {
 	// Replace invalid characters with underscore
 	sanitized := invalidChars.ReplaceAllString(filename, "_")
 	// Remove leading/trailing spaces and dots
 	sanitized = strings.TrimSpace(sanitized)
 	sanitized = strings.Trim(sanitized, ".")
 	// Collapse multiple underscores
 	multiUnderscore := regexp.MustCompile(`_+`)
 	sanitized = multiUnderscore.ReplaceAllString(sanitized, "_")
 	// Limit length (Android has 255 byte limit for filenames)
 	if len(sanitized) > 200 {
 		sanitized = sanitized[:200]
 	}
 	// Ensure not empty
 	if sanitized == "" {
 		sanitized = "untitled"
 	}
@@ -35,7 +28,6 @@ func sanitizeFilename(filename string) string {
 	return sanitized
 }
 // buildFilenameFromTemplate builds a filename from template and metadata
 func buildFilenameFromTemplate(template string, metadata map[string]interface{}) string {
 	if template == "" {
 		template = "{artist} - {title}"
@@ -43,7 +35,6 @@ func buildFilenameFromTemplate(template string, metadata map[string]interface{})
 	result := template
 	// Replace placeholders
 	placeholders := map[string]string{
 		"{title}":  getString(metadata, "title"),
 		"{artist}": getString(metadata, "artist"),
@@ -63,7 +54,6 @@ func buildFilenameFromTemplate(template string, metadata map[string]interface{})
 func getString(m map[string]interface{}, key string) string {
 	if v, ok := m[key]; ok {
 		if s, ok := v.(string); ok {
 			// Trim leading/trailing whitespace to prevent filename issues
 			return strings.TrimSpace(s)
 		}
 	}
@@ -98,7 +88,6 @@ func formatDiscNumber(n int) string {
 	return fmt.Sprintf("%d", n)
 }
 // extractYear extracts year from date string (YYYY-MM-DD or YYYY)
 func extractYear(date string) string {
 	if len(date) >= 4 {
 		return date[:4]
@@ -5,14 +5,19 @@ go 1.24.0
 toolchain go1.24.5
 require (
 	github.com/dop251/goja v0.0.0-20260106131823-651366fbe6e3
 	github.com/go-flac/flacpicture v0.3.0
 	github.com/go-flac/flacvorbis v0.2.0
 	github.com/go-flac/go-flac v1.0.0
 )
 require (
 	github.com/dlclark/regexp2 v1.11.4 // indirect
 	github.com/go-sourcemap/sourcemap v2.1.3+incompatible // indirect
 	github.com/google/pprof v0.0.0-20230207041349-798e818bf904 // indirect
 	golang.org/x/mobile v0.0.0-20251209145715-2553ed8ce294 // indirect
 	golang.org/x/mod v0.31.0 // indirect
 	golang.org/x/sync v0.19.0 // indirect
 	golang.org/x/text v0.3.8 // indirect
 	golang.org/x/tools v0.40.0 // indirect
 )
@@ -1,14 +1,28 @@
 github.com/Masterminds/semver/v3 v3.2.1 h1:RN9w6+7QoMeJVGyfmbcgs28Br8cvmnucEXnY0rYXWg0=
 github.com/Masterminds/semver/v3 v3.2.1/go.mod h1:qvl/7zhW3nngYb5+80sSMF+FG2BjYrf8m9wsX0PNOMQ=
 github.com/dlclark/regexp2 v1.11.4 h1:rPYF9/LECdNymJufQKmri9gV604RvvABwgOA8un7yAo=
 github.com/dlclark/regexp2 v1.11.4/go.mod h1:DHkYz0B9wPfa6wondMfaivmHpzrQ3v9q8cnmRbL6yW8=
 github.com/dop251/goja v0.0.0-20260106131823-651366fbe6e3 h1:bVp3yUzvSAJzu9GqID+Z96P+eu5TKnIMJSV4QaZMauM=
 github.com/dop251/goja v0.0.0-20260106131823-651366fbe6e3/go.mod h1:MxLav0peU43GgvwVgNbLAj1s/bSGboKkhuULvq/7hx4=
 github.com/go-flac/flacpicture v0.3.0 h1:LkmTxzFLIynwfhHiZsX0s8xcr3/u33MzvV89u+zOT8I=
 github.com/go-flac/flacpicture v0.3.0/go.mod h1:DPbrzVYQ3fJcvSgLFp9HXIrEQEdfdk/+m0nQCzwodZI=
 github.com/go-flac/flacvorbis v0.2.0 h1:KH0xjpkNTXFER4cszH4zeJxYcrHbUobz/RticWGOESs=
 github.com/go-flac/flacvorbis v0.2.0/go.mod h1:uIysHOtuU7OLGoCRG92bvnkg7QEqHx19qKRV6K1pBrI=
 github.com/go-flac/go-flac v1.0.0 h1:6qI9XOVLcO50xpzm3nXvO31BgDgHhnr/p/rER/K/doY=
 github.com/go-flac/go-flac v1.0.0/go.mod h1:WnZhcpmq4u1UdZMNn9LYSoASpWOCMOoxXxcWEHSzkW8=
 github.com/go-sourcemap/sourcemap v2.1.3+incompatible h1:W1iEw64niKVGogNgBN3ePyLFfuisuzeidWPMPWmECqU=
 github.com/go-sourcemap/sourcemap v2.1.3+incompatible/go.mod h1:F8jJfvm2KbVjc5NqelyYJmf/v5J0dwNLS2mL4sNA1Jg=
 github.com/google/pprof v0.0.0-20230207041349-798e818bf904 h1:4/hN5RUoecvl+RmJRE2YxKWtnnQls6rQjjW5oV7qg2U=
 github.com/google/pprof v0.0.0-20230207041349-798e818bf904/go.mod h1:uglQLonpP8qtYCYyzA+8c/9qtqgA3qsXGYqCPKARAFg=
 golang.org/x/mobile v0.0.0-20251209145715-2553ed8ce294 h1:Cr6kbEvA6nqvdHynE4CtVKlqpZB9dS1Jva/6IsHA19g=
 golang.org/x/mobile v0.0.0-20251209145715-2553ed8ce294/go.mod h1:RdZ+3sb4CVgpCFnzv+I4haEpwqFfsfzlLHs3L7ok+e0=
 golang.org/x/mod v0.31.0 h1:HaW9xtz0+kOcWKwli0ZXy79Ix+UW/vOfmWI5QVd2tgI=
 golang.org/x/mod v0.31.0/go.mod h1:43JraMp9cGx1Rx3AqioxrbrhNsLl2l/iNAvuBkrezpg=
 golang.org/x/sync v0.19.0 h1:vV+1eWNmZ5geRlYjzm2adRgW2/mcpevXNg50YZtPCE4=
 golang.org/x/sync v0.19.0/go.mod h1:9KTHXmSnoGruLpwFjVSX0lNNA75CykiMECbovNTZqGI=
 golang.org/x/text v0.3.8 h1:nAL+RVCQ9uMn3vJZbV+MRnydTJFPf8qqY42YiA6MrqY=
 golang.org/x/text v0.3.8/go.mod h1:E6s5w1FMmriuDzIBO73fBruAKo1PCIq6d2Q6DHfQ8WQ=
 golang.org/x/tools v0.40.0 h1:yLkxfA+Qnul4cs9QA3KnlFu0lVmd8JJfoq+E41uSutA=
 golang.org/x/tools v0.40.0/go.mod h1:Ik/tzLRlbscWpqqMRjyWYDisX8bG13FrdXp3o4Sr9lc=
 gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY=
 gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
@@ -1,45 +1,43 @@
 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
+// getRandomUserAgent generates a random Windows Chrome User-Agent string
-
+// Uses modern Chrome format with build and patch numbers
-// User-Agent pool for Android Chrome browsers
+// Windows 11 still reports as "Windows NT 10.0" for compatibility
 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)
 func getRandomUserAgent() string {
-	template := userAgentTemplates[rand.Intn(len(userAgentTemplates))]
+	// Chrome version 120-145 (modern range)
-
+	chromeVersion := rand.Intn(26) + 120
-	androidVersion := rand.Intn(5) + 10 // Android 10-14
+	chromeBuild := rand.Intn(1500) + 6000
 	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
-	return fmt.Sprintf(template, androidVersion, deviceModel, chromeVersion, chromeBuild, chromePatch)
+	return fmt.Sprintf(
 		"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/%d.0.%d.%d Safari/537.36",
 		chromeVersion,
 		chromeBuild,
 		chromePatch,
 	)
 }
 // Default timeout values
 const (
-	DefaultTimeout     = 60 * time.Second  // Default HTTP timeout
+	DefaultTimeout    = 60 * time.Second
-	DownloadTimeout    = 120 * time.Second // Timeout for file downloads
+	DownloadTimeout   = 120 * time.Second
-	SongLinkTimeout    = 30 * time.Second  // Timeout for SongLink API
+	SongLinkTimeout   = 30 * time.Second
-	DefaultMaxRetries  = 3                 // Default retry count
+	DefaultMaxRetries = 3
-	DefaultRetryDelay  = 1 * time.Second   // Initial retry delay
+	DefaultRetryDelay = 1 * time.Second
 )
 // Shared transport with connection pooling to prevent TCP exhaustion
@@ -54,24 +52,23 @@ var sharedTransport = &http.Transport{
 	IdleConnTimeout:       90 * time.Second,
 	TLSHandshakeTimeout:   10 * time.Second,
 	ExpectContinueTimeout: 1 * time.Second,
-	DisableKeepAlives:     false, // Enable keep-alives for connection reuse
+	DisableKeepAlives:     false,
 	ForceAttemptHTTP2:     true,
 	WriteBufferSize:       64 * 1024,
 	ReadBufferSize:        64 * 1024,
 	DisableCompression:    true,
 }
 // Shared HTTP client for general requests (reuses connections)
 var sharedClient = &http.Client{
 	Transport: sharedTransport,
 	Timeout:   DefaultTimeout,
 }
 // Shared HTTP client for downloads (longer timeout, reuses connections)
 var downloadClient = &http.Client{
 	Transport: sharedTransport,
 	Timeout:   DownloadTimeout,
 }
 // NewHTTPClientWithTimeout creates an HTTP client with specified timeout
 // Uses shared transport for connection reuse
 func NewHTTPClientWithTimeout(timeout time.Duration) *http.Client {
 	return &http.Client{
 		Transport: sharedTransport,
@@ -79,26 +76,27 @@ func NewHTTPClientWithTimeout(timeout time.Duration) *http.Client {
 	}
 }
 // GetSharedClient returns the shared HTTP client for general requests
 func GetSharedClient() *http.Client {
 	return sharedClient
 }
 // GetDownloadClient returns the shared HTTP client for downloads
 func GetDownloadClient() *http.Client {
 	return downloadClient
 }
 // CloseIdleConnections closes idle connections in the shared transport
 // Call this periodically during large batch downloads to prevent connection buildup
 func CloseIdleConnections() {
 	sharedTransport.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 {
 		CheckAndLogISPBlocking(err, req.URL.String(), "HTTP")
 	}
 	return resp, err
 }
 // RetryConfig holds configuration for retry logic
@@ -109,7 +107,6 @@ type RetryConfig struct {
 	BackoffFactor float64
 }
 // DefaultRetryConfig returns default retry configuration
 func DefaultRetryConfig() RetryConfig {
 	return RetryConfig{
 		MaxRetries:    DefaultMaxRetries,
@@ -121,9 +118,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)
@@ -133,7 +132,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)
 			}
@@ -154,17 +162,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)
 			}
@@ -178,16 +212,11 @@ func DoRequestWithRetry(client *http.Client, req *http.Request, config RetryConf
 	return nil, fmt.Errorf("request failed after %d retries: %w", config.MaxRetries+1, lastErr)
 }
 // 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 {
+	return min(nextDelay, config.MaxDelay)
 		nextDelay = config.MaxDelay
 	}
 	return nextDelay
 }
 // getRetryAfterDuration parses Retry-After header and returns duration
 // Returns 60 seconds as default if header is missing or invalid
 func getRetryAfterDuration(resp *http.Response) time.Duration {
 	retryAfter := resp.Header.Get("Retry-After")
@@ -230,7 +259,6 @@ func ReadResponseBody(resp *http.Response) ([]byte, error) {
 	return body, nil
 }
 // ValidateResponse checks if response is valid (non-nil, status 2xx)
 func ValidateResponse(resp *http.Response) error {
 	if resp == nil {
 		return fmt.Errorf("response is nil")
@@ -258,3 +286,169 @@ func BuildErrorMessage(apiURL string, statusCode int, responsePreview string) st
 	}
 	return msg
 }
 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
 }
 // 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"
 }
 // If ISP blocking is detected, returns a more descriptive error
 func WrapErrorWithISPCheck(err error, requestURL string, tag string) error {
 	if err == nil {
 		return nil
 	}
 	if CheckAndLogISPBlocking(err, requestURL, tag) {
 		domain := extractDomain(requestURL)
 		return fmt.Errorf("ISP blocking detected for %s - try using VPN or change DNS to 1.1.1.1/8.8.8.8: %w", domain, err)
 	}
 	return err
 }
@@ -0,0 +1,195 @@
 package gobackend
 import (
 	"encoding/json"
 	"fmt"
 	"strings"
 	"sync"
 	"time"
 )
 type LogEntry struct {
 	Timestamp string `json:"timestamp"`
 	Level     string `json:"level"`
 	Tag       string `json:"tag"`
 	Message   string `json:"message"`
 }
 type LogBuffer struct {
 	entries        []LogEntry
 	maxSize        int
 	mu             sync.RWMutex
 	loggingEnabled bool
 }
 var (
 	globalLogBuffer *LogBuffer
 	logBufferOnce   sync.Once
 )
 // GetLogBuffer returns the singleton log buffer instance
 func GetLogBuffer() *LogBuffer {
 	logBufferOnce.Do(func() {
 		globalLogBuffer = &LogBuffer{
 			entries:        make([]LogEntry, 0, 1000),
 			maxSize:        1000,
 			loggingEnabled: false, // Default: disabled for performance (user can enable in settings)
 		}
 	})
 	return globalLogBuffer
 }
 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
 }
 func (lb *LogBuffer) Add(level, tag, message string) {
 	lb.mu.Lock()
 	defer lb.mu.Unlock()
 	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 {
 		lb.entries = lb.entries[1:]
 	}
 	lb.entries = append(lb.entries, entry)
 	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)
 }
 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)
 }
@@ -3,14 +3,93 @@ package gobackend
 import (
 	"encoding/json"
 	"fmt"
 	"math"
 	"net/http"
 	"net/url"
 	"os"
 	"path/filepath"
 	"regexp"
 	"strconv"
 	"strings"
 	"sync"
 	"time"
 )
 const (
 	lyricsCacheTTL       = 24 * time.Hour
 	durationToleranceSec = 10.0
 )
 type lyricsCacheEntry struct {
 	response  *LyricsResponse
 	expiresAt time.Time
 }
 type lyricsCache struct {
 	mu    sync.RWMutex
 	cache map[string]*lyricsCacheEntry
 }
 var globalLyricsCache = &lyricsCache{
 	cache: make(map[string]*lyricsCacheEntry),
 }
 func (c *lyricsCache) generateKey(artist, track string, durationSec float64) string {
 	normalizedArtist := strings.ToLower(strings.TrimSpace(artist))
 	normalizedTrack := strings.ToLower(strings.TrimSpace(track))
 	roundedDuration := math.Round(durationSec/10) * 10
 	return fmt.Sprintf("%s|%s|%.0f", normalizedArtist, normalizedTrack, roundedDuration)
 }
 func (c *lyricsCache) Get(artist, track string, durationSec float64) (*LyricsResponse, bool) {
 	c.mu.RLock()
 	defer c.mu.RUnlock()
 	key := c.generateKey(artist, track, durationSec)
 	entry, exists := c.cache[key]
 	if !exists {
 		return nil, false
 	}
 	if time.Now().After(entry.expiresAt) {
 		return nil, false
 	}
 	return entry.response, true
 }
 func (c *lyricsCache) Set(artist, track string, durationSec float64, response *LyricsResponse) {
 	c.mu.Lock()
 	defer c.mu.Unlock()
 	key := c.generateKey(artist, track, durationSec)
 	c.cache[key] = &lyricsCacheEntry{
 		response:  response,
 		expiresAt: time.Now().Add(lyricsCacheTTL),
 	}
 }
 func (c *lyricsCache) CleanExpired() int {
 	c.mu.Lock()
 	defer c.mu.Unlock()
 	now := time.Now()
 	cleaned := 0
 	for key, entry := range c.cache {
 		if now.After(entry.expiresAt) {
 			delete(c.cache, key)
 			cleaned++
 		}
 	}
 	return cleaned
 }
 func (c *lyricsCache) Size() int {
 	c.mu.RLock()
 	defer c.mu.RUnlock()
 	return len(c.cache)
 }
 type LRCLibResponse struct {
 	ID           int     `json:"id"`
 	Name         string  `json:"name"`
@@ -44,9 +123,7 @@ type LyricsClient struct {
 func NewLyricsClient() *LyricsClient {
 	return &LyricsClient{
-		httpClient: &http.Client{
+		httpClient: NewHTTPClientWithTimeout(15 * time.Second),
 			Timeout: 15 * time.Second,
 		},
 	}
 }
@@ -86,7 +163,7 @@ func (c *LyricsClient) FetchLyricsWithMetadata(artist, track string) (*LyricsRes
 	return c.parseLRCLibResponse(&lrcResp), nil
 }
-func (c *LyricsClient) FetchLyricsFromLRCLibSearch(query string) (*LyricsResponse, error) {
+func (c *LyricsClient) FetchLyricsFromLRCLibSearch(query string, durationSec float64) (*LyricsResponse, error) {
 	baseURL := "https://lrclib.net/api/search"
 	params := url.Values{}
 	params.Set("q", query)
@@ -118,6 +195,11 @@ func (c *LyricsClient) FetchLyricsFromLRCLibSearch(query string) (*LyricsRespons
 		return nil, fmt.Errorf("no lyrics found")
 	}
 	bestMatch := c.findBestMatch(results, durationSec)
 	if bestMatch != nil {
 		return c.parseLRCLibResponse(bestMatch), nil
 	}
 	for _, result := range results {
 		if result.SyncedLyrics != "" {
 			return c.parseLRCLibResponse(&result), nil
@@ -127,38 +209,83 @@ func (c *LyricsClient) FetchLyricsFromLRCLibSearch(query string) (*LyricsRespons
 	return c.parseLRCLibResponse(&results[0]), nil
 }
-func (c *LyricsClient) FetchLyricsAllSources(spotifyID, trackName, artistName string) (*LyricsResponse, error) {
+func (c *LyricsClient) findBestMatch(results []LRCLibResponse, targetDurationSec float64) *LRCLibResponse {
-	// Strategy 1: Direct match with artist and track name
+	var bestSynced *LRCLibResponse
-	lyrics, err := c.FetchLyricsWithMetadata(artistName, trackName)
+	var bestPlain *LRCLibResponse
 	for i := range results {
 		result := &results[i]
 		durationMatches := targetDurationSec == 0 || c.durationMatches(result.Duration, targetDurationSec)
 		if durationMatches {
 			if result.SyncedLyrics != "" && bestSynced == nil {
 				bestSynced = result
 			} else if result.PlainLyrics != "" && bestPlain == nil {
 				bestPlain = result
 			}
 		}
 	}
 	if bestSynced != nil {
 		return bestSynced
 	}
 	return bestPlain
 }
 func (c *LyricsClient) durationMatches(lrcDuration, targetDuration float64) bool {
 	diff := math.Abs(lrcDuration - targetDuration)
 	return diff <= durationToleranceSec
 }
 // durationSec: track duration in seconds for matching, use 0 to skip duration matching
 func (c *LyricsClient) FetchLyricsAllSources(spotifyID, trackName, artistName string, durationSec float64) (*LyricsResponse, error) {
 	// Check cache first
 	if cached, found := globalLyricsCache.Get(artistName, trackName, durationSec); found {
 		fmt.Printf("[Lyrics] Cache hit for: %s - %s\n", artistName, trackName)
 		cachedCopy := *cached
 		cachedCopy.Source = cached.Source + " (cached)"
 		return &cachedCopy, nil
 	}
 	var lyrics *LyricsResponse
 	var err error
 	// Try exact match first
 	lyrics, err = c.FetchLyricsWithMetadata(artistName, trackName)
 	if err == nil && lyrics != nil && len(lyrics.Lines) > 0 {
 		lyrics.Source = "LRCLIB"
 		globalLyricsCache.Set(artistName, trackName, durationSec, lyrics)
 		return lyrics, nil
 	}
-	// Strategy 2: Try with simplified track name
+	// Try with simplified track name
 	simplifiedTrack := simplifyTrackName(trackName)
 	if simplifiedTrack != trackName {
 		lyrics, err = c.FetchLyricsWithMetadata(artistName, simplifiedTrack)
 		if err == nil && lyrics != nil && len(lyrics.Lines) > 0 {
 			lyrics.Source = "LRCLIB (simplified)"
 			globalLyricsCache.Set(artistName, trackName, durationSec, lyrics)
 			return lyrics, nil
 		}
 	}
-	// Strategy 3: Search with full query
+	// Search with duration matching
 	query := artistName + " " + trackName
-	lyrics, err = c.FetchLyricsFromLRCLibSearch(query)
+	lyrics, err = c.FetchLyricsFromLRCLibSearch(query, durationSec)
 	if err == nil && lyrics != nil && len(lyrics.Lines) > 0 {
 		lyrics.Source = "LRCLIB Search"
 		globalLyricsCache.Set(artistName, trackName, durationSec, lyrics)
 		return lyrics, nil
 	}
-	// Strategy 4: Search with simplified query
+	// Search with simplified name and duration matching
 	if simplifiedTrack != trackName {
 		query = artistName + " " + simplifiedTrack
-		lyrics, err = c.FetchLyricsFromLRCLibSearch(query)
+		lyrics, err = c.FetchLyricsFromLRCLibSearch(query, durationSec)
 		if err == nil && lyrics != nil && len(lyrics.Lines) > 0 {
 			lyrics.Source = "LRCLIB Search (simplified)"
 			globalLyricsCache.Set(artistName, trackName, durationSec, lyrics)
 			return lyrics, nil
 		}
 	}
@@ -248,15 +375,49 @@ func msToLRCTimestamp(ms int64) string {
 	return fmt.Sprintf("[%02d:%02d.%02d]", minutes, seconds, centiseconds)
 }
-func convertToLRC(lyrics *LyricsResponse) string {
+// Use convertToLRCWithMetadata for full LRC with headers
 // Kept for potential future use
 // func convertToLRC(lyrics *LyricsResponse) string {
 // 	if lyrics == nil || len(lyrics.Lines) == 0 {
 // 		return ""
 // 	}
 //
 // 	var builder strings.Builder
 //
 // 	if lyrics.SyncType == "LINE_SYNCED" {
 // 		for _, line := range lyrics.Lines {
 // 			timestamp := msToLRCTimestamp(line.StartTimeMs)
 // 			builder.WriteString(timestamp)
 // 			builder.WriteString(line.Words)
 // 			builder.WriteString("\n")
 // 		}
 // 	} else {
 // 		for _, line := range lyrics.Lines {
 // 			builder.WriteString(line.Words)
 // 			builder.WriteString("\n")
 // 		}
 // 	}
 //
 // 	return builder.String()
 // }
 func convertToLRCWithMetadata(lyrics *LyricsResponse, trackName, artistName string) string {
 	if lyrics == nil || len(lyrics.Lines) == 0 {
 		return ""
 	}
 	var builder strings.Builder
 	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")
 	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 +425,9 @@ func convertToLRC(lyrics *LyricsResponse) string {
 		}
 	} else {
 		for _, line := range lyrics.Lines {
 			if line.Words == "" {
 				continue
 			}
 			builder.WriteString(line.Words)
 			builder.WriteString("\n")
 		}
@@ -297,3 +461,22 @@ func simplifyTrackName(name string) string {
 	return strings.TrimSpace(result)
 }
 func SaveLRCFile(audioFilePath, lrcContent string) (string, error) {
 	if lrcContent == "" {
 		return "", fmt.Errorf("empty LRC content")
 	}
 	dir := filepath.Dir(audioFilePath)
 	ext := filepath.Ext(audioFilePath)
 	baseName := strings.TrimSuffix(filepath.Base(audioFilePath), ext)
 	lrcFilePath := filepath.Join(dir, baseName+".lrc")
 	if err := os.WriteFile(lrcFilePath, []byte(lrcContent), 0644); err != nil {
 		return "", fmt.Errorf("failed to write LRC file: %w", err)
 	}
 	GoLog("[Lyrics] Saved LRC file: %s\n", lrcFilePath)
 	return lrcFilePath, nil
 }
@@ -0,0 +1,248 @@
 package gobackend
 import (
 	"fmt"
 	"sync"
 	"time"
 )
 type TrackIDCacheEntry struct {
 	TidalTrackID  int64
 	QobuzTrackID  int64
 	AmazonTrackID string
 	ExpiresAt     time.Time
 }
 type TrackIDCache struct {
 	cache map[string]*TrackIDCacheEntry
 	mu    sync.RWMutex
 	ttl   time.Duration
 }
 var (
 	globalTrackIDCache *TrackIDCache
 	trackIDCacheOnce   sync.Once
 )
 func GetTrackIDCache() *TrackIDCache {
 	trackIDCacheOnce.Do(func() {
 		globalTrackIDCache = &TrackIDCache{
 			cache: make(map[string]*TrackIDCacheEntry),
 			ttl:   30 * time.Minute,
 		}
 	})
 	return globalTrackIDCache
 }
 func (c *TrackIDCache) Get(isrc string) *TrackIDCacheEntry {
 	c.mu.RLock()
 	defer c.mu.RUnlock()
 	entry, exists := c.cache[isrc]
 	if !exists || time.Now().After(entry.ExpiresAt) {
 		return nil
 	}
 	return entry
 }
 func (c *TrackIDCache) SetTidal(isrc string, trackID int64) {
 	c.mu.Lock()
 	defer c.mu.Unlock()
 	entry, exists := c.cache[isrc]
 	if !exists {
 		entry = &TrackIDCacheEntry{}
 		c.cache[isrc] = entry
 	}
 	entry.TidalTrackID = trackID
 	entry.ExpiresAt = time.Now().Add(c.ttl)
 }
 func (c *TrackIDCache) SetQobuz(isrc string, trackID int64) {
 	c.mu.Lock()
 	defer c.mu.Unlock()
 	entry, exists := c.cache[isrc]
 	if !exists {
 		entry = &TrackIDCacheEntry{}
 		c.cache[isrc] = entry
 	}
 	entry.QobuzTrackID = trackID
 	entry.ExpiresAt = time.Now().Add(c.ttl)
 }
 func (c *TrackIDCache) SetAmazon(isrc string, trackID string) {
 	c.mu.Lock()
 	defer c.mu.Unlock()
 	entry, exists := c.cache[isrc]
 	if !exists {
 		entry = &TrackIDCacheEntry{}
 		c.cache[isrc] = entry
 	}
 	entry.AmazonTrackID = trackID
 	entry.ExpiresAt = time.Now().Add(c.ttl)
 }
 func (c *TrackIDCache) Clear() {
 	c.mu.Lock()
 	defer c.mu.Unlock()
 	c.cache = make(map[string]*TrackIDCacheEntry)
 }
 func (c *TrackIDCache) Size() int {
 	c.mu.RLock()
 	defer c.mu.RUnlock()
 	return len(c.cache)
 }
 // ParallelDownloadResult holds results from parallel operations
 type ParallelDownloadResult struct {
 	CoverData  []byte
 	LyricsData *LyricsResponse
 	LyricsLRC  string
 	CoverErr   error
 	LyricsErr  error
 }
 func FetchCoverAndLyricsParallel(
 	coverURL string,
 	maxQualityCover bool,
 	spotifyID string,
 	trackName string,
 	artistName string,
 	embedLyrics bool,
 	durationMs int64,
 ) *ParallelDownloadResult {
 	result := &ParallelDownloadResult{}
 	var wg sync.WaitGroup
 	if coverURL != "" {
 		wg.Add(1)
 		go func() {
 			defer wg.Done()
 			fmt.Println("[Parallel] Starting cover download...")
 			data, err := downloadCoverToMemory(coverURL, maxQualityCover)
 			if err != nil {
 				result.CoverErr = err
 				fmt.Printf("[Parallel] Cover download failed: %v\n", err)
 			} else {
 				result.CoverData = data
 				fmt.Printf("[Parallel] Cover downloaded: %d bytes\n", len(data))
 			}
 		}()
 	}
 	if embedLyrics {
 		wg.Add(1)
 		go func() {
 			defer wg.Done()
 			fmt.Println("[Parallel] Starting lyrics fetch...")
 			client := NewLyricsClient()
 			durationSec := float64(durationMs) / 1000.0
 			lyrics, err := client.FetchLyricsAllSources(spotifyID, trackName, artistName, durationSec)
 			if err != nil {
 				result.LyricsErr = err
 				fmt.Printf("[Parallel] Lyrics fetch failed: %v\n", err)
 			} else if lyrics != nil && len(lyrics.Lines) > 0 {
 				result.LyricsData = lyrics
 				result.LyricsLRC = convertToLRCWithMetadata(lyrics, trackName, artistName)
 				fmt.Printf("[Parallel] Lyrics fetched: %d lines\n", len(lyrics.Lines))
 			} else {
 				result.LyricsErr = fmt.Errorf("no lyrics found")
 				fmt.Println("[Parallel] No lyrics found")
 			}
 		}()
 	}
 	wg.Wait()
 	return result
 }
 type PreWarmCacheRequest struct {
 	ISRC       string
 	TrackName  string
 	ArtistName string
 	SpotifyID  string // Needed for Amazon (SongLink lookup)
 	Service    string // "tidal", "qobuz", "amazon"
 }
 func PreWarmTrackCache(requests []PreWarmCacheRequest) {
 	if len(requests) == 0 {
 		return
 	}
 	fmt.Printf("[Cache] Pre-warming cache for %d tracks...\n", len(requests))
 	cache := GetTrackIDCache()
 	semaphore := make(chan struct{}, 3)
 	var wg sync.WaitGroup
 	for _, req := range requests {
 		if cached := cache.Get(req.ISRC); cached != nil {
 			continue
 		}
 		wg.Add(1)
 		go func(r PreWarmCacheRequest) {
 			defer wg.Done()
 			semaphore <- struct{}{}
 			defer func() { <-semaphore }()
 			switch r.Service {
 			case "tidal":
 				preWarmTidalCache(r.ISRC, r.TrackName, r.ArtistName)
 			case "qobuz":
 				preWarmQobuzCache(r.ISRC)
 			case "amazon":
 				preWarmAmazonCache(r.ISRC, r.SpotifyID)
 			}
 		}(req)
 	}
 	wg.Wait()
 	fmt.Printf("[Cache] Pre-warm complete. Cache size: %d\n", cache.Size())
 }
 func preWarmTidalCache(isrc, _, _ string) {
 	downloader := NewTidalDownloader()
 	track, err := downloader.SearchTrackByISRC(isrc)
 	if err == nil && track != nil {
 		GetTrackIDCache().SetTidal(isrc, track.ID)
 		fmt.Printf("[Cache] Cached Tidal ID for ISRC %s: %d\n", isrc, track.ID)
 	}
 }
 func preWarmQobuzCache(isrc string) {
 	downloader := NewQobuzDownloader()
 	track, err := downloader.SearchTrackByISRC(isrc)
 	if err == nil && track != nil {
 		GetTrackIDCache().SetQobuz(isrc, track.ID)
 		fmt.Printf("[Cache] Cached Qobuz ID for ISRC %s: %d\n", isrc, track.ID)
 	}
 }
 func preWarmAmazonCache(isrc, spotifyID string) {
 	client := NewSongLinkClient()
 	availability, err := client.CheckTrackAvailability(spotifyID, isrc)
 	if err == nil && availability != nil && availability.Amazon {
 		GetTrackIDCache().SetAmazon(isrc, availability.AmazonURL)
 		fmt.Printf("[Cache] Cached Amazon URL for ISRC %s\n", isrc)
 	}
 }
 func PreWarmCache(tracksJSON string) error {
 	var requests []PreWarmCacheRequest
 	go PreWarmTrackCache(requests)
 	return nil
 }
 func ClearTrackCache() {
 	GetTrackIDCache().Clear()
 	fmt.Println("[Cache] Track ID cache cleared")
 }
 func GetCacheSize() int {
 	return GetTrackIDCache().Size()
 }
@@ -3,10 +3,9 @@ package gobackend
 import (
 	"encoding/json"
 	"sync"
 	"time"
 )
 // DownloadProgress represents current download progress
 // Now unified - returns data from multi-progress system
 type DownloadProgress struct {
 	CurrentFile   string  `json:"current_file"`
 	Progress      float64 `json:"progress"`
@@ -14,20 +13,19 @@ type DownloadProgress struct {
 	BytesTotal    int64   `json:"bytes_total"`
 	BytesReceived int64   `json:"bytes_received"`
 	IsDownloading bool    `json:"is_downloading"`
-	Status        string  `json:"status"` // "downloading", "finalizing", "completed"
+	Status        string  `json:"status"`
 }
 // ItemProgress represents progress for a single download item
 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"`
 	SpeedMBps     float64 `json:"speed_mbps"`
 	IsDownloading bool    `json:"is_downloading"`
-	Status        string  `json:"status"` // "downloading", "finalizing", "completed"
+	Status        string  `json:"status"`
 }
 // MultiProgress holds progress for multiple concurrent downloads
 type MultiProgress struct {
 	Items map[string]*ItemProgress `json:"items"`
 }
@@ -36,22 +34,18 @@ var (
 	downloadDir   string
 	downloadDirMu sync.RWMutex
 	// Multi-download progress tracking (unified system)
 	multiProgress = MultiProgress{Items: make(map[string]*ItemProgress)}
 	multiMu       sync.RWMutex
 )
 // getProgress returns current download progress from multi-progress system
 // Returns first active item's progress for backward compatibility
 func getProgress() DownloadProgress {
 	multiMu.RLock()
 	defer multiMu.RUnlock()
 	// Find first active item
 	for _, item := range multiProgress.Items {
 		return DownloadProgress{
 			CurrentFile:   item.ItemID,
-			Progress:      item.Progress * 100, // Convert to percentage
+			Progress:      item.Progress * 100,
 			BytesTotal:    item.BytesTotal,
 			BytesReceived: item.BytesReceived,
 			IsDownloading: item.IsDownloading,
@@ -62,7 +56,6 @@ func getProgress() DownloadProgress {
 	return DownloadProgress{}
 }
 // GetMultiProgress returns progress for all active downloads as JSON
 func GetMultiProgress() string {
 	multiMu.RLock()
 	defer multiMu.RUnlock()
@@ -74,7 +67,6 @@ func GetMultiProgress() string {
 	return string(jsonBytes)
 }
 // GetItemProgress returns progress for a specific item as JSON
 func GetItemProgress(itemID string) string {
 	multiMu.RLock()
 	defer multiMu.RUnlock()
@@ -124,6 +116,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()
@@ -187,36 +193,57 @@ func setDownloadDir(path string) error {
 	return nil
 }
 // getDownloadDir returns the default download directory
 func getDownloadDir() string {
 	downloadDirMu.RLock()
 	defer downloadDirMu.RUnlock()
 	return downloadDir
 }
 // ItemProgressWriter wraps io.Writer to track download progress for a specific item
 type ItemProgressWriter struct {
-	writer  interface{ Write([]byte) (int, error) }
+	writer       interface{ Write([]byte) (int, error) }
-	itemID  string
+	itemID       string
-	current int64
+	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 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,
+		writer:       w,
-		itemID:  itemID,
+		itemID:       itemID,
-		current: 0,
+		current:      0,
 		lastReported: 0,
 		startTime:    now,
 		lastTime:     now,
 		lastBytes:    0,
 	}
 }
-// Write implements io.Writer
+// Write implements io.Writer with threshold-based progress updates and speed tracking
 func (pw *ItemProgressWriter) Write(p []byte) (int, error) {
 	if pw.itemID != "" && isDownloadCancelled(pw.itemID) {
 		return 0, ErrDownloadCancelled
 	}
 	n, err := pw.writer.Write(p)
 	if err != nil {
 		return n, err
 	}
 	pw.current += int64(n)
-	SetItemBytesReceived(pw.itemID, pw.current)
+
 	if pw.lastReported == 0 || pw.current-pw.lastReported >= progressUpdateThreshold {
 		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
 }
@@ -5,7 +5,6 @@ import (
 	"time"
 )
 // RateLimiter implements a sliding window rate limiter
 type RateLimiter struct {
 	mu          sync.Mutex
 	maxRequests int
@@ -13,7 +12,6 @@ type RateLimiter struct {
 	timestamps  []time.Time
 }
 // NewRateLimiter creates a new rate limiter with specified max requests per window
 func NewRateLimiter(maxRequests int, window time.Duration) *RateLimiter {
 	return &RateLimiter{
 		maxRequests: maxRequests,
@@ -22,39 +20,31 @@ func NewRateLimiter(maxRequests int, window time.Duration) *RateLimiter {
 	}
 }
 // WaitForSlot blocks until a request is allowed under the rate limit
 // Returns immediately if under the limit, otherwise waits until a slot is available
 func (r *RateLimiter) WaitForSlot() {
 	r.mu.Lock()
 	defer r.mu.Unlock()
 	now := time.Now()
 	// Remove timestamps outside the window
 	r.cleanOldTimestamps(now)
 	// If under limit, record and return immediately
 	if len(r.timestamps) < r.maxRequests {
 		r.timestamps = append(r.timestamps, now)
 		return
 	}
 	// Calculate wait time until oldest timestamp expires
 	oldestTimestamp := r.timestamps[0]
 	waitUntil := oldestTimestamp.Add(r.window)
 	waitDuration := waitUntil.Sub(now)
 	if waitDuration > 0 {
 		// Release lock while waiting
 		r.mu.Unlock()
 		time.Sleep(waitDuration)
 		r.mu.Lock()
 		// Clean again after waiting
 		r.cleanOldTimestamps(time.Now())
 	}
 	// Record this request
 	r.timestamps = append(r.timestamps, time.Now())
 }
@@ -76,8 +66,6 @@ func (r *RateLimiter) cleanOldTimestamps(now time.Time) {
 	}
 }
 // TryAcquire attempts to acquire a slot without blocking
 // Returns true if successful, false if rate limit would be exceeded
 func (r *RateLimiter) TryAcquire() bool {
 	r.mu.Lock()
 	defer r.mu.Unlock()
@@ -93,7 +81,6 @@ func (r *RateLimiter) TryAcquire() bool {
 	return false
 }
 // Available returns the number of requests available in the current window
 func (r *RateLimiter) Available() int {
 	r.mu.Lock()
 	defer r.mu.Unlock()
@@ -105,7 +92,6 @@ func (r *RateLimiter) Available() int {
 // Global SongLink rate limiter - 9 requests per minute (to be safe, limit is 10)
 var songLinkRateLimiter = NewRateLimiter(9, time.Minute)
 // GetSongLinkRateLimiter returns the global SongLink rate limiter
 func GetSongLinkRateLimiter() *RateLimiter {
 	return songLinkRateLimiter
 }
@@ -0,0 +1,211 @@
 package gobackend
 import (
 	"strings"
 	"unicode"
 )
 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",
 }
 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",
 }
 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",
 }
 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
 }
 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()
 }
 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)
 }
 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())
 }
 func CleanToASCII(s string) string {
 	var result strings.Builder
 	for _, r := range s {
 		// Keep only ASCII letters, numbers, spaces, and basic punctuation
 		if (r >= 'a' && r <= 'z') || (r >= 'A' && r <= 'Z') ||
 			(r >= '0' && r <= '9') || r == ' ' || r == '-' || r == '\'' {
 			result.WriteRune(r)
 		} else if r == ',' || r == '.' {
 			// Convert punctuation to space
 			result.WriteRune(' ')
 		}
 	}
 	// Clean up multiple spaces
 	cleaned := strings.Join(strings.Fields(result.String()), " ")
 	return strings.TrimSpace(cleaned)
 }
@@ -6,38 +6,49 @@ import (
 	"fmt"
 	"net/http"
 	"net/url"
 	"strings"
 	"sync"
 	"time"
 )
 // SongLinkClient handles song.link API interactions
 type SongLinkClient struct {
 	client *http.Client
 }
 // TrackAvailability represents track availability on different platforms
 type TrackAvailability struct {
 	SpotifyID string `json:"spotify_id"`
 	Tidal     bool   `json:"tidal"`
 	Amazon    bool   `json:"amazon"`
 	Qobuz     bool   `json:"qobuz"`
 	Deezer    bool   `json:"deezer"`
 	TidalURL  string `json:"tidal_url,omitempty"`
 	AmazonURL string `json:"amazon_url,omitempty"`
 	QobuzURL  string `json:"qobuz_url,omitempty"`
 	DeezerURL string `json:"deezer_url,omitempty"`
 	DeezerID  string `json:"deezer_id,omitempty"`
 }
-// NewSongLinkClient creates a new SongLink client
+var (
 	globalSongLinkClient *SongLinkClient
 	songLinkClientOnce   sync.Once
 )
 func NewSongLinkClient() *SongLinkClient {
-	return &SongLinkClient{
+	songLinkClientOnce.Do(func() {
-		client: NewHTTPClientWithTimeout(SongLinkTimeout), // 30s timeout
+		globalSongLinkClient = &SongLinkClient{
-	}
+			client: NewHTTPClientWithTimeout(SongLinkTimeout),
 		}
 	})
 	return globalSongLinkClient
 }
 // CheckTrackAvailability checks track availability on streaming platforms
 func (s *SongLinkClient) CheckTrackAvailability(spotifyTrackID string, isrc string) (*TrackAvailability, error) {
-	// Use global rate limiter - blocks until request is allowed
+	if spotifyTrackID == "" {
 		return nil, fmt.Errorf("spotify track ID is empty")
 	}
 	songLinkRateLimiter.WaitForSlot()
 	// Build API URL
 	spotifyBase, _ := base64.StdEncoding.DecodeString("aHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLw==")
 	spotifyURL := fmt.Sprintf("%s%s", string(spotifyBase), spotifyTrackID)
@@ -49,7 +60,6 @@ func (s *SongLinkClient) CheckTrackAvailability(spotifyTrackID string, isrc stri
 		return nil, fmt.Errorf("failed to create request: %w", err)
 	}
 	// Use retry logic with User-Agent
 	retryConfig := DefaultRetryConfig()
 	resp, err := DoRequestWithRetry(s.client, req, retryConfig)
 	if err != nil {
@@ -57,8 +67,17 @@ func (s *SongLinkClient) CheckTrackAvailability(spotifyTrackID string, isrc stri
 	}
 	defer resp.Body.Close()
 	if resp.StatusCode == 400 {
 		return nil, fmt.Errorf("track not found on SongLink (invalid Spotify ID or track unavailable)")
 	}
 	if resp.StatusCode == 404 {
 		return nil, fmt.Errorf("track not found on any streaming platform")
 	}
 	if resp.StatusCode == 429 {
 		return nil, fmt.Errorf("SongLink rate limit exceeded")
 	}
 	if resp.StatusCode != 200 {
-		return nil, fmt.Errorf("API returned status %d", resp.StatusCode)
+		return nil, fmt.Errorf("SongLink API returned status %d", resp.StatusCode)
 	}
 	body, err := ReadResponseBody(resp)
@@ -80,19 +99,22 @@ func (s *SongLinkClient) CheckTrackAvailability(spotifyTrackID string, isrc stri
 		SpotifyID: spotifyTrackID,
 	}
 	// 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 Qobuz using ISRC
+	if deezerLink, ok := songLinkResp.LinksByPlatform["deezer"]; ok && deezerLink.URL != "" {
 		availability.Deezer = true
 		availability.DeezerURL = deezerLink.URL
 		availability.DeezerID = extractDeezerIDFromURL(deezerLink.URL)
 	}
 	if isrc != "" {
 		availability.Qobuz = checkQobuzAvailability(isrc)
 	}
@@ -100,7 +122,6 @@ func (s *SongLinkClient) CheckTrackAvailability(spotifyTrackID string, isrc stri
 	return availability, nil
 }
 // GetStreamingURLs gets streaming URLs for a Spotify track
 func (s *SongLinkClient) GetStreamingURLs(spotifyTrackID string) (map[string]string, error) {
 	availability, err := s.CheckTrackAvailability(spotifyTrackID, "")
 	if err != nil {
@@ -151,3 +172,329 @@ func checkQobuzAvailability(isrc string) bool {
 	return searchResp.Tracks.Total > 0
 }
 // extractDeezerIDFromURL extracts Deezer track/album/artist ID from URL
 func extractDeezerIDFromURL(deezerURL string) string {
 	parts := strings.Split(deezerURL, "/")
 	if len(parts) > 0 {
 		lastPart := parts[len(parts)-1]
 		if idx := strings.Index(lastPart, "?"); idx > 0 {
 			lastPart = lastPart[:idx]
 		}
 		return lastPart
 	}
 	return ""
 }
 func (s *SongLinkClient) GetDeezerIDFromSpotify(spotifyTrackID string) (string, error) {
 	availability, err := s.CheckTrackAvailability(spotifyTrackID, "")
 	if err != nil {
 		return "", err
 	}
 	if !availability.Deezer || availability.DeezerID == "" {
 		return "", fmt.Errorf("track not found on Deezer")
 	}
 	return availability.DeezerID, nil
 }
 // AlbumAvailability represents album availability on different platforms
 type AlbumAvailability struct {
 	SpotifyID string `json:"spotify_id"`
 	Deezer    bool   `json:"deezer"`
 	DeezerURL string `json:"deezer_url,omitempty"`
 	DeezerID  string `json:"deezer_id,omitempty"`
 }
 func (s *SongLinkClient) CheckAlbumAvailability(spotifyAlbumID string) (*AlbumAvailability, error) {
 	// Use global rate limiter
 	songLinkRateLimiter.WaitForSlot()
 	// Build API URL for album
 	spotifyBase, _ := base64.StdEncoding.DecodeString("aHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL2FsYnVtLw==")
 	spotifyURL := fmt.Sprintf("%s%s", string(spotifyBase), spotifyAlbumID)
 	apiBase, _ := base64.StdEncoding.DecodeString("aHR0cHM6Ly9hcGkuc29uZy5saW5rL3YxLWFscGhhLjEvbGlua3M/dXJsPQ==")
 	apiURL := fmt.Sprintf("%s%s", string(apiBase), url.QueryEscape(spotifyURL))
 	req, err := http.NewRequest("GET", apiURL, nil)
 	if err != nil {
 		return nil, fmt.Errorf("failed to create request: %w", err)
 	}
 	retryConfig := DefaultRetryConfig()
 	resp, err := DoRequestWithRetry(s.client, req, retryConfig)
 	if err != nil {
 		return nil, fmt.Errorf("failed to check album availability: %w", err)
 	}
 	defer resp.Body.Close()
 	if resp.StatusCode != 200 {
 		return nil, fmt.Errorf("API returned status %d", resp.StatusCode)
 	}
 	body, err := ReadResponseBody(resp)
 	if err != nil {
 		return nil, fmt.Errorf("failed to read response: %w", err)
 	}
 	var songLinkResp struct {
 		LinksByPlatform map[string]struct {
 			URL string `json:"url"`
 		} `json:"linksByPlatform"`
 	}
 	if err := json.Unmarshal(body, &songLinkResp); err != nil {
 		return nil, fmt.Errorf("failed to decode response: %w", err)
 	}
 	availability := &AlbumAvailability{
 		SpotifyID: spotifyAlbumID,
 	}
 	if deezerLink, ok := songLinkResp.LinksByPlatform["deezer"]; ok && deezerLink.URL != "" {
 		availability.Deezer = true
 		availability.DeezerURL = deezerLink.URL
 		availability.DeezerID = extractDeezerIDFromURL(deezerLink.URL)
 	}
 	return availability, nil
 }
 // GetDeezerAlbumIDFromSpotify converts a Spotify album ID to Deezer album ID using SongLink
 func (s *SongLinkClient) GetDeezerAlbumIDFromSpotify(spotifyAlbumID string) (string, error) {
 	availability, err := s.CheckAlbumAvailability(spotifyAlbumID)
 	if err != nil {
 		return "", err
 	}
 	if !availability.Deezer || availability.DeezerID == "" {
 		return "", fmt.Errorf("album not found on Deezer")
 	}
 	return availability.DeezerID, nil
 }
 // 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")
 	}
 	songLinkRateLimiter.WaitForSlot()
 	deezerURL := fmt.Sprintf("https://www.deezer.com/track/%s", deezerTrackID)
 	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,
 	}
 	if spotifyLink, ok := songLinkResp.LinksByPlatform["spotify"]; ok && spotifyLink.URL != "" {
 		availability.SpotifyID = extractSpotifyIDFromURL(spotifyLink.URL)
 	}
 	if tidalLink, ok := songLinkResp.LinksByPlatform["tidal"]; ok && tidalLink.URL != "" {
 		availability.Tidal = true
 		availability.TidalURL = tidalLink.URL
 	}
 	if amazonLink, ok := songLinkResp.LinksByPlatform["amazonMusic"]; ok && amazonLink.URL != "" {
 		availability.Amazon = true
 		availability.AmazonURL = amazonLink.URL
 	}
 	if deezerLink, ok := songLinkResp.LinksByPlatform["deezer"]; ok && deezerLink.URL != "" {
 		availability.DeezerURL = deezerLink.URL
 	}
 	return availability, nil
 }
 // 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{}
 	if spotifyLink, ok := songLinkResp.LinksByPlatform["spotify"]; ok && spotifyLink.URL != "" {
 		availability.SpotifyID = extractSpotifyIDFromURL(spotifyLink.URL)
 	}
 	if tidalLink, ok := songLinkResp.LinksByPlatform["tidal"]; ok && tidalLink.URL != "" {
 		availability.Tidal = true
 		availability.TidalURL = tidalLink.URL
 	}
 	if amazonLink, ok := songLinkResp.LinksByPlatform["amazonMusic"]; ok && amazonLink.URL != "" {
 		availability.Amazon = true
 		availability.AmazonURL = amazonLink.URL
 	}
 	if deezerLink, ok := songLinkResp.LinksByPlatform["deezer"]; ok && deezerLink.URL != "" {
 		availability.Deezer = true
 		availability.DeezerURL = deezerLink.URL
 		availability.DeezerID = extractDeezerIDFromURL(deezerLink.URL)
 	}
 	return availability, nil
 }
 // extractSpotifyIDFromURL extracts Spotify track ID from URL
 func extractSpotifyIDFromURL(spotifyURL string) string {
 	parts := strings.Split(spotifyURL, "/track/")
 	if len(parts) > 1 {
 		idPart := parts[1]
 		if idx := strings.Index(idPart, "?"); idx > 0 {
 			idPart = idPart[:idx]
 		}
 		return idPart
 	}
 	return ""
 }
 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
 }
 func (s *SongLinkClient) GetAmazonURLFromDeezer(deezerTrackID string) (string, error) {
 	availability, err := s.CheckAvailabilityFromDeezer(deezerTrackID)
 	if err != nil {
 		return "", err
 	}
 	if !availability.Amazon || availability.AmazonURL == "" {
 		return "", fmt.Errorf("track not found on Amazon Music")
 	}
 	return availability.AmazonURL, nil
 }
@@ -2,7 +2,6 @@ package gobackend
 import (
 	"context"
 	"encoding/base64"
 	"encoding/json"
 	"errors"
 	"fmt"
@@ -17,15 +16,14 @@ import (
 )
 const (
-	spotifyTokenURL     = "https://accounts.spotify.com/api/token"
+	spotifyTokenURL = "https://accounts.spotify.com/api/token"
-	playlistBaseURL     = "https://api.spotify.com/v1/playlists/%s"
+	playlistBaseURL = "https://api.spotify.com/v1/playlists/%s"
-	albumBaseURL        = "https://api.spotify.com/v1/albums/%s"
+	albumBaseURL    = "https://api.spotify.com/v1/albums/%s"
-	trackBaseURL        = "https://api.spotify.com/v1/tracks/%s"
+	trackBaseURL    = "https://api.spotify.com/v1/tracks/%s"
-	artistBaseURL       = "https://api.spotify.com/v1/artists/%s"
+	artistBaseURL   = "https://api.spotify.com/v1/artists/%s"
-	artistAlbumsURL     = "https://api.spotify.com/v1/artists/%s/albums"
+	artistAlbumsURL = "https://api.spotify.com/v1/artists/%s/albums"
-	searchBaseURL       = "https://api.spotify.com/v1/search"
+	searchBaseURL   = "https://api.spotify.com/v1/search"
-	
+
 	// Cache TTL settings
 	artistCacheTTL = 10 * time.Minute
 	searchCacheTTL = 5 * time.Minute
 	albumCacheTTL  = 10 * time.Minute
@@ -33,7 +31,6 @@ const (
 var errInvalidSpotifyURL = errors.New("invalid or unsupported Spotify URL")
 // cacheEntry holds cached data with expiration
 type cacheEntry struct {
 	data      interface{}
 	expiresAt time.Time
@@ -43,34 +40,33 @@ func (e *cacheEntry) isExpired() bool {
 	return time.Now().After(e.expiresAt)
 }
 // SpotifyMetadataClient handles Spotify API interactions
 type SpotifyMetadataClient struct {
 	httpClient     *http.Client
 	clientID       string
 	clientSecret   string
 	cachedToken    string
 	tokenExpiresAt time.Time
-	tokenMu        sync.Mutex // Protects token cache for concurrent access
+	tokenMu        sync.Mutex
 	rng            *rand.Rand
 	rngMu          sync.Mutex
 	userAgent      string
-	
+
-	// Caches to reduce API calls
+	artistCache map[string]*cacheEntry
-	artistCache map[string]*cacheEntry // key: artistID
+	searchCache map[string]*cacheEntry
-	searchCache map[string]*cacheEntry // key: query+type
+	albumCache  map[string]*cacheEntry
 	albumCache  map[string]*cacheEntry // key: albumID
 	cacheMu     sync.RWMutex
 }
 // Custom credentials storage (set from Flutter)
 var (
 	customClientID     string
 	customClientSecret string
 	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,42 +74,50 @@ func SetSpotifyCredentials(clientID, clientSecret string) {
 	customClientSecret = clientSecret
 }
-// getCredentials returns the current credentials (custom or default)
+func HasSpotifyCredentials() bool {
 func getCredentials() (string, string) {
 	credentialsMu.RLock()
 	defer credentialsMu.RUnlock()
-	
+
 	if customClientID != "" && customClientSecret != "" {
-		return customClientID, customClientSecret
+		return true
 	}
 	// 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)
 		}
 	}
-	clientSecret := os.Getenv("SPOTIFY_CLIENT_SECRET")
+	if os.Getenv("SPOTIFY_CLIENT_ID") != "" && os.Getenv("SPOTIFY_CLIENT_SECRET") != "" {
-	if clientSecret == "" {
+		return true
 		if decoded, err := base64.StdEncoding.DecodeString("MjEyNDc2ZDliMGYzNDcyZWFhNzYyZDkwYjE5YjBiYTg="); err == nil {
 			clientSecret = string(decoded)
 		}
 	}
-	
+
-	return clientID, clientSecret
+	return false
 }
-// NewSpotifyMetadataClient creates a new Spotify client
+// getCredentials returns the current credentials or error if not configured
-func NewSpotifyMetadataClient() *SpotifyMetadataClient {
+func getCredentials() (string, string, error) {
 	credentialsMu.RLock()
 	defer credentialsMu.RUnlock()
 	if customClientID != "" && customClientSecret != "" {
 		return customClientID, customClientSecret, nil
 	}
 	clientID := os.Getenv("SPOTIFY_CLIENT_ID")
 	clientSecret := os.Getenv("SPOTIFY_CLIENT_SECRET")
 	if clientID != "" && clientSecret != "" {
 		return clientID, clientSecret, nil
 	}
 	return "", "", ErrNoSpotifyCredentials
 }
 func NewSpotifyMetadataClient() (*SpotifyMetadataClient, error) {
 	clientID, clientSecret, err := getCredentials()
 	if err != nil {
 		return nil, err
 	}
 	src := rand.NewSource(time.Now().UnixNano())
 	// Get credentials (custom or default)
 	clientID, clientSecret := getCredentials()
 	c := &SpotifyMetadataClient{
-		httpClient:   NewHTTPClientWithTimeout(15 * time.Second), // Use shared transport for connection pooling
+		httpClient:   NewHTTPClientWithTimeout(15 * time.Second),
 		clientID:     clientID,
 		clientSecret: clientSecret,
 		rng:          rand.New(src),
@@ -122,10 +126,9 @@ func NewSpotifyMetadataClient() *SpotifyMetadataClient {
 		albumCache:   make(map[string]*cacheEntry),
 	}
 	c.userAgent = c.randomUserAgent()
-	return c
+	return c, nil
 }
 // TrackMetadata represents track information
 type TrackMetadata struct {
 	SpotifyID   string `json:"spotify_id,omitempty"`
 	Artists     string `json:"artists"`
@@ -140,9 +143,9 @@ 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
 type AlbumTrackMetadata struct {
 	SpotifyID   string `json:"spotify_id,omitempty"`
 	Artists     string `json:"artists"`
@@ -159,24 +162,26 @@ 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"`
 }
 // AlbumInfoMetadata holds album information
 type AlbumInfoMetadata struct {
 	TotalTracks int    `json:"total_tracks"`
 	Name        string `json:"name"`
 	ReleaseDate string `json:"release_date"`
 	Artists     string `json:"artists"`
 	ArtistId    string `json:"artist_id,omitempty"`
 	Images      string `json:"images"`
 	Genre       string `json:"genre,omitempty"`
 	Label       string `json:"label,omitempty"`
 	Copyright   string `json:"copyright,omitempty"`
 }
 // AlbumResponsePayload is the response for album requests
 type AlbumResponsePayload struct {
 	AlbumInfo AlbumInfoMetadata    `json:"album_info"`
 	TrackList []AlbumTrackMetadata `json:"track_list"`
 }
 // PlaylistInfoMetadata holds playlist information
 type PlaylistInfoMetadata struct {
 	Tracks struct {
 		Total int `json:"total"`
@@ -188,13 +193,11 @@ type PlaylistInfoMetadata struct {
 	} `json:"owner"`
 }
 // PlaylistResponsePayload is the response for playlist requests
 type PlaylistResponsePayload struct {
 	PlaylistInfo PlaylistInfoMetadata `json:"playlist_info"`
 	TrackList    []AlbumTrackMetadata `json:"track_list"`
 }
 // ArtistInfoMetadata holds artist information
 type ArtistInfoMetadata struct {
 	ID         string `json:"id"`
 	Name       string `json:"name"`
@@ -203,7 +206,6 @@ type ArtistInfoMetadata struct {
 	Popularity int    `json:"popularity"`
 }
 // ArtistAlbumMetadata holds album info for artist discography
 type ArtistAlbumMetadata struct {
 	ID          string `json:"id"`
 	Name        string `json:"name"`
@@ -214,24 +216,20 @@ type ArtistAlbumMetadata struct {
 	Artists     string `json:"artists"`
 }
 // ArtistResponsePayload is the response for artist requests
 type ArtistResponsePayload struct {
 	ArtistInfo ArtistInfoMetadata    `json:"artist_info"`
 	Albums     []ArtistAlbumMetadata `json:"albums"`
 }
 // TrackResponse is the response for single track requests
 type TrackResponse struct {
 	Track TrackMetadata `json:"track"`
 }
 // SearchResult represents search results
 type SearchResult struct {
 	Tracks []TrackMetadata `json:"tracks"`
 	Total  int             `json:"total"`
 }
 // SearchArtistResult represents an artist in search results
 type SearchArtistResult struct {
 	ID         string `json:"id"`
 	Name       string `json:"name"`
@@ -240,7 +238,6 @@ type SearchArtistResult struct {
 	Popularity int    `json:"popularity"`
 }
 // SearchAllResult represents combined search results for tracks and artists
 type SearchAllResult struct {
 	Tracks  []TrackMetadata      `json:"tracks"`
 	Artists []SearchArtistResult `json:"artists"`
@@ -257,7 +254,6 @@ type accessTokenResponse struct {
 	TokenType   string      `json:"token_type"`
 }
 // Internal API response types
 type image struct {
 	URL string `json:"url"`
 }
@@ -283,6 +279,7 @@ type albumSimplified struct {
 	Images      []image     `json:"images"`
 	ExternalURL externalURL `json:"external_urls"`
 	Artists     []artist    `json:"artists"`
 	AlbumType   string      `json:"album_type"`
 }
 type trackFull struct {
@@ -297,7 +294,6 @@ type trackFull struct {
 	Artists     []artist        `json:"artists"`
 }
 // GetFilteredData fetches and formats Spotify data
 func (c *SpotifyMetadataClient) GetFilteredData(ctx context.Context, spotifyURL string, batch bool, delay time.Duration) (interface{}, error) {
 	parsed, err := parseSpotifyURI(spotifyURL)
 	if err != nil {
@@ -323,7 +319,6 @@ func (c *SpotifyMetadataClient) GetFilteredData(ctx context.Context, spotifyURL
 	}
 }
 // SearchTracks searches for tracks on Spotify
 func (c *SpotifyMetadataClient) SearchTracks(ctx context.Context, query string, limit int) (*SearchResult, error) {
 	token, err := c.getAccessToken(ctx)
 	if err != nil {
@@ -331,14 +326,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,18 +358,16 @@ func (c *SpotifyMetadataClient) SearchTracks(ctx context.Context, query string,
 			DiscNumber:  track.DiscNumber,
 			ExternalURL: track.ExternalURL.Spotify,
 			ISRC:        track.ExternalID.ISRC,
 			AlbumType:   track.Album.AlbumType,
 		})
 	}
 	return result, nil
 }
 // SearchAll searches for tracks and artists on Spotify
 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() {
 		c.cacheMu.RUnlock()
@@ -388,24 +381,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"`
+				ID        string  `json:"id"`
-				Name       string  `json:"name"`
+				Name      string  `json:"name"`
-				Images     []image `json:"images"`
+				Images    []image `json:"images"`
-				Followers  struct {
+				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,15 +423,15 @@ 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,
 		})
 	}
 	// Limit artists to artistLimit
 	artistCount := len(response.Artists.Items)
 	if artistCount > artistLimit {
 		artistCount = artistLimit
 	}
-	
+
 	for i := 0; i < artistCount; i++ {
 		artist := response.Artists.Items[i]
 		result.Artists = append(result.Artists, SearchArtistResult{
@@ -450,7 +443,6 @@ func (c *SpotifyMetadataClient) SearchAll(ctx context.Context, query string, tra
 		})
 	}
 	// Store in cache
 	c.cacheMu.Lock()
 	c.searchCache[cacheKey] = &cacheEntry{
 		data:      result,
@@ -487,7 +479,6 @@ func (c *SpotifyMetadataClient) fetchTrack(ctx context.Context, trackID, token s
 }
 func (c *SpotifyMetadataClient) fetchAlbum(ctx context.Context, albumID, token string) (*AlbumResponsePayload, error) {
 	// Check cache first
 	c.cacheMu.RLock()
 	if entry, ok := c.albumCache[albumID]; ok && !entry.isExpired() {
 		c.cacheMu.RUnlock()
@@ -495,6 +486,16 @@ func (c *SpotifyMetadataClient) fetchAlbum(ctx context.Context, albumID, token s
 	}
 	c.cacheMu.RUnlock()
 	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 +503,8 @@ func (c *SpotifyMetadataClient) fetchAlbum(ctx context.Context, albumID, token s
 		Images      []image  `json:"images"`
 		Artists     []artist `json:"artists"`
 		Tracks      struct {
-			Items []struct {
+			Items []trackItem `json:"items"`
-				ID          string      `json:"id"`
+			Next  string      `json:"next"`
 				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"`
 		} `json:"tracks"`
 	}
@@ -519,19 +513,52 @@ func (c *SpotifyMetadataClient) fetchAlbum(ctx context.Context, albumID, token s
 	}
 	albumImage := firstImageURL(data.Images)
 	// Get first artist ID
 	var firstArtistId string
 	if len(data.Artists) > 0 {
 		firstArtistId = data.Artists[0].ID
 	}
 	info := AlbumInfoMetadata{
 		TotalTracks: data.TotalTracks,
 		Name:        data.Name,
 		ReleaseDate: data.ReleaseDate,
 		Artists:     joinArtists(data.Artists),
 		ArtistId:    firstArtistId,
 		Images:      albumImage,
 	}
-	tracks := make([]AlbumTrackMetadata, 0, len(data.Tracks.Items))
+	allTrackItems := data.Tracks.Items
-	for _, item := range data.Tracks.Items {
+	nextURL := data.Tracks.Next
-		// Fetch ISRC for each track
+
-		isrc := c.fetchTrackISRC(ctx, item.ID, token)
+	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
 	}
 	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),
@@ -555,7 +582,6 @@ func (c *SpotifyMetadataClient) fetchAlbum(ctx context.Context, albumID, token s
 		TrackList: tracks,
 	}
 	// Store in cache
 	c.cacheMu.Lock()
 	c.albumCache[albumID] = &cacheEntry{
 		data:      result,
@@ -566,8 +592,44 @@ func (c *SpotifyMetadataClient) fetchAlbum(ctx context.Context, albumID, token s
 	return result, nil
 }
 func (c *SpotifyMetadataClient) fetchISRCsParallel(ctx context.Context, trackIDs []string, token string) map[string]string {
 	const maxParallelISRC = 10
 	result := make(map[string]string)
 	var resultMu sync.Mutex
 	if len(trackIDs) == 0 {
 		return result
 	}
 	sem := make(chan struct{}, maxParallelISRC)
 	var wg sync.WaitGroup
 	for _, trackID := range trackIDs {
 		wg.Add(1)
 		go func(id string) {
 			defer wg.Done()
 			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 {
 		Name   string  `json:"name"`
 		Images []image `json:"images"`
@@ -593,10 +655,8 @@ func (c *SpotifyMetadataClient) fetchPlaylist(ctx context.Context, playlistID, t
 	info.Owner.Name = data.Name
 	info.Owner.Images = firstImageURL(data.Images)
 	// 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 {
 			continue
@@ -620,11 +680,9 @@ func (c *SpotifyMetadataClient) fetchPlaylist(ctx context.Context, playlistID, t
 		})
 	}
 	// Fetch remaining tracks using pagination (up to 1000 tracks max)
 	nextURL := data.Tracks.Next
-	maxTracks := 1000
+
-	
+	for nextURL != "" {
 	for nextURL != "" && len(tracks) < maxTracks {
 		var pageData struct {
 			Items []struct {
 				Track *trackFull `json:"track"`
@@ -633,7 +691,6 @@ func (c *SpotifyMetadataClient) fetchPlaylist(ctx context.Context, playlistID, t
 		}
 		if err := c.getJSON(ctx, nextURL, token, &pageData); err != nil {
 			// Log error but return what we have so far
 			fmt.Printf("[Spotify] Warning: failed to fetch page, returning %d tracks: %v\n", len(tracks), err)
 			break
 		}
@@ -642,9 +699,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),
@@ -676,7 +730,6 @@ func (c *SpotifyMetadataClient) fetchPlaylist(ctx context.Context, playlistID, t
 }
 func (c *SpotifyMetadataClient) fetchArtist(ctx context.Context, artistID, token string) (*ArtistResponsePayload, error) {
 	// Check cache first
 	c.cacheMu.RLock()
 	if entry, ok := c.artistCache[artistID]; ok && !entry.isExpired() {
 		c.cacheMu.RUnlock()
@@ -684,12 +737,11 @@ func (c *SpotifyMetadataClient) fetchArtist(ctx context.Context, artistID, token
 	}
 	c.cacheMu.RUnlock()
 	// Fetch artist info
 	var artistData struct {
-		ID         string  `json:"id"`
+		ID        string  `json:"id"`
-		Name       string  `json:"name"`
+		Name      string  `json:"name"`
-		Images     []image `json:"images"`
+		Images    []image `json:"images"`
-		Followers  struct {
+		Followers struct {
 			Total int `json:"total"`
 		} `json:"followers"`
 		Popularity int `json:"popularity"`
@@ -707,7 +759,6 @@ func (c *SpotifyMetadataClient) fetchArtist(ctx context.Context, artistID, token
 		Popularity: artistData.Popularity,
 	}
 	// Fetch artist albums (all types: album, single, compilation)
 	albums := make([]ArtistAlbumMetadata, 0)
 	offset := 0
 	limit := 50
@@ -747,13 +798,11 @@ func (c *SpotifyMetadataClient) fetchArtist(ctx context.Context, artistID, token
 			})
 		}
 		// Check if there are more albums
 		if albumsData.Next == "" || len(albumsData.Items) < limit {
 			break
 		}
 		offset += limit
 		// Safety limit to prevent infinite loops
 		if offset > 500 {
 			break
 		}
@@ -764,7 +813,6 @@ func (c *SpotifyMetadataClient) fetchArtist(ctx context.Context, artistID, token
 		Albums:     albums,
 	}
 	// Store in cache
 	c.cacheMu.Lock()
 	c.artistCache[artistID] = &cacheEntry{
 		data:      result,
@@ -837,6 +885,13 @@ func (c *SpotifyMetadataClient) getJSON(ctx context.Context, endpoint, token str
 	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 +918,22 @@ func (c *SpotifyMetadataClient) randomUserAgent() string {
 	c.rngMu.Lock()
 	defer c.rngMu.Unlock()
-	chromeMajor := 80 + c.rng.Intn(25)
+	macMajor := c.rng.Intn(4) + 11
-	chromeBuild := 3000 + c.rng.Intn(1500)
+	macMinor := c.rng.Intn(5) + 4          // 4-8
-	chromePatch := 60 + c.rng.Intn(65)
+	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,
 	)
 }
@@ -879,7 +943,6 @@ func parseSpotifyURI(input string) (spotifyURI, error) {
 		return spotifyURI{}, errInvalidSpotifyURL
 	}
 	// Handle spotify: URI format
 	if strings.HasPrefix(trimmed, "spotify:") {
 		parts := strings.Split(trimmed, ":")
 		if len(parts) == 3 {
@@ -890,13 +953,11 @@ func parseSpotifyURI(input string) (spotifyURI, error) {
 		}
 	}
 	// Handle URL format
 	parsed, err := url.Parse(trimmed)
 	if err != nil {
 		return spotifyURI{}, err
 	}
 	// Handle embed.spotify.com URLs
 	if parsed.Host == "embed.spotify.com" {
 		if parsed.RawQuery == "" {
 			return spotifyURI{}, errInvalidSpotifyURL
@@ -909,7 +970,6 @@ func parseSpotifyURI(input string) (spotifyURI, error) {
 		return parseSpotifyURI(embedded)
 	}
 	// Handle plain ID (no scheme/host) - defaults to playlist
 	if parsed.Scheme == "" && parsed.Host == "" {
 		id := strings.Trim(strings.TrimSpace(parsed.Path), "/")
 		if id == "" {
@@ -935,7 +995,6 @@ func parseSpotifyURI(input string) (spotifyURI, error) {
 		return spotifyURI{}, errInvalidSpotifyURL
 	}
 	// Skip intl- prefix if present
 	if strings.HasPrefix(parts[0], "intl-") {
 		parts = parts[1:]
 	}
@@ -943,7 +1002,6 @@ func parseSpotifyURI(input string) (spotifyURI, error) {
 		return spotifyURI{}, errInvalidSpotifyURL
 	}
 	// Handle standard URLs: /album/{id}, /track/{id}, /playlist/{id}, /artist/{id}
 	if len(parts) == 2 {
 		switch parts[0] {
 		case "album", "track", "playlist", "artist":
@@ -951,7 +1009,6 @@ func parseSpotifyURI(input string) (spotifyURI, error) {
 		}
 	}
 	// Handle nested playlist URLs: /user/{user}/playlist/{id}
 	if len(parts) == 4 && parts[2] == "playlist" {
 		return spotifyURI{Type: "playlist", ID: parts[3]}, nil
 	}
@@ -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++";
@@ -120,6 +120,12 @@ import Gobackend  // Import Go framework
            let itemId = args["item_id"] as! String
            GobackendClearItemProgress(itemId)
            return nil
        case "cancelDownload":
            let args = call.arguments as! [String: Any]
            let itemId = args["item_id"] as! String
            GobackendCancelDownload(itemId)
            return nil
        case "setDownloadDirectory":
            let args = call.arguments as! [String: Any]
@@ -136,6 +142,27 @@ import Gobackend  // Import Go framework
            if let error = error { throw error }
            return response
        case "checkDuplicatesBatch":
            let args = call.arguments as! [String: Any]
            let outputDir = args["output_dir"] as! String
            let tracksJson = args["tracks"] as? String ?? "[]"
            let response = GobackendCheckDuplicatesBatch(outputDir, tracksJson, &error)
            if let error = error { throw error }
            return response
        case "preBuildDuplicateIndex":
            let args = call.arguments as! [String: Any]
            let outputDir = args["output_dir"] as! String
            GobackendPreBuildDuplicateIndex(outputDir, &error)
            if let error = error { throw error }
            return nil
        case "invalidateDuplicateIndex":
            let args = call.arguments as! [String: Any]
            let outputDir = args["output_dir"] as! String
            GobackendInvalidateDuplicateIndex(outputDir)
            return nil
        case "buildFilename":
            let args = call.arguments as! [String: Any]
            let template = args["template"] as! String
@@ -155,7 +182,8 @@ import Gobackend  // Import Go framework
            let spotifyId = args["spotify_id"] as! String
            let trackName = args["track_name"] as! String
            let artistName = args["artist_name"] as! String
-            let response = GobackendFetchLyrics(spotifyId, trackName, artistName, &error)
+            let durationMs = args["duration_ms"] as? Int64 ?? 0
            let response = GobackendFetchLyrics(spotifyId, trackName, artistName, durationMs, &error)
            if let error = error { throw error }
            return response
@@ -165,7 +193,8 @@ import Gobackend  // Import Go framework
            let trackName = args["track_name"] as! String
            let artistName = args["artist_name"] as! String
            let filePath = args["file_path"] as? String ?? ""
-            let response = GobackendGetLyricsLRC(spotifyId, trackName, artistName, filePath, &error)
+            let durationMs = args["duration_ms"] as? Int64 ?? 0
            let response = GobackendGetLyricsLRC(spotifyId, trackName, artistName, filePath, durationMs, &error)
            if let error = error { throw error }
            return response
@@ -181,6 +210,482 @@ 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 "getDeezerExtendedMetadata":
            let args = call.arguments as! [String: Any]
            let trackId = args["track_id"] as! String
            let response = GobackendGetDeezerExtendedMetadata(trackId, &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 "checkAvailabilityFromDeezerID":
            let args = call.arguments as! [String: Any]
            let deezerTrackId = args["deezer_track_id"] as! String
            let response = GobackendCheckAvailabilityFromDeezerID(deezerTrackId, &error)
            if let error = error { throw error }
            return response
        case "checkAvailabilityByPlatformID":
            let args = call.arguments as! [String: Any]
            let platform = args["platform"] as! String
            let entityType = args["entity_type"] as! String
            let entityId = args["entity_id"] as! String
            let response = GobackendCheckAvailabilityByPlatformID(platform, entityType, entityId, &error)
            if let error = error { throw error }
            return response
        case "getSpotifyIDFromDeezerTrack":
            let args = call.arguments as! [String: Any]
            let deezerTrackId = args["deezer_track_id"] as! String
            let response = GobackendGetSpotifyIDFromDeezerTrack(deezerTrackId, &error)
            if let error = error { throw error }
            return response
        case "getTidalURLFromDeezerTrack":
            let args = call.arguments as! [String: Any]
            let deezerTrackId = args["deezer_track_id"] as! String
            let response = GobackendGetTidalURLFromDeezerTrack(deezerTrackId, &error)
            if let error = error { throw error }
            return response
        case "getAmazonURLFromDeezerTrack":
            let args = call.arguments as! [String: Any]
            let deezerTrackId = args["deezer_track_id"] as! String
            let response = GobackendGetAmazonURLFromDeezerTrack(deezerTrackId, &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 "invokeExtensionAction":
            let args = call.arguments as! [String: Any]
            let extensionId = args["extension_id"] as! String
            let actionName = args["action"] as! String
            let response = GobackendInvokeExtensionActionJSON(extensionId, actionName, &error)
            if let error = error { throw error }
            return response
        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 "enrichTrackWithExtension":
            let args = call.arguments as! [String: Any]
            let extensionId = args["extension_id"] as! String
            let trackJson = args["track"] as? String ?? "{}"
            let response = GobackendEnrichTrackWithExtensionJSON(extensionId, trackJson, &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 URL Handler API
        case "handleURLWithExtension":
            let args = call.arguments as! [String: Any]
            let url = args["url"] as! String
            let response = GobackendHandleURLWithExtensionJSON(url, &error)
            if let error = error { throw error }
            return response
        case "findURLHandler":
            let args = call.arguments as! [String: Any]
            let url = args["url"] as! String
            let response = GobackendFindURLHandlerJSON(url)
            return response
        case "getURLHandlers":
            let response = GobackendGetURLHandlersJSON(&error)
            if let error = error { throw error }
            return response
        case "getAlbumWithExtension":
            let args = call.arguments as! [String: Any]
            let extensionId = args["extension_id"] as! String
            let albumId = args["album_id"] as! String
            let response = GobackendGetAlbumWithExtensionJSON(extensionId, albumId, &error)
            if let error = error { throw error }
            return response
        case "getPlaylistWithExtension":
            let args = call.arguments as! [String: Any]
            let extensionId = args["extension_id"] as! String
            let playlistId = args["playlist_id"] as! String
            let response = GobackendGetPlaylistWithExtensionJSON(extensionId, playlistId, &error)
            if let error = error { throw error }
            return response
        case "getArtistWithExtension":
            let args = call.arguments as! [String: Any]
            let extensionId = args["extension_id"] as! String
            let artistId = args["artist_id"] as! String
            let response = GobackendGetArtistWithExtensionJSON(extensionId, artistId, &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
        // Extension Store
        case "initExtensionStore":
            let args = call.arguments as! [String: Any]
            let cacheDir = args["cache_dir"] as! String
            GobackendInitExtensionStoreJSON(cacheDir, &error)
            if let error = error { throw error }
            return nil
        case "getStoreExtensions":
            let args = call.arguments as! [String: Any]
            let forceRefresh = args["force_refresh"] as? Bool ?? false
            let response = GobackendGetStoreExtensionsJSON(forceRefresh, &error)
            if let error = error { throw error }
            return response
        case "searchStoreExtensions":
            let args = call.arguments as! [String: Any]
            let query = args["query"] as? String ?? ""
            let category = args["category"] as? String ?? ""
            let response = GobackendSearchStoreExtensionsJSON(query, category, &error)
            if let error = error { throw error }
            return response
        case "getStoreCategories":
            let response = GobackendGetStoreCategoriesJSON(&error)
            if let error = error { throw error }
            return response
        case "downloadStoreExtension":
            let args = call.arguments as! [String: Any]
            let extensionId = args["extension_id"] as! String
            let destDir = args["dest_dir"] as! String
            let response = GobackendDownloadStoreExtensionJSON(extensionId, destDir, &error)
            if let error = error { throw error }
            return response
        case "clearStoreCache":
            GobackendClearStoreCacheJSON(&error)
            if let error = error { throw error }
            return nil
        // Extension Home Feed API
        case "getExtensionHomeFeed":
            let args = call.arguments as! [String: Any]
            let extensionId = args["extension_id"] as! String
            let response = GobackendGetExtensionHomeFeedJSON(extensionId, &error)
            if let error = error { throw error }
            return response
        case "getExtensionBrowseCategories":
            let args = call.arguments as! [String: Any]
            let extensionId = args["extension_id"] as! String
            let response = GobackendGetExtensionBrowseCategoriesJSON(extensionId, &error)
            if let error = error { throw error }
            return response
        default:
            throw NSError(
                domain: "SpotiFLAC",
@@ -1,122 +1 @@
-{
+{"images":[{"size":"20x20","idiom":"iphone","filename":"Icon-App-20x20@2x.png","scale":"2x"},{"size":"20x20","idiom":"iphone","filename":"Icon-App-20x20@3x.png","scale":"3x"},{"size":"29x29","idiom":"iphone","filename":"Icon-App-29x29@1x.png","scale":"1x"},{"size":"29x29","idiom":"iphone","filename":"Icon-App-29x29@2x.png","scale":"2x"},{"size":"29x29","idiom":"iphone","filename":"Icon-App-29x29@3x.png","scale":"3x"},{"size":"40x40","idiom":"iphone","filename":"Icon-App-40x40@2x.png","scale":"2x"},{"size":"40x40","idiom":"iphone","filename":"Icon-App-40x40@3x.png","scale":"3x"},{"size":"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"}}
  "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"
  }
 }
--- a/Show More
+++ b/Show More