chore: bump version to 3.1.3+62

- Add GetExtendedMetadataByISRC function in deezer.go
  - Searches track by ISRC then fetches album extended metadata
- Call enrichment in DownloadWithExtensionFallback before built-in download
  - Only enriches if genre/label are empty and ISRC is available
  - Logs enrichment results for debugging

.github/FUNDING.yml

@@ -0,0 +1 @@
+ko_fi: zarzet

.github/workflows/release.yml

@@ -345,6 +345,8 @@ jobs:
             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

.gitignore

@@ -6,6 +6,8 @@ Thumbs.db
 .idea/
 .vscode/
 *.iml
+.cursorignore
+.cursorrules
 
 # Kiro specs (development only)
 .kiro/
@@ -53,3 +55,20 @@ 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/

CHANGELOG.md

@@ -1,10 +1,717 @@
 # Changelog
 
-## [3.0.0-alpha.4] - Upcoming
+## [3.1.3] - 2026-01-19
+
+### Added
+
+- **External LRC Lyrics File Support**: Option to save lyrics as separate .lrc files for compatibility with external music players
+  - New "Lyrics Mode" setting in Settings > Download > Lyrics section
+  - Three modes available:
+    - **Embed in file** (default): Lyrics stored inside FLAC metadata
+    - **External .lrc file**: Save lyrics as separate .lrc file next to audio file
+    - **Both**: Embed and save external .lrc file
+  - Perfect for players like Samsung Music that prefer external .lrc files
+  - LRC files include metadata headers (title, artist, by:SpotiFLAC-Mobile)
+  - Works with all download services (Tidal, Qobuz, Amazon)
+
+- **CSV Import Quality Selection**: Choose audio quality when importing CSV playlists
+  - Quality picker now appears before adding CSV tracks to download queue
+  - Select between FLAC qualities (Lossless, Hi-Res, Hi-Res Max) or MP3
+  - Respects "Ask quality before download" setting - uses default quality if disabled
+
+  - **Persistent Cover Image Cache**: Album/track cover images now cached to persistent storage instead of temporary directory
+  - Cover images no longer disappear when app is closed or device restarts
+  - Cache stored in `app_flutter/cover_cache/` directory (not cleared by system)
+  - Maximum 1000 images cached for up to 365 days
+  - Covers are cached when displayed in History, Home, Album, Artist, or any other screen
+  - New `CoverCacheManager` service with `clearCache()` and `getStats()` methods for future cache management
+
+- **Extended Metadata from Deezer Enrichment**: Track downloads now include label, copyright, and genre metadata from Deezer
+  - New fields in `ExtTrackMetadata`: `label`, `copyright`, `genre`
+  - Metadata fetched during `enrichTrack()` via Deezer album API
+  - Embedded as FLAC Vorbis comments: `GENRE`, `ORGANIZATION` (label), `COPYRIGHT`
+  - Works for both extension downloads and built-in provider downloads (Tidal, Qobuz, Amazon)
+
+- **Track Metadata Screen Extended Info**: Genre, label, and copyright now displayed in track metadata screen
+  - Added `genre`, `label`, `copyright` fields to `DownloadHistoryItem` model
+  - Metadata is stored in download history and persists across app restarts
+  - New localization strings: `trackGenre`, `trackLabel`, `trackCopyright`
+
+- **`utils.randomUserAgent()` for Extensions**: New utility function for extensions to get random browser User-Agent strings
+  - 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
+
+- **Portuguese Language Bug**: Fixed locale parsing for languages with country codes (e.g., pt_PT, es_ES)
+  - App now correctly loads Portuguese and Spanish translations
+  - Updated Portuguese label to "Português (Brasil)"
+
+- **VM Race Condition Panic**: Fixed `panic during execution: runtime error: index out of range [-2]` crash when switching search providers
+  - Root cause: Goja VM was being accessed concurrently by multiple goroutines without synchronization
+  - Added `VMMu sync.Mutex` to `LoadedExtension` struct
+  - 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
+
+- **Tidal Release Date Fallback**: Fixed missing release date in FLAC metadata when downloading from Tidal
+  - Now uses Tidal API's release date when `req.ReleaseDate` is empty
+  - Ensures release date is always embedded in downloaded files
+
+- **Extended Metadata for M4A→FLAC Conversion**: Fixed genre, label, and copyright not being embedded when converting Amazon M4A to FLAC
+  - Flutter now extracts extended metadata from Go backend response
+  - Passes `genre`, `label`, `copyright` parameters to `_embedMetadataAndCover()`
+  - Tags correctly embedded during FFmpeg conversion
+
+- **Extended Metadata for MP3 Conversion**: Genre, label, and copyright now embedded in MP3 files when converting from FLAC
+  - Added `genre`, `label`, `copyright` parameters to `_embedMetadataToMp3()`
+  - Tags embedded as ID3v2: `GENRE`, `ORGANIZATION` (label), `COPYRIGHT`
+
+### Extensions
+
+- **spotify-web Extension**: Updated to v1.7.0
+  - Added `getMetadataFromDeezer()` function to fetch extended metadata:
+    - ISRC from track
+    - Label from album
+    - Copyright (generated as "YEAR LABEL")
+    - Genre from album genres
+    - Release date
+  - `enrichTrack()` now returns all extended metadata to Go backend
+  - Replaced all hardcoded User-Agent strings with `utils.randomUserAgent()`
+
+### Performance
+
+- **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
+
+- **New Languages**: Added Spanish (es) and Portuguese (pt) translations
+  - Spanish: Credits 125 ([@credits125](https://crowdin.com/profile/credits125))
+  - Portuguese: Pedro Marcondes ([@justapedro](https://crowdin.com/profile/justapedro))
+  - Russian: Владислав ([@odinokiy_kot](https://crowdin.com/profile/odinokiy_kot))
+
+- **Quick Search Provider Switcher** ([#76](https://github.com/zarzet/SpotiFLAC-Mobile/issues/76)): Dropdown menu in search bar for instant provider switching
+  - Tap the search icon to reveal a dropdown menu with all available search providers
+  - Shows default provider (Deezer based on metadata source setting) at the top
+  - 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
+
+- **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
+
+- **Lyrics Caching**: Lyrics are now cached for 24 hours to reduce API calls and improve performance
+  - Thread-safe cache with automatic expiration
+  - Cache key based on artist, track, and duration
+  - Log indicator shows "(cached)" when lyrics are served from cache
+
+- **Lyrics Duration Matching**: Improved lyrics accuracy with duration-based matching
+  - Compares track duration with lrclib.net results
+  - 10-second tolerance to handle version differences (radio edit, remaster, etc.)
+  - Prioritizes synced lyrics over plain text when duration matches
+  - Falls back gracefully if no duration match found
+
+- **Deezer Cover Art Upgrade**: Cover art from Deezer CDN now automatically upgraded to maximum quality
+  - Detects Deezer CDN URLs (`cdn-images.dzcdn.net`)
+  - Upgrades cover resolution to 1800x1800 (max available)
+  - Works alongside existing cover upgrade
+
+- **Live Search for Extensions**: Search-as-you-type functionality for extension search
+  - 800ms debounce delay to prevent excessive API calls
+  - Minimum 3 characters required before searching
+  - Concurrency control to prevent race conditions in extension runtime
+  - Queues pending searches if a search is already in progress
+
+- **Russian Language Support**: Added Russian (Русский) translation - 99% complete
+  - Translated via Crowdin community contributions
+  - Covers all UI elements, settings, and error messages
+
+### Fixed
+
+- **ISRC Index Race Condition**: Fixed repeated index rebuilding during parallel downloads
+  - Added per-directory build lock using `sync.Map` and `sync.Mutex`
+  - Double-check locking pattern ensures index is built only once
+  - Significantly improves performance during CSV import with many tracks
+
+- **Queue Tab Scroll Exception**: Fixed Flutter rendering exception with NestedScrollView
+  - Disabled Material 3 stretch overscroll indicator that caused `_StretchController` assertion
+  - Wrapped NestedScrollView with ScrollConfiguration to prevent `setState during build` errors
+  - Issue was especially noticeable during rapid queue updates (CSV import)
+
+- **CSV Import**: Fixed CSV export not being parsed correctly
+  - Added support for `Artist Name(s)` header (with parentheses)
+  - Added support for `Track URI` header for track IDs
+  - Added `artists` and `track_id` as alternative header names
+  - Now correctly parses "Liked Songs" and playlist exports
+
+---
+
+## [3.1.0] - 2026-01-16
+
+### Added
+
+- **Recent Access History**: Quick access to recently visited content when tapping the search bar
+  - Shows recently visited artists, albums, playlists, and downloaded tracks
+  - Merged view combining navigation history and download history
+  - Tap to quickly navigate back to previously accessed content
+  - X button to remove individual items from history
+  - "Clear All" button to clear entire history
+  - Persists across app restarts (stored in SharedPreferences)
+  - Max 20 items stored, sorted by most recent
+  - Multi-language support (Artist/Album/Song/Playlist labels localized)
+
+- **Artist Screen Redesign**
+  - Full-width header image (380px) with gradient overlay
+  - Artist name displayed at bottom of header with text shadow
+  - Monthly listeners count display (formatted with compact notation)
+  - "Popular" section showing top 5 tracks with download status indicators
+  - Dynamic download button states (queued, downloading, completed)
+  - Header image and top tracks fetched from extension metadata
+  - Image alignment set to top-center to show faces properly
+
+- **Extension Store Update Badge**: Badge indicator on Store tab icon showing number of available updates
+  - Users can see extension updates are available without opening Store tab
+  - Badge shows count of extensions with updates
+
+- **Extension Compatibility Warning**: Warning badge for extensions requiring newer app version
+  - Extensions with `minAppVersion` higher than current app show warning label
+  - Label displays "Requires vX.X.X+" to encourage users to upgrade
+  - Users can still install the extension (not blocked)
+
+- **Year in Album Folder Name** ([#50](https://github.com/zarzet/SpotiFLAC-Mobile/issues/50)): New album folder structure options with release year
+
+  - `Artist / [Year] Album`: Albums/Coldplay/[2005] X&Y/
+  - `[Year] Album Only`: Albums/[2005] X&Y/
+  - Year extracted from release date metadata
+  - Matches desktop SpotiFLAC folder structure
+
+- **Extension Album/Playlist/Artist Support**: Extensions can now return albums, playlists, and artists in search results
+
+  - Search results now properly separated into Albums, Playlists, Artists, and Songs sections
+  - Albums, playlists, and artists show chevron icon (navigate to detail) instead of download button
+  - Tap album/playlist to view track list and download
+  - Tap artist to view their albums/discography
+  - New `getAlbum()`, `getPlaylist()`, and `getArtist()` extension functions
+  - New `ExtensionAlbumScreen`, `ExtensionPlaylistScreen`, and `ExtensionArtistScreen` for fetching content from extensions
+  - YouTube Music extension updated with album/playlist/artist support
+
+- **Odesli (song.link) Integration for YouTube Music Extension**
+  - New `enrichTrack()` function to fetch ISRC and external service links
+  - Uses Odesli API to convert YouTube Music tracks to Deezer/Tidal/Qobuz
+  - Enables built-in service fallback for high-quality audio downloads
+  - Extension version updated to 1.4.0 with `api.song.link` and `odesli.io` network permissions
+- **Download Cancel**: Canceling a download now stops in-flight built-in provider downloads (Tidal/Qobuz/Amazon) and clears backend progress tracking.
+
+### Changed
+
+- **Search Bar Behavior**: Tapping search bar now immediately moves it to top position
+  - Logo and subtitle hide when search bar is focused
+  - Recent access history appears in the content area below
+  - More space for recent items, not blocked by keyboard
+
+### Fixed
+
+- Fixed search source chips still referencing removed badge props.
+- Fixed extension artist album metadata to preserve provider IDs and cover URLs for correct navigation.
+- Fixed extension playlist fetch to populate provider IDs and reject disabled extensions.
+- Fixed extension collection screens calling setState after dispose during async loads.
+- Fixed URL handler responses to include provider IDs for extension albums and artists.
+- Fixed YTMusic extension not extracting album name and duration from search results.
+  - Album name is now extracted from flexColumns/subtitle when linked to album browseId.
+  - Duration is now extracted from fixedColumns/flexColumns in addition to existing sources.
+- Fixed "Separate Singles" setting not working ([#54](https://github.com/zarzet/SpotiFLAC-Mobile/issues/54)) - singles were going to Albums folder.
+  - Root cause: `albumType` was not being extracted from Deezer API during metadata enrichment.
+  - Deezer track responses now correctly include `album_type` (single/ep/album/compilation).
+  - Track creation now preserves `albumType` and `source` fields throughout download flow.
+- Fixed PageView overscroll at edges (BouncingScrollPhysics → ClampingScrollPhysics)
+- Fixed settings item highlight on swipe (highlightColor: Colors.transparent)
+- Fixed extension duplicate load error (skip silently instead of throwing error)
+- Fixed keyboard appearing when swiping between tabs (unfocus on page change)
+- Removed "Free"/"API Key" badges from search source selector
+- Fixed cancel action briefly resuming downloads in the queue UI after ~1 second.
+- Fixed cancelled downloads being marked as failed when the backend returns after cancellation.
+- Fixed cancel triggering provider fallback (cancel now stops the download flow immediately).
+- Fixed stale ISRC cache returning deleted files after cancel.
+- Fixed search results mixing extension and built-in artists when using default provider.
+- Fixed audio files opening with non-music apps by passing audio MIME type on open.
+- Fixed album artist showing null/blank by normalizing empty metadata and using artist fallback for tags.
+- Fixed `use_build_context_synchronously` lint warnings in `home_tab.dart`
+- Fixed `unnecessary_underscores` lint warnings in error widget callbacks
+- Fixed duplicate artist entries in recent history (recording now only happens in screen's initState)
+- **Go Backend: Missing `item_type` and `album_type` fields**
+  - Added `ItemType` and `AlbumType` fields to `ExtTrackMetadata` struct
+  - Fixed `CustomSearchWithExtensionJSON` - now includes `item_type` and `album_type` in response
+  - Fixed `HandleURLWithExtensionJSON` - now includes `item_type` and `album_type` for tracks
+  - Fixed `GetAlbumWithExtensionJSON` - now includes `item_type` and `album_type` for album tracks
+  - Fixed `GetPlaylistWithExtensionJSON` - now includes `item_type` and `album_type` for playlist tracks
+- **Album/Playlist Track Thumbnails**: Tracks inside albums/playlists now use album/playlist cover as fallback when no individual cover exists
+- **YouTube Music Extension getArtist**: Fixed `getArtist()` function not being registered in extension, causing artist pages to fail with "returned null" error
+- **Recent Access UI**: Fixed recent access list disappearing when keyboard is dismissed - now stays visible until user presses Back button
+- **Extension Artist Top Tracks**: Fixed top tracks not appearing when opening artist from extension search results
+  - YT Music extension `getArtist()` now returns `top_tracks` array with up to 10 popular songs
+  - Go backend `GetArtistWithExtensionJSON` now forwards `top_tracks`, `header_image`, and `listeners` to Flutter
+  - `ExtensionArtistScreen` now parses and passes top tracks to `ArtistScreen`
+  - `ArtistScreen` with `extensionId` skips metadata fetch, uses extension data only (fixes "Rate Limited" errors)
+- **Search Bar Unfocus**: Fixed search bar not unfocusing when tapping outside - now properly dismisses keyboard and unfocus when tapping anywhere outside the search field
+- **Keyboard Appearing on Settings Navigation**: Fixed keyboard randomly appearing when returning from Settings sub-pages (e.g., Appearance) - now uses `FocusManager.instance.primaryFocus?.unfocus()` for more aggressive unfocus
+- **Recent Access Artist Navigation**: Fixed opening artist from recent access using wrong screen - now correctly uses `ExtensionArtistScreen` for extension artists (YT Music, etc.) instead of trying to fetch from API
+
+### Extensions
+
+- **YouTube Music Extension**: Updated to v1.5.0
+  - `getArtist()` now returns `top_tracks` array with popular songs
+  - Added `header_image` and `listeners` to artist response
+- **Web Extension**: Updated to v1.6.0
+
+### Localization
+
+- **Multi-Language Support**: App now supports multiple languages with community contributions via Crowdin
+  - Available languages: English, Indonesian (Bahasa Indonesia)
+  - More languages coming soon with community translations
+  - Contribute translations at [Crowdin](https://crowdin.com/project/spotiflac-mobile)
+- Added new localization strings for recent access types:
+  - `recentTypeArtist` - "Artist" / "Artis"
+  - `recentTypeAlbum` - "Album" / "Album"
+  - `recentTypeSong` - "Song" / "Lagu"
+  - `recentTypePlaylist` - "Playlist" / "Playlist"
+  - `recentPlaylistInfo` - "Playlist: {name}"
+  - `errorGeneric` - "Error: {message}"
+
+---
+
+## [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
+- New "Store" tab in bottom navigation
+- Browse by category: Metadata, Download, Utility, Lyrics, Integration
+- Search extensions by name, description, or tags
+- One-tap install, update, and uninstall
+- Offline cache for browsing without internet
+
+#### Web Extension
+
+- Available in Extension Store - install and enable in Settings > Extensions
+- Metadata provider using web player API
+- Download tracks from Daily Mix, Discover Weekly, and other personalized playlists
+- Useful when official API is rate-limited or unavailable
+
+#### Extension Capabilities
+
+- **Custom Search Providers**
+- **Custom URL Handlers**
+- **Custom Thumbnail Ratios**: Square (1:1), Wide (16:9), Portrait (2:3)
+- **Post-Processing Hooks**: Extensions can process downloaded files
+- **Quality Options**: Extensions can define custom quality settings
+
+#### Extension APIs
+
+- Full HTTP support: GET, POST, PUT, DELETE, PATCH
+- Persistent cookie jar per extension
+- Browser-like polyfills: `fetch()`, `atob()`/`btoa()`, `TextEncoder`/`TextDecoder`, `URL`/`URLSearchParams`
+- Storage API for persistent data
+- File API for file operations
+- HMAC-SHA1 utility for cryptographic operations
+
+#### Security
+
+- Sandboxed JavaScript runtime (goja)
+- Permission-based access control
+- Network domain whitelisting
+- Improved credential encryption with per-installation random salt
+
+### Added
+
+- **Album Folder Structure Setting**: Option to remove artist folder from album path
+
+  - `Artist / Album` (default): `Albums/Artist Name/Album Name/`
+  - `Album Only`: `Albums/Album Name/`
+
+- **Separate Singles Folder**: Organize downloads into Albums/ and Singles/ folders
+
+  - Based on `album_type` from metadata
+  - Toggle in Settings > Download > Separate Singles Folder
+
+- **Year in Album Folder Name**: New album folder structure options with release year
+
+  - `Artist / [Year] Album`: Albums/Coldplay/[2005] X&Y/
+  - `[Year] Album Only`: Albums/[2005] X&Y/
+  - Year extracted from release date metadata
+  - Matches desktop SpotiFLAC folder structure
+
+- **Parallel API Calls**: Download URL fetching now uses parallel requests
+  - Tidal: All 8 APIs requested simultaneously, first success wins
+  - Qobuz: Both APIs requested simultaneously, first success wins
+  - Significantly reduces download URL fetch time
+
+### UI/UX Improvements
+
+- **Swipeable History Filters**: History tab now supports swipe gestures between All, Albums, and Singles filters
+
+  - Swipe left/right to switch between filter tabs
+  - Filter chips sync with swipe position
+  - Smooth edge-to-edge transition: swipe past Singles to go to Store, swipe past All to go to Home
+  - Natural gesture feel - drag connects to parent navigation
+
+  - **Improved File Open Intent**: Play button in History now correctly opens music players only
+  - Added proper MIME type (`audio/flac`, `audio/mpeg`, etc.) when opening downloaded files
+  - Prevents system from showing unrelated apps in the "Open with" dialog
+
+### Fixed
+
+- **Fixed Tab Edge Overscroll**: Home and Settings tabs now stop at edges instead of bouncing into empty space
+
+- **Fixed Extension Duplicate Load Error**: Extension loading now silently skips already-loaded extensions instead of throwing error
+
+- **Fixed Settings Item Highlight on Swipe**: Settings items no longer highlight when swiping at page edge
+
+- **Fixed Keyboard Appearing on Tab Switch**: Keyboard now auto-dismisses when swiping between tabs
+
+- **Removed Search Source Badges**: Removed "Free" and "API Key" labels from provider selector in Options
+
+- **Back Gesture Freeze on Android 13+**: Fixed app freeze when using back gesture in settings
+
+  - Added `PopScope` with `canPop: true` to all settings pages
+  - Changed navigation to use `PageRouteBuilder` with proper slide transition
+
+- **Bottom Overflow in Folder Organization Dialog**: Fixed overflow in portrait and landscape mode
+
+  - Made dialog scrollable with max height constraint
+
+- **Japanese Artist Name Order**: Fixed artist mismatch for Japanese names
+
+  - "Sawano Hiroyuki" vs "Hiroyuki Sawano" now correctly matches
+
+- **Multi-Artist Matching**: Fixed artist mismatch for collaboration tracks
+
+  - "RADWIMPS feat. Toko Miura" now matches when service only shows "Toko Miura"
+
+- **Max Resolution Cover Download**: Fixed cover not upgrading to max resolution on mobile
+
+  - Mobile now correctly upgrades 300x300 → 640x640 → max resolution (~2000x2000)
+
+- **EXISTS: Prefix in File Path**: Fixed "File not found" error in metadata screen
+
+  - Duplicate detection prefix now stripped before saving to history
+
+- **Extension Search Result Parsing**: Fixed "cannot unmarshal array" error
+
+  - Go backend now handles both array and object formats from extensions
+
+- **Store Tab Unmount Crash**: Fixed "Using ref when widget is unmounted" error
+
+- **Duplicate History Entries**: Fixed duplicate entries when re-downloading same track
+
+  - Detects existing entries by track ID, Deezer ID, or ISRC
+
+- **Permission Error Message**: Fixed download showing "Song not found" when actually permission error
+
+  - Now shows proper message: "Cannot write to folder, check storage permission"
+
+- **Android 13+ Storage Permission**: Fixed storage permission not working on Android 13+
+  - Now requests both `MANAGE_EXTERNAL_STORAGE` and `READ_MEDIA_AUDIO`
+
+### Changed
+
+- **Extension Manifest**: New `file` permission required for file operations
+  ```json
+  "permissions": {
+    "network": ["api.example.com"],
+    "storage": true,
+    "file": true
+  }
+  ```
+
+### Technical
+
+- Go backend: Simplified parallel download result handling in Tidal/Qobuz
+- Go backend: Removed unused functions and fixed bit shifting warnings
+- Release workflow: Fixed duplicate `---` separator in release notes
+
+---
+
+## [3.0.0-beta.2] - 2026-01-13
+
+### Added
+
+- **Album Folder Structure Setting**: Option to remove artist folder from album path
+  - New setting in Download Settings when "Separate Singles Folder" is enabled
+  - `Artist / Album` (default): `Albums/Artist Name/Album Name/`
+  - `Album Only`: `Albums/Album Name/`
+  - Requested by user who prefers flat album organization
+
+### Fixed
+
+- **Back Gesture Freeze on OnePlus/Android 13+**: Fixed app freeze when using back gesture in settings
+
+  - Added `PopScope` with `canPop: true` to all settings pages
+  - Changed navigation to use `PageRouteBuilder` with proper slide transition
+  - Fixes predictive back gesture conflict on devices with gesture navigation
+  - Affected pages: Download, Appearance, Options, Extensions, About, Logs, Extension Detail
+
+- **Extension Search Result Parsing**: Fixed "cannot unmarshal array into Go value" error
+
+  - Go backend now handles both array and object formats from extensions
+  - Extensions returning `[{track}, {track}]` now work correctly
+  - Extensions returning `{tracks: [...], total: N}` still work as before
+
+- **Max Resolution Cover Download**: Fixed cover not upgrading to max resolution on mobile
+
+  - Added missing `spotifySize300` constant (300x300 size code)
+  - Mobile now correctly upgrades 300x300 → 640x640 → max resolution (~2000x2000)
+  - Added `_upgradeToMaxQualityCover()` helper in Flutter for M4A conversion path
+  - Go backend `cover.go` now directly replaces URL without HEAD verification
+
+- **Extension Search Provider Reset**: Fixed search provider not resetting to default when disabled
+
+  - `copyWith` in `AppSettings` couldn't set `searchProvider` to `null`
+  - Added `clearSearchProvider` boolean parameter to properly clear the value
+  - Settings menu now correctly switches back to default provider
+
+- **Extension Disabled Search Fallback**: Fixed error when extension is disabled but still called
+
+  - `_performSearch` now checks if extension is still enabled before calling custom search
+  - Automatically falls back to Deezer search if extension was disabled
+  - Clears `searchProvider` setting if extension no longer available
+
+- **Store Tab Unmount Crash**: Fixed "Using ref when widget is unmounted" error
+
+  - Added `mounted` check after async operation in `_initialize()`
+  - Prevents crash when navigating away from Store tab during initialization
+
+- **EXISTS: Prefix in File Path**: Fixed "File not found" error in metadata screen after download
+
+  - Duplicate detection was adding `EXISTS:` prefix to file paths
+  - Prefix now stripped before saving to download history
+  - Legacy history items with prefix are handled gracefully
+
+- **History Error Badge**: Fixed error badge showing on history items even when file exists
+
+  - `queue_tab.dart` now strips `EXISTS:` prefix before checking file existence
+  - File open and delete operations also use cleaned path
+
+- **Extension Artist URL Handler**: Fixed artist pages showing "0 releases" from extensions
+
+  - Extension `fetchArtist` now returns correct format: `{ type: "artist", artist: { albums } }`
+  - Go backend `HandleURLWithExtensionJSON` now includes albums in artist response
+  - Added `AlbumType` field to `ExtAlbumMetadata` struct
+
+- **Extension Artist Name in Logs**: Fixed empty artist name in extension track logs
+
+  - Now uses `firstArtist` + `otherArtists` instead of deprecated `artists.items`
+  - Logs correctly show "Fetched track: {title} by {artist}"
+
+- **Japanese Artist Name Order**: Fixed artist mismatch for Japanese names with different order
+
+  - "Sawano Hiroyuki" vs "Hiroyuki Sawano" now correctly matches
+  - Added `sameWordsUnordered` check to both Tidal and Qobuz artist matching
+  - Handles Japanese name order (family name first) vs Western name order (given name first)
+
+- **Multi-Artist Matching**: Fixed artist mismatch for collaboration tracks
+
+  - "RADWIMPS feat. Toko Miura" now matches when Qobuz/Tidal only shows "Toko Miura"
+  - Split artists by separators (`, `, `feat.`, `ft.`, `&`, `and`, `x`)
+  - Match if ANY expected artist matches ANY found artist
+
+- **Cover Download Logging**: Improved cover download logs for debugging
+  - Shows original URL, upgrade steps, and final URL
+  - Displays estimated resolution based on file size
+  - Logs now appear in Settings > Logs via GoLog
+
+---
+
+## [3.0.0-beta.1] - 2026-01-13
+
+### Security
+
+- Improved extension sandbox security
+- Improved credential encryption with per-installation random salt
+
+### Changed
+
+- **Extension Manifest**: New `file` permission required for file operations
+  ```json
+  "permissions": {
+    "network": ["api.example.com"],
+    "storage": true,
+    "file": true
+  }
+  ```
+  Extensions that need to download files must declare `"file": true` in manifest.
+
+### Fixed
+
+- Extension packages now preserve directory structure (subdirectories supported)
+- Back gesture freeze in settings pages on Android gesture navigation
+
+---
+
+## [3.0.0-alpha.4] - 2026-01-12
 
 ### Added
 
 - **Extension Store**: Browse and install extensions directly from the app
+
   - New "Store" tab in bottom navigation
   - Browse extensions by category (Metadata, Download, Utility, Lyrics, Integration)
   - Search extensions by name, description, or tags
@@ -13,13 +720,15 @@
   - Extensions hosted at github.com/zarzet/SpotiFLAC-Extension
 
 - **Custom URL Handler for Extensions**: Extensions can now register custom URL patterns
+
   - Handle URLs from YouTube Music, SoundCloud, Bandcamp, etc.
   - Manifest config: `urlHandler: { enabled: true, patterns: ["music.youtube.com"] }`
-  - Implement `handleURL(url)` function in extension to parse and return track metadata
+  - Implement `handleUrl(url)` function in extension to parse and return track metadata
   - SpotiFLAC automatically routes matching URLs to the appropriate extension
   - Supports share intents and paste from clipboard
 
 - **Artist URL Handler Support**: Extensions can now return artist data from URL handlers
+
   - Added `type: "artist"` handling in track_provider.dart
   - Navigate to artist screen with albums list from extension
 
@@ -36,13 +745,13 @@
 
 - Updated `docs/EXTENSION_DEVELOPMENT.md`:
   - Added Custom URL Handler section with examples
-  - Added `handleURL` function documentation
+  - Added `handleUrl` function documentation
   - Added URL pattern examples for YouTube, SoundCloud, Bandcamp
   - Added `utils.hmacSHA1` documentation with TOTP example
 
 ### Extensions
 
-- **Spotify Web Extension** (example): New extension for Spotify metadata via web API
+- **Web Extension** (example): New extension for metadata via web API
   - Supports personalized playlists (Daily Mix, Discover Weekly, Release Radar, etc.)
   - Search, album, playlist, track, and artist fetching
   - Available in Extension Store (3.0.0-alpha.4)
@@ -54,7 +763,7 @@
 ### Added
 
 - **Separate Singles Folder**: Option to organize downloads into Albums/ and Singles/ folders
-  - Based on `album_type` from Spotify/Deezer metadata
+  - Based on `album_type` from metadata
   - Toggle in Settings > Download > Separate Singles Folder
   - Singles saved to `{output}/Singles/`, albums to `{output}/Albums/`
 - **Browser-like Polyfills**: New global APIs for easier library porting
@@ -74,7 +783,7 @@
 ### Fixed
 
 - **Duplicate History Entries**: Fixed duplicate entries when re-downloading same track
-  - Detects existing entries by Spotify ID, Deezer ID, or ISRC
+  - Detects existing entries by track ID, Deezer ID, or ISRC
   - Replaces existing entry and moves to top of list
   - Auto-deduplicates existing history on app load
 - **Extension Search Fallback**: Fixed error when extension is disabled but still called for search
@@ -97,7 +806,7 @@
 
 - **Full HTTP Method Support**: New shortcut methods for all common HTTP verbs
   - `http.put(url, body, headers)` - PUT requests
-  - `http.delete(url, headers)` - DELETE requests  
+  - `http.delete(url, headers)` - DELETE requests
   - `http.patch(url, body, headers)` - PATCH requests
   - `http.clearCookies()` - Clear all cookies for the extension
 - **Persistent Cookie Jar**: Each extension now has its own cookie jar
@@ -139,6 +848,7 @@
 ## [3.0.0-alpha.1] - 2026-01-11
 
 #### Extension System
+
 - **Custom Search Providers**: Extensions can now provide custom search functionality
   - YouTube, SoundCloud, and other platforms via extensions
   - Custom search placeholder text per extension
@@ -217,16 +927,6 @@
 - **Android Changes**:
   - `android/app/src/main/kotlin/com/zarz/spotiflac/MainActivity.kt`: Already had upgrade methods
 
-### Documentation
-
-- Updated `docs/EXTENSION_DEVELOPMENT.md`:
-  - Added thumbnail ratio customization section
-  - Added extension upgrade documentation
-  - Added settings fields table with `secret` field
-  - Added new troubleshooting entries
-  - Updated table of contents
-  - Updated changelog
-
 ---
 
 ## [2.2.8] - 2026-01-12

CODE_OF_CONDUCT.md

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

CONTRIBUTING.md

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

README.md

@@ -1,11 +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/09c6260e9ebaf2ff0d15f30deda939642f41887f11aad602ac697cb37fa0308c/)
+[![VirusTotal](https://img.shields.io/badge/VirusTotal-Safe-brightgreen?style=for-the-badge&logo=virustotal)](https://www.virustotal.com/gui/file/e1c527eacb6f5ce527af214a75aab8da060c2afc629825fff24af858439e7e6b)
+[![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)
@@ -23,62 +24,60 @@ Get Spotify tracks in true FLAC from Tidal, Qobuz & Amazon Music — no account
   <img src="assets/images/4.jpg?v=2" width="200" />
 </p>
 
-## Metadata Source
+## Search Source
 
-SpotiFLAC supports two metadata sources for searching tracks:
+SpotiFLAC supports multiple search sources for finding music metadata:
 
-| Source | Pros | Cons |
-|--------|------|------|
-| **Deezer** (Default) | No developer account needed, rate limit per user IP | Slightly less comprehensive catalog |
-| **Spotify** | More comprehensive catalog, better search results | Requires developer API credentials to avoid rate limiting |
+| Source | Setup |
+|--------|-------|
+| **Deezer** (Default) | No setup required |
+| **Extensions** | Install additional search providers from the Store |
 
-### Using Spotify
-To use Spotify as your search source without hitting rate limits:
-1. Create a Spotify Developer account at [developer.spotify.com](https://developer.spotify.com)
-2. Create an app to get your Client ID and Client Secret
-3. Go to **Settings > Options > Spotify API > Change from Deezer to Spotify > Input Custom Credentials**
-4. Enter your Client ID and Secret
-5. Change **Search Source** to Spotify
+## Extensions
 
-## Extensions (Alpha)
-
-> **Alpha Feature**: Extensions are now available in alpha. Some features may be unstable or change in future releases.
-
-SpotiFLAC supports extensions to add custom metadata and download providers. Extensions are written in JavaScript and run in a secure sandbox.
-
-### Features
-- **Metadata Providers**: Add new sources for track/album/artist search
-- **Download Providers**: Add new sources for audio downloads
-- **Custom Settings**: Extensions can have user-configurable settings
-- **Provider Priority**: Set the order in which providers are tried
+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. Download a `.spotiflac-ext` file
-2. Go to **Settings > Extensions**
-3. Tap **Install Extension** and select the file
+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](docs/EXTENSION_DEVELOPMENT.md) for complete documentation.
-
-### Example Extensions
-Sample extensions are available in the [docs/extensions_example](docs/extensions_example) folder:
+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
+
+## 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).
 
 [![Ko-fi](https://img.shields.io/badge/Ko--fi-Support%20Me-FF5E5B?style=for-the-badge&logo=ko-fi&logoColor=white)](https://ko-fi.com/zarzet)
 
 ## Disclaimer
 
-> **iOS Support**: This app is primarily tested on Android. iOS support is experimental and may have bugs — the developer is too poor to afford an iPhone for proper testing. If you encounter issues on iOS, please report them!
-
 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.

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

@@ -117,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) {
@@ -151,8 +158,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)
                         }
@@ -161,8 +169,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)
                         }
@@ -275,6 +284,13 @@ class MainActivity: FlutterActivity() {
                             }
                             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") ?: ""
@@ -429,6 +445,14 @@ class MainActivity: FlutterActivity() {
                             }
                             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
@@ -572,6 +596,30 @@ class MainActivity: FlutterActivity() {
                             }
                             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") ?: ""

build_assets/ffmpeg_service_ios.dart

@@ -42,17 +42,27 @@ class FFmpegServiceIOS {
   }
 
   /// Convert FLAC to MP3
-  static Future<String?> convertFlacToMp3(String inputPath, {String bitrate = '320k'}) async {
-    final dir = File(inputPath).parent.path;
-    final baseName = inputPath.split(Platform.pathSeparator).last.replaceAll('.flac', '');
-    final outputDir = '$dir${Platform.pathSeparator}MP3';
-    await Directory(outputDir).create(recursive: true);
-    final outputPath = '$outputDir${Platform.pathSeparator}$baseName.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) return outputPath;
+    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;
   }
@@ -177,6 +187,123 @@ class FFmpegServiceIOS {
     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 {

crowdin.yml

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

go_backend/amazon.go

@@ -2,8 +2,10 @@ package gobackend
 
 import (
 	"bufio"
+	"context"
 	"encoding/base64"
 	"encoding/json"
+	"errors"
 	"fmt"
 	"io"
 	"net/http"
@@ -15,20 +17,18 @@ import (
 	"time"
 )
 
-// AmazonDownloader handles Amazon Music downloads using DoubleDouble service (same as PC)
 type AmazonDownloader struct {
 	client           *http.Client
-	regions          []string  // us, eu regions for DoubleDouble service
-	lastAPICallTime  time.Time // Rate limiting: track last API call
-	apiCallCount     int       // Rate limiting: counter per minute
-	apiCallResetTime time.Time // Rate limiting: reset time
+	regions          []string
+	lastAPICallTime  time.Time
+	apiCallCount     int
+	apiCallResetTime time.Time
 }
 
 var (
-	// Global Amazon downloader instance for connection reuse
 	globalAmazonDownloader *AmazonDownloader
 	amazonDownloaderOnce   sync.Once
-	amazonRateLimitMu      sync.Mutex // Mutex for rate limiting
+	amazonRateLimitMu      sync.Mutex
 )
 
 // DoubleDoubleSubmitResponse is the response from DoubleDouble submit endpoint
@@ -37,7 +37,6 @@ type DoubleDoubleSubmitResponse struct {
 	ID      string `json:"id"`
 }
 
-// DoubleDoubleStatusResponse is the response from DoubleDouble status endpoint
 type DoubleDoubleStatusResponse struct {
 	Status         string `json:"status"`
 	FriendlyStatus string `json:"friendlyStatus"`
@@ -48,22 +47,18 @@ 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]
@@ -78,13 +73,10 @@ func amazonArtistsMatch(expectedArtist, foundArtist string) bool {
 		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 {
@@ -95,7 +87,6 @@ func amazonArtistsMatch(expectedArtist, foundArtist string) bool {
 	return false
 }
 
-// amazonIsASCIIString checks if a string contains only ASCII characters
 func amazonIsASCIIString(s string) bool {
 	for _, r := range s {
 		if r > 127 {
@@ -105,7 +96,6 @@ func amazonIsASCIIString(s string) bool {
 	return true
 }
 
-// NewAmazonDownloader creates a new Amazon downloader (returns singleton for connection reuse)
 func NewAmazonDownloader() *AmazonDownloader {
 	amazonDownloaderOnce.Do(func() {
 		globalAmazonDownloader = &AmazonDownloader{
@@ -118,20 +108,17 @@ func NewAmazonDownloader() *AmazonDownloader {
 }
 
 // waitForRateLimit implements rate limiting similar to PC version
-// Max 9 requests per minute with 7 second delay between requests
 func (a *AmazonDownloader) waitForRateLimit() {
 	amazonRateLimitMu.Lock()
 	defer amazonRateLimitMu.Unlock()
 
 	now := time.Now()
 
-	// Reset counter every minute
 	if now.Sub(a.apiCallResetTime) >= time.Minute {
 		a.apiCallCount = 0
 		a.apiCallResetTime = now
 	}
 
-	// If we've hit the limit (9 requests per minute), wait until next minute
 	if a.apiCallCount >= 9 {
 		waitTime := time.Minute - now.Sub(a.apiCallResetTime)
 		if waitTime > 0 {
@@ -142,7 +129,6 @@ func (a *AmazonDownloader) waitForRateLimit() {
 		}
 	}
 
-	// Add delay between requests (7 seconds like PC version)
 	if !a.lastAPICallTime.IsZero() {
 		timeSinceLastCall := now.Sub(a.lastAPICallTime)
 		minDelay := 7 * time.Second
@@ -153,12 +139,10 @@ func (a *AmazonDownloader) waitForRateLimit() {
 		}
 	}
 
-	// Update tracking
 	a.lastAPICallTime = time.Now()
 	a.apiCallCount++
 }
 
-// GetAvailableAPIs returns list of available DoubleDouble regions
 // Uses same service as PC version (doubledouble.top)
 func (a *AmazonDownloader) GetAvailableAPIs() []string {
 	// DoubleDouble service regions (same as PC)
@@ -179,17 +163,13 @@ func (a *AmazonDownloader) downloadFromDoubleDoubleService(amazonURL, _ string)
 	for _, region := range a.regions {
 		GoLog("[Amazon] Trying region: %s...\n", region)
 
-		// Build base URL for DoubleDouble service
-		// Decode base64 service URL (same as PC)
 		serviceBase, _ := base64.StdEncoding.DecodeString("aHR0cHM6Ly8=")               // https://
 		serviceDomain, _ := base64.StdEncoding.DecodeString("LmRvdWJsZWRvdWJsZS50b3A=") // .doubledouble.top
 		baseURL := fmt.Sprintf("%s%s%s", string(serviceBase), region, string(serviceDomain))
 
-		// Step 1: Submit download request with rate limiting
 		encodedURL := url.QueryEscape(amazonURL)
 		submitURL := fmt.Sprintf("%s/dl?url=%s", baseURL, encodedURL)
 
-		// Apply rate limiting before request (like PC version)
 		a.waitForRateLimit()
 
 		req, err := http.NewRequest("GET", submitURL, nil)
@@ -299,7 +279,6 @@ func (a *AmazonDownloader) downloadFromDoubleDoubleService(amazonURL, _ string)
 			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:])
@@ -344,15 +323,22 @@ func (a *AmazonDownloader) downloadFromDoubleDoubleService(amazonURL, _ string)
 	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)
 	}
@@ -361,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()
@@ -370,7 +359,6 @@ func (a *AmazonDownloader) DownloadFile(downloadURL, outputPath, itemID string)
 	}
 
 	expectedSize := resp.ContentLength
-	// Set total bytes if available
 	if expectedSize > 0 && itemID != "" {
 		SetItemBytesTotal(itemID, expectedSize)
 	}
@@ -380,16 +368,13 @@ func (a *AmazonDownloader) DownloadFile(downloadURL, outputPath, itemID string)
 		return err
 	}
 
-	// Use buffered writer for better performance (256KB buffer)
 	bufWriter := bufio.NewWriterSize(out, 256*1024)
 
-	// Use item progress writer with buffered output
 	var written int64
 	if itemID != "" {
 		pw := NewItemProgressWriter(bufWriter, itemID)
 		written, err = io.Copy(pw, resp.Body)
 	} else {
-		// Fallback: direct copy without progress tracking
 		written, err = io.Copy(bufWriter, resp.Body)
 	}
 
@@ -397,9 +382,11 @@ func (a *AmazonDownloader) DownloadFile(downloadURL, outputPath, itemID string)
 	flushErr := bufWriter.Flush()
 	closeErr := out.Close()
 
-	// Check for any errors
 	if err != nil {
 		os.Remove(outputPath)
+		if isDownloadCancelled(itemID) {
+			return ErrDownloadCancelled
+		}
 		return fmt.Errorf("download interrupted: %w", err)
 	}
 	if flushErr != nil {
@@ -435,29 +422,23 @@ type AmazonDownloadResult struct {
 	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()
 	var availability *TrackAvailability
 	var err error
 
-	// Check if SpotifyID is actually a Deezer ID (format: "deezer:xxxxx")
 	if strings.HasPrefix(req.SpotifyID, "deezer:") {
-		// Extract Deezer ID and use Deezer-based lookup
 		deezerID := strings.TrimPrefix(req.SpotifyID, "deezer:")
 		GoLog("[Amazon] Using Deezer ID for SongLink lookup: %s\n", deezerID)
 		availability, err = songlink.CheckAvailabilityFromDeezer(deezerID)
 	} else if req.SpotifyID != "" {
-		// Use Spotify ID
 		availability, err = songlink.CheckTrackAvailability(req.SpotifyID, req.ISRC)
 	} else {
 		return AmazonDownloadResult{}, fmt.Errorf("no valid Spotify or Deezer ID provided for Amazon lookup")
@@ -471,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)
@@ -490,10 +470,8 @@ func downloadFromAmazon(req DownloadRequest) (AmazonDownloadResult, error) {
 		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)
 
-	// Build filename using Spotify metadata (more accurate)
 	filename := buildFilenameFromTemplate(req.FilenameFormat, map[string]interface{}{
 		"title":  req.TrackName,
 		"artist": req.ArtistName,
@@ -505,7 +483,6 @@ 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
 	}
@@ -522,19 +499,21 @@ func downloadFromAmazon(req DownloadRequest) (AmazonDownloadResult, error) {
 			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)
 	}
 
 	// Wait for parallel operations to complete
 	<-parallelDone
 
-	// Set progress to 100% and status to finalizing (before embedding)
-	// This makes the UI show "Finalizing..." while embedding happens
 	if req.ItemID != "" {
 		SetItemProgress(req.ItemID, 1.0, 0, 0)
 		SetItemFinalizing(req.ItemID)
@@ -545,14 +524,11 @@ func downloadFromAmazon(req DownloadRequest) (AmazonDownloadResult, error) {
 		GoLog("[Amazon] DoubleDouble returned: %s - %s\n", artistName, trackName)
 	}
 
-	// Read existing metadata from downloaded file BEFORE embedding
-	// Amazon/DoubleDouble files often have correct track/disc numbers that we should preserve
 	existingMeta, metaErr := ReadMetadata(outputPath)
 	actualTrackNum := req.TrackNumber
 	actualDiscNum := req.DiscNumber
 
 	if metaErr == nil && existingMeta != nil {
-		// Use file metadata if it has valid track/disc numbers and request doesn't have them
 		if existingMeta.TrackNumber > 0 && (req.TrackNumber == 0 || req.TrackNumber == 1) {
 			actualTrackNum = existingMeta.TrackNumber
 			GoLog("[Amazon] Using track number from file: %d (request had: %d)\n", actualTrackNum, req.TrackNumber)
@@ -575,6 +551,9 @@ func downloadFromAmazon(req DownloadRequest) (AmazonDownloadResult, error) {
 		TotalTracks: req.TotalTracks,
 		DiscNumber:  actualDiscNum,
 		ISRC:        req.ISRC,
+		Genre:       req.Genre,     // From Deezer album metadata
+		Label:       req.Label,     // From Deezer album metadata
+		Copyright:   req.Copyright, // From Deezer album metadata
 	}
 
 	// Use cover data from parallel fetch
@@ -588,13 +567,28 @@ func downloadFromAmazon(req DownloadRequest) (AmazonDownloadResult, error) {
 		fmt.Printf("Warning: failed to embed metadata: %v\n", err)
 	}
 
-	// Embed lyrics from parallel fetch
 	if req.EmbedLyrics && parallelResult != nil && parallelResult.LyricsLRC != "" {
-		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")
+		lyricsMode := req.LyricsMode
+		if lyricsMode == "" {
+			lyricsMode = "embed" // default
+		}
+
+		if lyricsMode == "external" || lyricsMode == "both" {
+			GoLog("[Amazon] Saving external LRC file...\n")
+			if lrcPath, lrcErr := SaveLRCFile(outputPath, parallelResult.LyricsLRC); lrcErr != nil {
+				GoLog("[Amazon] Warning: failed to save LRC file: %v\n", lrcErr)
+			} else {
+				GoLog("[Amazon] LRC file saved: %s\n", lrcPath)
+			}
+		}
+
+		if lyricsMode == "embed" || lyricsMode == "both" {
+			GoLog("[Amazon] Embedding parallel-fetched lyrics (%d lines)...\n", len(parallelResult.LyricsData.Lines))
+			if embedErr := EmbedLyrics(outputPath, parallelResult.LyricsLRC); embedErr != nil {
+				GoLog("[Amazon] Warning: failed to embed lyrics: %v\n", embedErr)
+			} else {
+				fmt.Println("[Amazon] Lyrics embedded successfully")
+			}
 		}
 	} else if req.EmbedLyrics {
 		fmt.Println("[Amazon] No lyrics available from parallel fetch")
@@ -602,8 +596,6 @@ func downloadFromAmazon(req DownloadRequest) (AmazonDownloadResult, error) {
 
 	fmt.Println("[Amazon] ✓ Downloaded successfully from Amazon Music")
 
-	// Read actual quality from the downloaded FLAC file
-	// Amazon API doesn't provide quality info, but we can read it from the file itself
 	quality, err := GetAudioQuality(outputPath)
 	if err != nil {
 		GoLog("[Amazon] Warning: couldn't read quality from file: %v\n", err)
@@ -611,8 +603,6 @@ func downloadFromAmazon(req DownloadRequest) (AmazonDownloadResult, error) {
 		GoLog("[Amazon] Actual quality: %d-bit/%dHz\n", quality.BitDepth, quality.SampleRate)
 	}
 
-	// Read metadata from file AFTER embedding to get accurate values
-	// This ensures we return what's actually in the file
 	finalMeta, metaReadErr := ReadMetadata(outputPath)
 	if metaReadErr == nil && finalMeta != nil {
 		GoLog("[Amazon] Final metadata from file - Track: %d, Disc: %d, Date: %s\n",
@@ -620,7 +610,6 @@ func downloadFromAmazon(req DownloadRequest) (AmazonDownloadResult, error) {
 		actualTrackNum = finalMeta.TrackNumber
 		actualDiscNum = finalMeta.DiscNumber
 		if finalMeta.Date != "" {
-			// Use date from file if available
 			req.ReleaseDate = finalMeta.Date
 		}
 	}

go_backend/cancel.go

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

go_backend/cover.go

@@ -4,36 +4,53 @@ import (
 	"fmt"
 	"io"
 	"net/http"
+	"regexp"
 	"strings"
 )
 
-// Spotify image size codes (same as PC version)
 const (
-	spotifySize640 = "ab67616d0000b273" // 640x640
-	spotifySizeMax = "ab67616d000082c1" // Max resolution (~2000x2000)
+	spotifySize300 = "ab67616d00001e02"
+	spotifySize640 = "ab67616d0000b273"
+	spotifySizeMax = "ab67616d000082c1"
 )
 
-// downloadCoverToMemory downloads cover art and returns as bytes (no file creation)
-// This avoids file permission issues on Android
+// Deezer CDN supports these sizes: 56, 250, 500, 1000, 1400, 1800
+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)
-		if downloadURL != coverURL {
-			fmt.Printf("[Cover] Upgraded to max quality URL: %s\n", downloadURL)
+		maxURL := upgradeToMaxQuality(downloadURL)
+		if maxURL != downloadURL {
+			downloadURL = maxURL
+			// Log already printed by upgradeToMaxQuality for Deezer
+			if strings.Contains(coverURL, "scdn.co") || strings.Contains(coverURL, "spotifycdn") {
+				GoLog("[Cover] Spotify: upgraded to max resolution (~2000x2000)")
+			}
 		}
 	}
 
+	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
-	// Format: https://i.scdn.co/image/ab67616d0000b273...
-	// ab67616d0000b273 = 640x640
-	// ab67616d000082c1 = Max resolution (~2000x2000)
-
+	// Spotify CDN upgrade
 	if strings.Contains(coverURL, spotifySize640) {
-		// Try max resolution first
-		maxURL := strings.Replace(coverURL, spotifySize640, spotifySizeMax, 1)
+		return strings.Replace(coverURL, spotifySize640, spotifySizeMax, 1)
+	}
 
-		// Verify max resolution URL is available
-		client := NewHTTPClientWithTimeout(DefaultTimeout)
-		req, err := http.NewRequest("HEAD", maxURL, nil)
-		if err == nil {
-			resp, err := DoRequestWithUserAgent(client, req)
-			if err == nil {
-				resp.Body.Close()
-				if resp.StatusCode == http.StatusOK {
-					return maxURL
-				}
-			}
-		}
+	// Deezer CDN upgrade
+	if strings.Contains(coverURL, "cdn-images.dzcdn.net") {
+		return upgradeDeezerCover(coverURL)
 	}
 
 	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
 }

go_backend/deezer.go

@@ -22,27 +22,23 @@ const (
 
 	deezerCacheTTL = 10 * time.Minute
 
-	// Parallel ISRC fetching settings
-	deezerMaxParallelISRC = 10 // Max concurrent ISRC fetches
+	deezerMaxParallelISRC = 10
 )
 
-// DeezerClient handles Deezer API interactions (no auth required)
 type DeezerClient struct {
 	httpClient  *http.Client
 	searchCache map[string]*cacheEntry
 	albumCache  map[string]*cacheEntry
 	artistCache map[string]*cacheEntry
-	isrcCache   map[string]string // trackID -> ISRC cache
+	isrcCache   map[string]string
 	cacheMu     sync.RWMutex
 }
 
-// Singleton instance
 var (
 	deezerClient     *DeezerClient
 	deezerClientOnce sync.Once
 )
 
-// GetDeezerClient returns singleton Deezer client
 func GetDeezerClient() *DeezerClient {
 	deezerClientOnce.Do(func() {
 		deezerClient = &DeezerClient{
@@ -56,7 +52,6 @@ func GetDeezerClient() *DeezerClient {
 	return deezerClient
 }
 
-// Deezer API response types
 type deezerTrack struct {
 	ID            int64             `json:"id"`
 	Title         string            `json:"title"`
@@ -65,7 +60,7 @@ type deezerTrack struct {
 	DiskNumber    int               `json:"disk_number"`
 	ISRC          string            `json:"isrc"`
 	Link          string            `json:"link"`
-	ReleaseDate   string            `json:"release_date"` // Sometimes at track level
+	ReleaseDate   string            `json:"release_date"`
 	Artist        deezerArtist      `json:"artist"`
 	Album         deezerAlbumSimple `json:"album"`
 	Contributors  []deezerArtist    `json:"contributors"`
@@ -88,12 +83,10 @@ type deezerAlbumSimple struct {
 	CoverMedium string `json:"cover_medium"`
 	CoverBig    string `json:"cover_big"`
 	CoverXL     string `json:"cover_xl"`
-	ReleaseDate string `json:"release_date"` // Sometimes at album level
+	ReleaseDate string `json:"release_date"`
+	RecordType  string `json:"record_type"`
 }
 
-// ... (skip other structs as they are fine/unchanged) ...
-
-// ... (in convertTrack) ...
 func (c *DeezerClient) convertTrack(track deezerTrack) TrackMetadata {
 	artistName := track.Artist.Name
 	if len(track.Contributors) > 0 {
@@ -115,7 +108,6 @@ func (c *DeezerClient) convertTrack(track deezerTrack) TrackMetadata {
 		albumImage = track.Album.Cover
 	}
 
-	// Try to find release date
 	releaseDate := track.ReleaseDate
 	if releaseDate == "" {
 		releaseDate = track.Album.ReleaseDate
@@ -137,16 +129,25 @@ func (c *DeezerClient) convertTrack(track deezerTrack) TrackMetadata {
 	}
 }
 
+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"` // album, single, ep, compile
+	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 {
@@ -181,7 +182,6 @@ type deezerPlaylistFull struct {
 	} `json:"tracks"`
 }
 
-// SearchAll searches for tracks and artists on Deezer
 // NOTE: ISRC is NOT fetched during search for performance - use GetTrackISRC when needed for download
 func (c *DeezerClient) SearchAll(ctx context.Context, query string, trackLimit, artistLimit int) (*SearchAllResult, error) {
 	GoLog("[Deezer] SearchAll: query=%q, trackLimit=%d, artistLimit=%d\n", query, trackLimit, artistLimit)
@@ -197,8 +197,8 @@ func (c *DeezerClient) SearchAll(ctx context.Context, query string, trackLimit,
 	c.cacheMu.RUnlock()
 
 	result := &SearchAllResult{
-		Tracks:  make([]TrackMetadata, 0),
-		Artists: make([]SearchArtistResult, 0),
+		Tracks:  make([]TrackMetadata, 0, trackLimit),
+		Artists: make([]SearchArtistResult, 0, artistLimit),
 	}
 
 	// Search tracks - NO ISRC fetch for performance
@@ -226,11 +226,9 @@ func (c *DeezerClient) SearchAll(ctx context.Context, query string, trackLimit,
 	GoLog("[Deezer] Got %d tracks from API\n", len(trackResp.Data))
 
 	for _, track := range trackResp.Data {
-		// Convert directly without fetching ISRC - much faster
 		result.Tracks = append(result.Tracks, c.convertTrack(track))
 	}
 
-	// Search artists
 	artistURL := fmt.Sprintf("%s/artist?q=%s&limit=%d", deezerSearchURL, url.QueryEscape(query), artistLimit)
 	GoLog("[Deezer] Fetching artists from: %s\n", artistURL)
 
@@ -263,7 +261,6 @@ func (c *DeezerClient) SearchAll(ctx context.Context, query string, trackLimit,
 
 	GoLog("[Deezer] SearchAll complete: %d tracks, %d artists\n", len(result.Tracks), len(result.Artists))
 
-	// Cache result
 	c.cacheMu.Lock()
 	c.searchCache[cacheKey] = &cacheEntry{
 		data:      result,
@@ -288,7 +285,6 @@ func (c *DeezerClient) GetTrack(ctx context.Context, trackID string) (*TrackResp
 	}, nil
 }
 
-// GetAlbum fetches album with tracks
 // ISRC is fetched in parallel for better performance
 func (c *DeezerClient) GetAlbum(ctx context.Context, albumID string) (*AlbumResponsePayload, error) {
 	c.cacheMu.RLock()
@@ -315,15 +311,25 @@ func (c *DeezerClient) GetAlbum(ctx context.Context, albumID string) (*AlbumResp
 		artistName = strings.Join(names, ", ")
 	}
 
+	// Extract genres as comma-separated string
+	var genres []string
+	for _, g := range album.Genres.Data {
+		if g.Name != "" {
+			genres = append(genres, g.Name)
+		}
+	}
+	genreStr := strings.Join(genres, ", ")
+
 	info := AlbumInfoMetadata{
 		TotalTracks: album.NbTracks,
 		Name:        album.Title,
 		ReleaseDate: album.ReleaseDate,
 		Artists:     artistName,
 		Images:      albumImage,
+		Genre:       genreStr,    // From Deezer album
+		Label:       album.Label, // From Deezer album
 	}
 
-	// Fetch ISRCs in parallel
 	isrcMap := c.fetchISRCsParallel(ctx, album.Tracks.Data)
 
 	tracks := make([]AlbumTrackMetadata, 0, len(album.Tracks.Data))
@@ -371,7 +377,6 @@ func (c *DeezerClient) GetAlbum(ctx context.Context, albumID string) (*AlbumResp
 	return result, nil
 }
 
-// GetArtist fetches artist with albums
 func (c *DeezerClient) GetArtist(ctx context.Context, artistID string) (*ArtistResponsePayload, error) {
 	c.cacheMu.RLock()
 	if entry, ok := c.artistCache[artistID]; ok && !entry.isExpired() {
@@ -457,8 +462,6 @@ func (c *DeezerClient) GetArtist(ctx context.Context, artistID string) (*ArtistR
 	return result, nil
 }
 
-// GetPlaylist fetches playlist with tracks
-// ISRC is fetched in parallel for better performance
 func (c *DeezerClient) GetPlaylist(ctx context.Context, playlistID string) (*PlaylistResponsePayload, error) {
 	playlistURL := fmt.Sprintf(deezerPlaylistURL, playlistID)
 
@@ -481,7 +484,6 @@ func (c *DeezerClient) GetPlaylist(ctx context.Context, playlistID string) (*Pla
 	info.Owner.Name = playlist.Title
 	info.Owner.Images = playlistImage
 
-	// Fetch ISRCs in parallel
 	isrcMap := c.fetchISRCsParallel(ctx, playlist.Tracks.Data)
 
 	tracks := make([]AlbumTrackMetadata, 0, len(playlist.Tracks.Data))
@@ -520,15 +522,11 @@ func (c *DeezerClient) GetPlaylist(ctx context.Context, playlistID string) (*Pla
 	}, nil
 }
 
-// SearchByISRC searches for a track by ISRC using direct endpoint
 func (c *DeezerClient) SearchByISRC(ctx context.Context, isrc string) (*TrackMetadata, error) {
-	// Use direct ISRC endpoint (API 2.0)
-	// https://api.deezer.com/2.0/track/isrc:{ISRC}
 	directURL := fmt.Sprintf("%s/track/isrc:%s", deezerBaseURL, isrc)
 
 	var track deezerTrack
 	if err := c.getJSON(ctx, directURL, &track); err != nil {
-		// Fallback to search if direct endpoint fails
 		searchURL := fmt.Sprintf("%s/track?q=isrc:%s&limit=1", deezerSearchURL, isrc)
 		var resp struct {
 			Data []deezerTrack `json:"data"`
@@ -543,7 +541,6 @@ func (c *DeezerClient) SearchByISRC(ctx context.Context, isrc string) (*TrackMet
 		return &result, nil
 	}
 
-	// Check if we got a valid response (ID > 0)
 	if track.ID == 0 {
 		return nil, fmt.Errorf("no track found for ISRC: %s", isrc)
 	}
@@ -563,14 +560,24 @@ func (c *DeezerClient) fetchFullTrack(ctx context.Context, trackID string) (*dee
 
 // 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)
+	result := make(map[string]string, len(tracks))
 	var resultMu sync.Mutex
 
-	// First, check cache for existing ISRCs
 	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 {
@@ -578,6 +585,13 @@ func (c *DeezerClient) fetchISRCsParallel(ctx context.Context, tracks []deezerTr
 		}
 	}
 	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
@@ -592,7 +606,6 @@ func (c *DeezerClient) fetchISRCsParallel(ctx context.Context, tracks []deezerTr
 		go func(t deezerTrack) {
 			defer wg.Done()
 
-			// Acquire semaphore
 			select {
 			case sem <- struct{}{}:
 				defer func() { <-sem }()
@@ -621,10 +634,8 @@ func (c *DeezerClient) fetchISRCsParallel(ctx context.Context, tracks []deezerTr
 	return result
 }
 
-// GetTrackISRC fetches ISRC for a single track (with caching)
 // Use this when you need ISRC for download
 func (c *DeezerClient) GetTrackISRC(ctx context.Context, trackID string) (string, error) {
-	// Check cache first
 	c.cacheMu.RLock()
 	if isrc, ok := c.isrcCache[trackID]; ok {
 		c.cacheMu.RUnlock()
@@ -632,13 +643,11 @@ func (c *DeezerClient) GetTrackISRC(ctx context.Context, trackID string) (string
 	}
 	c.cacheMu.RUnlock()
 
-	// Fetch from API
 	fullTrack, err := c.fetchFullTrack(ctx, trackID)
 	if err != nil {
 		return "", err
 	}
 
-	// Cache the result
 	c.cacheMu.Lock()
 	c.isrcCache[trackID] = fullTrack.ISRC
 	c.cacheMu.Unlock()
@@ -685,6 +694,104 @@ func (c *DeezerClient) getBestAlbumImage(album deezerAlbumFull) string {
 	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 {
@@ -729,7 +836,6 @@ func parseDeezerURL(input string) (string, string, error) {
 
 	parts := strings.Split(strings.Trim(parsed.Path, "/"), "/")
 
-	// Skip language prefix if present (e.g., /en/, /fr/)
 	if len(parts) > 0 && len(parts[0]) == 2 {
 		parts = parts[1:]
 	}

go_backend/duplicate.go

@@ -18,30 +18,45 @@ type ISRCIndex struct {
 	mu        sync.RWMutex
 }
 
-// Global ISRC index cache (per output directory)
 var (
 	isrcIndexCache   = make(map[string]*ISRCIndex)
 	isrcIndexCacheMu sync.RWMutex
-	isrcIndexTTL     = 5 * time.Minute // Cache TTL - rebuild after 5 minutes
+	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()
 
-	// Return cached index if still valid
 	if exists && time.Since(idx.buildTime) < isrcIndexTTL {
 		return idx
 	}
 
-	// Build new index
+	// 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
-// Same implementation as PC version for consistency
 func buildISRCIndex(outputDir string) *ISRCIndex {
 	idx := &ISRCIndex{
 		index:     make(map[string]string),
@@ -56,7 +71,6 @@ func buildISRCIndex(outputDir string) *ISRCIndex {
 	startTime := time.Now()
 	fileCount := 0
 
-	// Walk directory - only check .flac files
 	filepath.Walk(outputDir, func(path string, info os.FileInfo, err error) error {
 		if err != nil || info.IsDir() {
 			return nil
@@ -67,13 +81,11 @@ func buildISRCIndex(outputDir string) *ISRCIndex {
 			return nil
 		}
 
-		// Read ISRC from file
 		metadata, err := ReadMetadata(path)
 		if err != nil || metadata.ISRC == "" {
 			return nil
 		}
 
-		// Store in index (uppercase for case-insensitive matching)
 		idx.index[strings.ToUpper(metadata.ISRC)] = path
 		fileCount++
 		return nil
@@ -82,7 +94,6 @@ func buildISRCIndex(outputDir string) *ISRCIndex {
 	fmt.Printf("[ISRCIndex] Built index for %s: %d files in %v\n", 
 		outputDir, fileCount, time.Since(startTime).Round(time.Millisecond))
 
-	// Cache the index
 	isrcIndexCacheMu.Lock()
 	isrcIndexCache[outputDir] = idx
 	isrcIndexCacheMu.Unlock()
@@ -90,7 +101,6 @@ func buildISRCIndex(outputDir string) *ISRCIndex {
 	return idx
 }
 
-// lookup checks if an ISRC exists in the index (internal, returns bool)
 func (idx *ISRCIndex) lookup(isrc string) (string, bool) {
 	if isrc == "" {
 		return "", false
@@ -103,6 +113,18 @@ func (idx *ISRCIndex) lookup(isrc string) (string, bool) {
 	return path, exists
 }
 
+// remove deletes an ISRC entry from the index (internal use)
+func (idx *ISRCIndex) remove(isrc string) {
+	if isrc == "" {
+		return
+	}
+
+	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) {
@@ -136,13 +158,22 @@ func checkISRCExistsInternal(outputDir, isrc string) (string, bool) {
 		return "", false
 	}
 
-	// Use index for fast lookup
 	idx := GetISRCIndex(outputDir)
-	return idx.lookup(isrc)
+	filePath, exists := idx.lookup(isrc)
+	if !exists {
+		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
@@ -166,11 +197,7 @@ type FileExistenceResult struct {
 	ArtistName string `json:"artist_name,omitempty"`
 }
 
-// CheckFilesExistParallel checks if multiple files exist in parallel
-// It builds an ISRC index from the output directory once, then checks all tracks against it
-// Same implementation as PC version for consistency
 func CheckFilesExistParallel(outputDir string, tracksJSON string) (string, error) {
-	// Parse input JSON
 	var tracks []struct {
 		ISRC       string `json:"isrc"`
 		TrackName  string `json:"track_name"`
@@ -182,10 +209,8 @@ func CheckFilesExistParallel(outputDir string, tracksJSON string) (string, error
 
 	results := make([]FileExistenceResult, len(tracks))
 
-	// Build ISRC index from output directory (scan once)
 	isrcIdx := GetISRCIndex(outputDir)
 
-	// Check each track against the index (parallel)
 	var wg sync.WaitGroup
 	for i, track := range tracks {
 		wg.Add(1)
@@ -216,7 +241,6 @@ func CheckFilesExistParallel(outputDir string, tracksJSON string) (string, error
 
 	wg.Wait()
 
-	// Return results as JSON
 	resultJSON, err := json.Marshal(results)
 	if err != nil {
 		return "", fmt.Errorf("failed to marshal results: %w", err)
@@ -237,7 +261,6 @@ func PreBuildISRCIndex(outputDir string) error {
 }
 
 // AddToISRCIndex adds a new file to the ISRC index after successful download
-// This avoids rebuilding the entire index
 func AddToISRCIndex(outputDir, isrc, filePath string) {
 	if outputDir == "" || isrc == "" || filePath == "" {
 		return

go_backend/extension_manager.go

@@ -1,4 +1,3 @@
-// Package gobackend provides extension management functionality
 package gobackend
 
 import (
@@ -15,14 +14,10 @@ import (
 	"github.com/dop251/goja"
 )
 
-// compareVersions compares two semantic version strings
-// Returns: -1 if v1 < v2, 0 if v1 == v2, 1 if v1 > v2
 func compareVersions(v1, v2 string) int {
-	// Parse version parts
 	parts1 := strings.Split(strings.TrimPrefix(v1, "v"), ".")
 	parts2 := strings.Split(strings.TrimPrefix(v2, "v"), ".")
 
-	// Pad shorter version with zeros
 	maxLen := len(parts1)
 	if len(parts2) > maxLen {
 		maxLen = len(parts2)
@@ -48,16 +43,16 @@ func compareVersions(v1, v2 string) int {
 	return 0
 }
 
-// LoadedExtension represents an extension that has been loaded into memory
 type LoadedExtension struct {
 	ID        string             `json:"id"`
 	Manifest  *ExtensionManifest `json:"manifest"`
-	VM        *goja.Runtime      `json:"-"` // Goja VM instance (not serialized)
+	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"`   // Extension's data directory
-	SourceDir string             `json:"source_dir"` // Where extension files are extracted
-	IconPath  string             `json:"icon_path"`  // Full path to icon file (if exists)
+	DataDir   string             `json:"data_dir"`
+	SourceDir string             `json:"source_dir"`
+	IconPath  string             `json:"icon_path"`
 }
 
 // ExtensionManager manages all loaded extensions
@@ -68,13 +63,11 @@ type ExtensionManager struct {
 	dataDir       string // Base directory for extension data
 }
 
-// Global extension manager instance
 var (
 	globalExtManager     *ExtensionManager
 	globalExtManagerOnce sync.Once
 )
 
-// GetExtensionManager returns the global extension manager instance
 func GetExtensionManager() *ExtensionManager {
 	globalExtManagerOnce.Do(func() {
 		globalExtManager = &ExtensionManager{
@@ -84,7 +77,6 @@ func GetExtensionManager() *ExtensionManager {
 	return globalExtManager
 }
 
-// SetDirectories sets the extensions and data directories
 func (m *ExtensionManager) SetDirectories(extensionsDir, dataDir string) error {
 	m.mu.Lock()
 	defer m.mu.Unlock()
@@ -92,7 +84,6 @@ func (m *ExtensionManager) SetDirectories(extensionsDir, dataDir string) error {
 	m.extensionsDir = extensionsDir
 	m.dataDir = dataDir
 
-	// Create directories if they don't exist
 	if err := os.MkdirAll(extensionsDir, 0755); err != nil {
 		return fmt.Errorf("failed to create extensions directory: %w", err)
 	}
@@ -103,9 +94,7 @@ func (m *ExtensionManager) SetDirectories(extensionsDir, dataDir string) error {
 	return nil
 }
 
-// LoadExtensionFromFile loads an extension from a .spotiflac-ext file
 func (m *ExtensionManager) LoadExtensionFromFile(filePath string) (*LoadedExtension, error) {
-	// Validate file extension
 	if !strings.HasSuffix(strings.ToLower(filePath), ".spotiflac-ext") {
 		return nil, fmt.Errorf("Invalid file format. Please select a .spotiflac-ext file")
 	}
@@ -117,7 +106,6 @@ func (m *ExtensionManager) LoadExtensionFromFile(filePath string) (*LoadedExtens
 	}
 	defer zipReader.Close()
 
-	// Find and read manifest.json
 	var manifestData []byte
 	var hasIndexJS bool
 	for _, file := range zipReader.File {
@@ -146,13 +134,11 @@ func (m *ExtensionManager) LoadExtensionFromFile(filePath string) (*LoadedExtens
 		return nil, fmt.Errorf("Invalid extension package: index.js not found")
 	}
 
-	// Parse and validate manifest
 	manifest, err := ParseManifest(manifestData)
 	if err != nil {
 		return nil, fmt.Errorf("Invalid extension manifest: %w", err)
 	}
 
-	// Check if extension already loaded - if so, try upgrade (check without holding lock for long)
 	m.mu.RLock()
 	existing, exists := m.extensions[manifest.Name]
 	var existingVersion string
@@ -164,7 +150,6 @@ func (m *ExtensionManager) LoadExtensionFromFile(filePath string) (*LoadedExtens
 	m.mu.RUnlock()
 
 	if exists {
-		// Check if this is an upgrade
 		versionCompare := compareVersions(manifest.Version, existingVersion)
 		if versionCompare > 0 {
 			// This is an upgrade - call UpgradeExtension
@@ -176,37 +161,40 @@ func (m *ExtensionManager) LoadExtensionFromFile(filePath string) (*LoadedExtens
 		}
 	}
 
-	// Now acquire write lock for the rest of the operation
 	m.mu.Lock()
 	defer m.mu.Unlock()
 
-	// Double-check extension wasn't added while we were waiting for lock
 	if _, exists := m.extensions[manifest.Name]; exists {
 		return nil, fmt.Errorf("Extension '%s' was installed by another process", manifest.DisplayName)
 	}
 
-	// Create extension directory
 	extDir := filepath.Join(m.extensionsDir, manifest.Name)
 	if err := os.MkdirAll(extDir, 0755); err != nil {
 		return nil, fmt.Errorf("failed to create extension directory: %w", err)
 	}
 
-	// Extract all files
 	for _, file := range zipReader.File {
 		if file.FileInfo().IsDir() {
 			continue
 		}
 
-		// Get relative path within the zip
-		destPath := filepath.Join(extDir, filepath.Base(file.Name))
+		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)
+		}
 
-		// Create destination file
 		destFile, err := os.Create(destPath)
 		if err != nil {
 			return nil, fmt.Errorf("failed to create file %s: %w", destPath, err)
 		}
 
-		// Copy content
 		srcFile, err := file.Open()
 		if err != nil {
 			destFile.Close()
@@ -221,13 +209,11 @@ func (m *ExtensionManager) LoadExtensionFromFile(filePath string) (*LoadedExtens
 		}
 	}
 
-	// Create data directory for extension
 	extDataDir := filepath.Join(m.dataDir, manifest.Name)
 	if err := os.MkdirAll(extDataDir, 0755); err != nil {
 		return nil, fmt.Errorf("failed to create extension data directory: %w", err)
 	}
 
-	// Create loaded extension
 	ext := &LoadedExtension{
 		ID:        manifest.Name,
 		Manifest:  manifest,
@@ -249,25 +235,20 @@ func (m *ExtensionManager) LoadExtensionFromFile(filePath string) (*LoadedExtens
 	return ext, nil
 }
 
-// initializeVM creates and initializes the Goja VM for an extension
 func (m *ExtensionManager) initializeVM(ext *LoadedExtension) error {
-	// Create new Goja runtime
 	vm := goja.New()
 	ext.VM = vm
 
-	// Read index.js
 	indexPath := filepath.Join(ext.SourceDir, "index.js")
 	jsCode, err := os.ReadFile(indexPath)
 	if err != nil {
 		return fmt.Errorf("failed to read index.js: %w", err)
 	}
 
-	// Create extension runtime and register sandboxed APIs
 	runtime := NewExtensionRuntime(ext)
 	runtime.RegisterAPIs(vm)
 	runtime.RegisterGoBackendAPIs(vm)
 
-	// Set up console.log for debugging
 	console := vm.NewObject()
 	console.Set("log", func(call goja.FunctionCall) goja.Value {
 		args := make([]interface{}, len(call.Arguments))
@@ -279,12 +260,10 @@ func (m *ExtensionManager) initializeVM(ext *LoadedExtension) error {
 	})
 	vm.Set("console", console)
 
-	// Set up registerExtension function
 	var registeredExtension goja.Value
 	vm.Set("registerExtension", func(call goja.FunctionCall) goja.Value {
 		if len(call.Arguments) > 0 {
 			registeredExtension = call.Arguments[0]
-			// Also set it as global 'extension' variable for later access
 			vm.Set("extension", call.Arguments[0])
 		}
 		return goja.Undefined()
@@ -332,7 +311,6 @@ func (m *ExtensionManager) UnloadExtension(extensionID string) error {
 	return nil
 }
 
-// GetExtension returns a loaded extension by ID
 // Returns error if extension not found (gomobile compatible)
 func (m *ExtensionManager) GetExtension(extensionID string) (*LoadedExtension, error) {
 	m.mu.RLock()
@@ -357,7 +335,6 @@ func (m *ExtensionManager) GetAllExtensions() []*LoadedExtension {
 	return result
 }
 
-// SetExtensionEnabled enables or disables an extension
 func (m *ExtensionManager) SetExtensionEnabled(extensionID string, enabled bool) error {
 	m.mu.Lock()
 	defer m.mu.Unlock()
@@ -394,7 +371,6 @@ func (m *ExtensionManager) LoadExtensionsFromDirectory(dirPath string) ([]string
 
 	for _, entry := range entries {
 		if entry.IsDir() {
-			// Check if it's an extracted extension directory
 			manifestPath := filepath.Join(dirPath, entry.Name(), "manifest.json")
 			if _, err := os.Stat(manifestPath); err == nil {
 				ext, err := m.loadExtensionFromDirectory(filepath.Join(dirPath, entry.Name()))
@@ -406,7 +382,6 @@ func (m *ExtensionManager) LoadExtensionsFromDirectory(dirPath string) ([]string
 				}
 			}
 		} else if strings.HasSuffix(strings.ToLower(entry.Name()), ".spotiflac-ext") {
-			// Load from package file
 			ext, err := m.LoadExtensionFromFile(filepath.Join(dirPath, entry.Name()))
 			if err != nil {
 				GoLog("[Extension] Failed to load %s: %v\n", entry.Name(), err)
@@ -420,12 +395,10 @@ func (m *ExtensionManager) LoadExtensionsFromDirectory(dirPath string) ([]string
 	return loaded, errors
 }
 
-// loadExtensionFromDirectory loads an extension from an already extracted directory
 func (m *ExtensionManager) loadExtensionFromDirectory(dirPath string) (*LoadedExtension, error) {
 	m.mu.Lock()
 	defer m.mu.Unlock()
 
-	// Read manifest
 	manifestPath := filepath.Join(dirPath, "manifest.json")
 	manifestData, err := os.ReadFile(manifestPath)
 	if err != nil {
@@ -438,24 +411,21 @@ func (m *ExtensionManager) loadExtensionFromDirectory(dirPath string) (*LoadedEx
 		return nil, fmt.Errorf("Invalid extension manifest: %w", err)
 	}
 
-	// Check if index.js exists
 	indexPath := filepath.Join(dirPath, "index.js")
 	if _, err := os.Stat(indexPath); os.IsNotExist(err) {
 		return nil, fmt.Errorf("Extension is missing index.js file")
 	}
 
-	// Check if extension already loaded - skip if already exists (for directory loading on startup)
-	if _, exists := m.extensions[manifest.Name]; exists {
-		return nil, fmt.Errorf("Extension '%s' is already loaded", manifest.DisplayName)
+	if existing, exists := m.extensions[manifest.Name]; exists {
+		GoLog("[Extension] Extension '%s' already loaded, skipping\n", manifest.DisplayName)
+		return existing, nil
 	}
 
-	// Create data directory for extension
 	extDataDir := filepath.Join(m.dataDir, manifest.Name)
 	if err := os.MkdirAll(extDataDir, 0755); err != nil {
 		return nil, fmt.Errorf("failed to create extension data directory: %w", err)
 	}
 
-	// Create loaded extension
 	ext := &LoadedExtension{
 		ID:        manifest.Name,
 		Manifest:  manifest,
@@ -513,7 +483,6 @@ func (m *ExtensionManager) RemoveExtension(extensionID string) error {
 	return nil
 }
 
-// UpgradeExtension upgrades an existing extension from a new package file
 // Only allows upgrades (new version > current version), not downgrades
 func (m *ExtensionManager) UpgradeExtension(filePath string) (*LoadedExtension, error) {
 	// Validate file extension
@@ -528,7 +497,6 @@ func (m *ExtensionManager) UpgradeExtension(filePath string) (*LoadedExtension,
 	}
 	defer zipReader.Close()
 
-	// Find and read manifest.json
 	var manifestData []byte
 	var hasIndexJS bool
 	for _, file := range zipReader.File {
@@ -557,13 +525,11 @@ func (m *ExtensionManager) UpgradeExtension(filePath string) (*LoadedExtension,
 		return nil, fmt.Errorf("Invalid extension package: index.js not found")
 	}
 
-	// Parse and validate manifest
 	newManifest, err := ParseManifest(manifestData)
 	if err != nil {
 		return nil, fmt.Errorf("Invalid extension manifest: %w", err)
 	}
 
-	// Check if extension exists
 	m.mu.RLock()
 	existing, exists := m.extensions[newManifest.Name]
 	m.mu.RUnlock()
@@ -599,27 +565,32 @@ func (m *ExtensionManager) UpgradeExtension(filePath string) (*LoadedExtension,
 		}
 	}
 
-	// Recreate extension directory
 	if err := os.MkdirAll(extDir, 0755); err != nil {
 		return nil, fmt.Errorf("failed to create extension directory: %w", err)
 	}
 
-	// Extract all files from new package
 	for _, file := range zipReader.File {
 		if file.FileInfo().IsDir() {
 			continue
 		}
 
-		// Get relative path within the zip
-		destPath := filepath.Join(extDir, filepath.Base(file.Name))
+		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)
+		}
 
-		// Create destination file
 		destFile, err := os.Create(destPath)
 		if err != nil {
 			return nil, fmt.Errorf("failed to create file %s: %w", destPath, err)
 		}
 
-		// Copy content
 		srcFile, err := file.Open()
 		if err != nil {
 			destFile.Close()
@@ -634,7 +605,6 @@ func (m *ExtensionManager) UpgradeExtension(filePath string) (*LoadedExtension,
 		}
 	}
 
-	// Create new loaded extension (reusing data directory, preserving enabled state)
 	ext := &LoadedExtension{
 		ID:        newManifest.Name,
 		Manifest:  newManifest,
@@ -659,7 +629,6 @@ func (m *ExtensionManager) UpgradeExtension(filePath string) (*LoadedExtension,
 	return ext, nil
 }
 
-// ExtensionUpgradeInfo holds information about extension upgrade check
 type ExtensionUpgradeInfo struct {
 	ExtensionID    string `json:"extension_id"`
 	CurrentVersion string `json:"current_version"`
@@ -683,7 +652,6 @@ func (m *ExtensionManager) checkExtensionUpgradeInternal(filePath string) (*Exte
 	}
 	defer zipReader.Close()
 
-	// Find and read manifest.json
 	var manifestData []byte
 	for _, file := range zipReader.File {
 		name := filepath.Base(file.Name)
@@ -705,13 +673,11 @@ func (m *ExtensionManager) checkExtensionUpgradeInternal(filePath string) (*Exte
 		return nil, fmt.Errorf("manifest.json not found")
 	}
 
-	// Parse manifest
 	newManifest, err := ParseManifest(manifestData)
 	if err != nil {
 		return nil, fmt.Errorf("Invalid manifest: %w", err)
 	}
 
-	// Check if extension exists
 	m.mu.RLock()
 	existing, exists := m.extensions[newManifest.Name]
 	m.mu.RUnlock()
@@ -727,7 +693,6 @@ func (m *ExtensionManager) checkExtensionUpgradeInternal(filePath string) (*Exte
 		info.CurrentVersion = ""
 		info.CanUpgrade = false
 	} else {
-		// Compare versions
 		info.CurrentVersion = existing.Manifest.Version
 		info.CanUpgrade = compareVersions(newManifest.Version, existing.Manifest.Version) > 0
 	}
@@ -735,7 +700,6 @@ func (m *ExtensionManager) checkExtensionUpgradeInternal(filePath string) (*Exte
 	return info, nil
 }
 
-// CheckExtensionUpgradeJSON checks if a package file is an upgrade and returns JSON
 func (m *ExtensionManager) CheckExtensionUpgradeJSON(filePath string) (string, error) {
 	info, err := m.checkExtensionUpgradeInternal(filePath)
 	if err != nil {
@@ -780,7 +744,6 @@ func (m *ExtensionManager) GetInstalledExtensionsJSON() (string, error) {
 
 	infos := make([]ExtensionInfo, len(extensions))
 	for i, ext := range extensions {
-		// Build permissions list
 		permissions := []string{}
 		for _, domain := range ext.Manifest.Permissions.Network {
 			permissions = append(permissions, "network:"+domain)
@@ -797,7 +760,6 @@ func (m *ExtensionManager) GetInstalledExtensionsJSON() (string, error) {
 			status = "disabled"
 		}
 
-		// Check for icon file
 		iconPath := ""
 		if ext.Manifest.Icon != "" && ext.SourceDir != "" {
 			possibleIcon := filepath.Join(ext.SourceDir, ext.Manifest.Icon)
@@ -805,7 +767,6 @@ func (m *ExtensionManager) GetInstalledExtensionsJSON() (string, error) {
 				iconPath = possibleIcon
 			}
 		}
-		// Fallback: check for icon.png if not specified in manifest
 		if iconPath == "" && ext.SourceDir != "" {
 			possibleIcon := filepath.Join(ext.SourceDir, "icon.png")
 			if _, err := os.Stat(possibleIcon); err == nil {
@@ -848,7 +809,6 @@ func (m *ExtensionManager) GetInstalledExtensionsJSON() (string, error) {
 
 // ==================== Extension Lifecycle ====================
 
-// InitializeExtension calls the extension's initialize method with settings
 func (m *ExtensionManager) InitializeExtension(extensionID string, settings map[string]interface{}) error {
 	m.mu.Lock()
 	defer m.mu.Unlock()
@@ -862,13 +822,11 @@ func (m *ExtensionManager) InitializeExtension(extensionID string, settings map[
 		return fmt.Errorf("Extension failed to load. Please reinstall the extension")
 	}
 
-	// Convert settings to JSON for passing to JS
 	settingsJSON, err := json.Marshal(settings)
 	if err != nil {
 		return fmt.Errorf("Failed to save settings")
 	}
 
-	// Call initialize function
 	script := fmt.Sprintf(`
 		(function() {
 			var settings = %s;
@@ -892,7 +850,6 @@ func (m *ExtensionManager) InitializeExtension(extensionID string, settings map[
 		return err
 	}
 
-	// Check result
 	if result != nil && !goja.IsUndefined(result) {
 		exported := result.Export()
 		if resultMap, ok := exported.(map[string]interface{}); ok {
@@ -913,7 +870,6 @@ func (m *ExtensionManager) InitializeExtension(extensionID string, settings map[
 	return nil
 }
 
-// CleanupExtension calls the extension's cleanup method
 func (m *ExtensionManager) CleanupExtension(extensionID string) error {
 	m.mu.Lock()
 	defer m.mu.Unlock()
@@ -924,10 +880,9 @@ func (m *ExtensionManager) CleanupExtension(extensionID string) error {
 	}
 
 	if ext.VM == nil {
-		return nil // No VM, nothing to cleanup
+		return nil
 	}
 
-	// Call cleanup function
 	script := `
 		(function() {
 			if (typeof extension !== 'undefined' && typeof extension.cleanup === 'function') {
@@ -948,7 +903,6 @@ func (m *ExtensionManager) CleanupExtension(extensionID string) error {
 		return err
 	}
 
-	// Check result
 	if result != nil && !goja.IsUndefined(result) {
 		exported := result.Export()
 		if resultMap, ok := exported.(map[string]interface{}); ok {
@@ -977,11 +931,65 @@ func (m *ExtensionManager) UnloadAllExtensions() {
 	m.mu.Unlock()
 
 	for _, id := range extensionIDs {
-		// Call cleanup first
 		m.CleanupExtension(id)
-		// Then unload
 		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
+}

go_backend/extension_manifest.go

@@ -23,12 +23,14 @@ const (
 	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
@@ -41,6 +43,7 @@ type ExtensionSetting struct {
 	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
@@ -148,9 +151,7 @@ func ParseManifest(data []byte) (*ExtensionManifest, error) {
 	return &manifest, nil
 }
 
-// Validate checks if the manifest has all required fields and valid values
 func (m *ExtensionManifest) Validate() error {
-	// Check required fields
 	if strings.TrimSpace(m.Name) == "" {
 		return &ManifestValidationError{Field: "name", Message: "name is required"}
 	}
@@ -171,7 +172,6 @@ func (m *ExtensionManifest) Validate() error {
 		return &ManifestValidationError{Field: "type", Message: "at least one type is required"}
 	}
 
-	// Validate extension types
 	for _, t := range m.Types {
 		if t != ExtensionTypeMetadataProvider && t != ExtensionTypeDownloadProvider {
 			return &ManifestValidationError{
@@ -197,20 +197,6 @@ func (m *ExtensionManifest) Validate() error {
 			}
 		}
 
-		// Validate setting type
-		validTypes := map[SettingType]bool{
-			SettingTypeString: true,
-			SettingTypeNumber: true,
-			SettingTypeBool:   true,
-			SettingTypeSelect: true,
-		}
-		if !validTypes[setting.Type] {
-			return &ManifestValidationError{
-				Field:   fmt.Sprintf("settings[%d].type", i),
-				Message: fmt.Sprintf("invalid setting type: %s", setting.Type),
-			}
-		}
-
 		// Select type requires options
 		if setting.Type == SettingTypeSelect && len(setting.Options) == 0 {
 			return &ManifestValidationError{
@@ -218,6 +204,13 @@ func (m *ExtensionManifest) Validate() error {
 				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
@@ -288,7 +281,6 @@ func (m *ExtensionManifest) MatchesURL(urlStr string) bool {
 		return false
 	}
 
-	// Parse URL to get host
 	urlStr = strings.ToLower(strings.TrimSpace(urlStr))
 	for _, pattern := range m.URLHandler.Patterns {
 		pattern = strings.ToLower(strings.TrimSpace(pattern))

go_backend/extension_providers.go

@@ -2,11 +2,14 @@
 package gobackend
 
 import (
+	"context"
 	"encoding/json"
+	"errors"
 	"fmt"
 	"path/filepath"
 	"strings"
 	"sync"
+	"time"
 
 	"github.com/dop251/goja"
 )
@@ -28,6 +31,18 @@ type ExtTrackMetadata struct {
 	DiscNumber  int    `json:"disc_number,omitempty"`
 	ISRC        string `json:"isrc,omitempty"`
 	ProviderID  string `json:"provider_id"`
+	ItemType    string `json:"item_type,omitempty"`  // track, album, or playlist - for extension search results
+	AlbumType   string `json:"album_type,omitempty"` // album, single, ep, compilation
+	// Enrichment fields from Odesli/song.link
+	TidalID       string            `json:"tidal_id,omitempty"`
+	QobuzID       string            `json:"qobuz_id,omitempty"`
+	DeezerID      string            `json:"deezer_id,omitempty"`
+	SpotifyID     string            `json:"spotify_id,omitempty"`
+	ExternalLinks map[string]string `json:"external_links,omitempty"` // service -> URL mapping
+	// Extended metadata from enrichment (can come from Deezer, Spotify, etc.)
+	Label     string `json:"label,omitempty"`     // Record label
+	Copyright string `json:"copyright,omitempty"` // Copyright information
+	Genre     string `json:"genre,omitempty"`     // Music genre(s)
 }
 
 // ResolvedCoverURL returns the cover URL, checking both CoverURL and Images fields
@@ -46,17 +61,21 @@ type ExtAlbumMetadata struct {
 	CoverURL    string             `json:"cover_url,omitempty"`
 	ReleaseDate string             `json:"release_date,omitempty"`
 	TotalTracks int                `json:"total_tracks"`
+	AlbumType   string             `json:"album_type,omitempty"`
 	Tracks      []ExtTrackMetadata `json:"tracks"`
 	ProviderID  string             `json:"provider_id"`
 }
 
 // ExtArtistMetadata represents artist metadata from an extension
 type ExtArtistMetadata struct {
-	ID         string             `json:"id"`
-	Name       string             `json:"name"`
-	ImageURL   string             `json:"image_url,omitempty"`
-	Albums     []ExtAlbumMetadata `json:"albums,omitempty"`
-	ProviderID string             `json:"provider_id"`
+	ID          string             `json:"id"`
+	Name        string             `json:"name"`
+	ImageURL    string             `json:"image_url,omitempty"`
+	HeaderImage string             `json:"header_image,omitempty"` // Header image for artist page background
+	Listeners   int                `json:"listeners,omitempty"`    // Monthly listeners
+	Albums      []ExtAlbumMetadata `json:"albums,omitempty"`
+	TopTracks   []ExtTrackMetadata `json:"top_tracks,omitempty"` // Popular tracks
+	ProviderID  string             `json:"provider_id"`
 }
 
 // ExtSearchResult represents search results from an extension
@@ -130,6 +149,10 @@ func (p *ExtensionProviderWrapper) SearchTracks(query string, limit int) (*ExtSe
 		return nil, fmt.Errorf("extension '%s' is disabled", p.extension.ID)
 	}
 
+	// Lock VM to prevent concurrent access
+	p.extension.VMMu.Lock()
+	defer p.extension.VMMu.Unlock()
+
 	// Call extension's searchTracks function
 	script := fmt.Sprintf(`
 		(function() {
@@ -140,8 +163,11 @@ func (p *ExtensionProviderWrapper) SearchTracks(query string, limit int) (*ExtSe
 		})()
 	`, query, limit)
 
-	result, err := p.vm.RunString(script)
+	result, err := RunWithTimeoutAndRecover(p.vm, script, DefaultJSTimeout)
 	if err != nil {
+		if IsTimeoutError(err) {
+			return nil, fmt.Errorf("searchTracks timeout: extension took too long to respond")
+		}
 		return nil, fmt.Errorf("searchTracks failed: %w", err)
 	}
 
@@ -157,11 +183,21 @@ func (p *ExtensionProviderWrapper) SearchTracks(query string, limit int) (*ExtSe
 	}
 
 	var searchResult ExtSearchResult
+
+	// Try to parse as ExtSearchResult object first
 	if err := json.Unmarshal(jsonBytes, &searchResult); err != nil {
-		return nil, fmt.Errorf("failed to parse search result: %w", err)
+		// If that fails, try parsing as array of tracks directly
+		var tracks []ExtTrackMetadata
+		if arrErr := json.Unmarshal(jsonBytes, &tracks); arrErr != nil {
+			return nil, fmt.Errorf("failed to parse search result: %w (also tried array: %v)", err, arrErr)
+		}
+		// Wrap array in ExtSearchResult
+		searchResult = ExtSearchResult{
+			Tracks: tracks,
+			Total:  len(tracks),
+		}
 	}
 
-	// Set provider ID on all tracks
 	for i := range searchResult.Tracks {
 		searchResult.Tracks[i].ProviderID = p.extension.ID
 	}
@@ -179,6 +215,10 @@ func (p *ExtensionProviderWrapper) GetTrack(trackID string) (*ExtTrackMetadata,
 		return nil, fmt.Errorf("extension '%s' is disabled", p.extension.ID)
 	}
 
+	// Lock VM to prevent concurrent access
+	p.extension.VMMu.Lock()
+	defer p.extension.VMMu.Unlock()
+
 	script := fmt.Sprintf(`
 		(function() {
 			if (typeof extension !== 'undefined' && typeof extension.getTrack === 'function') {
@@ -188,8 +228,11 @@ func (p *ExtensionProviderWrapper) GetTrack(trackID string) (*ExtTrackMetadata,
 		})()
 	`, trackID)
 
-	result, err := p.vm.RunString(script)
+	result, err := RunWithTimeoutAndRecover(p.vm, script, DefaultJSTimeout)
 	if err != nil {
+		if IsTimeoutError(err) {
+			return nil, fmt.Errorf("getTrack timeout: extension took too long to respond")
+		}
 		return nil, fmt.Errorf("getTrack failed: %w", err)
 	}
 
@@ -222,6 +265,10 @@ func (p *ExtensionProviderWrapper) GetAlbum(albumID string) (*ExtAlbumMetadata,
 		return nil, fmt.Errorf("extension '%s' is disabled", p.extension.ID)
 	}
 
+	// Lock VM to prevent concurrent access
+	p.extension.VMMu.Lock()
+	defer p.extension.VMMu.Unlock()
+
 	script := fmt.Sprintf(`
 		(function() {
 			if (typeof extension !== 'undefined' && typeof extension.getAlbum === 'function') {
@@ -231,8 +278,11 @@ func (p *ExtensionProviderWrapper) GetAlbum(albumID string) (*ExtAlbumMetadata,
 		})()
 	`, albumID)
 
-	result, err := p.vm.RunString(script)
+	result, err := RunWithTimeoutAndRecover(p.vm, script, DefaultJSTimeout)
 	if err != nil {
+		if IsTimeoutError(err) {
+			return nil, fmt.Errorf("getAlbum timeout: extension took too long to respond")
+		}
 		return nil, fmt.Errorf("getAlbum failed: %w", err)
 	}
 
@@ -268,6 +318,10 @@ func (p *ExtensionProviderWrapper) GetArtist(artistID string) (*ExtArtistMetadat
 		return nil, fmt.Errorf("extension '%s' is disabled", p.extension.ID)
 	}
 
+	// Lock VM to prevent concurrent access
+	p.extension.VMMu.Lock()
+	defer p.extension.VMMu.Unlock()
+
 	script := fmt.Sprintf(`
 		(function() {
 			if (typeof extension !== 'undefined' && typeof extension.getArtist === 'function') {
@@ -277,8 +331,11 @@ func (p *ExtensionProviderWrapper) GetArtist(artistID string) (*ExtArtistMetadat
 		})()
 	`, artistID)
 
-	result, err := p.vm.RunString(script)
+	result, err := RunWithTimeoutAndRecover(p.vm, script, DefaultJSTimeout)
 	if err != nil {
+		if IsTimeoutError(err) {
+			return nil, fmt.Errorf("getArtist timeout: extension took too long to respond")
+		}
 		return nil, fmt.Errorf("getArtist failed: %w", err)
 	}
 
@@ -301,6 +358,76 @@ func (p *ExtensionProviderWrapper) GetArtist(artistID string) (*ExtArtistMetadat
 	return &artist, nil
 }
 
+// EnrichTrack enriches track metadata before download (e.g., fetch real ISRC)
+// This is called lazily when download starts, not when playlist/album is loaded
+// Extension should implement enrichTrack(track) function that returns enriched track
+func (p *ExtensionProviderWrapper) EnrichTrack(track *ExtTrackMetadata) (*ExtTrackMetadata, error) {
+	if !p.extension.Manifest.IsMetadataProvider() {
+		return track, nil // Not a metadata provider, return as-is
+	}
+
+	if !p.extension.Enabled {
+		return track, nil // Extension disabled, return as-is
+	}
+
+	// Lock VM to prevent concurrent access
+	p.extension.VMMu.Lock()
+	defer p.extension.VMMu.Unlock()
+
+	// Convert track to JSON for passing to JS
+	trackJSON, err := json.Marshal(track)
+	if err != nil {
+		GoLog("[Extension] EnrichTrack: failed to marshal track: %v\n", err)
+		return track, nil // Return original on error
+	}
+
+	script := fmt.Sprintf(`
+		(function() {
+			if (typeof extension !== 'undefined' && typeof extension.enrichTrack === 'function') {
+				var track = %s;
+				return extension.enrichTrack(track);
+			}
+			return null;
+		})()
+	`, string(trackJSON))
+
+	result, err := RunWithTimeoutAndRecover(p.vm, script, DefaultJSTimeout)
+	if err != nil {
+		if IsTimeoutError(err) {
+			GoLog("[Extension] EnrichTrack timeout for %s\n", p.extension.ID)
+		} else {
+			GoLog("[Extension] EnrichTrack error for %s: %v\n", p.extension.ID, err)
+		}
+		return track, nil // Return original on error
+	}
+
+	// If extension doesn't implement enrichTrack or returns null, return original
+	if result == nil || goja.IsUndefined(result) || goja.IsNull(result) {
+		return track, nil
+	}
+
+	exported := result.Export()
+	jsonBytes, err := json.Marshal(exported)
+	if err != nil {
+		GoLog("[Extension] EnrichTrack: failed to marshal result: %v\n", err)
+		return track, nil
+	}
+
+	var enrichedTrack ExtTrackMetadata
+	if err := json.Unmarshal(jsonBytes, &enrichedTrack); err != nil {
+		GoLog("[Extension] EnrichTrack: failed to parse enriched track: %v\n", err)
+		return track, nil
+	}
+
+	// Preserve provider ID
+	enrichedTrack.ProviderID = track.ProviderID
+
+	GoLog("[Extension] EnrichTrack: enriched track from %s (ISRC: %s -> %s)\n",
+		p.extension.ID, track.ISRC, enrichedTrack.ISRC)
+
+	return &enrichedTrack, nil
+}
+
 // ==================== Download Provider Methods ====================
 
 // CheckAvailability checks if a track is available for download
@@ -313,6 +440,10 @@ func (p *ExtensionProviderWrapper) CheckAvailability(isrc, trackName, artistName
 		return nil, fmt.Errorf("extension '%s' is disabled", p.extension.ID)
 	}
 
+	// Lock VM to prevent concurrent access
+	p.extension.VMMu.Lock()
+	defer p.extension.VMMu.Unlock()
+
 	script := fmt.Sprintf(`
 		(function() {
 			if (typeof extension !== 'undefined' && typeof extension.checkAvailability === 'function') {
@@ -322,8 +453,11 @@ func (p *ExtensionProviderWrapper) CheckAvailability(isrc, trackName, artistName
 		})()
 	`, isrc, trackName, artistName)
 
-	result, err := p.vm.RunString(script)
+	result, err := RunWithTimeoutAndRecover(p.vm, script, DefaultJSTimeout)
 	if err != nil {
+		if IsTimeoutError(err) {
+			return nil, fmt.Errorf("checkAvailability timeout: extension took too long to respond")
+		}
 		return nil, fmt.Errorf("checkAvailability failed: %w", err)
 	}
 
@@ -355,6 +489,10 @@ func (p *ExtensionProviderWrapper) GetDownloadURL(trackID, quality string) (*Ext
 		return nil, fmt.Errorf("extension '%s' is disabled", p.extension.ID)
 	}
 
+	// Lock VM to prevent concurrent access
+	p.extension.VMMu.Lock()
+	defer p.extension.VMMu.Unlock()
+
 	script := fmt.Sprintf(`
 		(function() {
 			if (typeof extension !== 'undefined' && typeof extension.getDownloadUrl === 'function') {
@@ -364,8 +502,11 @@ func (p *ExtensionProviderWrapper) GetDownloadURL(trackID, quality string) (*Ext
 		})()
 	`, trackID, quality)
 
-	result, err := p.vm.RunString(script)
+	result, err := RunWithTimeoutAndRecover(p.vm, script, DefaultJSTimeout)
 	if err != nil {
+		if IsTimeoutError(err) {
+			return nil, fmt.Errorf("getDownloadUrl timeout: extension took too long to respond")
+		}
 		return nil, fmt.Errorf("getDownloadUrl failed: %w", err)
 	}
 
@@ -387,6 +528,9 @@ func (p *ExtensionProviderWrapper) GetDownloadURL(trackID, quality string) (*Ext
 	return &urlResult, nil
 }
 
+// ExtDownloadTimeout is longer for extension download operations (5 minutes)
+const ExtDownloadTimeout = 5 * time.Minute
+
 // Download downloads a track with progress reporting
 func (p *ExtensionProviderWrapper) Download(trackID, quality, outputPath string, onProgress func(percent int)) (*ExtDownloadResult, error) {
 	if !p.extension.Manifest.IsDownloadProvider() {
@@ -397,6 +541,10 @@ func (p *ExtensionProviderWrapper) Download(trackID, quality, outputPath string,
 		return nil, fmt.Errorf("extension '%s' is disabled", p.extension.ID)
 	}
 
+	// Lock VM to prevent concurrent access
+	p.extension.VMMu.Lock()
+	defer p.extension.VMMu.Unlock()
+
 	// Set up progress callback in VM
 	p.vm.Set("__onProgress", func(call goja.FunctionCall) goja.Value {
 		if len(call.Arguments) > 0 {
@@ -424,12 +572,19 @@ func (p *ExtensionProviderWrapper) Download(trackID, quality, outputPath string,
 		})()
 	`, trackID, quality, outputPath)
 
-	result, err := p.vm.RunString(script)
+	// Use longer timeout for downloads (5 minutes)
+	result, err := RunWithTimeoutAndRecover(p.vm, script, ExtDownloadTimeout)
 	if err != nil {
+		errMsg := err.Error()
+		errType := "script_error"
+		if IsTimeoutError(err) {
+			errMsg = "download timeout: extension took too long to complete"
+			errType = "timeout"
+		}
 		return &ExtDownloadResult{
 			Success:      false,
-			ErrorMessage: err.Error(),
-			ErrorType:    "script_error",
+			ErrorMessage: errMsg,
+			ErrorType:    errType,
 		}, nil
 	}
 
@@ -595,13 +750,78 @@ func DownloadWithExtensionFallback(req DownloadRequest) (*DownloadResponse, erro
 	var lastErr error
 	var skipBuiltIn bool // If source extension has skipBuiltInFallback, don't try built-in providers
 
+	// LAZY ENRICHMENT: If track came from an extension, try to enrich metadata (e.g., get real ISRC)
+	// This is done lazily at download time, not when playlist/album is loaded
+	if req.Source != "" && !isBuiltInProvider(req.Source) {
+		ext, err := extManager.GetExtension(req.Source)
+		if err == nil && ext.Enabled && ext.Error == "" && ext.Manifest.IsMetadataProvider() {
+			GoLog("[DownloadWithExtensionFallback] Enriching track from extension '%s'...\n", req.Source)
+
+			provider := NewExtensionProviderWrapper(ext)
+			trackMeta := &ExtTrackMetadata{
+				ID:          req.SpotifyID,
+				Name:        req.TrackName,
+				Artists:     req.ArtistName,
+				AlbumName:   req.AlbumName,
+				DurationMS:  req.DurationMS,
+				ISRC:        req.ISRC,
+				ReleaseDate: req.ReleaseDate,
+				TrackNumber: req.TrackNumber,
+				DiscNumber:  req.DiscNumber,
+				ProviderID:  req.Source,
+			}
+
+			enrichedTrack, err := provider.EnrichTrack(trackMeta)
+			if err == nil && enrichedTrack != nil {
+				if enrichedTrack.ISRC != "" && enrichedTrack.ISRC != req.ISRC {
+					GoLog("[DownloadWithExtensionFallback] ISRC enriched: %s -> %s\n", req.ISRC, enrichedTrack.ISRC)
+					req.ISRC = enrichedTrack.ISRC
+				}
+				if enrichedTrack.TidalID != "" {
+					GoLog("[DownloadWithExtensionFallback] Tidal ID from Odesli: %s\n", enrichedTrack.TidalID)
+					req.TidalID = enrichedTrack.TidalID
+				}
+				if enrichedTrack.QobuzID != "" {
+					GoLog("[DownloadWithExtensionFallback] Qobuz ID from Odesli: %s\n", enrichedTrack.QobuzID)
+					req.QobuzID = enrichedTrack.QobuzID
+				}
+				if enrichedTrack.DeezerID != "" {
+					GoLog("[DownloadWithExtensionFallback] Deezer ID from Odesli: %s\n", enrichedTrack.DeezerID)
+					req.DeezerID = enrichedTrack.DeezerID
+				}
+				if enrichedTrack.Name != "" {
+					req.TrackName = enrichedTrack.Name
+				}
+				if enrichedTrack.Artists != "" {
+					req.ArtistName = enrichedTrack.Artists
+				}
+				// Copy extended metadata from enrichment (label, copyright, genre, release_date)
+				if enrichedTrack.Label != "" && req.Label == "" {
+					GoLog("[DownloadWithExtensionFallback] Label from enrichment: %s\n", enrichedTrack.Label)
+					req.Label = enrichedTrack.Label
+				}
+				if enrichedTrack.Copyright != "" && req.Copyright == "" {
+					GoLog("[DownloadWithExtensionFallback] Copyright from enrichment: %s\n", enrichedTrack.Copyright)
+					req.Copyright = enrichedTrack.Copyright
+				}
+				if enrichedTrack.Genre != "" && req.Genre == "" {
+					GoLog("[DownloadWithExtensionFallback] Genre from enrichment: %s\n", enrichedTrack.Genre)
+					req.Genre = enrichedTrack.Genre
+				}
+				if enrichedTrack.ReleaseDate != "" && req.ReleaseDate == "" {
+					GoLog("[DownloadWithExtensionFallback] ReleaseDate from enrichment: %s\n", enrichedTrack.ReleaseDate)
+					req.ReleaseDate = enrichedTrack.ReleaseDate
+				}
+			}
+		}
+	}
+
 	// If source extension is specified, try it first before the priority list
 	if req.Source != "" && !isBuiltInProvider(req.Source) {
 		GoLog("[DownloadWithExtensionFallback] Track source is extension '%s', trying it first\n", req.Source)
 
 		ext, err := extManager.GetExtension(req.Source)
 		if err == nil && ext.Enabled && ext.Error == "" && ext.Manifest.IsDownloadProvider() {
-			// Check if this extension wants to skip built-in fallback
 			skipBuiltIn = ext.Manifest.SkipBuiltInFallback
 
 			provider := NewExtensionProviderWrapper(ext)
@@ -612,7 +832,6 @@ func DownloadWithExtensionFallback(req DownloadRequest) (*DownloadResponse, erro
 
 			GoLog("[DownloadWithExtensionFallback] Downloading from source extension with trackID: %s (skipBuiltInFallback: %v)\n", trackID, skipBuiltIn)
 
-			// Build output path
 			outputPath := buildOutputPath(req)
 
 			// Download directly using the track ID from the extension
@@ -630,6 +849,18 @@ func DownloadWithExtensionFallback(req DownloadRequest) (*DownloadResponse, erro
 					ActualBitDepth:   result.BitDepth,
 					ActualSampleRate: result.SampleRate,
 					Service:          req.Source,
+					Genre:            req.Genre,
+					Label:            req.Label,
+					Copyright:        req.Copyright,
+				}
+
+				// Embed genre and label if provided (from Deezer metadata)
+				if req.Genre != "" || req.Label != "" {
+					if err := EmbedGenreLabel(result.FilePath, req.Genre, req.Label); err != nil {
+						GoLog("[DownloadWithExtensionFallback] Warning: failed to embed genre/label: %v\n", err)
+					} else {
+						GoLog("[DownloadWithExtensionFallback] Embedded genre=%q label=%q\n", req.Genre, req.Label)
+					}
 				}
 
 				// If extension has skipMetadataEnrichment, copy metadata
@@ -668,6 +899,14 @@ func DownloadWithExtensionFallback(req DownloadRequest) (*DownloadResponse, erro
 			}
 
 			if err != nil {
+				if errors.Is(err, ErrDownloadCancelled) {
+					return &DownloadResponse{
+						Success:   false,
+						Error:     "Download cancelled",
+						ErrorType: "cancelled",
+						Service:   req.Source,
+					}, nil
+				}
 				lastErr = err
 			} else if result.ErrorMessage != "" {
 				lastErr = fmt.Errorf("%s", result.ErrorMessage)
@@ -705,13 +944,55 @@ func DownloadWithExtensionFallback(req DownloadRequest) (*DownloadResponse, erro
 		GoLog("[DownloadWithExtensionFallback] Trying provider: %s\n", providerID)
 
 		if isBuiltInProvider(providerID) {
+			// For built-in providers, enrich with Deezer metadata if not already present
+			if (req.Genre == "" || req.Label == "") && req.ISRC != "" {
+				GoLog("[DownloadWithExtensionFallback] Enriching extended metadata from Deezer for ISRC: %s\n", req.ISRC)
+				ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+				deezerClient := GetDeezerClient()
+				extMeta, err := deezerClient.GetExtendedMetadataByISRC(ctx, req.ISRC)
+				cancel()
+				if err == nil && extMeta != nil {
+					if req.Genre == "" && extMeta.Genre != "" {
+						req.Genre = extMeta.Genre
+						GoLog("[DownloadWithExtensionFallback] Genre from Deezer: %s\n", req.Genre)
+					}
+					if req.Label == "" && extMeta.Label != "" {
+						req.Label = extMeta.Label
+						GoLog("[DownloadWithExtensionFallback] Label from Deezer: %s\n", req.Label)
+					}
+				} else if err != nil {
+					GoLog("[DownloadWithExtensionFallback] Failed to get extended metadata from Deezer: %v\n", err)
+				}
+			}
+
 			// Use built-in provider
 			result, err := tryBuiltInProvider(providerID, req)
 			if err == nil && result.Success {
 				result.Service = providerID
+				// Copy enriched metadata to response for Flutter (needed for M4A->FLAC conversion)
+				if req.Label != "" {
+					result.Label = req.Label
+				}
+				if req.Copyright != "" {
+					result.Copyright = req.Copyright
+				}
+				if req.Genre != "" {
+					result.Genre = req.Genre
+				}
+				if req.ReleaseDate != "" && result.ReleaseDate == "" {
+					result.ReleaseDate = req.ReleaseDate
+				}
 				return result, nil
 			}
 			if err != nil {
+				if errors.Is(err, ErrDownloadCancelled) {
+					return &DownloadResponse{
+						Success:   false,
+						Error:     "Download cancelled",
+						ErrorType: "cancelled",
+						Service:   providerID,
+					}, nil
+				}
 				lastErr = err
 				GoLog("[DownloadWithExtensionFallback] %s failed: %v\n", providerID, err)
 			}
@@ -729,7 +1010,6 @@ func DownloadWithExtensionFallback(req DownloadRequest) (*DownloadResponse, erro
 
 			provider := NewExtensionProviderWrapper(ext)
 
-			// Check availability first
 			availability, err := provider.CheckAvailability(req.ISRC, req.TrackName, req.ArtistName)
 			if err != nil || !availability.Available {
 				GoLog("[DownloadWithExtensionFallback] %s: not available\n", providerID)
@@ -739,12 +1019,9 @@ func DownloadWithExtensionFallback(req DownloadRequest) (*DownloadResponse, erro
 				continue
 			}
 
-			// Build output path
 			outputPath := buildOutputPath(req)
 
-			// Download
 			result, err := provider.Download(availability.TrackID, req.Quality, outputPath, func(percent int) {
-				// Update progress
 				if req.ItemID != "" {
 					SetItemProgress(req.ItemID, float64(percent), 0, 0)
 				}
@@ -758,6 +1035,18 @@ func DownloadWithExtensionFallback(req DownloadRequest) (*DownloadResponse, erro
 					ActualBitDepth:   result.BitDepth,
 					ActualSampleRate: result.SampleRate,
 					Service:          providerID,
+					Genre:            req.Genre,
+					Label:            req.Label,
+					Copyright:        req.Copyright,
+				}
+
+				// Embed genre and label if provided (from Deezer metadata)
+				if req.Genre != "" || req.Label != "" {
+					if err := EmbedGenreLabel(result.FilePath, req.Genre, req.Label); err != nil {
+						GoLog("[DownloadWithExtensionFallback] Warning: failed to embed genre/label: %v\n", err)
+					} else {
+						GoLog("[DownloadWithExtensionFallback] Embedded genre=%q label=%q\n", req.Genre, req.Label)
+					}
 				}
 
 				// If extension has skipMetadataEnrichment and returned metadata, use it
@@ -797,6 +1086,14 @@ func DownloadWithExtensionFallback(req DownloadRequest) (*DownloadResponse, erro
 			}
 
 			if err != nil {
+				if errors.Is(err, ErrDownloadCancelled) {
+					return &DownloadResponse{
+						Success:   false,
+						Error:     "Download cancelled",
+						ErrorType: "cancelled",
+						Service:   providerID,
+					}, nil
+				}
 				lastErr = err
 			} else if result.ErrorMessage != "" {
 				lastErr = fmt.Errorf("%s", result.ErrorMessage)
@@ -900,6 +1197,9 @@ func tryBuiltInProvider(providerID string, req DownloadRequest) (*DownloadRespon
 		TrackNumber:      result.TrackNumber,
 		DiscNumber:       result.DiscNumber,
 		ISRC:             result.ISRC,
+		Genre:            req.Genre,
+		Label:            req.Label,
+		Copyright:        req.Copyright,
 	}, nil
 }
 
@@ -935,6 +1235,10 @@ func (p *ExtensionProviderWrapper) CustomSearch(query string, options map[string
 		return nil, fmt.Errorf("extension '%s' is disabled", p.extension.ID)
 	}
 
+	// Lock VM to prevent concurrent access
+	p.extension.VMMu.Lock()
+	defer p.extension.VMMu.Unlock()
+
 	// Convert options to JSON
 	optionsJSON, _ := json.Marshal(options)
 
@@ -947,8 +1251,11 @@ func (p *ExtensionProviderWrapper) CustomSearch(query string, options map[string
 		})()
 	`, query, string(optionsJSON))
 
-	result, err := p.vm.RunString(script)
+	result, err := RunWithTimeoutAndRecover(p.vm, script, DefaultJSTimeout)
 	if err != nil {
+		if IsTimeoutError(err) {
+			return nil, fmt.Errorf("customSearch timeout: extension took too long to respond")
+		}
 		return nil, fmt.Errorf("customSearch failed: %w", err)
 	}
 
@@ -973,7 +1280,6 @@ func (p *ExtensionProviderWrapper) CustomSearch(query string, options map[string
 		tracks = []ExtTrackMetadata{}
 	}
 
-	// Set provider ID on all tracks
 	for i := range tracks {
 		tracks[i].ProviderID = p.extension.ID
 	}
@@ -1004,6 +1310,10 @@ func (p *ExtensionProviderWrapper) HandleURL(url string) (*ExtURLHandleResult, e
 		return nil, fmt.Errorf("extension '%s' is disabled", p.extension.ID)
 	}
 
+	// Lock VM to prevent concurrent access
+	p.extension.VMMu.Lock()
+	defer p.extension.VMMu.Unlock()
+
 	script := fmt.Sprintf(`
 		(function() {
 			if (typeof extension !== 'undefined' && typeof extension.handleUrl === 'function') {
@@ -1013,8 +1323,11 @@ func (p *ExtensionProviderWrapper) HandleURL(url string) (*ExtURLHandleResult, e
 		})()
 	`, url)
 
-	result, err := p.vm.RunString(script)
+	result, err := RunWithTimeoutAndRecover(p.vm, script, DefaultJSTimeout)
 	if err != nil {
+		if IsTimeoutError(err) {
+			return nil, fmt.Errorf("handleUrl timeout: extension took too long to respond")
+		}
 		return nil, fmt.Errorf("handleUrl failed: %w", err)
 	}
 
@@ -1040,6 +1353,24 @@ func (p *ExtensionProviderWrapper) HandleURL(url string) (*ExtURLHandleResult, e
 	for i := range handleResult.Tracks {
 		handleResult.Tracks[i].ProviderID = p.extension.ID
 	}
+	if handleResult.Album != nil {
+		handleResult.Album.ProviderID = p.extension.ID
+		for i := range handleResult.Album.Tracks {
+			handleResult.Album.Tracks[i].ProviderID = p.extension.ID
+		}
+	}
+	if handleResult.Artist != nil {
+		handleResult.Artist.ProviderID = p.extension.ID
+		for i := range handleResult.Artist.Albums {
+			handleResult.Artist.Albums[i].ProviderID = p.extension.ID
+			for j := range handleResult.Artist.Albums[i].Tracks {
+				handleResult.Artist.Albums[i].Tracks[j].ProviderID = p.extension.ID
+			}
+		}
+		for i := range handleResult.Artist.TopTracks {
+			handleResult.Artist.TopTracks[i].ProviderID = p.extension.ID
+		}
+	}
 
 	return &handleResult, nil
 }
@@ -1064,6 +1395,10 @@ func (p *ExtensionProviderWrapper) MatchTrack(sourceTrack map[string]interface{}
 		return nil, fmt.Errorf("extension '%s' is disabled", p.extension.ID)
 	}
 
+	// Lock VM to prevent concurrent access
+	p.extension.VMMu.Lock()
+	defer p.extension.VMMu.Unlock()
+
 	sourceJSON, _ := json.Marshal(sourceTrack)
 	candidatesJSON, _ := json.Marshal(candidates)
 
@@ -1076,8 +1411,11 @@ func (p *ExtensionProviderWrapper) MatchTrack(sourceTrack map[string]interface{}
 		})()
 	`, string(sourceJSON), string(candidatesJSON))
 
-	result, err := p.vm.RunString(script)
+	result, err := RunWithTimeoutAndRecover(p.vm, script, DefaultJSTimeout)
 	if err != nil {
+		if IsTimeoutError(err) {
+			return nil, fmt.Errorf("matchTrack timeout: extension took too long to respond")
+		}
 		return nil, fmt.Errorf("matchTrack failed: %w", err)
 	}
 
@@ -1111,6 +1449,9 @@ type PostProcessResult struct {
 	SampleRate int `json:"sample_rate,omitempty"`
 }
 
+// PostProcessTimeout is longer for post-processing (2 minutes)
+const PostProcessTimeout = 2 * time.Minute
+
 // PostProcess runs post-processing hooks on a downloaded file
 func (p *ExtensionProviderWrapper) PostProcess(filePath string, metadata map[string]interface{}, hookID string) (*PostProcessResult, error) {
 	if !p.extension.Manifest.HasPostProcessing() {
@@ -1121,6 +1462,10 @@ func (p *ExtensionProviderWrapper) PostProcess(filePath string, metadata map[str
 		return nil, fmt.Errorf("extension '%s' is disabled", p.extension.ID)
 	}
 
+	// Lock VM to prevent concurrent access
+	p.extension.VMMu.Lock()
+	defer p.extension.VMMu.Unlock()
+
 	metadataJSON, _ := json.Marshal(metadata)
 
 	script := fmt.Sprintf(`
@@ -1132,11 +1477,15 @@ func (p *ExtensionProviderWrapper) PostProcess(filePath string, metadata map[str
 		})()
 	`, filePath, string(metadataJSON), hookID)
 
-	result, err := p.vm.RunString(script)
+	result, err := RunWithTimeoutAndRecover(p.vm, script, PostProcessTimeout)
 	if err != nil {
+		errMsg := err.Error()
+		if IsTimeoutError(err) {
+			errMsg = "postProcess timeout: extension took too long to complete"
+		}
 		return &PostProcessResult{
 			Success: false,
-			Error:   err.Error(),
+			Error:   errMsg,
 		}, nil
 	}
 
@@ -1263,12 +1612,10 @@ func (m *ExtensionManager) RunPostProcessing(filePath string, metadata map[strin
 	for _, provider := range providers {
 		hooks := provider.extension.Manifest.GetPostProcessingHooks()
 		for _, hook := range hooks {
-			// Check if hook is enabled (TODO: check user settings)
 			if !hook.DefaultEnabled {
 				continue
 			}
 
-			// Check if format is supported
 			ext := strings.ToLower(filepath.Ext(currentPath))
 			if len(hook.SupportedFormats) > 0 {
 				supported := false

go_backend/extension_runtime.go

@@ -1,4 +1,3 @@
-// Package gobackend provides extension runtime with sandboxed execution
 package gobackend
 
 import (
@@ -10,13 +9,13 @@ import (
 	"github.com/dop251/goja"
 )
 
-// Global auth state for extensions (stores pending auth codes)
+const DefaultJSTimeout = 30 * time.Second
+
 var (
 	extensionAuthState   = make(map[string]*ExtensionAuthState)
 	extensionAuthStateMu sync.RWMutex
 )
 
-// ExtensionAuthState holds auth state for an extension
 type ExtensionAuthState struct {
 	PendingAuthURL  string
 	AuthCode        string
@@ -29,14 +28,12 @@ type ExtensionAuthState struct {
 	PKCEChallenge string
 }
 
-// PendingAuthRequest holds a pending OAuth request that needs Flutter to open URL
 type PendingAuthRequest struct {
 	ExtensionID string
 	AuthURL     string
 	CallbackURL string
 }
 
-// Global pending auth requests (Flutter polls this)
 var (
 	pendingAuthRequests   = make(map[string]*PendingAuthRequest)
 	pendingAuthRequestsMu sync.RWMutex
@@ -49,14 +46,12 @@ func GetPendingAuthRequest(extensionID string) *PendingAuthRequest {
 	return pendingAuthRequests[extensionID]
 }
 
-// ClearPendingAuthRequest clears pending auth request (called from Flutter after opening URL)
 func ClearPendingAuthRequest(extensionID string) {
 	pendingAuthRequestsMu.Lock()
 	defer pendingAuthRequestsMu.Unlock()
 	delete(pendingAuthRequests, extensionID)
 }
 
-// SetExtensionAuthCode sets auth code for an extension (called from Flutter after OAuth callback)
 func SetExtensionAuthCode(extensionID string, authCode string) {
 	extensionAuthStateMu.Lock()
 	defer extensionAuthStateMu.Unlock()
@@ -69,7 +64,6 @@ func SetExtensionAuthCode(extensionID string, authCode string) {
 	state.AuthCode = authCode
 }
 
-// SetExtensionTokens sets access/refresh tokens for an extension
 func SetExtensionTokens(extensionID string, accessToken, refreshToken string, expiresAt time.Time) {
 	extensionAuthStateMu.Lock()
 	defer extensionAuthStateMu.Unlock()
@@ -85,7 +79,6 @@ func SetExtensionTokens(extensionID string, accessToken, refreshToken string, ex
 	state.IsAuthenticated = accessToken != ""
 }
 
-// ExtensionRuntime provides sandboxed APIs for extensions
 type ExtensionRuntime struct {
 	extensionID string
 	manifest    *ExtensionManifest
@@ -96,28 +89,90 @@ type ExtensionRuntime struct {
 	vm          *goja.Runtime
 }
 
-// NewExtensionRuntime creates a new runtime for an extension
 func NewExtensionRuntime(ext *LoadedExtension) *ExtensionRuntime {
-	// Create a cookie jar for this extension
 	jar, _ := newSimpleCookieJar()
 
-	client := &http.Client{
-		Timeout: 30 * time.Second,
-		Jar:     jar,
-	}
-
-	return &ExtensionRuntime{
+	runtime := &ExtensionRuntime{
 		extensionID: ext.ID,
 		manifest:    ext.Manifest,
 		settings:    make(map[string]interface{}),
-		httpClient:  client,
 		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
 }
 
-// simpleCookieJar is a simple in-memory cookie jar
 type simpleCookieJar struct {
 	cookies map[string][]*http.Cookie
 	mu      sync.RWMutex
@@ -142,7 +197,6 @@ func (j *simpleCookieJar) Cookies(u *url.URL) []*http.Cookie {
 	return j.cookies[u.Host]
 }
 
-// SetSettings updates the runtime settings
 func (r *ExtensionRuntime) SetSettings(settings map[string]interface{}) {
 	r.settings = settings
 }
@@ -162,7 +216,6 @@ func (r *ExtensionRuntime) RegisterAPIs(vm *goja.Runtime) {
 	httpObj.Set("clearCookies", r.httpClearCookies)
 	vm.Set("http", httpObj)
 
-	// Storage API
 	storageObj := vm.NewObject()
 	storageObj.Set("get", r.storageGet)
 	storageObj.Set("set", r.storageSet)
@@ -177,7 +230,6 @@ func (r *ExtensionRuntime) RegisterAPIs(vm *goja.Runtime) {
 	credentialsObj.Set("has", r.credentialsHas)
 	vm.Set("credentials", credentialsObj)
 
-	// Auth API (for OAuth and other auth flows)
 	authObj := vm.NewObject()
 	authObj.Set("openAuthUrl", r.authOpenUrl)
 	authObj.Set("getAuthCode", r.authGetCode)
@@ -204,7 +256,6 @@ func (r *ExtensionRuntime) RegisterAPIs(vm *goja.Runtime) {
 	fileObj.Set("getSize", r.fileGetSize)
 	vm.Set("file", fileObj)
 
-	// FFmpeg API (for post-processing)
 	ffmpegObj := vm.NewObject()
 	ffmpegObj.Set("execute", r.ffmpegExecute)
 	ffmpegObj.Set("getInfo", r.ffmpegGetInfo)
@@ -218,7 +269,6 @@ func (r *ExtensionRuntime) RegisterAPIs(vm *goja.Runtime) {
 	matchingObj.Set("normalizeString", r.matchingNormalizeString)
 	vm.Set("matching", matchingObj)
 
-	// Utilities
 	utilsObj := vm.NewObject()
 	utilsObj.Set("base64Encode", r.base64Encode)
 	utilsObj.Set("base64Decode", r.base64Decode)
@@ -233,6 +283,7 @@ func (r *ExtensionRuntime) RegisterAPIs(vm *goja.Runtime) {
 	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)
@@ -243,7 +294,6 @@ func (r *ExtensionRuntime) RegisterAPIs(vm *goja.Runtime) {
 	logObj.Set("error", r.logError)
 	vm.Set("log", logObj)
 
-	// Go backend functions
 	gobackendObj := vm.NewObject()
 	gobackendObj.Set("sanitizeFilename", r.sanitizeFilenameWrapper)
 	vm.Set("gobackend", gobackendObj)
@@ -254,16 +304,12 @@ func (r *ExtensionRuntime) RegisterAPIs(vm *goja.Runtime) {
 	// Global fetch() - Promise-style HTTP API (browser-compatible)
 	vm.Set("fetch", r.fetchPolyfill)
 
-	// Global atob/btoa - Base64 encoding (browser-compatible)
 	vm.Set("atob", r.atobPolyfill)
 	vm.Set("btoa", r.btoaPolyfill)
 
-	// TextEncoder/TextDecoder constructors
 	r.registerTextEncoderDecoder(vm)
 
-	// URL class for URL parsing
 	r.registerURLClass(vm)
 
-	// JSON global (browser-compatible)
 	r.registerJSONGlobal(vm)
 }

go_backend/extension_runtime_auth.go

@@ -18,7 +18,6 @@ import (
 
 // ==================== Auth API (OAuth Support) ====================
 
-// authOpenUrl requests Flutter to open an OAuth URL
 func (r *ExtensionRuntime) authOpenUrl(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 1 {
 		return r.vm.ToValue(map[string]interface{}{
@@ -33,7 +32,6 @@ func (r *ExtensionRuntime) authOpenUrl(call goja.FunctionCall) goja.Value {
 		callbackURL = call.Arguments[1].String()
 	}
 
-	// Store pending auth request for Flutter to pick up
 	pendingAuthRequestsMu.Lock()
 	pendingAuthRequests[r.extensionID] = &PendingAuthRequest{
 		ExtensionID: r.extensionID,
@@ -42,7 +40,6 @@ func (r *ExtensionRuntime) authOpenUrl(call goja.FunctionCall) goja.Value {
 	}
 	pendingAuthRequestsMu.Unlock()
 
-	// Update auth state
 	extensionAuthStateMu.Lock()
 	state, exists := extensionAuthState[r.extensionID]
 	if !exists {
@@ -50,7 +47,7 @@ func (r *ExtensionRuntime) authOpenUrl(call goja.FunctionCall) goja.Value {
 		extensionAuthState[r.extensionID] = state
 	}
 	state.PendingAuthURL = authURL
-	state.AuthCode = "" // Clear any previous auth code
+	state.AuthCode = ""
 	extensionAuthStateMu.Unlock()
 
 	GoLog("[Extension:%s] Auth URL requested: %s\n", r.extensionID, authURL)
@@ -61,7 +58,6 @@ func (r *ExtensionRuntime) authOpenUrl(call goja.FunctionCall) goja.Value {
 	})
 }
 
-// authGetCode gets the auth code (set by Flutter after OAuth callback)
 func (r *ExtensionRuntime) authGetCode(call goja.FunctionCall) goja.Value {
 	extensionAuthStateMu.RLock()
 	defer extensionAuthStateMu.RUnlock()
@@ -114,7 +110,6 @@ func (r *ExtensionRuntime) authSetCode(call goja.FunctionCall) goja.Value {
 	return r.vm.ToValue(true)
 }
 
-// authClear clears all auth state for the extension
 func (r *ExtensionRuntime) authClear(call goja.FunctionCall) goja.Value {
 	extensionAuthStateMu.Lock()
 	delete(extensionAuthState, r.extensionID)
@@ -138,7 +133,6 @@ func (r *ExtensionRuntime) authIsAuthenticated(call goja.FunctionCall) goja.Valu
 		return r.vm.ToValue(false)
 	}
 
-	// Check if token is expired
 	if state.IsAuthenticated && !state.ExpiresAt.IsZero() && time.Now().After(state.ExpiresAt) {
 		return r.vm.ToValue(false)
 	}
@@ -146,7 +140,6 @@ func (r *ExtensionRuntime) authIsAuthenticated(call goja.FunctionCall) goja.Valu
 	return r.vm.ToValue(state.IsAuthenticated)
 }
 
-// authGetTokens returns current tokens (for extension to use in API calls)
 func (r *ExtensionRuntime) authGetTokens(call goja.FunctionCall) goja.Value {
 	extensionAuthStateMu.RLock()
 	defer extensionAuthStateMu.RUnlock()
@@ -182,16 +175,13 @@ func generatePKCEVerifier(length int) (string, error) {
 		length = 128
 	}
 
-	// Generate random bytes
 	bytes := make([]byte, length)
 	if _, err := rand.Read(bytes); err != nil {
 		return "", err
 	}
 
-	// Use base64url encoding without padding (RFC 7636 compliant)
 	verifier := base64.RawURLEncoding.EncodeToString(bytes)
 
-	// Trim to exact length
 	if len(verifier) > length {
 		verifier = verifier[:length]
 	}
@@ -199,15 +189,12 @@ func generatePKCEVerifier(length int) (string, error) {
 	return verifier, nil
 }
 
-// generatePKCEChallenge generates a code challenge from verifier using S256 method
 func generatePKCEChallenge(verifier string) string {
 	hash := sha256.Sum256([]byte(verifier))
 	// Base64url encode without padding (RFC 7636)
 	return base64.RawURLEncoding.EncodeToString(hash[:])
 }
 
-// authGeneratePKCE generates a PKCE code verifier and challenge pair
-// Returns: { verifier: string, challenge: string, method: "S256" }
 func (r *ExtensionRuntime) authGeneratePKCE(call goja.FunctionCall) goja.Value {
 	// Default length is 64 characters
 	length := 64
@@ -227,7 +214,6 @@ func (r *ExtensionRuntime) authGeneratePKCE(call goja.FunctionCall) goja.Value {
 
 	challenge := generatePKCEChallenge(verifier)
 
-	// Store in auth state for later use
 	extensionAuthStateMu.Lock()
 	state, exists := extensionAuthState[r.extensionID]
 	if !exists {
@@ -247,7 +233,6 @@ func (r *ExtensionRuntime) authGeneratePKCE(call goja.FunctionCall) goja.Value {
 	})
 }
 
-// authGetPKCE returns the current PKCE verifier and challenge (if generated)
 func (r *ExtensionRuntime) authGetPKCE(call goja.FunctionCall) goja.Value {
 	extensionAuthStateMu.RLock()
 	defer extensionAuthStateMu.RUnlock()
@@ -405,7 +390,6 @@ func (r *ExtensionRuntime) authExchangeCodeWithPKCE(call goja.FunctionCall) goja
 		})
 	}
 
-	// Get stored PKCE verifier
 	extensionAuthStateMu.RLock()
 	state, exists := extensionAuthState[r.extensionID]
 	var verifier string
@@ -421,7 +405,6 @@ func (r *ExtensionRuntime) authExchangeCodeWithPKCE(call goja.FunctionCall) goja
 		})
 	}
 
-	// Validate domain
 	if err := r.validateDomain(tokenURL); err != nil {
 		return r.vm.ToValue(map[string]interface{}{
 			"success": false,
@@ -429,7 +412,6 @@ func (r *ExtensionRuntime) authExchangeCodeWithPKCE(call goja.FunctionCall) goja
 		})
 	}
 
-	// Build token request body
 	formData := url.Values{}
 	formData.Set("grant_type", "authorization_code")
 	formData.Set("client_id", clientID)
@@ -439,14 +421,12 @@ func (r *ExtensionRuntime) authExchangeCodeWithPKCE(call goja.FunctionCall) goja
 		formData.Set("redirect_uri", redirectURI)
 	}
 
-	// Add extra params
 	if extraParams, ok := config["extraParams"].(map[string]interface{}); ok {
 		for k, v := range extraParams {
 			formData.Set(k, fmt.Sprintf("%v", v))
 		}
 	}
 
-	// Make token request
 	req, err := http.NewRequest("POST", tokenURL, strings.NewReader(formData.Encode()))
 	if err != nil {
 		return r.vm.ToValue(map[string]interface{}{
@@ -475,7 +455,6 @@ func (r *ExtensionRuntime) authExchangeCodeWithPKCE(call goja.FunctionCall) goja
 		})
 	}
 
-	// Parse response
 	var tokenResp map[string]interface{}
 	if err := json.Unmarshal(body, &tokenResp); err != nil {
 		return r.vm.ToValue(map[string]interface{}{
@@ -485,7 +464,6 @@ func (r *ExtensionRuntime) authExchangeCodeWithPKCE(call goja.FunctionCall) goja
 		})
 	}
 
-	// Check for error in response
 	if errMsg, ok := tokenResp["error"].(string); ok {
 		errDesc, _ := tokenResp["error_description"].(string)
 		return r.vm.ToValue(map[string]interface{}{
@@ -495,7 +473,6 @@ func (r *ExtensionRuntime) authExchangeCodeWithPKCE(call goja.FunctionCall) goja
 		})
 	}
 
-	// Extract tokens
 	accessToken, _ := tokenResp["access_token"].(string)
 	refreshToken, _ := tokenResp["refresh_token"].(string)
 	expiresIn, _ := tokenResp["expires_in"].(float64)
@@ -508,7 +485,6 @@ func (r *ExtensionRuntime) authExchangeCodeWithPKCE(call goja.FunctionCall) goja
 		})
 	}
 
-	// Store tokens in auth state
 	extensionAuthStateMu.Lock()
 	state, exists = extensionAuthState[r.extensionID]
 	if !exists {
@@ -521,14 +497,12 @@ func (r *ExtensionRuntime) authExchangeCodeWithPKCE(call goja.FunctionCall) goja
 	if expiresIn > 0 {
 		state.ExpiresAt = time.Now().Add(time.Duration(expiresIn) * time.Second)
 	}
-	// Clear PKCE after successful exchange
 	state.PKCEVerifier = ""
 	state.PKCEChallenge = ""
 	extensionAuthStateMu.Unlock()
 
 	GoLog("[Extension:%s] PKCE token exchange successful\n", r.extensionID)
 
-	// Return full token response
 	result := map[string]interface{}{
 		"success":       true,
 		"access_token":  accessToken,
@@ -538,7 +512,6 @@ func (r *ExtensionRuntime) authExchangeCodeWithPKCE(call goja.FunctionCall) goja
 	if expiresIn > 0 {
 		result["expires_in"] = expiresIn
 	}
-	// Include any additional fields from response
 	if scope, ok := tokenResp["scope"].(string); ok {
 		result["scope"] = scope
 	}

go_backend/extension_runtime_ffmpeg.go

@@ -31,14 +31,12 @@ var (
 	ffmpegCommandID  int64
 )
 
-// GetPendingFFmpegCommand returns a pending FFmpeg command (called from Flutter)
 func GetPendingFFmpegCommand(commandID string) *FFmpegCommand {
 	ffmpegCommandsMu.RLock()
 	defer ffmpegCommandsMu.RUnlock()
 	return ffmpegCommands[commandID]
 }
 
-// SetFFmpegCommandResult sets the result of an FFmpeg command (called from Flutter)
 func SetFFmpegCommandResult(commandID string, success bool, output, errorMsg string) {
 	ffmpegCommandsMu.Lock()
 	defer ffmpegCommandsMu.Unlock()
@@ -50,14 +48,12 @@ func SetFFmpegCommandResult(commandID string, success bool, output, errorMsg str
 	}
 }
 
-// ClearFFmpegCommand removes a completed FFmpeg command
 func ClearFFmpegCommand(commandID string) {
 	ffmpegCommandsMu.Lock()
 	defer ffmpegCommandsMu.Unlock()
 	delete(ffmpegCommands, commandID)
 }
 
-// ffmpegExecute queues an FFmpeg command for execution by Flutter
 func (r *ExtensionRuntime) ffmpegExecute(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 1 {
 		return r.vm.ToValue(map[string]interface{}{
@@ -118,7 +114,6 @@ func (r *ExtensionRuntime) ffmpegExecute(call goja.FunctionCall) goja.Value {
 	}
 }
 
-// ffmpegGetInfo gets audio file information using FFprobe
 func (r *ExtensionRuntime) ffmpegGetInfo(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 1 {
 		return r.vm.ToValue(map[string]interface{}{
@@ -147,7 +142,6 @@ func (r *ExtensionRuntime) ffmpegGetInfo(call goja.FunctionCall) goja.Value {
 	})
 }
 
-// ffmpegConvert is a helper for common conversion operations
 func (r *ExtensionRuntime) ffmpegConvert(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 2 {
 		return r.vm.ToValue(map[string]interface{}{

go_backend/extension_runtime_file.go

@@ -8,34 +8,78 @@ import (
 	"os"
 	"path/filepath"
 	"strings"
+	"sync"
 
 	"github.com/dop251/goja"
 )
 
 // ==================== File API (Sandboxed) ====================
 
-// validatePath checks if the path is within the extension's data directory
-// For absolute paths (from download queue), it allows them if they're valid
-func (r *ExtensionRuntime) validatePath(path string) (string, error) {
-	// Clean and resolve the path
-	cleanPath := filepath.Clean(path)
+// List of allowed directories for file operations (set by Go backend for download operations)
+var (
+	allowedDownloadDirs   []string
+	allowedDownloadDirsMu sync.RWMutex
+)
 
-	// If path is absolute, allow it (for download queue paths)
-	// This is safe because the Go backend controls what paths are passed
-	if filepath.IsAbs(cleanPath) {
-		return cleanPath, nil
+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")
 	}
 
-	// For relative paths, join with data directory
 	fullPath := filepath.Join(r.dataDir, cleanPath)
 
-	// Resolve to absolute path
 	absPath, err := filepath.Abs(fullPath)
 	if err != nil {
 		return "", fmt.Errorf("invalid path: %w", err)
 	}
 
-	// Ensure path is within data directory
 	absDataDir, _ := filepath.Abs(r.dataDir)
 	if !strings.HasPrefix(absPath, absDataDir) {
 		return "", fmt.Errorf("file access denied: path '%s' is outside sandbox", path)
@@ -44,8 +88,6 @@ func (r *ExtensionRuntime) validatePath(path string) (string, error) {
 	return absPath, nil
 }
 
-// fileDownload downloads a file from URL to the specified path
-// Supports progress callback via options.onProgress
 func (r *ExtensionRuntime) fileDownload(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 2 {
 		return r.vm.ToValue(map[string]interface{}{
@@ -57,7 +99,6 @@ func (r *ExtensionRuntime) fileDownload(call goja.FunctionCall) goja.Value {
 	urlStr := call.Arguments[0].String()
 	outputPath := call.Arguments[1].String()
 
-	// Validate domain
 	if err := r.validateDomain(urlStr); err != nil {
 		return r.vm.ToValue(map[string]interface{}{
 			"success": false,
@@ -65,7 +106,6 @@ func (r *ExtensionRuntime) fileDownload(call goja.FunctionCall) goja.Value {
 		})
 	}
 
-	// Validate output path (allows absolute paths for download queue)
 	fullPath, err := r.validatePath(outputPath)
 	if err != nil {
 		return r.vm.ToValue(map[string]interface{}{
@@ -74,20 +114,17 @@ func (r *ExtensionRuntime) fileDownload(call goja.FunctionCall) goja.Value {
 		})
 	}
 
-	// Get options if provided
 	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 {
-			// Extract headers
 			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)
 				}
 			}
-			// Extract onProgress callback
 			if progressVal, ok := opts["onProgress"]; ok {
 				if callable, ok := goja.AssertFunction(r.vm.ToValue(progressVal)); ok {
 					onProgress = callable
@@ -96,7 +133,6 @@ func (r *ExtensionRuntime) fileDownload(call goja.FunctionCall) goja.Value {
 		}
 	}
 
-	// Create directory if needed
 	dir := filepath.Dir(fullPath)
 	if err := os.MkdirAll(dir, 0755); err != nil {
 		return r.vm.ToValue(map[string]interface{}{
@@ -105,7 +141,6 @@ func (r *ExtensionRuntime) fileDownload(call goja.FunctionCall) goja.Value {
 		})
 	}
 
-	// Create HTTP request
 	req, err := http.NewRequest("GET", urlStr, nil)
 	if err != nil {
 		return r.vm.ToValue(map[string]interface{}{
@@ -114,7 +149,6 @@ func (r *ExtensionRuntime) fileDownload(call goja.FunctionCall) goja.Value {
 		})
 	}
 
-	// Set headers
 	for k, v := range headers {
 		req.Header.Set(k, v)
 	}
@@ -122,7 +156,6 @@ func (r *ExtensionRuntime) fileDownload(call goja.FunctionCall) goja.Value {
 		req.Header.Set("User-Agent", "SpotiFLAC-Extension/1.0")
 	}
 
-	// Download file
 	resp, err := r.httpClient.Do(req)
 	if err != nil {
 		return r.vm.ToValue(map[string]interface{}{
@@ -139,7 +172,6 @@ func (r *ExtensionRuntime) fileDownload(call goja.FunctionCall) goja.Value {
 		})
 	}
 
-	// Create output file
 	out, err := os.Create(fullPath)
 	if err != nil {
 		return r.vm.ToValue(map[string]interface{}{
@@ -149,12 +181,10 @@ func (r *ExtensionRuntime) fileDownload(call goja.FunctionCall) goja.Value {
 	}
 	defer out.Close()
 
-	// Get content length for progress
 	contentLength := resp.ContentLength
 
-	// Copy content with progress reporting
 	var written int64
-	buf := make([]byte, 32*1024) // 32KB buffer
+	buf := make([]byte, 32*1024)
 	for {
 		nr, er := resp.Body.Read(buf)
 		if nr > 0 {
@@ -179,7 +209,6 @@ func (r *ExtensionRuntime) fileDownload(call goja.FunctionCall) goja.Value {
 				})
 			}
 
-			// Report progress
 			if onProgress != nil && contentLength > 0 {
 				_, _ = onProgress(goja.Undefined(), r.vm.ToValue(written), r.vm.ToValue(contentLength))
 			}
@@ -204,7 +233,6 @@ func (r *ExtensionRuntime) fileDownload(call goja.FunctionCall) goja.Value {
 	})
 }
 
-// fileExists checks if a file exists in the sandbox
 func (r *ExtensionRuntime) fileExists(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 1 {
 		return r.vm.ToValue(false)
@@ -220,7 +248,6 @@ func (r *ExtensionRuntime) fileExists(call goja.FunctionCall) goja.Value {
 	return r.vm.ToValue(err == nil)
 }
 
-// fileDelete deletes a file in the sandbox
 func (r *ExtensionRuntime) fileDelete(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 1 {
 		return r.vm.ToValue(map[string]interface{}{
@@ -250,7 +277,6 @@ func (r *ExtensionRuntime) fileDelete(call goja.FunctionCall) goja.Value {
 	})
 }
 
-// fileRead reads a file from the sandbox
 func (r *ExtensionRuntime) fileRead(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 1 {
 		return r.vm.ToValue(map[string]interface{}{
@@ -282,7 +308,6 @@ func (r *ExtensionRuntime) fileRead(call goja.FunctionCall) goja.Value {
 	})
 }
 
-// fileWrite writes data to a file in the sandbox
 func (r *ExtensionRuntime) fileWrite(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 2 {
 		return r.vm.ToValue(map[string]interface{}{
@@ -324,7 +349,6 @@ func (r *ExtensionRuntime) fileWrite(call goja.FunctionCall) goja.Value {
 	})
 }
 
-// fileCopy copies a file within the sandbox
 func (r *ExtensionRuntime) fileCopy(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 2 {
 		return r.vm.ToValue(map[string]interface{}{
@@ -352,7 +376,6 @@ func (r *ExtensionRuntime) fileCopy(call goja.FunctionCall) goja.Value {
 		})
 	}
 
-	// Read source file
 	data, err := os.ReadFile(fullSrc)
 	if err != nil {
 		return r.vm.ToValue(map[string]interface{}{
@@ -361,7 +384,6 @@ func (r *ExtensionRuntime) fileCopy(call goja.FunctionCall) goja.Value {
 		})
 	}
 
-	// Create destination directory if needed
 	dir := filepath.Dir(fullDst)
 	if err := os.MkdirAll(dir, 0755); err != nil {
 		return r.vm.ToValue(map[string]interface{}{
@@ -370,7 +392,6 @@ func (r *ExtensionRuntime) fileCopy(call goja.FunctionCall) goja.Value {
 		})
 	}
 
-	// Write to destination
 	if err := os.WriteFile(fullDst, data, 0644); err != nil {
 		return r.vm.ToValue(map[string]interface{}{
 			"success": false,
@@ -384,7 +405,6 @@ func (r *ExtensionRuntime) fileCopy(call goja.FunctionCall) goja.Value {
 	})
 }
 
-// fileMove moves/renames a file within the sandbox
 func (r *ExtensionRuntime) fileMove(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 2 {
 		return r.vm.ToValue(map[string]interface{}{
@@ -412,7 +432,6 @@ func (r *ExtensionRuntime) fileMove(call goja.FunctionCall) goja.Value {
 		})
 	}
 
-	// Create destination directory if needed
 	dir := filepath.Dir(fullDst)
 	if err := os.MkdirAll(dir, 0755); err != nil {
 		return r.vm.ToValue(map[string]interface{}{
@@ -434,7 +453,6 @@ func (r *ExtensionRuntime) fileMove(call goja.FunctionCall) goja.Value {
 	})
 }
 
-// fileGetSize returns the size of a file in bytes
 func (r *ExtensionRuntime) fileGetSize(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 1 {
 		return r.vm.ToValue(map[string]interface{}{

go_backend/extension_runtime_http.go

@@ -29,6 +29,12 @@ func (r *ExtensionRuntime) validateDomain(urlStr string) error {
 	}
 
 	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)
 	}
@@ -46,7 +52,6 @@ func (r *ExtensionRuntime) httpGet(call goja.FunctionCall) goja.Value {
 
 	urlStr := call.Arguments[0].String()
 
-	// Validate domain
 	if err := r.validateDomain(urlStr); err != nil {
 		GoLog("[Extension:%s] HTTP blocked: %v\n", r.extensionID, err)
 		return r.vm.ToValue(map[string]interface{}{
@@ -54,7 +59,6 @@ func (r *ExtensionRuntime) httpGet(call goja.FunctionCall) goja.Value {
 		})
 	}
 
-	// Get headers if provided
 	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()
@@ -65,7 +69,6 @@ func (r *ExtensionRuntime) httpGet(call goja.FunctionCall) goja.Value {
 		}
 	}
 
-	// Create request
 	req, err := http.NewRequest("GET", urlStr, nil)
 	if err != nil {
 		return r.vm.ToValue(map[string]interface{}{
@@ -91,7 +94,6 @@ func (r *ExtensionRuntime) httpGet(call goja.FunctionCall) goja.Value {
 	}
 	defer resp.Body.Close()
 
-	// Read body
 	body, err := io.ReadAll(resp.Body)
 	if err != nil {
 		return r.vm.ToValue(map[string]interface{}{
@@ -128,7 +130,6 @@ func (r *ExtensionRuntime) httpPost(call goja.FunctionCall) goja.Value {
 
 	urlStr := call.Arguments[0].String()
 
-	// Validate domain
 	if err := r.validateDomain(urlStr); err != nil {
 		GoLog("[Extension:%s] HTTP blocked: %v\n", r.extensionID, err)
 		return r.vm.ToValue(map[string]interface{}{
@@ -169,7 +170,6 @@ func (r *ExtensionRuntime) httpPost(call goja.FunctionCall) goja.Value {
 		}
 	}
 
-	// Create request
 	req, err := http.NewRequest("POST", urlStr, strings.NewReader(bodyStr))
 	if err != nil {
 		return r.vm.ToValue(map[string]interface{}{
@@ -198,7 +198,6 @@ func (r *ExtensionRuntime) httpPost(call goja.FunctionCall) goja.Value {
 	}
 	defer resp.Body.Close()
 
-	// Read body
 	body, err := io.ReadAll(resp.Body)
 	if err != nil {
 		return r.vm.ToValue(map[string]interface{}{
@@ -225,8 +224,6 @@ func (r *ExtensionRuntime) httpPost(call goja.FunctionCall) goja.Value {
 	})
 }
 
-// httpRequest performs a generic HTTP request (GET, POST, PUT, DELETE, etc.)
-// Usage: http.request(url, options) where options = { method, body, headers }
 func (r *ExtensionRuntime) httpRequest(call goja.FunctionCall) goja.Value {
 	if len(call.Arguments) < 1 {
 		return r.vm.ToValue(map[string]interface{}{
@@ -236,7 +233,6 @@ func (r *ExtensionRuntime) httpRequest(call goja.FunctionCall) goja.Value {
 
 	urlStr := call.Arguments[0].String()
 
-	// Validate domain
 	if err := r.validateDomain(urlStr); err != nil {
 		GoLog("[Extension:%s] HTTP blocked: %v\n", r.extensionID, err)
 		return r.vm.ToValue(map[string]interface{}{
@@ -320,7 +316,6 @@ func (r *ExtensionRuntime) httpRequest(call goja.FunctionCall) goja.Value {
 	}
 	defer resp.Body.Close()
 
-	// Read body
 	body, err := io.ReadAll(resp.Body)
 	if err != nil {
 		return r.vm.ToValue(map[string]interface{}{
@@ -348,7 +343,6 @@ func (r *ExtensionRuntime) httpRequest(call goja.FunctionCall) goja.Value {
 	})
 }
 
-// httpPut performs a PUT request (shortcut for http.request with method: "PUT")
 func (r *ExtensionRuntime) httpPut(call goja.FunctionCall) goja.Value {
 	return r.httpMethodShortcut("PUT", call)
 }
@@ -358,7 +352,6 @@ func (r *ExtensionRuntime) httpDelete(call goja.FunctionCall) goja.Value {
 	return r.httpMethodShortcut("DELETE", call)
 }
 
-// httpPatch performs a PATCH request (shortcut for http.request with method: "PATCH")
 func (r *ExtensionRuntime) httpPatch(call goja.FunctionCall) goja.Value {
 	return r.httpMethodShortcut("PATCH", call)
 }
@@ -374,7 +367,6 @@ func (r *ExtensionRuntime) httpMethodShortcut(method string, call goja.FunctionC
 
 	urlStr := call.Arguments[0].String()
 
-	// Validate domain
 	if err := r.validateDomain(urlStr); err != nil {
 		GoLog("[Extension:%s] HTTP blocked: %v\n", r.extensionID, err)
 		return r.vm.ToValue(map[string]interface{}{
@@ -459,7 +451,6 @@ func (r *ExtensionRuntime) httpMethodShortcut(method string, call goja.FunctionC
 	}
 	defer resp.Body.Close()
 
-	// Read body
 	body, err := io.ReadAll(resp.Body)
 	if err != nil {
 		return r.vm.ToValue(map[string]interface{}{
@@ -486,7 +477,6 @@ func (r *ExtensionRuntime) httpMethodShortcut(method string, call goja.FunctionC
 	})
 }
 
-// httpClearCookies clears all cookies for this extension
 func (r *ExtensionRuntime) httpClearCookies(call goja.FunctionCall) goja.Value {
 	if jar, ok := r.cookieJar.(*simpleCookieJar); ok {
 		jar.mu.Lock()

go_backend/extension_runtime_storage.go

@@ -134,12 +134,45 @@ func (r *ExtensionRuntime) getCredentialsPath() string {
 	return filepath.Join(r.dataDir, ".credentials.enc")
 }
 
-// getEncryptionKey derives an encryption key from extension ID
-func (r *ExtensionRuntime) getEncryptionKey() []byte {
-	// Use SHA256 of extension ID + salt as encryption key
-	salt := "spotiflac-ext-cred-v1"
-	hash := sha256.Sum256([]byte(r.extensionID + salt))
-	return hash[:]
+// 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
@@ -154,7 +187,10 @@ func (r *ExtensionRuntime) loadCredentials() (map[string]interface{}, error) {
 	}
 
 	// Decrypt the data
-	key := r.getEncryptionKey()
+	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)
@@ -175,8 +211,10 @@ func (r *ExtensionRuntime) saveCredentials(creds map[string]interface{}) error {
 		return err
 	}
 
-	// Encrypt the data
-	key := r.getEncryptionKey()
+	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)

go_backend/extension_runtime_utils.go

@@ -94,7 +94,6 @@ func (r *ExtensionRuntime) hmacSHA1(call goja.FunctionCall) goja.Value {
 		return r.vm.ToValue([]byte{})
 	}
 
-	// Get key - can be string or array of bytes
 	var keyBytes []byte
 	keyArg := call.Arguments[0].Export()
 	switch k := keyArg.(type) {
@@ -113,7 +112,6 @@ func (r *ExtensionRuntime) hmacSHA1(call goja.FunctionCall) goja.Value {
 		return r.vm.ToValue([]byte{})
 	}
 
-	// Get message - can be string or array of bytes
 	var msgBytes []byte
 	msgArg := call.Arguments[1].Export()
 	switch m := msgArg.(type) {
@@ -136,7 +134,6 @@ func (r *ExtensionRuntime) hmacSHA1(call goja.FunctionCall) goja.Value {
 	mac.Write(msgBytes)
 	result := mac.Sum(nil)
 
-	// Convert to array of numbers for JavaScript
 	jsArray := make([]interface{}, len(result))
 	for i, b := range result {
 		jsArray[i] = int(b)
@@ -268,6 +265,11 @@ func (r *ExtensionRuntime) cryptoGenerateKey(call goja.FunctionCall) goja.Value
 	})
 }
 
+// randomUserAgent returns a random Chrome User-Agent string
+func (r *ExtensionRuntime) randomUserAgent(call goja.FunctionCall) goja.Value {
+	return r.vm.ToValue(getRandomUserAgent())
+}
+
 // ==================== Logging Functions ====================
 
 func (r *ExtensionRuntime) logDebug(call goja.FunctionCall) goja.Value {

go_backend/extension_settings.go

@@ -42,7 +42,6 @@ func (s *ExtensionSettingsStore) SetDataDir(dataDir string) error {
 		return fmt.Errorf("failed to create settings directory: %w", err)
 	}
 
-	// Load all existing settings
 	return s.loadAllSettings()
 }
 
@@ -99,7 +98,6 @@ func (s *ExtensionSettingsStore) loadSettings(extensionID string) (map[string]in
 func (s *ExtensionSettingsStore) saveSettings(extensionID string, settings map[string]interface{}) error {
 	settingsPath := s.getSettingsPath(extensionID)
 
-	// Create directory if needed
 	dir := filepath.Dir(settingsPath)
 	if err := os.MkdirAll(dir, 0755); err != nil {
 		return err
@@ -160,7 +158,6 @@ func (s *ExtensionSettingsStore) Set(extensionID, key string, value interface{})
 
 	s.settings[extensionID][key] = value
 
-	// Persist to disk
 	return s.saveSettings(extensionID, s.settings[extensionID])
 }
 
@@ -198,7 +195,6 @@ func (s *ExtensionSettingsStore) RemoveAll(extensionID string) error {
 
 	delete(s.settings, extensionID)
 
-	// Remove settings file
 	settingsPath := s.getSettingsPath(extensionID)
 	if err := os.Remove(settingsPath); err != nil && !os.IsNotExist(err) {
 		return err

go_backend/extension_store.go

@@ -35,7 +35,6 @@ type StoreExtension struct {
 	Downloads     int      `json:"downloads"`
 	UpdatedAt     string   `json:"updated_at"`
 	MinAppVersion string   `json:"min_app_version,omitempty"`
-	// Alternative camelCase fields (for flexibility)
 	DisplayNameAlt   string `json:"displayName,omitempty"`
 	DownloadURLAlt   string `json:"downloadUrl,omitempty"`
 	IconURLAlt       string `json:"iconUrl,omitempty"`
@@ -332,7 +331,6 @@ func (s *ExtensionStore) DownloadExtension(extensionID string, destPath string)
 		return fmt.Errorf("download returned HTTP %d", resp.StatusCode)
 	}
 
-	// Create destination file
 	out, err := os.Create(destPath)
 	if err != nil {
 		return fmt.Errorf("failed to create file: %w", err)

go_backend/extension_test.go

@@ -1,6 +1,7 @@
 package gobackend
 
 import (
+	"path/filepath"
 	"testing"
 
 	"github.com/dop251/goja"
@@ -137,6 +138,9 @@ func TestExtensionRuntime_FileSandbox(t *testing.T) {
 		ID: "test-ext",
 		Manifest: &ExtensionManifest{
 			Name: "test-ext",
+			Permissions: ExtensionPermissions{
+				File: true, // Enable file permission for test
+			},
 		},
 		DataDir: tempDir,
 	}
@@ -166,6 +170,36 @@ func TestExtensionRuntime_FileSandbox(t *testing.T) {
 	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) {
@@ -217,3 +251,79 @@ func TestExtensionRuntime_UtilityFunctions(t *testing.T) {
 		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)
+		}
+	}
+}

go_backend/extension_timeout.go

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

go_backend/filename.go

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

go_backend/httputil.go

@@ -15,76 +15,32 @@ import (
 	"time"
 )
 
-// HTTP utility functions for consistent request handling across all downloaders
-
 // getRandomUserAgent generates a random Windows Chrome User-Agent string
-// Uses same format as PC version (referensi/backend/spotify_metadata.go) for better API compatibility
+// Uses modern Chrome format with build and patch numbers
+// Windows 11 still reports as "Windows NT 10.0" for compatibility
 func getRandomUserAgent() string {
-	// Windows 10/11 Chrome format - same as PC version for maximum compatibility
-	// Some APIs may block mobile User-Agents, so we use desktop format
-	winMajor := rand.Intn(2) + 10 // Windows 10 or 11
-
-	chromeVersion := rand.Intn(25) + 100  // Chrome 100-124
-	chromeBuild := rand.Intn(1500) + 3000 // Build 3000-4500
-	chromePatch := rand.Intn(65) + 60     // Patch 60-125
+	// Chrome version 120-145 (modern range)
+	chromeVersion := rand.Intn(26) + 120
+	chromeBuild := rand.Intn(1500) + 6000
+	chromePatch := rand.Intn(200) + 100
 
 	return fmt.Sprintf(
-		"Mozilla/5.0 (Windows NT %d.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/%d.0.%d.%d Safari/537.36",
-		winMajor,
+		"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,
 	)
 }
 
-// getRandomMacUserAgent generates a random Mac Chrome User-Agent string
-// Alternative format matching referensi/backend/spotify_metadata.go exactly
-// Kept for potential future use
-// func getRandomMacUserAgent() string {
-// 	macMajor := rand.Intn(4) + 11 // macOS 11-14
-// 	macMinor := rand.Intn(5) + 4  // Minor 4-8
-// 	webkitMajor := rand.Intn(7) + 530
-// 	webkitMinor := rand.Intn(7) + 30
-// 	chromeMajor := rand.Intn(25) + 80
-// 	chromeBuild := rand.Intn(1500) + 3000
-// 	chromePatch := rand.Intn(65) + 60
-// 	safariMajor := rand.Intn(7) + 530
-// 	safariMinor := rand.Intn(6) + 30
-//
-// 	return fmt.Sprintf(
-// 		"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_%d_%d) AppleWebKit/%d.%d (KHTML, like Gecko) Chrome/%d.0.%d.%d Safari/%d.%d",
-// 		macMajor,
-// 		macMinor,
-// 		webkitMajor,
-// 		webkitMinor,
-// 		chromeMajor,
-// 		chromeBuild,
-// 		chromePatch,
-// 		safariMajor,
-// 		safariMinor,
-// 	)
-// }
-
-// getRandomDesktopUserAgent randomly picks between Windows and Mac User-Agent
-// Kept for potential future use
-// func getRandomDesktopUserAgent() string {
-// 	if rand.Intn(2) == 0 {
-// 		return getRandomUserAgent() // Windows
-// 	}
-// 	return getRandomMacUserAgent() // Mac
-// }
-
-// Default timeout values
 const (
-	DefaultTimeout    = 60 * time.Second  // Default HTTP timeout
-	DownloadTimeout   = 120 * time.Second // Timeout for file downloads
-	SongLinkTimeout   = 30 * time.Second  // Timeout for SongLink API
-	DefaultMaxRetries = 3                 // Default retry count
-	DefaultRetryDelay = 1 * time.Second   // Initial retry delay
+	DefaultTimeout    = 60 * time.Second
+	DownloadTimeout   = 120 * time.Second
+	SongLinkTimeout   = 30 * time.Second
+	DefaultMaxRetries = 3
+	DefaultRetryDelay = 1 * time.Second
 )
 
 // Shared transport with connection pooling to prevent TCP exhaustion
-// Optimized for large file downloads (FLAC ~30-50MB)
 var sharedTransport = &http.Transport{
 	DialContext: (&net.Dialer{
 		Timeout:   30 * time.Second,
@@ -96,27 +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, // 64KB write buffer
-	ReadBufferSize:        64 * 1024, // 64KB read buffer
-	DisableCompression:    true,      // FLAC is already compressed
+	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,
@@ -124,29 +76,24 @@ 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())
 	resp, err := client.Do(req)
 	if err != nil {
-		// Check for ISP blocking
 		CheckAndLogISPBlocking(err, req.URL.String(), "HTTP")
 	}
 	return resp, err
@@ -160,7 +107,6 @@ type RetryConfig struct {
 	BackoffFactor float64
 }
 
-// DefaultRetryConfig returns default retry configuration
 func DefaultRetryConfig() RetryConfig {
 	return RetryConfig{
 		MaxRetries:    DefaultMaxRetries,
@@ -266,13 +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)
 	return min(nextDelay, config.MaxDelay)
 }
 
-// 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")
@@ -315,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")
@@ -344,7 +287,6 @@ func BuildErrorMessage(apiURL string, statusCode int, responsePreview string) st
 	return msg
 }
 
-// ISPBlockingError represents an error caused by ISP blocking
 type ISPBlockingError struct {
 	Domain      string
 	Reason      string
@@ -460,7 +402,6 @@ func IsISPBlocking(err error, requestURL string) *ISPBlockingError {
 	return nil
 }
 
-// CheckAndLogISPBlocking checks for ISP blocking and logs if detected
 // Returns true if ISP blocking was detected
 func CheckAndLogISPBlocking(err error, requestURL string, tag string) bool {
 	ispErr := IsISPBlocking(err, requestURL)
@@ -498,7 +439,6 @@ func extractDomain(rawURL string) string {
 	return "unknown"
 }
 
-// WrapErrorWithISPCheck wraps an error with ISP blocking detection
 // If ISP blocking is detected, returns a more descriptive error
 func WrapErrorWithISPCheck(err error, requestURL string, tag string) error {
 	if err == nil {

go_backend/logbuffer.go

@@ -8,7 +8,6 @@ import (
 	"time"
 )
 
-// LogEntry represents a single log entry
 type LogEntry struct {
 	Timestamp string `json:"timestamp"`
 	Level     string `json:"level"`
@@ -16,12 +15,11 @@ type LogEntry struct {
 	Message   string `json:"message"`
 }
 
-// LogBuffer stores logs in a circular buffer for retrieval by Flutter
 type LogBuffer struct {
 	entries        []LogEntry
 	maxSize        int
 	mu             sync.RWMutex
-	loggingEnabled bool // Whether logging is enabled (controlled by Flutter)
+	loggingEnabled bool
 }
 
 var (
@@ -41,7 +39,6 @@ func GetLogBuffer() *LogBuffer {
 	return globalLogBuffer
 }
 
-// SetLoggingEnabled enables or disables logging
 func (lb *LogBuffer) SetLoggingEnabled(enabled bool) {
 	lb.mu.Lock()
 	defer lb.mu.Unlock()
@@ -55,12 +52,10 @@ func (lb *LogBuffer) IsLoggingEnabled() bool {
 	return lb.loggingEnabled
 }
 
-// Add adds a log entry to the buffer
 func (lb *LogBuffer) Add(level, tag, message string) {
 	lb.mu.Lock()
 	defer lb.mu.Unlock()
 
-	// Skip if logging is disabled (except for errors which are always logged)
 	if !lb.loggingEnabled && level != "ERROR" && level != "FATAL" {
 		return
 	}
@@ -73,12 +68,10 @@ func (lb *LogBuffer) Add(level, tag, message string) {
 	}
 
 	if len(lb.entries) >= lb.maxSize {
-		// Remove oldest entry
 		lb.entries = lb.entries[1:]
 	}
 	lb.entries = append(lb.entries, entry)
 
-	// Also print to logcat for debugging
 	fmt.Printf("[%s] %s\n", tag, message)
 }
 
@@ -91,7 +84,6 @@ func (lb *LogBuffer) GetAll() string {
 	return string(jsonBytes)
 }
 
-// getSince returns log entries since the given index (internal use)
 func (lb *LogBuffer) getSince(index int) ([]LogEntry, int) {
 	lb.mu.RLock()
 	defer lb.mu.RUnlock()

go_backend/lyrics.go

@@ -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{
-			Timeout: 15 * time.Second,
-		},
+		httpClient: NewHTTPClientWithTimeout(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) {
-	// Strategy 1: Direct match with artist and track name
-	lyrics, err := c.FetchLyricsWithMetadata(artistName, trackName)
+func (c *LyricsClient) findBestMatch(results []LRCLibResponse, targetDurationSec float64) *LRCLibResponse {
+	var bestSynced *LRCLibResponse
+	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,7 +375,6 @@ func msToLRCTimestamp(ms int64) string {
 	return fmt.Sprintf("[%02d:%02d.%02d]", minutes, seconds, centiseconds)
 }
 
-// convertToLRC converts lyrics to LRC format string (without metadata headers)
 // Use convertToLRCWithMetadata for full LRC with headers
 // Kept for potential future use
 // func convertToLRC(lyrics *LyricsResponse) string {
@@ -275,8 +401,6 @@ func msToLRCTimestamp(ms int64) string {
 // 	return builder.String()
 // }
 
-// convertToLRCWithMetadata converts lyrics to LRC format with metadata headers
-// Includes [ti:], [ar:], [by:] headers
 func convertToLRCWithMetadata(lyrics *LyricsResponse, trackName, artistName string) string {
 	if lyrics == nil || len(lyrics.Lines) == 0 {
 		return ""
@@ -284,13 +408,11 @@ func convertToLRCWithMetadata(lyrics *LyricsResponse, trackName, artistName stri
 
 	var builder strings.Builder
 
-	// Add metadata headers
 	builder.WriteString(fmt.Sprintf("[ti:%s]\n", trackName))
 	builder.WriteString(fmt.Sprintf("[ar:%s]\n", artistName))
 	builder.WriteString("[by:SpotiFLAC-Mobile]\n")
 	builder.WriteString("\n")
 
-	// Add lyrics lines
 	if lyrics.SyncType == "LINE_SYNCED" {
 		for _, line := range lyrics.Lines {
 			if line.Words == "" {
@@ -339,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
+}

go_backend/metadata.go

@@ -1,7 +1,10 @@
 package gobackend
 
 import (
+	"bytes"
+	"encoding/binary"
 	"fmt"
+	"io"
 	"os"
 	"strconv"
 	"strings"
@@ -11,7 +14,6 @@ import (
 	"github.com/go-flac/go-flac"
 )
 
-// Metadata represents track metadata for embedding
 type Metadata struct {
 	Title       string
 	Artist      string
@@ -24,16 +26,17 @@ type Metadata struct {
 	ISRC        string
 	Description string
 	Lyrics      string
+	Genre       string
+	Label       string
+	Copyright   string
 }
 
-// EmbedMetadata embeds metadata into a FLAC file
 func EmbedMetadata(filePath string, metadata Metadata, coverPath string) error {
 	f, err := flac.ParseFile(filePath)
 	if err != nil {
 		return fmt.Errorf("failed to parse FLAC file: %w", err)
 	}
 
-	// Find or create vorbis comment block
 	var cmtIdx int = -1
 	var cmt *flacvorbis.MetaDataBlockVorbisComment
 
@@ -52,7 +55,6 @@ func EmbedMetadata(filePath string, metadata Metadata, coverPath string) error {
 		cmt = flacvorbis.New()
 	}
 
-	// Set metadata fields
 	setComment(cmt, "TITLE", metadata.Title)
 	setComment(cmt, "ARTIST", metadata.Artist)
 	setComment(cmt, "ALBUM", metadata.Album)
@@ -84,7 +86,18 @@ func EmbedMetadata(filePath string, metadata Metadata, coverPath string) error {
 		setComment(cmt, "UNSYNCEDLYRICS", metadata.Lyrics)
 	}
 
-	// Update or add vorbis comment block
+	if metadata.Genre != "" {
+		setComment(cmt, "GENRE", metadata.Genre)
+	}
+
+	if metadata.Label != "" {
+		setComment(cmt, "ORGANIZATION", metadata.Label)
+	}
+
+	if metadata.Copyright != "" {
+		setComment(cmt, "COPYRIGHT", metadata.Copyright)
+	}
+
 	cmtBlock := cmt.Marshal()
 	if cmtIdx >= 0 {
 		f.Meta[cmtIdx] = &cmtBlock
@@ -92,14 +105,12 @@ func EmbedMetadata(filePath string, metadata Metadata, coverPath string) error {
 		f.Meta = append(f.Meta, &cmtBlock)
 	}
 
-	// Add cover art if provided
 	if coverPath != "" {
 		if fileExists(coverPath) {
 			coverData, err := os.ReadFile(coverPath)
 			if err != nil {
 				fmt.Printf("[Metadata] Warning: Failed to read cover file %s: %v\n", coverPath, err)
 			} else {
-				// Remove existing picture blocks first (like PC version)
 				for i := len(f.Meta) - 1; i >= 0; i-- {
 					if f.Meta[i].Type == flac.Picture {
 						f.Meta = append(f.Meta[:i], f.Meta[i+1:]...)
@@ -125,19 +136,15 @@ func EmbedMetadata(filePath string, metadata Metadata, coverPath string) error {
 		}
 	}
 
-	// Save file
 	return f.Save(filePath)
 }
 
-// EmbedMetadataWithCoverData embeds metadata into a FLAC file with cover data as bytes
-// This avoids file permission issues on Android by not requiring a temp file
 func EmbedMetadataWithCoverData(filePath string, metadata Metadata, coverData []byte) error {
 	f, err := flac.ParseFile(filePath)
 	if err != nil {
 		return fmt.Errorf("failed to parse FLAC file: %w", err)
 	}
 
-	// Find or create vorbis comment block
 	var cmtIdx int = -1
 	var cmt *flacvorbis.MetaDataBlockVorbisComment
 
@@ -156,7 +163,6 @@ func EmbedMetadataWithCoverData(filePath string, metadata Metadata, coverData []
 		cmt = flacvorbis.New()
 	}
 
-	// Set metadata fields
 	setComment(cmt, "TITLE", metadata.Title)
 	setComment(cmt, "ARTIST", metadata.Artist)
 	setComment(cmt, "ALBUM", metadata.Album)
@@ -188,7 +194,18 @@ func EmbedMetadataWithCoverData(filePath string, metadata Metadata, coverData []
 		setComment(cmt, "UNSYNCEDLYRICS", metadata.Lyrics)
 	}
 
-	// Update or add vorbis comment block
+	if metadata.Genre != "" {
+		setComment(cmt, "GENRE", metadata.Genre)
+	}
+
+	if metadata.Label != "" {
+		setComment(cmt, "ORGANIZATION", metadata.Label)
+	}
+
+	if metadata.Copyright != "" {
+		setComment(cmt, "COPYRIGHT", metadata.Copyright)
+	}
+
 	cmtBlock := cmt.Marshal()
 	if cmtIdx >= 0 {
 		f.Meta[cmtIdx] = &cmtBlock
@@ -196,9 +213,7 @@ func EmbedMetadataWithCoverData(filePath string, metadata Metadata, coverData []
 		f.Meta = append(f.Meta, &cmtBlock)
 	}
 
-	// Add cover art if provided
 	if len(coverData) > 0 {
-		// Remove existing picture blocks first
 		for i := len(f.Meta) - 1; i >= 0; i-- {
 			if f.Meta[i].Type == flac.Picture {
 				f.Meta = append(f.Meta[:i], f.Meta[i+1:]...)
@@ -220,7 +235,6 @@ func EmbedMetadataWithCoverData(filePath string, metadata Metadata, coverData []
 		}
 	}
 
-	// Save file
 	return f.Save(filePath)
 }
 
@@ -257,7 +271,6 @@ func ReadMetadata(filePath string) (*Metadata, error) {
 			if trackNum != "" {
 				fmt.Sscanf(trackNum, "%d", &metadata.TrackNumber)
 			}
-			// Also try lowercase variant (some encoders use lowercase)
 			if metadata.TrackNumber == 0 {
 				trackNum = getComment(cmt, "TRACK")
 				if trackNum != "" {
@@ -269,7 +282,6 @@ func ReadMetadata(filePath string) (*Metadata, error) {
 			if discNum != "" {
 				fmt.Sscanf(discNum, "%d", &metadata.DiscNumber)
 			}
-			// Also try DISC variant
 			if metadata.DiscNumber == 0 {
 				discNum = getComment(cmt, "DISC")
 				if discNum != "" {
@@ -277,7 +289,6 @@ func ReadMetadata(filePath string) (*Metadata, error) {
 				}
 			}
 
-			// Try DATE variants
 			if metadata.Date == "" {
 				metadata.Date = getComment(cmt, "YEAR")
 			}
@@ -293,7 +304,6 @@ func setComment(cmt *flacvorbis.MetaDataBlockVorbisComment, key, value string) {
 	if value == "" {
 		return
 	}
-	// Remove existing (case-insensitive comparison for Vorbis comments)
 	keyUpper := strings.ToUpper(key)
 	for i := len(cmt.Comments) - 1; i >= 0; i-- {
 		comment := cmt.Comments[i]
@@ -305,7 +315,6 @@ func setComment(cmt *flacvorbis.MetaDataBlockVorbisComment, key, value string) {
 			}
 		}
 	}
-	// Add new
 	cmt.Comments = append(cmt.Comments, key+"="+value)
 }
 
@@ -313,7 +322,6 @@ func getComment(cmt *flacvorbis.MetaDataBlockVorbisComment, key string) string {
 	keyUpper := strings.ToUpper(key) + "="
 	for _, comment := range cmt.Comments {
 		if len(comment) > len(key) {
-			// Case-insensitive comparison for Vorbis comments
 			commentUpper := strings.ToUpper(comment[:len(key)+1])
 			if commentUpper == keyUpper {
 				return comment[len(key)+1:]
@@ -323,13 +331,11 @@ func getComment(cmt *flacvorbis.MetaDataBlockVorbisComment, key string) string {
 	return ""
 }
 
-// fileExists checks if a file exists
 func fileExists(path string) bool {
 	_, err := os.Stat(path)
 	return err == nil
 }
 
-// EmbedLyrics embeds lyrics into a FLAC file as a separate operation
 func EmbedLyrics(filePath string, lyrics string) error {
 	f, err := flac.ParseFile(filePath)
 	if err != nil {
@@ -367,6 +373,51 @@ func EmbedLyrics(filePath string, lyrics string) error {
 	return f.Save(filePath)
 }
 
+func EmbedGenreLabel(filePath string, genre, label string) error {
+	if genre == "" && label == "" {
+		return nil
+	}
+
+	f, err := flac.ParseFile(filePath)
+	if err != nil {
+		return fmt.Errorf("failed to parse FLAC file: %w", err)
+	}
+
+	var cmtIdx int = -1
+	var cmt *flacvorbis.MetaDataBlockVorbisComment
+
+	for idx, meta := range f.Meta {
+		if meta.Type == flac.VorbisComment {
+			cmtIdx = idx
+			cmt, err = flacvorbis.ParseFromMetaDataBlock(*meta)
+			if err != nil {
+				return fmt.Errorf("failed to parse vorbis comment: %w", err)
+			}
+			break
+		}
+	}
+
+	if cmt == nil {
+		cmt = flacvorbis.New()
+	}
+
+	if genre != "" {
+		setComment(cmt, "GENRE", genre)
+	}
+	if label != "" {
+		setComment(cmt, "ORGANIZATION", label)
+	}
+
+	cmtBlock := cmt.Marshal()
+	if cmtIdx >= 0 {
+		f.Meta[cmtIdx] = &cmtBlock
+	} else {
+		f.Meta = append(f.Meta, &cmtBlock)
+	}
+
+	return f.Save(filePath)
+}
+
 // ExtractLyrics extracts embedded lyrics from a FLAC file
 func ExtractLyrics(filePath string) (string, error) {
 	f, err := flac.ParseFile(filePath)
@@ -381,13 +432,11 @@ func ExtractLyrics(filePath string) (string, error) {
 				continue
 			}
 
-			// Try LYRICS tag first
 			lyrics, err := cmt.Get("LYRICS")
 			if err == nil && len(lyrics) > 0 && lyrics[0] != "" {
 				return lyrics[0], nil
 			}
 
-			// Fallback to UNSYNCEDLYRICS
 			lyrics, err = cmt.Get("UNSYNCEDLYRICS")
 			if err == nil && len(lyrics) > 0 && lyrics[0] != "" {
 				return lyrics[0], nil
@@ -398,16 +447,12 @@ func ExtractLyrics(filePath string) (string, error) {
 	return "", fmt.Errorf("no lyrics found in file")
 }
 
-// AudioQuality represents audio quality info from a FLAC file
 type AudioQuality struct {
 	BitDepth     int   `json:"bit_depth"`
 	SampleRate   int   `json:"sample_rate"`
 	TotalSamples int64 `json:"total_samples"`
 }
 
-// GetAudioQuality reads bit depth and sample rate from a FLAC file's StreamInfo block
-// FLAC StreamInfo is always the first metadata block after the 4-byte "fLaC" marker
-// For M4A files, it delegates to GetM4AQuality
 func GetAudioQuality(filePath string) (AudioQuality, error) {
 	file, err := os.Open(filePath)
 	if err != nil {
@@ -415,16 +460,12 @@ func GetAudioQuality(filePath string) (AudioQuality, error) {
 	}
 	defer file.Close()
 
-	// Read first 4 bytes to detect file type
 	marker := make([]byte, 4)
 	if _, err := file.Read(marker); err != nil {
 		return AudioQuality{}, fmt.Errorf("failed to read marker: %w", err)
 	}
 
-	// Check if it's a FLAC file
 	if string(marker) == "fLaC" {
-		// Continue reading FLAC metadata
-		// Read metadata block header (4 bytes)
 		header := make([]byte, 4)
 		if _, err := file.Read(header); err != nil {
 			return AudioQuality{}, fmt.Errorf("failed to read header: %w", err)
@@ -435,19 +476,15 @@ func GetAudioQuality(filePath string) (AudioQuality, error) {
 			return AudioQuality{}, fmt.Errorf("first block is not STREAMINFO")
 		}
 
-		// Read STREAMINFO block (34 bytes minimum)
 		streamInfo := make([]byte, 34)
 		if _, err := file.Read(streamInfo); err != nil {
 			return AudioQuality{}, fmt.Errorf("failed to read STREAMINFO: %w", err)
 		}
 
-		// Parse sample rate (20 bits starting at byte 10)
 		sampleRate := (int(streamInfo[10]) << 12) | (int(streamInfo[11]) << 4) | (int(streamInfo[12]) >> 4)
 
-		// Parse bits per sample (5 bits)
 		bitsPerSample := ((int(streamInfo[12]) & 0x01) << 4) | (int(streamInfo[13]) >> 4) + 1
 
-		// Parse total samples (36 bits: 4 bits from byte 13, all of bytes 14-17)
 		totalSamples := int64(streamInfo[13]&0x0F)<<32 |
 			int64(streamInfo[14])<<24 |
 			int64(streamInfo[15])<<16 |
@@ -461,17 +498,14 @@ func GetAudioQuality(filePath string) (AudioQuality, error) {
 		}, nil
 	}
 
-	// Check if it's an M4A/MP4 file (starts with size + "ftyp")
-	// First 4 bytes are size, next 4 should be "ftyp"
-	file.Seek(0, 0) // Reset to beginning
+	file.Seek(0, 0)
 	header8 := make([]byte, 8)
 	if _, err := file.Read(header8); err != nil {
 		return AudioQuality{}, fmt.Errorf("failed to read header: %w", err)
 	}
 
 	if string(header8[4:8]) == "ftyp" {
-		// It's an M4A/MP4 file, use M4A quality reader
-		file.Close() // Close before calling GetM4AQuality which opens the file again
+		file.Close()
 		return GetM4AQuality(filePath)
 	}
 
@@ -483,94 +517,174 @@ func GetAudioQuality(filePath string) (AudioQuality, error) {
 // ========================================
 
 // EmbedM4AMetadata embeds metadata into an M4A file using iTunes-style atoms
-// This is a simplified implementation that writes metadata to the file
 func EmbedM4AMetadata(filePath string, metadata Metadata, coverData []byte) error {
-	// Read the entire file
-	data, err := os.ReadFile(filePath)
+	input, err := os.Open(filePath)
 	if err != nil {
-		return fmt.Errorf("failed to read M4A file: %w", err)
+		return fmt.Errorf("failed to open M4A file: %w", err)
 	}
+	defer input.Close()
 
-	// Find moov atom position
-	moovPos := findAtom(data, "moov", 0)
-	if moovPos < 0 {
+	info, err := input.Stat()
+	if err != nil {
+		return fmt.Errorf("failed to stat M4A file: %w", err)
+	}
+	fileSize := info.Size()
+
+	moovHeader, moovFound, err := findAtomInRange(input, 0, fileSize, "moov", fileSize)
+	if err != nil {
+		return fmt.Errorf("failed to find moov atom: %w", err)
+	}
+	if !moovFound {
 		return fmt.Errorf("moov atom not found in M4A file")
 	}
 
-	// Find udta atom inside moov, or create one
-	moovSize := int(data[moovPos]<<24 | data[moovPos+1]<<16 | data[moovPos+2]<<8 | data[moovPos+3])
-	udtaPos := findAtom(data, "udta", moovPos+8)
+	moovContentStart := moovHeader.offset + moovHeader.headerSize
+	moovContentSize := moovHeader.size - moovHeader.headerSize
 
-	// Build new metadata atoms
-	metaAtom := buildMetaAtom(metadata, coverData)
+	udtaHeader, udtaFound, err := findAtomInRange(input, moovContentStart, moovContentSize, "udta", fileSize)
+	if err != nil {
+		return fmt.Errorf("failed to locate udta atom: %w", err)
+	}
 
-	var newData []byte
-	if udtaPos >= 0 && udtaPos < moovPos+moovSize {
-		// udta exists, find meta inside it or replace
-		udtaSize := int(data[udtaPos]<<24 | data[udtaPos+1]<<16 | data[udtaPos+2]<<8 | data[udtaPos+3])
-		metaPos := findAtom(data, "meta", udtaPos+8)
-
-		if metaPos >= 0 && metaPos < udtaPos+udtaSize {
-			// Replace existing meta atom
-			metaSize := int(data[metaPos]<<24 | data[metaPos+1]<<16 | data[metaPos+2]<<8 | data[metaPos+3])
-			newData = append(newData, data[:metaPos]...)
-			newData = append(newData, metaAtom...)
-			newData = append(newData, data[metaPos+metaSize:]...)
-		} else {
-			// Add meta atom to udta
-			newUdtaContent := append(data[udtaPos+8:udtaPos+udtaSize], metaAtom...)
-			newUdtaSize := 8 + len(newUdtaContent)
-			newUdta := make([]byte, 4)
-			newUdta[0] = byte(newUdtaSize >> 24)
-			newUdta[1] = byte(newUdtaSize >> 16)
-			newUdta[2] = byte(newUdtaSize >> 8)
-			newUdta[3] = byte(newUdtaSize)
-			newUdta = append(newUdta, []byte("udta")...)
-			newUdta = append(newUdta, newUdtaContent...)
-
-			newData = append(newData, data[:udtaPos]...)
-			newData = append(newData, newUdta...)
-			newData = append(newData, data[udtaPos+udtaSize:]...)
+	var metaHeader atomHeader
+	metaFound := false
+	if udtaFound {
+		udtaContentStart := udtaHeader.offset + udtaHeader.headerSize
+		udtaContentSize := udtaHeader.size - udtaHeader.headerSize
+		metaHeader, metaFound, err = findAtomInRange(input, udtaContentStart, udtaContentSize, "meta", fileSize)
+		if err != nil {
+			return fmt.Errorf("failed to locate meta atom: %w", err)
 		}
-	} else {
-		// Create new udta with meta
-		udtaContent := metaAtom
-		udtaSize := 8 + len(udtaContent)
-		newUdta := make([]byte, 4)
-		newUdta[0] = byte(udtaSize >> 24)
-		newUdta[1] = byte(udtaSize >> 16)
-		newUdta[2] = byte(udtaSize >> 8)
-		newUdta[3] = byte(udtaSize)
-		newUdta = append(newUdta, []byte("udta")...)
-		newUdta = append(newUdta, udtaContent...)
-
-		// Insert udta at end of moov
-		insertPos := moovPos + moovSize
-		newData = append(newData, data[:insertPos]...)
-		newData = append(newData, newUdta...)
-		newData = append(newData, data[insertPos:]...)
 	}
 
-	// Update moov size
-	newMoovSize := moovSize + len(newData) - len(data)
-	newData[moovPos] = byte(newMoovSize >> 24)
-	newData[moovPos+1] = byte(newMoovSize >> 16)
-	newData[moovPos+2] = byte(newMoovSize >> 8)
-	newData[moovPos+3] = byte(newMoovSize)
+	metaAtom := buildMetaAtom(metadata, coverData)
+	metaSize := int64(len(metaAtom))
 
-	// Write back to file
-	if err := os.WriteFile(filePath, newData, 0644); err != nil {
-		return fmt.Errorf("failed to write M4A file: %w", err)
+	var delta int64
+	var newUdtaSize int64
+	switch {
+	case udtaFound && metaFound:
+		delta = metaSize - metaHeader.size
+		newUdtaSize = udtaHeader.size + delta
+	case udtaFound && !metaFound:
+		delta = metaSize
+		newUdtaSize = udtaHeader.size + delta
+	case !udtaFound:
+		newUdtaSize = int64(8 + len(metaAtom))
+		delta = newUdtaSize
 	}
 
+	newMoovSize := moovHeader.size + delta
+	if moovHeader.headerSize == 8 && newMoovSize > int64(^uint32(0)) {
+		return fmt.Errorf("moov atom exceeds 32-bit size after update")
+	}
+	if udtaFound && udtaHeader.headerSize == 8 && newUdtaSize > int64(^uint32(0)) {
+		return fmt.Errorf("udta atom exceeds 32-bit size after update")
+	}
+	if !udtaFound && newUdtaSize > int64(^uint32(0)) {
+		return fmt.Errorf("udta atom exceeds 32-bit size after update")
+	}
+
+	tempPath := filePath + ".tmp"
+	output, err := os.OpenFile(tempPath, os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0644)
+	if err != nil {
+		return fmt.Errorf("failed to create temp file: %w", err)
+	}
+	cleanupTemp := true
+	defer func() {
+		_ = output.Close()
+		if cleanupTemp {
+			_ = os.Remove(tempPath)
+		}
+	}()
+
+	switch {
+	case udtaFound && metaFound:
+		if err := copyRange(output, input, 0, moovHeader.offset); err != nil {
+			return err
+		}
+		if err := writeAtomHeader(output, "moov", newMoovSize, moovHeader.headerSize); err != nil {
+			return err
+		}
+		if err := copyRange(output, input, moovHeader.offset+moovHeader.headerSize, udtaHeader.offset-(moovHeader.offset+moovHeader.headerSize)); err != nil {
+			return err
+		}
+		if err := writeAtomHeader(output, "udta", newUdtaSize, udtaHeader.headerSize); err != nil {
+			return err
+		}
+		if err := copyRange(output, input, udtaHeader.offset+udtaHeader.headerSize, metaHeader.offset-(udtaHeader.offset+udtaHeader.headerSize)); err != nil {
+			return err
+		}
+		if _, err := output.Write(metaAtom); err != nil {
+			return fmt.Errorf("failed to write meta atom: %w", err)
+		}
+		metaEnd := metaHeader.offset + metaHeader.size
+		if err := copyRange(output, input, metaEnd, fileSize-metaEnd); err != nil {
+			return err
+		}
+	case udtaFound && !metaFound:
+		if err := copyRange(output, input, 0, moovHeader.offset); err != nil {
+			return err
+		}
+		if err := writeAtomHeader(output, "moov", newMoovSize, moovHeader.headerSize); err != nil {
+			return err
+		}
+		if err := copyRange(output, input, moovHeader.offset+moovHeader.headerSize, udtaHeader.offset-(moovHeader.offset+moovHeader.headerSize)); err != nil {
+			return err
+		}
+		if err := writeAtomHeader(output, "udta", newUdtaSize, udtaHeader.headerSize); err != nil {
+			return err
+		}
+		insertPos := udtaHeader.offset + udtaHeader.size
+		if err := copyRange(output, input, udtaHeader.offset+udtaHeader.headerSize, insertPos-(udtaHeader.offset+udtaHeader.headerSize)); err != nil {
+			return err
+		}
+		if _, err := output.Write(metaAtom); err != nil {
+			return fmt.Errorf("failed to write meta atom: %w", err)
+		}
+		if err := copyRange(output, input, insertPos, fileSize-insertPos); err != nil {
+			return err
+		}
+	case !udtaFound:
+		newUdtaAtom := buildUdtaAtom(metaAtom)
+		if err := copyRange(output, input, 0, moovHeader.offset); err != nil {
+			return err
+		}
+		if err := writeAtomHeader(output, "moov", newMoovSize, moovHeader.headerSize); err != nil {
+			return err
+		}
+		moovEnd := moovHeader.offset + moovHeader.size
+		if err := copyRange(output, input, moovHeader.offset+moovHeader.headerSize, moovEnd-(moovHeader.offset+moovHeader.headerSize)); err != nil {
+			return err
+		}
+		if _, err := output.Write(newUdtaAtom); err != nil {
+			return fmt.Errorf("failed to write udta atom: %w", err)
+		}
+		if err := copyRange(output, input, moovEnd, fileSize-moovEnd); err != nil {
+			return err
+		}
+	}
+
+	if err := output.Close(); err != nil {
+		return fmt.Errorf("failed to close temp file: %w", err)
+	}
+
+	_ = input.Close()
+	if err := os.Remove(filePath); err != nil {
+		return fmt.Errorf("failed to replace original file: %w", err)
+	}
+	if err := os.Rename(tempPath, filePath); err != nil {
+		return fmt.Errorf("failed to move temp file: %w", err)
+	}
+	cleanupTemp = false
+
 	fmt.Printf("[M4A] Metadata embedded successfully\n")
 	return nil
 }
 
-// findAtom finds an atom by name starting from offset
 func findAtom(data []byte, name string, offset int) int {
 	for i := offset; i < len(data)-8; {
-		size := int(data[i]<<24 | data[i+1]<<16 | data[i+2]<<8 | data[i+3])
+		size := int(uint32(data[i])<<24 | uint32(data[i+1])<<16 | uint32(data[i+2])<<8 | uint32(data[i+3]))
 		if size < 8 {
 			break
 		}
@@ -585,55 +699,44 @@ func findAtom(data []byte, name string, offset int) int {
 
 // buildMetaAtom builds a complete meta atom with ilst containing metadata
 func buildMetaAtom(metadata Metadata, coverData []byte) []byte {
-	// Build ilst content
 	var ilst []byte
 
-	// ©nam - Title
 	if metadata.Title != "" {
 		ilst = append(ilst, buildTextAtom("©nam", metadata.Title)...)
 	}
 
-	// ©ART - Artist
 	if metadata.Artist != "" {
 		ilst = append(ilst, buildTextAtom("©ART", metadata.Artist)...)
 	}
 
-	// ©alb - Album
 	if metadata.Album != "" {
 		ilst = append(ilst, buildTextAtom("©alb", metadata.Album)...)
 	}
 
-	// aART - Album Artist
 	if metadata.AlbumArtist != "" {
 		ilst = append(ilst, buildTextAtom("aART", metadata.AlbumArtist)...)
 	}
 
-	// ©day - Year/Date
 	if metadata.Date != "" {
 		ilst = append(ilst, buildTextAtom("©day", metadata.Date)...)
 	}
 
-	// trkn - Track Number
 	if metadata.TrackNumber > 0 {
 		ilst = append(ilst, buildTrackNumberAtom(metadata.TrackNumber, metadata.TotalTracks)...)
 	}
 
-	// disk - Disc Number
 	if metadata.DiscNumber > 0 {
 		ilst = append(ilst, buildDiscNumberAtom(metadata.DiscNumber, 0)...)
 	}
 
-	// ©lyr - Lyrics
 	if metadata.Lyrics != "" {
 		ilst = append(ilst, buildTextAtom("©lyr", metadata.Lyrics)...)
 	}
 
-	// covr - Cover Art
 	if len(coverData) > 0 {
 		ilst = append(ilst, buildCoverAtom(coverData)...)
 	}
 
-	// Build ilst atom
 	ilstSize := 8 + len(ilst)
 	ilstAtom := make([]byte, 4)
 	ilstAtom[0] = byte(ilstSize >> 24)
@@ -643,7 +746,6 @@ func buildMetaAtom(metadata Metadata, coverData []byte) []byte {
 	ilstAtom = append(ilstAtom, []byte("ilst")...)
 	ilstAtom = append(ilstAtom, ilst...)
 
-	// Build hdlr atom (required for meta)
 	hdlr := []byte{
 		0, 0, 0, 33, // size = 33
 		'h', 'd', 'l', 'r',
@@ -656,7 +758,6 @@ func buildMetaAtom(metadata Metadata, coverData []byte) []byte {
 		0, // null terminator
 	}
 
-	// Build meta atom
 	metaContent := append([]byte{0, 0, 0, 0}, hdlr...) // version + flags + hdlr
 	metaContent = append(metaContent, ilstAtom...)
 
@@ -672,11 +773,9 @@ func buildMetaAtom(metadata Metadata, coverData []byte) []byte {
 	return metaAtom
 }
 
-// buildTextAtom builds a text metadata atom (©nam, ©ART, etc.)
 func buildTextAtom(name, value string) []byte {
 	valueBytes := []byte(value)
 
-	// data atom
 	dataSize := 16 + len(valueBytes)
 	dataAtom := make([]byte, 4)
 	dataAtom[0] = byte(dataSize >> 24)
@@ -688,7 +787,6 @@ func buildTextAtom(name, value string) []byte {
 	dataAtom = append(dataAtom, 0, 0, 0, 0) // locale
 	dataAtom = append(dataAtom, valueBytes...)
 
-	// container atom
 	atomSize := 8 + len(dataAtom)
 	atom := make([]byte, 4)
 	atom[0] = byte(atomSize >> 24)
@@ -703,7 +801,6 @@ func buildTextAtom(name, value string) []byte {
 
 // buildTrackNumberAtom builds trkn atom
 func buildTrackNumberAtom(track, total int) []byte {
-	// data atom with track number
 	dataAtom := []byte{
 		0, 0, 0, 24, // size
 		'd', 'a', 't', 'a',
@@ -715,7 +812,6 @@ func buildTrackNumberAtom(track, total int) []byte {
 		0, 0, // padding
 	}
 
-	// trkn atom
 	atomSize := 8 + len(dataAtom)
 	atom := make([]byte, 4)
 	atom[0] = byte(atomSize >> 24)
@@ -728,9 +824,7 @@ func buildTrackNumberAtom(track, total int) []byte {
 	return atom
 }
 
-// buildDiscNumberAtom builds disk atom
 func buildDiscNumberAtom(disc, total int) []byte {
-	// data atom with disc number
 	dataAtom := []byte{
 		0, 0, 0, 22, // size
 		'd', 'a', 't', 'a',
@@ -741,7 +835,6 @@ func buildDiscNumberAtom(disc, total int) []byte {
 		byte(total >> 8), byte(total), // total discs
 	}
 
-	// disk atom
 	atomSize := 8 + len(dataAtom)
 	atom := make([]byte, 4)
 	atom[0] = byte(atomSize >> 24)
@@ -756,13 +849,11 @@ func buildDiscNumberAtom(disc, total int) []byte {
 
 // buildCoverAtom builds covr atom with image data
 func buildCoverAtom(coverData []byte) []byte {
-	// Detect image type (JPEG = 13, PNG = 14)
-	imageType := byte(13) // default JPEG
+	imageType := byte(13)
 	if len(coverData) > 8 && coverData[0] == 0x89 && coverData[1] == 'P' && coverData[2] == 'N' && coverData[3] == 'G' {
-		imageType = 14 // PNG
+		imageType = 14
 	}
 
-	// data atom
 	dataSize := 16 + len(coverData)
 	dataAtom := make([]byte, 4)
 	dataAtom[0] = byte(dataSize >> 24)
@@ -770,11 +861,10 @@ func buildCoverAtom(coverData []byte) []byte {
 	dataAtom[2] = byte(dataSize >> 8)
 	dataAtom[3] = byte(dataSize)
 	dataAtom = append(dataAtom, []byte("data")...)
-	dataAtom = append(dataAtom, 0, 0, 0, imageType) // type = JPEG or PNG
-	dataAtom = append(dataAtom, 0, 0, 0, 0)         // locale
+	dataAtom = append(dataAtom, 0, 0, 0, imageType)
+	dataAtom = append(dataAtom, 0, 0, 0, 0)
 	dataAtom = append(dataAtom, coverData...)
 
-	// covr atom
 	atomSize := 8 + len(dataAtom)
 	atom := make([]byte, 4)
 	atom[0] = byte(atomSize >> 24)
@@ -787,36 +877,226 @@ func buildCoverAtom(coverData []byte) []byte {
 	return atom
 }
 
-// GetM4AQuality reads audio quality from M4A file
 func GetM4AQuality(filePath string) (AudioQuality, error) {
-	data, err := os.ReadFile(filePath)
+	f, err := os.Open(filePath)
 	if err != nil {
-		return AudioQuality{}, fmt.Errorf("failed to read M4A file: %w", err)
+		return AudioQuality{}, fmt.Errorf("failed to open M4A file: %w", err)
 	}
+	defer f.Close()
 
-	// Find moov -> trak -> mdia -> minf -> stbl -> stsd
-	moovPos := findAtom(data, "moov", 0)
-	if moovPos < 0 {
+	info, err := f.Stat()
+	if err != nil {
+		return AudioQuality{}, fmt.Errorf("failed to stat M4A file: %w", err)
+	}
+	fileSize := info.Size()
+
+	moovHeader, moovFound, err := findAtomInRange(f, 0, fileSize, "moov", fileSize)
+	if err != nil {
+		return AudioQuality{}, fmt.Errorf("failed to find moov atom: %w", err)
+	}
+	if !moovFound {
 		return AudioQuality{}, fmt.Errorf("moov atom not found")
 	}
 
-	// Search for mp4a or alac atom which contains audio info
-	// This is a simplified search - real implementation would traverse the atom tree
-	for i := moovPos; i < len(data)-20; i++ {
-		if string(data[i:i+4]) == "mp4a" || string(data[i:i+4]) == "alac" {
-			// Sample rate is at offset 22-23 from atom start (16-bit big-endian)
-			if i+24 < len(data) {
-				sampleRate := int(data[i+22])<<8 | int(data[i+23])
-				// For AAC, bit depth is typically 16
-				bitDepth := 16
-				if string(data[i:i+4]) == "alac" {
-					// ALAC can have higher bit depth, check esds or alac specific data
-					bitDepth = 24 // Assume 24-bit for ALAC
-				}
-				return AudioQuality{BitDepth: bitDepth, SampleRate: sampleRate}, nil
-			}
-		}
+	moovStart := moovHeader.offset
+	moovEnd := moovHeader.offset + moovHeader.size
+
+	sampleOffset, atomType, err := findAudioSampleEntry(f, moovStart, moovEnd, fileSize)
+	if err != nil {
+		return AudioQuality{}, err
 	}
 
-	return AudioQuality{}, fmt.Errorf("audio info not found in M4A file")
+	buf := make([]byte, 24)
+	if _, err := f.ReadAt(buf, sampleOffset); err != nil {
+		return AudioQuality{}, fmt.Errorf("failed to read audio sample entry: %w", err)
+	}
+
+	sampleRate := int(buf[22])<<8 | int(buf[23])
+	bitDepth := 16
+	if atomType == "alac" {
+		bitDepth = 24
+	}
+
+	return AudioQuality{BitDepth: bitDepth, SampleRate: sampleRate}, nil
+}
+
+type atomHeader struct {
+	offset     int64
+	size       int64
+	headerSize int64
+	typ        string
+}
+
+func readAtomHeaderAt(f *os.File, offset, fileSize int64) (atomHeader, error) {
+	if offset+8 > fileSize {
+		return atomHeader{}, io.ErrUnexpectedEOF
+	}
+
+	headerBuf := make([]byte, 8)
+	if _, err := f.ReadAt(headerBuf, offset); err != nil {
+		return atomHeader{}, err
+	}
+
+	size32 := binary.BigEndian.Uint32(headerBuf[0:4])
+	typ := string(headerBuf[4:8])
+
+	if size32 == 1 {
+		if offset+16 > fileSize {
+			return atomHeader{}, io.ErrUnexpectedEOF
+		}
+		extBuf := make([]byte, 8)
+		if _, err := f.ReadAt(extBuf, offset+8); err != nil {
+			return atomHeader{}, err
+		}
+		size64 := binary.BigEndian.Uint64(extBuf)
+		return atomHeader{offset: offset, size: int64(size64), headerSize: 16, typ: typ}, nil
+	}
+
+	return atomHeader{offset: offset, size: int64(size32), headerSize: 8, typ: typ}, nil
+}
+
+func findAtomInRange(f *os.File, start, size int64, target string, fileSize int64) (atomHeader, bool, error) {
+	if size <= 0 {
+		return atomHeader{}, false, nil
+	}
+
+	end := start + size
+	pos := start
+
+	for pos+8 <= end {
+		header, err := readAtomHeaderAt(f, pos, fileSize)
+		if err != nil {
+			return atomHeader{}, false, err
+		}
+
+		atomSize := header.size
+		if atomSize == 0 {
+			atomSize = end - pos
+		}
+
+		if atomSize < header.headerSize {
+			return atomHeader{}, false, fmt.Errorf("invalid atom size for %s", header.typ)
+		}
+
+		header.size = atomSize
+		if header.typ == target {
+			return header, true, nil
+		}
+
+		pos += atomSize
+	}
+
+	return atomHeader{}, false, nil
+}
+
+func writeAtomHeader(w io.Writer, typ string, size int64, headerSize int64) error {
+	if len(typ) != 4 {
+		return fmt.Errorf("invalid atom type: %s", typ)
+	}
+
+	if headerSize == 16 {
+		header := make([]byte, 16)
+		binary.BigEndian.PutUint32(header[0:4], 1)
+		copy(header[4:8], []byte(typ))
+		binary.BigEndian.PutUint64(header[8:16], uint64(size))
+		_, err := w.Write(header)
+		return err
+	}
+
+	if size > int64(^uint32(0)) {
+		return fmt.Errorf("atom size exceeds 32-bit for %s", typ)
+	}
+
+	header := make([]byte, 8)
+	binary.BigEndian.PutUint32(header[0:4], uint32(size))
+	copy(header[4:8], []byte(typ))
+	_, err := w.Write(header)
+	return err
+}
+
+func copyRange(dst io.Writer, src *os.File, offset, length int64) error {
+	if length <= 0 {
+		return nil
+	}
+	if _, err := src.Seek(offset, io.SeekStart); err != nil {
+		return fmt.Errorf("failed to seek source: %w", err)
+	}
+	if _, err := io.CopyN(dst, src, length); err != nil {
+		return fmt.Errorf("failed to copy data: %w", err)
+	}
+	return nil
+}
+
+func buildUdtaAtom(metaAtom []byte) []byte {
+	size := 8 + len(metaAtom)
+	header := make([]byte, 8)
+	binary.BigEndian.PutUint32(header[0:4], uint32(size))
+	copy(header[4:8], []byte("udta"))
+	return append(header, metaAtom...)
+}
+
+func findAudioSampleEntry(f *os.File, start, end, fileSize int64) (int64, string, error) {
+	const chunkSize = 64 * 1024
+	patternMP4A := []byte("mp4a")
+	patternALAC := []byte("alac")
+
+	var tail []byte
+	readPos := start
+
+	for readPos < end {
+		toRead := end - readPos
+		if toRead > chunkSize {
+			toRead = chunkSize
+		}
+
+		buf := make([]byte, toRead)
+		n, err := f.ReadAt(buf, readPos)
+		if err != nil && err != io.EOF {
+			return 0, "", fmt.Errorf("failed to read M4A atom data: %w", err)
+		}
+		if n == 0 {
+			break
+		}
+
+		data := append(tail, buf[:n]...)
+		mp4aIdx := bytes.Index(data, patternMP4A)
+		alacIdx := bytes.Index(data, patternALAC)
+
+		bestIdx := -1
+		bestType := ""
+		switch {
+		case mp4aIdx >= 0 && alacIdx >= 0:
+			if mp4aIdx <= alacIdx {
+				bestIdx = mp4aIdx
+				bestType = "mp4a"
+			} else {
+				bestIdx = alacIdx
+				bestType = "alac"
+			}
+		case mp4aIdx >= 0:
+			bestIdx = mp4aIdx
+			bestType = "mp4a"
+		case alacIdx >= 0:
+			bestIdx = alacIdx
+			bestType = "alac"
+		}
+
+		if bestIdx >= 0 {
+			absolute := readPos - int64(len(tail)) + int64(bestIdx)
+			if absolute+24 > fileSize {
+				return 0, "", fmt.Errorf("audio info not found in M4A file")
+			}
+			return absolute, bestType, nil
+		}
+
+		if len(data) >= 3 {
+			tail = append([]byte{}, data[len(data)-3:]...)
+		} else {
+			tail = append([]byte{}, data...)
+		}
+
+		readPos += int64(n)
+	}
+
+	return 0, "", fmt.Errorf("audio info not found in M4A file")
 }

go_backend/parallel.go

@@ -6,11 +6,6 @@ import (
 	"time"
 )
 
-// ========================================
-// ISRC to Track ID Cache
-// ========================================
-
-// TrackIDCacheEntry holds cached track ID with metadata
 type TrackIDCacheEntry struct {
 	TidalTrackID  int64
 	QobuzTrackID  int64
@@ -18,7 +13,6 @@ type TrackIDCacheEntry struct {
 	ExpiresAt     time.Time
 }
 
-// TrackIDCache caches ISRC to track ID mappings
 type TrackIDCache struct {
 	cache map[string]*TrackIDCacheEntry
 	mu    sync.RWMutex
@@ -30,18 +24,16 @@ var (
 	trackIDCacheOnce   sync.Once
 )
 
-// GetTrackIDCache returns the global track ID cache
 func GetTrackIDCache() *TrackIDCache {
 	trackIDCacheOnce.Do(func() {
 		globalTrackIDCache = &TrackIDCache{
 			cache: make(map[string]*TrackIDCacheEntry),
-			ttl:   30 * time.Minute, // Cache for 30 minutes
+			ttl:   30 * time.Minute,
 		}
 	})
 	return globalTrackIDCache
 }
 
-// Get retrieves a cached entry by ISRC
 func (c *TrackIDCache) Get(isrc string) *TrackIDCacheEntry {
 	c.mu.RLock()
 	defer c.mu.RUnlock()
@@ -53,7 +45,6 @@ func (c *TrackIDCache) Get(isrc string) *TrackIDCacheEntry {
 	return entry
 }
 
-// SetTidal caches Tidal track ID for an ISRC
 func (c *TrackIDCache) SetTidal(isrc string, trackID int64) {
 	c.mu.Lock()
 	defer c.mu.Unlock()
@@ -67,7 +58,6 @@ func (c *TrackIDCache) SetTidal(isrc string, trackID int64) {
 	entry.ExpiresAt = time.Now().Add(c.ttl)
 }
 
-// SetQobuz caches Qobuz track ID for an ISRC
 func (c *TrackIDCache) SetQobuz(isrc string, trackID int64) {
 	c.mu.Lock()
 	defer c.mu.Unlock()
@@ -81,7 +71,6 @@ func (c *TrackIDCache) SetQobuz(isrc string, trackID int64) {
 	entry.ExpiresAt = time.Now().Add(c.ttl)
 }
 
-// SetAmazon caches Amazon track ID for an ISRC
 func (c *TrackIDCache) SetAmazon(isrc string, trackID string) {
 	c.mu.Lock()
 	defer c.mu.Unlock()
@@ -95,24 +84,18 @@ func (c *TrackIDCache) SetAmazon(isrc string, trackID string) {
 	entry.ExpiresAt = time.Now().Add(c.ttl)
 }
 
-// Clear removes all cached entries
 func (c *TrackIDCache) Clear() {
 	c.mu.Lock()
 	defer c.mu.Unlock()
 	c.cache = make(map[string]*TrackIDCacheEntry)
 }
 
-// Size returns the number of cached entries
 func (c *TrackIDCache) Size() int {
 	c.mu.RLock()
 	defer c.mu.RUnlock()
 	return len(c.cache)
 }
 
-// ========================================
-// Parallel Download Helper
-// ========================================
-
 // ParallelDownloadResult holds results from parallel operations
 type ParallelDownloadResult struct {
 	CoverData  []byte
@@ -122,8 +105,6 @@ type ParallelDownloadResult struct {
 	LyricsErr  error
 }
 
-// FetchCoverAndLyricsParallel downloads cover and fetches lyrics in parallel
-// This runs while the main audio download is happening
 func FetchCoverAndLyricsParallel(
 	coverURL string,
 	maxQualityCover bool,
@@ -131,11 +112,11 @@ func FetchCoverAndLyricsParallel(
 	trackName string,
 	artistName string,
 	embedLyrics bool,
+	durationMs int64,
 ) *ParallelDownloadResult {
 	result := &ParallelDownloadResult{}
 	var wg sync.WaitGroup
 
-	// Download cover in parallel
 	if coverURL != "" {
 		wg.Add(1)
 		go func() {
@@ -152,20 +133,19 @@ func FetchCoverAndLyricsParallel(
 		}()
 	}
 
-	// Fetch lyrics in parallel
 	if embedLyrics {
 		wg.Add(1)
 		go func() {
 			defer wg.Done()
 			fmt.Println("[Parallel] Starting lyrics fetch...")
 			client := NewLyricsClient()
-			lyrics, err := client.FetchLyricsAllSources(spotifyID, trackName, artistName)
+			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
-				// Use LRC with metadata headers (like PC version)
 				result.LyricsLRC = convertToLRCWithMetadata(lyrics, trackName, artistName)
 				fmt.Printf("[Parallel] Lyrics fetched: %d lines\n", len(lyrics.Lines))
 			} else {
@@ -179,11 +159,6 @@ func FetchCoverAndLyricsParallel(
 	return result
 }
 
-// ========================================
-// Pre-warm Cache for Album/Playlist
-// ========================================
-
-// PreWarmCacheRequest represents a track to pre-warm cache for
 type PreWarmCacheRequest struct {
 	ISRC       string
 	TrackName  string
@@ -192,8 +167,6 @@ type PreWarmCacheRequest struct {
 	Service    string // "tidal", "qobuz", "amazon"
 }
 
-// PreWarmTrackCache pre-fetches track IDs for multiple tracks (for album/playlist)
-// This runs in background while user is viewing the track list
 func PreWarmTrackCache(requests []PreWarmCacheRequest) {
 	if len(requests) == 0 {
 		return
@@ -202,12 +175,10 @@ func PreWarmTrackCache(requests []PreWarmCacheRequest) {
 	fmt.Printf("[Cache] Pre-warming cache for %d tracks...\n", len(requests))
 	cache := GetTrackIDCache()
 
-	// Limit concurrent pre-warm requests
-	semaphore := make(chan struct{}, 3) // Max 3 concurrent
+	semaphore := make(chan struct{}, 3)
 	var wg sync.WaitGroup
 
 	for _, req := range requests {
-		// Skip if already cached
 		if cached := cache.Get(req.ISRC); cached != nil {
 			continue
 		}
@@ -215,8 +186,8 @@ func PreWarmTrackCache(requests []PreWarmCacheRequest) {
 		wg.Add(1)
 		go func(r PreWarmCacheRequest) {
 			defer wg.Done()
-			semaphore <- struct{}{}        // Acquire
-			defer func() { <-semaphore }() // Release
+			semaphore <- struct{}{}
+			defer func() { <-semaphore }()
 
 			switch r.Service {
 			case "tidal":
@@ -252,38 +223,26 @@ func preWarmQobuzCache(isrc string) {
 }
 
 func preWarmAmazonCache(isrc, spotifyID string) {
-	// Amazon uses SongLink to get URL, so we pre-warm by checking availability
 	client := NewSongLinkClient()
 	availability, err := client.CheckTrackAvailability(spotifyID, isrc)
 	if err == nil && availability != nil && availability.Amazon {
-		// Store Amazon URL in cache (using ISRC as key)
 		GetTrackIDCache().SetAmazon(isrc, availability.AmazonURL)
 		fmt.Printf("[Cache] Cached Amazon URL for ISRC %s\n", isrc)
 	}
 }
 
-// ========================================
-// Exported Functions for Flutter
-// ========================================
-
-// PreWarmCache is called from Flutter to pre-warm cache for album/playlist tracks
-// tracksJSON is a JSON array of {isrc, track_name, artist_name, service}
 func PreWarmCache(tracksJSON string) error {
 	var requests []PreWarmCacheRequest
-	// Parse JSON (simplified - in production use proper JSON parsing)
-	// For now, this is called from exports.go with proper parsing
 
-	go PreWarmTrackCache(requests) // Run in background
+	go PreWarmTrackCache(requests)
 	return nil
 }
 
-// ClearTrackCache clears the track ID cache
 func ClearTrackCache() {
 	GetTrackIDCache().Clear()
 	fmt.Println("[Cache] Track ID cache cleared")
 }
 
-// GetCacheSize returns the current cache size
 func GetCacheSize() int {
 	return GetTrackIDCache().Size()
 }

go_backend/progress.go

@@ -6,8 +6,6 @@ import (
 	"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"`
@@ -15,21 +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
-	SpeedMBps     float64 `json:"speed_mbps"` // Download speed in MB/s
+	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"`
 }
@@ -38,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,
@@ -64,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()
@@ -76,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()
@@ -203,14 +193,6 @@ func setDownloadDir(path string) error {
 	return nil
 }
 
-// getDownloadDir returns the default download directory
-// Kept for potential future use
-// func getDownloadDir() string {
-// 	downloadDirMu.RLock()
-// 	defer downloadDirMu.RUnlock()
-// 	return downloadDir
-// }
-
 // ItemProgressWriter wraps io.Writer to track download progress for a specific item
 type ItemProgressWriter struct {
 	writer       interface{ Write([]byte) (int, error) }
@@ -240,16 +222,16 @@ func NewItemProgressWriter(w interface{ Write([]byte) (int, error) }, itemID str
 
 // Write implements io.Writer with threshold-based progress updates and speed tracking
 func (pw *ItemProgressWriter) Write(p []byte) (int, error) {
+	if pw.itemID != "" && isDownloadCancelled(pw.itemID) {
+		return 0, ErrDownloadCancelled
+	}
 	n, err := pw.writer.Write(p)
 	if err != nil {
 		return n, err
 	}
 	pw.current += int64(n)
 
-	// Update progress when we've received at least 64KB since last update
-	// Also update on first write to show download has started
 	if pw.lastReported == 0 || pw.current-pw.lastReported >= progressUpdateThreshold {
-		// Calculate speed (MB/s) based on bytes received since last update
 		now := time.Now()
 		elapsed := now.Sub(pw.lastTime).Seconds()
 		var speedMBps float64

go_backend/qobuz.go

@@ -2,8 +2,10 @@ package gobackend
 
 import (
 	"bufio"
+	"context"
 	"encoding/base64"
 	"encoding/json"
+	"errors"
 	"fmt"
 	"io"
 	"net/http"
@@ -15,7 +17,6 @@ import (
 	"time"
 )
 
-// QobuzDownloader handles Qobuz downloads
 type QobuzDownloader struct {
 	client *http.Client
 	appID  string
@@ -23,12 +24,10 @@ type QobuzDownloader struct {
 }
 
 var (
-	// Global Qobuz downloader instance for connection reuse
 	globalQobuzDownloader *QobuzDownloader
 	qobuzDownloaderOnce   sync.Once
 )
 
-// QobuzTrack represents a Qobuz track
 type QobuzTrack struct {
 	ID                  int64   `json:"id"`
 	Title               string  `json:"title"`
@@ -49,7 +48,6 @@ type QobuzTrack struct {
 	} `json:"performer"`
 }
 
-// qobuzArtistsMatch checks if the artist names are similar enough
 func qobuzArtistsMatch(expectedArtist, foundArtist string) bool {
 	normExpected := strings.ToLower(strings.TrimSpace(expectedArtist))
 	normFound := strings.ToLower(strings.TrimSpace(foundArtist))
@@ -64,28 +62,24 @@ func qobuzArtistsMatch(expectedArtist, foundArtist string) bool {
 		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)
+	expectedArtists := qobuzSplitArtists(normExpected)
+	foundArtists := qobuzSplitArtists(normFound)
 
-	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
+	for _, exp := range expectedArtists {
+		for _, fnd := range foundArtists {
+			if exp == fnd {
+				return true
+			}
+			if strings.Contains(exp, fnd) || strings.Contains(fnd, exp) {
+				return true
+			}
+			if qobuzSameWordsUnordered(exp, fnd) {
+				GoLog("[Qobuz] Artist names have same words in different order: '%s' vs '%s'\n", exp, fnd)
+				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 TRULY different (Latin vs CJK/Arabic/Cyrillic), assume match (transliteration)
-	// Don't treat Latin Extended (Polish, French, etc.) as different script
 	expectedLatin := qobuzIsLatinScript(expectedArtist)
 	foundLatin := qobuzIsLatinScript(foundArtist)
 	if expectedLatin != foundLatin {
@@ -96,7 +90,65 @@ func qobuzArtistsMatch(expectedArtist, foundArtist string) bool {
 	return false
 }
 
-// qobuzTitlesMatch checks if track titles are similar enough
+func qobuzSplitArtists(artists string) []string {
+	normalized := artists
+	normalized = strings.ReplaceAll(normalized, " feat. ", "|")
+	normalized = strings.ReplaceAll(normalized, " feat ", "|")
+	normalized = strings.ReplaceAll(normalized, " ft. ", "|")
+	normalized = strings.ReplaceAll(normalized, " ft ", "|")
+	normalized = strings.ReplaceAll(normalized, " & ", "|")
+	normalized = strings.ReplaceAll(normalized, " and ", "|")
+	normalized = strings.ReplaceAll(normalized, ", ", "|")
+	normalized = strings.ReplaceAll(normalized, " x ", "|")
+
+	parts := strings.Split(normalized, "|")
+	result := make([]string, 0, len(parts))
+	for _, p := range parts {
+		trimmed := strings.TrimSpace(p)
+		if trimmed != "" {
+			result = append(result, trimmed)
+		}
+	}
+	return result
+}
+
+// qobuzSameWordsUnordered checks if two strings have the same words regardless of order
+// Useful for Japanese names: "Sawano Hiroyuki" vs "Hiroyuki Sawano"
+func qobuzSameWordsUnordered(a, b string) bool {
+	wordsA := strings.Fields(a)
+	wordsB := strings.Fields(b)
+
+	// Must have same number of words
+	if len(wordsA) != len(wordsB) || len(wordsA) == 0 {
+		return false
+	}
+
+	// Sort and compare
+	sortedA := make([]string, len(wordsA))
+	sortedB := make([]string, len(wordsB))
+	copy(sortedA, wordsA)
+	copy(sortedB, wordsB)
+
+	// Simple bubble sort (usually just 2-3 words)
+	for i := 0; i < len(sortedA)-1; i++ {
+		for j := i + 1; j < len(sortedA); j++ {
+			if sortedA[i] > sortedA[j] {
+				sortedA[i], sortedA[j] = sortedA[j], sortedA[i]
+			}
+			if sortedB[i] > sortedB[j] {
+				sortedB[i], sortedB[j] = sortedB[j], sortedB[i]
+			}
+		}
+	}
+
+	for i := range sortedA {
+		if sortedA[i] != sortedB[i] {
+			return false
+		}
+	}
+	return true
+}
+
 func qobuzTitlesMatch(expectedTitle, foundTitle string) bool {
 	normExpected := strings.ToLower(strings.TrimSpace(expectedTitle))
 	normFound := strings.ToLower(strings.TrimSpace(foundTitle))
@@ -106,12 +158,10 @@ func qobuzTitlesMatch(expectedTitle, foundTitle string) bool {
 		return true
 	}
 
-	// Check if one contains the other
 	if strings.Contains(normExpected, normFound) || strings.Contains(normFound, normExpected) {
 		return true
 	}
 
-	// Clean BOTH titles and compare (removes suffixes like remaster, remix, etc)
 	cleanExpected := qobuzCleanTitle(normExpected)
 	cleanFound := qobuzCleanTitle(normFound)
 
@@ -119,14 +169,12 @@ func qobuzTitlesMatch(expectedTitle, foundTitle string) bool {
 		return true
 	}
 
-	// Check if cleaned versions contain each other
 	if cleanExpected != "" && cleanFound != "" {
 		if strings.Contains(cleanExpected, cleanFound) || strings.Contains(cleanFound, cleanExpected) {
 			return true
 		}
 	}
 
-	// Extract core title (before any parentheses/brackets)
 	coreExpected := qobuzExtractCoreTitle(normExpected)
 	coreFound := qobuzExtractCoreTitle(normFound)
 
@@ -167,19 +215,15 @@ func qobuzExtractCoreTitle(title string) string {
 	return strings.TrimSpace(title[:cutIdx])
 }
 
-// qobuzCleanTitle removes common suffixes from track titles for comparison
 func qobuzCleanTitle(title string) string {
 	cleaned := title
 
-	// Remove content in parentheses/brackets that are version indicators
-	// This helps match "Song (Remastered)" with "Song" or "Song (2024 Remaster)"
 	versionPatterns := []string{
 		"remaster", "remastered", "deluxe", "bonus", "single",
 		"album version", "radio edit", "original mix", "extended",
 		"club mix", "remix", "live", "acoustic", "demo",
 	}
 
-	// Remove parenthetical content if it contains version indicators
 	for {
 		startParen := strings.LastIndex(cleaned, "(")
 		endParen := strings.LastIndex(cleaned, ")")
@@ -200,7 +244,6 @@ func qobuzCleanTitle(title string) string {
 		break
 	}
 
-	// Same for brackets
 	for {
 		startBracket := strings.LastIndex(cleaned, "[")
 		endBracket := strings.LastIndex(cleaned, "]")
@@ -221,7 +264,6 @@ func qobuzCleanTitle(title string) string {
 		break
 	}
 
-	// Remove trailing " - version" patterns
 	dashPatterns := []string{
 		" - remaster", " - remastered", " - single version", " - radio edit",
 		" - live", " - acoustic", " - demo", " - remix",
@@ -232,7 +274,6 @@ func qobuzCleanTitle(title string) string {
 		}
 	}
 
-	// Remove multiple spaces
 	for strings.Contains(cleaned, "  ") {
 		cleaned = strings.ReplaceAll(cleaned, "  ", " ")
 	}
@@ -292,7 +333,6 @@ func containsQueryQobuz(queries []string, query string) bool {
 	return false
 }
 
-// NewQobuzDownloader creates a new Qobuz downloader (returns singleton for connection reuse)
 func NewQobuzDownloader() *QobuzDownloader {
 	qobuzDownloaderOnce.Do(func() {
 		globalQobuzDownloader = &QobuzDownloader{
@@ -303,6 +343,34 @@ func NewQobuzDownloader() *QobuzDownloader {
 	return globalQobuzDownloader
 }
 
+func (q *QobuzDownloader) GetTrackByID(trackID int64) (*QobuzTrack, error) {
+	// Qobuz API: /track/get?track_id=XXX
+	apiBase, _ := base64.StdEncoding.DecodeString("aHR0cHM6Ly93d3cucW9idXouY29tL2FwaS5qc29uLzAuMi90cmFjay9nZXQ/dHJhY2tfaWQ9")
+	trackURL := fmt.Sprintf("%s%d&app_id=%s", string(apiBase), trackID, q.appID)
+
+	req, err := http.NewRequest("GET", trackURL, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	resp, err := DoRequestWithUserAgent(q.client, req)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != 200 {
+		return nil, fmt.Errorf("get track failed: HTTP %d", resp.StatusCode)
+	}
+
+	var track QobuzTrack
+	if err := json.NewDecoder(resp.Body).Decode(&track); err != nil {
+		return nil, err
+	}
+
+	return &track, nil
+}
+
 // GetAvailableAPIs returns list of available Qobuz APIs
 // Uses same APIs as PC version for compatibility
 func (q *QobuzDownloader) GetAvailableAPIs() []string {
@@ -325,7 +393,6 @@ func (q *QobuzDownloader) GetAvailableAPIs() []string {
 	return apis
 }
 
-// SearchTrackByISRC searches for a track by ISRC
 func (q *QobuzDownloader) SearchTrackByISRC(isrc string) (*QobuzTrack, error) {
 	apiBase, _ := base64.StdEncoding.DecodeString("aHR0cHM6Ly93d3cucW9idXouY29tL2FwaS5qc29uLzAuMi90cmFjay9zZWFyY2g/cXVlcnk9")
 	searchURL := fmt.Sprintf("%s%s&limit=50&app_id=%s", string(apiBase), url.QueryEscape(isrc), q.appID)
@@ -368,7 +435,6 @@ func (q *QobuzDownloader) SearchTrackByISRC(isrc string) (*QobuzTrack, error) {
 	return nil, fmt.Errorf("no exact ISRC match found for: %s", isrc)
 }
 
-// SearchTrackByISRCWithTitle searches for a track by ISRC with duration verification
 // expectedDurationSec is the expected duration in seconds (0 to skip verification)
 func (q *QobuzDownloader) SearchTrackByISRCWithDuration(isrc string, expectedDurationSec int) (*QobuzTrack, error) {
 	GoLog("[Qobuz] Searching by ISRC: %s\n", isrc)
@@ -413,7 +479,6 @@ func (q *QobuzDownloader) SearchTrackByISRCWithDuration(isrc string, expectedDur
 	GoLog("[Qobuz] Found %d exact ISRC matches\n", len(isrcMatches))
 
 	if len(isrcMatches) > 0 {
-		// Verify duration if provided
 		if expectedDurationSec > 0 {
 			var durationVerifiedMatches []*QobuzTrack
 			for _, track := range isrcMatches {
@@ -421,7 +486,6 @@ func (q *QobuzDownloader) SearchTrackByISRCWithDuration(isrc string, expectedDur
 				if durationDiff < 0 {
 					durationDiff = -durationDiff
 				}
-				// Allow 10 seconds tolerance
 				if durationDiff <= 10 {
 					durationVerifiedMatches = append(durationVerifiedMatches, track)
 				}
@@ -433,14 +497,12 @@ func (q *QobuzDownloader) SearchTrackByISRCWithDuration(isrc string, expectedDur
 				return durationVerifiedMatches[0], nil
 			}
 
-			// ISRC matches but duration doesn't
 			GoLog("[Qobuz] WARNING: ISRC %s found but duration mismatch. Expected=%ds, Found=%ds. Rejecting.\n",
 				isrc, expectedDurationSec, isrcMatches[0].Duration)
 			return nil, fmt.Errorf("ISRC found but duration mismatch: expected %ds, found %ds (likely different version)",
 				expectedDurationSec, isrcMatches[0].Duration)
 		}
 
-		// No duration to verify, return first match
 		GoLog("[Qobuz] ISRC match (no duration verification): '%s'\n", isrcMatches[0].Title)
 		return isrcMatches[0], nil
 	}
@@ -452,17 +514,14 @@ func (q *QobuzDownloader) SearchTrackByISRCWithDuration(isrc string, expectedDur
 	return nil, fmt.Errorf("no exact ISRC match found for: %s", isrc)
 }
 
-// SearchTrackByISRCWithTitle is deprecated, use SearchTrackByISRCWithDuration instead
 func (q *QobuzDownloader) SearchTrackByISRCWithTitle(isrc, expectedTitle string) (*QobuzTrack, error) {
 	return q.SearchTrackByISRCWithDuration(isrc, 0)
 }
 
-// SearchTrackByMetadata searches for a track using artist name and track name
 func (q *QobuzDownloader) SearchTrackByMetadata(trackName, artistName string) (*QobuzTrack, error) {
 	return q.SearchTrackByMetadataWithDuration(trackName, artistName, 0)
 }
 
-// SearchTrackByMetadataWithDuration searches for a track with duration verification
 // Now includes romaji conversion for Japanese text (same as Tidal)
 // Also includes title verification to prevent wrong song downloads
 func (q *QobuzDownloader) SearchTrackByMetadataWithDuration(trackName, artistName string, expectedDurationSec int) (*QobuzTrack, error) {
@@ -601,7 +660,6 @@ func (q *QobuzDownloader) SearchTrackByMetadataWithDuration(trackName, artistNam
 		}
 
 		if len(durationMatches) > 0 {
-			// Return best quality among duration matches
 			for _, track := range durationMatches {
 				if track.MaximumBitDepth >= 24 {
 					GoLog("[Qobuz] ✓ Match found: '%s' by '%s' (title+duration verified, hi-res)\n",
@@ -614,7 +672,6 @@ func (q *QobuzDownloader) SearchTrackByMetadataWithDuration(trackName, artistNam
 			return durationMatches[0], nil
 		}
 
-		// No duration match found
 		return nil, fmt.Errorf("no tracks found with matching title and duration (expected '%s', %ds)", trackName, expectedDurationSec)
 	}
 
@@ -644,8 +701,6 @@ type qobuzAPIResult struct {
 	duration    time.Duration
 }
 
-// getQobuzDownloadURLParallel requests download URL from all APIs in parallel
-// "Siapa cepat dia dapat" - first successful response wins
 func getQobuzDownloadURLParallel(apis []string, trackID int64, quality string) (string, string, error) {
 	if len(apis) == 0 {
 		return "", "", fmt.Errorf("no APIs available")
@@ -661,9 +716,7 @@ func getQobuzDownloadURLParallel(apis []string, trackID int64, quality string) (
 		go func(api string) {
 			reqStart := time.Now()
 
-			client := &http.Client{
-				Timeout: 15 * time.Second,
-			}
+			client := NewHTTPClientWithTimeout(15 * time.Second)
 
 			reqURL := fmt.Sprintf("%s%d&quality=%s", api, trackID, quality)
 
@@ -702,7 +755,7 @@ func getQobuzDownloadURLParallel(apis []string, trackID int64, quality string) (
 				Error string `json:"error"`
 			}
 			if json.Unmarshal(body, &errorResp) == nil && errorResp.Error != "" {
-				resultChan <- qobuzAPIResult{apiURL: api, err: fmt.Errorf(errorResp.Error), duration: time.Since(reqStart)}
+				resultChan <- qobuzAPIResult{apiURL: api, err: fmt.Errorf("%s", errorResp.Error), duration: time.Since(reqStart)}
 				return
 			}
 
@@ -725,12 +778,10 @@ func getQobuzDownloadURLParallel(apis []string, trackID int64, quality string) (
 
 	// Collect results - return first success
 	var errors []string
-	var firstSuccess *qobuzAPIResult
 
 	for i := 0; i < len(apis); i++ {
 		result := <-resultChan
-		if result.err == nil && firstSuccess == nil {
-			firstSuccess = &result
+		if result.err == nil {
 			GoLog("[Qobuz] [Parallel] ✓ Got response from %s in %v\n", result.apiURL, result.duration)
 
 			// Drain remaining results to avoid goroutine leaks
@@ -741,100 +792,25 @@ func getQobuzDownloadURLParallel(apis []string, trackID int64, quality string) (
 			}(len(apis) - i - 1)
 
 			GoLog("[Qobuz] [Parallel] Total time: %v (first success)\n", time.Since(startTime))
-			return firstSuccess.apiURL, firstSuccess.downloadURL, nil
-		} else if result.err != nil {
-			errMsg := result.err.Error()
-			if len(errMsg) > 50 {
-				errMsg = errMsg[:50] + "..."
-			}
-			errors = append(errors, fmt.Sprintf("%s: %s", result.apiURL, errMsg))
+			return result.apiURL, result.downloadURL, nil
 		}
+		errMsg := result.err.Error()
+		if len(errMsg) > 50 {
+			errMsg = errMsg[:50] + "..."
+		}
+		errors = append(errors, fmt.Sprintf("%s: %s", result.apiURL, errMsg))
 	}
 
 	GoLog("[Qobuz] [Parallel] All %d APIs failed in %v\n", len(apis), time.Since(startTime))
 	return "", "", fmt.Errorf("all %d Qobuz APIs failed. Errors: %v", len(apis), errors)
 }
 
-// getQobuzDownloadURLSequential requests download URL from APIs sequentially
-// Uses same URL format as PC version: /api/stream?trackId={id}&quality={quality}
-func getQobuzDownloadURLSequential(apis []string, trackID int64, quality string) (string, string, error) {
-	if len(apis) == 0 {
-		return "", "", fmt.Errorf("no APIs available")
-	}
-
-	client := NewHTTPClientWithTimeout(DefaultTimeout)
-	retryConfig := DefaultRetryConfig()
-	var errors []string
-
-	for _, apiURL := range apis {
-		// All APIs now use same format: https://domain/api/stream?trackId={id}&quality={quality}
-		// The apiURL already includes the path, just append trackID and quality
-		reqURL := fmt.Sprintf("%s%d&quality=%s", apiURL, trackID, quality)
-
-		GoLog("[Qobuz] Trying: %s\n", reqURL)
-
-		req, err := http.NewRequest("GET", reqURL, nil)
-		if err != nil {
-			errors = append(errors, BuildErrorMessage(apiURL, 0, err.Error()))
-			continue
-		}
-
-		resp, err := DoRequestWithRetry(client, req, retryConfig)
-		if err != nil {
-			errors = append(errors, BuildErrorMessage(apiURL, 0, err.Error()))
-			continue
-		}
-
-		body, err := ReadResponseBody(resp)
-		resp.Body.Close()
-		if err != nil {
-			errors = append(errors, BuildErrorMessage(apiURL, resp.StatusCode, err.Error()))
-			continue
-		}
-
-		// Check if response is HTML (error page)
-		if len(body) > 0 && body[0] == '<' {
-			errors = append(errors, BuildErrorMessage(apiURL, resp.StatusCode, "received HTML instead of JSON"))
-			continue
-		}
-
-		// Check for error in JSON response
-		var errorResp struct {
-			Error string `json:"error"`
-		}
-		if json.Unmarshal(body, &errorResp) == nil && errorResp.Error != "" {
-			errors = append(errors, BuildErrorMessage(apiURL, resp.StatusCode, errorResp.Error))
-			continue
-		}
-
-		var result struct {
-			URL string `json:"url"`
-		}
-		if err := json.Unmarshal(body, &result); err != nil {
-			errors = append(errors, BuildErrorMessage(apiURL, resp.StatusCode, "invalid JSON: "+err.Error()))
-			continue
-		}
-
-		if result.URL != "" {
-			GoLog("[Qobuz] Got download URL from: %s\n", apiURL)
-			return apiURL, result.URL, nil
-		}
-
-		errors = append(errors, BuildErrorMessage(apiURL, resp.StatusCode, "no download URL in response"))
-	}
-
-	return "", "", fmt.Errorf("all %d Qobuz APIs failed. Errors: %v", len(apis), errors)
-}
-
-// GetDownloadURL gets download URL for a track - tries ALL APIs in parallel
-// "Siapa cepat dia dapat" - first successful response wins
 func (q *QobuzDownloader) GetDownloadURL(trackID int64, quality string) (string, error) {
 	apis := q.GetAvailableAPIs()
 	if len(apis) == 0 {
 		return "", fmt.Errorf("no Qobuz API available")
 	}
 
-	// Use parallel approach - request from all APIs simultaneously
 	_, downloadURL, err := getQobuzDownloadURLParallel(apis, trackID, quality)
 	if err != nil {
 		return "", err
@@ -845,19 +821,30 @@ func (q *QobuzDownloader) GetDownloadURL(trackID int64, quality string) (string,
 
 // DownloadFile downloads a file from URL with User-Agent and progress tracking
 func (q *QobuzDownloader) 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)
 	}
 
 	resp, err := DoRequestWithUserAgent(q.client, req)
 	if err != nil {
+		if isDownloadCancelled(itemID) {
+			return ErrDownloadCancelled
+		}
 		return err
 	}
 	defer resp.Body.Close()
@@ -867,7 +854,6 @@ func (q *QobuzDownloader) DownloadFile(downloadURL, outputPath, itemID string) e
 	}
 
 	expectedSize := resp.ContentLength
-	// Set total bytes if available
 	if expectedSize > 0 && itemID != "" {
 		SetItemBytesTotal(itemID, expectedSize)
 	}
@@ -877,16 +863,13 @@ func (q *QobuzDownloader) DownloadFile(downloadURL, outputPath, itemID string) e
 		return err
 	}
 
-	// Use buffered writer for better performance (256KB buffer)
 	bufWriter := bufio.NewWriterSize(out, 256*1024)
 
-	// Use item progress writer with buffered output
 	var written int64
 	if itemID != "" {
 		progressWriter := NewItemProgressWriter(bufWriter, itemID)
 		written, err = io.Copy(progressWriter, resp.Body)
 	} else {
-		// Fallback: direct copy without progress tracking
 		written, err = io.Copy(bufWriter, resp.Body)
 	}
 
@@ -894,9 +877,11 @@ func (q *QobuzDownloader) DownloadFile(downloadURL, outputPath, itemID string) e
 	flushErr := bufWriter.Flush()
 	closeErr := out.Close()
 
-	// Check for any errors
 	if err != nil {
 		os.Remove(outputPath)
+		if isDownloadCancelled(itemID) {
+			return ErrDownloadCancelled
+		}
 		return fmt.Errorf("download interrupted: %w", err)
 	}
 	if flushErr != nil {
@@ -917,7 +902,6 @@ func (q *QobuzDownloader) DownloadFile(downloadURL, outputPath, itemID string) e
 	return nil
 }
 
-// QobuzDownloadResult contains download result with quality info
 type QobuzDownloadResult struct {
 	FilePath    string
 	BitDepth    int
@@ -931,23 +915,34 @@ type QobuzDownloadResult struct {
 	ISRC        string
 }
 
-// downloadFromQobuz downloads a track using the request parameters
 func downloadFromQobuz(req DownloadRequest) (QobuzDownloadResult, error) {
 	downloader := NewQobuzDownloader()
 
-	// Check for existing file first
 	if existingFile, exists := checkISRCExistsInternal(req.OutputDir, req.ISRC); exists {
 		return QobuzDownloadResult{FilePath: "EXISTS:" + existingFile}, nil
 	}
 
-	// Convert expected duration from ms to seconds
 	expectedDurationSec := req.DurationMS / 1000
 
 	var track *QobuzTrack
 	var err error
 
+	if req.QobuzID != "" {
+		GoLog("[Qobuz] Using Qobuz ID from Odesli enrichment: %s\n", req.QobuzID)
+		var trackID int64
+		if _, parseErr := fmt.Sscanf(req.QobuzID, "%d", &trackID); parseErr == nil && trackID > 0 {
+			track, err = downloader.GetTrackByID(trackID)
+			if err != nil {
+				GoLog("[Qobuz] Failed to get track by Odesli ID %d: %v\n", trackID, err)
+				track = nil
+			} else if track != nil {
+				GoLog("[Qobuz] Successfully found track via Odesli ID: '%s' by '%s'\n", track.Title, track.Performer.Name)
+			}
+		}
+	}
+
 	// OPTIMIZATION: Check cache first for track ID
-	if req.ISRC != "" {
+	if track == nil && req.ISRC != "" {
 		if cached := GetTrackIDCache().Get(req.ISRC); cached != nil && cached.QobuzTrackID > 0 {
 			GoLog("[Qobuz] Cache hit! Using cached track ID: %d\n", cached.QobuzTrackID)
 			// For Qobuz we need to search again to get full track info, but we can use the ID
@@ -1002,7 +997,6 @@ func downloadFromQobuz(req DownloadRequest) (QobuzDownloadResult, error) {
 		GetTrackIDCache().SetQobuz(req.ISRC, track.ID)
 	}
 
-	// Build filename
 	filename := buildFilenameFromTemplate(req.FilenameFormat, map[string]interface{}{
 		"title":  req.TrackName,
 		"artist": req.ArtistName,
@@ -1014,7 +1008,6 @@ func downloadFromQobuz(req DownloadRequest) (QobuzDownloadResult, 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 QobuzDownloadResult{FilePath: "EXISTS:" + outputPath}, nil
 	}
@@ -1033,12 +1026,10 @@ func downloadFromQobuz(req DownloadRequest) (QobuzDownloadResult, error) {
 	}
 	GoLog("[Qobuz] Using quality: %s (mapped from %s)\n", qobuzQuality, req.Quality)
 
-	// Get actual quality from track metadata
 	actualBitDepth := track.MaximumBitDepth
 	actualSampleRate := int(track.MaximumSamplingRate * 1000) // Convert kHz to Hz
 	GoLog("[Qobuz] Actual quality: %d-bit/%.1fkHz\n", actualBitDepth, track.MaximumSamplingRate)
 
-	// Get download URL using parallel API requests
 	downloadURL, err := downloader.GetDownloadURL(track.ID, qobuzQuality)
 	if err != nil {
 		return QobuzDownloadResult{}, fmt.Errorf("failed to get download URL: %w", err)
@@ -1056,27 +1047,26 @@ func downloadFromQobuz(req DownloadRequest) (QobuzDownloadResult, error) {
 			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 QobuzDownloadResult{}, ErrDownloadCancelled
+		}
 		return QobuzDownloadResult{}, fmt.Errorf("download failed: %w", err)
 	}
 
 	// Wait for parallel operations to complete
 	<-parallelDone
 
-	// Set progress to 100% and status to finalizing (before embedding)
-	// This makes the UI show "Finalizing..." while embedding happens
 	if req.ItemID != "" {
 		SetItemProgress(req.ItemID, 1.0, 0, 0)
 		SetItemFinalizing(req.ItemID)
 	}
 
-	// Embed metadata using parallel-fetched cover data
-	// Use metadata from the actual Qobuz track found (more accurate than request) but prefer
-	// requested Album Name to avoid ISRC version mismatches (e.g. Compilations vs Original)
 	albumName := track.Album.Title
 	if req.AlbumName != "" {
 		albumName = req.AlbumName
@@ -1092,9 +1082,11 @@ func downloadFromQobuz(req DownloadRequest) (QobuzDownloadResult, error) {
 		TotalTracks: req.TotalTracks,
 		DiscNumber:  req.DiscNumber, // QobuzTrack struct usually doesn't have disc info in simple search result
 		ISRC:        track.ISRC,
+		Genre:       req.Genre,     // From Deezer album metadata
+		Label:       req.Label,     // From Deezer album metadata
+		Copyright:   req.Copyright, // From Deezer album metadata
 	}
 
-	// Use cover data from parallel fetch
 	var coverData []byte
 	if parallelResult != nil && parallelResult.CoverData != nil {
 		coverData = parallelResult.CoverData
@@ -1105,13 +1097,28 @@ func downloadFromQobuz(req DownloadRequest) (QobuzDownloadResult, error) {
 		fmt.Printf("Warning: failed to embed metadata: %v\n", err)
 	}
 
-	// Embed lyrics from parallel fetch
 	if req.EmbedLyrics && parallelResult != nil && parallelResult.LyricsLRC != "" {
-		GoLog("[Qobuz] Embedding parallel-fetched lyrics (%d lines)...\n", len(parallelResult.LyricsData.Lines))
-		if embedErr := EmbedLyrics(outputPath, parallelResult.LyricsLRC); embedErr != nil {
-			GoLog("[Qobuz] Warning: failed to embed lyrics: %v\n", embedErr)
-		} else {
-			fmt.Println("[Qobuz] Lyrics embedded successfully")
+		lyricsMode := req.LyricsMode
+		if lyricsMode == "" {
+			lyricsMode = "embed"
+		}
+
+		if lyricsMode == "external" || lyricsMode == "both" {
+			GoLog("[Qobuz] Saving external LRC file...\n")
+			if lrcPath, lrcErr := SaveLRCFile(outputPath, parallelResult.LyricsLRC); lrcErr != nil {
+				GoLog("[Qobuz] Warning: failed to save LRC file: %v\n", lrcErr)
+			} else {
+				GoLog("[Qobuz] LRC file saved: %s\n", lrcPath)
+			}
+		}
+
+		if lyricsMode == "embed" || lyricsMode == "both" {
+			GoLog("[Qobuz] Embedding parallel-fetched lyrics (%d lines)...\n", len(parallelResult.LyricsData.Lines))
+			if embedErr := EmbedLyrics(outputPath, parallelResult.LyricsLRC); embedErr != nil {
+				GoLog("[Qobuz] Warning: failed to embed lyrics: %v\n", embedErr)
+			} else {
+				fmt.Println("[Qobuz] Lyrics embedded successfully")
+			}
 		}
 	} else if req.EmbedLyrics {
 		fmt.Println("[Qobuz] No lyrics available from parallel fetch")

go_backend/ratelimit.go

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

go_backend/romaji.go

@@ -5,7 +5,6 @@ import (
 	"unicode"
 )
 
-// Hiragana to Romaji mapping
 var hiraganaToRomaji = map[rune]string{
 	'あ': "a", 'い': "i", 'う': "u", 'え': "e", 'お': "o",
 	'か': "ka", 'き': "ki", 'く': "ku", 'け': "ke", 'こ': "ko",
@@ -30,7 +29,6 @@ var hiraganaToRomaji = map[rune]string{
 	'ぁ': "a", 'ぃ': "i", 'ぅ': "u", 'ぇ': "e", 'ぉ': "o",
 }
 
-// Katakana to Romaji mapping
 var katakanaToRomaji = map[rune]string{
 	'ア': "a", 'イ': "i", 'ウ': "u", 'エ': "e", 'オ': "o",
 	'カ': "ka", 'キ': "ki", 'ク': "ku", 'ケ': "ke", 'コ': "ko",
@@ -58,7 +56,6 @@ var katakanaToRomaji = map[rune]string{
 	'ヴ': "vu",
 }
 
-// Combination mappings for きゃ, しゃ, etc.
 var combinationHiragana = map[string]string{
 	"きゃ": "kya", "きゅ": "kyu", "きょ": "kyo",
 	"しゃ": "sha", "しゅ": "shu", "しょ": "sho",
@@ -91,7 +88,6 @@ var combinationKatakana = map[string]string{
 	"ウィ": "wi", "ウェ": "we", "ウォ": "wo",
 }
 
-// ContainsJapanese checks if a string contains Japanese characters
 func ContainsJapanese(s string) bool {
 	for _, r := range s {
 		if isHiragana(r) || isKatakana(r) || isKanji(r) {
@@ -114,8 +110,6 @@ func isKanji(r rune) bool {
 		(r >= 0x3400 && r <= 0x4DBF) // CJK Unified Ideographs Extension A
 }
 
-// JapaneseToRomaji converts Japanese text (hiragana/katakana) to romaji
-// Note: Kanji cannot be converted without a dictionary, so they are kept as-is
 func JapaneseToRomaji(text string) string {
 	if !ContainsJapanese(text) {
 		return text
@@ -175,8 +169,6 @@ func JapaneseToRomaji(text string) string {
 	return result.String()
 }
 
-// BuildSearchQuery creates a search query from track name and artist
-// Converts Japanese to romaji if present
 func BuildSearchQuery(trackName, artistName string) string {
 	// Convert Japanese to romaji
 	trackRomaji := JapaneseToRomaji(trackName)
@@ -189,7 +181,6 @@ func BuildSearchQuery(trackName, artistName string) string {
 	return strings.TrimSpace(artistClean + " " + trackClean)
 }
 
-// cleanSearchQuery removes special characters that might interfere with search
 func cleanSearchQuery(s string) string {
 	var result strings.Builder
 	for _, r := range s {
@@ -202,8 +193,6 @@ func cleanSearchQuery(s string) string {
 	return strings.TrimSpace(result.String())
 }
 
-// CleanToASCII removes all non-ASCII characters and keeps only letters, numbers, spaces
-// This is useful for creating search queries that work better with Tidal's search
 func CleanToASCII(s string) string {
 	var result strings.Builder
 	for _, r := range s {

go_backend/songlink.go

@@ -11,12 +11,10 @@ import (
 	"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"`
@@ -31,32 +29,26 @@ type TrackAvailability struct {
 }
 
 var (
-	// Global SongLink client instance for connection reuse
 	globalSongLinkClient *SongLinkClient
 	songLinkClientOnce   sync.Once
 )
 
-// NewSongLinkClient creates a new SongLink client (returns singleton for connection reuse)
 func NewSongLinkClient() *SongLinkClient {
 	songLinkClientOnce.Do(func() {
 		globalSongLinkClient = &SongLinkClient{
-			client: NewHTTPClientWithTimeout(SongLinkTimeout), // 30s timeout
+			client: NewHTTPClientWithTimeout(SongLinkTimeout),
 		}
 	})
 	return globalSongLinkClient
 }
 
-// CheckTrackAvailability checks track availability on streaming platforms
 func (s *SongLinkClient) CheckTrackAvailability(spotifyTrackID string, isrc string) (*TrackAvailability, error) {
-	// Validate Spotify ID format (should be 22 characters alphanumeric)
 	if spotifyTrackID == "" {
 		return nil, fmt.Errorf("spotify track ID is empty")
 	}
 	
-	// Use global rate limiter - blocks until request is allowed
 	songLinkRateLimiter.WaitForSlot()
 
-	// Build API URL
 	spotifyBase, _ := base64.StdEncoding.DecodeString("aHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLw==")
 	spotifyURL := fmt.Sprintf("%s%s", string(spotifyBase), spotifyTrackID)
 
@@ -68,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 {
@@ -76,7 +67,6 @@ func (s *SongLinkClient) CheckTrackAvailability(spotifyTrackID string, isrc stri
 	}
 	defer resp.Body.Close()
 
-	// Handle specific error codes
 	if resp.StatusCode == 400 {
 		return nil, fmt.Errorf("track not found on SongLink (invalid Spotify ID or track unavailable)")
 	}
@@ -109,27 +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 Deezer
 	if deezerLink, ok := songLinkResp.LinksByPlatform["deezer"]; ok && deezerLink.URL != "" {
 		availability.Deezer = true
 		availability.DeezerURL = deezerLink.URL
-		// Extract Deezer ID from URL (e.g., https://www.deezer.com/track/123456)
 		availability.DeezerID = extractDeezerIDFromURL(deezerLink.URL)
 	}
 
-	// Check Qobuz using ISRC (SongLink doesn't support Qobuz directly)
 	if isrc != "" {
 		availability.Qobuz = checkQobuzAvailability(isrc)
 	}
@@ -137,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 {
@@ -191,12 +175,9 @@ func checkQobuzAvailability(isrc string) bool {
 
 // extractDeezerIDFromURL extracts Deezer track/album/artist ID from URL
 func extractDeezerIDFromURL(deezerURL string) string {
-	// URL format: https://www.deezer.com/track/123456 or https://www.deezer.com/en/track/123456
 	parts := strings.Split(deezerURL, "/")
 	if len(parts) > 0 {
-		// Get the last part which should be the ID
 		lastPart := parts[len(parts)-1]
-		// Remove any query parameters
 		if idx := strings.Index(lastPart, "?"); idx > 0 {
 			lastPart = lastPart[:idx]
 		}
@@ -205,7 +186,6 @@ func extractDeezerIDFromURL(deezerURL string) string {
 	return ""
 }
 
-// GetDeezerIDFromSpotify converts a Spotify track ID to Deezer track ID using SongLink
 func (s *SongLinkClient) GetDeezerIDFromSpotify(spotifyTrackID string) (string, error) {
 	availability, err := s.CheckTrackAvailability(spotifyTrackID, "")
 	if err != nil {
@@ -227,7 +207,6 @@ type AlbumAvailability struct {
 	DeezerID  string `json:"deezer_id,omitempty"`
 }
 
-// CheckAlbumAvailability checks album availability on streaming platforms using SongLink
 func (s *SongLinkClient) CheckAlbumAvailability(spotifyAlbumID string) (*AlbumAvailability, error) {
 	// Use global rate limiter
 	songLinkRateLimiter.WaitForSlot()
@@ -274,7 +253,6 @@ func (s *SongLinkClient) CheckAlbumAvailability(spotifyAlbumID string) (*AlbumAv
 		SpotifyID: spotifyAlbumID,
 	}
 
-	// Check Deezer
 	if deezerLink, ok := songLinkResp.LinksByPlatform["deezer"]; ok && deezerLink.URL != "" {
 		availability.Deezer = true
 		availability.DeezerURL = deezerLink.URL
@@ -298,24 +276,16 @@ func (s *SongLinkClient) GetDeezerAlbumIDFromSpotify(spotifyAlbumID string) (str
 	return availability.DeezerID, nil
 }
 
-// ========================================
-// Deezer ID Support - Query SongLink using Deezer as source
-// ========================================
-
-// CheckAvailabilityFromDeezer checks track availability using Deezer track ID as source
 // This is useful when we have Deezer metadata and want to find the track on other platforms
 func (s *SongLinkClient) CheckAvailabilityFromDeezer(deezerTrackID string) (*TrackAvailability, error) {
 	if deezerTrackID == "" {
 		return nil, fmt.Errorf("deezer track ID is empty")
 	}
 	
-	// Use global rate limiter
 	songLinkRateLimiter.WaitForSlot()
 
-	// Build Deezer URL
 	deezerURL := fmt.Sprintf("https://www.deezer.com/track/%s", deezerTrackID)
 
-	// Build API URL using Deezer URL as source
 	apiBase, _ := base64.StdEncoding.DecodeString("aHR0cHM6Ly9hcGkuc29uZy5saW5rL3YxLWFscGhhLjEvbGlua3M/dXJsPQ==")
 	apiURL := fmt.Sprintf("%s%s&userCountry=US", string(apiBase), url.QueryEscape(deezerURL))
 
@@ -371,25 +341,20 @@ func (s *SongLinkClient) CheckAvailabilityFromDeezer(deezerTrackID string) (*Tra
 		DeezerID: deezerTrackID,
 	}
 
-	// Check Spotify
 	if spotifyLink, ok := songLinkResp.LinksByPlatform["spotify"]; ok && spotifyLink.URL != "" {
-		// Extract Spotify ID from URL
 		availability.SpotifyID = extractSpotifyIDFromURL(spotifyLink.URL)
 	}
 
-	// Check Tidal
 	if tidalLink, ok := songLinkResp.LinksByPlatform["tidal"]; ok && tidalLink.URL != "" {
 		availability.Tidal = true
 		availability.TidalURL = tidalLink.URL
 	}
 
-	// Check Amazon
 	if amazonLink, ok := songLinkResp.LinksByPlatform["amazonMusic"]; ok && amazonLink.URL != "" {
 		availability.Amazon = true
 		availability.AmazonURL = amazonLink.URL
 	}
 
-	// Check Deezer URL
 	if deezerLink, ok := songLinkResp.LinksByPlatform["deezer"]; ok && deezerLink.URL != "" {
 		availability.DeezerURL = deezerLink.URL
 	}
@@ -397,7 +362,6 @@ func (s *SongLinkClient) CheckAvailabilityFromDeezer(deezerTrackID string) (*Tra
 	return availability, nil
 }
 
-// CheckAvailabilityByPlatform checks track availability using any supported platform
 // platform: "spotify", "deezer", "tidal", "amazonMusic", "appleMusic", "youtube", etc.
 // entityType: "song" or "album"
 // entityID: the ID on that platform
@@ -459,24 +423,20 @@ func (s *SongLinkClient) CheckAvailabilityByPlatform(platform, entityType, entit
 
 	availability := &TrackAvailability{}
 
-	// Check Spotify
 	if spotifyLink, ok := songLinkResp.LinksByPlatform["spotify"]; ok && spotifyLink.URL != "" {
 		availability.SpotifyID = extractSpotifyIDFromURL(spotifyLink.URL)
 	}
 
-	// Check Tidal
 	if tidalLink, ok := songLinkResp.LinksByPlatform["tidal"]; ok && tidalLink.URL != "" {
 		availability.Tidal = true
 		availability.TidalURL = tidalLink.URL
 	}
 
-	// Check Amazon
 	if amazonLink, ok := songLinkResp.LinksByPlatform["amazonMusic"]; ok && amazonLink.URL != "" {
 		availability.Amazon = true
 		availability.AmazonURL = amazonLink.URL
 	}
 
-	// Check Deezer
 	if deezerLink, ok := songLinkResp.LinksByPlatform["deezer"]; ok && deezerLink.URL != "" {
 		availability.Deezer = true
 		availability.DeezerURL = deezerLink.URL
@@ -488,10 +448,8 @@ func (s *SongLinkClient) CheckAvailabilityByPlatform(platform, entityType, entit
 
 // extractSpotifyIDFromURL extracts Spotify track ID from URL
 func extractSpotifyIDFromURL(spotifyURL string) string {
-	// URL format: https://open.spotify.com/track/0Jcij1eWd5bDMU5iPbxe2i
 	parts := strings.Split(spotifyURL, "/track/")
 	if len(parts) > 1 {
-		// Get the ID part and remove any query parameters
 		idPart := parts[1]
 		if idx := strings.Index(idPart, "?"); idx > 0 {
 			idPart = idPart[:idx]
@@ -501,7 +459,6 @@ func extractSpotifyIDFromURL(spotifyURL string) string {
 	return ""
 }
 
-// GetSpotifyIDFromDeezer converts a Deezer track ID to Spotify track ID using SongLink
 func (s *SongLinkClient) GetSpotifyIDFromDeezer(deezerTrackID string) (string, error) {
 	availability, err := s.CheckAvailabilityFromDeezer(deezerTrackID)
 	if err != nil {
@@ -529,7 +486,6 @@ func (s *SongLinkClient) GetTidalURLFromDeezer(deezerTrackID string) (string, er
 	return availability.TidalURL, nil
 }
 
-// GetAmazonURLFromDeezer converts a Deezer track ID to Amazon Music URL using SongLink
 func (s *SongLinkClient) GetAmazonURLFromDeezer(deezerTrackID string) (string, error) {
 	availability, err := s.CheckAvailabilityFromDeezer(deezerTrackID)
 	if err != nil {

go_backend/spotify.go

@@ -24,7 +24,6 @@ const (
 	artistAlbumsURL = "https://api.spotify.com/v1/artists/%s/albums"
 	searchBaseURL   = "https://api.spotify.com/v1/search"
 
-	// Cache TTL settings
 	artistCacheTTL = 10 * time.Minute
 	searchCacheTTL = 5 * time.Minute
 	albumCacheTTL  = 10 * time.Minute
@@ -32,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
@@ -42,26 +40,23 @@ 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 // key: artistID
-	searchCache map[string]*cacheEntry // key: query+type
-	albumCache  map[string]*cacheEntry // key: albumID
+	artistCache map[string]*cacheEntry
+	searchCache map[string]*cacheEntry
+	albumCache  map[string]*cacheEntry
 	cacheMu     sync.RWMutex
 }
 
-// Custom credentials storage (set from Flutter)
 var (
 	customClientID     string
 	customClientSecret string
@@ -79,17 +74,14 @@ func SetSpotifyCredentials(clientID, clientSecret string) {
 	customClientSecret = clientSecret
 }
 
-// HasSpotifyCredentials checks if Spotify credentials are configured
 func HasSpotifyCredentials() bool {
 	credentialsMu.RLock()
 	defer credentialsMu.RUnlock()
 
-	// Check custom credentials first
 	if customClientID != "" && customClientSecret != "" {
 		return true
 	}
 
-	// Check environment variables
 	if os.Getenv("SPOTIFY_CLIENT_ID") != "" && os.Getenv("SPOTIFY_CLIENT_SECRET") != "" {
 		return true
 	}
@@ -102,12 +94,10 @@ func getCredentials() (string, string, error) {
 	credentialsMu.RLock()
 	defer credentialsMu.RUnlock()
 
-	// Check custom credentials first
 	if customClientID != "" && customClientSecret != "" {
 		return customClientID, customClientSecret, nil
 	}
 
-	// Check environment variables
 	clientID := os.Getenv("SPOTIFY_CLIENT_ID")
 	clientSecret := os.Getenv("SPOTIFY_CLIENT_SECRET")
 
@@ -115,14 +105,10 @@ func getCredentials() (string, string, error) {
 		return clientID, clientSecret, nil
 	}
 
-	// No credentials available
 	return "", "", ErrNoSpotifyCredentials
 }
 
-// NewSpotifyMetadataClient creates a new Spotify client
-// Returns error if credentials are not configured
 func NewSpotifyMetadataClient() (*SpotifyMetadataClient, error) {
-	// Get credentials - will error if not configured
 	clientID, clientSecret, err := getCredentials()
 	if err != nil {
 		return nil, err
@@ -131,7 +117,7 @@ func NewSpotifyMetadataClient() (*SpotifyMetadataClient, error) {
 	src := rand.NewSource(time.Now().UnixNano())
 
 	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),
@@ -143,7 +129,6 @@ func NewSpotifyMetadataClient() (*SpotifyMetadataClient, error) {
 	return c, nil
 }
 
-// TrackMetadata represents track information
 type TrackMetadata struct {
 	SpotifyID   string `json:"spotify_id,omitempty"`
 	Artists     string `json:"artists"`
@@ -161,7 +146,6 @@ type TrackMetadata struct {
 	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"`
@@ -178,25 +162,25 @@ type AlbumTrackMetadata struct {
 	ISRC        string `json:"isrc"`
 	AlbumID     string `json:"album_id,omitempty"`
 	AlbumURL    string `json:"album_url,omitempty"`
-	AlbumType   string `json:"album_type,omitempty"` // album, single, ep, compilation
+	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"`
 	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"`
@@ -208,13 +192,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"`
@@ -223,7 +205,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"`
@@ -234,24 +215,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"`
@@ -260,7 +237,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"`
@@ -277,7 +253,6 @@ type accessTokenResponse struct {
 	TokenType   string      `json:"token_type"`
 }
 
-// Internal API response types
 type image struct {
 	URL string `json:"url"`
 }
@@ -303,7 +278,7 @@ type albumSimplified struct {
 	Images      []image     `json:"images"`
 	ExternalURL externalURL `json:"external_urls"`
 	Artists     []artist    `json:"artists"`
-	AlbumType   string      `json:"album_type"` // album, single, compilation
+	AlbumType   string      `json:"album_type"`
 }
 
 type trackFull struct {
@@ -318,7 +293,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 {
@@ -344,7 +318,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 {
@@ -391,12 +364,9 @@ func (c *SpotifyMetadataClient) SearchTracks(ctx context.Context, query string,
 	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()
@@ -456,7 +426,6 @@ func (c *SpotifyMetadataClient) SearchAll(ctx context.Context, query string, tra
 		})
 	}
 
-	// Limit artists to artistLimit
 	artistCount := len(response.Artists.Items)
 	if artistCount > artistLimit {
 		artistCount = artistLimit
@@ -473,7 +442,6 @@ func (c *SpotifyMetadataClient) SearchAll(ctx context.Context, query string, tra
 		})
 	}
 
-	// Store in cache
 	c.cacheMu.Lock()
 	c.searchCache[cacheKey] = &cacheEntry{
 		data:      result,
@@ -510,7 +478,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()
@@ -518,7 +485,6 @@ func (c *SpotifyMetadataClient) fetchAlbum(ctx context.Context, albumID, token s
 	}
 	c.cacheMu.RUnlock()
 
-	// Track item structure for pagination
 	type trackItem struct {
 		ID          string      `json:"id"`
 		Name        string      `json:"name"`
@@ -554,11 +520,9 @@ func (c *SpotifyMetadataClient) fetchAlbum(ctx context.Context, albumID, token s
 		Images:      albumImage,
 	}
 
-	// Collect all tracks (including paginated)
 	allTrackItems := data.Tracks.Items
 	nextURL := data.Tracks.Next
 
-	// Fetch remaining tracks using pagination (no limit)
 	for nextURL != "" {
 		var pageData struct {
 			Items []trackItem `json:"items"`
@@ -580,7 +544,6 @@ func (c *SpotifyMetadataClient) fetchAlbum(ctx context.Context, albumID, token s
 		trackIDs[i] = item.ID
 	}
 
-	// Fetch ISRCs in parallel for ALL tracks (like Deezer implementation)
 	isrcMap := c.fetchISRCsParallel(ctx, trackIDs, token)
 
 	tracks := make([]AlbumTrackMetadata, 0, len(allTrackItems))
@@ -610,7 +573,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,
@@ -621,10 +583,8 @@ func (c *SpotifyMetadataClient) fetchAlbum(ctx context.Context, albumID, token s
 	return result, nil
 }
 
-// fetchISRCsParallel fetches ISRCs for multiple tracks in parallel
-// Similar to Deezer implementation for consistency
 func (c *SpotifyMetadataClient) fetchISRCsParallel(ctx context.Context, trackIDs []string, token string) map[string]string {
-	const maxParallelISRC = 10 // Max concurrent ISRC fetches
+	const maxParallelISRC = 10
 
 	result := make(map[string]string)
 	var resultMu sync.Mutex
@@ -633,7 +593,6 @@ func (c *SpotifyMetadataClient) fetchISRCsParallel(ctx context.Context, trackIDs
 		return result
 	}
 
-	// Use semaphore to limit concurrent requests
 	sem := make(chan struct{}, maxParallelISRC)
 	var wg sync.WaitGroup
 
@@ -642,7 +601,6 @@ func (c *SpotifyMetadataClient) fetchISRCsParallel(ctx context.Context, trackIDs
 		go func(id string) {
 			defer wg.Done()
 
-			// Acquire semaphore
 			select {
 			case sem <- struct{}{}:
 				defer func() { <-sem }()
@@ -663,7 +621,6 @@ func (c *SpotifyMetadataClient) fetchISRCsParallel(ctx context.Context, trackIDs
 }
 
 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"`
@@ -689,10 +646,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
@@ -716,7 +671,6 @@ func (c *SpotifyMetadataClient) fetchPlaylist(ctx context.Context, playlistID, t
 		})
 	}
 
-	// Fetch remaining tracks using pagination (NO LIMIT - fetch all tracks)
 	nextURL := data.Tracks.Next
 
 	for nextURL != "" {
@@ -728,7 +682,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
 		}
@@ -768,7 +721,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()
@@ -776,7 +728,6 @@ func (c *SpotifyMetadataClient) fetchArtist(ctx context.Context, artistID, token
 	}
 	c.cacheMu.RUnlock()
 
-	// Fetch artist info
 	var artistData struct {
 		ID        string  `json:"id"`
 		Name      string  `json:"name"`
@@ -799,7 +750,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
@@ -839,13 +789,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
 		}
@@ -856,7 +804,6 @@ func (c *SpotifyMetadataClient) fetchArtist(ctx context.Context, artistID, token
 		Albums:     albums,
 	}
 
-	// Store in cache
 	c.cacheMu.Lock()
 	c.artistCache[artistID] = &cacheEntry{
 		data:      result,
@@ -927,7 +874,6 @@ func (c *SpotifyMetadataClient) getJSON(ctx context.Context, endpoint, token str
 		return err
 	}
 
-	// Set headers (same as PC version baseHeaders)
 	req.Header.Set("User-Agent", c.userAgent)
 	req.Header.Set("Accept", "application/json")
 	req.Header.Set("Accept-Language", "en-US,en;q=0.9")
@@ -963,8 +909,7 @@ func (c *SpotifyMetadataClient) randomUserAgent() string {
 	c.rngMu.Lock()
 	defer c.rngMu.Unlock()
 
-	// Use Mac User-Agent format (same as PC version)
-	macMajor := c.rng.Intn(4) + 11         // 11-14
+	macMajor := c.rng.Intn(4) + 11
 	macMinor := c.rng.Intn(5) + 4          // 4-8
 	webkitMajor := c.rng.Intn(7) + 530     // 530-536
 	webkitMinor := c.rng.Intn(7) + 30      // 30-36
@@ -989,7 +934,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 {
@@ -1000,13 +944,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
@@ -1019,7 +961,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 == "" {
@@ -1045,7 +986,6 @@ func parseSpotifyURI(input string) (spotifyURI, error) {
 		return spotifyURI{}, errInvalidSpotifyURL
 	}
 
-	// Skip intl- prefix if present
 	if strings.HasPrefix(parts[0], "intl-") {
 		parts = parts[1:]
 	}
@@ -1053,7 +993,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":
@@ -1061,7 +1000,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
 	}

ios/Runner/AppDelegate.swift

@@ -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]
@@ -155,7 +161,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 +172,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
             
@@ -219,6 +227,13 @@ import Gobackend  // Import Go framework
             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
@@ -367,6 +382,14 @@ import Gobackend  // Import Go framework
             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
@@ -503,6 +526,30 @@ import Gobackend  // Import Go framework
             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]
@@ -517,6 +564,47 @@ import Gobackend  // Import Go framework
             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
+            
         default:
             throw NSError(
                 domain: "SpotiFLAC",

ios/Runner/Info.plist

@@ -4,6 +4,23 @@
 <dict>
 	<key>CFBundleDevelopmentRegion</key>
 	<string>$(DEVELOPMENT_LANGUAGE)</string>
+	<key>CFBundleLocalizations</key>
+	<array>
+		<string>en</string>
+		<string>de</string>
+		<string>es</string>
+		<string>fr</string>
+		<string>hi</string>
+		<string>id</string>
+		<string>ja</string>
+		<string>ko</string>
+		<string>nl</string>
+		<string>pt</string>
+		<string>ru</string>
+		<string>zh</string>
+		<string>zh-Hans</string>
+		<string>zh-Hant</string>
+	</array>
 	<key>CFBundleDisplayName</key>
 	<string>SpotiFLAC</string>
 	<key>CFBundleExecutable</key>

l10n.yaml

@@ -0,0 +1,6 @@
+arb-dir: lib/l10n/arb
+template-arb-file: app_en.arb
+output-localization-file: app_localizations.dart
+output-class: AppLocalizations
+output-dir: lib/l10n
+nullable-getter: false

lib/app.dart

@@ -1,13 +1,14 @@
 import 'package:flutter/material.dart';
 import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:flutter_localizations/flutter_localizations.dart';
 import 'package:go_router/go_router.dart';
 import 'package:spotiflac_android/screens/main_shell.dart';
 import 'package:spotiflac_android/screens/setup_screen.dart';
 import 'package:spotiflac_android/providers/settings_provider.dart';
 import 'package:spotiflac_android/theme/dynamic_color_wrapper.dart';
+import 'package:spotiflac_android/l10n/app_localizations.dart';
 
 final _routerProvider = Provider<GoRouter>((ref) {
-  // Only watch isFirstLaunch to prevent router rebuild on other settings changes
   final isFirstLaunch = ref.watch(settingsProvider.select((s) => s.isFirstLaunch));
   
   return GoRouter(
@@ -31,6 +32,17 @@ class SpotiFLACApp extends ConsumerWidget {
   @override
   Widget build(BuildContext context, WidgetRef ref) {
     final router = ref.watch(_routerProvider);
+    final localeString = ref.watch(settingsProvider.select((s) => s.locale));
+    
+    Locale? locale;
+    if (localeString != 'system') {
+      if (localeString.contains('_')) {
+        final parts = localeString.split('_');
+        locale = Locale(parts[0], parts[1]);
+      } else {
+        locale = Locale(localeString);
+      }
+    }
     
     return DynamicColorWrapper(
       builder: (lightTheme, darkTheme, themeMode) {
@@ -43,6 +55,14 @@ class SpotiFLACApp extends ConsumerWidget {
           themeAnimationDuration: const Duration(milliseconds: 300),
           themeAnimationCurve: Curves.easeInOut,
           routerConfig: router,
+          locale: locale,
+          localizationsDelegates: const [
+            AppLocalizations.delegate,
+            GlobalMaterialLocalizations.delegate,
+            GlobalWidgetsLocalizations.delegate,
+            GlobalCupertinoLocalizations.delegate,
+          ],
+          supportedLocales: AppLocalizations.supportedLocales,
         );
       },
     );

lib/constants/app_info.dart

@@ -1,8 +1,8 @@
 /// App version and info constants
 /// Update version here only - all other files will reference this
 class AppInfo {
-  static const String version = '3.0.0-alpha.4';
-  static const String buildNumber = '53';
+  static const String version = '3.1.3';
+  static const String buildNumber = '62';
   static const String fullVersion = '$version+$buildNumber';
   
   

lib/l10n/arb/app_id.arb

@@ -0,0 +1,687 @@
+{
+  "@@locale": "id",
+  "@@last_modified": "2026-01-16",
+
+  "appName": "SpotiFLAC",
+  "appDescription": "Unduh lagu Spotify dalam kualitas lossless dari Tidal, Qobuz, dan Amazon Music.",
+
+  "navHome": "Beranda",
+  "navHistory": "Riwayat",
+  "navSettings": "Pengaturan",
+  "navStore": "Toko",
+
+  "homeTitle": "Beranda",
+  "homeSearchHint": "Tempel URL Spotify atau cari...",
+  "homeSearchHintExtension": "Cari dengan {extensionName}...",
+  "homeSubtitle": "Tempel link Spotify atau cari berdasarkan nama",
+  "homeSupports": "Mendukung: URL Track, Album, Playlist, Artis",
+  "homeRecent": "Terbaru",
+
+  "historyTitle": "Riwayat",
+  "historyDownloading": "Mengunduh ({count})",
+  "historyDownloaded": "Terunduh",
+  "historyFilterAll": "Semua",
+  "historyFilterAlbums": "Album",
+  "historyFilterSingles": "Single",
+  "historyTracksCount": "{count, plural, =1{1 lagu} other{{count} lagu}}",
+  "historyAlbumsCount": "{count, plural, =1{1 album} other{{count} album}}",
+  "historyNoDownloads": "Tidak ada riwayat unduhan",
+  "historyNoDownloadsSubtitle": "Lagu yang diunduh akan muncul di sini",
+  "historyNoAlbums": "Tidak ada unduhan album",
+  "historyNoAlbumsSubtitle": "Unduh beberapa lagu dari album untuk melihatnya di sini",
+  "historyNoSingles": "Tidak ada unduhan single",
+  "historyNoSinglesSubtitle": "Unduhan lagu satuan akan muncul di sini",
+
+  "settingsTitle": "Pengaturan",
+  "settingsDownload": "Unduhan",
+  "settingsAppearance": "Tampilan",
+  "settingsOptions": "Opsi",
+  "settingsExtensions": "Ekstensi",
+  "settingsAbout": "Tentang",
+
+  "downloadTitle": "Unduhan",
+  "downloadLocation": "Lokasi Unduhan",
+  "downloadLocationSubtitle": "Pilih tempat menyimpan file",
+  "downloadLocationDefault": "Lokasi default",
+  "downloadDefaultService": "Layanan Default",
+  "downloadDefaultServiceSubtitle": "Layanan yang digunakan untuk unduhan",
+  "downloadDefaultQuality": "Kualitas Default",
+  "downloadAskQuality": "Tanya Kualitas Sebelum Unduh",
+  "downloadAskQualitySubtitle": "Tampilkan pemilih kualitas untuk setiap unduhan",
+  "downloadFilenameFormat": "Format Nama File",
+  "downloadFolderOrganization": "Organisasi Folder",
+  "downloadSeparateSingles": "Pisahkan Single",
+  "downloadSeparateSinglesSubtitle": "Letakkan lagu satuan di folder terpisah",
+
+  "qualityBest": "Terbaik",
+  "qualityFlac": "FLAC",
+  "quality320": "320 kbps",
+  "quality128": "128 kbps",
+
+  "appearanceTitle": "Tampilan",
+  "appearanceTheme": "Tema",
+  "appearanceThemeSystem": "Sistem",
+  "appearanceThemeLight": "Terang",
+  "appearanceThemeDark": "Gelap",
+  "appearanceDynamicColor": "Warna Dinamis",
+  "appearanceDynamicColorSubtitle": "Gunakan warna dari wallpaper Anda",
+  "appearanceAccentColor": "Warna Aksen",
+  "appearanceHistoryView": "Tampilan Riwayat",
+  "appearanceHistoryViewList": "Daftar",
+  "appearanceHistoryViewGrid": "Grid",
+
+  "optionsTitle": "Opsi",
+  "optionsSearchSource": "Sumber Pencarian",
+  "optionsPrimaryProvider": "Provider Utama",
+  "optionsPrimaryProviderSubtitle": "Layanan yang digunakan saat mencari berdasarkan nama lagu.",
+  "optionsUsingExtension": "Menggunakan ekstensi: {extensionName}",
+  "optionsSwitchBack": "Ketuk Deezer atau Spotify untuk beralih dari ekstensi",
+  "optionsAutoFallback": "Auto Fallback",
+  "optionsAutoFallbackSubtitle": "Coba layanan lain jika unduhan gagal",
+  "optionsUseExtensionProviders": "Gunakan Provider Ekstensi",
+  "optionsUseExtensionProvidersOn": "Ekstensi akan dicoba terlebih dahulu",
+  "optionsUseExtensionProvidersOff": "Hanya menggunakan provider bawaan",
+  "optionsEmbedLyrics": "Sematkan Lirik",
+  "optionsEmbedLyricsSubtitle": "Sematkan lirik sinkron ke file FLAC",
+  "optionsMaxQualityCover": "Cover Kualitas Maksimal",
+  "optionsMaxQualityCoverSubtitle": "Unduh cover art resolusi tertinggi",
+  "optionsConcurrentDownloads": "Unduhan Bersamaan",
+  "optionsConcurrentSequential": "Berurutan (1 per waktu)",
+  "optionsConcurrentParallel": "{count} unduhan paralel",
+  "optionsConcurrentWarning": "Unduhan paralel dapat memicu pembatasan rate",
+  "optionsExtensionStore": "Toko Ekstensi",
+  "optionsExtensionStoreSubtitle": "Tampilkan tab Toko di navigasi",
+  "optionsCheckUpdates": "Periksa Pembaruan",
+  "optionsCheckUpdatesSubtitle": "Beritahu saat versi baru tersedia",
+  "optionsUpdateChannel": "Saluran Pembaruan",
+  "optionsUpdateChannelStable": "Hanya rilis stabil",
+  "optionsUpdateChannelPreview": "Dapatkan rilis preview",
+  "optionsUpdateChannelWarning": "Preview mungkin mengandung bug atau fitur belum lengkap",
+  "optionsClearHistory": "Hapus Riwayat Unduhan",
+  "optionsClearHistorySubtitle": "Hapus semua lagu dari riwayat",
+  "optionsDetailedLogging": "Log Detail",
+  "optionsDetailedLoggingOn": "Log detail sedang direkam",
+  "optionsDetailedLoggingOff": "Aktifkan untuk laporan bug",
+  "optionsSpotifyCredentials": "Kredensial Spotify",
+  "optionsSpotifyCredentialsConfigured": "Client ID: {clientId}...",
+  "optionsSpotifyCredentialsRequired": "Diperlukan - ketuk untuk mengatur",
+  "optionsSpotifyWarning": "Spotify memerlukan kredensial API Anda sendiri. Dapatkan gratis dari developer.spotify.com",
+
+  "extensionsTitle": "Ekstensi",
+  "extensionsInstalled": "Ekstensi Terpasang",
+  "extensionsNone": "Tidak ada ekstensi terpasang",
+  "extensionsNoneSubtitle": "Pasang ekstensi dari tab Toko",
+  "extensionsEnabled": "Aktif",
+  "extensionsDisabled": "Nonaktif",
+  "extensionsVersion": "Versi {version}",
+  "extensionsAuthor": "oleh {author}",
+  "extensionsUninstall": "Copot",
+  "extensionsSetAsSearch": "Jadikan Provider Pencarian",
+
+  "storeTitle": "Toko Ekstensi",
+  "storeSearch": "Cari ekstensi...",
+  "storeInstall": "Pasang",
+  "storeInstalled": "Terpasang",
+  "storeUpdate": "Perbarui",
+
+  "aboutTitle": "Tentang",
+  "aboutContributors": "Kontributor",
+  "aboutMobileDeveloper": "Pengembang versi mobile",
+  "aboutOriginalCreator": "Pencipta SpotiFLAC asli",
+  "aboutLogoArtist": "Seniman berbakat yang membuat logo aplikasi kami yang indah!",
+  "aboutSpecialThanks": "Terima Kasih Khusus",
+  "aboutLinks": "Tautan",
+  "aboutMobileSource": "Kode sumber mobile",
+  "aboutPCSource": "Kode sumber PC",
+  "aboutReportIssue": "Laporkan masalah",
+  "aboutReportIssueSubtitle": "Laporkan masalah yang Anda temui",
+  "aboutFeatureRequest": "Permintaan fitur",
+  "aboutFeatureRequestSubtitle": "Sarankan fitur baru untuk aplikasi",
+  "aboutSupport": "Dukungan",
+  "aboutBuyMeCoffee": "Traktir saya kopi",
+  "aboutBuyMeCoffeeSubtitle": "Dukung pengembangan di Ko-fi",
+  "aboutApp": "Aplikasi",
+  "aboutVersion": "Versi",
+
+  "albumTitle": "Album",
+  "albumTracks": "{count, plural, =1{1 lagu} other{{count} lagu}}",
+  "albumDownloadAll": "Unduh Semua",
+  "albumDownloadRemaining": "Unduh Sisanya",
+
+  "playlistTitle": "Playlist",
+  "artistTitle": "Artis",
+  "artistAlbums": "Album",
+  "artistSingles": "Single & EP",
+
+  "trackMetadataTitle": "Info Lagu",
+  "trackMetadataArtist": "Artis",
+  "trackMetadataAlbum": "Album",
+  "trackMetadataDuration": "Durasi",
+  "trackMetadataQuality": "Kualitas",
+  "trackMetadataPath": "Lokasi File",
+  "trackMetadataDownloadedAt": "Diunduh",
+  "trackMetadataService": "Layanan",
+  "trackMetadataPlay": "Putar",
+  "trackMetadataShare": "Bagikan",
+  "trackMetadataDelete": "Hapus",
+  "trackMetadataRedownload": "Unduh ulang",
+  "trackMetadataOpenFolder": "Buka Folder",
+
+  "setupTitle": "Selamat Datang di SpotiFLAC",
+  "setupSubtitle": "Mari mulai pengaturan",
+  "setupStoragePermission": "Izin Penyimpanan",
+  "setupStoragePermissionSubtitle": "Diperlukan untuk menyimpan file unduhan",
+  "setupStoragePermissionGranted": "Izin diberikan",
+  "setupStoragePermissionDenied": "Izin ditolak",
+  "setupGrantPermission": "Berikan Izin",
+  "setupDownloadLocation": "Lokasi Unduhan",
+  "setupChooseFolder": "Pilih Folder",
+  "setupContinue": "Lanjutkan",
+  "setupSkip": "Lewati untuk sekarang",
+
+  "dialogCancel": "Batal",
+  "dialogOk": "OK",
+  "dialogSave": "Simpan",
+  "dialogDelete": "Hapus",
+  "dialogRetry": "Coba Lagi",
+  "dialogClose": "Tutup",
+  "dialogYes": "Ya",
+  "dialogNo": "Tidak",
+  "dialogClear": "Hapus",
+  "dialogConfirm": "Konfirmasi",
+  "dialogDone": "Selesai",
+
+  "dialogClearHistoryTitle": "Hapus Riwayat",
+  "dialogClearHistoryMessage": "Apakah Anda yakin ingin menghapus semua riwayat unduhan? Ini tidak dapat dibatalkan.",
+  "dialogDeleteSelectedTitle": "Hapus yang Dipilih",
+  "dialogDeleteSelectedMessage": "Hapus {count} {count, plural, =1{lagu} other{lagu}} dari riwayat?\n\nIni juga akan menghapus file dari penyimpanan.",
+  "dialogImportPlaylistTitle": "Impor Playlist",
+  "dialogImportPlaylistMessage": "Ditemukan {count} lagu di CSV. Tambahkan ke antrian unduhan?",
+
+  "snackbarAddedToQueue": "Menambahkan \"{trackName}\" ke antrian",
+  "snackbarAddedTracksToQueue": "Menambahkan {count} lagu ke antrian",
+  "snackbarAlreadyDownloaded": "\"{trackName}\" sudah diunduh",
+  "snackbarHistoryCleared": "Riwayat dihapus",
+  "snackbarCredentialsSaved": "Kredensial disimpan",
+  "snackbarCredentialsCleared": "Kredensial dihapus",
+  "snackbarDeletedTracks": "Menghapus {count} {count, plural, =1{lagu} other{lagu}}",
+  "snackbarCannotOpenFile": "Tidak dapat membuka file: {error}",
+  "snackbarFillAllFields": "Harap isi semua field",
+  "snackbarViewQueue": "Lihat Antrian",
+
+  "errorRateLimited": "Dibatasi",
+  "errorRateLimitedMessage": "Terlalu banyak permintaan. Harap tunggu sebentar sebelum mencari lagi.",
+  "errorFailedToLoad": "Gagal memuat {item}",
+  "errorNoTracksFound": "Tidak ada lagu ditemukan",
+  "errorMissingExtensionSource": "Tidak dapat memuat {item}: sumber ekstensi tidak ada",
+
+  "statusQueued": "Mengantri",
+  "statusDownloading": "Mengunduh",
+  "statusFinalizing": "Menyelesaikan",
+  "statusCompleted": "Selesai",
+  "statusFailed": "Gagal",
+  "statusSkipped": "Dilewati",
+  "statusPaused": "Dijeda",
+
+  "actionPause": "Jeda",
+  "actionResume": "Lanjutkan",
+  "actionCancel": "Batal",
+  "actionStop": "Hentikan",
+  "actionSelect": "Pilih",
+  "actionSelectAll": "Pilih Semua",
+  "actionDeselect": "Batal Pilih",
+  "actionPaste": "Tempel",
+  "actionImportCsv": "Impor CSV",
+  "actionRemoveCredentials": "Hapus Kredensial",
+  "actionSaveCredentials": "Simpan Kredensial",
+
+  "selectionSelected": "{count} dipilih",
+  "selectionAllSelected": "Semua lagu dipilih",
+  "selectionTapToSelect": "Ketuk lagu untuk memilih",
+  "selectionDeleteTracks": "Hapus {count} {count, plural, =1{lagu} other{lagu}}",
+  "selectionSelectToDelete": "Pilih lagu untuk dihapus",
+
+  "progressFetchingMetadata": "Mengambil metadata... {current}/{total}",
+  "progressReadingCsv": "Membaca CSV...",
+
+  "searchSongs": "Lagu",
+  "searchArtists": "Artis",
+  "searchAlbums": "Album",
+  "searchPlaylists": "Playlist",
+
+  "tooltipPlay": "Putar",
+  "tooltipCancel": "Batal",
+  "tooltipStop": "Hentikan",
+  "tooltipRetry": "Coba Lagi",
+  "tooltipRemove": "Hapus",
+  "tooltipClear": "Hapus",
+  "tooltipPaste": "Tempel",
+
+  "filenameFormat": "Format Nama File",
+  "filenameFormatPreview": "Pratinjau: {preview}",
+  "folderOrganization": "Organisasi Folder",
+  "folderOrganizationNone": "Tanpa organisasi",
+  "folderOrganizationByArtist": "Berdasarkan Artis",
+  "folderOrganizationByAlbum": "Berdasarkan Album",
+  "folderOrganizationByArtistAlbum": "Artis/Album",
+
+  "updateAvailable": "Pembaruan Tersedia",
+  "updateNewVersion": "Versi {version} tersedia",
+  "updateDownload": "Unduh",
+  "updateLater": "Nanti",
+  "updateChangelog": "Log Perubahan",
+
+  "providerPriority": "Prioritas Provider",
+  "providerPrioritySubtitle": "Seret untuk mengatur ulang provider unduhan",
+  "metadataProviderPriority": "Prioritas Provider Metadata",
+  "metadataProviderPrioritySubtitle": "Urutan yang digunakan saat mengambil metadata lagu",
+
+  "logTitle": "Log",
+  "logCopy": "Salin Log",
+  "logClear": "Hapus Log",
+  "logShare": "Bagikan Log",
+  "logEmpty": "Belum ada log",
+  "logCopied": "Log disalin ke clipboard",
+
+  "credentialsTitle": "Kredensial Spotify",
+  "credentialsDescription": "Masukkan Client ID dan Secret Anda untuk menggunakan kuota aplikasi Spotify Anda sendiri.",
+  "credentialsClientId": "Client ID",
+  "credentialsClientIdHint": "Tempel Client ID",
+  "credentialsClientSecret": "Client Secret",
+  "credentialsClientSecretHint": "Tempel Client Secret",
+
+  "channelStable": "Stabil",
+  "channelPreview": "Preview",
+
+  "sectionSearchSource": "Sumber Pencarian",
+  "sectionDownload": "Unduhan",
+  "sectionPerformance": "Performa",
+  "sectionApp": "Aplikasi",
+  "sectionData": "Data",
+  "sectionDebug": "Debug",
+  "sectionService": "Layanan",
+  "sectionAudioQuality": "Kualitas Audio",
+  "sectionFileSettings": "Pengaturan File",
+  "sectionColor": "Warna",
+  "sectionTheme": "Tema",
+  "sectionLayout": "Tata Letak",
+  "sectionLanguage": "Bahasa",
+
+  "appearanceLanguage": "Bahasa Aplikasi",
+  "appearanceLanguageSubtitle": "Pilih bahasa yang kamu inginkan",
+  "languageSystem": "Bawaan Sistem",
+  "languageEnglish": "English",
+  "languageIndonesian": "Bahasa Indonesia",
+
+  "settingsAppearanceSubtitle": "Tema, warna, tampilan",
+  "settingsDownloadSubtitle": "Layanan, kualitas, format nama file",
+  "settingsOptionsSubtitle": "Fallback, lirik, cover art, pembaruan",
+  "settingsExtensionsSubtitle": "Kelola provider unduhan",
+  "settingsLogsSubtitle": "Lihat log aplikasi untuk debugging",
+
+  "loadingSharedLink": "Memuat link yang dibagikan...",
+  "pressBackAgainToExit": "Tekan kembali sekali lagi untuk keluar",
+
+  "artistReleases": "{count, plural, =1{1 rilis} other{{count} rilis}}",
+  "artistCompilations": "Kompilasi",
+  "artistPopular": "Populer",
+  "artistMonthlyListeners": "{count} pendengar bulanan",
+
+  "tracksHeader": "Lagu",
+  "downloadAllCount": "Unduh Semua ({count})",
+  "tracksCount": "{count, plural, =1{1 lagu} other{{count} lagu}}",
+
+  "setupStorageAccessRequired": "Akses Penyimpanan Diperlukan",
+  "setupStorageAccessMessage": "SpotiFLAC membutuhkan izin \"Akses semua file\" untuk menyimpan file musik ke folder pilihan Anda.",
+  "setupStorageAccessMessageAndroid11": "Android 11+ memerlukan izin \"Akses semua file\" untuk menyimpan file ke folder unduhan pilihan Anda.",
+  "setupOpenSettings": "Buka Pengaturan",
+  "setupPermissionDeniedMessage": "Izin ditolak. Harap berikan semua izin untuk melanjutkan.",
+  "setupPermissionRequired": "Izin {permissionType} Diperlukan",
+  "setupPermissionRequiredMessage": "Izin {permissionType} diperlukan untuk pengalaman terbaik. Anda dapat mengubahnya nanti di Pengaturan.",
+  "setupSelectDownloadFolder": "Pilih Folder Unduhan",
+  "setupUseDefaultFolder": "Gunakan Folder Default?",
+  "setupNoFolderSelected": "Tidak ada folder dipilih. Apakah Anda ingin menggunakan folder Musik default?",
+  "setupUseDefault": "Gunakan Default",
+  "setupDownloadLocationTitle": "Lokasi Unduhan",
+  "setupDownloadLocationIosMessage": "Di iOS, unduhan disimpan ke folder Documents aplikasi. Anda dapat mengaksesnya melalui aplikasi Files.",
+  "setupAppDocumentsFolder": "Folder Documents Aplikasi",
+  "setupAppDocumentsFolderSubtitle": "Direkomendasikan - dapat diakses via aplikasi Files",
+  "setupChooseFromFiles": "Pilih dari Files",
+  "setupChooseFromFilesSubtitle": "Pilih lokasi iCloud atau lainnya",
+  "setupIosEmptyFolderWarning": "Batasan iOS: Folder kosong tidak dapat dipilih. Pilih folder dengan minimal satu file.",
+  "setupDownloadInFlac": "Unduh lagu Spotify dalam format FLAC",
+  "setupStepStorage": "Penyimpanan",
+  "setupStepNotification": "Notifikasi",
+  "setupStepFolder": "Folder",
+  "setupStepSpotify": "Spotify",
+  "setupStepPermission": "Izin",
+  "setupStorageGranted": "Izin Penyimpanan Diberikan!",
+  "setupStorageRequired": "Izin Penyimpanan Diperlukan",
+  "setupStorageDescription": "SpotiFLAC membutuhkan izin penyimpanan untuk menyimpan file musik yang diunduh.",
+  "setupNotificationGranted": "Izin Notifikasi Diberikan!",
+  "setupNotificationEnable": "Aktifkan Notifikasi",
+  "setupNotificationDescription": "Dapatkan pemberitahuan saat unduhan selesai atau membutuhkan perhatian.",
+  "setupFolderSelected": "Folder Unduhan Dipilih!",
+  "setupFolderChoose": "Pilih Folder Unduhan",
+  "setupFolderDescription": "Pilih folder tempat musik yang diunduh akan disimpan.",
+  "setupChangeFolder": "Ubah Folder",
+  "setupSelectFolder": "Pilih Folder",
+  "setupSpotifyApiOptional": "Spotify API (Opsional)",
+  "setupSpotifyApiDescription": "Tambahkan kredensial Spotify API untuk hasil pencarian lebih baik dan akses ke konten eksklusif Spotify.",
+  "setupUseSpotifyApi": "Gunakan Spotify API",
+  "setupEnterCredentialsBelow": "Masukkan kredensial Anda di bawah",
+  "setupUsingDeezer": "Menggunakan Deezer (tidak perlu akun)",
+  "setupEnterClientId": "Masukkan Spotify Client ID",
+  "setupEnterClientSecret": "Masukkan Spotify Client Secret",
+  "setupGetFreeCredentials": "Dapatkan kredensial API gratis dari Spotify Developer Dashboard.",
+  "setupEnableNotifications": "Aktifkan Notifikasi",
+
+  "dialogImport": "Impor",
+  "dialogDiscard": "Buang",
+  "dialogRemove": "Hapus",
+  "dialogUninstall": "Copot",
+  "dialogDiscardChanges": "Buang Perubahan?",
+  "dialogUnsavedChanges": "Anda memiliki perubahan yang belum disimpan. Apakah Anda ingin membuangnya?",
+  "dialogDownloadFailed": "Unduhan Gagal",
+  "dialogTrackLabel": "Lagu:",
+  "dialogArtistLabel": "Artis:",
+  "dialogErrorLabel": "Error:",
+  "dialogClearAll": "Hapus Semua",
+  "dialogClearAllDownloads": "Apakah Anda yakin ingin menghapus semua unduhan?",
+  "dialogRemoveFromDevice": "Hapus dari perangkat?",
+  "dialogRemoveExtension": "Hapus Ekstensi",
+  "dialogRemoveExtensionMessage": "Apakah Anda yakin ingin menghapus ekstensi ini? Tindakan ini tidak dapat dibatalkan.",
+  "dialogUninstallExtension": "Copot Ekstensi?",
+  "dialogUninstallExtensionMessage": "Apakah Anda yakin ingin menghapus {extensionName}?",
+
+  "snackbarFailedToLoad": "Gagal memuat: {error}",
+  "snackbarUrlCopied": "URL {platform} disalin ke clipboard",
+  "snackbarFileNotFound": "File tidak ditemukan",
+  "snackbarSelectExtFile": "Harap pilih file .spotiflac-ext",
+  "snackbarProviderPrioritySaved": "Prioritas provider disimpan",
+  "snackbarMetadataProviderSaved": "Prioritas provider metadata disimpan",
+  "snackbarExtensionInstalled": "{extensionName} terpasang.",
+  "snackbarExtensionUpdated": "{extensionName} diperbarui.",
+  "snackbarFailedToInstall": "Gagal memasang ekstensi",
+  "snackbarFailedToUpdate": "Gagal memperbarui ekstensi",
+
+  "storeFilterAll": "Semua",
+  "storeFilterMetadata": "Metadata",
+  "storeFilterDownload": "Unduhan",
+  "storeFilterUtility": "Utilitas",
+  "storeFilterLyrics": "Lirik",
+  "storeFilterIntegration": "Integrasi",
+  "storeClearFilters": "Hapus filter",
+  "storeNoResults": "Tidak ada ekstensi ditemukan",
+
+  "extensionProviderPriority": "Prioritas Provider",
+  "extensionInstallButton": "Pasang Ekstensi",
+  "extensionDefaultProvider": "Default (Deezer/Spotify)",
+  "extensionDefaultProviderSubtitle": "Gunakan pencarian bawaan",
+  "extensionAuthor": "Pembuat",
+  "extensionId": "ID",
+  "extensionError": "Error",
+  "extensionCapabilities": "Kemampuan",
+  "extensionMetadataProvider": "Provider Metadata",
+  "extensionDownloadProvider": "Provider Unduhan",
+  "extensionLyricsProvider": "Provider Lirik",
+  "extensionUrlHandler": "Penanganan URL",
+  "extensionQualityOptions": "Opsi Kualitas",
+  "extensionPostProcessingHooks": "Hook Pasca-Pemrosesan",
+  "extensionPermissions": "Izin",
+  "extensionSettings": "Pengaturan",
+  "extensionRemoveButton": "Hapus Ekstensi",
+  "extensionUpdated": "Diperbarui",
+  "extensionMinAppVersion": "Versi App Minimum",
+
+  "qualityFlacLossless": "FLAC Lossless",
+  "qualityFlacLosslessSubtitle": "16-bit / 44.1kHz",
+  "qualityHiResFlac": "Hi-Res FLAC",
+  "qualityHiResFlacSubtitle": "24-bit / hingga 96kHz",
+  "qualityHiResFlacMax": "Hi-Res FLAC Max",
+  "qualityHiResFlacMaxSubtitle": "24-bit / hingga 192kHz",
+  "qualityMp3": "MP3",
+  "qualityMp3Subtitle": "320kbps (konversi dari FLAC)",
+  "enableMp3Option": "Aktifkan Opsi MP3",
+  "enableMp3OptionSubtitleOn": "Opsi kualitas MP3 tersedia",
+  "enableMp3OptionSubtitleOff": "Unduh FLAC lalu konversi ke MP3 320kbps",
+  "qualityNote": "Kualitas sebenarnya tergantung ketersediaan lagu dari layanan",
+
+  "downloadAskBeforeDownload": "Tanya Sebelum Unduh",
+  "downloadDirectory": "Direktori Unduhan",
+  "downloadSeparateSinglesFolder": "Folder Singles Terpisah",
+  "downloadAlbumFolderStructure": "Struktur Folder Album",
+  "downloadSaveFormat": "Simpan Format",
+  "downloadSelectService": "Pilih Layanan",
+  "downloadSelectQuality": "Pilih Kualitas",
+  "downloadFrom": "Unduh Dari",
+  "downloadDefaultQualityLabel": "Kualitas Default",
+  "downloadBestAvailable": "Terbaik tersedia",
+
+  "folderNone": "Tidak ada",
+  "folderNoneSubtitle": "Simpan semua file langsung ke folder unduhan",
+  "folderArtist": "Artis",
+  "folderArtistSubtitle": "Nama Artis/namafile",
+  "folderAlbum": "Album",
+  "folderAlbumSubtitle": "Nama Album/namafile",
+  "folderArtistAlbum": "Artis/Album",
+  "folderArtistAlbumSubtitle": "Nama Artis/Nama Album/namafile",
+
+  "serviceTidal": "Tidal",
+  "serviceQobuz": "Qobuz",
+  "serviceAmazon": "Amazon",
+  "serviceDeezer": "Deezer",
+  "serviceSpotify": "Spotify",
+
+  "logSearchHint": "Cari log...",
+  "logFilterLevel": "Level",
+  "logFilterSection": "Filter",
+  "logShareLogs": "Bagikan log",
+  "logClearLogs": "Hapus log",
+  "logClearLogsTitle": "Hapus Log",
+  "logClearLogsMessage": "Apakah Anda yakin ingin menghapus semua log?",
+  "logIspBlocking": "PEMBLOKIRAN ISP TERDETEKSI",
+  "logRateLimited": "DIBATASI",
+  "logNetworkError": "ERROR JARINGAN",
+  "logTrackNotFound": "LAGU TIDAK DITEMUKAN",
+
+  "appearanceAmoledDark": "AMOLED Gelap",
+  "appearanceAmoledDarkSubtitle": "Latar belakang hitam murni",
+  "appearanceChooseAccentColor": "Pilih Warna Aksen",
+  "appearanceChooseTheme": "Mode Tema",
+
+  "updateStartingDownload": "Memulai unduhan...",
+  "updateDownloadFailed": "Unduhan gagal",
+  "updateFailedMessage": "Gagal mengunduh pembaruan",
+  "updateNewVersionReady": "Versi baru sudah siap",
+  "updateCurrent": "Saat ini",
+  "updateNew": "Baru",
+  "updateDownloading": "Mengunduh...",
+  "updateWhatsNew": "Yang Baru",
+  "updateDownloadInstall": "Unduh & Pasang",
+  "updateDontRemind": "Jangan ingatkan",
+
+  "trackCopyFilePath": "Salin lokasi file",
+  "trackRemoveFromDevice": "Hapus dari perangkat",
+  "trackLoadLyrics": "Muat Lirik",
+
+  "dateToday": "Hari ini",
+  "dateYesterday": "Kemarin",
+  "dateDaysAgo": "{count} hari lalu",
+  "dateWeeksAgo": "{count} minggu lalu",
+  "dateMonthsAgo": "{count} bulan lalu",
+
+  "concurrentSequential": "Berurutan",
+  "concurrentParallel2": "2 Paralel",
+  "concurrentParallel3": "3 Paralel",
+
+  "filenameAvailablePlaceholders": "Placeholder yang tersedia:",
+  "filenameHint": "{artist} - {title}",
+
+  "tapToSeeError": "Ketuk untuk melihat detail error",
+
+  "setupProceedToNextStep": "Anda dapat melanjutkan ke langkah berikutnya.",
+  "setupNotificationProgressDescription": "Anda akan menerima notifikasi progres unduhan.",
+  "setupNotificationBackgroundDescription": "Dapatkan notifikasi tentang progres dan penyelesaian unduhan. Ini membantu Anda melacak unduhan saat aplikasi di latar belakang.",
+  "setupSkipForNow": "Lewati untuk sekarang",
+  "setupBack": "Kembali",
+  "setupNext": "Lanjut",
+  "setupGetStarted": "Mulai",
+  "setupSkipAndStart": "Lewati & Mulai",
+  "setupAllowAccessToManageFiles": "Harap aktifkan \"Izinkan akses untuk mengelola semua file\" di layar berikutnya.",
+  "setupGetCredentialsFromSpotify": "Dapatkan kredensial dari developer.spotify.com",
+
+  "trackMetadata": "Metadata",
+  "trackFileInfo": "Info File",
+  "trackLyrics": "Lirik",
+  "trackFileNotFound": "File tidak ditemukan",
+  "trackOpenInDeezer": "Buka di Deezer",
+  "trackOpenInSpotify": "Buka di Spotify",
+  "trackTrackName": "Nama lagu",
+  "trackArtist": "Artis",
+  "trackAlbumArtist": "Artis album",
+  "trackAlbum": "Album",
+  "trackTrackNumber": "Nomor lagu",
+  "trackDiscNumber": "Nomor disc",
+  "trackDuration": "Durasi",
+  "trackAudioQuality": "Kualitas audio",
+  "trackReleaseDate": "Tanggal rilis",
+  "trackDownloaded": "Diunduh",
+  "trackCopyLyrics": "Salin lirik",
+  "trackLyricsNotAvailable": "Lirik tidak tersedia untuk lagu ini",
+  "trackLyricsTimeout": "Permintaan timeout. Coba lagi nanti.",
+  "trackLyricsLoadFailed": "Gagal memuat lirik",
+  "trackCopiedToClipboard": "Disalin ke clipboard",
+  "trackDeleteConfirmTitle": "Hapus dari perangkat?",
+  "trackDeleteConfirmMessage": "Ini akan menghapus file unduhan secara permanen dan menghapusnya dari riwayat Anda.",
+  "trackCannotOpen": "Tidak dapat membuka: {message}",
+
+  "logFilterBySeverity": "Filter log berdasarkan tingkat keparahan",
+  "logNoLogsYet": "Belum ada log",
+  "logNoLogsYetSubtitle": "Log akan muncul di sini saat Anda menggunakan aplikasi",
+  "logIssueSummary": "Ringkasan Masalah",
+  "logIspBlockingDescription": "ISP Anda mungkin memblokir akses ke layanan unduhan",
+  "logIspBlockingSuggestion": "Coba gunakan VPN atau ubah DNS ke 1.1.1.1 atau 8.8.8.8",
+  "logRateLimitedDescription": "Terlalu banyak permintaan ke layanan",
+  "logRateLimitedSuggestion": "Tunggu beberapa menit sebelum mencoba lagi",
+  "logNetworkErrorDescription": "Masalah koneksi terdeteksi",
+  "logNetworkErrorSuggestion": "Periksa koneksi internet Anda",
+  "logTrackNotFoundDescription": "Beberapa lagu tidak dapat ditemukan di layanan unduhan",
+  "logTrackNotFoundSuggestion": "Lagu mungkin tidak tersedia dalam kualitas lossless",
+  "logTotalErrors": "Total error: {count}",
+  "logAffected": "Terpengaruh: {domains}",
+  "logEntriesFiltered": "Entri ({count} difilter)",
+  "logEntries": "Entri ({count})",
+
+  "extensionsProviderPrioritySection": "Prioritas Provider",
+  "extensionsInstalledSection": "Ekstensi Terpasang",
+  "extensionsNoExtensions": "Tidak ada ekstensi terpasang",
+  "extensionsNoExtensionsSubtitle": "Pasang file .spotiflac-ext untuk menambahkan provider baru",
+  "extensionsInstallButton": "Pasang Ekstensi",
+  "extensionsInfoTip": "Ekstensi dapat menambahkan provider metadata dan unduhan baru. Hanya pasang ekstensi dari sumber terpercaya.",
+  "extensionsInstalledSuccess": "Ekstensi berhasil dipasang",
+  "extensionsDownloadPriority": "Prioritas Unduhan",
+  "extensionsDownloadPrioritySubtitle": "Atur urutan layanan unduhan",
+  "extensionsNoDownloadProvider": "Tidak ada ekstensi dengan provider unduhan",
+  "extensionsMetadataPriority": "Prioritas Metadata",
+  "extensionsMetadataPrioritySubtitle": "Atur urutan sumber pencarian & metadata",
+  "extensionsNoMetadataProvider": "Tidak ada ekstensi dengan provider metadata",
+  "extensionsSearchProvider": "Provider Pencarian",
+  "extensionsNoCustomSearch": "Tidak ada ekstensi dengan pencarian kustom",
+  "extensionsSearchProviderDescription": "Pilih layanan yang digunakan untuk mencari lagu",
+  "extensionsCustomSearch": "Pencarian kustom",
+  "extensionsErrorLoading": "Error memuat ekstensi",
+
+  "extensionCustomTrackMatching": "Pencocokan Lagu Kustom",
+  "extensionPostProcessing": "Pasca-Pemrosesan",
+  "extensionHooksAvailable": "{count} hook tersedia",
+  "extensionPatternsCount": "{count} pola",
+  "extensionStrategy": "Strategi: {strategy}",
+
+  "aboutDoubleDouble": "DoubleDouble",
+  "aboutDoubleDoubleDesc": "API luar biasa untuk unduhan Amazon Music. Terima kasih sudah membuatnya gratis!",
+  "aboutDabMusic": "DAB Music",
+  "aboutDabMusicDesc": "API streaming Qobuz terbaik. Unduhan Hi-Res tidak akan mungkin tanpa ini!",
+
+  "queueTitle": "Antrian Unduhan",
+  "queueClearAll": "Hapus Semua",
+  "queueClearAllMessage": "Apakah Anda yakin ingin menghapus semua unduhan?",
+
+  "albumFolderArtistAlbum": "Artis / Album",
+  "albumFolderArtistAlbumSubtitle": "Albums/Nama Artis/Nama Album/",
+  "albumFolderArtistYearAlbum": "Artis / [Tahun] Album",
+  "albumFolderArtistYearAlbumSubtitle": "Albums/Nama Artis/[2005] Nama Album/",
+  "albumFolderAlbumOnly": "Album Saja",
+  "albumFolderAlbumOnlySubtitle": "Albums/Nama Album/",
+  "albumFolderYearAlbum": "[Tahun] Album",
+  "albumFolderYearAlbumSubtitle": "Albums/[2005] Nama Album/",
+
+  "downloadedAlbumDeleteSelected": "Hapus yang Dipilih",
+  "downloadedAlbumDeleteMessage": "Hapus {count} {count, plural, =1{lagu} other{lagu}} dari album ini?\n\nIni juga akan menghapus file dari penyimpanan.",
+
+  "utilityFunctions": "Fungsi Utilitas",
+
+  "aboutMobileDeveloper": "Pengembang versi mobile",
+  "aboutOriginalCreator": "Pembuat SpotiFLAC asli",
+  "aboutLogoArtist": "Seniman berbakat yang membuat logo aplikasi kita yang indah!",
+  "aboutBinimumDesc": "Pembuat QQDL & HiFi API. Tanpa API ini, unduhan Tidal tidak akan ada!",
+  "aboutSachinsenalDesc": "Pembuat proyek HiFi asli. Fondasi dari integrasi Tidal!",
+  "aboutMobileSource": "Kode sumber mobile",
+  "aboutPCSource": "Kode sumber PC",
+  "aboutReportIssue": "Laporkan masalah",
+  "aboutReportIssueSubtitle": "Laporkan masalah yang Anda temui",
+  "aboutFeatureRequest": "Permintaan fitur",
+  "aboutFeatureRequestSubtitle": "Sarankan fitur baru untuk aplikasi",
+  "aboutBuyMeCoffee": "Belikan saya kopi",
+  "aboutBuyMeCoffeeSubtitle": "Dukung pengembangan di Ko-fi",
+  "aboutVersion": "Versi",
+  "aboutAppDescription": "Unduh lagu Spotify dalam kualitas lossless dari Tidal, Qobuz, dan Amazon Music.",
+
+  "providerPriorityTitle": "Prioritas Provider",
+  "providerPriorityDescription": "Seret untuk mengatur ulang urutan provider unduhan. Aplikasi akan mencoba provider dari atas ke bawah saat mengunduh lagu.",
+  "providerPriorityInfo": "Jika lagu tidak tersedia di provider pertama, aplikasi akan otomatis mencoba yang berikutnya.",
+  "providerBuiltIn": "Bawaan",
+  "providerExtension": "Ekstensi",
+
+  "metadataProviderPriorityTitle": "Prioritas Metadata",
+  "metadataProviderPriorityDescription": "Seret untuk mengatur ulang urutan provider metadata. Aplikasi akan mencoba provider dari atas ke bawah saat mencari lagu dan mengambil metadata.",
+  "metadataProviderPriorityInfo": "Deezer tidak memiliki batas rate dan direkomendasikan sebagai utama. Spotify mungkin membatasi rate setelah banyak permintaan.",
+  "metadataNoRateLimits": "Tidak ada batas rate",
+  "metadataMayRateLimit": "Mungkin dibatasi rate",
+
+  "queueEmpty": "Tidak ada unduhan dalam antrian",
+  "queueEmptySubtitle": "Tambahkan lagu dari layar beranda",
+  "queueClearCompleted": "Hapus yang selesai",
+  "queueDownloadFailed": "Unduhan Gagal",
+  "queueTrackLabel": "Lagu:",
+  "queueArtistLabel": "Artis:",
+  "queueErrorLabel": "Error:",
+  "queueUnknownError": "Error tidak diketahui",
+
+  "downloadedAlbumTracksHeader": "Lagu",
+  "downloadedAlbumDownloadedCount": "{count} diunduh",
+  "downloadedAlbumSelectedCount": "{count} dipilih",
+  "downloadedAlbumAllSelected": "Semua lagu dipilih",
+  "downloadedAlbumTapToSelect": "Ketuk lagu untuk memilih",
+  "downloadedAlbumDeleteCount": "Hapus {count} {count, plural, =1{lagu} other{lagu}}",
+  "downloadedAlbumSelectToDelete": "Pilih lagu untuk dihapus",
+  "downloadedAlbumDiscHeader": "Disc {discNumber}",
+
+  "folderOrganizationDescription": "Atur file yang diunduh ke dalam folder",
+  "folderOrganizationNone": "Tidak ada",
+  "folderOrganizationNoneSubtitle": "Semua file di folder unduhan",
+  "folderOrganizationByArtist": "Berdasarkan Artis",
+  "folderOrganizationByArtistSubtitle": "Folder terpisah untuk setiap artis",
+  "folderOrganizationByAlbum": "Berdasarkan Album",
+  "folderOrganizationByAlbumSubtitle": "Folder terpisah untuk setiap album",
+  "folderOrganizationByArtistAlbum": "Berdasarkan Artis & Album",
+  "folderOrganizationByArtistAlbumSubtitle": "Folder bersarang untuk artis dan album",
+
+  "recentTypeArtist": "Artis",
+  "recentTypeAlbum": "Album",
+  "recentTypeSong": "Lagu",
+  "recentTypePlaylist": "Playlist",
+
+  "recentPlaylistInfo": "Playlist: {name}",
+  "errorGeneric": "Error: {message}"
+}

lib/l10n/l10n.dart

@@ -0,0 +1,11 @@
+import 'package:flutter/material.dart';
+import 'package:spotiflac_android/l10n/app_localizations.dart';
+
+export 'package:spotiflac_android/l10n/app_localizations.dart';
+
+/// Extension to easily access AppLocalizations from BuildContext
+extension AppLocalizationsX on BuildContext {
+  /// Get the AppLocalizations instance
+  /// Usage: context.l10n.navHome
+  AppLocalizations get l10n => AppLocalizations.of(this);
+}

lib/l10n/supported_locales.dart

@@ -0,0 +1,30 @@
+// GENERATED FILE - DO NOT EDIT
+// Generated by: dart run tool/check_translations.dart 70
+// Only languages with >= 70% translation completion are included.
+// Translation is measured by comparing VALUES (not just key existence).
+//
+// To regenerate, run: dart run tool/check_translations.dart 70
+
+import 'package:flutter/widgets.dart';
+
+/// Minimum translation completion threshold used to filter languages.
+const int translationThreshold = 70;
+
+/// List of locales that meet the translation threshold.
+/// Only these languages will be available in the app.
+const List<Locale> filteredSupportedLocales = <Locale>[
+  Locale('en'),
+  Locale('ru'),
+  Locale('es', 'ES'),
+  Locale('id'),
+  Locale('pt', 'PT'),
+];
+
+/// Set of locale codes for quick lookup.
+const Set<String> filteredLocaleCodes = <String>{
+  'en',
+  'ru',
+  'es_ES',
+  'id',
+  'pt_PT',
+};

lib/main.dart

@@ -7,15 +7,18 @@ import 'package:spotiflac_android/providers/download_queue_provider.dart';
 import 'package:spotiflac_android/providers/extension_provider.dart';
 import 'package:spotiflac_android/services/notification_service.dart';
 import 'package:spotiflac_android/services/share_intent_service.dart';
+import 'package:spotiflac_android/services/cover_cache_manager.dart';
 
 void main() async {
   WidgetsFlutterBinding.ensureInitialized();
   
-  // Initialize notification service
-  await NotificationService().initialize();
+  await CoverCacheManager.initialize();
+  debugPrint('CoverCacheManager initialized: ${CoverCacheManager.isInitialized}');
   
-  // Initialize share intent service
-  await ShareIntentService().initialize();
+  await Future.wait([
+    NotificationService().initialize(),
+    ShareIntentService().initialize(),
+  ]);
   
   runApp(
     ProviderScope(
@@ -48,11 +51,9 @@ class _EagerInitializationState extends ConsumerState<_EagerInitialization> {
       final extensionsDir = '${appDir.path}/extensions';
       final dataDir = '${appDir.path}/extension_data';
       
-      // Create directories if needed
       await Directory(extensionsDir).create(recursive: true);
       await Directory(dataDir).create(recursive: true);
       
-      // Initialize extension system
       await ref.read(extensionProvider.notifier).initialize(extensionsDir, dataDir);
     } catch (e) {
       debugPrint('Failed to initialize extensions: $e');
@@ -61,7 +62,6 @@ class _EagerInitializationState extends ConsumerState<_EagerInitialization> {
 
   @override
   Widget build(BuildContext context) {
-    // Eagerly initialize download history provider to load from storage
     ref.watch(downloadHistoryProvider);
     return widget.child;
   }

lib/models/download_item.dart

@@ -3,23 +3,21 @@ import 'package:spotiflac_android/models/track.dart';
 
 part 'download_item.g.dart';
 
-/// Download status enum
 enum DownloadStatus {
   queued,
   downloading,
-  finalizing, // Embedding metadata, cover, lyrics
+  finalizing,
   completed,
   failed,
   skipped,
 }
 
-/// Error type enum for better error handling
 enum DownloadErrorType {
   unknown,
-  notFound,    // Track not found on any service
-  rateLimit,   // Rate limited by service
-  network,     // Network/connection error
-  permission,  // File/folder permission error
+  notFound,
+  rateLimit,
+  network,
+  permission,
 }
 
 @JsonSerializable()
@@ -29,7 +27,7 @@ class DownloadItem {
   final String service;
   final DownloadStatus status;
   final double progress;
-  final double speedMBps; // Download speed in MB/s
+  final double speedMBps;
   final String? filePath;
   final String? error;
   final DownloadErrorType? errorType;
@@ -78,7 +76,6 @@ class DownloadItem {
     );
   }
 
-  /// Get user-friendly error message based on error type
   String get errorMessage {
     if (error == null) return '';
     

lib/models/settings.dart

@@ -12,23 +12,27 @@ class AppSettings {
   final bool embedLyrics;
   final bool maxQualityCover;
   final bool isFirstLaunch;
-  final int concurrentDownloads; // 1 = sequential (default), max 3
-  final bool checkForUpdates; // Check for updates on app start
-  final String updateChannel; // stable, preview
-  final bool hasSearchedBefore; // Hide helper text after first search
-  final String folderOrganization; // none, artist, album, artist_album
-  final String historyViewMode; // list, grid
-  final String historyFilterMode; // all, albums, singles
-  final bool askQualityBeforeDownload; // Show quality picker before each download
-  final String spotifyClientId; // Custom Spotify client ID (empty = use default)
-  final String spotifyClientSecret; // Custom Spotify client secret (empty = use default)
-  final bool useCustomSpotifyCredentials; // Whether to use custom credentials (if set)
-  final String metadataSource; // spotify, deezer - source for search and metadata
-  final bool enableLogging; // Enable detailed logging for debugging
-  final bool useExtensionProviders; // Use extension providers for downloads when available
-  final String? searchProvider; // null/empty = default (Deezer/Spotify), otherwise extension ID
-  final bool separateSingles; // Separate singles/EPs into their own folder
-  final bool showExtensionStore; // Show Extension Store tab in navigation
+  final int concurrentDownloads;
+  final bool checkForUpdates;
+  final String updateChannel;
+  final bool hasSearchedBefore;
+  final String folderOrganization;
+  final String historyViewMode;
+  final String historyFilterMode;
+  final bool askQualityBeforeDownload;
+  final String spotifyClientId;
+  final String spotifyClientSecret;
+  final bool useCustomSpotifyCredentials;
+  final String metadataSource;
+  final bool enableLogging;
+  final bool useExtensionProviders;
+  final String? searchProvider;
+  final bool separateSingles;
+  final String albumFolderStructure;
+  final bool showExtensionStore;
+  final String locale;
+  final bool enableMp3Option;
+  final String lyricsMode;
 
   const AppSettings({
     this.defaultService = 'tidal',
@@ -39,23 +43,27 @@ class AppSettings {
     this.embedLyrics = true,
     this.maxQualityCover = true,
     this.isFirstLaunch = true,
-    this.concurrentDownloads = 1, // Default: sequential (off)
-    this.checkForUpdates = true, // Default: enabled
-    this.updateChannel = 'stable', // Default: stable releases only
-    this.hasSearchedBefore = false, // Default: show helper text
-    this.folderOrganization = 'none', // Default: no folder organization
-    this.historyViewMode = 'grid', // Default: grid view
-    this.historyFilterMode = 'all', // Default: show all
-    this.askQualityBeforeDownload = true, // Default: ask quality before download
-    this.spotifyClientId = '', // Default: use built-in credentials
-    this.spotifyClientSecret = '', // Default: use built-in credentials
-    this.useCustomSpotifyCredentials = true, // Default: use custom if set
-    this.metadataSource = 'deezer', // Default: Deezer (no rate limit)
-    this.enableLogging = false, // Default: disabled for performance
-    this.useExtensionProviders = true, // Default: use extensions when available
-    this.searchProvider, // Default: null (use Deezer/Spotify)
-    this.separateSingles = false, // Default: disabled
-    this.showExtensionStore = true, // Default: show store
+    this.concurrentDownloads = 1,
+    this.checkForUpdates = true,
+    this.updateChannel = 'stable',
+    this.hasSearchedBefore = false,
+    this.folderOrganization = 'none',
+    this.historyViewMode = 'grid',
+    this.historyFilterMode = 'all',
+    this.askQualityBeforeDownload = true,
+    this.spotifyClientId = '',
+    this.spotifyClientSecret = '',
+    this.useCustomSpotifyCredentials = true,
+    this.metadataSource = 'deezer',
+    this.enableLogging = false,
+    this.useExtensionProviders = true,
+    this.searchProvider,
+    this.separateSingles = false,
+    this.albumFolderStructure = 'artist_album',
+    this.showExtensionStore = true,
+    this.locale = 'system',
+    this.enableMp3Option = false,
+    this.lyricsMode = 'embed',
   });
 
   AppSettings copyWith({
@@ -82,8 +90,13 @@ class AppSettings {
     bool? enableLogging,
     bool? useExtensionProviders,
     String? searchProvider,
+    bool clearSearchProvider = false,
     bool? separateSingles,
+    String? albumFolderStructure,
     bool? showExtensionStore,
+    String? locale,
+    bool? enableMp3Option,
+    String? lyricsMode,
   }) {
     return AppSettings(
       defaultService: defaultService ?? this.defaultService,
@@ -108,9 +121,13 @@ class AppSettings {
       metadataSource: metadataSource ?? this.metadataSource,
       enableLogging: enableLogging ?? this.enableLogging,
       useExtensionProviders: useExtensionProviders ?? this.useExtensionProviders,
-      searchProvider: searchProvider ?? this.searchProvider,
+      searchProvider: clearSearchProvider ? null : (searchProvider ?? this.searchProvider),
       separateSingles: separateSingles ?? this.separateSingles,
+      albumFolderStructure: albumFolderStructure ?? this.albumFolderStructure,
       showExtensionStore: showExtensionStore ?? this.showExtensionStore,
+      locale: locale ?? this.locale,
+      enableMp3Option: enableMp3Option ?? this.enableMp3Option,
+      lyricsMode: lyricsMode ?? this.lyricsMode,
     );
   }
 

lib/models/settings.g.dart

@@ -32,7 +32,12 @@ AppSettings _$AppSettingsFromJson(Map<String, dynamic> json) => AppSettings(
   useExtensionProviders: json['useExtensionProviders'] as bool? ?? true,
   searchProvider: json['searchProvider'] as String?,
   separateSingles: json['separateSingles'] as bool? ?? false,
+  albumFolderStructure:
+      json['albumFolderStructure'] as String? ?? 'artist_album',
   showExtensionStore: json['showExtensionStore'] as bool? ?? true,
+  locale: json['locale'] as String? ?? 'system',
+  enableMp3Option: json['enableMp3Option'] as bool? ?? false,
+  lyricsMode: json['lyricsMode'] as String? ?? 'embed',
 );
 
 Map<String, dynamic> _$AppSettingsToJson(AppSettings instance) =>
@@ -61,5 +66,9 @@ Map<String, dynamic> _$AppSettingsToJson(AppSettings instance) =>
       'useExtensionProviders': instance.useExtensionProviders,
       'searchProvider': instance.searchProvider,
       'separateSingles': instance.separateSingles,
+      'albumFolderStructure': instance.albumFolderStructure,
       'showExtensionStore': instance.showExtensionStore,
+      'locale': instance.locale,
+      'enableMp3Option': instance.enableMp3Option,
+      'lyricsMode': instance.lyricsMode,
     };

lib/models/theme_settings.dart

@@ -9,7 +9,6 @@ const String kUseAmoledKey = 'use_amoled';
 /// Default Spotify green color for fallback
 const int kDefaultSeedColor = 0xFF1DB954;
 
-/// Theme settings model for Material Expressive 3
 class ThemeSettings {
   final ThemeMode themeMode;
   final bool useDynamicColor;
@@ -23,10 +22,8 @@ class ThemeSettings {
     this.useAmoled = false,
   });
 
-  /// Get seed color as Color object
   Color get seedColor => Color(seedColorValue);
 
-  /// Create a copy with updated values
   ThemeSettings copyWith({
     ThemeMode? themeMode,
     bool? useDynamicColor,
@@ -41,7 +38,6 @@ class ThemeSettings {
     );
   }
 
-  /// Convert to JSON map for persistence
   Map<String, dynamic> toJson() => {
         kThemeModeKey: themeMode.name,
         kUseDynamicColorKey: useDynamicColor,
@@ -49,7 +45,6 @@ class ThemeSettings {
         kUseAmoledKey: useAmoled,
       };
 
-  /// Create from JSON map
   factory ThemeSettings.fromJson(Map<String, dynamic> json) {
     return ThemeSettings(
       themeMode: _themeModeFromString(json[kThemeModeKey] as String?),
@@ -74,7 +69,6 @@ class ThemeSettings {
       themeMode.hashCode ^ useDynamicColor.hashCode ^ seedColorValue.hashCode ^ useAmoled.hashCode;
 }
 
-/// Helper to convert string to ThemeMode
 ThemeMode _themeModeFromString(String? value) {
   if (value == null) return ThemeMode.system;
   return ThemeMode.values.firstWhere(

lib/models/track.dart

@@ -2,7 +2,6 @@ import 'package:json_annotation/json_annotation.dart';
 
 part 'track.g.dart';
 
-/// Track model representing a music track
 @JsonSerializable()
 class Track {
   final String id;
@@ -18,8 +17,9 @@ class Track {
   final String? releaseDate;
   final String? deezerId;
   final ServiceAvailability? availability;
-  final String? source; // Extension ID that provided this track (null for built-in sources)
-  final String? albumType; // album, single, ep, compilation (from metadata API)
+  final String? source;
+  final String? albumType;
+  final String? itemType;
 
   const Track({
     required this.id,
@@ -37,15 +37,22 @@ class Track {
     this.availability,
     this.source,
     this.albumType,
+    this.itemType,
   });
 
-  /// Check if this track is a single (based on album_type metadata)
   bool get isSingle => albumType == 'single' || albumType == 'ep';
+  
+  bool get isAlbumItem => itemType == 'album';
+  
+  bool get isPlaylistItem => itemType == 'playlist';
+  
+  bool get isArtistItem => itemType == 'artist';
+  
+  bool get isCollection => isAlbumItem || isPlaylistItem || isArtistItem;
 
   factory Track.fromJson(Map<String, dynamic> json) => _$TrackFromJson(json);
   Map<String, dynamic> toJson() => _$TrackToJson(this);
   
-  /// Check if this track is from an extension
   bool get isFromExtension => source != null && source!.isNotEmpty;
 }
 

lib/models/track.g.dart

@@ -26,6 +26,7 @@ Track _$TrackFromJson(Map<String, dynamic> json) => Track(
         ),
   source: json['source'] as String?,
   albumType: json['albumType'] as String?,
+  itemType: json['itemType'] as String?,
 );
 
 Map<String, dynamic> _$TrackToJson(Track instance) => <String, dynamic>{
@@ -44,6 +45,7 @@ Map<String, dynamic> _$TrackToJson(Track instance) => <String, dynamic>{
   'availability': instance.availability,
   'source': instance.source,
   'albumType': instance.albumType,
+  'itemType': instance.itemType,
 };
 
 ServiceAvailability _$ServiceAvailabilityFromJson(Map<String, dynamic> json) =>

lib/providers/extension_provider.dart

@@ -5,7 +5,6 @@ import 'package:spotiflac_android/providers/settings_provider.dart';
 
 final _log = AppLogger('ExtensionProvider');
 
-/// Represents an installed extension
 class Extension {
   final String id;
   final String name;
@@ -14,19 +13,19 @@ class Extension {
   final String author;
   final String description;
   final bool enabled;
-  final String status; // 'loaded', 'error', 'disabled'
+  final String status;
   final String? errorMessage;
-  final String? iconPath; // Path to extension icon
+  final String? iconPath;
   final List<String> permissions;
   final List<ExtensionSetting> settings;
-  final List<QualityOption> qualityOptions; // Custom quality options for download providers
+  final List<QualityOption> qualityOptions;
   final bool hasMetadataProvider;
   final bool hasDownloadProvider;
   final bool skipMetadataEnrichment; // If true, use metadata from extension instead of enriching
-  final SearchBehavior? searchBehavior; // Custom search behavior
-  final URLHandler? urlHandler; // Custom URL handling
-  final TrackMatching? trackMatching; // Custom track matching
-  final PostProcessing? postProcessing; // Post-processing hooks
+  final SearchBehavior? searchBehavior;
+  final URLHandler? urlHandler;
+  final TrackMatching? trackMatching;
+  final PostProcessing? postProcessing;
 
   const Extension({
     required this.id,
@@ -140,7 +139,6 @@ class Extension {
   bool get hasPostProcessing => postProcessing?.enabled ?? false;
 }
 
-/// Custom search behavior configuration
 class SearchBehavior {
   final bool enabled;
   final String? placeholder;
@@ -172,15 +170,11 @@ class SearchBehavior {
     );
   }
 
-  /// Get thumbnail size based on configuration
-  /// Returns (width, height) tuple
   (double, double) getThumbnailSize({double defaultSize = 56}) {
-    // If custom dimensions specified, use them
     if (thumbnailWidth != null && thumbnailHeight != null) {
       return (thumbnailWidth!.toDouble(), thumbnailHeight!.toDouble());
     }
     
-    // Otherwise use ratio presets
     switch (thumbnailRatio) {
       case 'wide': // 16:9 - YouTube style
         return (defaultSize * 16 / 9, defaultSize);
@@ -193,11 +187,10 @@ class SearchBehavior {
   }
 }
 
-/// Custom track matching configuration
 class TrackMatching {
   final bool customMatching;
-  final String? strategy; // "isrc", "name", "duration", "custom"
-  final int durationTolerance; // in seconds
+  final String? strategy;
+  final int durationTolerance;
 
   const TrackMatching({
     required this.customMatching,
@@ -214,7 +207,6 @@ class TrackMatching {
   }
 }
 
-/// Post-processing configuration
 class PostProcessing {
   final bool enabled;
   final List<PostProcessingHook> hooks;
@@ -264,7 +256,6 @@ class URLHandler {
   }
 }
 
-/// A post-processing hook
 class PostProcessingHook {
   final String id;
   final String name;
@@ -291,12 +282,11 @@ class PostProcessingHook {
   }
 }
 
-/// Represents a quality option for download providers
 class QualityOption {
   final String id;
   final String label;
   final String? description;
-  final List<QualitySpecificSetting> settings; // Quality-specific settings
+  final List<QualitySpecificSetting> settings;
 
   const QualityOption({
     required this.id,
@@ -317,14 +307,13 @@ class QualityOption {
   }
 }
 
-/// Represents a setting that's specific to a quality option
 class QualitySpecificSetting {
   final String key;
   final String label;
-  final String type; // 'string', 'number', 'boolean', 'select'
+  final String type;
   final dynamic defaultValue;
   final String? description;
-  final List<String>? options; // For select type
+  final List<String>? options;
   final bool required;
   final bool secret;
 
@@ -353,15 +342,15 @@ class QualitySpecificSetting {
   }
 }
 
-/// Represents a setting field for an extension
 class ExtensionSetting {
   final String key;
   final String label;
-  final String type; // 'string', 'number', 'boolean', 'select'
+  final String type;
   final dynamic defaultValue;
   final String? description;
-  final List<String>? options; // For select type
+  final List<String>? options;
   final bool required;
+  final String? action;
 
   const ExtensionSetting({
     required this.key,
@@ -371,6 +360,7 @@ class ExtensionSetting {
     this.description,
     this.options,
     this.required = false,
+    this.action,
   });
 
   factory ExtensionSetting.fromJson(Map<String, dynamic> json) {
@@ -382,11 +372,11 @@ class ExtensionSetting {
       description: json['description'] as String?,
       options: (json['options'] as List<dynamic>?)?.cast<String>(),
       required: json['required'] as bool? ?? false,
+      action: json['action'] as String?,
     );
   }
 }
 
-/// State for extension management
 class ExtensionState {
   final List<Extension> extensions;
   final List<String> providerPriority;
@@ -424,7 +414,6 @@ class ExtensionState {
 }
 
 
-/// Provider for managing extensions
 class ExtensionNotifier extends Notifier<ExtensionState> {
   @override
   ExtensionState build() {
@@ -450,7 +439,6 @@ class ExtensionNotifier extends Notifier<ExtensionState> {
     }
   }
 
-  /// Load all extensions from directory
   Future<void> loadExtensions(String dirPath) async {
     state = state.copyWith(isLoading: true, error: null);
     
@@ -485,12 +473,10 @@ class ExtensionNotifier extends Notifier<ExtensionState> {
     }
   }
 
-  /// Clear any error state
   void clearError() {
     state = state.copyWith(error: null);
   }
 
-  /// Install extension from file (auto-upgrades if already installed with newer version)
   Future<bool> installExtension(String filePath) async {
     state = state.copyWith(isLoading: true, error: null);
     
@@ -507,8 +493,6 @@ class ExtensionNotifier extends Notifier<ExtensionState> {
     }
   }
 
-  /// Check if a package file is an upgrade for an existing extension
-  /// Returns: {extension_id, current_version, new_version, can_upgrade, is_installed}
   Future<Map<String, dynamic>> checkExtensionUpgrade(String filePath) async {
     try {
       return await PlatformBridge.checkExtensionUpgrade(filePath);
@@ -518,7 +502,6 @@ class ExtensionNotifier extends Notifier<ExtensionState> {
     }
   }
 
-  /// Upgrade an existing extension from a new package file
   Future<bool> upgradeExtension(String filePath) async {
     state = state.copyWith(isLoading: true, error: null);
     
@@ -552,16 +535,13 @@ class ExtensionNotifier extends Notifier<ExtensionState> {
     }
   }
 
-  /// Enable or disable an extension
   Future<void> setExtensionEnabled(String extensionId, bool enabled) async {
     try {
       await PlatformBridge.setExtensionEnabled(extensionId, enabled);
       _log.d('Set extension $extensionId enabled: $enabled');
       
-      // Get extension info before updating state
       final ext = state.extensions.where((e) => e.id == extensionId).firstOrNull;
       
-      // Update local state
       final extensions = state.extensions.map((e) {
         if (e.id == extensionId) {
           return e.copyWith(enabled: enabled);
@@ -571,18 +551,15 @@ class ExtensionNotifier extends Notifier<ExtensionState> {
       
       state = state.copyWith(extensions: extensions);
       
-      // If disabling an extension, reset related settings
       if (!enabled && ext != null) {
         final settings = ref.read(settingsProvider);
         
-        // If this extension was the search provider, clear it and reset to Deezer
         if (settings.searchProvider == extensionId) {
           ref.read(settingsProvider.notifier).setSearchProvider(null);
           ref.read(settingsProvider.notifier).setMetadataSource('deezer');
           _log.d('Cleared search provider and reset to Deezer because extension $extensionId was disabled');
         }
         
-        // If this extension was the default download service, reset to Tidal
         if (ext.hasDownloadProvider && settings.defaultService == extensionId) {
           ref.read(settingsProvider.notifier).setDefaultService('tidal');
           _log.d('Reset default service to Tidal because extension $extensionId was disabled');
@@ -604,7 +581,6 @@ class ExtensionNotifier extends Notifier<ExtensionState> {
     }
   }
 
-  /// Update settings for an extension
   Future<void> setExtensionSettings(String extensionId, Map<String, dynamic> settings) async {
     try {
       await PlatformBridge.setExtensionSettings(extensionId, settings);
@@ -625,7 +601,6 @@ class ExtensionNotifier extends Notifier<ExtensionState> {
     }
   }
 
-  /// Set provider priority order
   Future<void> setProviderPriority(List<String> priority) async {
     try {
       await PlatformBridge.setProviderPriority(priority);
@@ -647,7 +622,6 @@ class ExtensionNotifier extends Notifier<ExtensionState> {
     }
   }
 
-  /// Set metadata provider priority order
   Future<void> setMetadataProviderPriority(List<String> priority) async {
     try {
       await PlatformBridge.setMetadataProviderPriority(priority);
@@ -669,7 +643,6 @@ class ExtensionNotifier extends Notifier<ExtensionState> {
     }
   }
 
-  /// Get extension by ID
   Extension? getExtension(String extensionId) {
     try {
       return state.extensions.firstWhere((ext) => ext.id == extensionId);
@@ -683,7 +656,6 @@ class ExtensionNotifier extends Notifier<ExtensionState> {
     return state.extensions.where((ext) => ext.enabled).toList();
   }
 
-  /// Get all download providers (built-in + extensions)
   List<String> getAllDownloadProviders() {
     final providers = ['tidal', 'qobuz', 'amazon'];
     for (final ext in state.extensions) {
@@ -704,7 +676,6 @@ class ExtensionNotifier extends Notifier<ExtensionState> {
     }
     return providers;
   }
-  /// Get all extensions that provide custom search
   List<Extension> get searchProviders {
     return state.extensions.where((ext) => ext.enabled && ext.hasCustomSearch).toList();
   }

lib/providers/recent_access_provider.dart

@@ -0,0 +1,270 @@
+import 'dart:convert';
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:shared_preferences/shared_preferences.dart';
+
+const _recentAccessKey = 'recent_access_history';
+const _hiddenDownloadsKey = 'hidden_downloads_in_recents';
+const _maxRecentItems = 20;
+
+/// Types of items that can be accessed
+enum RecentAccessType {
+  artist,
+  album,
+  track,
+  playlist,
+}
+
+/// Represents a recently accessed item
+class RecentAccessItem {
+  final String id;
+  final String name;
+  final String? subtitle; // Artist name for tracks/albums, null for artists
+  final String? imageUrl;
+  final RecentAccessType type;
+  final DateTime accessedAt;
+  final String? providerId; // Extension ID or 'deezer' for built-in
+
+  const RecentAccessItem({
+    required this.id,
+    required this.name,
+    this.subtitle,
+    this.imageUrl,
+    required this.type,
+    required this.accessedAt,
+    this.providerId,
+  });
+
+  Map<String, dynamic> toJson() => {
+    'id': id,
+    'name': name,
+    'subtitle': subtitle,
+    'imageUrl': imageUrl,
+    'type': type.name,
+    'accessedAt': accessedAt.toIso8601String(),
+    'providerId': providerId,
+  };
+
+  factory RecentAccessItem.fromJson(Map<String, dynamic> json) {
+    return RecentAccessItem(
+      id: json['id'] as String,
+      name: json['name'] as String,
+      subtitle: json['subtitle'] as String?,
+      imageUrl: json['imageUrl'] as String?,
+      type: RecentAccessType.values.firstWhere(
+        (e) => e.name == json['type'],
+        orElse: () => RecentAccessType.track,
+      ),
+      accessedAt: DateTime.parse(json['accessedAt'] as String),
+      providerId: json['providerId'] as String?,
+    );
+  }
+
+  /// Create a unique key for deduplication
+  String get uniqueKey => '${type.name}:${providerId ?? 'default'}:$id';
+
+  @override
+  bool operator ==(Object other) =>
+      identical(this, other) ||
+      other is RecentAccessItem &&
+          runtimeType == other.runtimeType &&
+          uniqueKey == other.uniqueKey;
+
+  @override
+  int get hashCode => uniqueKey.hashCode;
+}
+
+/// State for recent access history
+class RecentAccessState {
+  final List<RecentAccessItem> items;
+  final Set<String> hiddenDownloadIds; // IDs of downloads hidden from recents
+  final bool isLoaded;
+
+  const RecentAccessState({
+    this.items = const [],
+    this.hiddenDownloadIds = const {},
+    this.isLoaded = false,
+  });
+
+  RecentAccessState copyWith({
+    List<RecentAccessItem>? items,
+    Set<String>? hiddenDownloadIds,
+    bool? isLoaded,
+  }) {
+    return RecentAccessState(
+      items: items ?? this.items,
+      hiddenDownloadIds: hiddenDownloadIds ?? this.hiddenDownloadIds,
+      isLoaded: isLoaded ?? this.isLoaded,
+    );
+  }
+}
+
+/// Provider for managing recent access history
+class RecentAccessNotifier extends Notifier<RecentAccessState> {
+  @override
+  RecentAccessState build() {
+    _loadHistory();
+    return const RecentAccessState();
+  }
+
+  Future<void> _loadHistory() async {
+    final prefs = await SharedPreferences.getInstance();
+    final json = prefs.getString(_recentAccessKey);
+    final hiddenJson = prefs.getStringList(_hiddenDownloadsKey);
+    
+    List<RecentAccessItem> items = [];
+    Set<String> hiddenIds = {};
+    
+    if (json != null) {
+      try {
+        final List<dynamic> decoded = jsonDecode(json);
+        items = decoded
+            .map((e) => RecentAccessItem.fromJson(e as Map<String, dynamic>))
+            .toList();
+      } catch (e) {
+      }
+    }
+    
+    if (hiddenJson != null) {
+      hiddenIds = hiddenJson.toSet();
+    }
+    
+    state = state.copyWith(items: items, hiddenDownloadIds: hiddenIds, isLoaded: true);
+  }
+
+  Future<void> _saveHistory() async {
+    final prefs = await SharedPreferences.getInstance();
+    final json = jsonEncode(state.items.map((e) => e.toJson()).toList());
+    await prefs.setString(_recentAccessKey, json);
+  }
+
+  Future<void> _saveHiddenDownloads() async {
+    final prefs = await SharedPreferences.getInstance();
+    await prefs.setStringList(_hiddenDownloadsKey, state.hiddenDownloadIds.toList());
+  }
+
+  /// Record an access to an artist
+  void recordArtistAccess({
+    required String id,
+    required String name,
+    String? imageUrl,
+    String? providerId,
+  }) {
+    _recordAccess(RecentAccessItem(
+      id: id,
+      name: name,
+      imageUrl: imageUrl,
+      type: RecentAccessType.artist,
+      accessedAt: DateTime.now(),
+      providerId: providerId,
+    ));
+  }
+
+  /// Record an access to an album
+  void recordAlbumAccess({
+    required String id,
+    required String name,
+    String? artistName,
+    String? imageUrl,
+    String? providerId,
+  }) {
+    _recordAccess(RecentAccessItem(
+      id: id,
+      name: name,
+      subtitle: artistName,
+      imageUrl: imageUrl,
+      type: RecentAccessType.album,
+      accessedAt: DateTime.now(),
+      providerId: providerId,
+    ));
+  }
+
+  /// Record an access to a track
+  void recordTrackAccess({
+    required String id,
+    required String name,
+    String? artistName,
+    String? imageUrl,
+    String? providerId,
+  }) {
+    _recordAccess(RecentAccessItem(
+      id: id,
+      name: name,
+      subtitle: artistName,
+      imageUrl: imageUrl,
+      type: RecentAccessType.track,
+      accessedAt: DateTime.now(),
+      providerId: providerId,
+    ));
+  }
+
+  /// Record an access to a playlist
+  void recordPlaylistAccess({
+    required String id,
+    required String name,
+    String? ownerName,
+    String? imageUrl,
+    String? providerId,
+  }) {
+    _recordAccess(RecentAccessItem(
+      id: id,
+      name: name,
+      subtitle: ownerName,
+      imageUrl: imageUrl,
+      type: RecentAccessType.playlist,
+      accessedAt: DateTime.now(),
+      providerId: providerId,
+    ));
+  }
+
+  void _recordAccess(RecentAccessItem item) {
+    final updatedItems = state.items
+        .where((e) => e.uniqueKey != item.uniqueKey)
+        .toList();
+    
+    updatedItems.insert(0, item);
+    
+    if (updatedItems.length > _maxRecentItems) {
+      updatedItems.removeRange(_maxRecentItems, updatedItems.length);
+    }
+    
+    state = state.copyWith(items: updatedItems);
+    _saveHistory();
+  }
+
+  /// Remove a specific item from history
+  void removeItem(RecentAccessItem item) {
+    final updatedItems = state.items
+        .where((e) => e.uniqueKey != item.uniqueKey)
+        .toList();
+    state = state.copyWith(items: updatedItems);
+    _saveHistory();
+  }
+
+  /// Hide a download item from recents (without deleting the actual download)
+  void hideDownloadFromRecents(String downloadId) {
+    final updatedHidden = {...state.hiddenDownloadIds, downloadId};
+    state = state.copyWith(hiddenDownloadIds: updatedHidden);
+    _saveHiddenDownloads();
+  }
+
+  /// Check if a download is hidden from recents
+  bool isDownloadHidden(String downloadId) {
+    return state.hiddenDownloadIds.contains(downloadId);
+  }
+
+  /// Clear all history
+  void clearHistory() {
+    state = state.copyWith(items: []);
+    _saveHistory();
+  }
+
+  /// Clear hidden downloads (show all again)
+  void clearHiddenDownloads() {
+    state = state.copyWith(hiddenDownloadIds: {});
+    _saveHiddenDownloads();
+  }
+}
+
+final recentAccessProvider = NotifierProvider<RecentAccessNotifier, RecentAccessState>(
+  RecentAccessNotifier.new,
+);

lib/providers/settings_provider.dart

@@ -22,32 +22,24 @@ class SettingsNotifier extends Notifier<AppSettings> {
     if (json != null) {
       state = AppSettings.fromJson(jsonDecode(json));
       
-      // Run migrations if needed
       await _runMigrations(prefs);
       
-      // Apply Spotify credentials to Go backend on load
       _applySpotifyCredentials();
       
-      // Sync logging state
       LogBuffer.loggingEnabled = state.enableLogging;
     }
   }
 
-  /// Run one-time migrations for settings
   Future<void> _runMigrations(SharedPreferences prefs) async {
     final lastMigration = prefs.getInt(_migrationVersionKey) ?? 0;
     
     if (lastMigration < 1) {
-      // Migration 1: Set metadataSource to 'deezer' for existing users
-      // Only apply if user hasn't enabled custom Spotify credentials
-      // (users with custom credentials likely prefer Spotify)
       if (!state.useCustomSpotifyCredentials) {
         state = state.copyWith(metadataSource: 'deezer');
         await _saveSettings();
       }
     }
     
-    // Save current migration version
     if (lastMigration < _currentMigrationVersion) {
       await prefs.setInt(_migrationVersionKey, _currentMigrationVersion);
     }
@@ -58,9 +50,7 @@ class SettingsNotifier extends Notifier<AppSettings> {
     await prefs.setString(_settingsKey, jsonEncode(state.toJson()));
   }
 
-  /// Apply current Spotify credentials to Go backend
   Future<void> _applySpotifyCredentials() async {
-    // Only apply if both fields are set
     if (state.spotifyClientId.isNotEmpty && 
         state.spotifyClientSecret.isNotEmpty) {
       await PlatformBridge.setSpotifyCredentials(
@@ -68,8 +58,6 @@ class SettingsNotifier extends Notifier<AppSettings> {
         state.spotifyClientSecret,
       );
     }
-    // Note: If credentials are empty, Spotify API will return error
-    // User should use Deezer as metadata source instead
   }
 
   void setDefaultService(String service) {
@@ -102,6 +90,13 @@ class SettingsNotifier extends Notifier<AppSettings> {
     _saveSettings();
   }
 
+  void setLyricsMode(String mode) {
+    if (mode == 'embed' || mode == 'external' || mode == 'both') {
+      state = state.copyWith(lyricsMode: mode);
+      _saveSettings();
+    }
+  }
+
   void setMaxQualityCover(bool enabled) {
     state = state.copyWith(maxQualityCover: enabled);
     _saveSettings();
@@ -113,7 +108,6 @@ class SettingsNotifier extends Notifier<AppSettings> {
   }
 
   void setConcurrentDownloads(int count) {
-    // Clamp between 1 and 3
     final clamped = count.clamp(1, 3);
     state = state.copyWith(concurrentDownloads: clamped);
     _saveSettings();
@@ -196,14 +190,17 @@ class SettingsNotifier extends Notifier<AppSettings> {
   }
 
   void setSearchProvider(String? provider) {
-    state = state.copyWith(searchProvider: provider);
+    if (provider == null || provider.isEmpty) {
+      state = state.copyWith(clearSearchProvider: true);
+    } else {
+      state = state.copyWith(searchProvider: provider);
+    }
     _saveSettings();
   }
 
   void setEnableLogging(bool enabled) {
     state = state.copyWith(enableLogging: enabled);
     _saveSettings();
-    // Sync logging state to LogBuffer
     LogBuffer.loggingEnabled = enabled;
   }
 
@@ -217,10 +214,29 @@ class SettingsNotifier extends Notifier<AppSettings> {
     _saveSettings();
   }
 
+  void setAlbumFolderStructure(String structure) {
+    state = state.copyWith(albumFolderStructure: structure);
+    _saveSettings();
+  }
+
   void setShowExtensionStore(bool enabled) {
     state = state.copyWith(showExtensionStore: enabled);
     _saveSettings();
   }
+
+  void setLocale(String locale) {
+    state = state.copyWith(locale: locale);
+    _saveSettings();
+  }
+
+  void setEnableMp3Option(bool enabled) {
+    state = state.copyWith(enableMp3Option: enabled);
+    // If MP3 is disabled and current quality is MP3, reset to LOSSLESS
+    if (!enabled && state.audioQuality == 'MP3') {
+      state = state.copyWith(audioQuality: 'LOSSLESS');
+    }
+    _saveSettings();
+  }
 }
 
 final settingsProvider = NotifierProvider<SettingsNotifier, AppSettings>(

lib/providers/store_provider.dart

@@ -1,10 +1,29 @@
 import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:spotiflac_android/constants/app_info.dart';
 import 'package:spotiflac_android/services/platform_bridge.dart';
 import 'package:spotiflac_android/utils/logger.dart';
 import 'package:spotiflac_android/providers/extension_provider.dart';
 
 final _log = AppLogger('StoreProvider');
 
+/// Compare two semantic version strings
+/// Returns: -1 if v1 < v2, 0 if equal, 1 if v1 > v2
+int compareVersions(String v1, String v2) {
+  final parts1 = v1.replaceAll(RegExp(r'^v'), '').split('.');
+  final parts2 = v2.replaceAll(RegExp(r'^v'), '').split('.');
+  
+  final maxLen = parts1.length > parts2.length ? parts1.length : parts2.length;
+  
+  for (var i = 0; i < maxLen; i++) {
+    final n1 = i < parts1.length ? (int.tryParse(parts1[i]) ?? 0) : 0;
+    final n2 = i < parts2.length ? (int.tryParse(parts2[i]) ?? 0) : 0;
+    
+    if (n1 < n2) return -1;
+    if (n1 > n2) return 1;
+  }
+  return 0;
+}
+
 /// Extension categories
 class StoreCategory {
   static const String metadata = 'metadata';
@@ -33,7 +52,6 @@ class StoreCategory {
   }
 }
 
-/// Represents an extension in the store
 class StoreExtension {
   final String id;
   final String name;
@@ -91,9 +109,14 @@ class StoreExtension {
       hasUpdate: json['has_update'] as bool? ?? false,
     );
   }
+
+  /// Check if this extension requires a higher app version than current
+  bool get requiresNewerApp {
+    if (minAppVersion == null || minAppVersion!.isEmpty) return false;
+    return compareVersions(minAppVersion!, AppInfo.version) > 0;
+  }
 }
 
-/// State for extension store
 class StoreState {
   final List<StoreExtension> extensions;
   final String? selectedCategory;
@@ -161,6 +184,11 @@ class StoreState {
 
     return result;
   }
+
+  /// Count of extensions with updates available
+  int get updatesAvailableCount {
+    return extensions.where((e) => e.hasUpdate).length;
+  }
 }
 
 /// Provider for managing extension store
@@ -170,7 +198,6 @@ class StoreNotifier extends Notifier<StoreState> {
     return const StoreState();
   }
 
-  /// Initialize the store
   Future<void> initialize(String cacheDir) async {
     if (state.isInitialized) return;
 
@@ -204,7 +231,6 @@ class StoreNotifier extends Notifier<StoreState> {
     }
   }
 
-  /// Set category filter
   void setCategory(String? category) {
     if (category == null) {
       state = state.copyWith(clearCategory: true);
@@ -218,7 +244,6 @@ class StoreNotifier extends Notifier<StoreState> {
     state = state.copyWith(searchQuery: query);
   }
 
-  /// Clear search
   void clearSearch() {
     state = state.copyWith(searchQuery: '', clearCategory: true);
   }
@@ -249,7 +274,6 @@ class StoreNotifier extends Notifier<StoreState> {
     }
   }
 
-  /// Update an installed extension
   Future<bool> updateExtension(String extensionId, String tempDir) async {
     state = state.copyWith(isDownloading: true, downloadingId: extensionId, clearError: true);
 
@@ -275,7 +299,6 @@ class StoreNotifier extends Notifier<StoreState> {
     }
   }
 
-  /// Clear error
   void clearError() {
     state = state.copyWith(clearError: true);
   }

lib/providers/theme_provider.dart

@@ -34,7 +34,6 @@ class ThemeNotifier extends Notifier<ThemeSettings> {
       );
     } catch (e) {
       debugPrint('Error loading theme settings: $e');
-      // Keep default state on error
     }
   }
 

lib/providers/track_provider.dart

@@ -17,9 +17,13 @@ class TrackState {
   final String? artistId;
   final String? artistName;
   final String? coverUrl;
+  final String? headerImageUrl; // Artist header image for background
+  final int? monthlyListeners; // Artist monthly listeners
   final List<ArtistAlbum>? artistAlbums; // For artist page
+  final List<Track>? artistTopTracks; // Artist's popular tracks
   final List<SearchArtist>? searchArtists; // For search results
   final bool hasSearchText; // For back button handling
+  final bool isShowingRecentAccess; // For recent access mode
   final String? searchExtensionId; // Extension ID used for current search results
 
   const TrackState({
@@ -32,9 +36,13 @@ class TrackState {
     this.artistId,
     this.artistName,
     this.coverUrl,
+    this.headerImageUrl,
+    this.monthlyListeners,
     this.artistAlbums,
+    this.artistTopTracks,
     this.searchArtists,
     this.hasSearchText = false,
+    this.isShowingRecentAccess = false,
     this.searchExtensionId,
   });
 
@@ -50,9 +58,13 @@ class TrackState {
     String? artistId,
     String? artistName,
     String? coverUrl,
+    String? headerImageUrl,
+    int? monthlyListeners,
     List<ArtistAlbum>? artistAlbums,
+    List<Track>? artistTopTracks,
     List<SearchArtist>? searchArtists,
     bool? hasSearchText,
+    bool? isShowingRecentAccess,
     String? searchExtensionId,
   }) {
     return TrackState(
@@ -65,15 +77,18 @@ class TrackState {
       artistId: artistId ?? this.artistId,
       artistName: artistName ?? this.artistName,
       coverUrl: coverUrl ?? this.coverUrl,
+      headerImageUrl: headerImageUrl ?? this.headerImageUrl,
+      monthlyListeners: monthlyListeners ?? this.monthlyListeners,
       artistAlbums: artistAlbums ?? this.artistAlbums,
+      artistTopTracks: artistTopTracks ?? this.artistTopTracks,
       searchArtists: searchArtists ?? this.searchArtists,
       hasSearchText: hasSearchText ?? this.hasSearchText,
+      isShowingRecentAccess: isShowingRecentAccess ?? this.isShowingRecentAccess,
       searchExtensionId: searchExtensionId,
     );
   }
 }
 
-/// Represents an album in artist discography
 class ArtistAlbum {
   final String id;
   final String name;
@@ -82,6 +97,7 @@ class ArtistAlbum {
   final String? coverUrl;
   final String albumType; // album, single, compilation
   final String artists;
+  final String? providerId; // Extension ID if from extension
 
   const ArtistAlbum({
     required this.id,
@@ -91,10 +107,10 @@ class ArtistAlbum {
     this.coverUrl,
     required this.albumType,
     required this.artists,
+    this.providerId,
   });
 }
 
-/// Represents an artist in search results
 class SearchArtist {
   final String id;
   final String name;
@@ -112,7 +128,6 @@ class SearchArtist {
 }
 
 class TrackNotifier extends Notifier<TrackState> {
-  /// Request ID to track and cancel outdated requests
   int _currentRequestId = 0;
 
   @override
@@ -124,14 +139,11 @@ class TrackNotifier extends Notifier<TrackState> {
   bool _isRequestValid(int requestId) => requestId == _currentRequestId;
 
   Future<void> fetchFromUrl(String url, {bool useDeezerFallback = true}) async {
-    // Increment request ID to cancel any pending requests
     final requestId = ++_currentRequestId;
 
-    // Preserve hasSearchText during fetch
     state = TrackState(isLoading: true, hasSearchText: state.hasSearchText);
 
     try {
-      // First, check if any extension can handle this URL
       final extensionHandler = await PlatformBridge.findURLHandler(url);
       if (extensionHandler != null) {
         _log.i('Found extension URL handler: $extensionHandler for URL: $url');
@@ -169,13 +181,20 @@ class TrackNotifier extends Notifier<TrackState> {
             final artistData = result['artist'] as Map<String, dynamic>;
             final albumsList = artistData['albums'] as List<dynamic>? ?? [];
             final albums = albumsList.map((a) => _parseArtistAlbum(a as Map<String, dynamic>)).toList();
+            
+            final topTracksList = artistData['top_tracks'] as List<dynamic>? ?? [];
+            final topTracks = topTracksList.map((t) => _parseSearchTrack(t as Map<String, dynamic>, source: extensionId)).toList();
+            
             state = TrackState(
               tracks: [],
               isLoading: false,
               artistId: artistData['id'] as String?,
               artistName: artistData['name'] as String?,
               coverUrl: artistData['image_url'] as String? ?? artistData['images'] as String?,
+              headerImageUrl: artistData['header_image'] as String?,
+              monthlyListeners: artistData['listeners'] as int?,
               artistAlbums: albums,
+              artistTopTracks: topTracks.isNotEmpty ? topTracks : null,
               searchExtensionId: extensionId,
             );
             return;
@@ -183,25 +202,16 @@ class TrackNotifier extends Notifier<TrackState> {
         }
       }
       
-      // No extension handler found, try Spotify URL parsing
       final parsed = await PlatformBridge.parseSpotifyUrl(url);
       if (!_isRequestValid(requestId)) return; // Request cancelled
       
       final type = parsed['type'] as String;
 
-      // Use the new fallback-enabled method
       Map<String, dynamic> metadata;
       
       try {
-        // ignore: avoid_print
-        print('[FetchURL] Fetching $type with Deezer fallback enabled...');
         metadata = await PlatformBridge.getSpotifyMetadataWithFallback(url);
-        // ignore: avoid_print
-        print('[FetchURL] Metadata fetch success');
       } catch (e) {
-        // If fallback also fails, show error
-        // ignore: avoid_print
-        print('[FetchURL] Metadata fetch failed: $e');
         rethrow;
       }
       
@@ -226,7 +236,6 @@ class TrackNotifier extends Notifier<TrackState> {
           albumName: albumInfo['name'] as String?,
           coverUrl: albumInfo['images'] as String?,
         );
-        // Pre-warm cache for album tracks in background
         _preWarmCacheForTracks(tracks);
       } else if (type == 'playlist') {
         final playlistInfo = metadata['playlist_info'] as Map<String, dynamic>;
@@ -239,14 +248,13 @@ class TrackNotifier extends Notifier<TrackState> {
           playlistName: owner?['name'] as String?,
           coverUrl: owner?['images'] as String?,
         );
-        // Pre-warm cache for playlist tracks in background
         _preWarmCacheForTracks(tracks);
       } else if (type == 'artist') {
         final artistInfo = metadata['artist_info'] as Map<String, dynamic>;
         final albumsList = metadata['albums'] as List<dynamic>;
         final albums = albumsList.map((a) => _parseArtistAlbum(a as Map<String, dynamic>)).toList();
         state = TrackState(
-          tracks: [], // No tracks for artist view
+          tracks: [],
           isLoading: false,
           artistId: artistInfo['id'] as String?,
           artistName: artistInfo['name'] as String?,
@@ -255,44 +263,44 @@ class TrackNotifier extends Notifier<TrackState> {
         );
       }
     } catch (e) {
-      if (!_isRequestValid(requestId)) return; // Request cancelled
-      // Preserve hasSearchText on error so user stays on search screen
+      if (!_isRequestValid(requestId)) return;
       state = TrackState(isLoading: false, error: e.toString(), hasSearchText: state.hasSearchText);
     }
   }
 
   Future<void> search(String query, {String? metadataSource}) async {
-    // Increment request ID to cancel any pending requests
     final requestId = ++_currentRequestId;
 
-    // Preserve hasSearchText during search
     state = TrackState(isLoading: true, hasSearchText: state.hasSearchText);
 
     try {
-      // Check if extension providers should be used for search
       final settings = ref.read(settingsProvider);
       final extensionState = ref.read(extensionProvider);
       final hasActiveMetadataExtensions = extensionState.extensions.any(
         (e) => e.enabled && e.hasMetadataProvider,
       );
-      final useExtensions = settings.useExtensionProviders && hasActiveMetadataExtensions;
+      final searchProvider = settings.searchProvider;
+      final useExtensions =
+          settings.useExtensionProviders &&
+          hasActiveMetadataExtensions &&
+          searchProvider != null &&
+          searchProvider.isNotEmpty;
 
-      // Use Deezer or Spotify based on settings
       final source = metadataSource ?? 'deezer';
       
-      _log.i('Search started: source=$source, query="$query", useExtensions=$useExtensions');
+      _log.i(
+        'Search started: source=$source, query="$query", useExtensions=$useExtensions',
+      );
       
       Map<String, dynamic> results;
       List<Track> extensionTracks = [];
       
-      // Try extension providers first if enabled
       if (useExtensions) {
         try {
           _log.d('Calling extension search API...');
           final extResults = await PlatformBridge.searchTracksWithExtensions(query, limit: 20);
           _log.i('Extensions returned ${extResults.length} tracks');
           
-          // Parse extension results
           for (final t in extResults) {
             try {
               extensionTracks.add(_parseSearchTrack(t));
@@ -305,7 +313,6 @@ class TrackNotifier extends Notifier<TrackState> {
         }
       }
       
-      // Also search with built-in providers
       if (source == 'deezer') {
         _log.d('Calling Deezer search API...');
         results = await PlatformBridge.searchDeezerAll(query, trackLimit: 20, artistLimit: 5);
@@ -326,13 +333,10 @@ class TrackNotifier extends Notifier<TrackState> {
       
       _log.d('Raw results: ${trackList.length} tracks, ${artistList.length} artists');
       
-      // Parse tracks with error handling per item
       final tracks = <Track>[];
       
-      // Add extension tracks first (they have priority)
       tracks.addAll(extensionTracks);
       
-      // Add built-in provider tracks, avoiding duplicates by ISRC
       final existingIsrcs = extensionTracks
           .where((t) => t.isrc != null && t.isrc!.isNotEmpty)
           .map((t) => t.isrc!)
@@ -343,7 +347,6 @@ class TrackNotifier extends Notifier<TrackState> {
         try {
           if (t is Map<String, dynamic>) {
             final track = _parseSearchTrack(t);
-            // Skip if we already have this track from extensions
             if (track.isrc != null && existingIsrcs.contains(track.isrc)) {
               continue;
             }
@@ -356,7 +359,6 @@ class TrackNotifier extends Notifier<TrackState> {
         }
       }
       
-      // Parse artists with error handling per item
       final artists = <SearchArtist>[];
       for (int i = 0; i < artistList.length; i++) {
         final a = artistList[i];
@@ -386,12 +388,9 @@ class TrackNotifier extends Notifier<TrackState> {
     }
   }
 
-  /// Perform custom search using a specific extension
   Future<void> customSearch(String extensionId, String query, {Map<String, dynamic>? options}) async {
-    // Increment request ID to cancel any pending requests
     final requestId = ++_currentRequestId;
 
-    // Preserve hasSearchText during search
     state = TrackState(isLoading: true, hasSearchText: state.hasSearchText);
 
     try {
@@ -406,7 +405,6 @@ class TrackNotifier extends Notifier<TrackState> {
       
       _log.i('Custom search returned ${results.length} tracks');
       
-      // Parse tracks with error handling per item, setting source to extension ID
       final tracks = <Track>[];
       for (int i = 0; i < results.length; i++) {
         final t = results[i];
@@ -421,7 +419,7 @@ class TrackNotifier extends Notifier<TrackState> {
       
       state = TrackState(
         tracks: tracks,
-        searchArtists: [], // Custom search doesn't return artists
+        searchArtists: [],
         isLoading: false,
         hasSearchText: state.hasSearchText,
         searchExtensionId: extensionId, // Store which extension was used
@@ -453,6 +451,8 @@ class TrackNotifier extends Notifier<TrackState> {
         trackNumber: track.trackNumber,
         discNumber: track.discNumber,
         releaseDate: track.releaseDate,
+        albumType: track.albumType,
+        source: track.source,
         availability: ServiceAvailability(
           tidal: availability['tidal'] as bool? ?? false,
           qobuz: availability['qobuz'] as bool? ?? false,
@@ -467,7 +467,6 @@ class TrackNotifier extends Notifier<TrackState> {
       tracks[index] = updatedTrack;
       state = state.copyWith(tracks: tracks);
     } catch (e) {
-      // Silently fail availability check
     }
   }
 
@@ -477,8 +476,32 @@ class TrackNotifier extends Notifier<TrackState> {
 
   /// Set search text state for back button handling
   void setSearchText(bool hasText) {
+    if (state.hasSearchText == hasText) {
+      return;
+    }
     state = state.copyWith(hasSearchText: hasText);
   }
+  
+  void setShowingRecentAccess(bool showing) {
+    state = state.copyWith(isShowingRecentAccess: showing);
+  }
+  
+  /// Set tracks from a collection (album/playlist) opened from search results
+  void setTracksFromCollection({
+    required List<Track> tracks,
+    String? albumName,
+    String? playlistName,
+    String? coverUrl,
+  }) {
+    state = TrackState(
+      tracks: tracks,
+      isLoading: false,
+      albumName: albumName,
+      playlistName: playlistName,
+      coverUrl: coverUrl,
+      hasSearchText: state.hasSearchText,
+    );
+  }
 
   Track _parseTrack(Map<String, dynamic> data) {
     return Track(
@@ -497,7 +520,6 @@ class TrackNotifier extends Notifier<TrackState> {
   }
 
   Track _parseSearchTrack(Map<String, dynamic> data, {String? source}) {
-    // Handle duration_ms which might be int or double
     int durationMs = 0;
     final durationValue = data['duration_ms'];
     if (durationValue is int) {
@@ -506,13 +528,15 @@ class TrackNotifier extends Notifier<TrackState> {
       durationMs = durationValue.toInt();
     }
     
+    final itemType = data['item_type']?.toString();
+    
     return Track(
       id: (data['spotify_id'] ?? data['id'] ?? '').toString(),
       name: (data['name'] ?? '').toString(),
       artistName: (data['artists'] ?? data['artist'] ?? '').toString(),
       albumName: (data['album_name'] ?? data['album'] ?? '').toString(),
       albumArtist: data['album_artist']?.toString(),
-      coverUrl: data['images']?.toString(),
+      coverUrl: (data['cover_url'] ?? data['images'])?.toString(),
       isrc: data['isrc']?.toString(),
       duration: (durationMs / 1000).round(),
       trackNumber: data['track_number'] as int?,
@@ -520,6 +544,7 @@ class TrackNotifier extends Notifier<TrackState> {
       releaseDate: data['release_date']?.toString(),
       source: source ?? data['source']?.toString() ?? data['provider_id']?.toString(),
       albumType: data['album_type']?.toString(),
+      itemType: itemType,
     );
   }
 
@@ -529,9 +554,10 @@ class TrackNotifier extends Notifier<TrackState> {
       name: data['name'] as String? ?? '',
       releaseDate: data['release_date'] as String? ?? '',
       totalTracks: data['total_tracks'] as int? ?? 0,
-      coverUrl: data['images'] as String?,
+      coverUrl: (data['cover_url'] ?? data['images'])?.toString(),
       albumType: data['album_type'] as String? ?? 'album',
       artists: data['artists'] as String? ?? '',
+      providerId: data['provider_id']?.toString(),
     );
   }
 
@@ -545,26 +571,19 @@ class TrackNotifier extends Notifier<TrackState> {
     );
   }
 
-  /// Pre-warm track ID cache for faster downloads
-  /// Runs in background, doesn't block UI
   void _preWarmCacheForTracks(List<Track> tracks) {
-    // Only pre-warm if we have tracks with ISRC
     final tracksWithIsrc = tracks.where((t) => t.isrc != null && t.isrc!.isNotEmpty).toList();
     if (tracksWithIsrc.isEmpty) return;
 
-    // Build request list for Go backend
     final cacheRequests = tracksWithIsrc.map((t) => {
       'isrc': t.isrc!,
       'track_name': t.name,
       'artist_name': t.artistName,
       'spotify_id': t.id, // Include Spotify ID for Amazon lookup
-      'service': 'tidal', // Default to tidal for pre-warming
+      'service': 'tidal',
     }).toList();
 
-    // Fire and forget - runs in background
-    PlatformBridge.preWarmTrackCache(cacheRequests).catchError((_) {
-      // Silently ignore errors - this is just an optimization
-    });
+    PlatformBridge.preWarmTrackCache(cacheRequests).catchError((_) {});
   }
 }
 

lib/screens/album_screen.dart

@@ -2,14 +2,17 @@ import 'dart:io';
 import 'package:flutter/material.dart';
 import 'package:flutter_riverpod/flutter_riverpod.dart';
 import 'package:cached_network_image/cached_network_image.dart';
+import 'package:palette_generator/palette_generator.dart';
+import 'package:spotiflac_android/services/cover_cache_manager.dart';
+import 'package:spotiflac_android/l10n/l10n.dart';
 import 'package:spotiflac_android/models/track.dart';
 import 'package:spotiflac_android/models/download_item.dart';
 import 'package:spotiflac_android/providers/download_queue_provider.dart';
 import 'package:spotiflac_android/providers/settings_provider.dart';
+import 'package:spotiflac_android/providers/recent_access_provider.dart';
 import 'package:spotiflac_android/services/platform_bridge.dart';
 import 'package:spotiflac_android/widgets/download_service_picker.dart';
 
-/// Simple in-memory cache for album tracks
 class _AlbumCache {
   static final Map<String, _CacheEntry> _cache = {};
   static const Duration _ttl = Duration(minutes: 10);
@@ -35,7 +38,6 @@ class _CacheEntry {
   _CacheEntry(this.tracks, this.expiresAt);
 }
 
-/// Album detail screen with Material Expressive 3 design
 class AlbumScreen extends ConsumerStatefulWidget {
   final String albumId;
   final String albumName;
@@ -58,15 +60,65 @@ class _AlbumScreenState extends ConsumerState<AlbumScreen> {
   List<Track>? _tracks;
   bool _isLoading = false;
   String? _error;
+  Color? _dominantColor;
+  bool _showTitleInAppBar = false;
+  final ScrollController _scrollController = ScrollController();
 
   @override
   void initState() {
     super.initState();
-    // Priority: widget.tracks > cache > fetch
+    
+    _scrollController.addListener(_onScroll);
+    
+    WidgetsBinding.instance.addPostFrameCallback((_) {
+      final providerId = widget.albumId.startsWith('deezer:') ? 'deezer' : 'spotify';
+      ref.read(recentAccessProvider.notifier).recordAlbumAccess(
+        id: widget.albumId,
+        name: widget.albumName,
+        artistName: widget.tracks?.firstOrNull?.artistName,
+        imageUrl: widget.coverUrl,
+        providerId: providerId,
+      );
+    });
+    
     _tracks = widget.tracks ?? _AlbumCache.get(widget.albumId);
     if (_tracks == null) {
       _fetchTracks();
     }
+    
+    _extractDominantColor();
+  }
+
+  @override
+  void dispose() {
+    _scrollController.removeListener(_onScroll);
+    _scrollController.dispose();
+    super.dispose();
+  }
+
+  void _onScroll() {
+    final shouldShow = _scrollController.offset > 280;
+    if (shouldShow != _showTitleInAppBar) {
+      setState(() => _showTitleInAppBar = shouldShow);
+    }
+  }
+
+  Future<void> _extractDominantColor() async {
+    if (widget.coverUrl == null) return;
+    try {
+      final paletteGenerator = await PaletteGenerator.fromImageProvider(
+        CachedNetworkImageProvider(widget.coverUrl!),
+        maximumColorCount: 16,
+      );
+      if (mounted) {
+        setState(() {
+          _dominantColor = paletteGenerator.dominantColor?.color ??
+              paletteGenerator.vibrantColor?.color ??
+              paletteGenerator.mutedColor?.color;
+        });
+      }
+    } catch (_) {
+    }
   }
 
   Future<void> _fetchTracks() async {
@@ -74,16 +126,10 @@ class _AlbumScreenState extends ConsumerState<AlbumScreen> {
     try {
       Map<String, dynamic> metadata;
       
-      // Check if this is a Deezer album ID (format: "deezer:123456")
       if (widget.albumId.startsWith('deezer:')) {
         final deezerAlbumId = widget.albumId.replaceFirst('deezer:', '');
-        // ignore: avoid_print
-        print('[AlbumScreen] Fetching from Deezer: $deezerAlbumId');
         metadata = await PlatformBridge.getDeezerMetadata('album', deezerAlbumId);
       } else {
-        // Spotify album - use fallback method
-        // ignore: avoid_print
-        print('[AlbumScreen] Fetching from Spotify with fallback: ${widget.albumId}');
         final url = 'https://open.spotify.com/album/${widget.albumId}';
         metadata = await PlatformBridge.getSpotifyMetadataWithFallback(url);
       }
@@ -91,7 +137,6 @@ class _AlbumScreenState extends ConsumerState<AlbumScreen> {
       final trackList = metadata['track_list'] as List<dynamic>;
       final tracks = trackList.map((t) => _parseTrack(t as Map<String, dynamic>)).toList();
       
-      // Store in cache
       _AlbumCache.set(widget.albumId, tracks);
       
       if (mounted) {
@@ -133,6 +178,7 @@ class _AlbumScreenState extends ConsumerState<AlbumScreen> {
 
     return Scaffold(
       body: CustomScrollView(
+        controller: _scrollController,
         slivers: [
           _buildAppBar(context, colorScheme),
           _buildInfoCard(context, colorScheme),
@@ -157,74 +203,106 @@ class _AlbumScreenState extends ConsumerState<AlbumScreen> {
   }
 
   Widget _buildAppBar(BuildContext context, ColorScheme colorScheme) {
+    final screenWidth = MediaQuery.of(context).size.width;
+    final coverSize = screenWidth * 0.5; // 50% of screen width
+    final bgColor = _dominantColor ?? colorScheme.surface;
+    
     return SliverAppBar(
-      expandedHeight: 280,
+      expandedHeight: 320,
       pinned: true,
       stretch: true,
       backgroundColor: colorScheme.surface,
       surfaceTintColor: Colors.transparent,
-      flexibleSpace: FlexibleSpaceBar(
-        background: Stack(
-          fit: StackFit.expand,
-          children: [
-            if (widget.coverUrl != null)
-              CachedNetworkImage(
-                imageUrl: widget.coverUrl!,
-                fit: BoxFit.cover,
-                color: Colors.black.withValues(alpha: 0.5),
-                colorBlendMode: BlendMode.darken,
-                memCacheWidth: 600,
-              ),
-            Container(
-              decoration: BoxDecoration(
-                gradient: LinearGradient(
-                  begin: Alignment.topCenter,
-                  end: Alignment.bottomCenter,
-                  colors: [
-                    Colors.transparent,
-                    colorScheme.surface.withValues(alpha: 0.8),
-                    colorScheme.surface,
-                  ],
-                  stops: const [0.0, 0.7, 1.0],
-                ),
-              ),
-            ),
-            Center(
-              child: Padding(
-                padding: const EdgeInsets.only(top: 60),
-                child: Container(
-                  width: 140,
-                  height: 140,
-                  decoration: BoxDecoration(
-                    borderRadius: BorderRadius.circular(16),
-                    boxShadow: [
-                      BoxShadow(
-                        color: Colors.black.withValues(alpha: 0.3),
-                        blurRadius: 20,
-                        offset: const Offset(0, 10),
-                      ),
-                    ],
-                  ),
-                  child: ClipRRect(
-                    borderRadius: BorderRadius.circular(16),
-                    child: widget.coverUrl != null
-                        ? CachedNetworkImage(imageUrl: widget.coverUrl!, fit: BoxFit.cover, memCacheWidth: 280)
-                        : Container(
-                            color: colorScheme.surfaceContainerHighest,
-                            child: Icon(Icons.album, size: 48, color: colorScheme.onSurfaceVariant),
-                          ),
-                  ),
-                ),
-              ),
-            ),
-          ],
+      title: AnimatedOpacity(
+        duration: const Duration(milliseconds: 200),
+        opacity: _showTitleInAppBar ? 1.0 : 0.0,
+        child: Text(
+          widget.albumName,
+          style: TextStyle(
+            color: colorScheme.onSurface,
+            fontWeight: FontWeight.w600,
+            fontSize: 16,
+          ),
+          maxLines: 1,
+          overflow: TextOverflow.ellipsis,
         ),
-        stretchModes: const [StretchMode.zoomBackground, StretchMode.blurBackground],
+      ),
+      flexibleSpace: LayoutBuilder(
+        builder: (context, constraints) {
+          final collapseRatio = (constraints.maxHeight - kToolbarHeight) / (320 - kToolbarHeight);
+          final showContent = collapseRatio > 0.3;
+          
+          return FlexibleSpaceBar(
+            collapseMode: CollapseMode.none,
+            background: Stack(
+              fit: StackFit.expand,
+              children: [
+                // Background with dominant color
+                AnimatedContainer(
+                  duration: const Duration(milliseconds: 500),
+                  decoration: BoxDecoration(
+                    gradient: LinearGradient(
+                      begin: Alignment.topCenter,
+                      end: Alignment.bottomCenter,
+                      colors: [
+                        bgColor,
+                        bgColor.withValues(alpha: 0.8),
+                        colorScheme.surface,
+                      ],
+                      stops: const [0.0, 0.6, 1.0],
+                    ),
+                  ),
+                ),
+                AnimatedOpacity(
+                  duration: const Duration(milliseconds: 150),
+                  opacity: showContent ? 1.0 : 0.0,
+                  child: Center(
+                    child: Padding(
+                      padding: const EdgeInsets.only(top: 60),
+                      child: Container(
+                        width: coverSize,
+                        height: coverSize,
+                        decoration: BoxDecoration(
+                          borderRadius: BorderRadius.circular(20),
+                          boxShadow: [
+                            BoxShadow(
+                              color: Colors.black.withValues(alpha: 0.4),
+                              blurRadius: 30,
+                              offset: const Offset(0, 15),
+                            ),
+                          ],
+                        ),
+                        child: ClipRRect(
+                          borderRadius: BorderRadius.circular(20),
+                          child: widget.coverUrl != null
+? CachedNetworkImage(
+                                  imageUrl: widget.coverUrl!, 
+                                  fit: BoxFit.cover, 
+                                  memCacheWidth: (coverSize * 2).toInt(),
+                                  cacheManager: CoverCacheManager.instance,
+                                )
+                              : Container(
+                                  color: colorScheme.surfaceContainerHighest,
+                                  child: Icon(Icons.album, size: 64, color: colorScheme.onSurfaceVariant),
+                                ),
+                        ),
+                      ),
+                    ),
+                  ),
+                ),
+              ],
+            ),
+            stretchModes: const [StretchMode.zoomBackground, StretchMode.blurBackground],
+          );
+        },
       ),
       leading: IconButton(
         icon: Container(
           padding: const EdgeInsets.all(8),
-          decoration: BoxDecoration(color: colorScheme.surface.withValues(alpha: 0.8), shape: BoxShape.circle),
+          decoration: BoxDecoration(
+            color: colorScheme.surface.withValues(alpha: 0.8), 
+            shape: BoxShape.circle,
+          ),
           child: Icon(Icons.arrow_back, color: colorScheme.onSurface),
         ),
         onPressed: () => Navigator.pop(context),
@@ -234,6 +312,8 @@ class _AlbumScreenState extends ConsumerState<AlbumScreen> {
 
   Widget _buildInfoCard(BuildContext context, ColorScheme colorScheme) {
     final tracks = _tracks ?? [];
+    final artistName = tracks.isNotEmpty ? tracks.first.artistName : null;
+    
     return SliverToBoxAdapter(
       child: Padding(
         padding: const EdgeInsets.all(16),
@@ -250,7 +330,14 @@ class _AlbumScreenState extends ConsumerState<AlbumScreen> {
                   widget.albumName,
                   style: Theme.of(context).textTheme.headlineSmall?.copyWith(fontWeight: FontWeight.bold, color: colorScheme.onSurface),
                 ),
-                const SizedBox(height: 8),
+                if (artistName != null && artistName.isNotEmpty) ...[
+                  const SizedBox(height: 4),
+                  Text(
+                    artistName,
+                    style: Theme.of(context).textTheme.titleMedium?.copyWith(color: colorScheme.onSurfaceVariant),
+                  ),
+                ],
+                const SizedBox(height: 12),
                 if (tracks.isNotEmpty)
                   Container(
                     padding: const EdgeInsets.symmetric(horizontal: 12, vertical: 6),
@@ -260,7 +347,7 @@ class _AlbumScreenState extends ConsumerState<AlbumScreen> {
                       children: [
                         Icon(Icons.music_note, size: 14, color: colorScheme.onSecondaryContainer),
                         const SizedBox(width: 4),
-                        Text('${tracks.length} tracks', style: TextStyle(color: colorScheme.onSecondaryContainer, fontWeight: FontWeight.w600, fontSize: 12)),
+                        Text(context.l10n.tracksCount(tracks.length), style: TextStyle(color: colorScheme.onSecondaryContainer, fontWeight: FontWeight.w600, fontSize: 12)),
                       ],
                     ),
                   ),
@@ -269,7 +356,7 @@ class _AlbumScreenState extends ConsumerState<AlbumScreen> {
                   FilledButton.icon(
                     onPressed: () => _downloadAll(context),
                     icon: const Icon(Icons.download),
-                    label: Text('Download All (${tracks.length})'),
+                    label: Text(context.l10n.downloadAllCount(tracks.length)),
                     style: FilledButton.styleFrom(minimumSize: const Size.fromHeight(52), shape: RoundedRectangleBorder(borderRadius: BorderRadius.circular(16))),
                   ),
                 ],
@@ -289,7 +376,7 @@ class _AlbumScreenState extends ConsumerState<AlbumScreen> {
           children: [
             Icon(Icons.queue_music, size: 20, color: colorScheme.primary),
             const SizedBox(width: 8),
-            Text('Tracks', style: Theme.of(context).textTheme.titleMedium?.copyWith(fontWeight: FontWeight.w600, color: colorScheme.onSurface)),
+            Text(context.l10n.tracksHeader, style: Theme.of(context).textTheme.titleMedium?.copyWith(fontWeight: FontWeight.w600, color: colorScheme.onSurface)),
           ],
         ),
       ),
@@ -324,12 +411,12 @@ class _AlbumScreenState extends ConsumerState<AlbumScreen> {
         coverUrl: track.coverUrl,
         onSelect: (quality, service) {
           ref.read(downloadQueueProvider.notifier).addToQueue(track, service, qualityOverride: quality);
-          ScaffoldMessenger.of(context).showSnackBar(SnackBar(content: Text('Added "${track.name}" to queue')));
+          ScaffoldMessenger.of(context).showSnackBar(SnackBar(content: Text(context.l10n.snackbarAddedToQueue(track.name))));
         },
       );
     } else {
       ref.read(downloadQueueProvider.notifier).addToQueue(track, settings.defaultService);
-      ScaffoldMessenger.of(context).showSnackBar(SnackBar(content: Text('Added "${track.name}" to queue')));
+      ScaffoldMessenger.of(context).showSnackBar(SnackBar(content: Text(context.l10n.snackbarAddedToQueue(track.name))));
     }
   }
 
@@ -344,16 +431,15 @@ class _AlbumScreenState extends ConsumerState<AlbumScreen> {
         artistName: widget.albumName,
         onSelect: (quality, service) {
           ref.read(downloadQueueProvider.notifier).addMultipleToQueue(tracks, service, qualityOverride: quality);
-          ScaffoldMessenger.of(context).showSnackBar(SnackBar(content: Text('Added ${tracks.length} tracks to queue')));
+          ScaffoldMessenger.of(context).showSnackBar(SnackBar(content: Text(context.l10n.snackbarAddedTracksToQueue(tracks.length))));
         },
       );
     } else {
       ref.read(downloadQueueProvider.notifier).addMultipleToQueue(tracks, settings.defaultService);
-      ScaffoldMessenger.of(context).showSnackBar(SnackBar(content: Text('Added ${tracks.length} tracks to queue')));
+      ScaffoldMessenger.of(context).showSnackBar(SnackBar(content: Text(context.l10n.snackbarAddedTracksToQueue(tracks.length))));
     }
   }
 
-  /// Build error widget with special handling for rate limit (429)
   Widget _buildErrorWidget(String error, ColorScheme colorScheme) {
     final isRateLimit = error.contains('429') || 
                         error.toLowerCase().contains('rate limit') ||
@@ -375,7 +461,7 @@ class _AlbumScreenState extends ConsumerState<AlbumScreen> {
                   crossAxisAlignment: CrossAxisAlignment.start,
                   children: [
                     Text(
-                      'Rate Limited',
+                      context.l10n.errorRateLimited,
                       style: TextStyle(
                         color: colorScheme.onErrorContainer,
                         fontWeight: FontWeight.bold,
@@ -383,7 +469,7 @@ class _AlbumScreenState extends ConsumerState<AlbumScreen> {
                     ),
                     const SizedBox(height: 4),
                     Text(
-                      'Too many requests. Please wait a moment and try again.',
+                      context.l10n.errorRateLimitedMessage,
                       style: TextStyle(
                         color: colorScheme.onErrorContainer,
                         fontSize: 12,
@@ -398,7 +484,6 @@ class _AlbumScreenState extends ConsumerState<AlbumScreen> {
       );
     }
     
-    // Default error display
     return Card(
       elevation: 0,
       color: colorScheme.errorContainer.withValues(alpha: 0.5),
@@ -417,7 +502,6 @@ class _AlbumScreenState extends ConsumerState<AlbumScreen> {
   }
 }
 
-/// Separate Consumer widget for each track - only rebuilds when this specific track's status changes
 class _AlbumTrackItem extends ConsumerWidget {
   final Track track;
   final VoidCallback onDownload;
@@ -428,12 +512,10 @@ class _AlbumTrackItem extends ConsumerWidget {
   Widget build(BuildContext context, WidgetRef ref) {
     final colorScheme = Theme.of(context).colorScheme;
     
-    // Only watch the specific item for this track
-    final queueItem = ref.watch(downloadQueueProvider.select((state) {
-      return state.items.where((item) => item.track.id == track.id).firstOrNull;
-    }));
+    final queueItem = ref.watch(
+      downloadQueueLookupProvider.select((lookup) => lookup.byTrackId[track.id]),
+    );
     
-    // Check if track is in history (already downloaded before)
     final isInHistory = ref.watch(downloadHistoryProvider.select((state) {
       return state.isDownloaded(track.id);
     }));
@@ -444,7 +526,6 @@ class _AlbumTrackItem extends ConsumerWidget {
     final isCompleted = queueItem?.status == DownloadStatus.completed;
     final progress = queueItem?.progress ?? 0.0;
     
-    // Show as downloaded if in queue completed OR in history
     final showAsDownloaded = isCompleted || (!isQueued && isInHistory);
 
     return Padding(
@@ -455,8 +536,8 @@ class _AlbumTrackItem extends ConsumerWidget {
         margin: const EdgeInsets.symmetric(vertical: 2),
         child: ListTile(
           shape: RoundedRectangleBorder(borderRadius: BorderRadius.circular(12)),
-          leading: track.coverUrl != null
-              ? ClipRRect(borderRadius: BorderRadius.circular(8), child: CachedNetworkImage(imageUrl: track.coverUrl!, width: 48, height: 48, fit: BoxFit.cover, memCacheWidth: 96))
+leading: track.coverUrl != null
+              ? ClipRRect(borderRadius: BorderRadius.circular(8), child: CachedNetworkImage(imageUrl: track.coverUrl!, width: 48, height: 48, fit: BoxFit.cover, memCacheWidth: 96, cacheManager: CoverCacheManager.instance))
               : Container(width: 48, height: 48, decoration: BoxDecoration(color: colorScheme.surfaceContainerHighest, borderRadius: BorderRadius.circular(8)), child: Icon(Icons.music_note, color: colorScheme.onSurfaceVariant)),
           title: Text(track.name, maxLines: 1, overflow: TextOverflow.ellipsis, style: Theme.of(context).textTheme.bodyLarge?.copyWith(fontWeight: FontWeight.w500)),
           subtitle: Text(track.artistName, maxLines: 1, overflow: TextOverflow.ellipsis, style: TextStyle(color: colorScheme.onSurfaceVariant)),
@@ -476,7 +557,7 @@ class _AlbumTrackItem extends ConsumerWidget {
         final fileExists = await File(historyItem.filePath).exists();
         if (fileExists) {
           if (context.mounted) {
-            ScaffoldMessenger.of(context).showSnackBar(SnackBar(content: Text('"${track.name}" already downloaded')));
+            ScaffoldMessenger.of(context).showSnackBar(SnackBar(content: Text(context.l10n.snackbarAlreadyDownloaded(track.name))));
           }
           return;
         } else {

lib/screens/downloaded_album_screen.dart

@@ -3,7 +3,11 @@ import 'package:flutter/material.dart';
 import 'package:flutter/services.dart';
 import 'package:flutter_riverpod/flutter_riverpod.dart';
 import 'package:cached_network_image/cached_network_image.dart';
+import 'package:palette_generator/palette_generator.dart';
 import 'package:open_filex/open_filex.dart';
+import 'package:spotiflac_android/services/cover_cache_manager.dart';
+import 'package:spotiflac_android/l10n/l10n.dart';
+import 'package:spotiflac_android/utils/mime_utils.dart';
 import 'package:spotiflac_android/providers/download_queue_provider.dart';
 import 'package:spotiflac_android/screens/track_metadata_screen.dart';
 
@@ -25,18 +29,73 @@ class DownloadedAlbumScreen extends ConsumerStatefulWidget {
 }
 
 class _DownloadedAlbumScreenState extends ConsumerState<DownloadedAlbumScreen> {
-  // Multi-select state
   bool _isSelectionMode = false;
   final Set<String> _selectedIds = {};
+  Color? _dominantColor;
+  bool _showTitleInAppBar = false;
+  final ScrollController _scrollController = ScrollController();
+
+  @override
+  void initState() {
+    super.initState();
+    _scrollController.addListener(_onScroll);
+    _extractDominantColor();
+  }
+
+  @override
+  void dispose() {
+    _scrollController.removeListener(_onScroll);
+    _scrollController.dispose();
+    super.dispose();
+  }
+
+  void _onScroll() {
+    final shouldShow = _scrollController.offset > 280;
+    if (shouldShow != _showTitleInAppBar) {
+      setState(() => _showTitleInAppBar = shouldShow);
+    }
+  }
+
+  Future<void> _extractDominantColor() async {
+    if (widget.coverUrl == null || widget.coverUrl!.isEmpty) return;
+    
+    // Only use network images for palette extraction
+    final isNetworkUrl = widget.coverUrl!.startsWith('http://') || 
+                         widget.coverUrl!.startsWith('https://');
+    if (!isNetworkUrl) return;
+    
+    try {
+      final paletteGenerator = await PaletteGenerator.fromImageProvider(
+        CachedNetworkImageProvider(widget.coverUrl!),
+        maximumColorCount: 16,
+      );
+      if (mounted) {
+        setState(() {
+          _dominantColor = paletteGenerator.dominantColor?.color ??
+              paletteGenerator.vibrantColor?.color ??
+              paletteGenerator.mutedColor?.color;
+        });
+      }
+    } catch (_) {
+    }
+  }
 
   /// Get tracks for this album from history provider (reactive)
   List<DownloadHistoryItem> _getAlbumTracks(List<DownloadHistoryItem> allItems) {
     return allItems.where((item) {
-      final itemKey = '${item.albumName}|${item.albumArtist ?? item.artistName}';
+      // Use albumArtist if available and not empty, otherwise artistName
+      final itemArtist = (item.albumArtist != null && item.albumArtist!.isNotEmpty) 
+          ? item.albumArtist! 
+          : item.artistName;
+      final itemKey = '${item.albumName}|$itemArtist';
       final albumKey = '${widget.albumName}|${widget.artistName}';
       return itemKey == albumKey;
     }).toList()
       ..sort((a, b) {
+        // Sort by disc number first, then by track number
+        final aDisc = a.discNumber ?? 1;
+        final bDisc = b.discNumber ?? 1;
+        if (aDisc != bDisc) return aDisc.compareTo(bDisc);
         final aNum = a.trackNumber ?? 999;
         final bNum = b.trackNumber ?? 999;
         if (aNum != bNum) return aNum.compareTo(bNum);
@@ -44,6 +103,17 @@ class _DownloadedAlbumScreenState extends ConsumerState<DownloadedAlbumScreen> {
       });
   }
 
+  Map<int, List<DownloadHistoryItem>> _groupTracksByDisc(
+    List<DownloadHistoryItem> tracks,
+  ) {
+    final discMap = <int, List<DownloadHistoryItem>>{};
+    for (final track in tracks) {
+      final discNumber = track.discNumber ?? 1;
+      discMap.putIfAbsent(discNumber, () => []).add(track);
+    }
+    return discMap;
+  }
+
   void _enterSelectionMode(String itemId) {
     HapticFeedback.mediumImpact();
     setState(() {
@@ -83,19 +153,19 @@ class _DownloadedAlbumScreenState extends ConsumerState<DownloadedAlbumScreen> {
     final confirmed = await showDialog<bool>(
       context: context,
       builder: (ctx) => AlertDialog(
-        title: const Text('Delete Selected'),
-        content: Text('Delete $count ${count == 1 ? 'track' : 'tracks'} from this album?\n\nThis will also delete the files from storage.'),
+        title: Text(context.l10n.downloadedAlbumDeleteSelected),
+        content: Text(context.l10n.downloadedAlbumDeleteMessage(count)),
         actions: [
           TextButton(
             onPressed: () => Navigator.pop(ctx, false),
-            child: const Text('Cancel'),
+            child: Text(context.l10n.dialogCancel),
           ),
           FilledButton(
             onPressed: () => Navigator.pop(ctx, true),
             style: FilledButton.styleFrom(
               backgroundColor: Theme.of(context).colorScheme.error,
             ),
-            child: const Text('Delete'),
+            child: Text(context.l10n.dialogDelete),
           ),
         ],
       ),
@@ -124,7 +194,7 @@ class _DownloadedAlbumScreenState extends ConsumerState<DownloadedAlbumScreen> {
       
       if (mounted) {
         ScaffoldMessenger.of(context).showSnackBar(
-          SnackBar(content: Text('Deleted $deletedCount ${deletedCount == 1 ? 'track' : 'tracks'}')),
+          SnackBar(content: Text(context.l10n.snackbarDeletedTracks(deletedCount))),
         );
       }
     }
@@ -132,17 +202,19 @@ class _DownloadedAlbumScreenState extends ConsumerState<DownloadedAlbumScreen> {
 
   Future<void> _openFile(String filePath) async {
     try {
-      await OpenFilex.open(filePath);
+      final mimeType = audioMimeTypeForPath(filePath);
+      await OpenFilex.open(filePath, type: mimeType);
     } catch (e) {
       if (mounted) {
         ScaffoldMessenger.of(context).showSnackBar(
-          SnackBar(content: Text('Cannot open file: $e')),
+          SnackBar(content: Text(context.l10n.snackbarCannotOpenFile(e.toString()))),
         );
       }
     }
   }
 
   void _navigateToMetadataScreen(DownloadHistoryItem item) {
+    _precacheCover(item.coverUrl);
     Navigator.push(context, PageRouteBuilder(
       transitionDuration: const Duration(milliseconds: 300),
       reverseTransitionDuration: const Duration(milliseconds: 250),
@@ -151,24 +223,37 @@ class _DownloadedAlbumScreenState extends ConsumerState<DownloadedAlbumScreen> {
     ));
   }
 
+  void _precacheCover(String? url) {
+    if (url == null || url.isEmpty) return;
+    if (!url.startsWith('http://') && !url.startsWith('https://')) {
+      return;
+    }
+    precacheImage(
+      CachedNetworkImageProvider(url, cacheManager: CoverCacheManager.instance),
+      context,
+    );
+  }
+
   @override
   Widget build(BuildContext context) {
     final colorScheme = Theme.of(context).colorScheme;
     final bottomPadding = MediaQuery.of(context).padding.bottom;
     
-    // Watch history and get tracks for this album (reactive!)
     final allHistoryItems = ref.watch(downloadHistoryProvider.select((s) => s.items));
     final tracks = _getAlbumTracks(allHistoryItems);
     
-    // Auto-pop if album has less than 2 tracks (no longer an "album")
-    if (tracks.length < 2) {
-      WidgetsBinding.instance.addPostFrameCallback((_) {
-        if (mounted) Navigator.pop(context);
-      });
-      return const SizedBox.shrink();
+    // Show empty state if no tracks found
+    if (tracks.isEmpty) {
+      return Scaffold(
+        appBar: AppBar(
+          title: Text(widget.albumName),
+        ),
+        body: Center(
+          child: Text('No tracks found for this album'),
+        ),
+      );
     }
     
-    // Clean up selected IDs that no longer exist
     final validIds = tracks.map((t) => t.id).toSet();
     _selectedIds.removeWhere((id) => !validIds.contains(id));
     if (_selectedIds.isEmpty && _isSelectionMode) {
@@ -188,6 +273,7 @@ class _DownloadedAlbumScreenState extends ConsumerState<DownloadedAlbumScreen> {
         body: Stack(
           children: [
             CustomScrollView(
+              controller: _scrollController,
               slivers: [
                 _buildAppBar(context, colorScheme),
                 _buildInfoCard(context, colorScheme, tracks),
@@ -197,7 +283,6 @@ class _DownloadedAlbumScreenState extends ConsumerState<DownloadedAlbumScreen> {
               ],
             ),
             
-            // Bottom Selection Action Bar
             AnimatedPositioned(
               duration: const Duration(milliseconds: 250),
               curve: Curves.easeOutCubic,
@@ -213,69 +298,99 @@ class _DownloadedAlbumScreenState extends ConsumerState<DownloadedAlbumScreen> {
   }
 
   Widget _buildAppBar(BuildContext context, ColorScheme colorScheme) {
+    final screenWidth = MediaQuery.of(context).size.width;
+    final coverSize = screenWidth * 0.5; // 50% of screen width
+    final bgColor = _dominantColor ?? colorScheme.surface;
+    
     return SliverAppBar(
-      expandedHeight: 280,
+      expandedHeight: 320,
       pinned: true,
       stretch: true,
-      backgroundColor: colorScheme.surface,
+      backgroundColor: colorScheme.surface, // Use theme color for collapsed state
       surfaceTintColor: Colors.transparent,
-      flexibleSpace: FlexibleSpaceBar(
-        background: Stack(
-          fit: StackFit.expand,
-          children: [
-            if (widget.coverUrl != null)
-              CachedNetworkImage(
-                imageUrl: widget.coverUrl!,
-                fit: BoxFit.cover,
-                color: Colors.black.withValues(alpha: 0.5),
-                colorBlendMode: BlendMode.darken,
-                memCacheWidth: 600,
-              ),
-            Container(
-              decoration: BoxDecoration(
-                gradient: LinearGradient(
-                  begin: Alignment.topCenter,
-                  end: Alignment.bottomCenter,
-                  colors: [
-                    Colors.transparent,
-                    colorScheme.surface.withValues(alpha: 0.8),
-                    colorScheme.surface,
-                  ],
-                  stops: const [0.0, 0.7, 1.0],
-                ),
-              ),
-            ),
-            Center(
-              child: Padding(
-                padding: const EdgeInsets.only(top: 60),
-                child: Container(
-                  width: 140,
-                  height: 140,
-                  decoration: BoxDecoration(
-                    borderRadius: BorderRadius.circular(16),
-                    boxShadow: [
-                      BoxShadow(
-                        color: Colors.black.withValues(alpha: 0.3),
-                        blurRadius: 20,
-                        offset: const Offset(0, 10),
-                      ),
-                    ],
-                  ),
-                  child: ClipRRect(
-                    borderRadius: BorderRadius.circular(16),
-                    child: widget.coverUrl != null
-                        ? CachedNetworkImage(imageUrl: widget.coverUrl!, fit: BoxFit.cover, memCacheWidth: 280)
-                        : Container(
-                            color: colorScheme.surfaceContainerHighest,
-                            child: Icon(Icons.album, size: 48, color: colorScheme.onSurfaceVariant),
-                          ),
-                  ),
-                ),
-              ),
-            ),
-          ],
+      title: AnimatedOpacity(
+        duration: const Duration(milliseconds: 200),
+        opacity: _showTitleInAppBar ? 1.0 : 0.0,
+        child: Text(
+          widget.albumName,
+          style: TextStyle(
+            color: colorScheme.onSurface,
+            fontWeight: FontWeight.w600,
+            fontSize: 16,
+          ),
+          maxLines: 1,
+          overflow: TextOverflow.ellipsis,
         ),
-        stretchModes: const [StretchMode.zoomBackground, StretchMode.blurBackground],
+      ),
+      flexibleSpace: LayoutBuilder(
+        builder: (context, constraints) {
+          final collapseRatio = (constraints.maxHeight - kToolbarHeight) / (320 - kToolbarHeight);
+          final showContent = collapseRatio > 0.3;
+          
+          return FlexibleSpaceBar(
+            collapseMode: CollapseMode.none,
+            background: Stack(
+              fit: StackFit.expand,
+              children: [
+                // Background with dominant color
+                AnimatedContainer(
+                  duration: const Duration(milliseconds: 500),
+                  decoration: BoxDecoration(
+                    gradient: LinearGradient(
+                      begin: Alignment.topCenter,
+                      end: Alignment.bottomCenter,
+                      colors: [
+                        bgColor,
+                        bgColor.withValues(alpha: 0.8),
+                        colorScheme.surface,
+                      ],
+                      stops: const [0.0, 0.6, 1.0],
+                    ),
+                  ),
+                ),
+                // Cover image centered - fade out when collapsing
+                AnimatedOpacity(
+                  duration: const Duration(milliseconds: 150),
+                  opacity: showContent ? 1.0 : 0.0,
+                  child: Center(
+                    child: Padding(
+                      padding: const EdgeInsets.only(top: 60),
+                      child: Container(
+                        width: coverSize,
+                        height: coverSize,
+                        decoration: BoxDecoration(
+                          borderRadius: BorderRadius.circular(20),
+                          boxShadow: [
+                            BoxShadow(
+                              color: Colors.black.withValues(alpha: 0.4),
+                              blurRadius: 30,
+                              offset: const Offset(0, 15),
+                            ),
+                          ],
+                        ),
+                        child: ClipRRect(
+                          borderRadius: BorderRadius.circular(20),
+                          child: widget.coverUrl != null
+? CachedNetworkImage(
+                                  imageUrl: widget.coverUrl!, 
+                                  fit: BoxFit.cover, 
+                                  memCacheWidth: (coverSize * 2).toInt(),
+                                  cacheManager: CoverCacheManager.instance,
+                                )
+                              : Container(
+                                  color: colorScheme.surfaceContainerHighest,
+                                  child: Icon(Icons.album, size: 64, color: colorScheme.onSurfaceVariant),
+                                ),
+                        ),
+                      ),
+                    ),
+                  ),
+                ),
+              ],
+            ),
+            stretchModes: const [StretchMode.zoomBackground, StretchMode.blurBackground],
+          );
+        },
       ),
       leading: IconButton(
         icon: Container(
@@ -321,7 +436,7 @@ class _DownloadedAlbumScreenState extends ConsumerState<DownloadedAlbumScreen> {
                         children: [
                           Icon(Icons.download_done, size: 14, color: colorScheme.onPrimaryContainer),
                           const SizedBox(width: 4),
-                          Text('${tracks.length} downloaded', style: TextStyle(color: colorScheme.onPrimaryContainer, fontWeight: FontWeight.w600, fontSize: 12)),
+                          Text(context.l10n.downloadedAlbumDownloadedCount(tracks.length), style: TextStyle(color: colorScheme.onPrimaryContainer, fontWeight: FontWeight.w600, fontSize: 12)),
                         ],
                       ),
                     ),
@@ -374,13 +489,13 @@ class _DownloadedAlbumScreenState extends ConsumerState<DownloadedAlbumScreen> {
           children: [
             Icon(Icons.queue_music, size: 20, color: colorScheme.primary),
             const SizedBox(width: 8),
-            Text('Tracks', style: Theme.of(context).textTheme.titleMedium?.copyWith(fontWeight: FontWeight.w600, color: colorScheme.onSurface)),
+            Text(context.l10n.downloadedAlbumTracksHeader, style: Theme.of(context).textTheme.titleMedium?.copyWith(fontWeight: FontWeight.w600, color: colorScheme.onSurface)),
             const Spacer(),
             if (!_isSelectionMode)
               TextButton.icon(
                 onPressed: tracks.isNotEmpty ? () => _enterSelectionMode(tracks.first.id) : null,
                 icon: const Icon(Icons.checklist, size: 18),
-                label: const Text('Select'),
+                label: Text(context.l10n.actionSelect),
                 style: TextButton.styleFrom(visualDensity: VisualDensity.compact),
               ),
           ],
@@ -390,16 +505,83 @@ class _DownloadedAlbumScreenState extends ConsumerState<DownloadedAlbumScreen> {
   }
 
   Widget _buildTrackList(BuildContext context, ColorScheme colorScheme, List<DownloadHistoryItem> tracks) {
-    return SliverList(
-      delegate: SliverChildBuilderDelegate(
-        (context, index) {
-          final track = tracks[index];
-          return KeyedSubtree(
+    final discMap = _groupTracksByDisc(tracks);
+
+    if (discMap.length <= 1) {
+      return SliverList(
+        delegate: SliverChildBuilderDelegate(
+          (context, index) {
+            final track = tracks[index];
+            return KeyedSubtree(
+              key: ValueKey(track.id),
+              child: _buildTrackItem(context, colorScheme, track),
+            );
+          },
+          childCount: tracks.length,
+        ),
+      );
+    }
+
+    final discNumbers = discMap.keys.toList()..sort();
+    final List<Widget> children = [];
+
+    for (final discNumber in discNumbers) {
+      final discTracks = discMap[discNumber];
+      if (discTracks == null || discTracks.isEmpty) continue;
+
+      // Add disc separator
+      children.add(_buildDiscSeparator(context, colorScheme, discNumber));
+
+      // Add tracks for this disc
+      for (final track in discTracks) {
+        children.add(
+          KeyedSubtree(
             key: ValueKey(track.id),
             child: _buildTrackItem(context, colorScheme, track),
-          );
-        },
-        childCount: tracks.length,
+          ),
+        );
+      }
+    }
+
+    return SliverList(
+      delegate: SliverChildListDelegate(children),
+    );
+  }
+
+  Widget _buildDiscSeparator(BuildContext context, ColorScheme colorScheme, int discNumber) {
+    return Padding(
+      padding: const EdgeInsets.fromLTRB(20, 16, 20, 8),
+      child: Row(
+        children: [
+          Container(
+            padding: const EdgeInsets.symmetric(horizontal: 12, vertical: 6),
+            decoration: BoxDecoration(
+              color: colorScheme.secondaryContainer,
+              borderRadius: BorderRadius.circular(16),
+            ),
+            child: Row(
+              mainAxisSize: MainAxisSize.min,
+              children: [
+                Icon(Icons.album, size: 16, color: colorScheme.onSecondaryContainer),
+                const SizedBox(width: 6),
+                Text(
+                  context.l10n.downloadedAlbumDiscHeader(discNumber),
+                  style: Theme.of(context).textTheme.labelLarge?.copyWith(
+                    color: colorScheme.onSecondaryContainer,
+                    fontWeight: FontWeight.w600,
+                  ),
+                ),
+              ],
+            ),
+          ),
+          const SizedBox(width: 12),
+          Expanded(
+            child: Container(
+              height: 1,
+              color: colorScheme.outlineVariant.withValues(alpha: 0.5),
+            ),
+          ),
+        ],
       ),
     );
   }
@@ -521,11 +703,11 @@ class _DownloadedAlbumScreenState extends ConsumerState<DownloadedAlbumScreen> {
                       crossAxisAlignment: CrossAxisAlignment.start,
                       children: [
                         Text(
-                          '$selectedCount selected',
+                          context.l10n.downloadedAlbumSelectedCount(selectedCount),
                           style: Theme.of(context).textTheme.titleMedium?.copyWith(fontWeight: FontWeight.bold),
                         ),
                         Text(
-                          allSelected ? 'All tracks selected' : 'Tap tracks to select',
+                          allSelected ? context.l10n.downloadedAlbumAllSelected : context.l10n.downloadedAlbumTapToSelect,
                           style: Theme.of(context).textTheme.bodySmall?.copyWith(color: colorScheme.onSurfaceVariant),
                         ),
                       ],
@@ -540,7 +722,7 @@ class _DownloadedAlbumScreenState extends ConsumerState<DownloadedAlbumScreen> {
                       }
                     },
                     icon: Icon(allSelected ? Icons.deselect : Icons.select_all, size: 20),
-                    label: Text(allSelected ? 'Deselect' : 'Select All'),
+                    label: Text(allSelected ? context.l10n.actionDeselect : context.l10n.actionSelectAll),
                     style: TextButton.styleFrom(foregroundColor: colorScheme.primary),
                   ),
                 ],
@@ -553,8 +735,8 @@ class _DownloadedAlbumScreenState extends ConsumerState<DownloadedAlbumScreen> {
                   icon: const Icon(Icons.delete_outline),
                   label: Text(
                     selectedCount > 0 
-                        ? 'Delete $selectedCount ${selectedCount == 1 ? 'track' : 'tracks'}'
-                        : 'Select tracks to delete',
+                        ? context.l10n.downloadedAlbumDeleteCount(selectedCount)
+                        : context.l10n.downloadedAlbumSelectToDelete,
                   ),
                   style: FilledButton.styleFrom(
                     backgroundColor: selectedCount > 0 ? colorScheme.error : colorScheme.surfaceContainerHighest,