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

CHANGELOG.md

@@ -1,5 +1,147 @@
 # Changelog
 
+## [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

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

go_backend/amazon.go

@@ -17,13 +17,12 @@ 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 (
@@ -38,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"`
@@ -49,7 +47,6 @@ 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))
@@ -90,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 {
@@ -100,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{
@@ -113,7 +108,6 @@ 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()
@@ -125,7 +119,6 @@ func (a *AmazonDownloader) waitForRateLimit() {
 		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 {
@@ -136,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
@@ -151,7 +143,6 @@ func (a *AmazonDownloader) waitForRateLimit() {
 	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)
@@ -176,11 +167,9 @@ func (a *AmazonDownloader) downloadFromDoubleDoubleService(amazonURL, _ string)
 		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)
@@ -334,7 +323,6 @@ 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()
 
@@ -434,7 +422,6 @@ 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()
@@ -580,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")

go_backend/cover.go

@@ -8,18 +8,15 @@ import (
 	"strings"
 )
 
-// Spotify image size codes (same as PC version)
 const (
-	spotifySize300 = "ab67616d00001e02" // 300x300 (small)
-	spotifySize640 = "ab67616d0000b273" // 640x640 (medium)
-	spotifySizeMax = "ab67616d000082c1" // Max resolution (~2000x2000)
+	spotifySize300 = "ab67616d00001e02"
+	spotifySize640 = "ab67616d0000b273"
+	spotifySizeMax = "ab67616d000082c1"
 )
 
 // Deezer CDN supports these sizes: 56, 250, 500, 1000, 1400, 1800
 var deezerSizeRegex = regexp.MustCompile(`/(\d+)x(\d+)-\d+-\d+-\d+-\d+\.jpg$`)
 
-// convertSmallToMedium upgrades 300x300 cover URL to 640x640
-// Same logic as PC version for consistency
 func convertSmallToMedium(imageURL string) string {
 	if strings.Contains(imageURL, spotifySize300) {
 		return strings.Replace(imageURL, spotifySize300, spotifySize640, 1)
@@ -27,8 +24,6 @@ func convertSmallToMedium(imageURL string) string {
 	return imageURL
 }
 
-// downloadCoverToMemory downloads cover art and returns as bytes (no file creation)
-// This avoids file permission issues on Android
 func downloadCoverToMemory(coverURL string, maxQuality bool) ([]byte, error) {
 	if coverURL == "" {
 		return nil, fmt.Errorf("no cover URL provided")
@@ -90,8 +85,6 @@ func downloadCoverToMemory(coverURL string, maxQuality bool) ([]byte, error) {
 	return data, nil
 }
 
-// upgradeToMaxQuality upgrades cover URL to maximum quality
-// Supports both Spotify and Deezer CDNs
 func upgradeToMaxQuality(coverURL string) string {
 	// Spotify CDN upgrade
 	if strings.Contains(coverURL, spotifySize640) {
@@ -106,9 +99,6 @@ func upgradeToMaxQuality(coverURL string) string {
 	return coverURL
 }
 
-// upgradeDeezerCover upgrades Deezer cover URL to maximum quality (1800x1800)
-// Deezer CDN format: https://cdn-images.dzcdn.net/images/cover/{hash}/{size}x{size}-000000-80-0-0.jpg
-// Available sizes: 56, 250, 500, 1000, 1400, 1800
 func upgradeDeezerCover(coverURL string) string {
 	if !strings.Contains(coverURL, "cdn-images.dzcdn.net") {
 		return coverURL
@@ -122,7 +112,6 @@ func upgradeDeezerCover(coverURL string) string {
 	return upgraded
 }
 
-// GetCoverFromSpotify gets cover URL from Spotify metadata
 func GetCoverFromSpotify(imageURL string, maxQuality bool) string {
 	if imageURL == "" {
 		return ""

go_backend/deezer.go

@@ -25,13 +25,12 @@ const (
 	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
 }
 
@@ -40,7 +39,6 @@ var (
 	deezerClientOnce sync.Once
 )
 
-// GetDeezerClient returns singleton Deezer client
 func GetDeezerClient() *DeezerClient {
 	deezerClientOnce.Do(func() {
 		deezerClient = &DeezerClient{
@@ -54,7 +52,6 @@ func GetDeezerClient() *DeezerClient {
 	return deezerClient
 }
 
-// Deezer API response types
 type deezerTrack struct {
 	ID            int64             `json:"id"`
 	Title         string            `json:"title"`
@@ -63,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"`
@@ -86,8 +83,8 @@ 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
-	RecordType  string `json:"record_type"`  // album, single, ep, compile
+	ReleaseDate string `json:"release_date"`
+	RecordType  string `json:"record_type"`
 }
 
 func (c *DeezerClient) convertTrack(track deezerTrack) TrackMetadata {
@@ -146,8 +143,8 @@ type deezerAlbumFull struct {
 	CoverXL     string `json:"cover_xl"`
 	ReleaseDate string `json:"release_date"`
 	NbTracks    int    `json:"nb_tracks"`
-	RecordType  string `json:"record_type"` // album, single, ep, compile
-	Label       string `json:"label"`       // Record label name
+	RecordType  string `json:"record_type"`
+	Label       string `json:"label"`
 	Genres      struct {
 		Data []deezerGenre `json:"data"`
 	} `json:"genres"`
@@ -185,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)
@@ -201,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
@@ -230,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)
 
@@ -267,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,
@@ -292,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()
@@ -338,7 +330,6 @@ func (c *DeezerClient) GetAlbum(ctx context.Context, albumID string) (*AlbumResp
 		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))
@@ -386,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() {
@@ -472,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)
 
@@ -496,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))
@@ -535,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"`
@@ -577,13 +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
 
 	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 {
@@ -591,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
@@ -605,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 }()
@@ -634,7 +634,6 @@ 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) {
 	c.cacheMu.RLock()
@@ -644,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()
@@ -697,20 +694,17 @@ func (c *DeezerClient) getBestAlbumImage(album deezerAlbumFull) string {
 	return album.Cover
 }
 
-// AlbumExtendedMetadata contains genre and label information from an album
 type AlbumExtendedMetadata struct {
 	Genre string // Comma-separated list of genres
 	Label string // Record label name
 }
 
-// GetAlbumExtendedMetadata fetches genre and label from a Deezer album
 // 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")
 	}
 
-	// Check cache first
 	cacheKey := fmt.Sprintf("album_meta:%s", albumID)
 	c.cacheMu.RLock()
 	if entry, ok := c.searchCache[cacheKey]; ok && !entry.isExpired() {
@@ -726,7 +720,6 @@ func (c *DeezerClient) GetAlbumExtendedMetadata(ctx context.Context, albumID str
 		return nil, fmt.Errorf("failed to fetch album: %w", err)
 	}
 
-	// Extract genres as comma-separated string
 	var genres []string
 	for _, g := range album.Genres.Data {
 		if g.Name != "" {
@@ -739,7 +732,6 @@ func (c *DeezerClient) GetAlbumExtendedMetadata(ctx context.Context, albumID str
 		Label: album.Label,
 	}
 
-	// Cache the result
 	c.cacheMu.Lock()
 	c.searchCache[cacheKey] = &cacheEntry{
 		data:      result,
@@ -764,7 +756,6 @@ func (c *DeezerClient) GetTrackAlbumID(ctx context.Context, trackID string) (str
 	return fmt.Sprintf("%d", track.Album.ID), nil
 }
 
-// GetExtendedMetadataByTrackID fetches genre and label using a Deezer track ID
 // 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)
@@ -775,6 +766,32 @@ func (c *DeezerClient) GetExtendedMetadataByTrackID(ctx context.Context, trackID
 	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 {
@@ -819,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

@@ -158,7 +158,6 @@ func checkISRCExistsInternal(outputDir, isrc string) (string, bool) {
 		return "", false
 	}
 
-	// Use index for fast lookup
 	idx := GetISRCIndex(outputDir)
 	filePath, exists := idx.lookup(isrc)
 	if !exists {
@@ -175,7 +174,6 @@ func checkISRCExistsInternal(outputDir, isrc string) (string, bool) {
 }
 
 // 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
@@ -199,9 +197,6 @@ 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) {
 	var tracks []struct {
 		ISRC       string `json:"isrc"`
@@ -266,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/exports.go

@@ -13,8 +13,6 @@ import (
 	"github.com/dop251/goja"
 )
 
-// ParseSpotifyURL parses and validates a Spotify URL
-// Returns JSON with type (track/album/playlist) and ID
 func ParseSpotifyURL(url string) (string, error) {
 	parsed, err := parseSpotifyURI(url)
 	if err != nil {
@@ -34,19 +32,14 @@ func ParseSpotifyURL(url string) (string, error) {
 	return string(jsonBytes), nil
 }
 
-// SetSpotifyAPICredentials sets custom Spotify API credentials from Flutter
 func SetSpotifyAPICredentials(clientID, clientSecret string) {
 	SetSpotifyCredentials(clientID, clientSecret)
 }
 
-// CheckSpotifyCredentials checks if Spotify credentials are configured
-// Returns true if credentials are available (custom or env vars)
 func CheckSpotifyCredentials() bool {
 	return HasSpotifyCredentials()
 }
 
-// GetSpotifyMetadata fetches metadata from Spotify URL
-// Returns JSON with track/album/playlist data
 func GetSpotifyMetadata(spotifyURL string) (string, error) {
 	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
 	defer cancel()
@@ -68,8 +61,6 @@ func GetSpotifyMetadata(spotifyURL string) (string, error) {
 	return string(jsonBytes), nil
 }
 
-// SearchSpotify searches for tracks on Spotify
-// Returns JSON array of track results
 func SearchSpotify(query string, limit int) (string, error) {
 	ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
 	defer cancel()
@@ -91,8 +82,6 @@ func SearchSpotify(query string, limit int) (string, error) {
 	return string(jsonBytes), nil
 }
 
-// SearchSpotifyAll searches for tracks and artists on Spotify
-// Returns JSON with tracks and artists arrays
 func SearchSpotifyAll(query string, trackLimit, artistLimit int) (string, error) {
 	ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
 	defer cancel()
@@ -114,8 +103,6 @@ func SearchSpotifyAll(query string, trackLimit, artistLimit int) (string, error)
 	return string(jsonBytes), nil
 }
 
-// CheckAvailability checks track availability on streaming services
-// Returns JSON with availability info for Tidal, Qobuz, Amazon
 func CheckAvailability(spotifyID, isrc string) (string, error) {
 	client := NewSongLinkClient()
 	availability, err := client.CheckTrackAvailability(spotifyID, isrc)
@@ -131,7 +118,6 @@ func CheckAvailability(spotifyID, isrc string) (string, error) {
 	return string(jsonBytes), nil
 }
 
-// DownloadRequest represents a download request from Flutter
 type DownloadRequest struct {
 	ISRC                 string `json:"isrc"`
 	Service              string `json:"service"`
@@ -143,52 +129,51 @@ type DownloadRequest struct {
 	CoverURL             string `json:"cover_url"`
 	OutputDir            string `json:"output_dir"`
 	FilenameFormat       string `json:"filename_format"`
-	Quality              string `json:"quality"` // LOSSLESS, HI_RES, HI_RES_LOSSLESS
+	Quality              string `json:"quality"`
 	EmbedLyrics          bool   `json:"embed_lyrics"`
 	EmbedMaxQualityCover bool   `json:"embed_max_quality_cover"`
 	TrackNumber          int    `json:"track_number"`
 	DiscNumber           int    `json:"disc_number"`
 	TotalTracks          int    `json:"total_tracks"`
 	ReleaseDate          string `json:"release_date"`
-	ItemID               string `json:"item_id"`     // Unique ID for progress tracking
-	DurationMS           int    `json:"duration_ms"` // Expected duration in milliseconds (for verification)
-	Source               string `json:"source"`      // Extension ID that provided this track (prioritize this extension)
-	// Extended metadata from Deezer for FLAC tagging
-	Genre     string `json:"genre,omitempty"`     // Music genre(s), comma-separated
-	Label     string `json:"label,omitempty"`     // Record label name
-	Copyright string `json:"copyright,omitempty"` // Copyright information
-	// Enriched IDs from Odesli/song.link - used to skip search and directly fetch
-	TidalID  string `json:"tidal_id,omitempty"`
-	QobuzID  string `json:"qobuz_id,omitempty"`
-	DeezerID string `json:"deezer_id,omitempty"`
+	ItemID               string `json:"item_id"`
+	DurationMS           int    `json:"duration_ms"`
+	Source               string `json:"source"`
+	Genre                string `json:"genre,omitempty"`
+	Label                string `json:"label,omitempty"`
+	Copyright            string `json:"copyright,omitempty"`
+	TidalID              string `json:"tidal_id,omitempty"`
+	QobuzID              string `json:"qobuz_id,omitempty"`
+	DeezerID             string `json:"deezer_id,omitempty"`
+	LyricsMode           string `json:"lyrics_mode,omitempty"`
 }
 
 // DownloadResponse represents the result of a download
 type DownloadResponse struct {
-	Success       bool   `json:"success"`
-	Message       string `json:"message"`
-	FilePath      string `json:"file_path,omitempty"`
-	Error         string `json:"error,omitempty"`
-	ErrorType     string `json:"error_type,omitempty"` // "not_found", "rate_limit", "network", "unknown"
-	AlreadyExists bool   `json:"already_exists,omitempty"`
-	// Actual quality info from the source
-	ActualBitDepth   int    `json:"actual_bit_depth,omitempty"`
-	ActualSampleRate int    `json:"actual_sample_rate,omitempty"`
-	Service          string `json:"service,omitempty"` // Actual service used (for fallback)
-	Title            string `json:"title,omitempty"`
-	Artist           string `json:"artist,omitempty"`
-	Album            string `json:"album,omitempty"`
-	AlbumArtist      string `json:"album_artist,omitempty"`
-	ReleaseDate      string `json:"release_date,omitempty"`
-	TrackNumber      int    `json:"track_number,omitempty"`
-	DiscNumber       int    `json:"disc_number,omitempty"`
-	ISRC             string `json:"isrc,omitempty"`
-	CoverURL         string `json:"cover_url,omitempty"`
-	// If true, skip metadata enrichment from Deezer/Spotify (extension already provides metadata)
-	SkipMetadataEnrichment bool `json:"skip_metadata_enrichment,omitempty"`
+	Success                bool   `json:"success"`
+	Message                string `json:"message"`
+	FilePath               string `json:"file_path,omitempty"`
+	Error                  string `json:"error,omitempty"`
+	ErrorType              string `json:"error_type,omitempty"` // "not_found", "rate_limit", "network", "unknown"
+	AlreadyExists          bool   `json:"already_exists,omitempty"`
+	ActualBitDepth         int    `json:"actual_bit_depth,omitempty"`
+	ActualSampleRate       int    `json:"actual_sample_rate,omitempty"`
+	Service                string `json:"service,omitempty"` // Actual service used (for fallback)
+	Title                  string `json:"title,omitempty"`
+	Artist                 string `json:"artist,omitempty"`
+	Album                  string `json:"album,omitempty"`
+	AlbumArtist            string `json:"album_artist,omitempty"`
+	ReleaseDate            string `json:"release_date,omitempty"`
+	TrackNumber            int    `json:"track_number,omitempty"`
+	DiscNumber             int    `json:"disc_number,omitempty"`
+	ISRC                   string `json:"isrc,omitempty"`
+	CoverURL               string `json:"cover_url,omitempty"`
+	Genre                  string `json:"genre,omitempty"`
+	Label                  string `json:"label,omitempty"`
+	Copyright              string `json:"copyright,omitempty"`
+	SkipMetadataEnrichment bool   `json:"skip_metadata_enrichment,omitempty"`
 }
 
-// DownloadResult is a generic result type for all downloaders
 type DownloadResult struct {
 	FilePath    string
 	BitDepth    int
@@ -202,9 +187,6 @@ type DownloadResult struct {
 	ISRC        string
 }
 
-// DownloadTrack downloads a track from the specified service
-// requestJSON is a JSON string of DownloadRequest
-// Returns JSON string of DownloadResponse
 func DownloadTrack(requestJSON string) (string, error) {
 	var req DownloadRequest
 	if err := json.Unmarshal([]byte(requestJSON), &req); err != nil {
@@ -218,7 +200,6 @@ func DownloadTrack(requestJSON string) (string, error) {
 	req.AlbumArtist = strings.TrimSpace(req.AlbumArtist)
 	req.OutputDir = strings.TrimSpace(req.OutputDir)
 
-	// Add output directory to allowed download dirs for extensions
 	if req.OutputDir != "" {
 		AddAllowedDownloadDir(req.OutputDir)
 	}
@@ -342,22 +323,18 @@ func DownloadTrack(requestJSON string) (string, error) {
 	return string(jsonBytes), nil
 }
 
-// DownloadWithFallback tries to download from services in order
-// Starts with the preferred service from request, then tries others
 func DownloadWithFallback(requestJSON string) (string, error) {
 	var req DownloadRequest
 	if err := json.Unmarshal([]byte(requestJSON), &req); err != nil {
 		return errorResponse("Invalid request: " + err.Error())
 	}
 
-	// Trim whitespace from string fields to prevent filename/path issues
 	req.TrackName = strings.TrimSpace(req.TrackName)
 	req.ArtistName = strings.TrimSpace(req.ArtistName)
 	req.AlbumName = strings.TrimSpace(req.AlbumName)
 	req.AlbumArtist = strings.TrimSpace(req.AlbumArtist)
 	req.OutputDir = strings.TrimSpace(req.OutputDir)
 
-	// Add output directory to allowed download dirs for extensions
 	if req.OutputDir != "" {
 		AddAllowedDownloadDir(req.OutputDir)
 	}
@@ -514,47 +491,36 @@ func DownloadWithFallback(requestJSON string) (string, error) {
 	return errorResponse("All services failed. Last error: " + lastErr.Error())
 }
 
-// GetDownloadProgress returns current download progress
 func GetDownloadProgress() string {
 	progress := getProgress()
 	jsonBytes, _ := json.Marshal(progress)
 	return string(jsonBytes)
 }
 
-// GetAllDownloadProgress returns progress for all active downloads (concurrent mode)
 func GetAllDownloadProgress() string {
 	return GetMultiProgress()
 }
 
-// InitItemProgress initializes progress tracking for a download item
 func InitItemProgress(itemID string) {
 	StartItemProgress(itemID)
 }
 
-// FinishItemProgress marks a download item as complete and removes tracking
 func FinishItemProgress(itemID string) {
 	CompleteItemProgress(itemID)
 }
 
-// ClearItemProgress removes progress tracking for a specific item
 func ClearItemProgress(itemID string) {
 	RemoveItemProgress(itemID)
 }
 
-// CancelDownload cancels an in-progress download for the given item.
 func CancelDownload(itemID string) {
 	cancelDownload(itemID)
 }
 
-// CleanupConnections closes idle HTTP connections
-// Call this periodically during large batch downloads to prevent TCP exhaustion
 func CleanupConnections() {
 	CloseIdleConnections()
 }
 
-// ReadFileMetadata reads metadata directly from a FLAC file
-// Returns JSON with all embedded metadata (title, artist, album, track number, etc.)
-// This is useful for displaying accurate metadata in the UI without relying on cached data
 func ReadFileMetadata(filePath string) (string, error) {
 	metadata, err := ReadMetadata(filePath)
 	if err != nil {
@@ -594,12 +560,10 @@ func ReadFileMetadata(filePath string) (string, error) {
 	return string(jsonBytes), nil
 }
 
-// SetDownloadDirectory sets the default download directory
 func SetDownloadDirectory(path string) error {
 	return setDownloadDir(path)
 }
 
-// CheckDuplicate checks if a file with the given ISRC exists
 func CheckDuplicate(outputDir, isrc string) (string, error) {
 	existingFile, exists := CheckISRCExists(outputDir, isrc)
 
@@ -616,26 +580,18 @@ func CheckDuplicate(outputDir, isrc string) (string, error) {
 	return string(jsonBytes), nil
 }
 
-// CheckDuplicatesBatch checks multiple files for duplicates in parallel
-// Uses ISRC index for fast lookup (builds index once, checks all tracks)
-// tracksJSON format: [{"isrc": "...", "track_name": "...", "artist_name": "..."}, ...]
-// Returns JSON array of results
 func CheckDuplicatesBatch(outputDir, tracksJSON string) (string, error) {
 	return CheckFilesExistParallel(outputDir, tracksJSON)
 }
 
-// PreBuildDuplicateIndex pre-builds the ISRC index for a directory
-// Call this when entering album/playlist screen for faster duplicate checking
 func PreBuildDuplicateIndex(outputDir string) error {
 	return PreBuildISRCIndex(outputDir)
 }
 
-// InvalidateDuplicateIndex clears the ISRC index cache for a directory
 func InvalidateDuplicateIndex(outputDir string) {
 	InvalidateISRCCache(outputDir)
 }
 
-// BuildFilename builds a filename from template and metadata
 func BuildFilename(template string, metadataJSON string) (string, error) {
 	var metadata map[string]interface{}
 	if err := json.Unmarshal([]byte(metadataJSON), &metadata); err != nil {
@@ -646,14 +602,10 @@ func BuildFilename(template string, metadataJSON string) (string, error) {
 	return filename, nil
 }
 
-// SanitizeFilename removes invalid characters from filename
 func SanitizeFilename(filename string) string {
 	return sanitizeFilename(filename)
 }
 
-// FetchLyrics fetches lyrics for a track from LRCLIB
-// Returns JSON with lyrics data
-// durationMs: track duration in milliseconds for matching, use 0 to skip duration matching
 func FetchLyrics(spotifyID, trackName, artistName string, durationMs int64) (string, error) {
 	client := NewLyricsClient()
 	durationSec := float64(durationMs) / 1000.0
@@ -677,9 +629,6 @@ func FetchLyrics(spotifyID, trackName, artistName string, durationMs int64) (str
 	return string(jsonBytes), nil
 }
 
-// GetLyricsLRC fetches lyrics and converts to LRC format string with metadata headers
-// First tries to extract from file, then falls back to fetching from internet
-// durationMs: track duration in milliseconds for matching, use 0 to skip duration matching
 func GetLyricsLRC(spotifyID, trackName, artistName string, filePath string, durationMs int64) (string, error) {
 	if filePath != "" {
 		lyrics, err := ExtractLyrics(filePath)
@@ -699,7 +648,6 @@ func GetLyricsLRC(spotifyID, trackName, artistName string, filePath string, dura
 	return lrcContent, nil
 }
 
-// EmbedLyricsToFile embeds lyrics into an existing FLAC file
 func EmbedLyricsToFile(filePath, lyrics string) (string, error) {
 	err := EmbedLyrics(filePath, lyrics)
 	if err != nil {
@@ -715,9 +663,6 @@ func EmbedLyricsToFile(filePath, lyrics string) (string, error) {
 	return string(jsonBytes), nil
 }
 
-// PreWarmTrackCacheJSON pre-warms the track ID cache for album/playlist tracks
-// tracksJSON is a JSON array of objects with: isrc, track_name, artist_name, spotify_id, service
-// This runs in background and returns immediately
 func PreWarmTrackCacheJSON(tracksJSON string) (string, error) {
 	var tracks []struct {
 		ISRC       string `json:"isrc"`
@@ -753,20 +698,14 @@ func PreWarmTrackCacheJSON(tracksJSON string) (string, error) {
 	return string(jsonBytes), nil
 }
 
-// GetTrackCacheSize returns the current track ID cache size
 func GetTrackCacheSize() int {
 	return GetCacheSize()
 }
 
-// ClearTrackIDCache clears the track ID cache
 func ClearTrackIDCache() {
 	ClearTrackCache()
 }
 
-// ==================== DEEZER API ====================
-
-// SearchDeezerAll searches for tracks and artists on Deezer (no API key required)
-// Returns JSON with tracks and artists arrays
 func SearchDeezerAll(query string, trackLimit, artistLimit int) (string, error) {
 	ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
 	defer cancel()
@@ -984,10 +923,6 @@ func GetSpotifyMetadataWithDeezerFallback(spotifyURL string) (string, error) {
 	return "", fmt.Errorf("spotify rate limited. Playlists are user-specific and require Spotify API")
 }
 
-// ==================== SONGLINK DEEZER SUPPORT ====================
-
-// CheckAvailabilityFromDeezerID checks track availability using Deezer track ID as source
-// Returns JSON with availability info for Spotify, Tidal, Amazon, etc.
 func CheckAvailabilityFromDeezerID(deezerTrackID string) (string, error) {
 	client := NewSongLinkClient()
 	availability, err := client.CheckAvailabilityFromDeezer(deezerTrackID)
@@ -1171,14 +1106,12 @@ func UpgradeExtensionFromPath(filePath string) (string, error) {
 		return "", err
 	}
 
-	// Initialize with saved settings
 	settingsStore := GetExtensionSettingsStore()
 	settings := settingsStore.GetAll(ext.ID)
 	if len(settings) > 0 {
 		manager.InitializeExtension(ext.ID, settings)
 	}
 
-	// Return extension info as JSON
 	result := map[string]interface{}{
 		"id":           ext.ID,
 		"display_name": ext.Manifest.DisplayName,
@@ -1342,8 +1275,6 @@ func InvokeExtensionActionJSON(extensionID, actionName string) (string, error) {
 	return string(jsonBytes), nil
 }
 
-// ==================== EXTENSION AUTH API ====================
-
 // GetExtensionPendingAuthJSON returns pending auth request for an extension
 func GetExtensionPendingAuthJSON(extensionID string) (string, error) {
 	req := GetPendingAuthRequest(extensionID)
@@ -1423,9 +1354,6 @@ func GetAllPendingAuthRequestsJSON() (string, error) {
 	return string(jsonBytes), nil
 }
 
-// ==================== EXTENSION FFMPEG API ====================
-
-// GetPendingFFmpegCommandJSON returns a pending FFmpeg command for Flutter to execute
 func GetPendingFFmpegCommandJSON(commandID string) (string, error) {
 	cmd := GetPendingFFmpegCommand(commandID)
 	if cmd == nil {
@@ -1485,7 +1413,6 @@ func EnrichTrackWithExtensionJSON(extensionID, trackJSON string) (string, error)
 	manager := GetExtensionManager()
 	ext, err := manager.GetExtension(extensionID)
 	if err != nil {
-		// Extension not found, return original track
 		return trackJSON, nil
 	}
 
@@ -1589,10 +1516,6 @@ func GetSearchProvidersJSON() (string, error) {
 	return string(jsonBytes), nil
 }
 
-// ==================== EXTENSION URL HANDLER ====================
-
-// HandleURLWithExtensionJSON tries to handle a URL with any matching extension
-// Returns JSON with type, tracks, album info, etc.
 func HandleURLWithExtensionJSON(url string) (string, error) {
 	manager := GetExtensionManager()
 	resultWithID, err := manager.HandleURLWithExtension(url)
@@ -1854,7 +1777,6 @@ func GetPlaylistWithExtensionJSON(extensionID, playlistID string) (string, error
 		return "", fmt.Errorf("failed to marshal result: %w", err)
 	}
 
-	// Parse into album metadata (same structure)
 	var album ExtAlbumMetadata
 	if err := json.Unmarshal(jsonBytes, &album); err != nil {
 		return "", fmt.Errorf("failed to parse playlist: %w", err)
@@ -1955,7 +1877,6 @@ func GetArtistWithExtensionJSON(extensionID, artistID string) (string, error) {
 		response["header_image"] = artist.HeaderImage
 	}
 
-	// Add listeners if present
 	if artist.Listeners > 0 {
 		response["listeners"] = artist.Listeners
 	}
@@ -2013,9 +1934,6 @@ func GetURLHandlersJSON() (string, error) {
 	return string(jsonBytes), nil
 }
 
-// ==================== EXTENSION POST-PROCESSING ====================
-
-// RunPostProcessingJSON runs post-processing hooks on a file
 func RunPostProcessingJSON(filePath, metadataJSON string) (string, error) {
 	var metadata map[string]interface{}
 	if metadataJSON != "" {
@@ -2071,8 +1989,6 @@ func GetPostProcessingProvidersJSON() (string, error) {
 	return string(jsonBytes), nil
 }
 
-// ==================== EXTENSION STORE ====================
-
 // InitExtensionStoreJSON initializes the extension store with cache directory
 func InitExtensionStoreJSON(cacheDir string) error {
 	InitExtensionStore(cacheDir)
@@ -2086,7 +2002,6 @@ func GetStoreExtensionsJSON(forceRefresh bool) (string, error) {
 		return "", fmt.Errorf("extension store not initialized")
 	}
 
-	// Force refresh if requested
 	if forceRefresh {
 		store.FetchRegistry(true)
 	}

go_backend/extension_manager.go

@@ -1,4 +1,3 @@
-// Package gobackend provides extension management functionality
 package gobackend
 
 import (
@@ -15,8 +14,6 @@ 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 {
 	parts1 := strings.Split(strings.TrimPrefix(v1, "v"), ".")
 	parts2 := strings.Split(strings.TrimPrefix(v2, "v"), ".")
@@ -46,11 +43,11 @@ 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:"-"`
+	VMMu      sync.Mutex         `json:"-"` // Mutex to prevent concurrent VM access
 	Enabled   bool               `json:"enabled"`
 	Error     string             `json:"error,omitempty"`
 	DataDir   string             `json:"data_dir"`
@@ -71,7 +68,6 @@ var (
 	globalExtManagerOnce sync.Once
 )
 
-// GetExtensionManager returns the global extension manager instance
 func GetExtensionManager() *ExtensionManager {
 	globalExtManagerOnce.Do(func() {
 		globalExtManager = &ExtensionManager{
@@ -81,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()
@@ -99,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")
 	}
@@ -180,14 +173,11 @@ func (m *ExtensionManager) LoadExtensionFromFile(filePath string) (*LoadedExtens
 		return nil, fmt.Errorf("failed to create extension directory: %w", err)
 	}
 
-	// Extract all files (preserving directory structure)
 	for _, file := range zipReader.File {
 		if file.FileInfo().IsDir() {
 			continue
 		}
 
-		// Preserve relative path within the zip (support subdirectories)
-		// Clean the path to prevent path traversal attacks
 		relPath := filepath.Clean(file.Name)
 		if strings.HasPrefix(relPath, "..") || filepath.IsAbs(relPath) {
 			GoLog("[Extension] Skipping unsafe path in archive: %s\n", file.Name)
@@ -245,7 +235,6 @@ 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 {
 	vm := goja.New()
 	ext.VM = vm
@@ -322,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()
@@ -347,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()
@@ -408,7 +395,6 @@ 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()
@@ -497,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
@@ -644,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"`
@@ -716,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 {
@@ -826,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()
@@ -888,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()
@@ -899,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') {
@@ -951,16 +931,13 @@ 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")
 }
 
-// InvokeAction calls a custom action function on an extension (e.g., for button settings)
 // 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()

go_backend/extension_manifest.go

@@ -151,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"}
 	}
@@ -174,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{
@@ -200,21 +197,6 @@ func (m *ExtensionManifest) Validate() error {
 			}
 		}
 
-		// Validate setting type
-		validTypes := map[SettingType]bool{
-			SettingTypeString: true,
-			SettingTypeNumber: true,
-			SettingTypeBool:   true,
-			SettingTypeSelect: true,
-			SettingTypeButton: 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{
@@ -223,7 +205,6 @@ func (m *ExtensionManifest) Validate() error {
 			}
 		}
 
-		// Button type requires action
 		if setting.Type == SettingTypeButton && setting.Action == "" {
 			return &ManifestValidationError{
 				Field:   fmt.Sprintf("settings[%d].action", i),
@@ -300,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,6 +2,7 @@
 package gobackend
 
 import (
+	"context"
 	"encoding/json"
 	"errors"
 	"fmt"
@@ -38,6 +39,10 @@ type ExtTrackMetadata struct {
 	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
@@ -144,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() {
@@ -206,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') {
@@ -252,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') {
@@ -301,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') {
@@ -349,6 +370,10 @@ func (p *ExtensionProviderWrapper) EnrichTrack(track *ExtTrackMetadata) (*ExtTra
 		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 {
@@ -415,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') {
@@ -460,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') {
@@ -508,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 {
@@ -758,6 +795,23 @@ func DownloadWithExtensionFallback(req DownloadRequest) (*DownloadResponse, erro
 				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
+				}
 			}
 		}
 	}
@@ -795,6 +849,9 @@ 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)
@@ -887,10 +944,44 @@ 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 {
@@ -944,6 +1035,9 @@ 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)
@@ -1103,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
 }
 
@@ -1138,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)
 
@@ -1209,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') {
@@ -1290,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)
 
@@ -1353,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(`

go_backend/extension_runtime.go

@@ -1,4 +1,3 @@
-// Package gobackend provides extension runtime with sandboxed execution
 package gobackend
 
 import (
@@ -17,7 +16,6 @@ var (
 	extensionAuthStateMu sync.RWMutex
 )
 
-// ExtensionAuthState holds auth state for an extension
 type ExtensionAuthState struct {
 	PendingAuthURL  string
 	AuthCode        string
@@ -30,7 +28,6 @@ type ExtensionAuthState struct {
 	PKCEChallenge string
 }
 
-// PendingAuthRequest holds a pending OAuth request that needs Flutter to open URL
 type PendingAuthRequest struct {
 	ExtensionID string
 	AuthURL     string
@@ -55,7 +52,6 @@ func ClearPendingAuthRequest(extensionID string) {
 	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()
@@ -68,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()
@@ -84,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
@@ -95,7 +89,6 @@ type ExtensionRuntime struct {
 	vm          *goja.Runtime
 }
 
-// NewExtensionRuntime creates a new runtime for an extension
 func NewExtensionRuntime(ext *LoadedExtension) *ExtensionRuntime {
 	jar, _ := newSimpleCookieJar()
 
@@ -108,7 +101,6 @@ func NewExtensionRuntime(ext *LoadedExtension) *ExtensionRuntime {
 		vm:          ext.VM,
 	}
 
-	// Create HTTP client with redirect validation to prevent SSRF via open redirect
 	client := &http.Client{
 		Timeout: 30 * time.Second,
 		Jar:     jar,
@@ -119,7 +111,6 @@ func NewExtensionRuntime(ext *LoadedExtension) *ExtensionRuntime {
 				GoLog("[Extension:%s] Redirect blocked: domain '%s' not in allowed list\n", ext.ID, domain)
 				return &RedirectBlockedError{Domain: domain}
 			}
-			// Also block redirects to private/local networks (SSRF protection)
 			if isPrivateIP(domain) {
 				GoLog("[Extension:%s] Redirect blocked: private IP '%s'\n", ext.ID, domain)
 				return &RedirectBlockedError{Domain: domain, IsPrivate: true}
@@ -136,7 +127,6 @@ func NewExtensionRuntime(ext *LoadedExtension) *ExtensionRuntime {
 	return runtime
 }
 
-// RedirectBlockedError is returned when a redirect is blocked due to domain validation
 type RedirectBlockedError struct {
 	Domain    string
 	IsPrivate bool
@@ -162,10 +152,10 @@ func isPrivateIP(host string) bool {
 		"172.24.", "172.25.", "172.26.", "172.27.",
 		"172.28.", "172.29.", "172.30.", "172.31.",
 		"192.168.",
-		"169.254.", // Link-local
-		"::1",      // IPv6 localhost
-		"fc00:",    // IPv6 private
-		"fe80:",    // IPv6 link-local
+		"169.254.",
+		"::1",
+		"fc00:",
+		"fe80:",
 	}
 
 	hostLower := host
@@ -183,7 +173,6 @@ func isPrivateIP(host string) bool {
 	return false
 }
 
-// simpleCookieJar is a simple in-memory cookie jar
 type simpleCookieJar struct {
 	cookies map[string][]*http.Cookie
 	mu      sync.RWMutex
@@ -208,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
 }
@@ -228,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)
@@ -243,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)
@@ -270,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)
@@ -284,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)
@@ -299,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)
@@ -309,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)
@@ -320,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

@@ -21,8 +21,6 @@ var (
 	allowedDownloadDirsMu sync.RWMutex
 )
 
-// SetAllowedDownloadDirs sets the list of directories where extensions can write files
-// This should be called by the Go backend when setting up download paths
 func SetAllowedDownloadDirs(dirs []string) {
 	allowedDownloadDirsMu.Lock()
 	defer allowedDownloadDirsMu.Unlock()
@@ -30,7 +28,6 @@ func SetAllowedDownloadDirs(dirs []string) {
 	GoLog("[Extension] Allowed download directories set: %v\n", dirs)
 }
 
-// AddAllowedDownloadDir adds a directory to the allowed list
 func AddAllowedDownloadDir(dir string) {
 	allowedDownloadDirsMu.Lock()
 	defer allowedDownloadDirsMu.Unlock()
@@ -40,7 +37,6 @@ func AddAllowedDownloadDir(dir string) {
 	}
 }
 
-// isPathInAllowedDirs checks if an absolute path is within any allowed directory
 func isPathInAllowedDirs(absPath string) bool {
 	allowedDownloadDirsMu.RLock()
 	defer allowedDownloadDirsMu.RUnlock()
@@ -62,36 +58,28 @@ func (r *ExtensionRuntime) validatePath(path string) (string, error) {
 		return "", fmt.Errorf("file access denied: extension does not have 'file' permission")
 	}
 
-	// Clean and resolve the path
 	cleanPath := filepath.Clean(path)
 
-	// SECURITY: Block absolute paths by default
-	// Only allow if path is in explicitly allowed download directories
 	if filepath.IsAbs(cleanPath) {
 		absPath, err := filepath.Abs(cleanPath)
 		if err != nil {
 			return "", fmt.Errorf("invalid path: %w", err)
 		}
 
-		// Check if path is in allowed download directories
 		if isPathInAllowedDirs(absPath) {
 			return absPath, nil
 		}
 
-		// Block all other absolute paths
 		return "", fmt.Errorf("file access denied: absolute paths are not allowed. Use relative paths within extension sandbox")
 	}
 
-	// For relative paths, join with data directory (extension's sandbox)
 	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 (prevent path traversal)
 	absDataDir, _ := filepath.Abs(r.dataDir)
 	if !strings.HasPrefix(absPath, absDataDir) {
 		return "", fmt.Errorf("file access denied: path '%s' is outside sandbox", path)
@@ -100,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{}{
@@ -113,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,
@@ -121,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{}{
@@ -130,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
@@ -152,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{}{
@@ -161,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{}{
@@ -170,7 +149,6 @@ func (r *ExtensionRuntime) fileDownload(call goja.FunctionCall) goja.Value {
 		})
 	}
 
-	// Set headers
 	for k, v := range headers {
 		req.Header.Set(k, v)
 	}
@@ -178,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{}{
@@ -195,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{}{
@@ -205,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 {
@@ -235,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))
 			}
@@ -260,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)
@@ -276,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{}{
@@ -306,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{}{
@@ -338,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{}{
@@ -380,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{}{
@@ -408,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{}{
@@ -417,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{}{
@@ -426,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,
@@ -440,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{}{
@@ -468,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{}{
@@ -490,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

@@ -52,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{}{
@@ -60,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()
@@ -71,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{}{
@@ -97,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{}{
@@ -134,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{}{
@@ -175,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{}{
@@ -204,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{}{
@@ -231,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{}{
@@ -242,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{}{
@@ -326,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{}{
@@ -354,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)
 }
@@ -364,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)
 }
@@ -380,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{}{
@@ -465,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{}{
@@ -492,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

@@ -143,19 +143,16 @@ func (r *ExtensionRuntime) getSaltPath() string {
 func (r *ExtensionRuntime) getOrCreateSalt() ([]byte, error) {
 	saltPath := r.getSaltPath()
 
-	// Try to read existing salt
 	salt, err := os.ReadFile(saltPath)
 	if err == nil && len(salt) == 32 {
 		return salt, nil
 	}
 
-	// Generate new random salt (32 bytes)
 	salt = make([]byte, 32)
 	if _, err := io.ReadFull(rand.Reader, salt); err != nil {
 		return nil, fmt.Errorf("failed to generate salt: %w", err)
 	}
 
-	// Save salt to file
 	if err := os.WriteFile(saltPath, salt, 0600); err != nil {
 		return nil, fmt.Errorf("failed to save salt: %w", err)
 	}
@@ -214,7 +211,6 @@ func (r *ExtensionRuntime) saveCredentials(creds map[string]interface{}) error {
 		return err
 	}
 
-	// Encrypt the data
 	key, err := r.getEncryptionKey()
 	if err != nil {
 		return fmt.Errorf("failed to get encryption key: %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/filename.go

@@ -6,10 +6,8 @@ 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 {
 	sanitized := invalidChars.ReplaceAllString(filename, "_")
 	
@@ -30,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}"
@@ -91,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,61 +15,23 @@ 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 {
-	winMajor := rand.Intn(2) + 10
-
-	chromeVersion := rand.Intn(25) + 100
-	chromeBuild := rand.Intn(1500) + 3000
-	chromePatch := rand.Intn(65) + 60
+	// 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
-// 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
-// func getRandomDesktopUserAgent() string {
-// 	if rand.Intn(2) == 0 {
-// 		return getRandomUserAgent() // Windows
-// 	}
-// 	return getRandomMacUserAgent() // Mac
-// }
-
 const (
 	DefaultTimeout    = 60 * time.Second
 	DownloadTimeout   = 120 * time.Second
@@ -107,7 +69,6 @@ var downloadClient = &http.Client{
 	Timeout:   DownloadTimeout,
 }
 
-// NewHTTPClientWithTimeout creates an HTTP client with specified timeout
 func NewHTTPClientWithTimeout(timeout time.Duration) *http.Client {
 	return &http.Client{
 		Transport: sharedTransport,
@@ -128,7 +89,6 @@ 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())
@@ -147,7 +107,6 @@ type RetryConfig struct {
 	BackoffFactor float64
 }
 
-// DefaultRetryConfig returns default retry configuration
 func DefaultRetryConfig() RetryConfig {
 	return RetryConfig{
 		MaxRetries:    DefaultMaxRetries,
@@ -253,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")
@@ -302,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")
@@ -331,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
@@ -447,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)
@@ -485,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,7 +15,6 @@ 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
@@ -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,7 +52,6 @@ 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()

go_backend/lyrics.go

@@ -6,6 +6,8 @@ import (
 	"math"
 	"net/http"
 	"net/url"
+	"os"
+	"path/filepath"
 	"regexp"
 	"strconv"
 	"strings"
@@ -13,13 +15,9 @@ import (
 	"time"
 )
 
-// ========================================
-// Lyrics Cache with TTL
-// ========================================
-
 const (
-	lyricsCacheTTL       = 24 * time.Hour // Cache lyrics for 24 hours
-	durationToleranceSec = 10.0           // Duration matching tolerance in seconds
+	lyricsCacheTTL       = 24 * time.Hour
+	durationToleranceSec = 10.0
 )
 
 type lyricsCacheEntry struct {
@@ -37,10 +35,8 @@ var globalLyricsCache = &lyricsCache{
 }
 
 func (c *lyricsCache) generateKey(artist, track string, durationSec float64) string {
-	// Normalize key: lowercase, trim spaces
 	normalizedArtist := strings.ToLower(strings.TrimSpace(artist))
 	normalizedTrack := strings.ToLower(strings.TrimSpace(track))
-	// Round duration to nearest 10 seconds for cache key
 	roundedDuration := math.Round(durationSec/10) * 10
 	return fmt.Sprintf("%s|%s|%.0f", normalizedArtist, normalizedTrack, roundedDuration)
 }
@@ -55,7 +51,6 @@ func (c *lyricsCache) Get(artist, track string, durationSec float64) (*LyricsRes
 		return nil, false
 	}
 
-	// Check if expired
 	if time.Now().After(entry.expiresAt) {
 		return nil, false
 	}
@@ -74,7 +69,6 @@ func (c *lyricsCache) Set(artist, track string, durationSec float64, response *L
 	}
 }
 
-// CleanExpired removes expired entries from cache
 func (c *lyricsCache) CleanExpired() int {
 	c.mu.Lock()
 	defer c.mu.Unlock()
@@ -90,7 +84,6 @@ func (c *lyricsCache) CleanExpired() int {
 	return cleaned
 }
 
-// Size returns current cache size
 func (c *lyricsCache) Size() int {
 	c.mu.RLock()
 	defer c.mu.RUnlock()
@@ -130,9 +123,7 @@ type LyricsClient struct {
 
 func NewLyricsClient() *LyricsClient {
 	return &LyricsClient{
-		httpClient: &http.Client{
-			Timeout: 15 * time.Second,
-		},
+		httpClient: NewHTTPClientWithTimeout(15 * time.Second),
 	}
 }
 
@@ -172,8 +163,6 @@ func (c *LyricsClient) FetchLyricsWithMetadata(artist, track string) (*LyricsRes
 	return c.parseLRCLibResponse(&lrcResp), nil
 }
 
-// FetchLyricsFromLRCLibSearch searches lyrics with optional duration matching
-// durationSec: track duration in seconds, use 0 to skip duration matching
 func (c *LyricsClient) FetchLyricsFromLRCLibSearch(query string, durationSec float64) (*LyricsResponse, error) {
 	baseURL := "https://lrclib.net/api/search"
 	params := url.Values{}
@@ -206,13 +195,11 @@ func (c *LyricsClient) FetchLyricsFromLRCLibSearch(query string, durationSec flo
 		return nil, fmt.Errorf("no lyrics found")
 	}
 
-	// Filter and score results based on duration matching and synced lyrics
 	bestMatch := c.findBestMatch(results, durationSec)
 	if bestMatch != nil {
 		return c.parseLRCLibResponse(bestMatch), nil
 	}
 
-	// Fallback: return first result with synced lyrics
 	for _, result := range results {
 		if result.SyncedLyrics != "" {
 			return c.parseLRCLibResponse(&result), nil
@@ -222,7 +209,6 @@ func (c *LyricsClient) FetchLyricsFromLRCLibSearch(query string, durationSec flo
 	return c.parseLRCLibResponse(&results[0]), nil
 }
 
-// findBestMatch finds the best matching lyrics based on duration and sync status
 func (c *LyricsClient) findBestMatch(results []LRCLibResponse, targetDurationSec float64) *LRCLibResponse {
 	var bestSynced *LRCLibResponse
 	var bestPlain *LRCLibResponse
@@ -230,11 +216,9 @@ func (c *LyricsClient) findBestMatch(results []LRCLibResponse, targetDurationSec
 	for i := range results {
 		result := &results[i]
 
-		// Check duration match if target duration is provided
 		durationMatches := targetDurationSec == 0 || c.durationMatches(result.Duration, targetDurationSec)
 
 		if durationMatches {
-			// Prefer synced lyrics over plain
 			if result.SyncedLyrics != "" && bestSynced == nil {
 				bestSynced = result
 			} else if result.PlainLyrics != "" && bestPlain == nil {
@@ -243,20 +227,17 @@ func (c *LyricsClient) findBestMatch(results []LRCLibResponse, targetDurationSec
 		}
 	}
 
-	// Return synced first, then plain
 	if bestSynced != nil {
 		return bestSynced
 	}
 	return bestPlain
 }
 
-// durationMatches checks if two durations are within tolerance
 func (c *LyricsClient) durationMatches(lrcDuration, targetDuration float64) bool {
 	diff := math.Abs(lrcDuration - targetDuration)
 	return diff <= durationToleranceSec
 }
 
-// FetchLyricsAllSources fetches lyrics from multiple sources with caching and duration matching
 // 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
@@ -394,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 {
@@ -421,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 ""
@@ -430,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 == "" {
@@ -485,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,12 +26,11 @@ type Metadata struct {
 	ISRC        string
 	Description string
 	Lyrics      string
-	Genre       string // Music genre (e.g., "Rock", "Pop", "Electronic")
-	Label       string // Record label (ORGANIZATION tag in Vorbis)
-	Copyright   string // Copyright information
+	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 {
@@ -138,8 +139,6 @@ func EmbedMetadata(filePath string, metadata Metadata, coverPath string) error {
 	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 {
@@ -337,7 +336,6 @@ func fileExists(path string) bool {
 	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 {
@@ -375,11 +373,9 @@ func EmbedLyrics(filePath string, lyrics string) error {
 	return f.Save(filePath)
 }
 
-// EmbedGenreLabel embeds genre and label into a FLAC file as a separate operation
-// This is used for extension downloads where the file is already downloaded
 func EmbedGenreLabel(filePath string, genre, label string) error {
 	if genre == "" && label == "" {
-		return nil // Nothing to embed
+		return nil
 	}
 
 	f, err := flac.ParseFile(filePath)
@@ -451,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 {
@@ -526,78 +518,170 @@ func GetAudioQuality(filePath string) (AudioQuality, error) {
 
 // EmbedM4AMetadata embeds metadata into an M4A file using iTunes-style atoms
 func EmbedM4AMetadata(filePath string, metadata Metadata, coverData []byte) error {
-	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()
 
-	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")
 	}
 
-	moovSize := int(uint32(data[moovPos])<<24 | uint32(data[moovPos+1])<<16 | uint32(data[moovPos+2])<<8 | uint32(data[moovPos+3]))
-	udtaPos := findAtom(data, "udta", moovPos+8)
+	moovContentStart := moovHeader.offset + moovHeader.headerSize
+	moovContentSize := moovHeader.size - moovHeader.headerSize
+
+	udtaHeader, udtaFound, err := findAtomInRange(input, moovContentStart, moovContentSize, "udta", fileSize)
+	if err != nil {
+		return fmt.Errorf("failed to locate udta atom: %w", err)
+	}
+
+	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)
+		}
+	}
 
 	metaAtom := buildMetaAtom(metadata, coverData)
+	metaSize := int64(len(metaAtom))
 
-	var newData []byte
-	if udtaPos >= 0 && udtaPos < moovPos+moovSize {
-		udtaSize := int(uint32(data[udtaPos])<<24 | uint32(data[udtaPos+1])<<16 | uint32(data[udtaPos+2])<<8 | uint32(data[udtaPos+3]))
-		metaPos := findAtom(data, "meta", udtaPos+8)
+	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
+	}
 
-		if metaPos >= 0 && metaPos < udtaPos+udtaSize {
-			metaSize := int(uint32(data[metaPos])<<24 | uint32(data[metaPos+1])<<16 | uint32(data[metaPos+2])<<8 | uint32(data[metaPos+3]))
-			newData = append(newData, data[:metaPos]...)
-			newData = append(newData, metaAtom...)
-			newData = append(newData, data[metaPos+metaSize:]...)
-		} else {
-			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...)
+	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")
+	}
 
-			newData = append(newData, data[:udtaPos]...)
-			newData = append(newData, newUdta...)
-			newData = append(newData, data[udtaPos+udtaSize:]...)
+	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)
 		}
-	} else {
-		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...)
+	}()
 
-		insertPos := moovPos + moovSize
-		newData = append(newData, data[:insertPos]...)
-		newData = append(newData, newUdta...)
-		newData = append(newData, data[insertPos:]...)
+	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
+		}
 	}
 
-	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)
-
-	if err := os.WriteFile(filePath, newData, 0644); err != nil {
-		return fmt.Errorf("failed to write M4A file: %w", 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(uint32(data[i])<<24 | uint32(data[i+1])<<16 | uint32(data[i+2])<<8 | uint32(data[i+3]))
@@ -689,7 +773,6 @@ 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)
 
@@ -741,7 +824,6 @@ func buildTrackNumberAtom(track, total int) []byte {
 	return atom
 }
 
-// buildDiscNumberAtom builds disk atom
 func buildDiscNumberAtom(disc, total int) []byte {
 	dataAtom := []byte{
 		0, 0, 0, 22, // size
@@ -767,9 +849,9 @@ func buildDiscNumberAtom(disc, total int) []byte {
 
 // buildCoverAtom builds covr atom with image data
 func buildCoverAtom(coverData []byte) []byte {
-	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
 	}
 
 	dataSize := 16 + len(coverData)
@@ -779,8 +861,8 @@ 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...)
 
 	atomSize := 8 + len(dataAtom)
@@ -795,30 +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()
 
-	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")
 	}
 
-	for i := moovPos; i < len(data)-20; i++ {
-		if string(data[i:i+4]) == "mp4a" || string(data[i:i+4]) == "alac" {
-			if i+24 < len(data) {
-				sampleRate := int(data[i+22])<<8 | int(data[i+23])
-				bitDepth := 16
-				if string(data[i:i+4]) == "alac" {
-					bitDepth = 24
-				}
-				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,7 +24,6 @@ var (
 	trackIDCacheOnce   sync.Once
 )
 
-// GetTrackIDCache returns the global track ID cache
 func GetTrackIDCache() *TrackIDCache {
 	trackIDCacheOnce.Do(func() {
 		globalTrackIDCache = &TrackIDCache{
@@ -41,7 +34,6 @@ func GetTrackIDCache() *TrackIDCache {
 	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,9 +105,6 @@ type ParallelDownloadResult struct {
 	LyricsErr  error
 }
 
-// FetchCoverAndLyricsParallel downloads cover and fetches lyrics in parallel
-// This runs while the main audio download is happening
-// durationMs: track duration in milliseconds for lyrics matching
 func FetchCoverAndLyricsParallel(
 	coverURL string,
 	maxQualityCover bool,
@@ -153,7 +133,6 @@ func FetchCoverAndLyricsParallel(
 		}()
 	}
 
-	// Fetch lyrics in parallel
 	if embedLyrics {
 		wg.Add(1)
 		go func() {
@@ -180,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
@@ -193,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
@@ -214,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":
@@ -259,12 +231,6 @@ func preWarmAmazonCache(isrc, spotifyID string) {
 	}
 }
 
-// ========================================
-// 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
 
@@ -272,13 +238,11 @@ func PreWarmCache(tracksJSON string) error {
 	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,12 +34,10 @@ 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
 func getProgress() DownloadProgress {
 	multiMu.RLock()
 	defer multiMu.RUnlock()
@@ -62,7 +56,6 @@ func getProgress() DownloadProgress {
 	return DownloadProgress{}
 }
 
-// GetMultiProgress returns progress for all active downloads as JSON
 func GetMultiProgress() string {
 	multiMu.RLock()
 	defer multiMu.RUnlock()
@@ -74,7 +67,6 @@ func GetMultiProgress() string {
 	return string(jsonBytes)
 }
 
-// GetItemProgress returns progress for a specific item as JSON
 func GetItemProgress(itemID string) string {
 	multiMu.RLock()
 	defer multiMu.RUnlock()
@@ -201,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) }

go_backend/qobuz.go

@@ -17,7 +17,6 @@ import (
 	"time"
 )
 
-// QobuzDownloader handles Qobuz downloads
 type QobuzDownloader struct {
 	client *http.Client
 	appID  string
@@ -29,7 +28,6 @@ var (
 	qobuzDownloaderOnce   sync.Once
 )
 
-// QobuzTrack represents a Qobuz track
 type QobuzTrack struct {
 	ID                  int64   `json:"id"`
 	Title               string  `json:"title"`
@@ -50,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))
@@ -93,9 +90,7 @@ func qobuzArtistsMatch(expectedArtist, foundArtist string) bool {
 	return false
 }
 
-// qobuzSplitArtists splits artist string by common separators
 func qobuzSplitArtists(artists string) []string {
-	// Replace common separators with a standard one
 	normalized := artists
 	normalized = strings.ReplaceAll(normalized, " feat. ", "|")
 	normalized = strings.ReplaceAll(normalized, " feat ", "|")
@@ -154,7 +149,6 @@ func qobuzSameWordsUnordered(a, b string) bool {
 	return true
 }
 
-// qobuzTitlesMatch checks if track titles are similar enough
 func qobuzTitlesMatch(expectedTitle, foundTitle string) bool {
 	normExpected := strings.ToLower(strings.TrimSpace(expectedTitle))
 	normFound := strings.ToLower(strings.TrimSpace(foundTitle))
@@ -164,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)
 
@@ -177,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)
 
@@ -225,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, ")")
@@ -258,7 +244,6 @@ func qobuzCleanTitle(title string) string {
 		break
 	}
 
-	// Same for brackets
 	for {
 		startBracket := strings.LastIndex(cleaned, "[")
 		endBracket := strings.LastIndex(cleaned, "]")
@@ -279,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",
@@ -290,7 +274,6 @@ func qobuzCleanTitle(title string) string {
 		}
 	}
 
-	// Remove multiple spaces
 	for strings.Contains(cleaned, "  ") {
 		cleaned = strings.ReplaceAll(cleaned, "  ", " ")
 	}
@@ -350,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{
@@ -361,7 +343,6 @@ func NewQobuzDownloader() *QobuzDownloader {
 	return globalQobuzDownloader
 }
 
-// GetTrackByID fetches track info directly by Qobuz track ID
 func (q *QobuzDownloader) GetTrackByID(trackID int64) (*QobuzTrack, error) {
 	// Qobuz API: /track/get?track_id=XXX
 	apiBase, _ := base64.StdEncoding.DecodeString("aHR0cHM6Ly93d3cucW9idXouY29tL2FwaS5qc29uLzAuMi90cmFjay9nZXQ/dHJhY2tfaWQ9")
@@ -412,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)
@@ -455,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)
@@ -500,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 {
@@ -508,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)
 				}
@@ -520,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
 	}
@@ -539,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) {
@@ -688,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",
@@ -701,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)
 	}
 
@@ -731,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")
@@ -748,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)
 
@@ -839,8 +805,6 @@ func getQobuzDownloadURLParallel(apis []string, trackID int64, quality string) (
 	return "", "", fmt.Errorf("all %d Qobuz APIs failed. Errors: %v", len(apis), errors)
 }
 
-// GetDownloadURL gets download URL for a track - tries 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 {
@@ -938,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
@@ -952,7 +915,6 @@ type QobuzDownloadResult struct {
 	ISRC        string
 }
 
-// downloadFromQobuz downloads a track using the request parameters
 func downloadFromQobuz(req DownloadRequest) (QobuzDownloadResult, error) {
 	downloader := NewQobuzDownloader()
 
@@ -1135,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,8 +20,6 @@ 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()
@@ -70,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()
@@ -87,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()
@@ -99,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"`
@@ -35,7 +33,6 @@ var (
 	songLinkClientOnce   sync.Once
 )
 
-// NewSongLinkClient creates a new SongLink client (returns singleton for connection reuse)
 func NewSongLinkClient() *SongLinkClient {
 	songLinkClientOnce.Do(func() {
 		globalSongLinkClient = &SongLinkClient{
@@ -45,7 +42,6 @@ func NewSongLinkClient() *SongLinkClient {
 	return globalSongLinkClient
 }
 
-// CheckTrackAvailability checks track availability on streaming platforms
 func (s *SongLinkClient) CheckTrackAvailability(spotifyTrackID string, isrc string) (*TrackAvailability, error) {
 	if spotifyTrackID == "" {
 		return nil, fmt.Errorf("spotify track ID is empty")
@@ -126,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,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 {
@@ -213,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()
@@ -283,11 +276,6 @@ 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 == "" {
@@ -374,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
@@ -472,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 {
@@ -500,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,7 +74,6 @@ func SetSpotifyCredentials(clientID, clientSecret string) {
 	customClientSecret = clientSecret
 }
 
-// HasSpotifyCredentials checks if Spotify credentials are configured
 func HasSpotifyCredentials() bool {
 	credentialsMu.RLock()
 	defer credentialsMu.RUnlock()
@@ -114,8 +108,6 @@ func getCredentials() (string, string, error) {
 	return "", "", ErrNoSpotifyCredentials
 }
 
-// NewSpotifyMetadataClient creates a new Spotify client
-// Returns error if credentials are not configured
 func NewSpotifyMetadataClient() (*SpotifyMetadataClient, error) {
 	clientID, clientSecret, err := getCredentials()
 	if err != nil {
@@ -137,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"`
@@ -155,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"`
@@ -172,28 +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"`     // Music genre(s), comma-separated
-	Label       string `json:"label,omitempty"`     // Record label name
-	Copyright   string `json:"copyright,omitempty"` // Copyright information
+	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"`
@@ -205,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"`
@@ -220,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"`
@@ -231,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"`
@@ -257,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"`
@@ -274,7 +253,6 @@ type accessTokenResponse struct {
 	TokenType   string      `json:"token_type"`
 }
 
-// Internal API response types
 type image struct {
 	URL string `json:"url"`
 }
@@ -300,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 {
@@ -315,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 {
@@ -341,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 {
@@ -388,7 +364,6 @@ 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) {
 	cacheKey := fmt.Sprintf("all:%s:%d:%d", query, trackLimit, artistLimit)
 
@@ -510,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"`
@@ -546,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"`
@@ -572,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))
@@ -612,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
@@ -624,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
 
@@ -633,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 }()
@@ -654,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"`
@@ -680,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
@@ -707,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 != "" {
@@ -719,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
 		}
@@ -766,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"`
@@ -789,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
@@ -829,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
 		}
@@ -916,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")
@@ -952,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
@@ -978,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 {
@@ -989,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
@@ -1008,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 == "" {
@@ -1034,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:]
 	}
@@ -1042,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":
@@ -1050,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
 	}

go_backend/tidal.go

@@ -19,7 +19,6 @@ import (
 	"time"
 )
 
-// TidalDownloader handles Tidal downloads
 type TidalDownloader struct {
 	client         *http.Client
 	clientID       string
@@ -35,7 +34,6 @@ var (
 	tidalDownloaderOnce   sync.Once
 )
 
-// TidalTrack represents a Tidal track
 type TidalTrack struct {
 	ID           int64  `json:"id"`
 	Title        string `json:"title"`
@@ -60,7 +58,6 @@ type TidalTrack struct {
 	} `json:"mediaMetadata"`
 }
 
-// TidalAPIResponseV2 is the new API response format (version 2.0)
 type TidalAPIResponseV2 struct {
 	Version string `json:"version"`
 	Data    struct {
@@ -76,7 +73,6 @@ type TidalAPIResponseV2 struct {
 	} `json:"data"`
 }
 
-// TidalBTSManifest is the BTS (application/vnd.tidal.bts) manifest format
 type TidalBTSManifest struct {
 	MimeType       string   `json:"mimeType"`
 	Codecs         string   `json:"codecs"`
@@ -84,7 +80,6 @@ type TidalBTSManifest struct {
 	URLs           []string `json:"urls"`
 }
 
-// MPD represents DASH manifest structure
 type MPD struct {
 	XMLName xml.Name `xml:"MPD"`
 	Period  struct {
@@ -105,7 +100,6 @@ type MPD struct {
 	} `xml:"Period"`
 }
 
-// NewTidalDownloader creates a new Tidal downloader (returns singleton for token reuse)
 func NewTidalDownloader() *TidalDownloader {
 	tidalDownloaderOnce.Do(func() {
 		clientID, _ := base64.StdEncoding.DecodeString("NkJEU1JkcEs5aHFFQlRnVQ==")
@@ -150,7 +144,6 @@ func (t *TidalDownloader) GetAvailableAPIs() []string {
 	return apis
 }
 
-// GetAccessToken gets Tidal access token (with caching)
 func (t *TidalDownloader) GetAccessToken() (string, error) {
 	t.tokenMu.Lock()
 	defer t.tokenMu.Unlock()
@@ -199,7 +192,6 @@ func (t *TidalDownloader) GetAccessToken() (string, error) {
 	return result.AccessToken, nil
 }
 
-// GetTidalURLFromSpotify gets Tidal URL from Spotify track ID using SongLink
 func (t *TidalDownloader) GetTidalURLFromSpotify(spotifyTrackID string) (string, error) {
 	spotifyBase, _ := base64.StdEncoding.DecodeString("aHR0cHM6Ly9vcGVuLnNwb3RpZnkuY29tL3RyYWNrLw==")
 	spotifyURL := fmt.Sprintf("%s%s", string(spotifyBase), spotifyTrackID)
@@ -239,7 +231,6 @@ func (t *TidalDownloader) GetTidalURLFromSpotify(spotifyTrackID string) (string,
 	return tidalLink.URL, nil
 }
 
-// GetTrackIDFromURL extracts track ID from Tidal URL
 func (t *TidalDownloader) GetTrackIDFromURL(tidalURL string) (int64, error) {
 	parts := strings.Split(tidalURL, "/track/")
 	if len(parts) < 2 {
@@ -293,7 +284,6 @@ func (t *TidalDownloader) GetTrackInfoByID(trackID int64) (*TidalTrack, error) {
 	return &trackInfo, nil
 }
 
-// SearchTrackByISRC searches for a track by ISRC
 func (t *TidalDownloader) SearchTrackByISRC(isrc string) (*TidalTrack, error) {
 	token, err := t.GetAccessToken()
 	if err != nil {
@@ -341,30 +331,7 @@ func (t *TidalDownloader) SearchTrackByISRC(isrc string) (*TidalTrack, error) {
 	return nil, fmt.Errorf("no exact ISRC match found for: %s", isrc)
 }
 
-// normalizeTitle normalizes a track title for comparison
-// Kept for potential future use
-// func normalizeTitle(title string) string {
-// 	normalized := strings.ToLower(strings.TrimSpace(title))
-//
-// 	// Remove common suffixes in parentheses or brackets
-// 	suffixPatterns := []string{
-// 		" (remaster)", " (remastered)", " (deluxe)", " (deluxe edition)",
-// 		" (bonus track)", " (single)", " (album version)", " (radio edit)",
-// 		" [remaster]", " [remastered]", " [deluxe]", " [bonus track]",
-// 	}
-// 	for _, suffix := range suffixPatterns {
-// 		normalized = strings.TrimSuffix(normalized, suffix)
-// 	}
-//
-// 	// Remove multiple spaces
-// 	for strings.Contains(normalized, "  ") {
-// 		normalized = strings.ReplaceAll(normalized, "  ", " ")
-// 	}
-//
-// 	return normalized
-// }
 
-// SearchTrackByMetadataWithISRC searches for a track with ISRC matching priority
 // Now includes romaji conversion for Japanese text (4 search strategies like PC)
 func (t *TidalDownloader) SearchTrackByMetadataWithISRC(trackName, artistName, spotifyISRC string, expectedDuration int) (*TidalTrack, error) {
 	token, err := t.GetAccessToken()
@@ -466,7 +433,6 @@ func (t *TidalDownloader) SearchTrackByMetadataWithISRC(trackName, artistName, s
 		if len(result.Items) > 0 {
 			GoLog("[Tidal] Found %d results for '%s'\n", len(result.Items), cleanQuery)
 
-			// OPTIMIZATION: If ISRC provided, check for match immediately and return early
 			if spotifyISRC != "" {
 				for i := range result.Items {
 					if result.Items[i].ISRC == spotifyISRC {
@@ -592,7 +558,6 @@ func (t *TidalDownloader) SearchTrackByMetadataWithISRC(trackName, artistName, s
 	return bestMatch, nil
 }
 
-// containsQuery checks if a query already exists in the list
 func containsQuery(queries []string, query string) bool {
 	for _, q := range queries {
 		if q == query {
@@ -602,7 +567,6 @@ func containsQuery(queries []string, query string) bool {
 	return false
 }
 
-// SearchTrackByMetadata searches for a track using artist name and track name
 func (t *TidalDownloader) SearchTrackByMetadata(trackName, artistName string) (*TidalTrack, error) {
 	return t.SearchTrackByMetadataWithISRC(trackName, artistName, "", 0)
 }
@@ -614,7 +578,6 @@ type TidalDownloadInfo struct {
 	SampleRate int
 }
 
-// tidalAPIResult holds the result from a parallel API request
 type tidalAPIResult struct {
 	apiURL   string
 	info     TidalDownloadInfo
@@ -622,9 +585,7 @@ type tidalAPIResult struct {
 	duration time.Duration
 }
 
-// getDownloadURLParallel requests download URL from all APIs in parallel
 // Returns the first successful result (supports both v1 and v2 API formats)
-// "Siapa cepat dia dapat" - first success wins
 func getDownloadURLParallel(apis []string, trackID int64, quality string) (string, TidalDownloadInfo, error) {
 	if len(apis) == 0 {
 		return "", TidalDownloadInfo{}, fmt.Errorf("no APIs available")
@@ -639,9 +600,7 @@ func getDownloadURLParallel(apis []string, trackID int64, quality string) (strin
 		go func(api string) {
 			reqStart := time.Now()
 
-			client := &http.Client{
-				Timeout: 15 * time.Second,
-			}
+			client := NewHTTPClientWithTimeout(15 * time.Second)
 
 			reqURL := fmt.Sprintf("%s/track/?id=%d&quality=%s", api, trackID, quality)
 
@@ -671,8 +630,7 @@ func getDownloadURLParallel(apis []string, trackID int64, quality string) (strin
 
 			var v2Response TidalAPIResponseV2
 			if err := json.Unmarshal(body, &v2Response); err == nil && v2Response.Data.Manifest != "" {
-				// IMPORTANT: Reject PREVIEW responses - we need FULL tracks
-				if v2Response.Data.AssetPresentation == "PREVIEW" {
+						if v2Response.Data.AssetPresentation == "PREVIEW" {
 					resultChan <- tidalAPIResult{apiURL: api, err: fmt.Errorf("returned PREVIEW instead of FULL"), duration: time.Since(reqStart)}
 					return
 				}
@@ -715,7 +673,6 @@ func getDownloadURLParallel(apis []string, trackID int64, quality string) (strin
 			GoLog("[Tidal] [Parallel] ✓ Got response from %s (%d-bit/%dHz) in %v\n",
 				result.apiURL, result.info.BitDepth, result.info.SampleRate, result.duration)
 
-			// Don't return immediately - drain remaining results to avoid goroutine leaks
 			go func(remaining int) {
 				for j := 0; j < remaining; j++ {
 					<-resultChan
@@ -736,8 +693,6 @@ func getDownloadURLParallel(apis []string, trackID int64, quality string) (strin
 	return "", TidalDownloadInfo{}, fmt.Errorf("all %d Tidal 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 (t *TidalDownloader) GetDownloadURL(trackID int64, quality string) (TidalDownloadInfo, error) {
 	apis := t.GetAvailableAPIs()
 	if len(apis) == 0 {
@@ -752,7 +707,6 @@ func (t *TidalDownloader) GetDownloadURL(trackID int64, quality string) (TidalDo
 	return info, nil
 }
 
-// parseManifest parses Tidal manifest (supports both BTS and DASH formats)
 func parseManifest(manifestB64 string) (directURL string, initURL string, mediaURLs []string, err error) {
 	manifestBytes, err := base64.StdEncoding.DecodeString(manifestB64)
 	if err != nil {
@@ -859,7 +813,6 @@ func (t *TidalDownloader) DownloadFile(downloadURL, outputPath, itemID string) e
 		return t.downloadFromManifest(ctx, strings.TrimPrefix(downloadURL, "MANIFEST:"), outputPath, itemID)
 	}
 
-	// Initialize item progress for direct downloads
 	if itemID != "" {
 		StartItemProgress(itemID)
 		defer CompleteItemProgress(itemID)
@@ -946,15 +899,11 @@ func (t *TidalDownloader) downloadFromManifest(ctx context.Context, manifestB64,
 	GoLog("[Tidal] Manifest parsed - directURL: %v, initURL: %v, mediaURLs count: %d\n",
 		directURL != "", initURL != "", len(mediaURLs))
 
-	client := &http.Client{
-		Timeout: 120 * time.Second,
-	}
+	client := NewHTTPClientWithTimeout(120 * time.Second)
 
 	if directURL != "" {
 		GoLog("[Tidal] BTS format - downloading from direct URL: %s...\n", directURL[:min(80, len(directURL))])
-		// Note: Progress tracking is initialized by the caller (DownloadFile)
-
-		if isDownloadCancelled(itemID) {
+			if isDownloadCancelled(itemID) {
 			return ErrDownloadCancelled
 		}
 
@@ -1135,7 +1084,6 @@ func (t *TidalDownloader) downloadFromManifest(ctx context.Context, manifestB64,
 	return nil
 }
 
-// TidalDownloadResult contains download result with quality info
 type TidalDownloadResult struct {
 	FilePath    string
 	BitDepth    int
@@ -1149,12 +1097,10 @@ type TidalDownloadResult struct {
 	ISRC        string
 }
 
-// artistsMatch checks if the artist names are similar enough
 func artistsMatch(spotifyArtist, tidalArtist string) bool {
 	normSpotify := strings.ToLower(strings.TrimSpace(spotifyArtist))
 	normTidal := strings.ToLower(strings.TrimSpace(tidalArtist))
 
-	// Exact match
 	if normSpotify == normTidal {
 		return true
 	}
@@ -1164,22 +1110,17 @@ func artistsMatch(spotifyArtist, tidalArtist string) bool {
 		return true
 	}
 
-	// Split artists by common separators (comma, feat, ft., &, and)
-	// e.g., "RADWIMPS, Toko Miura" or "RADWIMPS feat. Toko Miura"
 	spotifyArtists := splitArtists(normSpotify)
 	tidalArtists := splitArtists(normTidal)
 
-	// Check if ANY expected artist matches ANY found artist
 	for _, exp := range spotifyArtists {
 		for _, fnd := range tidalArtists {
 			if exp == fnd {
 				return true
 			}
-			// Also check contains for partial matches
 			if strings.Contains(exp, fnd) || strings.Contains(fnd, exp) {
 				return true
 			}
-			// Check same words different order
 			if sameWordsUnordered(exp, fnd) {
 				GoLog("[Tidal] Artist names have same words in different order: '%s' vs '%s'\n", exp, fnd)
 				return true
@@ -1187,9 +1128,6 @@ func artistsMatch(spotifyArtist, tidalArtist string) bool {
 		}
 	}
 
-	// If scripts are TRULY different (Latin vs CJK/Arabic/Cyrillic), assume match (transliteration)
-	// Don't treat Latin Extended (Polish, French, etc.) as different script
-	// This handles cases like "鈴木雅之" vs "Masayuki Suzuki"
 	spotifyLatin := isLatinScript(spotifyArtist)
 	tidalLatin := isLatinScript(tidalArtist)
 	if spotifyLatin != tidalLatin {
@@ -1200,9 +1138,7 @@ func artistsMatch(spotifyArtist, tidalArtist string) bool {
 	return false
 }
 
-// splitArtists splits artist string by common separators
 func splitArtists(artists string) []string {
-	// Replace common separators with a standard one
 	normalized := artists
 	normalized = strings.ReplaceAll(normalized, " feat. ", "|")
 	normalized = strings.ReplaceAll(normalized, " feat ", "|")
@@ -1224,8 +1160,6 @@ func splitArtists(artists string) []string {
 	return result
 }
 
-// sameWordsUnordered checks if two strings have the same words regardless of order
-// Useful for Japanese names: "Sawano Hiroyuki" vs "Hiroyuki Sawano"
 func sameWordsUnordered(a, b string) bool {
 	wordsA := strings.Fields(a)
 	wordsB := strings.Fields(b)
@@ -1235,13 +1169,11 @@ func sameWordsUnordered(a, b string) bool {
 		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] {
@@ -1261,7 +1193,6 @@ func sameWordsUnordered(a, b string) bool {
 	return true
 }
 
-// titlesMatch checks if track titles are similar enough
 func titlesMatch(expectedTitle, foundTitle string) bool {
 	normExpected := strings.ToLower(strings.TrimSpace(expectedTitle))
 	normFound := strings.ToLower(strings.TrimSpace(foundTitle))
@@ -1271,7 +1202,6 @@ func titlesMatch(expectedTitle, foundTitle string) bool {
 		return true
 	}
 
-	// Check if one contains the other
 	if strings.Contains(normExpected, normFound) || strings.Contains(normFound, normExpected) {
 		return true
 	}
@@ -1284,7 +1214,6 @@ func titlesMatch(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
@@ -1299,7 +1228,6 @@ func titlesMatch(expectedTitle, foundTitle string) bool {
 		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 := isLatinScript(expectedTitle)
 	foundLatin := isLatinScript(foundTitle)
@@ -1311,9 +1239,7 @@ func titlesMatch(expectedTitle, foundTitle string) bool {
 	return false
 }
 
-// extractCoreTitle extracts the main title before any parentheses or brackets
 func extractCoreTitle(title string) string {
-	// Find first occurrence of ( or [
 	parenIdx := strings.Index(title, "(")
 	bracketIdx := strings.Index(title, "[")
 	dashIdx := strings.Index(title, " - ")
@@ -1332,18 +1258,15 @@ func extractCoreTitle(title string) string {
 	return strings.TrimSpace(title[:cutIdx])
 }
 
-// cleanTitle removes common suffixes from track titles for comparison
 func cleanTitle(title string) string {
 	cleaned := title
 
-	// Version indicators to remove from parentheses/brackets
 	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, ")")
@@ -1364,7 +1287,6 @@ func cleanTitle(title string) string {
 		break
 	}
 
-	// Same for brackets
 	for {
 		startBracket := strings.LastIndex(cleaned, "[")
 		endBracket := strings.LastIndex(cleaned, "]")
@@ -1385,7 +1307,6 @@ func cleanTitle(title string) string {
 		break
 	}
 
-	// Remove trailing " - version" patterns
 	dashPatterns := []string{
 		" - remaster", " - remastered", " - single version", " - radio edit",
 		" - live", " - acoustic", " - demo", " - remix",
@@ -1396,7 +1317,6 @@ func cleanTitle(title string) string {
 		}
 	}
 
-	// Remove multiple spaces
 	for strings.Contains(cleaned, "  ") {
 		cleaned = strings.ReplaceAll(cleaned, "  ", " ")
 	}
@@ -1404,48 +1324,29 @@ func cleanTitle(title string) string {
 	return strings.TrimSpace(cleaned)
 }
 
-// isLatinScript checks if a string is primarily Latin script
-// Returns true for ASCII and Latin Extended characters (European languages)
-// Returns false for CJK, Arabic, Cyrillic, etc.
 func isLatinScript(s string) bool {
 	for _, r := range s {
-		// Skip common punctuation and numbers
 		if r < 128 {
 			continue
 		}
-		// Latin Extended-A: U+0100 to U+017F (Polish, Czech, etc.)
-		// Latin Extended-B: U+0180 to U+024F
-		// Latin Extended Additional: U+1E00 to U+1EFF
-		if (r >= 0x0100 && r <= 0x024F) || // Latin Extended A & B
-			(r >= 0x1E00 && r <= 0x1EFF) || // Latin Extended Additional
-			(r >= 0x00C0 && r <= 0x00FF) { // Latin-1 Supplement (accented chars)
+		if (r >= 0x0100 && r <= 0x024F) ||
+			(r >= 0x1E00 && r <= 0x1EFF) ||
+			(r >= 0x00C0 && r <= 0x00FF) {
 			continue
 		}
-		// CJK ranges - definitely different script
-		if (r >= 0x4E00 && r <= 0x9FFF) || // CJK Unified Ideographs
-			(r >= 0x3040 && r <= 0x309F) || // Hiragana
-			(r >= 0x30A0 && r <= 0x30FF) || // Katakana
-			(r >= 0xAC00 && r <= 0xD7AF) || // Hangul (Korean)
-			(r >= 0x0600 && r <= 0x06FF) || // Arabic
-			(r >= 0x0400 && r <= 0x04FF) { // Cyrillic
+		if (r >= 0x4E00 && r <= 0x9FFF) ||
+			(r >= 0x3040 && r <= 0x309F) ||
+			(r >= 0x30A0 && r <= 0x30FF) ||
+			(r >= 0xAC00 && r <= 0xD7AF) ||
+			(r >= 0x0600 && r <= 0x06FF) ||
+			(r >= 0x0400 && r <= 0x04FF) {
 			return false
 		}
 	}
 	return true
 }
 
-// isASCIIString checks if a string contains only ASCII characters
-// Kept for potential future use
-// func isASCIIString(s string) bool {
-// 	for _, r := range s {
-// 		if r > 127 {
-// 			return false
-// 		}
-// 	}
-// 	return true
-// }
 
-// downloadFromTidal downloads a track using the request parameters
 func downloadFromTidal(req DownloadRequest) (TidalDownloadResult, error) {
 	downloader := NewTidalDownloader()
 
@@ -1453,16 +1354,13 @@ func downloadFromTidal(req DownloadRequest) (TidalDownloadResult, error) {
 		return TidalDownloadResult{FilePath: "EXISTS:" + existingFile}, nil
 	}
 
-	// Convert expected duration from ms to seconds
 	expectedDurationSec := req.DurationMS / 1000
 
 	var track *TidalTrack
 	var err error
 
-	// STRATEGY 0: Use pre-fetched Tidal ID from Odesli enrichment (highest priority)
 	if req.TidalID != "" {
 		GoLog("[Tidal] Using Tidal ID from Odesli enrichment: %s\n", req.TidalID)
-		// Parse track ID (could be a number or extracted from URL)
 		var trackID int64
 		if _, parseErr := fmt.Sscanf(req.TidalID, "%d", &trackID); parseErr == nil && trackID > 0 {
 			track, err = downloader.GetTrackInfoByID(trackID)
@@ -1475,7 +1373,6 @@ func downloadFromTidal(req DownloadRequest) (TidalDownloadResult, error) {
 		}
 	}
 
-	// OPTIMIZATION: Check cache first for track ID
 	if track == nil && req.ISRC != "" {
 		if cached := GetTrackIDCache().Get(req.ISRC); cached != nil && cached.TidalTrackID > 0 {
 			GoLog("[Tidal] Cache hit! Using cached track ID: %d\n", cached.TidalTrackID)
@@ -1487,8 +1384,6 @@ func downloadFromTidal(req DownloadRequest) (TidalDownloadResult, error) {
 		}
 	}
 
-	// OPTIMIZED: Try ISRC search with metadata (search by name, filter by ISRC)
-	// Strategy 1: Search by metadata, match by ISRC (most accurate)
 	if track == nil && req.ISRC != "" {
 		GoLog("[Tidal] Trying ISRC search: %s\n", req.ISRC)
 		track, err = downloader.SearchTrackByMetadataWithISRC(req.TrackName, req.ArtistName, req.ISRC, expectedDurationSec)
@@ -1510,7 +1405,6 @@ func downloadFromTidal(req DownloadRequest) (TidalDownloadResult, error) {
 		}
 	}
 
-	// Strategy 2: Try SongLink if we have Spotify ID
 	if track == nil && req.SpotifyID != "" {
 		GoLog("[Tidal] ISRC search failed, trying SongLink...\n")
 		var tidalURL string
@@ -1545,13 +1439,11 @@ func downloadFromTidal(req DownloadRequest) (TidalDownloadResult, error) {
 						track = nil
 					}
 
-					// Verify duration if we have expected duration
 					if track != nil && expectedDurationSec > 0 {
 						durationDiff := track.Duration - expectedDurationSec
 						if durationDiff < 0 {
 							durationDiff = -durationDiff
 						}
-						// Allow 3 seconds tolerance (same as PC version)
 						if durationDiff > 3 {
 							GoLog("[Tidal] Duration mismatch from SongLink: expected %ds, got %ds. Rejecting.\n",
 								expectedDurationSec, track.Duration)
@@ -1563,11 +1455,9 @@ func downloadFromTidal(req DownloadRequest) (TidalDownloadResult, error) {
 		}
 	}
 
-	// Strategy 3: Search by metadata only (no ISRC requirement) - last resort
 	if track == nil {
 		GoLog("[Tidal] Trying metadata search as last resort...\n")
 		track, err = downloader.SearchTrackByMetadataWithISRC(req.TrackName, req.ArtistName, "", expectedDurationSec)
-		// Verify artist AND title for metadata search
 		if track != nil {
 			tidalArtist := track.Artist.Name
 			if len(track.Artists) > 0 {
@@ -1578,7 +1468,6 @@ func downloadFromTidal(req DownloadRequest) (TidalDownloadResult, error) {
 				tidalArtist = strings.Join(artistNames, ", ")
 			}
 
-			// Verify title first
 			if !titlesMatch(req.TrackName, track.Title) {
 				GoLog("[Tidal] Title mismatch from metadata search: expected '%s', got '%s'. Rejecting.\n",
 					req.TrackName, track.Title)
@@ -1599,7 +1488,6 @@ func downloadFromTidal(req DownloadRequest) (TidalDownloadResult, error) {
 		return TidalDownloadResult{}, fmt.Errorf("tidal search failed: %s", errMsg)
 	}
 
-	// Final verification logging
 	tidalArtist := track.Artist.Name
 	if len(track.Artists) > 0 {
 		var artistNames []string
@@ -1633,7 +1521,6 @@ func downloadFromTidal(req DownloadRequest) (TidalDownloadResult, error) {
 		return TidalDownloadResult{FilePath: "EXISTS:" + m4aPath}, nil
 	}
 
-	// Clean up any leftover .tmp files from previous failed downloads
 	tmpPath := outputPath + ".m4a.tmp"
 	if _, err := os.Stat(tmpPath); err == nil {
 		GoLog("[Tidal] Cleaning up leftover temp file: %s\n", tmpPath)
@@ -1651,10 +1538,8 @@ func downloadFromTidal(req DownloadRequest) (TidalDownloadResult, error) {
 		return TidalDownloadResult{}, fmt.Errorf("failed to get download URL: %w", err)
 	}
 
-	// Log actual quality received
 	GoLog("[Tidal] Actual quality: %d-bit/%dHz\n", downloadInfo.BitDepth, downloadInfo.SampleRate)
 
-	// START PARALLEL: Fetch cover and lyrics while downloading audio
 	var parallelResult *ParallelDownloadResult
 	parallelDone := make(chan struct{})
 	go func() {
@@ -1670,7 +1555,6 @@ func downloadFromTidal(req DownloadRequest) (TidalDownloadResult, error) {
 		)
 	}()
 
-	// Download audio file with item ID for progress tracking
 	GoLog("[Tidal] Starting download to: %s\n", outputPath)
 	GoLog("[Tidal] Download URL type: %s\n", func() string {
 		if strings.HasPrefix(downloadInfo.URL, "MANIFEST:") {
@@ -1688,7 +1572,6 @@ func downloadFromTidal(req DownloadRequest) (TidalDownloadResult, error) {
 	}
 	fmt.Println("[Tidal] Download completed successfully")
 
-	// Wait for parallel operations to complete
 	<-parallelDone
 
 	if req.ItemID != "" {
@@ -1701,24 +1584,28 @@ func downloadFromTidal(req DownloadRequest) (TidalDownloadResult, error) {
 		actualOutputPath = m4aPath
 		GoLog("[Tidal] File saved as M4A (DASH stream): %s\n", actualOutputPath)
 	} else if _, err := os.Stat(outputPath); err != nil {
-		// Neither FLAC nor M4A exists
 		return TidalDownloadResult{}, fmt.Errorf("download completed but file not found at %s or %s", outputPath, m4aPath)
 	}
 
-	// Embed metadata using parallel-fetched cover data
+	releaseDate := req.ReleaseDate
+	if releaseDate == "" && track.Album.ReleaseDate != "" {
+		releaseDate = track.Album.ReleaseDate
+		GoLog("[Tidal] Using release date from Tidal API: %s\n", releaseDate)
+	}
+
 	metadata := Metadata{
 		Title:       req.TrackName,
 		Artist:      req.ArtistName,
 		Album:       req.AlbumName,
 		AlbumArtist: req.AlbumArtist,
-		Date:        req.ReleaseDate,
-		TrackNumber: track.TrackNumber, // Use actual track number from Tidal
+		Date:        releaseDate,
+		TrackNumber: track.TrackNumber,
 		TotalTracks: req.TotalTracks,
-		DiscNumber:  track.VolumeNumber, // Use actual disc number from Tidal
-		ISRC:        track.ISRC,         // Use actual ISRC from Tidal
-		Genre:       req.Genre,          // From Deezer album metadata
-		Label:       req.Label,          // From Deezer album metadata
-		Copyright:   req.Copyright,      // From Deezer album metadata
+		DiscNumber:  track.VolumeNumber,
+		ISRC:        track.ISRC,
+		Genre:       req.Genre,
+		Label:       req.Label,
+		Copyright:   req.Copyright,
 	}
 
 	var coverData []byte
@@ -1727,46 +1614,41 @@ func downloadFromTidal(req DownloadRequest) (TidalDownloadResult, error) {
 		GoLog("[Tidal] Using parallel-fetched cover (%d bytes)\n", len(coverData))
 	}
 
-	// Embed metadata based on file type
 	if strings.HasSuffix(actualOutputPath, ".flac") {
 		if err := EmbedMetadataWithCoverData(actualOutputPath, metadata, coverData); err != nil {
 			fmt.Printf("Warning: failed to embed metadata: %v\n", err)
 		}
 
-		// Embed lyrics from parallel fetch
 		if req.EmbedLyrics && parallelResult != nil && parallelResult.LyricsLRC != "" {
-			GoLog("[Tidal] Embedding parallel-fetched lyrics (%d lines)...\n", len(parallelResult.LyricsData.Lines))
-			if embedErr := EmbedLyrics(actualOutputPath, parallelResult.LyricsLRC); embedErr != nil {
-				GoLog("[Tidal] Warning: failed to embed lyrics: %v\n", embedErr)
-			} else {
-				fmt.Println("[Tidal] Lyrics embedded successfully")
+			lyricsMode := req.LyricsMode
+			if lyricsMode == "" {
+				lyricsMode = "embed"
+			}
+
+			if lyricsMode == "external" || lyricsMode == "both" {
+				GoLog("[Tidal] Saving external LRC file...\n")
+				if lrcPath, lrcErr := SaveLRCFile(actualOutputPath, parallelResult.LyricsLRC); lrcErr != nil {
+					GoLog("[Tidal] Warning: failed to save LRC file: %v\n", lrcErr)
+				} else {
+					GoLog("[Tidal] LRC file saved: %s\n", lrcPath)
+				}
+			}
+
+			if lyricsMode == "embed" || lyricsMode == "both" {
+				GoLog("[Tidal] Embedding parallel-fetched lyrics (%d lines)...\n", len(parallelResult.LyricsData.Lines))
+				if embedErr := EmbedLyrics(actualOutputPath, parallelResult.LyricsLRC); embedErr != nil {
+					GoLog("[Tidal] Warning: failed to embed lyrics: %v\n", embedErr)
+				} else {
+					fmt.Println("[Tidal] Lyrics embedded successfully")
+				}
 			}
 		} else if req.EmbedLyrics {
 			fmt.Println("[Tidal] No lyrics available from parallel fetch")
 		}
 	} else if strings.HasSuffix(actualOutputPath, ".m4a") {
-		// Embed metadata to M4A file
-		// GoLog("[Tidal] Embedding metadata to M4A file...\n")
-
-		// Add lyrics to metadata if available
-		// if req.EmbedLyrics && parallelResult != nil && parallelResult.LyricsLRC != "" {
-		// 	metadata.Lyrics = parallelResult.LyricsLRC
-		// }
-
-		// SKIP metadata embedding for M4A to prevent issues with FFmpeg conversion
-		// M4A files from DASH are often fragmented and editing metadata might corrupt the container
-		// structure that FFmpeg expects. Metadata will be re-embedded after conversion to FLAC in Flutter.
-
 		fmt.Println("[Tidal] Skipping metadata embedding for M4A file (will be handled after FFmpeg conversion)")
-
-		// if err := EmbedM4AMetadata(actualOutputPath, metadata, coverData); err != nil {
-		// 	GoLog("[Tidal] Warning: failed to embed M4A metadata: %v\n", err)
-		// } else {
-		// 	fmt.Println("[Tidal] M4A metadata embedded successfully")
-		// }
 	}
 
-	// Add to ISRC index for fast duplicate checking
 	AddToISRCIndex(req.OutputDir, req.ISRC, actualOutputPath)
 
 	return TidalDownloadResult{

lib/app.dart

@@ -36,7 +36,12 @@ class SpotiFLACApp extends ConsumerWidget {
     
     Locale? locale;
     if (localeString != 'system') {
-      locale = Locale(localeString);
+      if (localeString.contains('_')) {
+        final parts = localeString.split('_');
+        locale = Locale(parts[0], parts[1]);
+      } else {
+        locale = Locale(localeString);
+      }
     }
     
     return DynamicColorWrapper(

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.1.2';
-  static const String buildNumber = '61';
+  static const String version = '3.1.3';
+  static const String buildNumber = '62';
   static const String fullVersion = '$version+$buildNumber';
   
   

lib/l10n/app_localizations.dart

@@ -1688,6 +1688,12 @@ abstract class AppLocalizations {
   /// **'Found {count} tracks in CSV. Add them to download queue?'**
   String dialogImportPlaylistMessage(int count);
 
+  /// Label shown in quality picker for CSV import
+  ///
+  /// In en, this message translates to:
+  /// **'{count} tracks from CSV'**
+  String csvImportTracks(int count);
+
   /// Snackbar - track added to download queue
   ///
   /// In en, this message translates to:
@@ -2612,6 +2618,60 @@ abstract class AppLocalizations {
   /// **'File Settings'**
   String get sectionFileSettings;
 
+  /// Settings section header
+  ///
+  /// In en, this message translates to:
+  /// **'Lyrics'**
+  String get sectionLyrics;
+
+  /// Setting - how to save lyrics
+  ///
+  /// In en, this message translates to:
+  /// **'Lyrics Mode'**
+  String get lyricsMode;
+
+  /// Lyrics mode picker description
+  ///
+  /// In en, this message translates to:
+  /// **'Choose how lyrics are saved with your downloads'**
+  String get lyricsModeDescription;
+
+  /// Lyrics mode option - embed in audio file
+  ///
+  /// In en, this message translates to:
+  /// **'Embed in file'**
+  String get lyricsModeEmbed;
+
+  /// Subtitle for embed option
+  ///
+  /// In en, this message translates to:
+  /// **'Lyrics stored inside FLAC metadata'**
+  String get lyricsModeEmbedSubtitle;
+
+  /// Lyrics mode option - separate LRC file
+  ///
+  /// In en, this message translates to:
+  /// **'External .lrc file'**
+  String get lyricsModeExternal;
+
+  /// Subtitle for external option
+  ///
+  /// In en, this message translates to:
+  /// **'Separate .lrc file for players like Samsung Music'**
+  String get lyricsModeExternalSubtitle;
+
+  /// Lyrics mode option - embed and external
+  ///
+  /// In en, this message translates to:
+  /// **'Both'**
+  String get lyricsModeBoth;
+
+  /// Subtitle for both option
+  ///
+  /// In en, this message translates to:
+  /// **'Embed and save .lrc file'**
+  String get lyricsModeBothSubtitle;
+
   /// Settings section header
   ///
   /// In en, this message translates to:
@@ -2816,6 +2876,24 @@ abstract class AppLocalizations {
   /// **'Release date'**
   String get trackReleaseDate;
 
+  /// Metadata label - music genre
+  ///
+  /// In en, this message translates to:
+  /// **'Genre'**
+  String get trackGenre;
+
+  /// Metadata label - record label
+  ///
+  /// In en, this message translates to:
+  /// **'Label'**
+  String get trackLabel;
+
+  /// Metadata label - copyright information
+  ///
+  /// In en, this message translates to:
+  /// **'Copyright'**
+  String get trackCopyright;
+
   /// Metadata label - download date
   ///
   /// In en, this message translates to:

lib/l10n/app_localizations_de.dart

@@ -910,6 +910,11 @@ class AppLocalizationsDe extends AppLocalizations {
     return 'Found $count tracks in CSV. Add them to download queue?';
   }
 
+  @override
+  String csvImportTracks(int count) {
+    return '$count tracks from CSV';
+  }
+
   @override
   String snackbarAddedToQueue(String trackName) {
     return 'Added \"$trackName\" to queue';
@@ -1443,6 +1448,35 @@ class AppLocalizationsDe extends AppLocalizations {
   @override
   String get sectionFileSettings => 'File Settings';
 
+  @override
+  String get sectionLyrics => 'Lyrics';
+
+  @override
+  String get lyricsMode => 'Lyrics Mode';
+
+  @override
+  String get lyricsModeDescription =>
+      'Choose how lyrics are saved with your downloads';
+
+  @override
+  String get lyricsModeEmbed => 'Embed in file';
+
+  @override
+  String get lyricsModeEmbedSubtitle => 'Lyrics stored inside FLAC metadata';
+
+  @override
+  String get lyricsModeExternal => 'External .lrc file';
+
+  @override
+  String get lyricsModeExternalSubtitle =>
+      'Separate .lrc file for players like Samsung Music';
+
+  @override
+  String get lyricsModeBoth => 'Both';
+
+  @override
+  String get lyricsModeBothSubtitle => 'Embed and save .lrc file';
+
   @override
   String get sectionColor => 'Color';
 
@@ -1555,6 +1589,15 @@ class AppLocalizationsDe extends AppLocalizations {
   @override
   String get trackReleaseDate => 'Release date';
 
+  @override
+  String get trackGenre => 'Genre';
+
+  @override
+  String get trackLabel => 'Label';
+
+  @override
+  String get trackCopyright => 'Copyright';
+
   @override
   String get trackDownloaded => 'Downloaded';
 

lib/l10n/app_localizations_en.dart

@@ -897,6 +897,11 @@ class AppLocalizationsEn extends AppLocalizations {
     return 'Found $count tracks in CSV. Add them to download queue?';
   }
 
+  @override
+  String csvImportTracks(int count) {
+    return '$count tracks from CSV';
+  }
+
   @override
   String snackbarAddedToQueue(String trackName) {
     return 'Added \"$trackName\" to queue';
@@ -1430,6 +1435,35 @@ class AppLocalizationsEn extends AppLocalizations {
   @override
   String get sectionFileSettings => 'File Settings';
 
+  @override
+  String get sectionLyrics => 'Lyrics';
+
+  @override
+  String get lyricsMode => 'Lyrics Mode';
+
+  @override
+  String get lyricsModeDescription =>
+      'Choose how lyrics are saved with your downloads';
+
+  @override
+  String get lyricsModeEmbed => 'Embed in file';
+
+  @override
+  String get lyricsModeEmbedSubtitle => 'Lyrics stored inside FLAC metadata';
+
+  @override
+  String get lyricsModeExternal => 'External .lrc file';
+
+  @override
+  String get lyricsModeExternalSubtitle =>
+      'Separate .lrc file for players like Samsung Music';
+
+  @override
+  String get lyricsModeBoth => 'Both';
+
+  @override
+  String get lyricsModeBothSubtitle => 'Embed and save .lrc file';
+
   @override
   String get sectionColor => 'Color';
 
@@ -1542,6 +1576,15 @@ class AppLocalizationsEn extends AppLocalizations {
   @override
   String get trackReleaseDate => 'Release date';
 
+  @override
+  String get trackGenre => 'Genre';
+
+  @override
+  String get trackLabel => 'Label';
+
+  @override
+  String get trackCopyright => 'Copyright';
+
   @override
   String get trackDownloaded => 'Downloaded';
 

lib/l10n/app_localizations_es.dart

@@ -897,6 +897,11 @@ class AppLocalizationsEs extends AppLocalizations {
     return 'Found $count tracks in CSV. Add them to download queue?';
   }
 
+  @override
+  String csvImportTracks(int count) {
+    return '$count tracks from CSV';
+  }
+
   @override
   String snackbarAddedToQueue(String trackName) {
     return 'Added \"$trackName\" to queue';
@@ -1430,6 +1435,35 @@ class AppLocalizationsEs extends AppLocalizations {
   @override
   String get sectionFileSettings => 'File Settings';
 
+  @override
+  String get sectionLyrics => 'Lyrics';
+
+  @override
+  String get lyricsMode => 'Lyrics Mode';
+
+  @override
+  String get lyricsModeDescription =>
+      'Choose how lyrics are saved with your downloads';
+
+  @override
+  String get lyricsModeEmbed => 'Embed in file';
+
+  @override
+  String get lyricsModeEmbedSubtitle => 'Lyrics stored inside FLAC metadata';
+
+  @override
+  String get lyricsModeExternal => 'External .lrc file';
+
+  @override
+  String get lyricsModeExternalSubtitle =>
+      'Separate .lrc file for players like Samsung Music';
+
+  @override
+  String get lyricsModeBoth => 'Both';
+
+  @override
+  String get lyricsModeBothSubtitle => 'Embed and save .lrc file';
+
   @override
   String get sectionColor => 'Color';
 
@@ -1542,6 +1576,15 @@ class AppLocalizationsEs extends AppLocalizations {
   @override
   String get trackReleaseDate => 'Release date';
 
+  @override
+  String get trackGenre => 'Genre';
+
+  @override
+  String get trackLabel => 'Label';
+
+  @override
+  String get trackCopyright => 'Copyright';
+
   @override
   String get trackDownloaded => 'Downloaded';
 

lib/l10n/app_localizations_fr.dart

@@ -897,6 +897,11 @@ class AppLocalizationsFr extends AppLocalizations {
     return 'Found $count tracks in CSV. Add them to download queue?';
   }
 
+  @override
+  String csvImportTracks(int count) {
+    return '$count tracks from CSV';
+  }
+
   @override
   String snackbarAddedToQueue(String trackName) {
     return 'Added \"$trackName\" to queue';
@@ -1430,6 +1435,35 @@ class AppLocalizationsFr extends AppLocalizations {
   @override
   String get sectionFileSettings => 'File Settings';
 
+  @override
+  String get sectionLyrics => 'Lyrics';
+
+  @override
+  String get lyricsMode => 'Lyrics Mode';
+
+  @override
+  String get lyricsModeDescription =>
+      'Choose how lyrics are saved with your downloads';
+
+  @override
+  String get lyricsModeEmbed => 'Embed in file';
+
+  @override
+  String get lyricsModeEmbedSubtitle => 'Lyrics stored inside FLAC metadata';
+
+  @override
+  String get lyricsModeExternal => 'External .lrc file';
+
+  @override
+  String get lyricsModeExternalSubtitle =>
+      'Separate .lrc file for players like Samsung Music';
+
+  @override
+  String get lyricsModeBoth => 'Both';
+
+  @override
+  String get lyricsModeBothSubtitle => 'Embed and save .lrc file';
+
   @override
   String get sectionColor => 'Color';
 
@@ -1542,6 +1576,15 @@ class AppLocalizationsFr extends AppLocalizations {
   @override
   String get trackReleaseDate => 'Release date';
 
+  @override
+  String get trackGenre => 'Genre';
+
+  @override
+  String get trackLabel => 'Label';
+
+  @override
+  String get trackCopyright => 'Copyright';
+
   @override
   String get trackDownloaded => 'Downloaded';
 

lib/l10n/app_localizations_hi.dart

@@ -897,6 +897,11 @@ class AppLocalizationsHi extends AppLocalizations {
     return 'Found $count tracks in CSV. Add them to download queue?';
   }
 
+  @override
+  String csvImportTracks(int count) {
+    return '$count tracks from CSV';
+  }
+
   @override
   String snackbarAddedToQueue(String trackName) {
     return 'Added \"$trackName\" to queue';
@@ -1430,6 +1435,35 @@ class AppLocalizationsHi extends AppLocalizations {
   @override
   String get sectionFileSettings => 'File Settings';
 
+  @override
+  String get sectionLyrics => 'Lyrics';
+
+  @override
+  String get lyricsMode => 'Lyrics Mode';
+
+  @override
+  String get lyricsModeDescription =>
+      'Choose how lyrics are saved with your downloads';
+
+  @override
+  String get lyricsModeEmbed => 'Embed in file';
+
+  @override
+  String get lyricsModeEmbedSubtitle => 'Lyrics stored inside FLAC metadata';
+
+  @override
+  String get lyricsModeExternal => 'External .lrc file';
+
+  @override
+  String get lyricsModeExternalSubtitle =>
+      'Separate .lrc file for players like Samsung Music';
+
+  @override
+  String get lyricsModeBoth => 'Both';
+
+  @override
+  String get lyricsModeBothSubtitle => 'Embed and save .lrc file';
+
   @override
   String get sectionColor => 'Color';
 
@@ -1542,6 +1576,15 @@ class AppLocalizationsHi extends AppLocalizations {
   @override
   String get trackReleaseDate => 'Release date';
 
+  @override
+  String get trackGenre => 'Genre';
+
+  @override
+  String get trackLabel => 'Label';
+
+  @override
+  String get trackCopyright => 'Copyright';
+
   @override
   String get trackDownloaded => 'Downloaded';
 

lib/l10n/app_localizations_id.dart

@@ -903,6 +903,11 @@ class AppLocalizationsId extends AppLocalizations {
     return 'Ditemukan $count lagu di CSV. Tambahkan ke antrian unduhan?';
   }
 
+  @override
+  String csvImportTracks(int count) {
+    return '$count tracks from CSV';
+  }
+
   @override
   String snackbarAddedToQueue(String trackName) {
     return 'Menambahkan \"$trackName\" ke antrian';
@@ -1440,6 +1445,35 @@ class AppLocalizationsId extends AppLocalizations {
   @override
   String get sectionFileSettings => 'Pengaturan File';
 
+  @override
+  String get sectionLyrics => 'Lyrics';
+
+  @override
+  String get lyricsMode => 'Lyrics Mode';
+
+  @override
+  String get lyricsModeDescription =>
+      'Choose how lyrics are saved with your downloads';
+
+  @override
+  String get lyricsModeEmbed => 'Embed in file';
+
+  @override
+  String get lyricsModeEmbedSubtitle => 'Lyrics stored inside FLAC metadata';
+
+  @override
+  String get lyricsModeExternal => 'External .lrc file';
+
+  @override
+  String get lyricsModeExternalSubtitle =>
+      'Separate .lrc file for players like Samsung Music';
+
+  @override
+  String get lyricsModeBoth => 'Both';
+
+  @override
+  String get lyricsModeBothSubtitle => 'Embed and save .lrc file';
+
   @override
   String get sectionColor => 'Warna';
 
@@ -1552,6 +1586,15 @@ class AppLocalizationsId extends AppLocalizations {
   @override
   String get trackReleaseDate => 'Tanggal rilis';
 
+  @override
+  String get trackGenre => 'Genre';
+
+  @override
+  String get trackLabel => 'Label';
+
+  @override
+  String get trackCopyright => 'Copyright';
+
   @override
   String get trackDownloaded => 'Diunduh';
 

lib/l10n/app_localizations_ja.dart

@@ -897,6 +897,11 @@ class AppLocalizationsJa extends AppLocalizations {
     return 'Found $count tracks in CSV. Add them to download queue?';
   }
 
+  @override
+  String csvImportTracks(int count) {
+    return '$count tracks from CSV';
+  }
+
   @override
   String snackbarAddedToQueue(String trackName) {
     return 'Added \"$trackName\" to queue';
@@ -1430,6 +1435,35 @@ class AppLocalizationsJa extends AppLocalizations {
   @override
   String get sectionFileSettings => 'File Settings';
 
+  @override
+  String get sectionLyrics => 'Lyrics';
+
+  @override
+  String get lyricsMode => 'Lyrics Mode';
+
+  @override
+  String get lyricsModeDescription =>
+      'Choose how lyrics are saved with your downloads';
+
+  @override
+  String get lyricsModeEmbed => 'Embed in file';
+
+  @override
+  String get lyricsModeEmbedSubtitle => 'Lyrics stored inside FLAC metadata';
+
+  @override
+  String get lyricsModeExternal => 'External .lrc file';
+
+  @override
+  String get lyricsModeExternalSubtitle =>
+      'Separate .lrc file for players like Samsung Music';
+
+  @override
+  String get lyricsModeBoth => 'Both';
+
+  @override
+  String get lyricsModeBothSubtitle => 'Embed and save .lrc file';
+
   @override
   String get sectionColor => 'Color';
 
@@ -1542,6 +1576,15 @@ class AppLocalizationsJa extends AppLocalizations {
   @override
   String get trackReleaseDate => 'Release date';
 
+  @override
+  String get trackGenre => 'Genre';
+
+  @override
+  String get trackLabel => 'Label';
+
+  @override
+  String get trackCopyright => 'Copyright';
+
   @override
   String get trackDownloaded => 'Downloaded';
 

lib/l10n/app_localizations_ko.dart

@@ -897,6 +897,11 @@ class AppLocalizationsKo extends AppLocalizations {
     return 'Found $count tracks in CSV. Add them to download queue?';
   }
 
+  @override
+  String csvImportTracks(int count) {
+    return '$count tracks from CSV';
+  }
+
   @override
   String snackbarAddedToQueue(String trackName) {
     return 'Added \"$trackName\" to queue';
@@ -1430,6 +1435,35 @@ class AppLocalizationsKo extends AppLocalizations {
   @override
   String get sectionFileSettings => 'File Settings';
 
+  @override
+  String get sectionLyrics => 'Lyrics';
+
+  @override
+  String get lyricsMode => 'Lyrics Mode';
+
+  @override
+  String get lyricsModeDescription =>
+      'Choose how lyrics are saved with your downloads';
+
+  @override
+  String get lyricsModeEmbed => 'Embed in file';
+
+  @override
+  String get lyricsModeEmbedSubtitle => 'Lyrics stored inside FLAC metadata';
+
+  @override
+  String get lyricsModeExternal => 'External .lrc file';
+
+  @override
+  String get lyricsModeExternalSubtitle =>
+      'Separate .lrc file for players like Samsung Music';
+
+  @override
+  String get lyricsModeBoth => 'Both';
+
+  @override
+  String get lyricsModeBothSubtitle => 'Embed and save .lrc file';
+
   @override
   String get sectionColor => 'Color';
 
@@ -1542,6 +1576,15 @@ class AppLocalizationsKo extends AppLocalizations {
   @override
   String get trackReleaseDate => 'Release date';
 
+  @override
+  String get trackGenre => 'Genre';
+
+  @override
+  String get trackLabel => 'Label';
+
+  @override
+  String get trackCopyright => 'Copyright';
+
   @override
   String get trackDownloaded => 'Downloaded';
 

lib/l10n/app_localizations_nl.dart

@@ -897,6 +897,11 @@ class AppLocalizationsNl extends AppLocalizations {
     return 'Found $count tracks in CSV. Add them to download queue?';
   }
 
+  @override
+  String csvImportTracks(int count) {
+    return '$count tracks from CSV';
+  }
+
   @override
   String snackbarAddedToQueue(String trackName) {
     return 'Added \"$trackName\" to queue';
@@ -1430,6 +1435,35 @@ class AppLocalizationsNl extends AppLocalizations {
   @override
   String get sectionFileSettings => 'File Settings';
 
+  @override
+  String get sectionLyrics => 'Lyrics';
+
+  @override
+  String get lyricsMode => 'Lyrics Mode';
+
+  @override
+  String get lyricsModeDescription =>
+      'Choose how lyrics are saved with your downloads';
+
+  @override
+  String get lyricsModeEmbed => 'Embed in file';
+
+  @override
+  String get lyricsModeEmbedSubtitle => 'Lyrics stored inside FLAC metadata';
+
+  @override
+  String get lyricsModeExternal => 'External .lrc file';
+
+  @override
+  String get lyricsModeExternalSubtitle =>
+      'Separate .lrc file for players like Samsung Music';
+
+  @override
+  String get lyricsModeBoth => 'Both';
+
+  @override
+  String get lyricsModeBothSubtitle => 'Embed and save .lrc file';
+
   @override
   String get sectionColor => 'Color';
 
@@ -1542,6 +1576,15 @@ class AppLocalizationsNl extends AppLocalizations {
   @override
   String get trackReleaseDate => 'Release date';
 
+  @override
+  String get trackGenre => 'Genre';
+
+  @override
+  String get trackLabel => 'Label';
+
+  @override
+  String get trackCopyright => 'Copyright';
+
   @override
   String get trackDownloaded => 'Downloaded';
 

lib/l10n/app_localizations_pt.dart

@@ -897,6 +897,11 @@ class AppLocalizationsPt extends AppLocalizations {
     return 'Found $count tracks in CSV. Add them to download queue?';
   }
 
+  @override
+  String csvImportTracks(int count) {
+    return '$count tracks from CSV';
+  }
+
   @override
   String snackbarAddedToQueue(String trackName) {
     return 'Added \"$trackName\" to queue';
@@ -1430,6 +1435,35 @@ class AppLocalizationsPt extends AppLocalizations {
   @override
   String get sectionFileSettings => 'File Settings';
 
+  @override
+  String get sectionLyrics => 'Lyrics';
+
+  @override
+  String get lyricsMode => 'Lyrics Mode';
+
+  @override
+  String get lyricsModeDescription =>
+      'Choose how lyrics are saved with your downloads';
+
+  @override
+  String get lyricsModeEmbed => 'Embed in file';
+
+  @override
+  String get lyricsModeEmbedSubtitle => 'Lyrics stored inside FLAC metadata';
+
+  @override
+  String get lyricsModeExternal => 'External .lrc file';
+
+  @override
+  String get lyricsModeExternalSubtitle =>
+      'Separate .lrc file for players like Samsung Music';
+
+  @override
+  String get lyricsModeBoth => 'Both';
+
+  @override
+  String get lyricsModeBothSubtitle => 'Embed and save .lrc file';
+
   @override
   String get sectionColor => 'Color';
 
@@ -1542,6 +1576,15 @@ class AppLocalizationsPt extends AppLocalizations {
   @override
   String get trackReleaseDate => 'Release date';
 
+  @override
+  String get trackGenre => 'Genre';
+
+  @override
+  String get trackLabel => 'Label';
+
+  @override
+  String get trackCopyright => 'Copyright';
+
   @override
   String get trackDownloaded => 'Downloaded';
 

lib/l10n/app_localizations_ru.dart

@@ -919,6 +919,11 @@ class AppLocalizationsRu extends AppLocalizations {
     return 'Найдено $count треков в CSV. Добавить их в очередь загрузки?';
   }
 
+  @override
+  String csvImportTracks(int count) {
+    return '$count tracks from CSV';
+  }
+
   @override
   String snackbarAddedToQueue(String trackName) {
     return '\"$trackName\" добавлен в очередь';
@@ -1458,6 +1463,35 @@ class AppLocalizationsRu extends AppLocalizations {
   @override
   String get sectionFileSettings => 'Настройки файла';
 
+  @override
+  String get sectionLyrics => 'Lyrics';
+
+  @override
+  String get lyricsMode => 'Lyrics Mode';
+
+  @override
+  String get lyricsModeDescription =>
+      'Choose how lyrics are saved with your downloads';
+
+  @override
+  String get lyricsModeEmbed => 'Embed in file';
+
+  @override
+  String get lyricsModeEmbedSubtitle => 'Lyrics stored inside FLAC metadata';
+
+  @override
+  String get lyricsModeExternal => 'External .lrc file';
+
+  @override
+  String get lyricsModeExternalSubtitle =>
+      'Separate .lrc file for players like Samsung Music';
+
+  @override
+  String get lyricsModeBoth => 'Both';
+
+  @override
+  String get lyricsModeBothSubtitle => 'Embed and save .lrc file';
+
   @override
   String get sectionColor => 'Цвет';
 
@@ -1574,6 +1608,15 @@ class AppLocalizationsRu extends AppLocalizations {
   @override
   String get trackReleaseDate => 'Дата выхода';
 
+  @override
+  String get trackGenre => 'Genre';
+
+  @override
+  String get trackLabel => 'Label';
+
+  @override
+  String get trackCopyright => 'Copyright';
+
   @override
   String get trackDownloaded => 'Скачано';
 

lib/l10n/app_localizations_zh.dart

@@ -897,6 +897,11 @@ class AppLocalizationsZh extends AppLocalizations {
     return 'Found $count tracks in CSV. Add them to download queue?';
   }
 
+  @override
+  String csvImportTracks(int count) {
+    return '$count tracks from CSV';
+  }
+
   @override
   String snackbarAddedToQueue(String trackName) {
     return 'Added \"$trackName\" to queue';
@@ -1430,6 +1435,35 @@ class AppLocalizationsZh extends AppLocalizations {
   @override
   String get sectionFileSettings => 'File Settings';
 
+  @override
+  String get sectionLyrics => 'Lyrics';
+
+  @override
+  String get lyricsMode => 'Lyrics Mode';
+
+  @override
+  String get lyricsModeDescription =>
+      'Choose how lyrics are saved with your downloads';
+
+  @override
+  String get lyricsModeEmbed => 'Embed in file';
+
+  @override
+  String get lyricsModeEmbedSubtitle => 'Lyrics stored inside FLAC metadata';
+
+  @override
+  String get lyricsModeExternal => 'External .lrc file';
+
+  @override
+  String get lyricsModeExternalSubtitle =>
+      'Separate .lrc file for players like Samsung Music';
+
+  @override
+  String get lyricsModeBoth => 'Both';
+
+  @override
+  String get lyricsModeBothSubtitle => 'Embed and save .lrc file';
+
   @override
   String get sectionColor => 'Color';
 
@@ -1542,6 +1576,15 @@ class AppLocalizationsZh extends AppLocalizations {
   @override
   String get trackReleaseDate => 'Release date';
 
+  @override
+  String get trackGenre => 'Genre';
+
+  @override
+  String get trackLabel => 'Label';
+
+  @override
+  String get trackCopyright => 'Copyright';
+
   @override
   String get trackDownloaded => 'Downloaded';
 

lib/l10n/arb/app_en.arb

@@ -619,6 +619,13 @@
   "dialogImportPlaylistTitle": "Import Playlist",
   "@dialogImportPlaylistTitle": {"description": "Dialog title - import CSV playlist"},
   "dialogImportPlaylistMessage": "Found {count} tracks in CSV. Add them to download queue?",
+  "csvImportTracks": "{count} tracks from CSV",
+  "@csvImportTracks": {
+    "description": "Label shown in quality picker for CSV import",
+    "placeholders": {
+      "count": {"type": "int"}
+    }
+  },
   "@dialogImportPlaylistMessage": {
     "description": "Dialog message - import playlist confirmation",
     "placeholders": {
@@ -1051,6 +1058,26 @@
   "@sectionAudioQuality": {"description": "Settings section header"},
   "sectionFileSettings": "File Settings",
   "@sectionFileSettings": {"description": "Settings section header"},
+  "sectionLyrics": "Lyrics",
+  "@sectionLyrics": {"description": "Settings section header"},
+
+  "lyricsMode": "Lyrics Mode",
+  "@lyricsMode": {"description": "Setting - how to save lyrics"},
+  "lyricsModeDescription": "Choose how lyrics are saved with your downloads",
+  "@lyricsModeDescription": {"description": "Lyrics mode picker description"},
+  "lyricsModeEmbed": "Embed in file",
+  "@lyricsModeEmbed": {"description": "Lyrics mode option - embed in audio file"},
+  "lyricsModeEmbedSubtitle": "Lyrics stored inside FLAC metadata",
+  "@lyricsModeEmbedSubtitle": {"description": "Subtitle for embed option"},
+  "lyricsModeExternal": "External .lrc file",
+  "@lyricsModeExternal": {"description": "Lyrics mode option - separate LRC file"},
+  "lyricsModeExternalSubtitle": "Separate .lrc file for players like Samsung Music",
+  "@lyricsModeExternalSubtitle": {"description": "Subtitle for external option"},
+  "lyricsModeBoth": "Both",
+  "@lyricsModeBoth": {"description": "Lyrics mode option - embed and external"},
+  "lyricsModeBothSubtitle": "Embed and save .lrc file",
+  "@lyricsModeBothSubtitle": {"description": "Subtitle for both option"},
+
   "sectionColor": "Color",
   "@sectionColor": {"description": "Settings section header"},
   "sectionTheme": "Theme",
@@ -1133,6 +1160,12 @@
   "@trackAudioQuality": {"description": "Metadata label - audio quality"},
   "trackReleaseDate": "Release date",
   "@trackReleaseDate": {"description": "Metadata label - release date"},
+  "trackGenre": "Genre",
+  "@trackGenre": {"description": "Metadata label - music genre"},
+  "trackLabel": "Label",
+  "@trackLabel": {"description": "Metadata label - record label"},
+  "trackCopyright": "Copyright",
+  "@trackCopyright": {"description": "Metadata label - copyright information"},
   "trackDownloaded": "Downloaded",
   "@trackDownloaded": {"description": "Metadata label - download date"},
   "trackCopyLyrics": "Copy lyrics",

lib/main.dart

@@ -7,13 +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();
   
-  await NotificationService().initialize();
+  await CoverCacheManager.initialize();
+  debugPrint('CoverCacheManager initialized: ${CoverCacheManager.isInitialized}');
   
-  await ShareIntentService().initialize();
+  await Future.wait([
+    NotificationService().initialize(),
+    ShareIntentService().initialize(),
+  ]);
   
   runApp(
     ProviderScope(

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,26 +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 String albumFolderStructure; // artist_album, album_only, artist_year_album, year_album
-  final bool showExtensionStore; // Show Extension Store tab in navigation
-  final String locale; // App language: 'system', 'en', 'id', etc.
-  final bool enableMp3Option; // Enable MP3 quality option (default off, requires FFmpeg conversion)
+  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',
@@ -42,26 +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.albumFolderStructure = 'artist_album', // Default: Albums/Artist/Album
-    this.showExtensionStore = true, // Default: show store
-    this.locale = 'system', // Default: follow system language
-    this.enableMp3Option = false, // Default: disabled
+    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({
@@ -88,12 +90,13 @@ class AppSettings {
     bool? enableLogging,
     bool? useExtensionProviders,
     String? searchProvider,
-    bool clearSearchProvider = false, // Set to true to clear searchProvider to null
+    bool clearSearchProvider = false,
     bool? separateSingles,
     String? albumFolderStructure,
     bool? showExtensionStore,
     String? locale,
     bool? enableMp3Option,
+    String? lyricsMode,
   }) {
     return AppSettings(
       defaultService: defaultService ?? this.defaultService,
@@ -124,6 +127,7 @@ class AppSettings {
       showExtensionStore: showExtensionStore ?? this.showExtensionStore,
       locale: locale ?? this.locale,
       enableMp3Option: enableMp3Option ?? this.enableMp3Option,
+      lyricsMode: lyricsMode ?? this.lyricsMode,
     );
   }
 

lib/models/settings.g.dart

@@ -37,6 +37,7 @@ AppSettings _$AppSettingsFromJson(Map<String, dynamic> json) => AppSettings(
   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) =>
@@ -69,4 +70,5 @@ Map<String, dynamic> _$AppSettingsToJson(AppSettings instance) =>
       '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,9 +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? itemType; // track, album, playlist - for extension search results
+  final String? source;
+  final String? albumType;
+  final String? itemType;
 
   const Track({
     required this.id,
@@ -41,25 +40,19 @@ class Track {
     this.itemType,
   });
 
-  /// Check if this track is a single (based on album_type metadata)
   bool get isSingle => albumType == 'single' || albumType == 'ep';
   
-  /// Check if this is an album item (not a track)
   bool get isAlbumItem => itemType == 'album';
   
-  /// Check if this is a playlist item (not a track)
   bool get isPlaylistItem => itemType == 'playlist';
   
-  /// Check if this is an artist item (not a track)
   bool get isArtistItem => itemType == 'artist';
   
-  /// Check if this is a collection (album, playlist, or 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/providers/download_queue_provider.dart

@@ -26,6 +26,10 @@ String? _normalizeOptionalString(String? value) {
   return trimmed;
 }
 
+final _invalidFolderChars = RegExp(r'[<>:"/\\|?*]');
+final _trailingDotsRegex = RegExp(r'\.+$');
+final _yearRegex = RegExp(r'^(\d{4})');
+
 class DownloadHistoryItem {
   final String id;
   final String trackName;
@@ -45,6 +49,9 @@ class DownloadHistoryItem {
   final String? quality;
   final int? bitDepth;
   final int? sampleRate;
+  final String? genre;
+  final String? label;
+  final String? copyright;
 
   const DownloadHistoryItem({
     required this.id,
@@ -65,6 +72,9 @@ class DownloadHistoryItem {
     this.quality,
     this.bitDepth,
     this.sampleRate,
+    this.genre,
+    this.label,
+    this.copyright,
   });
 
   Map<String, dynamic> toJson() => {
@@ -86,6 +96,9 @@ class DownloadHistoryItem {
     'quality': quality,
     'bitDepth': bitDepth,
     'sampleRate': sampleRate,
+    'genre': genre,
+    'label': label,
+    'copyright': copyright,
   };
 
   factory DownloadHistoryItem.fromJson(Map<String, dynamic> json) =>
@@ -108,12 +121,15 @@ class DownloadHistoryItem {
         quality: json['quality'] as String?,
         bitDepth: json['bitDepth'] as int?,
         sampleRate: json['sampleRate'] as int?,
+        genre: json['genre'] as String?,
+        label: json['label'] as String?,
+        copyright: json['copyright'] as String?,
       );
 }
 
 class DownloadHistoryState {
   final List<DownloadHistoryItem> items;
-  final Set<String> _downloadedSpotifyIds; // Cache for O(1) lookup
+  final Set<String> _downloadedSpotifyIds;
 
   DownloadHistoryState({this.items = const []})
     : _downloadedSpotifyIds = items
@@ -121,7 +137,6 @@ class DownloadHistoryState {
           .map((item) => item.spotifyId!)
           .toSet();
 
-  /// Check if a track has been downloaded (by Spotify ID)
   bool isDownloaded(String spotifyId) =>
       _downloadedSpotifyIds.contains(spotifyId);
 
@@ -132,6 +147,7 @@ class DownloadHistoryState {
 
 class DownloadHistoryNotifier extends Notifier<DownloadHistoryState> {
   static const _storageKey = 'download_history';
+  final Future<SharedPreferences> _prefs = SharedPreferences.getInstance();
   bool _isLoaded = false;
 
   @override
@@ -151,7 +167,7 @@ class DownloadHistoryNotifier extends Notifier<DownloadHistoryState> {
 
   Future<void> _loadFromStorage() async {
     try {
-      final prefs = await SharedPreferences.getInstance();
+      final prefs = await _prefs;
       final jsonStr = prefs.getString(_storageKey);
       if (jsonStr != null && jsonStr.isNotEmpty) {
         final List<dynamic> jsonList = jsonDecode(jsonStr);
@@ -176,7 +192,6 @@ class DownloadHistoryNotifier extends Notifier<DownloadHistoryState> {
     }
   }
 
-  /// Deduplicate history items by spotifyId, deezerId, or ISRC
   /// Keeps the most recent entry (first occurrence since list is sorted by date desc)
   List<DownloadHistoryItem> _deduplicateHistory(List<DownloadHistoryItem> items) {
     final seen = <String, int>{}; // key -> index of first occurrence
@@ -213,7 +228,7 @@ class DownloadHistoryNotifier extends Notifier<DownloadHistoryState> {
 
   Future<void> _saveToStorage() async {
     try {
-      final prefs = await SharedPreferences.getInstance();
+      final prefs = await _prefs;
       final jsonList = state.items.map((e) => e.toJson()).toList();
       await prefs.setString(_storageKey, jsonEncode(jsonList));
       _historyLog.d('Saved ${state.items.length} items to storage');
@@ -222,7 +237,6 @@ class DownloadHistoryNotifier extends Notifier<DownloadHistoryState> {
     }
   }
 
-  /// Force reload from storage (useful after app restart)
   Future<void> reloadFromStorage() async {
     await _loadFromStorage();
   }
@@ -273,7 +287,6 @@ class DownloadHistoryNotifier extends Notifier<DownloadHistoryState> {
     _saveToStorage();
   }
 
-  /// Remove item from history by Spotify ID
   void removeBySpotifyId(String spotifyId) {
     state = state.copyWith(
       items: state.items.where((item) => item.spotifyId != spotifyId).toList(),
@@ -282,7 +295,6 @@ class DownloadHistoryNotifier extends Notifier<DownloadHistoryState> {
     _historyLog.d('Removed item with spotifyId: $spotifyId');
   }
 
-  /// Get history item by Spotify ID
   DownloadHistoryItem? getBySpotifyId(String spotifyId) {
     return state.items.where((item) => item.spotifyId == spotifyId).firstOrNull;
   }
@@ -302,12 +314,12 @@ class DownloadQueueState {
   final List<DownloadItem> items;
   final DownloadItem? currentDownload;
   final bool isProcessing;
-  final bool isPaused; // NEW: pause state
+  final bool isPaused;
   final String outputDir;
   final String filenameFormat;
-  final String audioQuality; // LOSSLESS, HI_RES, HI_RES_LOSSLESS
+  final String audioQuality;
   final bool autoFallback;
-  final int concurrentDownloads; // 1 = sequential, max 3
+  final int concurrentDownloads;
 
   const DownloadQueueState({
     this.items = const [],
@@ -360,17 +372,30 @@ class DownloadQueueState {
       items.where((i) => i.status == DownloadStatus.downloading).length;
 }
 
+class _ProgressUpdate {
+  final DownloadStatus status;
+  final double progress;
+  final double? speedMBps;
+
+  const _ProgressUpdate({
+    required this.status,
+    required this.progress,
+    this.speedMBps,
+  });
+}
+
 class DownloadQueueNotifier extends Notifier<DownloadQueueState> {
   Timer? _progressTimer;
-  int _downloadCount = 0; // Counter for connection cleanup
-  static const _cleanupInterval = 50; // Cleanup every 50 downloads
-  static const _queueStorageKey =
-      'download_queue'; // Storage key for queue persistence
+  int _downloadCount = 0;
+  static const _cleanupInterval = 50;
+  static const _queueStorageKey = 'download_queue';
   final NotificationService _notificationService = NotificationService();
-  int _totalQueuedAtStart = 0; // Track total items when queue started
-  int _completedInSession = 0; // Track completed downloads in current session
-  int _failedInSession = 0; // Track failed downloads in current session
+  final Future<SharedPreferences> _prefs = SharedPreferences.getInstance();
+  int _totalQueuedAtStart = 0;
+  int _completedInSession = 0;
+  int _failedInSession = 0;
   bool _isLoaded = false;
+  final Set<String> _ensuredDirs = {};
 
   @override
   DownloadQueueState build() {
@@ -386,13 +411,12 @@ class DownloadQueueNotifier extends Notifier<DownloadQueueState> {
     return const DownloadQueueState();
   }
 
-  /// Load persisted queue from storage (for app restart recovery)
   Future<void> _loadQueueFromStorage() async {
     if (_isLoaded) return;
     _isLoaded = true;
 
     try {
-      final prefs = await SharedPreferences.getInstance();
+      final prefs = await _prefs;
       final jsonStr = prefs.getString(_queueStorageKey);
       if (jsonStr != null && jsonStr.isNotEmpty) {
         final List<dynamic> jsonList = jsonDecode(jsonStr);
@@ -428,10 +452,9 @@ class DownloadQueueNotifier extends Notifier<DownloadQueueState> {
     }
   }
 
-  /// Save current queue to storage (only pending items)
   Future<void> _saveQueueToStorage() async {
     try {
-      final prefs = await SharedPreferences.getInstance();
+      final prefs = await _prefs;
 
       final pendingItems = state.items
           .where(
@@ -454,7 +477,6 @@ class DownloadQueueNotifier extends Notifier<DownloadQueueState> {
     }
   }
 
-  /// Start multi-progress polling for all downloads (sequential and parallel)
   void _startMultiProgressPolling() {
     _progressTimer?.cancel();
     _progressTimer = Timer.periodic(const Duration(milliseconds: 500), (
@@ -463,6 +485,15 @@ class DownloadQueueNotifier extends Notifier<DownloadQueueState> {
       try {
         final allProgress = await PlatformBridge.getAllDownloadProgress();
         final items = allProgress['items'] as Map<String, dynamic>? ?? {};
+        final currentItems = state.items;
+        final itemsById = <String, DownloadItem>{};
+        final itemIndexById = <String, int>{};
+        for (int i = 0; i < currentItems.length; i++) {
+          final item = currentItems[i];
+          itemsById[item.id] = item;
+          itemIndexById[item.id] = i;
+        }
+        final progressUpdates = <String, _ProgressUpdate>{};
 
         bool hasFinalizingItem = false;
         String? finalizingTrackName;
@@ -470,9 +501,7 @@ class DownloadQueueNotifier extends Notifier<DownloadQueueState> {
 
         for (final entry in items.entries) {
           final itemId = entry.key;
-          final localItem = state.items
-              .where((i) => i.id == itemId)
-              .firstOrNull;
+          final localItem = itemsById[itemId];
           if (localItem == null) {
             continue;
           }
@@ -494,16 +523,13 @@ class DownloadQueueNotifier extends Notifier<DownloadQueueState> {
           final status = itemProgress['status'] as String? ?? 'downloading';
 
           if (status == 'finalizing' && bytesTotal > 0) {
-            updateItemStatus(itemId, DownloadStatus.finalizing, progress: 1.0);
-
-            final currentItem = state.items
-                .where((i) => i.id == itemId)
-                .firstOrNull;
-            if (currentItem != null) {
-              hasFinalizingItem = true;
-              finalizingTrackName = currentItem.track.name;
-              finalizingArtistName = currentItem.track.artistName;
-            }
+            progressUpdates[itemId] = const _ProgressUpdate(
+              status: DownloadStatus.finalizing,
+              progress: 1.0,
+            );
+            hasFinalizingItem = true;
+            finalizingTrackName = localItem.track.name;
+            finalizingArtistName = localItem.track.artistName;
             continue;
           }
 
@@ -518,7 +544,11 @@ class DownloadQueueNotifier extends Notifier<DownloadQueueState> {
               percentage = progressFromBackend;
             }
 
-            updateProgress(itemId, percentage, speedMBps: speedMBps);
+            progressUpdates[itemId] = _ProgressUpdate(
+              status: DownloadStatus.downloading,
+              progress: percentage,
+              speedMBps: speedMBps,
+            );
 
             final mbReceived = bytesReceived / (1024 * 1024);
             final mbTotal = bytesTotal / (1024 * 1024);
@@ -534,12 +564,47 @@ class DownloadQueueNotifier extends Notifier<DownloadQueueState> {
           }
         }
 
+        if (progressUpdates.isNotEmpty) {
+          var updatedItems = currentItems;
+          bool changed = false;
+
+          for (final entry in progressUpdates.entries) {
+            final index = itemIndexById[entry.key];
+            if (index == null) continue;
+            final current = updatedItems[index];
+            if (current.status == DownloadStatus.skipped ||
+                current.status == DownloadStatus.completed ||
+                current.status == DownloadStatus.failed) {
+              continue;
+            }
+            final update = entry.value;
+            final next = current.copyWith(
+              status: update.status,
+              progress: update.progress,
+              speedMBps: update.speedMBps ?? current.speedMBps,
+            );
+            if (current.status != next.status ||
+                current.progress != next.progress ||
+                current.speedMBps != next.speedMBps) {
+              if (!changed) {
+                updatedItems = List<DownloadItem>.from(updatedItems);
+                changed = true;
+              }
+              updatedItems[index] = next;
+            }
+          }
+
+          if (changed) {
+            state = state.copyWith(items: updatedItems);
+          }
+        }
+
         if (hasFinalizingItem && finalizingTrackName != null) {
           _notificationService.showDownloadFinalizing(
             trackName: finalizingTrackName,
             artistName: finalizingArtistName ?? '',
           );
-          return; // Don't show download progress notification
+          return;
         }
 
         if (items.isNotEmpty) {
@@ -583,14 +648,11 @@ class DownloadQueueNotifier extends Notifier<DownloadQueueState> {
                 progress: notifProgress,
                 total: notifTotal > 0 ? notifTotal : 1,
                 queueCount: state.queuedCount,
-              ).catchError((_) {}); // Ignore errors
+              ).catchError((_) {});
             }
           }
         }
-      } catch (e) {
-        // Silently ignore polling errors to avoid spamming logs
-        // Polling is not critical and will retry on next interval
-      }
+      } catch (_) {}
     });
   }
 
@@ -639,11 +701,24 @@ class DownloadQueueNotifier extends Notifier<DownloadQueueState> {
     }
   }
 
+  Future<void> _ensureDirExists(String path, {String? label}) async {
+    if (_ensuredDirs.contains(path)) return;
+    final dir = Directory(path);
+    if (!await dir.exists()) {
+      await dir.create(recursive: true);
+      if (label != null) {
+        _log.d('Created $label: $path');
+      } else {
+        _log.d('Created folder: $path');
+      }
+    }
+    _ensuredDirs.add(path);
+  }
+
   void setOutputDir(String dir) {
     state = state.copyWith(outputDir: dir);
   }
 
-  /// Build output directory based on folder organization setting and separateSingles
   Future<String> _buildOutputDir(Track track, String folderOrganization, {bool separateSingles = false, String albumFolderStructure = 'artist_album'}) async {
     String baseDir = state.outputDir;
     final albumArtist = _normalizeOptionalString(track.albumArtist) ?? track.artistName;
@@ -653,11 +728,7 @@ class DownloadQueueNotifier extends Notifier<DownloadQueueState> {
       
       if (isSingle) {
         final singlesPath = '$baseDir${Platform.pathSeparator}Singles';
-        final dir = Directory(singlesPath);
-        if (!await dir.exists()) {
-          await dir.create(recursive: true);
-          _log.d('Created Singles folder: $singlesPath');
-        }
+        await _ensureDirExists(singlesPath, label: 'Singles folder');
         return singlesPath;
       } else {
         final albumName = _sanitizeFolderName(track.albumName);
@@ -681,11 +752,7 @@ class DownloadQueueNotifier extends Notifier<DownloadQueueState> {
             albumPath = '$baseDir${Platform.pathSeparator}Albums${Platform.pathSeparator}$artistName${Platform.pathSeparator}$albumName';
         }
         
-        final dir = Directory(albumPath);
-        if (!await dir.exists()) {
-          await dir.create(recursive: true);
-          _log.d('Created Album folder: $albumPath');
-        }
+        await _ensureDirExists(albumPath, label: 'Album folder');
         return albumPath;
       }
     }
@@ -713,29 +780,24 @@ class DownloadQueueNotifier extends Notifier<DownloadQueueState> {
 
     if (subPath.isNotEmpty) {
       final fullPath = '$baseDir${Platform.pathSeparator}$subPath';
-      final dir = Directory(fullPath);
-      if (!await dir.exists()) {
-        await dir.create(recursive: true);
-        _log.d('Created folder: $fullPath');
-      }
+      await _ensureDirExists(fullPath);
       return fullPath;
     }
 
     return baseDir;
   }
 
-  /// Sanitize folder names (remove invalid characters)
   String _sanitizeFolderName(String name) {
     return name
-        .replaceAll(RegExp(r'[<>:"/\\|?*]'), '_')
-        .replaceAll(RegExp(r'\.+$'), '') // Remove trailing dots
+        .replaceAll(_invalidFolderChars, '_')
+        .replaceAll(_trailingDotsRegex, '') // Remove trailing dots
         .trim();
   }
 
   /// Extract year from release date (format: "2005-06-13" or "2005")
   String? _extractYear(String? releaseDate) {
     if (releaseDate == null || releaseDate.isEmpty) return null;
-    final match = RegExp(r'^(\d{4})').firstMatch(releaseDate);
+    final match = _yearRegex.firstMatch(releaseDate);
     return match?.group(1);
   }
 
@@ -796,7 +858,7 @@ class DownloadQueueNotifier extends Notifier<DownloadQueueState> {
     }).toList();
 
     state = state.copyWith(items: [...state.items, ...newItems]);
-    _saveQueueToStorage(); // Persist queue
+    _saveQueueToStorage();
 
     if (!state.isProcessing) {
       Future.microtask(() => _processQueue());
@@ -812,21 +874,32 @@ class DownloadQueueNotifier extends Notifier<DownloadQueueState> {
     String? error,
     DownloadErrorType? errorType,
   }) {
-    final items = state.items.map((item) {
-      if (item.id == id) {
-        return item.copyWith(
-          status: status,
-          progress: progress ?? item.progress,
-          speedMBps: speedMBps ?? item.speedMBps,
-          filePath: filePath,
-          error: error,
-          errorType: errorType,
-        );
-      }
-      return item;
-    }).toList();
+    final items = state.items;
+    final index = items.indexWhere((item) => item.id == id);
+    if (index == -1) return;
 
-    state = state.copyWith(items: items);
+    final current = items[index];
+    final next = current.copyWith(
+      status: status,
+      progress: progress ?? current.progress,
+      speedMBps: speedMBps ?? current.speedMBps,
+      filePath: filePath,
+      error: error,
+      errorType: errorType,
+    );
+
+    if (current.status == next.status &&
+        current.progress == next.progress &&
+        current.speedMBps == next.speedMBps &&
+        current.filePath == next.filePath &&
+        current.error == next.error &&
+        current.errorType == next.errorType) {
+      return;
+    }
+
+    final updatedItems = List<DownloadItem>.from(items);
+    updatedItems[index] = next;
+    state = state.copyWith(items: updatedItems);
 
     if (status == DownloadStatus.completed ||
         status == DownloadStatus.failed ||
@@ -836,9 +909,11 @@ class DownloadQueueNotifier extends Notifier<DownloadQueueState> {
   }
 
   void updateProgress(String id, double progress, {double? speedMBps}) {
-    final item = state.items.where((i) => i.id == id).firstOrNull;
-    if (item == null ||
-        item.status == DownloadStatus.skipped ||
+    final items = state.items;
+    final index = items.indexWhere((i) => i.id == id);
+    if (index == -1) return;
+    final item = items[index];
+    if (item.status == DownloadStatus.skipped ||
         item.status == DownloadStatus.completed ||
         item.status == DownloadStatus.failed) {
       return;
@@ -868,15 +943,14 @@ class DownloadQueueNotifier extends Notifier<DownloadQueueState> {
         .toList();
 
     state = state.copyWith(items: items);
-    _saveQueueToStorage(); // Persist queue
+    _saveQueueToStorage();
   }
 
   void clearAll() {
     state = state.copyWith(items: [], isPaused: false);
-    _saveQueueToStorage(); // Clear persisted queue
+    _saveQueueToStorage();
   }
 
-  /// Pause the download queue
   void pauseQueue() {
     if (state.isProcessing && !state.isPaused) {
       state = state.copyWith(isPaused: true);
@@ -885,7 +959,6 @@ class DownloadQueueNotifier extends Notifier<DownloadQueueState> {
     }
   }
 
-  /// Resume the download queue
   void resumeQueue() {
     if (state.isPaused) {
       state = state.copyWith(isPaused: false);
@@ -896,7 +969,6 @@ class DownloadQueueNotifier extends Notifier<DownloadQueueState> {
     }
   }
 
-  /// Toggle pause/resume
   void togglePause() {
     if (state.isPaused) {
       resumeQueue();
@@ -905,7 +977,6 @@ class DownloadQueueNotifier extends Notifier<DownloadQueueState> {
     }
   }
 
-  /// Retry a failed or skipped download
   void retryItem(String id) {
     final item = state.items.where((i) => i.id == id).firstOrNull;
     if (item == null) {
@@ -942,14 +1013,12 @@ class DownloadQueueNotifier extends Notifier<DownloadQueueState> {
     }
   }
 
-  /// Remove a specific item from queue
   void removeItem(String id) {
     final items = state.items.where((item) => item.id != id).toList();
     state = state.copyWith(items: items);
-    _saveQueueToStorage(); // Persist queue
+    _saveQueueToStorage();
   }
 
-  /// Run post-processing hooks on a downloaded file
   Future<void> _runPostProcessingHooks(String filePath, Track track) async {
     try {
       final settings = ref.read(settingsProvider);
@@ -996,7 +1065,6 @@ class DownloadQueueNotifier extends Notifier<DownloadQueueState> {
     }
   }
 
-  /// Upgrade Spotify cover URL to max quality (~2000x2000)
   /// Same logic as Go backend cover.go
   String _upgradeToMaxQualityCover(String coverUrl) {
     const spotifySize300 = 'ab67616d00001e02'; // 300x300 (small)
@@ -1015,8 +1083,13 @@ class DownloadQueueNotifier extends Notifier<DownloadQueueState> {
     return result;
   }
 
-  /// Embed metadata and cover to a FLAC file after M4A conversion
-  Future<void> _embedMetadataAndCover(String flacPath, Track track) async {
+  Future<void> _embedMetadataAndCover(
+    String flacPath, 
+    Track track, {
+    String? genre,
+    String? label,
+    String? copyright,
+  }) async {
     final settings = ref.read(settingsProvider);
     
     String? coverPath;
@@ -1066,12 +1139,12 @@ class DownloadQueueNotifier extends Notifier<DownloadQueueState> {
 
       if (track.trackNumber != null) {
         metadata['TRACKNUMBER'] = track.trackNumber.toString();
-        metadata['TRACK'] = track.trackNumber.toString(); // Compatibility
+        metadata['TRACK'] = track.trackNumber.toString();
       }
 
       if (track.discNumber != null) {
         metadata['DISCNUMBER'] = track.discNumber.toString();
-        metadata['DISC'] = track.discNumber.toString(); // Compatibility
+        metadata['DISC'] = track.discNumber.toString();
       }
 
       if (track.releaseDate != null) {
@@ -1083,23 +1156,35 @@ class DownloadQueueNotifier extends Notifier<DownloadQueueState> {
         metadata['ISRC'] = track.isrc!;
       }
 
+      if (genre != null && genre.isNotEmpty) {
+        metadata['GENRE'] = genre;
+        _log.d('Adding GENRE: $genre');
+      }
+      if (label != null && label.isNotEmpty) {
+        metadata['ORGANIZATION'] = label;
+        _log.d('Adding ORGANIZATION (label): $label');
+      }
+      if (copyright != null && copyright.isNotEmpty) {
+        metadata['COPYRIGHT'] = copyright;
+        _log.d('Adding COPYRIGHT: $copyright');
+      }
+
       _log.d('Metadata map content: $metadata');
 
       try {
-        // Convert duration from seconds to milliseconds for better lyrics matching
         final durationMs = track.duration * 1000;
         
         final lrcContent = await PlatformBridge.getLyricsLRC(
-          track.id, // spotifyID
+          track.id,
           track.name,
           track.artistName,
-          filePath: '', // No local file path yet (processed in memory)
+          filePath: '',
           durationMs: durationMs,
         );
 
         if (lrcContent.isNotEmpty) {
           metadata['LYRICS'] = lrcContent;
-          metadata['UNSYNCEDLYRICS'] = lrcContent; // Fallback for some players
+          metadata['UNSYNCEDLYRICS'] = lrcContent;
           _log.d('Lyrics fetched for embedding (${lrcContent.length} chars)');
         }
       } catch (e) {
@@ -1137,8 +1222,13 @@ class DownloadQueueNotifier extends Notifier<DownloadQueueState> {
     }
   }
 
-  /// Embed metadata, lyrics, and cover to a MP3 file
-  Future<void> _embedMetadataToMp3(String mp3Path, Track track) async {
+  Future<void> _embedMetadataToMp3(
+    String mp3Path, 
+    Track track, {
+    String? genre,
+    String? label,
+    String? copyright,
+  }) async {
     final settings = ref.read(settingsProvider);
     
     String? coverPath;
@@ -1205,9 +1295,21 @@ class DownloadQueueNotifier extends Notifier<DownloadQueueState> {
         metadata['ISRC'] = track.isrc!;
       }
 
+      if (genre != null && genre.isNotEmpty) {
+        metadata['GENRE'] = genre;
+        _log.d('Adding GENRE to MP3: $genre');
+      }
+      if (label != null && label.isNotEmpty) {
+        metadata['ORGANIZATION'] = label;
+        _log.d('Adding ORGANIZATION (label) to MP3: $label');
+      }
+      if (copyright != null && copyright.isNotEmpty) {
+        metadata['COPYRIGHT'] = copyright;
+        _log.d('Adding COPYRIGHT to MP3: $copyright');
+      }
+
       _log.d('MP3 Metadata map content: $metadata');
 
-      // Fetch lyrics if embedLyrics is enabled
       if (settings.embedLyrics) {
         try {
           final durationMs = track.duration * 1000;
@@ -1262,7 +1364,7 @@ class DownloadQueueNotifier extends Notifier<DownloadQueueState> {
   }
 
   Future<void> _processQueue() async {
-    if (state.isProcessing) return; // Prevent multiple concurrent processing
+    if (state.isProcessing) return;
 
     state = state.copyWith(isProcessing: true);
     _log.i('Starting queue processing...');
@@ -1359,7 +1461,6 @@ class DownloadQueueNotifier extends Notifier<DownloadQueueState> {
     }
   }
 
-  /// Sequential download processing (uses multi-progress system with single item)
   Future<void> _processQueueSequential() async {
     _startMultiProgressPolling();
 
@@ -1371,29 +1472,17 @@ class DownloadQueueNotifier extends Notifier<DownloadQueueState> {
       }
 
       final currentItems = state.items;
-      final nextItem = currentItems.firstWhere(
+      final nextIndex = currentItems.indexWhere(
         (item) => item.status == DownloadStatus.queued,
-        orElse: () => DownloadItem(
-          id: '',
-          track: const Track(
-            id: '',
-            name: '',
-            artistName: '',
-            albumName: '',
-            duration: 0,
-          ),
-          service: '',
-          createdAt: DateTime.now(),
-        ),
       );
-
-      if (nextItem.id.isEmpty) {
+      if (nextIndex == -1) {
         _log.d(
           'No more items to process (checked ${currentItems.length} items)',
         );
         break;
       }
 
+      final nextItem = currentItems[nextIndex];
       _log.d(
         'Processing next item: ${nextItem.track.name} (id: ${nextItem.id})',
       );
@@ -1405,10 +1494,10 @@ class DownloadQueueNotifier extends Notifier<DownloadQueueState> {
     _stopProgressPolling();
   }
 
-  /// Parallel download processing with worker pool
   Future<void> _processQueueParallel() async {
     final maxConcurrent = state.concurrentDownloads;
-    final activeDownloads = <String, Future<void>>{}; // Map item ID to future
+    final activeDownloads = <String, Future<void>>{};
+
 
     _startMultiProgressPolling();
 
@@ -1462,7 +1551,6 @@ class DownloadQueueNotifier extends Notifier<DownloadQueueState> {
     _stopProgressPolling();
   }
 
-  /// Download a single item (used by both sequential and parallel processing)
   Future<void> _downloadSingleItem(DownloadItem item) async {
     _log.d('Processing: ${item.track.name} by ${item.track.artistName}');
     _log.d('Cover URL: ${item.track.coverUrl}');
@@ -1525,7 +1613,6 @@ class DownloadQueueNotifier extends Notifier<DownloadQueueState> {
                     trackToDownload.albumName,
                 albumArtist: data['album_artist'] as String?,
                 coverUrl: data['images'] as String?,
-                // duration_ms from Go is in milliseconds, Track.duration is in seconds
                 duration:
                     ((data['duration_ms'] as int?) ??
                         (trackToDownload.duration * 1000)) ~/
@@ -1572,7 +1659,6 @@ class DownloadQueueNotifier extends Notifier<DownloadQueueState> {
       String? genre;
       String? label;
       
-      // Try to get Deezer track ID from various sources
       String? deezerTrackId = trackToDownload.deezerId;
       if (deezerTrackId == null && trackToDownload.id.startsWith('deezer:')) {
         deezerTrackId = trackToDownload.id.split(':')[1];
@@ -1593,7 +1679,6 @@ class DownloadQueueNotifier extends Notifier<DownloadQueueState> {
           }
         } catch (e) {
           _log.w('Failed to fetch extended metadata from Deezer: $e');
-          // Continue without extended metadata
         }
       }
 
@@ -1625,9 +1710,10 @@ class DownloadQueueNotifier extends Notifier<DownloadQueueState> {
           releaseDate: trackToDownload.releaseDate,
           itemId: item.id,
           durationMs: trackToDownload.duration,
-          source: trackToDownload.source, // Pass extension ID that provided this track
+          source: trackToDownload.source,
           genre: genre,
           label: label,
+          lyricsMode: settings.lyricsMode,
         );
       } else if (state.autoFallback) {
         _log.d('Using auto-fallback mode');
@@ -1650,11 +1736,11 @@ class DownloadQueueNotifier extends Notifier<DownloadQueueState> {
           discNumber: trackToDownload.discNumber ?? 1,
           releaseDate: trackToDownload.releaseDate,
           preferredService: item.service,
-          itemId: item.id, // Pass item ID for progress tracking
-          durationMs:
-              trackToDownload.duration, // Duration in ms for verification
+          itemId: item.id,
+          durationMs: trackToDownload.duration,
           genre: genre,
           label: label,
+          lyricsMode: settings.lyricsMode,
         );
       } else {
         result = await PlatformBridge.downloadTrack(
@@ -1704,8 +1790,6 @@ class DownloadQueueNotifier extends Notifier<DownloadQueueState> {
       if (result['success'] == true) {
         var filePath = result['file_path'] as String?;
         
-        // Track if this was an existing file (not a new download)
-        // This is important to prevent converting existing FLAC files to MP3
         final wasExisting = filePath != null && filePath.startsWith('EXISTS:');
         if (wasExisting) {
           filePath = filePath.substring(7); // Remove "EXISTS:" prefix
@@ -1807,7 +1891,21 @@ class DownloadQueueNotifier extends Notifier<DownloadQueueState> {
                       );
                     }
 
-                    await _embedMetadataAndCover(flacPath, finalTrack);
+                    final backendGenre = result['genre'] as String?;
+                    final backendLabel = result['label'] as String?;
+                    final backendCopyright = result['copyright'] as String?;
+                    
+                    if (backendGenre != null || backendLabel != null || backendCopyright != null) {
+                      _log.d('Extended metadata from backend - Genre: $backendGenre, Label: $backendLabel, Copyright: $backendCopyright');
+                    }
+
+                    await _embedMetadataAndCover(
+                      flacPath, 
+                      finalTrack,
+                      genre: backendGenre ?? genre,
+                      label: backendLabel ?? label,
+                      copyright: backendCopyright,
+                    );
                     _log.d('Metadata and cover embedded successfully');
                   } catch (e) {
                     _log.w('Warning: Failed to embed metadata/cover: $e');
@@ -1842,15 +1940,9 @@ class DownloadQueueNotifier extends Notifier<DownloadQueueState> {
           return;
         }
 
-        // Convert FLAC to MP3 if MP3 quality was selected
-        // IMPORTANT: Only convert NEW downloads, never convert existing files
-        // to prevent overwriting the user's existing FLAC files
         if (quality == 'MP3' && filePath != null && filePath.endsWith('.flac')) {
           if (wasExisting) {
-            // User wanted MP3 but an existing FLAC file was found
-            // Do NOT convert it - that would delete their existing FLAC
             _log.i('MP3 requested but existing FLAC found - skipping conversion to preserve original file');
-            // Keep the existing FLAC file as-is
           } else {
             _log.i('MP3 quality selected, converting FLAC to MP3...');
             updateItemStatus(
@@ -1871,14 +1963,24 @@ class DownloadQueueNotifier extends Notifier<DownloadQueueState> {
                 actualQuality = 'MP3 320kbps';
                 _log.i('Successfully converted to MP3: $mp3Path');
                 
-                // Embed metadata, lyrics, and cover to the MP3 file
                 _log.i('Embedding metadata to MP3...');
                 updateItemStatus(
                   item.id,
                   DownloadStatus.downloading,
                   progress: 0.99,
                 );
-                await _embedMetadataToMp3(mp3Path, trackToDownload);
+                
+                final mp3BackendGenre = result['genre'] as String?;
+                final mp3BackendLabel = result['label'] as String?;
+                final mp3BackendCopyright = result['copyright'] as String?;
+                
+                await _embedMetadataToMp3(
+                  mp3Path, 
+                  trackToDownload,
+                  genre: mp3BackendGenre ?? genre,
+                  label: mp3BackendLabel ?? label,
+                  copyright: mp3BackendCopyright,
+                );
               } else {
                 _log.w('MP3 conversion failed, keeping FLAC file');
               }
@@ -1918,6 +2020,9 @@ class DownloadQueueNotifier extends Notifier<DownloadQueueState> {
           final backendBitDepth = result['actual_bit_depth'] as int?;
           final backendSampleRate = result['actual_sample_rate'] as int?;
           final backendISRC = result['isrc'] as String?;
+          final backendGenre = result['genre'] as String?;
+          final backendLabel = result['label'] as String?;
+          final backendCopyright = result['copyright'] as String?;
 
           _log.d('Saving to history - coverUrl: ${trackToDownload.coverUrl}');
 
@@ -1927,7 +2032,6 @@ class DownloadQueueNotifier extends Notifier<DownloadQueueState> {
                   ? normalizedAlbumArtist
                   : null;
 
-          // For MP3 files, don't save FLAC bitDepth/sampleRate - they're not applicable
           final isMp3 = filePath.endsWith('.mp3');
           final historyBitDepth = isMp3 ? null : backendBitDepth;
           final historySampleRate = isMp3 ? null : backendSampleRate;
@@ -1968,6 +2072,9 @@ class DownloadQueueNotifier extends Notifier<DownloadQueueState> {
                   quality: actualQuality,
                   bitDepth: historyBitDepth,
                   sampleRate: historySampleRate,
+                  genre: backendGenre,
+                  label: backendLabel,
+                  copyright: backendCopyright,
                 ),
               );
 
@@ -2066,3 +2173,22 @@ final downloadQueueProvider =
     NotifierProvider<DownloadQueueNotifier, DownloadQueueState>(
       DownloadQueueNotifier.new,
     );
+
+class DownloadQueueLookup {
+  final Map<String, DownloadItem> byTrackId;
+
+  DownloadQueueLookup._(this.byTrackId);
+
+  factory DownloadQueueLookup.fromItems(List<DownloadItem> items) {
+    final map = <String, DownloadItem>{};
+    for (final item in items) {
+      map.putIfAbsent(item.track.id, () => item);
+    }
+    return DownloadQueueLookup._(map);
+  }
+}
+
+final downloadQueueLookupProvider = Provider<DownloadQueueLookup>((ref) {
+  final items = ref.watch(downloadQueueProvider.select((s) => s.items));
+  return DownloadQueueLookup.fromItems(items);
+});

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,8 +170,6 @@ class SearchBehavior {
     );
   }
 
-  /// Get thumbnail size based on configuration
-  /// Returns (width, height) tuple
   (double, double) getThumbnailSize({double defaultSize = 56}) {
     if (thumbnailWidth != null && thumbnailHeight != null) {
       return (thumbnailWidth!.toDouble(), thumbnailHeight!.toDouble());
@@ -191,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,
@@ -212,7 +207,6 @@ class TrackMatching {
   }
 }
 
-/// Post-processing configuration
 class PostProcessing {
   final bool enabled;
   final List<PostProcessingHook> hooks;
@@ -262,7 +256,6 @@ class URLHandler {
   }
 }
 
-/// A post-processing hook
 class PostProcessingHook {
   final String id;
   final String name;
@@ -289,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,
@@ -315,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;
 
@@ -351,16 +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', 'button'
+  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; // For button type: JS function name to call
+  final String? action;
 
   const ExtensionSetting({
     required this.key,
@@ -387,7 +377,6 @@ class ExtensionSetting {
   }
 }
 
-/// State for extension management
 class ExtensionState {
   final List<Extension> extensions;
   final List<String> providerPriority;
@@ -425,7 +414,6 @@ class ExtensionState {
 }
 
 
-/// Provider for managing extensions
 class ExtensionNotifier extends Notifier<ExtensionState> {
   @override
   ExtensionState build() {
@@ -451,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);
     
@@ -486,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);
     
@@ -508,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);
@@ -519,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);
     
@@ -553,7 +535,6 @@ class ExtensionNotifier extends Notifier<ExtensionState> {
     }
   }
 
-  /// Enable or disable an extension
   Future<void> setExtensionEnabled(String extensionId, bool enabled) async {
     try {
       await PlatformBridge.setExtensionEnabled(extensionId, enabled);
@@ -600,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);
@@ -621,7 +601,6 @@ class ExtensionNotifier extends Notifier<ExtensionState> {
     }
   }
 
-  /// Set provider priority order
   Future<void> setProviderPriority(List<String> priority) async {
     try {
       await PlatformBridge.setProviderPriority(priority);
@@ -643,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);
@@ -665,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);
@@ -679,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) {
@@ -700,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

@@ -121,7 +121,6 @@ class RecentAccessNotifier extends Notifier<RecentAccessState> {
             .map((e) => RecentAccessItem.fromJson(e as Map<String, dynamic>))
             .toList();
       } catch (e) {
-        // Ignore parse errors
       }
     }
     
@@ -266,7 +265,6 @@ class RecentAccessNotifier extends Notifier<RecentAccessState> {
   }
 }
 
-/// Provider instance
 final recentAccessProvider = NotifierProvider<RecentAccessNotifier, RecentAccessState>(
   RecentAccessNotifier.new,
 );

lib/providers/settings_provider.dart

@@ -30,7 +30,6 @@ class SettingsNotifier extends Notifier<AppSettings> {
     }
   }
 
-  /// Run one-time migrations for settings
   Future<void> _runMigrations(SharedPreferences prefs) async {
     final lastMigration = prefs.getInt(_migrationVersionKey) ?? 0;
     
@@ -51,7 +50,6 @@ class SettingsNotifier extends Notifier<AppSettings> {
     await prefs.setString(_settingsKey, jsonEncode(state.toJson()));
   }
 
-  /// Apply current Spotify credentials to Go backend
   Future<void> _applySpotifyCredentials() async {
     if (state.spotifyClientId.isNotEmpty && 
         state.spotifyClientSecret.isNotEmpty) {
@@ -92,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();

lib/providers/store_provider.dart

@@ -52,7 +52,6 @@ class StoreCategory {
   }
 }
 
-/// Represents an extension in the store
 class StoreExtension {
   final String id;
   final String name;
@@ -118,7 +117,6 @@ class StoreExtension {
   }
 }
 
-/// State for extension store
 class StoreState {
   final List<StoreExtension> extensions;
   final String? selectedCategory;
@@ -200,7 +198,6 @@ class StoreNotifier extends Notifier<StoreState> {
     return const StoreState();
   }
 
-  /// Initialize the store
   Future<void> initialize(String cacheDir) async {
     if (state.isInitialized) return;
 
@@ -234,7 +231,6 @@ class StoreNotifier extends Notifier<StoreState> {
     }
   }
 
-  /// Set category filter
   void setCategory(String? category) {
     if (category == null) {
       state = state.copyWith(clearCategory: true);
@@ -248,7 +244,6 @@ class StoreNotifier extends Notifier<StoreState> {
     state = state.copyWith(searchQuery: query);
   }
 
-  /// Clear search
   void clearSearch() {
     state = state.copyWith(searchQuery: '', clearCategory: true);
   }
@@ -279,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);
 
@@ -305,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

@@ -89,7 +89,6 @@ class TrackState {
   }
 }
 
-/// Represents an album in artist discography
 class ArtistAlbum {
   final String id;
   final String name;
@@ -112,7 +111,6 @@ class ArtistAlbum {
   });
 }
 
-/// Represents an artist in search results
 class SearchArtist {
   final String id;
   final String name;
@@ -130,7 +128,6 @@ class SearchArtist {
 }
 
 class TrackNotifier extends Notifier<TrackState> {
-  /// Request ID to track and cancel outdated requests
   int _currentRequestId = 0;
 
   @override
@@ -213,14 +210,8 @@ class TrackNotifier extends Notifier<TrackState> {
       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) {
-        // ignore: avoid_print
-        print('[FetchURL] Metadata fetch failed: $e');
         rethrow;
       }
       
@@ -263,7 +254,7 @@ class TrackNotifier extends Notifier<TrackState> {
         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?,
@@ -397,7 +388,6 @@ class TrackNotifier extends Notifier<TrackState> {
     }
   }
 
-  /// Perform custom search using a specific extension
   Future<void> customSearch(String extensionId, String query, {Map<String, dynamic>? options}) async {
     final requestId = ++_currentRequestId;
 
@@ -429,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
@@ -477,8 +467,6 @@ class TrackNotifier extends Notifier<TrackState> {
       tracks[index] = updatedTrack;
       state = state.copyWith(tracks: tracks);
     } catch (e) {
-      // Silently ignore availability check errors
-      // This is a background operation that shouldn't disrupt the user
     }
   }
 
@@ -488,10 +476,12 @@ 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);
   }
   
-  /// Set recent access mode state
   void setShowingRecentAccess(bool showing) {
     state = state.copyWith(isShowingRecentAccess: showing);
   }
@@ -581,8 +571,6 @@ 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) {
     final tracksWithIsrc = tracks.where((t) => t.isrc != null && t.isrc!.isNotEmpty).toList();
     if (tracksWithIsrc.isEmpty) return;

lib/screens/album_screen.dart

@@ -3,6 +3,7 @@ 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';
@@ -12,7 +13,6 @@ 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);
@@ -38,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;
@@ -98,7 +97,6 @@ class _AlbumScreenState extends ConsumerState<AlbumScreen> {
   }
 
   void _onScroll() {
-    // Show title in AppBar when scrolled past the header (320 - kToolbarHeight + info card top)
     final shouldShow = _scrollController.offset > 280;
     if (shouldShow != _showTitleInAppBar) {
       setState(() => _showTitleInAppBar = shouldShow);
@@ -120,7 +118,6 @@ class _AlbumScreenState extends ConsumerState<AlbumScreen> {
         });
       }
     } catch (_) {
-      // Ignore palette extraction errors
     }
   }
 
@@ -131,12 +128,8 @@ class _AlbumScreenState extends ConsumerState<AlbumScreen> {
       
       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 {
-        // 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);
       }
@@ -218,7 +211,7 @@ class _AlbumScreenState extends ConsumerState<AlbumScreen> {
       expandedHeight: 320,
       pinned: true,
       stretch: true,
-      backgroundColor: colorScheme.surface, // Use theme color for collapsed state
+      backgroundColor: colorScheme.surface,
       surfaceTintColor: Colors.transparent,
       title: AnimatedOpacity(
         duration: const Duration(milliseconds: 200),
@@ -260,7 +253,6 @@ class _AlbumScreenState extends ConsumerState<AlbumScreen> {
                     ),
                   ),
                 ),
-                // Cover image centered - fade out when collapsing
                 AnimatedOpacity(
                   duration: const Duration(milliseconds: 150),
                   opacity: showContent ? 1.0 : 0.0,
@@ -283,10 +275,11 @@ class _AlbumScreenState extends ConsumerState<AlbumScreen> {
                         child: ClipRRect(
                           borderRadius: BorderRadius.circular(20),
                           child: widget.coverUrl != null
-                              ? CachedNetworkImage(
+? CachedNetworkImage(
                                   imageUrl: widget.coverUrl!, 
                                   fit: BoxFit.cover, 
                                   memCacheWidth: (coverSize * 2).toInt(),
+                                  cacheManager: CoverCacheManager.instance,
                                 )
                               : Container(
                                   color: colorScheme.surfaceContainerHighest,
@@ -447,7 +440,6 @@ class _AlbumScreenState extends ConsumerState<AlbumScreen> {
     }
   }
 
-  /// 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') ||
@@ -510,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;
@@ -521,9 +512,9 @@ class _AlbumTrackItem extends ConsumerWidget {
   Widget build(BuildContext context, WidgetRef ref) {
     final colorScheme = Theme.of(context).colorScheme;
     
-    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]),
+    );
     
     final isInHistory = ref.watch(downloadHistoryProvider.select((state) {
       return state.isDownloaded(track.id);
@@ -545,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)),

lib/screens/artist_screen.dart

@@ -3,6 +3,7 @@ import 'package:flutter/material.dart';
 import 'package:flutter_riverpod/flutter_riverpod.dart';
 import 'package:cached_network_image/cached_network_image.dart';
 import 'package:intl/intl.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';
@@ -96,7 +97,6 @@ class _ArtistScreenState extends ConsumerState<ArtistScreen> {
   int? _monthlyListeners;
   String? _error;
   
-  // Sticky title state
   bool _showTitleInAppBar = false;
   final ScrollController _scrollController = ScrollController();
 
@@ -309,7 +309,6 @@ return Scaffold(
     );
   }
 
-  /// Build Spotify-style header with full-width image and artist name overlay
   Widget _buildHeader(BuildContext context, ColorScheme colorScheme) {
     String? imageUrl = _headerImageUrl;
     if (imageUrl == null || imageUrl.isEmpty) {
@@ -355,12 +354,13 @@ return SliverAppBar(
         background: Stack(
           fit: StackFit.expand,
           children: [
-            if (hasValidImage)
+if (hasValidImage)
               CachedNetworkImage(
                 imageUrl: imageUrl,
                 fit: BoxFit.cover,
                 alignment: Alignment.topCenter, // Show top of image (faces)
                 memCacheWidth: 800,
+                cacheManager: CoverCacheManager.instance,
                 placeholder: (context, url) => Container(
                   color: colorScheme.surfaceContainerHighest,
                 ),
@@ -477,11 +477,10 @@ return SliverAppBar(
     );
   }
 
-  /// Build a single popular track item with dynamic download status
   Widget _buildPopularTrackItem(int rank, Track track, ColorScheme colorScheme) {
-    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]),
+    );
     
     final isInHistory = ref.watch(downloadHistoryProvider.select((state) {
       return state.isDownloaded(track.id);
@@ -515,12 +514,13 @@ return SliverAppBar(
             ClipRRect(
               borderRadius: BorderRadius.circular(4),
               child: track.coverUrl != null
-                  ? CachedNetworkImage(
+? CachedNetworkImage(
                       imageUrl: track.coverUrl!,
                       width: 48,
                       height: 48,
                       fit: BoxFit.cover,
                       memCacheWidth: 96,
+                      cacheManager: CoverCacheManager.instance,
                       placeholder: (context, url) => Container(
                         width: 48,
                         height: 48,
@@ -605,7 +605,6 @@ return SliverAppBar(
     _downloadTrack(track);
   }
 
-  /// Build download button with status indicator for popular tracks
   Widget _buildPopularDownloadButton({
     required Track track,
     required ColorScheme colorScheme,
@@ -751,12 +750,13 @@ return SliverAppBar(
             ClipRRect(
               borderRadius: BorderRadius.circular(8),
               child: album.coverUrl != null
-                  ? CachedNetworkImage(
+? CachedNetworkImage(
                       imageUrl: album.coverUrl!,
                       width: 140,
                       height: 140,
                       fit: BoxFit.cover,
                       memCacheWidth: 280,
+                      cacheManager: CoverCacheManager.instance,
                       placeholder: (context, url) => Container(
                         width: 140,
                         height: 140,

lib/screens/downloaded_album_screen.dart

@@ -5,6 +5,7 @@ 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';
@@ -76,7 +77,6 @@ class _DownloadedAlbumScreenState extends ConsumerState<DownloadedAlbumScreen> {
         });
       }
     } catch (_) {
-      // Ignore palette extraction errors
     }
   }
 
@@ -103,24 +103,15 @@ class _DownloadedAlbumScreenState extends ConsumerState<DownloadedAlbumScreen> {
       });
   }
 
-  /// Get unique disc numbers from tracks (sorted)
-  List<int> _getDiscNumbers(List<DownloadHistoryItem> tracks) {
-    final discNumbers = tracks
-        .map((t) => t.discNumber ?? 1)
-        .toSet()
-        .toList()
-      ..sort();
-    return discNumbers;
-  }
-
-  /// Check if album has multiple discs
-  bool _hasMultipleDiscs(List<DownloadHistoryItem> tracks) {
-    return _getDiscNumbers(tracks).length > 1;
-  }
-
-  /// Get tracks for a specific disc
-  List<DownloadHistoryItem> _getTracksForDisc(List<DownloadHistoryItem> tracks, int discNumber) {
-    return tracks.where((t) => (t.discNumber ?? 1) == discNumber).toList();
+  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) {
@@ -223,6 +214,7 @@ class _DownloadedAlbumScreenState extends ConsumerState<DownloadedAlbumScreen> {
   }
 
   void _navigateToMetadataScreen(DownloadHistoryItem item) {
+    _precacheCover(item.coverUrl);
     Navigator.push(context, PageRouteBuilder(
       transitionDuration: const Duration(milliseconds: 300),
       reverseTransitionDuration: const Duration(milliseconds: 250),
@@ -231,6 +223,17 @@ 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;
@@ -368,10 +371,11 @@ class _DownloadedAlbumScreenState extends ConsumerState<DownloadedAlbumScreen> {
                         child: ClipRRect(
                           borderRadius: BorderRadius.circular(20),
                           child: widget.coverUrl != null
-                              ? CachedNetworkImage(
+? CachedNetworkImage(
                                   imageUrl: widget.coverUrl!, 
                                   fit: BoxFit.cover, 
                                   memCacheWidth: (coverSize * 2).toInt(),
+                                  cacheManager: CoverCacheManager.instance,
                                 )
                               : Container(
                                   color: colorScheme.surfaceContainerHighest,
@@ -501,9 +505,9 @@ class _DownloadedAlbumScreenState extends ConsumerState<DownloadedAlbumScreen> {
   }
 
   Widget _buildTrackList(BuildContext context, ColorScheme colorScheme, List<DownloadHistoryItem> tracks) {
-    // Check if album has multiple discs
-    if (!_hasMultipleDiscs(tracks)) {
-      // Single disc - use simple list
+    final discMap = _groupTracksByDisc(tracks);
+
+    if (discMap.length <= 1) {
       return SliverList(
         delegate: SliverChildBuilderDelegate(
           (context, index) {
@@ -518,13 +522,12 @@ class _DownloadedAlbumScreenState extends ConsumerState<DownloadedAlbumScreen> {
       );
     }
 
-    // Multiple discs - build list with separators
-    final discNumbers = _getDiscNumbers(tracks);
+    final discNumbers = discMap.keys.toList()..sort();
     final List<Widget> children = [];
 
     for (final discNumber in discNumbers) {
-      final discTracks = _getTracksForDisc(tracks, discNumber);
-      if (discTracks.isEmpty) continue;
+      final discTracks = discMap[discNumber];
+      if (discTracks == null || discTracks.isEmpty) continue;
 
       // Add disc separator
       children.add(_buildDiscSeparator(context, colorScheme, discNumber));

lib/screens/home_screen.dart

@@ -3,6 +3,7 @@ import 'package:flutter/services.dart';
 import 'package:flutter_riverpod/flutter_riverpod.dart';
 import 'package:go_router/go_router.dart';
 import 'package:cached_network_image/cached_network_image.dart';
+import 'package:spotiflac_android/services/cover_cache_manager.dart';
 import 'package:spotiflac_android/providers/track_provider.dart';
 import 'package:spotiflac_android/providers/download_queue_provider.dart';
 import 'package:spotiflac_android/providers/settings_provider.dart';
@@ -45,16 +46,15 @@ class _HomeScreenState extends ConsumerState<HomeScreen> {
     }
   }
 
-  void _downloadTrack(int index) {
-    final trackState = ref.read(trackProvider);
-    if (index >= 0 && index < trackState.tracks.length) {
-      final track = trackState.tracks[index];
-      final settings = ref.read(settingsProvider);
-      ref.read(downloadQueueProvider.notifier).addToQueue(track, settings.defaultService);
-      ScaffoldMessenger.of(context).showSnackBar(
-        SnackBar(content: Text('Added "${track.name}" to queue')),
-      );
-    }
+  void _downloadTrack(Track track) {
+    final settings = ref.read(settingsProvider);
+    ref.read(downloadQueueProvider.notifier).addToQueue(
+      track,
+      settings.defaultService,
+    );
+    ScaffoldMessenger.of(context).showSnackBar(
+      SnackBar(content: Text('Added "${track.name}" to queue')),
+    );
   }
 
   void _downloadAll() {
@@ -88,8 +88,10 @@ class _HomeScreenState extends ConsumerState<HomeScreen> {
   @override
   Widget build(BuildContext context) {
     final trackState = ref.watch(trackProvider);
-    final queueState = ref.watch(downloadQueueProvider);
+    final queuedCount =
+        ref.watch(downloadQueueProvider.select((s) => s.queuedCount));
     final colorScheme = Theme.of(context).colorScheme;
+    final tracks = trackState.tracks;
 
     return Scaffold(
       appBar: AppBar(
@@ -145,13 +147,13 @@ class _HomeScreenState extends ConsumerState<HomeScreen> {
           if (trackState.albumName != null || trackState.playlistName != null)
             _buildHeader(trackState, colorScheme),
 
-          if (trackState.tracks.length > 1)
+          if (tracks.length > 1)
             Padding(
               padding: const EdgeInsets.symmetric(horizontal: 16.0, vertical: 8.0),
               child: FilledButton.icon(
                 onPressed: _downloadAll,
                 icon: const Icon(Icons.download),
-                label: Text('Download All (${trackState.tracks.length})'),
+                label: Text('Download All (${tracks.length})'),
                 style: FilledButton.styleFrom(
                   minimumSize: const Size.fromHeight(48),
                 ),
@@ -159,11 +161,12 @@ class _HomeScreenState extends ConsumerState<HomeScreen> {
             ),
 
           Expanded(
-            child: trackState.tracks.isEmpty
+            child: tracks.isEmpty
                 ? _buildEmptyState(colorScheme)
                 : ListView.builder(
-                    itemCount: trackState.tracks.length,
-                    itemBuilder: (context, index) => _buildTrackTile(index, colorScheme),
+                    itemCount: tracks.length,
+                    itemBuilder: (context, index) =>
+                        _buildTrackTile(tracks[index], colorScheme),
                   ),
           ),
         ],
@@ -179,13 +182,13 @@ class _HomeScreenState extends ConsumerState<HomeScreen> {
           ),
           NavigationDestination(
             icon: Badge(
-              isLabelVisible: queueState.queuedCount > 0,
-              label: Text('${queueState.queuedCount}'),
+              isLabelVisible: queuedCount > 0,
+              label: Text('$queuedCount'),
               child: const Icon(Icons.queue_music_outlined),
             ),
             selectedIcon: Badge(
-              isLabelVisible: queueState.queuedCount > 0,
-              label: Text('${queueState.queuedCount}'),
+              isLabelVisible: queuedCount > 0,
+              label: Text('$queuedCount'),
               child: const Icon(Icons.queue_music),
             ),
             label: 'Queue',
@@ -210,11 +213,12 @@ class _HomeScreenState extends ConsumerState<HomeScreen> {
             if (state.coverUrl != null)
               ClipRRect(
                 borderRadius: BorderRadius.circular(8),
-                child: CachedNetworkImage(
+child: CachedNetworkImage(
                   imageUrl: state.coverUrl!,
                   width: 80,
                   height: 80,
                   fit: BoxFit.cover,
+                  cacheManager: CoverCacheManager.instance,
                   placeholder: (_, _) => Container(
                     width: 80,
                     height: 80,
@@ -259,8 +263,7 @@ class _HomeScreenState extends ConsumerState<HomeScreen> {
     );
   }
 
-  Widget _buildTrackTile(int index, ColorScheme colorScheme) {
-    final track = ref.watch(trackProvider).tracks[index];
+  Widget _buildTrackTile(Track track, ColorScheme colorScheme) {
     final isCollection = track.isCollection;
     
     String subtitleText;
@@ -281,11 +284,12 @@ class _HomeScreenState extends ConsumerState<HomeScreen> {
       leading: track.coverUrl != null
           ? ClipRRect(
               borderRadius: BorderRadius.circular(8),
-              child: CachedNetworkImage(
+child: CachedNetworkImage(
                 imageUrl: track.coverUrl!,
                 width: 48,
                 height: 48,
                 fit: BoxFit.cover,
+                cacheManager: CoverCacheManager.instance,
               ),
             )
           : Container(
@@ -315,7 +319,7 @@ class _HomeScreenState extends ConsumerState<HomeScreen> {
                 color: colorScheme.onSurfaceVariant,
               ),
             ),
-      onTap: () => isCollection ? _openCollection(track) : _downloadTrack(index),
+      onTap: () => isCollection ? _openCollection(track) : _downloadTrack(track),
     );
   }
   

lib/screens/home_tab.dart

@@ -4,6 +4,7 @@ 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: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/providers/track_provider.dart';
@@ -74,7 +75,6 @@ class _HomeTabState extends ConsumerState<HomeTab> with AutomaticKeepAliveClient
     }
   }
 
-  /// Called when trackState changes - used to sync search bar with state
   void _onTrackStateChanged(TrackState? previous, TrackState next) {
     if (previous != null && 
         !next.hasContent && 
@@ -95,7 +95,6 @@ class _HomeTabState extends ConsumerState<HomeTab> with AutomaticKeepAliveClient
     
     if (searchProvider == null || searchProvider.isEmpty) return false;
     
-    // Check if the extension is enabled and has search capability
     final extension = extState.extensions.where((e) => e.id == searchProvider && e.enabled).firstOrNull;
     return extension != null;
   }
@@ -129,10 +128,7 @@ class _HomeTabState extends ConsumerState<HomeTab> with AutomaticKeepAliveClient
     }
   }
   
-  /// Execute live search with concurrency protection
-  /// Prevents race conditions in extensions by ensuring only one search runs at a time
   Future<void> _executeLiveSearch(String query) async {
-    // If a search is already in progress, queue this one
     if (_isLiveSearchInProgress) {
       _pendingLiveSearchQuery = query;
       return;
@@ -150,13 +146,10 @@ class _HomeTabState extends ConsumerState<HomeTab> with AutomaticKeepAliveClient
       final pending = _pendingLiveSearchQuery;
       _pendingLiveSearchQuery = null;
       
-      // Execute pending query if it's different from what we just searched
-      // and still matches current text field content
       if (pending != null && 
           pending != query && 
           mounted && 
           _urlController.text.trim() == pending) {
-        // Small delay to let extension's state settle
         await Future.delayed(const Duration(milliseconds: 100));
         if (mounted && _urlController.text.trim() == pending) {
           _executeLiveSearch(pending);
@@ -223,7 +216,6 @@ class _HomeTabState extends ConsumerState<HomeTab> with AutomaticKeepAliveClient
     ref.read(settingsProvider.notifier).setHasSearchedBefore();
   }
 
-  /// Navigate to detail screen based on fetched content type
   void _navigateToDetailIfNeeded() {
     final trackState = ref.read(trackProvider);
     
@@ -355,37 +347,63 @@ class _HomeTabState extends ConsumerState<HomeTab> with AutomaticKeepAliveClient
       // ignore: use_build_context_synchronously
       final l10n = context.l10n;
       
-      final confirmed = await showDialog<bool>(
-        context: this.context,
-        builder: (dialogCtx) => AlertDialog(
-          title: Text(l10n.dialogImportPlaylistTitle),
-          content: Text(l10n.dialogImportPlaylistMessage(tracks.length)),
-          actions: [
-            TextButton(
-              onPressed: () => Navigator.pop(dialogCtx, false),
-              child: Text(l10n.dialogCancel),
-            ),
-            FilledButton(
-              onPressed: () => Navigator.pop(dialogCtx, true),
-              child: Text(l10n.dialogImport),
-            ),
-          ],
-        ),
-      );
-
-      if (confirmed == true) {
-        ref.read(downloadQueueProvider.notifier).addMultipleToQueue(tracks, settings.defaultService);
-        if (mounted) {
-           ScaffoldMessenger.of(this.context).showSnackBar(
-            SnackBar(
-              content: Text(l10n.snackbarAddedTracksToQueue(tracks.length)),
-              action: SnackBarAction(
-                label: l10n.snackbarViewQueue,
-                onPressed: () {
-                },
+      if (settings.askQualityBeforeDownload) {
+        DownloadServicePicker.show(
+          this.context,
+          trackName: l10n.csvImportTracks(tracks.length),
+          artistName: l10n.dialogImportPlaylistTitle,
+          onSelect: (quality, service) {
+            ref.read(downloadQueueProvider.notifier).addMultipleToQueue(
+              tracks, 
+              service, 
+              qualityOverride: quality,
+            );
+            if (mounted) {
+              ScaffoldMessenger.of(this.context).showSnackBar(
+                SnackBar(
+                  content: Text(l10n.snackbarAddedTracksToQueue(tracks.length)),
+                  action: SnackBarAction(
+                    label: l10n.snackbarViewQueue,
+                    onPressed: () {},
+                  ),
+                ),
+              );
+            }
+          },
+        );
+      } else {
+        // Use default settings without quality picker
+        final confirmed = await showDialog<bool>(
+          context: this.context,
+          builder: (dialogCtx) => AlertDialog(
+            title: Text(l10n.dialogImportPlaylistTitle),
+            content: Text(l10n.dialogImportPlaylistMessage(tracks.length)),
+            actions: [
+              TextButton(
+                onPressed: () => Navigator.pop(dialogCtx, false),
+                child: Text(l10n.dialogCancel),
               ),
-            ),
-          );
+              FilledButton(
+                onPressed: () => Navigator.pop(dialogCtx, true),
+                child: Text(l10n.dialogImport),
+              ),
+            ],
+          ),
+        );
+
+        if (confirmed == true) {
+          ref.read(downloadQueueProvider.notifier).addMultipleToQueue(tracks, settings.defaultService);
+          if (mounted) {
+            ScaffoldMessenger.of(this.context).showSnackBar(
+              SnackBar(
+                content: Text(l10n.snackbarAddedTracksToQueue(tracks.length)),
+                action: SnackBarAction(
+                  label: l10n.snackbarViewQueue,
+                  onPressed: () {},
+                ),
+              ),
+            );
+          }
         }
       }
     }
@@ -530,7 +548,11 @@ class _HomeTabState extends ConsumerState<HomeTab> with AutomaticKeepAliveClient
           
           if (showRecentAccess)
             SliverToBoxAdapter(
-              child: _buildRecentAccess(recentAccessItems, colorScheme),
+              child: _buildRecentAccess(
+                recentAccessItems,
+                historyItems,
+                colorScheme,
+              ),
             ),
           
           SliverToBoxAdapter(
@@ -610,13 +632,14 @@ class _HomeTabState extends ConsumerState<HomeTab> with AutomaticKeepAliveClient
                         ClipRRect(
                           borderRadius: BorderRadius.circular(12),
                           child: item.coverUrl != null
-                              ? CachedNetworkImage(
+? CachedNetworkImage(
                                   imageUrl: item.coverUrl!,
                                   width: 100,
                                   height: 100,
                                   fit: BoxFit.cover,
                                   memCacheWidth: 200,
                                   memCacheHeight: 200,
+                                  cacheManager: CoverCacheManager.instance,
                                 )
                               : Container(
                                   width: 100,
@@ -647,10 +670,11 @@ class _HomeTabState extends ConsumerState<HomeTab> with AutomaticKeepAliveClient
     );
   }
 
-  /// Build recent access history section (shown when search focused)
-  Widget _buildRecentAccess(List<RecentAccessItem> items, ColorScheme colorScheme) {
-    final historyItems = ref.read(downloadHistoryProvider).items;
-    
+  Widget _buildRecentAccess(
+    List<RecentAccessItem> items,
+    List<DownloadHistoryItem> historyItems,
+    ColorScheme colorScheme,
+  ) {
     // Group download history by album
     final albumGroups = <String, List<DownloadHistoryItem>>{};
     for (final h in historyItems) {
@@ -661,9 +685,6 @@ class _HomeTabState extends ConsumerState<HomeTab> with AutomaticKeepAliveClient
       albumGroups.putIfAbsent(albumKey, () => []).add(h);
     }
     
-    // Convert to RecentAccessItem based on track count:
-    // - 1 track: show as individual Track
-    // - 2+ tracks: show as Album
     final downloadItems = <RecentAccessItem>[];
     for (final entry in albumGroups.entries) {
       final tracks = entry.value;
@@ -674,7 +695,6 @@ class _HomeTabState extends ConsumerState<HomeTab> with AutomaticKeepAliveClient
           : mostRecent.artistName;
       
       if (tracks.length == 1) {
-        // Single track - show as Track
         downloadItems.add(RecentAccessItem(
           id: mostRecent.spotifyId ?? mostRecent.id,
           name: mostRecent.trackName,
@@ -685,7 +705,6 @@ class _HomeTabState extends ConsumerState<HomeTab> with AutomaticKeepAliveClient
           providerId: 'download',
         ));
       } else {
-        // Multiple tracks - show as Album
         downloadItems.add(RecentAccessItem(
           id: '${mostRecent.albumName}|$artistForKey',
           name: mostRecent.albumName,
@@ -698,10 +717,8 @@ class _HomeTabState extends ConsumerState<HomeTab> with AutomaticKeepAliveClient
       }
     }
     
-    // Sort by most recent and take top 10
     downloadItems.sort((a, b) => b.accessedAt.compareTo(a.accessedAt));
-    
-    // Filter out hidden downloads (use ref.watch for reactivity)
+
     final hiddenIds = ref.watch(recentAccessProvider.select((s) => s.hiddenDownloadIds));
     final visibleDownloads = downloadItems
         .where((item) => !hiddenIds.contains(item.id))
@@ -739,11 +756,9 @@ class _HomeTabState extends ConsumerState<HomeTab> with AutomaticKeepAliveClient
               if (uniqueItems.isNotEmpty)
                 TextButton(
                   onPressed: () {
-                    // Hide ALL download items (not just visible ones)
                     for (final item in downloadItems) {
                       ref.read(recentAccessProvider.notifier).hideDownloadFromRecents(item.id);
                     }
-                    // Clear non-download recent history
                     ref.read(recentAccessProvider.notifier).clearHistory();
                   },
                   child: Text(
@@ -755,7 +770,6 @@ class _HomeTabState extends ConsumerState<HomeTab> with AutomaticKeepAliveClient
           ),
           const SizedBox(height: 8),
           if (uniqueItems.isEmpty && hasHiddenDownloads)
-            // Show "Show All" button when recents is empty but there are hidden downloads
             Center(
               child: Padding(
                 padding: const EdgeInsets.symmetric(vertical: 24),
@@ -818,12 +832,13 @@ class _HomeTabState extends ConsumerState<HomeTab> with AutomaticKeepAliveClient
               ClipRRect(
                 borderRadius: BorderRadius.circular(item.type == RecentAccessType.artist ? 28 : 4),
                 child: item.imageUrl != null && item.imageUrl!.isNotEmpty
-                    ? CachedNetworkImage(
+? CachedNetworkImage(
                         imageUrl: item.imageUrl!,
                         width: 56,
                         height: 56,
                         fit: BoxFit.cover,
                         memCacheWidth: 112,
+                        cacheManager: CoverCacheManager.instance,
                         errorWidget: (context, url, error) => Container(
                           width: 56,
                           height: 56,
@@ -867,10 +882,8 @@ class _HomeTabState extends ConsumerState<HomeTab> with AutomaticKeepAliveClient
                 icon: Icon(Icons.close, size: 20, color: colorScheme.onSurfaceVariant),
                 onPressed: () {
                   if (item.providerId == 'download') {
-                    // For download items, hide from recents without deleting the file
                     ref.read(recentAccessProvider.notifier).hideDownloadFromRecents(item.id);
                   } else {
-                    // For other items, remove from recent history
                     ref.read(recentAccessProvider.notifier).removeItem(item);
                   }
                 },
@@ -906,7 +919,6 @@ class _HomeTabState extends ConsumerState<HomeTab> with AutomaticKeepAliveClient
           ));
         }
       case RecentAccessType.album:
-        // Handle downloaded albums - navigate to DownloadedAlbumScreen
         if (item.providerId == 'download') {
           Navigator.push(context, MaterialPageRoute(
             builder: (context) => DownloadedAlbumScreen(
@@ -950,6 +962,7 @@ class _HomeTabState extends ConsumerState<HomeTab> with AutomaticKeepAliveClient
   }
 
   void _navigateToMetadataScreen(DownloadHistoryItem item) {
+    _precacheCover(item.coverUrl);
     Navigator.push(context, PageRouteBuilder(
       transitionDuration: const Duration(milliseconds: 300),
       reverseTransitionDuration: const Duration(milliseconds: 250),
@@ -958,7 +971,17 @@ class _HomeTabState extends ConsumerState<HomeTab> with AutomaticKeepAliveClient
     ));
   }
 
-  /// Build error widget with special handling for rate limit (429)
+  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,
+    );
+  }
+
   Widget _buildErrorWidget(String error, ColorScheme colorScheme) {
     final isRateLimit = error.contains('429') || 
                         error.toLowerCase().contains('rate limit') ||
@@ -1032,10 +1055,28 @@ class _HomeTabState extends ConsumerState<HomeTab> with AutomaticKeepAliveClient
       return [const SliverToBoxAdapter(child: SizedBox.shrink())];
     }
     
-    final realTracks = tracks.where((t) => !t.isCollection).toList();
-    final albumItems = tracks.where((t) => t.isAlbumItem).toList();
-    final playlistItems = tracks.where((t) => t.isPlaylistItem).toList();
-    final artistItems = tracks.where((t) => t.isArtistItem).toList();
+    final realTracks = <Track>[];
+    final realTrackIndexes = <int>[];
+    final albumItems = <Track>[];
+    final playlistItems = <Track>[];
+    final artistItems = <Track>[];
+    
+    for (int i = 0; i < tracks.length; i++) {
+      final track = tracks[i];
+      if (!track.isCollection) {
+        realTracks.add(track);
+        realTrackIndexes.add(i);
+      }
+      if (track.isAlbumItem) {
+        albumItems.add(track);
+      }
+      if (track.isPlaylistItem) {
+        playlistItems.add(track);
+      }
+      if (track.isArtistItem) {
+        artistItems.add(track);
+      }
+    }
     
     return [
       if (error != null)
@@ -1178,9 +1219,9 @@ class _HomeTabState extends ConsumerState<HomeTab> with AutomaticKeepAliveClient
                     _TrackItemWithStatus(
                       key: ValueKey(realTracks[i].id),
                       track: realTracks[i],
-                      index: tracks.indexOf(realTracks[i]), // Use original index for download
+                      index: realTrackIndexes[i],
                       showDivider: i < realTracks.length - 1,
-                      onDownload: () => _downloadTrack(tracks.indexOf(realTracks[i])),
+                      onDownload: () => _downloadTrack(realTrackIndexes[i]),
                     ),
                 ],
               ),
@@ -1240,11 +1281,12 @@ class _HomeTabState extends ConsumerState<HomeTab> with AutomaticKeepAliveClient
               ),
               child: ClipOval(
                 child: hasValidImage
-                    ? CachedNetworkImage(
+? CachedNetworkImage(
                         imageUrl: artist.imageUrl!,
                         fit: BoxFit.cover,
                         memCacheWidth: 200,
                         memCacheHeight: 200,
+                        cacheManager: CoverCacheManager.instance,
                         errorWidget: (context, url, error) => Icon(
                           Icons.person,
                           color: colorScheme.onSurfaceVariant,
@@ -1366,7 +1408,6 @@ class _HomeTabState extends ConsumerState<HomeTab> with AutomaticKeepAliveClient
     ));
   }
 
-  /// Get search hint based on selected provider
   String _getSearchHint() {
     final settings = ref.read(settingsProvider);
     final searchProvider = settings.searchProvider;
@@ -1413,11 +1454,8 @@ class _HomeTabState extends ConsumerState<HomeTab> with AutomaticKeepAliveClient
         ),
         prefixIcon: _SearchProviderDropdown(
           onProviderChanged: () {
-            // Reset search state when provider changes
             _lastSearchQuery = null;
-            // Force rebuild to update hint text
             setState(() {});
-            // Re-trigger search if there's text
             final text = _urlController.text.trim();
             if (text.isNotEmpty && text.length >= _minLiveSearchChars) {
               _performSearch(text);
@@ -1453,9 +1491,7 @@ class _HomeTabState extends ConsumerState<HomeTab> with AutomaticKeepAliveClient
     );
   }
 
-  /// Handle Enter key press - search or fetch URL
   void _onSearchSubmitted() {
-    // Cancel any pending live search since user explicitly pressed enter
     _liveSearchDebounce?.cancel();
     _pendingLiveSearchQuery = null;
     
@@ -1488,13 +1524,11 @@ class _SearchProviderDropdown extends ConsumerWidget {
     final extState = ref.watch(extensionProvider);
     final colorScheme = Theme.of(context).colorScheme;
     
-    // Get current provider info
     final currentProvider = settings.searchProvider;
     final searchProviders = extState.extensions
         .where((ext) => ext.enabled && ext.hasCustomSearch)
         .toList();
     
-    // Find current provider extension
     Extension? currentExt;
     if (currentProvider != null && currentProvider.isNotEmpty) {
       currentExt = searchProviders.where((e) => e.id == currentProvider).firstOrNull;
@@ -1506,12 +1540,10 @@ class _SearchProviderDropdown extends ConsumerWidget {
     if (currentExt != null) {
       iconPath = currentExt.iconPath;
       if (currentExt.searchBehavior?.icon != null) {
-        // Use search behavior icon if available
         displayIcon = _getIconFromName(currentExt.searchBehavior!.icon!);
       }
     }
     
-    // Don't show dropdown if no custom search providers available
     if (searchProviders.isEmpty) {
       return const Icon(Icons.search);
     }
@@ -1547,15 +1579,13 @@ class _SearchProviderDropdown extends ConsumerWidget {
         offset: const Offset(0, 40),
         shape: RoundedRectangleBorder(borderRadius: BorderRadius.circular(12)),
         onSelected: (String providerId) {
-        // Empty string means default (Deezer/Spotify)
         final provider = providerId.isEmpty ? null : providerId;
         ref.read(settingsProvider.notifier).setSearchProvider(provider);
         onProviderChanged?.call();
       },
       itemBuilder: (context) => [
-        // Default option (Deezer/Spotify based on metadata source)
         PopupMenuItem<String>(
-          value: '', // Empty string = default provider
+          value: '',
           child: Row(
             children: [
               Icon(
@@ -1655,7 +1685,6 @@ class _SearchProviderDropdown extends ConsumerWidget {
   }
 }
 
-/// Separate Consumer widget for each track item - only rebuilds when this specific track's status changes
 class _TrackItemWithStatus extends ConsumerWidget {
   final Track track;
   final int index;
@@ -1674,9 +1703,9 @@ class _TrackItemWithStatus extends ConsumerWidget {
   Widget build(BuildContext context, WidgetRef ref) {
     final colorScheme = Theme.of(context).colorScheme;
     
-    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]),
+    );
     
     final isInHistory = ref.watch(downloadHistoryProvider.select((state) {
       return state.isDownloaded(track.id);
@@ -1723,13 +1752,14 @@ class _TrackItemWithStatus extends ConsumerWidget {
                 ClipRRect(
                   borderRadius: BorderRadius.circular(10),
                   child: track.coverUrl != null
-                      ? CachedNetworkImage(
+? CachedNetworkImage(
                           imageUrl: track.coverUrl!,
                           width: thumbWidth,
                           height: thumbHeight,
                           fit: BoxFit.cover,
                           memCacheWidth: (thumbWidth * 2).toInt(),
                           memCacheHeight: (thumbHeight * 2).toInt(),
+                          cacheManager: CoverCacheManager.instance,
                         )
                       : Container(
                           width: thumbWidth,
@@ -1902,13 +1932,14 @@ class _CollectionItemWidget extends StatelessWidget {
                 ClipRRect(
                   borderRadius: BorderRadius.circular(isArtist ? 28 : 10),
                   child: item.coverUrl != null && item.coverUrl!.isNotEmpty
-                      ? CachedNetworkImage(
+? CachedNetworkImage(
                           imageUrl: item.coverUrl!,
                           width: 56,
                           height: 56,
                           fit: BoxFit.cover,
                           memCacheWidth: 112,
                           memCacheHeight: 112,
+                          cacheManager: CoverCacheManager.instance,
                         )
                       : Container(
                           width: 56,
@@ -1965,7 +1996,6 @@ class _CollectionItemWidget extends StatelessWidget {
   }
 }
 
-/// Screen for viewing extension album with track fetching
 class ExtensionAlbumScreen extends ConsumerStatefulWidget {
   final String extensionId;
   final String albumId;
@@ -2236,7 +2266,6 @@ class _ExtensionPlaylistScreenState extends ConsumerState<ExtensionPlaylistScree
   }
 }
 
-/// Screen for viewing extension artist with album fetching
 class ExtensionArtistScreen extends ConsumerStatefulWidget {
   final String extensionId;
   final String artistId;

lib/screens/main_shell.dart

@@ -120,7 +120,6 @@ class _MainShellState extends ConsumerState<MainShell> {
     }
   }
 
-  /// Handle back press with double-tap to exit
   void _handleBackPress() {
     final trackState = ref.read(trackProvider);
     
@@ -174,9 +173,6 @@ class _MainShellState extends ConsumerState<MainShell> {
     
     final isKeyboardVisible = MediaQuery.of(context).viewInsets.bottom > 0;
     
-    // Determine if we can pop (for predictive back animation)
-    // canPop is true when we're at root with no content - enables predictive back gesture
-    // IMPORTANT: Never allow pop when keyboard is visible to prevent accidental navigation
     final canPop = _currentIndex == 0 && 
                    !trackState.hasSearchText && 
                    !trackState.hasContent && 
@@ -250,8 +246,6 @@ class _MainShellState extends ConsumerState<MainShell> {
       canPop: canPop,
       onPopInvokedWithResult: (didPop, result) async {
         if (didPop) {
-          // System handled the pop - this means predictive back completed
-          // We need to handle double-tap to exit here
           return;
         }
         

lib/screens/playlist_screen.dart

@@ -3,6 +3,7 @@ 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';
@@ -10,7 +11,6 @@ import 'package:spotiflac_android/providers/download_queue_provider.dart';
 import 'package:spotiflac_android/providers/settings_provider.dart';
 import 'package:spotiflac_android/widgets/download_service_picker.dart';
 
-/// Playlist detail screen with Material Expressive 3 design
 class PlaylistScreen extends ConsumerStatefulWidget {
   final String playlistName;
   final String? coverUrl;
@@ -68,7 +68,6 @@ class _PlaylistScreenState extends ConsumerState<PlaylistScreen> {
         });
       }
     } catch (_) {
-      // Ignore palette extraction errors
     }
   }
 
@@ -164,10 +163,11 @@ class _PlaylistScreenState extends ConsumerState<PlaylistScreen> {
                         child: ClipRRect(
                           borderRadius: BorderRadius.circular(20),
                           child: widget.coverUrl != null
-                              ? CachedNetworkImage(
+? CachedNetworkImage(
                                   imageUrl: widget.coverUrl!, 
                                   fit: BoxFit.cover, 
                                   memCacheWidth: (coverSize * 2).toInt(),
+                                  cacheManager: CoverCacheManager.instance,
                                 )
                               : Container(
                                   color: colorScheme.surfaceContainerHighest, 
@@ -323,9 +323,9 @@ class _PlaylistTrackItem extends ConsumerWidget {
   Widget build(BuildContext context, WidgetRef ref) {
     final colorScheme = Theme.of(context).colorScheme;
     
-    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]),
+    );
     
     final isInHistory = ref.watch(downloadHistoryProvider.select((state) {
       return state.isDownloaded(track.id);
@@ -347,8 +347,8 @@ class _PlaylistTrackItem 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)),

lib/screens/queue_screen.dart

@@ -1,6 +1,7 @@
 import 'package:flutter/material.dart';
 import 'package:flutter_riverpod/flutter_riverpod.dart';
 import 'package:cached_network_image/cached_network_image.dart';
+import 'package:spotiflac_android/services/cover_cache_manager.dart';
 import 'package:spotiflac_android/l10n/l10n.dart';
 import 'package:spotiflac_android/models/download_item.dart';
 import 'package:spotiflac_android/providers/download_queue_provider.dart';
@@ -10,20 +11,20 @@ class QueueScreen extends ConsumerWidget {
 
   @override
   Widget build(BuildContext context, WidgetRef ref) {
-    final queueState = ref.watch(downloadQueueProvider);
+    final items = ref.watch(downloadQueueProvider.select((s) => s.items));
     final colorScheme = Theme.of(context).colorScheme;
 
     return Scaffold(
       appBar: AppBar(
         title: Text(context.l10n.queueTitle),
         actions: [
-          if (queueState.items.isNotEmpty)
+          if (items.isNotEmpty)
             IconButton(
               icon: const Icon(Icons.delete_sweep),
               onPressed: () => ref.read(downloadQueueProvider.notifier).clearCompleted(),
               tooltip: context.l10n.queueClearCompleted,
             ),
-          if (queueState.items.isNotEmpty)
+          if (items.isNotEmpty)
             IconButton(
               icon: const Icon(Icons.clear_all),
               onPressed: () => _showClearAllDialog(context, ref),
@@ -31,11 +32,12 @@ class QueueScreen extends ConsumerWidget {
             ),
         ],
       ),
-      body: queueState.items.isEmpty
+      body: items.isEmpty
           ? _buildEmptyState(context, colorScheme)
           : ListView.builder(
-              itemCount: queueState.items.length,
-              itemBuilder: (context, index) => _buildQueueItem(context, ref, queueState.items[index], colorScheme),
+              itemCount: items.length,
+              itemBuilder: (context, index) =>
+                  _buildQueueItem(context, ref, items[index], colorScheme),
             ),
     );
   }
@@ -74,11 +76,12 @@ class QueueScreen extends ConsumerWidget {
       leading: item.track.coverUrl != null
           ? ClipRRect(
               borderRadius: BorderRadius.circular(8),
-              child: CachedNetworkImage(
+child: CachedNetworkImage(
                 imageUrl: item.track.coverUrl!,
                 width: 48,
                 height: 48,
                 fit: BoxFit.cover,
+                cacheManager: CoverCacheManager.instance,
               ),
             )
           : Container(

lib/screens/queue_tab.dart

@@ -4,6 +4,7 @@ import 'package:flutter/services.dart';
 import 'package:flutter_riverpod/flutter_riverpod.dart';
 import 'package:cached_network_image/cached_network_image.dart';
 import 'package:open_filex/open_filex.dart';
+import 'package:spotiflac_android/services/cover_cache_manager.dart';
 import 'package:spotiflac_android/l10n/l10n.dart';
 import 'package:spotiflac_android/utils/mime_utils.dart';
 import 'package:spotiflac_android/models/download_item.dart';
@@ -12,7 +13,6 @@ import 'package:spotiflac_android/providers/settings_provider.dart';
 import 'package:spotiflac_android/screens/track_metadata_screen.dart';
 import 'package:spotiflac_android/screens/downloaded_album_screen.dart';
 
-/// Grouped album data for history display
 class _GroupedAlbum {
   final String albumName;
   final String artistName;
@@ -31,6 +31,20 @@ class _GroupedAlbum {
   String get key => '$albumName|$artistName';
 }
 
+class _HistoryStats {
+  final Map<String, int> albumCounts;
+  final List<_GroupedAlbum> groupedAlbums;
+  final int albumCount;
+  final int singleTracks;
+
+  const _HistoryStats({
+    required this.albumCounts,
+    required this.groupedAlbums,
+    required this.albumCount,
+    required this.singleTracks,
+  });
+}
+
 class QueueTab extends ConsumerStatefulWidget {
   final PageController? parentPageController;
   final int parentPageIndex;
@@ -93,7 +107,6 @@ class _QueueTabState extends ConsumerState<QueueTab> {
     );
   }
 
-  /// Enter selection mode with initial item
   void _enterSelectionMode(String itemId) {
     HapticFeedback.mediumImpact();
     setState(() {
@@ -110,7 +123,6 @@ class _QueueTabState extends ConsumerState<QueueTab> {
     });
   }
 
-  /// Toggle item selection
   void _toggleSelection(String itemId) {
     setState(() {
       if (_selectedIds.contains(itemId)) {
@@ -131,7 +143,6 @@ class _QueueTabState extends ConsumerState<QueueTab> {
     });
   }
 
-  /// Delete selected items
   Future<void> _deleteSelected() async {
     final count = _selectedIds.length;
     final confirmed = await showDialog<bool>(
@@ -234,6 +245,17 @@ class _QueueTabState extends ConsumerState<QueueTab> {
     }
   }
 
+  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,
+    );
+  }
+
   void _navigateToMetadataScreen(DownloadItem item) {
     final historyItem = ref
         .read(downloadHistoryProvider)
@@ -252,6 +274,7 @@ class _QueueTabState extends ConsumerState<QueueTab> {
           ),
         );
 
+    _precacheCover(historyItem.coverUrl);
     Navigator.push(
       context,
       PageRouteBuilder(
@@ -266,6 +289,7 @@ class _QueueTabState extends ConsumerState<QueueTab> {
   }
 
   void _navigateToHistoryMetadataScreen(DownloadHistoryItem item) {
+    _precacheCover(item.coverUrl);
     Navigator.push(
       context,
       PageRouteBuilder(
@@ -279,21 +303,13 @@ class _QueueTabState extends ConsumerState<QueueTab> {
     );
   }
 
-  /// Filter history items based on current filter mode
-  /// Album = track yang albumnya punya >1 track di history
-  /// Single = track yang albumnya cuma 1 track di history
   List<DownloadHistoryItem> _filterHistoryItems(
     List<DownloadHistoryItem> items,
     String filterMode,
+    Map<String, int> albumCounts,
   ) {
     if (filterMode == 'all') return items;
 
-    final albumCounts = <String, int>{};
-    for (final item in items) {
-      final key = '${item.albumName}|${item.albumArtist ?? item.artistName}';
-      albumCounts[key] = (albumCounts[key] ?? 0) + 1;
-    }
-
     switch (filterMode) {
       case 'albums':
         return items.where((item) {
@@ -312,82 +328,56 @@ class _QueueTabState extends ConsumerState<QueueTab> {
     }
   }
 
-  /// Count albums vs singles for filter chips
-  Map<String, int> _countAlbumsAndSingles(List<DownloadHistoryItem> items) {
+  _HistoryStats _buildHistoryStats(List<DownloadHistoryItem> items) {
     final albumCounts = <String, int>{};
+    final albumMap = <String, List<DownloadHistoryItem>>{};
     for (final item in items) {
       final key = '${item.albumName}|${item.albumArtist ?? item.artistName}';
       albumCounts[key] = (albumCounts[key] ?? 0) + 1;
+      albumMap.putIfAbsent(key, () => []).add(item);
     }
 
-    int albumTracks = 0;
     int singleTracks = 0;
-
     for (final item in items) {
       final key = '${item.albumName}|${item.albumArtist ?? item.artistName}';
-      if ((albumCounts[key] ?? 0) > 1) {
-        albumTracks++;
-      } else {
+      if ((albumCounts[key] ?? 0) <= 1) {
         singleTracks++;
       }
     }
 
-    return {'albums': albumTracks, 'singles': singleTracks};
-  }
+    final groupedAlbums = <_GroupedAlbum>[];
+    albumMap.forEach((_, tracks) {
+      if (tracks.length <= 1) return;
+      tracks.sort((a, b) {
+        final aNum = a.trackNumber ?? 999;
+        final bNum = b.trackNumber ?? 999;
+        return aNum.compareTo(bNum);
+      });
 
-  /// Group history items by album (for Albums filter view)
-  List<_GroupedAlbum> _groupByAlbum(List<DownloadHistoryItem> items) {
-    final albumMap = <String, List<DownloadHistoryItem>>{};
-
-    for (final item in items) {
-      final key = '${item.albumName}|${item.albumArtist ?? item.artistName}';
-      albumMap.putIfAbsent(key, () => []).add(item);
-    }
-
-    final groupedAlbums = albumMap.entries.where((e) => e.value.length > 1).map(
-      (e) {
-        final tracks = e.value;
-        tracks.sort((a, b) {
-          final aNum = a.trackNumber ?? 999;
-          final bNum = b.trackNumber ?? 999;
-          return aNum.compareTo(bNum);
-        });
-
-        return _GroupedAlbum(
-          albumName: tracks.first.albumName,
-          artistName: tracks.first.albumArtist ?? tracks.first.artistName,
-          coverUrl: tracks.first.coverUrl,
-          tracks: tracks,
-          latestDownload: tracks
-              .map((t) => t.downloadedAt)
-              .reduce((a, b) => a.isAfter(b) ? a : b),
-        );
-      },
-    ).toList();
+      groupedAlbums.add(_GroupedAlbum(
+        albumName: tracks.first.albumName,
+        artistName: tracks.first.albumArtist ?? tracks.first.artistName,
+        coverUrl: tracks.first.coverUrl,
+        tracks: tracks,
+        latestDownload: tracks
+            .map((t) => t.downloadedAt)
+            .reduce((a, b) => a.isAfter(b) ? a : b),
+      ));
+    });
 
     groupedAlbums.sort((a, b) => b.latestDownload.compareTo(a.latestDownload));
 
-    return groupedAlbums;
-  }
-
-  /// Count unique albums (for filter chip badge)
-  int _countUniqueAlbums(List<DownloadHistoryItem> items) {
-    final albumKeys = <String>{};
-    for (final item in items) {
-      final key = '${item.albumName}|${item.albumArtist ?? item.artistName}';
-      albumKeys.add(key);
+    int albumCount = 0;
+    for (final count in albumCounts.values) {
+      if (count > 1) albumCount++;
     }
 
-    int count = 0;
-    for (final key in albumKeys) {
-      final trackCount = items
-          .where(
-            (i) => '${i.albumName}|${i.albumArtist ?? i.artistName}' == key,
-          )
-          .length;
-      if (trackCount > 1) count++;
-    }
-    return count;
+    return _HistoryStats(
+      albumCounts: albumCounts,
+      groupedAlbums: groupedAlbums,
+      albumCount: albumCount,
+      singleTracks: singleTracks,
+    );
   }
 
   void _navigateToDownloadedAlbum(_GroupedAlbum album) {
@@ -435,11 +425,10 @@ class _QueueTabState extends ConsumerState<QueueTab> {
     final colorScheme = Theme.of(context).colorScheme;
     final topPadding = MediaQuery.of(context).padding.top;
 
-    final groupedAlbums = _groupByAlbum(allHistoryItems);
-
-    final counts = _countAlbumsAndSingles(allHistoryItems);
-    final albumCount = _countUniqueAlbums(allHistoryItems);
-    final singleCount = counts['singles'] ?? 0;
+    final historyStats = _buildHistoryStats(allHistoryItems);
+    final groupedAlbums = historyStats.groupedAlbums;
+    final albumCount = historyStats.albumCount;
+    final singleCount = historyStats.singleTracks;
 
     final bottomPadding = MediaQuery.of(context).padding.bottom;
 
@@ -679,6 +668,7 @@ class _QueueTabState extends ConsumerState<QueueTab> {
                     historyViewMode: historyViewMode,
                     queueItems: queueItems,
                     groupedAlbums: groupedAlbums,
+                    albumCounts: historyStats.albumCounts,
                   ),
                   _buildFilterContent(
                     context: context,
@@ -688,6 +678,7 @@ class _QueueTabState extends ConsumerState<QueueTab> {
                     historyViewMode: historyViewMode,
                     queueItems: queueItems,
                     groupedAlbums: groupedAlbums,
+                    albumCounts: historyStats.albumCounts,
                   ),
                   _buildFilterContent(
                     context: context,
@@ -697,6 +688,7 @@ class _QueueTabState extends ConsumerState<QueueTab> {
                     historyViewMode: historyViewMode,
                     queueItems: queueItems,
                     groupedAlbums: groupedAlbums,
+                    albumCounts: historyStats.albumCounts,
                   ),
                 ],
               ),
@@ -713,7 +705,11 @@ class _QueueTabState extends ConsumerState<QueueTab> {
             child: _buildSelectionBottomBar(
               context,
               colorScheme,
-              _filterHistoryItems(allHistoryItems, historyFilterMode),
+              _filterHistoryItems(
+                allHistoryItems,
+                historyFilterMode,
+                historyStats.albumCounts,
+              ),
               bottomPadding,
             ),
           ),
@@ -722,7 +718,6 @@ class _QueueTabState extends ConsumerState<QueueTab> {
     );
   }
 
-  /// Build content for each filter tab
   Widget _buildFilterContent({
     required BuildContext context,
     required ColorScheme colorScheme,
@@ -731,8 +726,10 @@ class _QueueTabState extends ConsumerState<QueueTab> {
     required String historyViewMode,
     required List<DownloadItem> queueItems,
     required List<_GroupedAlbum> groupedAlbums,
+    required Map<String, int> albumCounts,
   }) {
-    final historyItems = _filterHistoryItems(allHistoryItems, filterMode);
+    final historyItems =
+        _filterHistoryItems(allHistoryItems, filterMode, albumCounts);
 
     return CustomScrollView(
       slivers: [
@@ -926,7 +923,6 @@ class _QueueTabState extends ConsumerState<QueueTab> {
     );
   }
 
-  /// Build album grid item for grouped albums view
   Widget _buildAlbumGridItem(
     BuildContext context,
     _GroupedAlbum album,
@@ -943,13 +939,14 @@ class _QueueTabState extends ConsumerState<QueueTab> {
                 ClipRRect(
                   borderRadius: BorderRadius.circular(12),
                   child: album.coverUrl != null
-                      ? CachedNetworkImage(
+? CachedNetworkImage(
                           imageUrl: album.coverUrl!,
                           fit: BoxFit.cover,
                           width: double.infinity,
                           height: double.infinity,
                           memCacheWidth: 300,
                           memCacheHeight: 300,
+                          cacheManager: CoverCacheManager.instance,
                         )
                       : Container(
                           color: colorScheme.surfaceContainerHighest,
@@ -1245,13 +1242,14 @@ class _QueueTabState extends ConsumerState<QueueTab> {
     return item.track.coverUrl != null
         ? ClipRRect(
             borderRadius: BorderRadius.circular(8),
-            child: CachedNetworkImage(
+child: CachedNetworkImage(
               imageUrl: item.track.coverUrl!,
               width: 56,
               height: 56,
               fit: BoxFit.cover,
               memCacheWidth: 112,
               memCacheHeight: 112,
+              cacheManager: CoverCacheManager.instance,
             ),
           )
         : Container(
@@ -1404,11 +1402,12 @@ class _QueueTabState extends ConsumerState<QueueTab> {
                     child: ClipRRect(
                       borderRadius: BorderRadius.circular(8),
                       child: item.coverUrl != null
-                          ? CachedNetworkImage(
+? CachedNetworkImage(
                               imageUrl: item.coverUrl!,
                               fit: BoxFit.cover,
                               memCacheWidth: 200,
                               memCacheHeight: 200,
+                              cacheManager: CoverCacheManager.instance,
                             )
                           : Container(
                               color: colorScheme.surfaceContainerHighest,
@@ -1613,13 +1612,14 @@ class _QueueTabState extends ConsumerState<QueueTab> {
               item.coverUrl != null
                   ? ClipRRect(
                       borderRadius: BorderRadius.circular(8),
-                      child: CachedNetworkImage(
+child: CachedNetworkImage(
                         imageUrl: item.coverUrl!,
                         width: 56,
                         height: 56,
                         fit: BoxFit.cover,
                         memCacheWidth: 112,
                         memCacheHeight: 112,
+                        cacheManager: CoverCacheManager.instance,
                       ),
                     )
                   : Container(
@@ -1736,7 +1736,6 @@ class _QueueTabState extends ConsumerState<QueueTab> {
   }
 }
 
-/// Filter chip widget for history filtering
 class _FilterChip extends StatelessWidget {
   final String label;
   final int count;

lib/screens/search_screen.dart

@@ -1,6 +1,8 @@
 import 'package:flutter/material.dart';
 import 'package:flutter_riverpod/flutter_riverpod.dart';
 import 'package:cached_network_image/cached_network_image.dart';
+import 'package:spotiflac_android/services/cover_cache_manager.dart';
+import 'package:spotiflac_android/models/track.dart';
 import 'package:spotiflac_android/providers/track_provider.dart';
 import 'package:spotiflac_android/providers/download_queue_provider.dart';
 import 'package:spotiflac_android/providers/settings_provider.dart';
@@ -43,22 +45,22 @@ class _SearchScreenState extends ConsumerState<SearchScreen> {
     }
   }
 
-  void _downloadTrack(int index) {
-    final trackState = ref.read(trackProvider);
-    if (index >= 0 && index < trackState.tracks.length) {
-      final track = trackState.tracks[index];
-      final settings = ref.read(settingsProvider);
-      ref.read(downloadQueueProvider.notifier).addToQueue(track, settings.defaultService);
-      ScaffoldMessenger.of(context).showSnackBar(
-        SnackBar(content: Text('Added "${track.name}" to queue')),
-      );
-    }
+  void _downloadTrack(Track track) {
+    final settings = ref.read(settingsProvider);
+    ref.read(downloadQueueProvider.notifier).addToQueue(
+      track,
+      settings.defaultService,
+    );
+    ScaffoldMessenger.of(context).showSnackBar(
+      SnackBar(content: Text('Added "${track.name}" to queue')),
+    );
   }
 
   @override
   Widget build(BuildContext context) {
     final trackState = ref.watch(trackProvider);
     final colorScheme = Theme.of(context).colorScheme;
+    final tracks = trackState.tracks;
 
     return Scaffold(
       appBar: AppBar(
@@ -95,11 +97,12 @@ class _SearchScreenState extends ConsumerState<SearchScreen> {
               ),
             ),
           Expanded(
-            child: trackState.tracks.isEmpty
+            child: tracks.isEmpty
                 ? _buildEmptyState(colorScheme)
                 : ListView.builder(
-                    itemCount: trackState.tracks.length,
-                    itemBuilder: (context, index) => _buildTrackTile(index, colorScheme),
+                    itemCount: tracks.length,
+                    itemBuilder: (context, index) =>
+                        _buildTrackTile(tracks[index], colorScheme),
                   ),
           ),
         ],
@@ -129,17 +132,17 @@ class _SearchScreenState extends ConsumerState<SearchScreen> {
     );
   }
 
-  Widget _buildTrackTile(int index, ColorScheme colorScheme) {
-    final track = ref.watch(trackProvider).tracks[index];
+  Widget _buildTrackTile(Track track, ColorScheme colorScheme) {
     return ListTile(
       leading: track.coverUrl != null
           ? ClipRRect(
               borderRadius: BorderRadius.circular(8),
-              child: CachedNetworkImage(
+child: CachedNetworkImage(
                 imageUrl: track.coverUrl!,
                 width: 48,
                 height: 48,
                 fit: BoxFit.cover,
+                cacheManager: CoverCacheManager.instance,
               ),
             )
           : Container(
@@ -173,9 +176,9 @@ class _SearchScreenState extends ConsumerState<SearchScreen> {
       ),
       trailing: IconButton(
         icon: Icon(Icons.download, color: colorScheme.primary),
-        onPressed: () => _downloadTrack(index),
+        onPressed: () => _downloadTrack(track),
       ),
-      onTap: () => _downloadTrack(index),
+      onTap: () => _downloadTrack(track),
     );
   }
 }

lib/screens/settings/about_page.dart

@@ -1,6 +1,7 @@
 import 'package:flutter/material.dart';
 import 'package:url_launcher/url_launcher.dart';
 import 'package:cached_network_image/cached_network_image.dart';
+import 'package:spotiflac_android/services/cover_cache_manager.dart';
 import 'package:spotiflac_android/constants/app_info.dart';
 import 'package:spotiflac_android/l10n/l10n.dart';
 import 'package:spotiflac_android/widgets/settings_group.dart';
@@ -14,7 +15,7 @@ class AboutPage extends StatelessWidget {
     final topPadding = MediaQuery.of(context).padding.top;
 
     return PopScope(
-      canPop: true, // Always allow back gesture
+      canPop: true,
       child: Scaffold(
         body: CustomScrollView(
           slivers: [
@@ -252,9 +253,9 @@ class _AppHeaderCard extends StatelessWidget {
               color: colorScheme.primary,
               shape: BoxShape.circle,
             ),
-            child: Image.asset(
+            child:             Image.asset(
               'assets/images/logo-transparant.png',
-              color: colorScheme.onPrimary, // Tint with onPrimary color
+              color: colorScheme.onPrimary,
               fit: BoxFit.contain,
               errorBuilder: (_, _, _) => ClipRRect(
                 borderRadius: BorderRadius.circular(24),
@@ -333,11 +334,12 @@ class _ContributorItem extends StatelessWidget {
               children: [
                 ClipRRect(
                   borderRadius: BorderRadius.circular(12),
-                  child: CachedNetworkImage(
+child: CachedNetworkImage(
                     imageUrl: 'https://github.com/$githubUsername.png',
                     width: 40,
                     height: 40,
                     fit: BoxFit.cover,
+                    cacheManager: CoverCacheManager.instance,
                     placeholder: (context, url) => Container(
                       width: 40,
                       height: 40,

lib/screens/settings/appearance_settings_page.dart

@@ -17,7 +17,7 @@ class AppearanceSettingsPage extends ConsumerWidget {
     final topPadding = MediaQuery.of(context).padding.top;
 
     return PopScope(
-      canPop: true, // Always allow back gesture
+      canPop: true,
       child: Scaffold(
         body: CustomScrollView(
           slivers: [
@@ -161,7 +161,7 @@ class _ThemePreviewCard extends StatelessWidget {
         width: double.infinity,
         decoration: BoxDecoration(
           color: colorScheme
-              .surfaceContainerHighest, // Background similar to reference
+              .surfaceContainerHighest,
           borderRadius: BorderRadius.circular(28),
         ),
         clipBehavior: Clip.antiAlias,
@@ -203,7 +203,7 @@ class _ThemePreviewCard extends StatelessWidget {
                   boxShadow: [
                     BoxShadow(
                       color: Colors.black.withValues(alpha: 0.1),
-                      blurRadius: 12, // Reduced from 20 for performance
+                      blurRadius: 12,
                       offset: const Offset(0, 8),
                     ),
                   ],
@@ -707,7 +707,7 @@ static const _allLanguages = [
     ('ko', '한국어', Icons.language),
     ('nl', 'Nederlands', Icons.language),
     ('pt', 'Português', Icons.language),
-    ('pt_PT', 'Português (Portugal)', Icons.language),
+    ('pt_PT', 'Português (Brasil)', Icons.language),
     ('ru', 'Русский', Icons.language),
     ('zh', '简体中文', Icons.language),
     ('zh_CN', '简体中文 (中国)', Icons.language),

lib/screens/settings/download_settings_page.dart

@@ -22,7 +22,7 @@ class DownloadSettingsPage extends ConsumerWidget {
     final isBuiltInService = _builtInServices.contains(settings.defaultService);
 
     return PopScope(
-      canPop: true, // Always allow back gesture
+      canPop: true,
       child: Scaffold(
         body: CustomScrollView(
           slivers: [
@@ -169,14 +169,35 @@ class DownloadSettingsPage extends ConsumerWidget {
                         ],
                       ),
                     ),
-                  ],
                 ],
-              ),
+              ],
             ),
+          ),
 
-            SliverToBoxAdapter(
-              child: SettingsSectionHeader(title: context.l10n.sectionFileSettings),
+          SliverToBoxAdapter(
+            child: SettingsSectionHeader(title: context.l10n.sectionLyrics),
+          ),
+          SliverToBoxAdapter(
+            child: SettingsGroup(
+              children: [
+                SettingsItem(
+                  icon: Icons.lyrics_outlined,
+                  title: context.l10n.lyricsMode,
+                  subtitle: _getLyricsModeLabel(context, settings.lyricsMode),
+                  onTap: () => _showLyricsModePicker(
+                    context,
+                    ref,
+                    settings.lyricsMode,
+                  ),
+                  showDivider: false,
+                ),
+              ],
             ),
+          ),
+
+          SliverToBoxAdapter(
+            child: SettingsSectionHeader(title: context.l10n.sectionFileSettings),
+          ),
             SliverToBoxAdapter(
               child: SettingsGroup(
                 children: [
@@ -606,6 +627,89 @@ class DownloadSettingsPage extends ConsumerWidget {
     }
   }
 
+  String _getLyricsModeLabel(BuildContext context, String mode) {
+    switch (mode) {
+      case 'external':
+        return context.l10n.lyricsModeExternal;
+      case 'both':
+        return context.l10n.lyricsModeBoth;
+      default:
+        return context.l10n.lyricsModeEmbed;
+    }
+  }
+
+  void _showLyricsModePicker(
+    BuildContext context,
+    WidgetRef ref,
+    String current,
+  ) {
+    final colorScheme = Theme.of(context).colorScheme;
+    showModalBottomSheet(
+      context: context,
+      backgroundColor: colorScheme.surfaceContainerHigh,
+      shape: const RoundedRectangleBorder(
+        borderRadius: BorderRadius.vertical(top: Radius.circular(28)),
+      ),
+      builder: (context) => SafeArea(
+        child: Column(
+          mainAxisSize: MainAxisSize.min,
+          crossAxisAlignment: CrossAxisAlignment.start,
+          children: [
+            Padding(
+              padding: const EdgeInsets.fromLTRB(24, 24, 24, 8),
+              child: Text(
+                context.l10n.lyricsMode,
+                style: Theme.of(
+                  context,
+                ).textTheme.titleLarge?.copyWith(fontWeight: FontWeight.bold),
+              ),
+            ),
+            Padding(
+              padding: const EdgeInsets.fromLTRB(24, 0, 24, 16),
+              child: Text(
+                context.l10n.lyricsModeDescription,
+                style: Theme.of(context).textTheme.bodyMedium?.copyWith(
+                  color: colorScheme.onSurfaceVariant,
+                ),
+              ),
+            ),
+            ListTile(
+              leading: const Icon(Icons.audiotrack),
+              title: Text(context.l10n.lyricsModeEmbed),
+              subtitle: Text(context.l10n.lyricsModeEmbedSubtitle),
+              trailing: current == 'embed' ? const Icon(Icons.check) : null,
+              onTap: () {
+                ref.read(settingsProvider.notifier).setLyricsMode('embed');
+                Navigator.pop(context);
+              },
+            ),
+            ListTile(
+              leading: const Icon(Icons.insert_drive_file_outlined),
+              title: Text(context.l10n.lyricsModeExternal),
+              subtitle: Text(context.l10n.lyricsModeExternalSubtitle),
+              trailing: current == 'external' ? const Icon(Icons.check) : null,
+              onTap: () {
+                ref.read(settingsProvider.notifier).setLyricsMode('external');
+                Navigator.pop(context);
+              },
+            ),
+            ListTile(
+              leading: const Icon(Icons.library_music_outlined),
+              title: Text(context.l10n.lyricsModeBoth),
+              subtitle: Text(context.l10n.lyricsModeBothSubtitle),
+              trailing: current == 'both' ? const Icon(Icons.check) : null,
+              onTap: () {
+                ref.read(settingsProvider.notifier).setLyricsMode('both');
+                Navigator.pop(context);
+              },
+            ),
+            const SizedBox(height: 16),
+          ],
+        ),
+      ),
+    );
+  }
+
   void _showFolderOrganizationPicker(
     BuildContext context,
     WidgetRef ref,

lib/screens/setup_screen.dart

@@ -581,7 +581,7 @@ class _SetupScreenState extends ConsumerState<SetupScreen> {
       switch (step) {
         case 0: return _storagePermissionGranted;
         case 1: return _selectedDirectory != null;
-        case 2: return false; // Spotify step never shows checkmark (optional)
+        case 2: return false;
       }
     }
     return false;

lib/screens/store_tab.dart

@@ -122,7 +122,7 @@ class _StoreTabState extends ConsumerState<StoreTab> {
                   ),
                   onChanged: (value) {
                     ref.read(storeProvider.notifier).setSearchQuery(value);
-                    setState(() {}); // Update suffix icon
+                    setState(() {});
                   },
                 ),
               ),

lib/screens/track_metadata_screen.dart

@@ -5,6 +5,7 @@ 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/utils/mime_utils.dart';
 import 'package:url_launcher/url_launcher.dart';
 import 'package:share_plus/share_plus.dart';
@@ -12,8 +13,6 @@ import 'package:spotiflac_android/providers/download_queue_provider.dart';
 import 'package:spotiflac_android/services/platform_bridge.dart';
 import 'package:spotiflac_android/l10n/l10n.dart';
 
-/// Screen to display detailed metadata for a downloaded track
-/// Designed with Material Expressive 3 style
 class TrackMetadataScreen extends ConsumerStatefulWidget {
   final DownloadHistoryItem item;
 
@@ -32,6 +31,22 @@ class _TrackMetadataScreenState extends ConsumerState<TrackMetadataScreen> {
   Color? _dominantColor;
   bool _showTitleInAppBar = false;
   final ScrollController _scrollController = ScrollController();
+  static final RegExp _lrcTimestampPattern =
+      RegExp(r'^\[\d{2}:\d{2}\.\d{2,3}\]');
+  static const List<String> _months = [
+    'Jan',
+    'Feb',
+    'Mar',
+    'Apr',
+    'May',
+    'Jun',
+    'Jul',
+    'Aug',
+    'Sep',
+    'Oct',
+    'Nov',
+    'Dec',
+  ];
 
   String? _normalizeOptionalString(String? value) {
     if (value == null) return null;
@@ -64,21 +79,26 @@ class _TrackMetadataScreenState extends ConsumerState<TrackMetadataScreen> {
   }
 
   Future<void> _extractDominantColor() async {
-    if (widget.item.coverUrl == null) return;
+    final coverUrl = widget.item.coverUrl;
+    if (coverUrl == null || coverUrl.isEmpty) return;
+    if (!coverUrl.startsWith('http://') && !coverUrl.startsWith('https://')) {
+      return;
+    }
     try {
       final paletteGenerator = await PaletteGenerator.fromImageProvider(
-        CachedNetworkImageProvider(widget.item.coverUrl!),
-        maximumColorCount: 16,
+        CachedNetworkImageProvider(coverUrl),
+        size: const Size(128, 128),
+        maximumColorCount: 12,
       );
-      if (mounted) {
+      final nextColor = paletteGenerator.dominantColor?.color ??
+          paletteGenerator.vibrantColor?.color ??
+          paletteGenerator.mutedColor?.color;
+      if (mounted && nextColor != _dominantColor) {
         setState(() {
-          _dominantColor = paletteGenerator.dominantColor?.color ??
-              paletteGenerator.vibrantColor?.color ??
-              paletteGenerator.mutedColor?.color;
+          _dominantColor = nextColor;
         });
       }
     } catch (_) {
-      // Ignore palette extraction errors
     }
   }
 
@@ -87,26 +107,26 @@ class _TrackMetadataScreenState extends ConsumerState<TrackMetadataScreen> {
     if (filePath.startsWith('EXISTS:')) {
       filePath = filePath.substring(7);
     }
-    
-    final file = File(filePath);
-    final exists = await file.exists();
+
+    bool exists = false;
     int? size;
-    
-    if (exists) {
-      try {
-        size = await file.length();
-      } catch (_) {}
-    }
-    
-    if (mounted) {
+    try {
+      final stat = await FileStat.stat(filePath);
+      exists = stat.type != FileSystemEntityType.notFound;
+      if (exists) {
+        size = stat.size;
+      }
+    } catch (_) {}
+
+    if (mounted && (exists != _fileExists || size != _fileSize)) {
       setState(() {
         _fileExists = exists;
         _fileSize = size;
       });
-      
-      if (exists) {
-        _fetchLyrics();
-      }
+    }
+
+    if (mounted && exists && _lyrics == null && !_lyricsLoading) {
+      _fetchLyrics();
     }
   }
 
@@ -119,6 +139,9 @@ class _TrackMetadataScreenState extends ConsumerState<TrackMetadataScreen> {
   int? get discNumber => item.discNumber;
   String? get releaseDate => item.releaseDate;
   String? get isrc => item.isrc;
+  String? get genre => item.genre;
+  String? get label => item.label;
+  String? get copyright => item.copyright;
   
   String get cleanFilePath {
     final path = item.filePath;
@@ -237,7 +260,6 @@ class _TrackMetadataScreenState extends ConsumerState<TrackMetadataScreen> {
     return Stack(
       fit: StackFit.expand,
       children: [
-        // Background with dominant color
         AnimatedContainer(
           duration: const Duration(milliseconds: 500),
           decoration: BoxDecoration(
@@ -254,7 +276,6 @@ class _TrackMetadataScreenState extends ConsumerState<TrackMetadataScreen> {
           ),
         ),
         
-        // Cover image centered - fade out when collapsing
         AnimatedOpacity(
           duration: const Duration(milliseconds: 150),
           opacity: showContent ? 1.0 : 0.0,
@@ -279,10 +300,11 @@ class _TrackMetadataScreenState extends ConsumerState<TrackMetadataScreen> {
                   child: ClipRRect(
                     borderRadius: BorderRadius.circular(20),
                     child: item.coverUrl != null
-                        ? CachedNetworkImage(
+? CachedNetworkImage(
                             imageUrl: item.coverUrl!,
                             fit: BoxFit.cover,
                             memCacheWidth: (coverSize * 2).toInt(),
+                            cacheManager: CoverCacheManager.instance,
                             placeholder: (_, _) => Container(
                               color: colorScheme.surfaceContainerHighest,
                               child: Icon(
@@ -519,6 +541,12 @@ class _TrackMetadataScreenState extends ConsumerState<TrackMetadataScreen> {
         _MetadataItem(context.l10n.trackAudioQuality, audioQualityStr),
       if (releaseDate != null && releaseDate!.isNotEmpty)
         _MetadataItem(context.l10n.trackReleaseDate, releaseDate!),
+      if (genre != null && genre!.isNotEmpty)
+        _MetadataItem(context.l10n.trackGenre, genre!),
+      if (label != null && label!.isNotEmpty)
+        _MetadataItem(context.l10n.trackLabel, label!),
+      if (copyright != null && copyright!.isNotEmpty)
+        _MetadataItem(context.l10n.trackCopyright, copyright!),
       if (isrc != null && isrc!.isNotEmpty)
         _MetadataItem('ISRC', isrc!),
     ];
@@ -650,7 +678,6 @@ class _TrackMetadataScreenState extends ConsumerState<TrackMetadataScreen> {
                       ),
                     ),
                   ),
-                // Show 320kbps for MP3, bit depth/sample rate for FLAC
                 if (fileExtension == 'MP3')
                   Container(
                     padding: const EdgeInsets.symmetric(horizontal: 12, vertical: 6),
@@ -900,10 +927,9 @@ class _TrackMetadataScreenState extends ConsumerState<TrackMetadataScreen> {
   String _cleanLrcForDisplay(String lrc) {
     final lines = lrc.split('\n');
     final cleanLines = <String>[];
-    final timestampPattern = RegExp(r'^\[\d{2}:\d{2}\.\d{2,3}\]');
     
     for (final line in lines) {
-      final cleanLine = line.replaceAll(timestampPattern, '').trim();
+      final cleanLine = line.replaceAll(_lrcTimestampPattern, '').trim();
       if (cleanLine.isNotEmpty) {
         cleanLines.add(cleanLine);
       }
@@ -1025,8 +1051,8 @@ class _TrackMetadataScreenState extends ConsumerState<TrackMetadataScreen> {
               ref.read(downloadHistoryProvider.notifier).removeFromHistory(item.id);
               
               if (context.mounted) {
-                Navigator.pop(context); // Close dialog
-                Navigator.pop(context); // Go back to history
+                Navigator.pop(context);
+                Navigator.pop(context);
               }
             },
             child: Text(context.l10n.dialogDelete, style: TextStyle(color: colorScheme.error)),
@@ -1084,9 +1110,7 @@ class _TrackMetadataScreenState extends ConsumerState<TrackMetadataScreen> {
   }
 
   String _formatFullDate(DateTime date) {
-    final months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 
-                    'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
-    return '${date.day} ${months[date.month - 1]} ${date.year}, '
+    return '${date.day} ${_months[date.month - 1]} ${date.year}, '
            '${date.hour.toString().padLeft(2, '0')}:'
            '${date.minute.toString().padLeft(2, '0')}';
   }

lib/services/cover_cache_manager.dart

@@ -0,0 +1,122 @@
+import 'dart:io';
+import 'package:flutter/foundation.dart';
+import 'package:flutter_cache_manager/flutter_cache_manager.dart';
+import 'package:path_provider/path_provider.dart';
+import 'package:path/path.dart' as p;
+
+/// Persistent cache manager for album/track cover images.
+/// 
+/// Unlike the default cache manager which stores in temp directory
+/// (can be cleared by system anytime), this stores in app support
+/// directory which persists across app restarts.
+class CoverCacheManager {
+  static const String _cacheKey = 'coverImageCache';
+  static const int _maxCacheObjects = 1000;
+  static const Duration _maxCacheAge = Duration(days: 365);
+
+  static CacheManager? _instance;
+  static bool _initialized = false;
+  static String? _cachePath;
+
+  static CacheManager get instance {
+    if (!_initialized || _instance == null) {
+      // Fallback to default cache manager if not initialized
+      debugPrint('CoverCacheManager: Not initialized, using DefaultCacheManager');
+      return DefaultCacheManager();
+    }
+    return _instance!;
+  }
+
+  /// Check if cache manager is initialized
+  static bool get isInitialized => _initialized && _instance != null;
+
+  static Future<void> initialize() async {
+    if (_initialized) return;
+
+    try {
+      final appDir = await getApplicationSupportDirectory();
+      _cachePath = p.join(appDir.path, 'cover_cache');
+      
+      // Ensure cache directory exists
+      await Directory(_cachePath!).create(recursive: true);
+      
+      debugPrint('CoverCacheManager: Initializing at $_cachePath');
+
+      _instance = CacheManager(
+        Config(
+          _cacheKey,
+          stalePeriod: _maxCacheAge,
+          maxNrOfCacheObjects: _maxCacheObjects,
+          // Use path only (not databaseName) to store database in persistent directory
+          repo: JsonCacheInfoRepository(path: _cachePath),
+          fileSystem: IOFileSystem(_cachePath!),
+          fileService: HttpFileService(),
+        ),
+      );
+      
+      _initialized = true;
+      debugPrint('CoverCacheManager: Initialized successfully');
+    } catch (e) {
+      debugPrint('CoverCacheManager: Failed to initialize: $e');
+      // Will fallback to DefaultCacheManager
+    }
+  }
+
+  /// Clear all cached cover images.
+  /// Returns the number of files deleted.
+  static Future<void> clearCache() async {
+    if (!_initialized || _instance == null) return;
+    await _instance!.emptyCache();
+  }
+
+  static Future<CacheStats> getStats() async {
+    if (!_initialized || _cachePath == null) {
+      return const CacheStats(fileCount: 0, totalSizeBytes: 0);
+    }
+
+    final cacheDir = Directory(_cachePath!);
+    
+    if (!await cacheDir.exists()) {
+      return const CacheStats(fileCount: 0, totalSizeBytes: 0);
+    }
+
+    int fileCount = 0;
+    int totalSize = 0;
+
+    try {
+      await for (final entity in cacheDir.list(recursive: true)) {
+        if (entity is File) {
+          fileCount++;
+          totalSize += await entity.length();
+        }
+      }
+    } catch (e) {
+      debugPrint('CoverCacheManager: Error getting stats: $e');
+    }
+
+    return CacheStats(fileCount: fileCount, totalSizeBytes: totalSize);
+  }
+}
+
+/// Statistics about the cover image cache
+class CacheStats {
+  final int fileCount;
+  final int totalSizeBytes;
+
+  const CacheStats({
+    required this.fileCount,
+    required this.totalSizeBytes,
+  });
+
+  String get formattedSize {
+    if (totalSizeBytes < 1024) {
+      return '$totalSizeBytes B';
+    } else if (totalSizeBytes < 1024 * 1024) {
+      return '${(totalSizeBytes / 1024).toStringAsFixed(1)} KB';
+    } else if (totalSizeBytes < 1024 * 1024 * 1024) {
+      return '${(totalSizeBytes / (1024 * 1024)).toStringAsFixed(1)} MB';
+    } else {
+      return '${(totalSizeBytes / (1024 * 1024 * 1024)).toStringAsFixed(2)} GB';
+    }
+  }
+}

lib/services/csv_import_service.dart

@@ -7,8 +7,6 @@ import 'package:spotiflac_android/utils/logger.dart';
 class CsvImportService {
   static final _log = AppLogger('CsvImportService');
 
-  /// Pick and parse CSV file, then enrich metadata from Deezer
-  /// [onProgress] callback receives (current, total) for progress updates
   static Future<List<Track>> pickAndParseCsv({
     void Function(int current, int total)? onProgress,
   }) async {
@@ -34,8 +32,6 @@ class CsvImportService {
     return [];
   }
 
-  /// Enrich tracks with metadata from Deezer using ISRC or search
-  /// This fetches cover URL, duration, and other metadata that CSV doesn't have
   static Future<List<Track>> _enrichTracksMetadata(
     List<Track> tracks, {
     void Function(int current, int total)? onProgress,

lib/services/ffmpeg_service.dart

@@ -10,7 +10,6 @@ final _log = AppLogger('FFmpeg');
 class FFmpegService {
   static const _channel = MethodChannel('com.zarz.spotiflac/ffmpeg');
 
-  /// Execute FFmpeg command and return result
   static Future<FFmpegResult> _execute(String command) async {
     try {
       final result = await _channel.invokeMethod('execute', {'command': command});
@@ -26,8 +25,6 @@ class FFmpegService {
     }
   }
 
-  /// Convert M4A (DASH segments) to FLAC
-  /// Returns the output file path on success, null on failure
   static Future<String?> convertM4aToFlac(String inputPath) async {
     final outputPath = inputPath.replaceAll('.m4a', '.flac');
 
@@ -47,14 +44,11 @@ class FFmpegService {
     return null;
   }
 
-  /// Convert FLAC to MP3
-  /// If deleteOriginal is true, deletes the FLAC file after conversion
   static Future<String?> convertFlacToMp3(
     String inputPath, {
     String bitrate = '320k',
     bool deleteOriginal = true,
   }) async {
-    // Convert in same folder, just change extension
     final outputPath = inputPath.replaceAll('.flac', '.mp3');
 
     final command =
@@ -63,7 +57,6 @@ class FFmpegService {
     final result = await _execute(command);
 
     if (result.success) {
-      // Delete original FLAC if requested
       if (deleteOriginal) {
         try {
           await File(inputPath).delete();
@@ -76,7 +69,6 @@ class FFmpegService {
     return null;
   }
 
-  /// Convert FLAC to M4A (AAC or ALAC)
   static Future<String?> convertFlacToM4a(
     String inputPath, {
     String codec = 'aac',
@@ -110,7 +102,6 @@ class FFmpegService {
     return null;
   }
 
-  /// Check if FFmpeg is available
   static Future<bool> isAvailable() async {
     try {
       final version = await _channel.invokeMethod('getVersion');
@@ -120,7 +111,6 @@ class FFmpegService {
     }
   }
 
-  /// Get FFmpeg version info
   static Future<String?> getVersion() async {
     try {
       final version = await _channel.invokeMethod('getVersion');
@@ -130,8 +120,6 @@ class FFmpegService {
     }
   }
 
-  /// Embed metadata and cover art to FLAC file
-  /// Returns the file path on success, null on failure
   static Future<String?> embedMetadata({
     required String flacPath,
     String? coverPath,
@@ -211,8 +199,6 @@ class FFmpegService {
     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,
@@ -242,7 +228,6 @@ class FFmpegService {
     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('"', '\\"');
@@ -295,7 +280,6 @@ class FFmpegService {
     return null;
   }
 
-  /// Convert FLAC/Vorbis comment tags to ID3v2 compatible tags
   static Map<String, String> _convertToId3Tags(Map<String, String> vorbisMetadata) {
     final id3Map = <String, String>{};
     
@@ -330,7 +314,7 @@ class FFmpegService {
           id3Map['date'] = value;
           break;
         case 'ISRC':
-          id3Map['TSRC'] = value; // ID3v2 ISRC frame
+          id3Map['TSRC'] = value;
           break;
         case 'LYRICS':
         case 'UNSYNCEDLYRICS':
@@ -346,7 +330,6 @@ class FFmpegService {
   }
 }
 
-/// Result of FFmpeg command execution
 class FFmpegResult {
   final bool success;
   final int returnCode;

lib/services/platform_bridge.dart

@@ -4,25 +4,21 @@ import 'package:spotiflac_android/utils/logger.dart';
 
 final _log = AppLogger('PlatformBridge');
 
-/// Bridge to communicate with Go backend via platform channels
 class PlatformBridge {
   static const _channel = MethodChannel('com.zarz.spotiflac/backend');
 
-  /// Parse and validate Spotify URL
   static Future<Map<String, dynamic>> parseSpotifyUrl(String url) async {
     _log.d('parseSpotifyUrl: $url');
     final result = await _channel.invokeMethod('parseSpotifyUrl', {'url': url});
     return jsonDecode(result as String) as Map<String, dynamic>;
   }
 
-  /// Get Spotify metadata from URL
   static Future<Map<String, dynamic>> getSpotifyMetadata(String url) async {
     _log.d('getSpotifyMetadata: $url');
     final result = await _channel.invokeMethod('getSpotifyMetadata', {'url': url});
     return jsonDecode(result as String) as Map<String, dynamic>;
   }
 
-  /// Search Spotify
   static Future<Map<String, dynamic>> searchSpotify(String query, {int limit = 10}) async {
     _log.d('searchSpotify: "$query" (limit: $limit)');
     final result = await _channel.invokeMethod('searchSpotify', {
@@ -32,7 +28,6 @@ class PlatformBridge {
     return jsonDecode(result as String) as Map<String, dynamic>;
   }
 
-  /// Search Spotify for tracks and artists
   static Future<Map<String, dynamic>> searchSpotifyAll(String query, {int trackLimit = 15, int artistLimit = 3}) async {
     _log.d('searchSpotifyAll: "$query"');
     final result = await _channel.invokeMethod('searchSpotifyAll', {
@@ -43,7 +38,6 @@ class PlatformBridge {
     return jsonDecode(result as String) as Map<String, dynamic>;
   }
 
-  /// Check track availability on streaming services
   static Future<Map<String, dynamic>> checkAvailability(String spotifyId, String isrc) async {
     _log.d('checkAvailability: $spotifyId (ISRC: $isrc)');
     final result = await _channel.invokeMethod('checkAvailability', {
@@ -53,7 +47,6 @@ class PlatformBridge {
     return jsonDecode(result as String) as Map<String, dynamic>;
   }
 
-  /// Download a track from specific service
   static Future<Map<String, dynamic>> downloadTrack({
     required String isrc,
     required String service,
@@ -108,7 +101,6 @@ class PlatformBridge {
     return response;
   }
 
-  /// Download with automatic fallback to other services
   static Future<Map<String, dynamic>> downloadWithFallback({
     required String isrc,
     required String spotifyId,
@@ -129,10 +121,10 @@ class PlatformBridge {
     String preferredService = 'tidal',
     String? itemId,
     int durationMs = 0,
-    // Extended metadata for FLAC tagging
     String? genre,
     String? label,
     String? copyright,
+    String lyricsMode = 'embed',
   }) async {
     _log.i('downloadWithFallback: "$trackName" by $artistName (preferred: $preferredService)');
     final request = jsonEncode({
@@ -155,10 +147,10 @@ class PlatformBridge {
       'release_date': releaseDate ?? '',
       'item_id': itemId ?? '',
       'duration_ms': durationMs,
-      // Extended metadata
       'genre': genre ?? '',
       'label': label ?? '',
       'copyright': copyright ?? '',
+      'lyrics_mode': lyricsMode,
     });
     
     final result = await _channel.invokeMethod('downloadWithFallback', request);
@@ -180,44 +172,36 @@ class PlatformBridge {
     return response;
   }
 
-  /// Get download progress (legacy single download)
   static Future<Map<String, dynamic>> getDownloadProgress() async {
     final result = await _channel.invokeMethod('getDownloadProgress');
     return jsonDecode(result as String) as Map<String, dynamic>;
   }
 
-  /// Get progress for all active downloads (concurrent mode)
   static Future<Map<String, dynamic>> getAllDownloadProgress() async {
     final result = await _channel.invokeMethod('getAllDownloadProgress');
     return jsonDecode(result as String) as Map<String, dynamic>;
   }
 
-  /// Initialize progress tracking for a download item
   static Future<void> initItemProgress(String itemId) async {
     await _channel.invokeMethod('initItemProgress', {'item_id': itemId});
   }
 
-  /// Finish progress tracking for a download item
   static Future<void> finishItemProgress(String itemId) async {
     await _channel.invokeMethod('finishItemProgress', {'item_id': itemId});
   }
 
-  /// Clear progress tracking for a download item
   static Future<void> clearItemProgress(String itemId) async {
     await _channel.invokeMethod('clearItemProgress', {'item_id': itemId});
   }
 
-  /// Cancel an in-progress download
   static Future<void> cancelDownload(String itemId) async {
     await _channel.invokeMethod('cancelDownload', {'item_id': itemId});
   }
 
-  /// Set download directory
   static Future<void> setDownloadDirectory(String path) async {
     await _channel.invokeMethod('setDownloadDirectory', {'path': path});
   }
 
-  /// Check if file with ISRC already exists
   static Future<Map<String, dynamic>> checkDuplicate(String outputDir, String isrc) async {
     final result = await _channel.invokeMethod('checkDuplicate', {
       'output_dir': outputDir,
@@ -226,7 +210,6 @@ class PlatformBridge {
     return jsonDecode(result as String) as Map<String, dynamic>;
   }
 
-  /// Build filename from template
   static Future<String> buildFilename(String template, Map<String, dynamic> metadata) async {
     final result = await _channel.invokeMethod('buildFilename', {
       'template': template,
@@ -235,7 +218,6 @@ class PlatformBridge {
     return result as String;
   }
 
-  /// Sanitize filename
   static Future<String> sanitizeFilename(String filename) async {
     final result = await _channel.invokeMethod('sanitizeFilename', {
       'filename': filename,
@@ -243,8 +225,6 @@ class PlatformBridge {
     return result as String;
   }
 
-  /// Fetch lyrics for a track
-  /// [durationMs] is the track duration in milliseconds for better matching
   static Future<Map<String, dynamic>> fetchLyrics(
     String spotifyId,
     String trackName,
@@ -260,9 +240,6 @@ class PlatformBridge {
     return jsonDecode(result as String) as Map<String, dynamic>;
   }
 
-  /// Get lyrics in LRC format
-  /// First tries to extract from embedded file, then falls back to internet
-  /// [durationMs] is the track duration in milliseconds for better matching
   static Future<String> getLyricsLRC(
     String spotifyId,
     String trackName,
@@ -280,7 +257,6 @@ class PlatformBridge {
     return result as String;
   }
 
-  /// Embed lyrics into an existing FLAC file
   static Future<Map<String, dynamic>> embedLyricsToFile(
     String filePath,
     String lyrics,
@@ -292,15 +268,10 @@ class PlatformBridge {
     return jsonDecode(result as String) as Map<String, dynamic>;
   }
 
-  /// Cleanup idle HTTP connections to prevent TCP exhaustion
-  /// Call this periodically during large batch downloads
   static Future<void> cleanupConnections() async {
     await _channel.invokeMethod('cleanupConnections');
   }
 
-  /// Read metadata directly from a FLAC file
-  /// Returns all embedded metadata (title, artist, album, track number, etc.)
-  /// This reads from the actual file, not from cached/database data
   static Future<Map<String, dynamic>> readFileMetadata(String filePath) async {
     final result = await _channel.invokeMethod('readFileMetadata', {
       'file_path': filePath,
@@ -308,7 +279,6 @@ class PlatformBridge {
     return jsonDecode(result as String) as Map<String, dynamic>;
   }
 
-  /// Start foreground download service to keep downloads running in background
   static Future<void> startDownloadService({
     String trackName = '',
     String artistName = '',
@@ -321,12 +291,10 @@ class PlatformBridge {
     });
   }
 
-  /// Stop foreground download service
   static Future<void> stopDownloadService() async {
     await _channel.invokeMethod('stopDownloadService');
   }
 
-  /// Update download service notification progress
   static Future<void> updateDownloadServiceProgress({
     required String trackName,
     required String artistName,
@@ -343,13 +311,11 @@ class PlatformBridge {
     });
   }
 
-  /// Check if download service is running
   static Future<bool> isDownloadServiceRunning() async {
     final result = await _channel.invokeMethod('isDownloadServiceRunning');
     return result as bool;
   }
 
-  /// Set custom Spotify API credentials
   static Future<void> setSpotifyCredentials(String clientId, String clientSecret) async {
     await _channel.invokeMethod('setSpotifyCredentials', {
       'client_id': clientId,
@@ -357,35 +323,26 @@ class PlatformBridge {
     });
   }
 
-  /// Check if Spotify credentials are configured
   /// Returns true if credentials are available (custom or env vars)
   static Future<bool> hasSpotifyCredentials() async {
     final result = await _channel.invokeMethod('hasSpotifyCredentials');
     return result as bool;
   }
 
-  /// Pre-warm track ID cache for album/playlist tracks
-  /// This runs in background and returns immediately
-  /// Speeds up subsequent downloads by caching ISRC → Track ID mappings
   static Future<void> preWarmTrackCache(List<Map<String, String>> tracks) async {
     final tracksJson = jsonEncode(tracks);
     await _channel.invokeMethod('preWarmTrackCache', {'tracks': tracksJson});
   }
 
-  /// Get current track cache size
   static Future<int> getTrackCacheSize() async {
     final result = await _channel.invokeMethod('getTrackCacheSize');
     return result as int;
   }
 
-  /// Clear track ID cache
   static Future<void> clearTrackCache() async {
     await _channel.invokeMethod('clearTrackCache');
   }
 
-  // ==================== DEEZER API ====================
-
-  /// Search Deezer for tracks and artists (no API key required)
   static Future<Map<String, dynamic>> searchDeezerAll(String query, {int trackLimit = 15, int artistLimit = 3}) async {
     final result = await _channel.invokeMethod('searchDeezerAll', {
       'query': query,
@@ -395,7 +352,6 @@ class PlatformBridge {
     return jsonDecode(result as String) as Map<String, dynamic>;
   }
 
-  /// Get Deezer metadata by type and ID
   static Future<Map<String, dynamic>> getDeezerMetadata(String resourceType, String resourceId) async {
     final result = await _channel.invokeMethod('getDeezerMetadata', {
       'resource_type': resourceType,
@@ -407,20 +363,16 @@ class PlatformBridge {
     return jsonDecode(result as String) as Map<String, dynamic>;
   }
 
-  /// Parse Deezer URL and return type and ID
   static Future<Map<String, dynamic>> parseDeezerUrl(String url) async {
     final result = await _channel.invokeMethod('parseDeezerUrl', {'url': url});
     return jsonDecode(result as String) as Map<String, dynamic>;
   }
 
-  /// Search Deezer by ISRC
   static Future<Map<String, dynamic>> searchDeezerByISRC(String isrc) async {
     final result = await _channel.invokeMethod('searchDeezerByISRC', {'isrc': isrc});
     return jsonDecode(result as String) as Map<String, dynamic>;
   }
 
-  /// Get extended metadata (genre, label) from Deezer using track ID
-  /// Returns {"genre": "...", "label": "..."} or null if not found
   static Future<Map<String, String>?> getDeezerExtendedMetadata(String trackId) async {
     try {
       final result = await _channel.invokeMethod('getDeezerExtendedMetadata', {
@@ -438,7 +390,6 @@ class PlatformBridge {
     }
   }
 
-  /// Convert Spotify track to Deezer and get metadata (for rate limit fallback)
   static Future<Map<String, dynamic>> convertSpotifyToDeezer(String resourceType, String spotifyId) async {
     final result = await _channel.invokeMethod('convertSpotifyToDeezer', {
       'resource_type': resourceType,
@@ -447,15 +398,11 @@ class PlatformBridge {
     return jsonDecode(result as String) as Map<String, dynamic>;
   }
 
-  /// Get Spotify metadata with automatic Deezer fallback on rate limit
   static Future<Map<String, dynamic>> getSpotifyMetadataWithFallback(String url) async {
     final result = await _channel.invokeMethod('getSpotifyMetadataWithFallback', {'url': url});
     return jsonDecode(result as String) as Map<String, dynamic>;
   }
 
-  // ==================== GO BACKEND LOGS ====================
-
-  /// Get all logs from Go backend
   static Future<List<Map<String, dynamic>>> getGoLogs() async {
     final result = await _channel.invokeMethod('getLogs');
     final logs = jsonDecode(result as String) as List<dynamic>;
@@ -468,25 +415,20 @@ class PlatformBridge {
     return jsonDecode(result as String) as Map<String, dynamic>;
   }
 
-  /// Clear Go backend logs
   static Future<void> clearGoLogs() async {
     await _channel.invokeMethod('clearLogs');
   }
 
-  /// Get Go backend log count
   static Future<int> getGoLogCount() async {
     final result = await _channel.invokeMethod('getLogCount');
     return result as int;
   }
 
-  /// Enable or disable Go backend logging
   static Future<void> setGoLoggingEnabled(bool enabled) async {
     await _channel.invokeMethod('setLoggingEnabled', {'enabled': enabled});
   }
 
-  // ==================== EXTENSION SYSTEM ====================
 
-  /// Initialize the extension system
   static Future<void> initExtensionSystem(String extensionsDir, String dataDir) async {
     _log.d('initExtensionSystem: $extensionsDir, $dataDir');
     await _channel.invokeMethod('initExtensionSystem', {
@@ -495,7 +437,6 @@ class PlatformBridge {
     });
   }
 
-  /// Load all extensions from directory
   static Future<Map<String, dynamic>> loadExtensionsFromDir(String dirPath) async {
     _log.d('loadExtensionsFromDir: $dirPath');
     final result = await _channel.invokeMethod('loadExtensionsFromDir', {
@@ -504,7 +445,6 @@ class PlatformBridge {
     return jsonDecode(result as String) as Map<String, dynamic>;
   }
 
-  /// Load a single extension from file
   static Future<Map<String, dynamic>> loadExtensionFromPath(String filePath) async {
     _log.d('loadExtensionFromPath: $filePath');
     final result = await _channel.invokeMethod('loadExtensionFromPath', {
@@ -513,7 +453,6 @@ class PlatformBridge {
     return jsonDecode(result as String) as Map<String, dynamic>;
   }
 
-  /// Unload an extension
   static Future<void> unloadExtension(String extensionId) async {
     _log.d('unloadExtension: $extensionId');
     await _channel.invokeMethod('unloadExtension', {
@@ -521,7 +460,6 @@ class PlatformBridge {
     });
   }
 
-  /// Remove an extension completely (unload + delete files)
   static Future<void> removeExtension(String extensionId) async {
     _log.d('removeExtension: $extensionId');
     await _channel.invokeMethod('removeExtension', {
@@ -529,7 +467,6 @@ class PlatformBridge {
     });
   }
 
-  /// Upgrade an existing extension from a new package file
   static Future<Map<String, dynamic>> upgradeExtension(String filePath) async {
     _log.d('upgradeExtension: $filePath');
     final result = await _channel.invokeMethod('upgradeExtension', {
@@ -538,7 +475,6 @@ class PlatformBridge {
     return jsonDecode(result as String) as Map<String, dynamic>;
   }
 
-  /// Check if a package file is an upgrade for an existing extension
   static Future<Map<String, dynamic>> checkExtensionUpgrade(String filePath) async {
     _log.d('checkExtensionUpgrade: $filePath');
     final result = await _channel.invokeMethod('checkExtensionUpgrade', {
@@ -547,14 +483,12 @@ class PlatformBridge {
     return jsonDecode(result as String) as Map<String, dynamic>;
   }
 
-  /// Get all installed extensions
   static Future<List<Map<String, dynamic>>> getInstalledExtensions() async {
     final result = await _channel.invokeMethod('getInstalledExtensions');
     final list = jsonDecode(result as String) as List<dynamic>;
     return list.map((e) => e as Map<String, dynamic>).toList();
   }
 
-  /// Enable or disable an extension
   static Future<void> setExtensionEnabled(String extensionId, bool enabled) async {
     _log.d('setExtensionEnabled: $extensionId = $enabled');
     await _channel.invokeMethod('setExtensionEnabled', {
@@ -563,7 +497,6 @@ class PlatformBridge {
     });
   }
 
-  /// Set provider priority order
   static Future<void> setProviderPriority(List<String> providerIds) async {
     _log.d('setProviderPriority: $providerIds');
     await _channel.invokeMethod('setProviderPriority', {
@@ -571,14 +504,12 @@ class PlatformBridge {
     });
   }
 
-  /// Get provider priority order
   static Future<List<String>> getProviderPriority() async {
     final result = await _channel.invokeMethod('getProviderPriority');
     final list = jsonDecode(result as String) as List<dynamic>;
     return list.map((e) => e as String).toList();
   }
 
-  /// Set metadata provider priority order
   static Future<void> setMetadataProviderPriority(List<String> providerIds) async {
     _log.d('setMetadataProviderPriority: $providerIds');
     await _channel.invokeMethod('setMetadataProviderPriority', {
@@ -586,14 +517,12 @@ class PlatformBridge {
     });
   }
 
-  /// Get metadata provider priority order
   static Future<List<String>> getMetadataProviderPriority() async {
     final result = await _channel.invokeMethod('getMetadataProviderPriority');
     final list = jsonDecode(result as String) as List<dynamic>;
     return list.map((e) => e as String).toList();
   }
 
-  /// Get extension settings
   static Future<Map<String, dynamic>> getExtensionSettings(String extensionId) async {
     final result = await _channel.invokeMethod('getExtensionSettings', {
       'extension_id': extensionId,
@@ -601,7 +530,6 @@ class PlatformBridge {
     return jsonDecode(result as String) as Map<String, dynamic>;
   }
 
-  /// Set extension settings
   static Future<void> setExtensionSettings(String extensionId, Map<String, dynamic> settings) async {
     _log.d('setExtensionSettings: $extensionId');
     await _channel.invokeMethod('setExtensionSettings', {
@@ -610,8 +538,6 @@ class PlatformBridge {
     });
   }
 
-  /// Invoke an action on an extension (e.g., button click handler like "startLogin")
-  /// Returns the result from the JS function
   static Future<Map<String, dynamic>> invokeExtensionAction(String extensionId, String actionName) async {
     _log.d('invokeExtensionAction: $extensionId.$actionName');
     final result = await _channel.invokeMethod('invokeExtensionAction', {
@@ -624,7 +550,6 @@ class PlatformBridge {
     return jsonDecode(result) as Map<String, dynamic>;
   }
 
-  /// Search tracks using extension providers
   static Future<List<Map<String, dynamic>>> searchTracksWithExtensions(String query, {int limit = 20}) async {
     _log.d('searchTracksWithExtensions: "$query"');
     final result = await _channel.invokeMethod('searchTracksWithExtensions', {
@@ -635,7 +560,6 @@ class PlatformBridge {
     return list.map((e) => e as Map<String, dynamic>).toList();
   }
 
-  /// Download with extension providers (includes fallback)
   static Future<Map<String, dynamic>> downloadWithExtensions({
     required String isrc,
     required String spotifyId,
@@ -655,9 +579,10 @@ class PlatformBridge {
     String? releaseDate,
     String? itemId,
     int durationMs = 0,
-    String? source, // Extension ID that provided this track (prioritize this extension)
+    String? source,
     String? genre,
     String? label,
+    String lyricsMode = 'embed',
   }) async {
     _log.i('downloadWithExtensions: "$trackName" by $artistName${source != null ? ' (source: $source)' : ''}');
     final request = jsonEncode({
@@ -679,24 +604,21 @@ class PlatformBridge {
       'release_date': releaseDate ?? '',
       'item_id': itemId ?? '',
       'duration_ms': durationMs,
-      'source': source ?? '', // Extension ID that provided this track
+      'source': source ?? '',
       'genre': genre ?? '',
       'label': label ?? '',
+      'lyrics_mode': lyricsMode,
     });
     
     final result = await _channel.invokeMethod('downloadWithExtensions', request);
     return jsonDecode(result as String) as Map<String, dynamic>;
   }
 
-  /// Cleanup all extensions (call on app close)
   static Future<void> cleanupExtensions() async {
     _log.d('cleanupExtensions');
     await _channel.invokeMethod('cleanupExtensions');
   }
 
-  // ==================== EXTENSION AUTH API ====================
-
-  /// Get pending auth request for an extension (if any)
   static Future<Map<String, dynamic>?> getExtensionPendingAuth(String extensionId) async {
     final result = await _channel.invokeMethod('getExtensionPendingAuth', {
       'extension_id': extensionId,
@@ -705,7 +627,6 @@ class PlatformBridge {
     return jsonDecode(result as String) as Map<String, dynamic>;
   }
 
-  /// Set auth code for an extension (after OAuth callback)
   static Future<void> setExtensionAuthCode(String extensionId, String authCode) async {
     _log.d('setExtensionAuthCode: $extensionId');
     await _channel.invokeMethod('setExtensionAuthCode', {
@@ -714,7 +635,6 @@ class PlatformBridge {
     });
   }
 
-  /// Set tokens for an extension (after token exchange)
   static Future<void> setExtensionTokens(
     String extensionId, {
     required String accessToken,
@@ -730,14 +650,12 @@ class PlatformBridge {
     });
   }
 
-  /// Clear pending auth request for an extension
   static Future<void> clearExtensionPendingAuth(String extensionId) async {
     await _channel.invokeMethod('clearExtensionPendingAuth', {
       'extension_id': extensionId,
     });
   }
 
-  /// Check if extension is authenticated
   static Future<bool> isExtensionAuthenticated(String extensionId) async {
     final result = await _channel.invokeMethod('isExtensionAuthenticated', {
       'extension_id': extensionId,
@@ -745,16 +663,12 @@ class PlatformBridge {
     return result as bool;
   }
 
-  /// Get all pending auth requests (for polling)
   static Future<List<Map<String, dynamic>>> getAllPendingAuthRequests() async {
     final result = await _channel.invokeMethod('getAllPendingAuthRequests');
     final list = jsonDecode(result as String) as List<dynamic>;
     return list.map((e) => e as Map<String, dynamic>).toList();
   }
 
-  // ==================== EXTENSION FFMPEG API ====================
-
-  /// Get pending FFmpeg command for execution
   static Future<Map<String, dynamic>?> getPendingFFmpegCommand(String commandId) async {
     final result = await _channel.invokeMethod('getPendingFFmpegCommand', {
       'command_id': commandId,
@@ -763,7 +677,6 @@ class PlatformBridge {
     return jsonDecode(result as String) as Map<String, dynamic>;
   }
 
-  /// Set FFmpeg command result
   static Future<void> setFFmpegCommandResult(
     String commandId, {
     required bool success,
@@ -778,16 +691,12 @@ class PlatformBridge {
     });
   }
 
-  /// Get all pending FFmpeg commands
   static Future<List<Map<String, dynamic>>> getAllPendingFFmpegCommands() async {
     final result = await _channel.invokeMethod('getAllPendingFFmpegCommands');
     final list = jsonDecode(result as String) as List<dynamic>;
     return list.map((e) => e as Map<String, dynamic>).toList();
   }
 
-  // ==================== EXTENSION CUSTOM SEARCH ====================
-
-  /// Perform custom search using an extension
   static Future<List<Map<String, dynamic>>> customSearchWithExtension(
     String extensionId,
     String query, {
@@ -802,17 +711,12 @@ class PlatformBridge {
     return list.map((e) => e as Map<String, dynamic>).toList();
   }
 
-  /// Get all extensions that provide custom search
   static Future<List<Map<String, dynamic>>> getSearchProviders() async {
     final result = await _channel.invokeMethod('getSearchProviders');
     final list = jsonDecode(result as String) as List<dynamic>;
     return list.map((e) => e as Map<String, dynamic>).toList();
   }
 
-  // ==================== EXTENSION URL HANDLER ====================
-
-  /// Handle a URL with any matching extension
-  /// Returns null if no extension can handle the URL
   static Future<Map<String, dynamic>?> handleURLWithExtension(String url) async {
     try {
       final result = await _channel.invokeMethod('handleURLWithExtension', {
@@ -825,8 +729,6 @@ class PlatformBridge {
     }
   }
 
-  /// Find an extension that can handle the given URL
-  /// Returns extension ID or null if none found
   static Future<String?> findURLHandler(String url) async {
     final result = await _channel.invokeMethod('findURLHandler', {
       'url': url,
@@ -835,14 +737,12 @@ class PlatformBridge {
     return result as String;
   }
 
-  /// Get all extensions that handle custom URLs
   static Future<List<Map<String, dynamic>>> getURLHandlers() async {
     final result = await _channel.invokeMethod('getURLHandlers');
     final list = jsonDecode(result as String) as List<dynamic>;
     return list.map((e) => e as Map<String, dynamic>).toList();
   }
 
-  /// Get album tracks using an extension
   static Future<Map<String, dynamic>?> getAlbumWithExtension(
     String extensionId,
     String albumId,
@@ -860,7 +760,6 @@ class PlatformBridge {
     }
   }
 
-  /// Get playlist tracks using an extension
   static Future<Map<String, dynamic>?> getPlaylistWithExtension(
     String extensionId,
     String playlistId,
@@ -878,7 +777,6 @@ class PlatformBridge {
     }
   }
 
-  /// Get artist info and albums using an extension
   static Future<Map<String, dynamic>?> getArtistWithExtension(
     String extensionId,
     String artistId,
@@ -896,9 +794,7 @@ class PlatformBridge {
     }
   }
 
-  // ==================== EXTENSION POST-PROCESSING ====================
 
-  /// Run post-processing hooks on a file
   static Future<Map<String, dynamic>> runPostProcessing(
     String filePath, {
     Map<String, dynamic>? metadata,
@@ -910,22 +806,18 @@ class PlatformBridge {
     return jsonDecode(result as String) as Map<String, dynamic>;
   }
 
-  /// Get all extensions that provide post-processing
   static Future<List<Map<String, dynamic>>> getPostProcessingProviders() async {
     final result = await _channel.invokeMethod('getPostProcessingProviders');
     final list = jsonDecode(result as String) as List<dynamic>;
     return list.map((e) => e as Map<String, dynamic>).toList();
   }
 
-  // ==================== EXTENSION STORE ====================
 
-  /// Initialize extension store
   static Future<void> initExtensionStore(String cacheDir) async {
     _log.d('initExtensionStore: $cacheDir');
     await _channel.invokeMethod('initExtensionStore', {'cache_dir': cacheDir});
   }
 
-  /// Get all extensions from store with installation status
   static Future<List<Map<String, dynamic>>> getStoreExtensions({bool forceRefresh = false}) async {
     _log.d('getStoreExtensions (forceRefresh: $forceRefresh)');
     final result = await _channel.invokeMethod('getStoreExtensions', {
@@ -935,7 +827,6 @@ class PlatformBridge {
     return list.map((e) => e as Map<String, dynamic>).toList();
   }
 
-  /// Search extensions in store
   static Future<List<Map<String, dynamic>>> searchStoreExtensions(String query, {String? category}) async {
     _log.d('searchStoreExtensions: "$query" (category: $category)');
     final result = await _channel.invokeMethod('searchStoreExtensions', {
@@ -946,14 +837,12 @@ class PlatformBridge {
     return list.map((e) => e as Map<String, dynamic>).toList();
   }
 
-  /// Get store categories
   static Future<List<String>> getStoreCategories() async {
     final result = await _channel.invokeMethod('getStoreCategories');
     final list = jsonDecode(result as String) as List<dynamic>;
     return list.cast<String>();
   }
 
-  /// Download extension from store
   static Future<String> downloadStoreExtension(String extensionId, String destDir) async {
     _log.i('downloadStoreExtension: $extensionId to $destDir');
     final result = await _channel.invokeMethod('downloadStoreExtension', {
@@ -963,7 +852,6 @@ class PlatformBridge {
     return result as String;
   }
 
-  /// Clear store cache
   static Future<void> clearStoreCache() async {
     _log.d('clearStoreCache');
     await _channel.invokeMethod('clearStoreCache');

lib/services/share_intent_service.dart

@@ -4,7 +4,6 @@ import 'package:spotiflac_android/utils/logger.dart';
 
 final _log = AppLogger('ShareIntent');
 
-/// Service to handle incoming share intents from other apps (e.g., Spotify)
 class ShareIntentService {
   static final ShareIntentService _instance = ShareIntentService._internal();
   factory ShareIntentService() => _instance;
@@ -15,17 +14,14 @@ class ShareIntentService {
   bool _initialized = false;
   String? _pendingUrl; // Store URL received before listener is ready
 
-  /// Stream of shared Spotify URLs
   Stream<String> get sharedUrlStream => _sharedUrlController.stream;
 
-  /// Get pending URL that was received before listener was ready
   String? consumePendingUrl() {
     final url = _pendingUrl;
     _pendingUrl = null;
     return url;
   }
 
-  /// Initialize the service and start listening for share intents
   Future<void> initialize() async {
     if (_initialized) return;
     _initialized = true;
@@ -58,11 +54,6 @@ class ShareIntentService {
     }
   }
 
-  /// Extract Spotify URL from shared text
-  /// Handles various formats:
-  /// - Direct URL: https://open.spotify.com/track/xxx
-  /// - With text: "Check out this song! https://open.spotify.com/track/xxx"
-  /// - Spotify URI: spotify:track:xxx
   String? _extractSpotifyUrl(String text) {
     if (text.isEmpty) return null;
 
@@ -83,7 +74,6 @@ class ShareIntentService {
     return null;
   }
 
-  /// Dispose resources
   void dispose() {
     _mediaSubscription?.cancel();
     _sharedUrlController.close();

lib/theme/app_theme.dart

@@ -1,12 +1,10 @@
 import 'package:flutter/material.dart';
 import 'package:spotiflac_android/models/theme_settings.dart';
 
-/// App theme configuration for Material Expressive 3
 class AppTheme {
   /// Default seed color (Spotify green)
   static const Color defaultSeedColor = Color(kDefaultSeedColor);
 
-  /// Create light theme
   static ThemeData light({ColorScheme? dynamicScheme, Color? seedColor}) {
     final scheme =
         dynamicScheme ??
@@ -73,7 +71,6 @@ class AppTheme {
     );
   }
 
-  /// AppBar theme
   static AppBarTheme _appBarTheme(
     ColorScheme scheme, {
     bool isAmoled = false,
@@ -101,7 +98,6 @@ class AppTheme {
     surfaceTintColor: scheme.surfaceTint,
   );
 
-  /// Elevated button theme
   static ElevatedButtonThemeData _elevatedButtonTheme(ColorScheme scheme) =>
       ElevatedButtonThemeData(
         style: ElevatedButton.styleFrom(
@@ -124,7 +120,6 @@ class AppTheme {
         ),
       );
 
-  /// Outlined button theme
   static OutlinedButtonThemeData _outlinedButtonTheme(ColorScheme scheme) =>
       OutlinedButtonThemeData(
         style: OutlinedButton.styleFrom(
@@ -146,7 +141,6 @@ class AppTheme {
         ),
       );
 
-  /// FAB theme
   static FloatingActionButtonThemeData _fabTheme(ColorScheme scheme) =>
       FloatingActionButtonThemeData(
         elevation: 3,
@@ -184,7 +178,6 @@ class AppTheme {
         ), // consistent padding
       );
 
-  /// List tile theme
   static ListTileThemeData _listTileTheme(ColorScheme scheme) =>
       ListTileThemeData(
         shape: RoundedRectangleBorder(
@@ -193,7 +186,6 @@ class AppTheme {
         contentPadding: const EdgeInsets.symmetric(horizontal: 16, vertical: 4),
       );
 
-  /// Dialog theme
   static DialogThemeData _dialogTheme(ColorScheme scheme) => DialogThemeData(
     elevation: 6,
     shape: RoundedRectangleBorder(borderRadius: BorderRadius.circular(28)),
@@ -213,7 +205,6 @@ class AppTheme {
     labelBehavior: NavigationDestinationLabelBehavior.alwaysShow,
   );
 
-  /// SnackBar theme
   static SnackBarThemeData _snackBarTheme(ColorScheme scheme) =>
       SnackBarThemeData(
         behavior: SnackBarBehavior.floating,
@@ -231,7 +222,6 @@ class AppTheme {
     circularTrackColor: scheme.surfaceContainerHighest,
   );
 
-  /// Switch theme
   static SwitchThemeData _switchTheme(ColorScheme scheme) => SwitchThemeData(
     thumbColor: WidgetStateProperty.resolveWith((states) {
       if (states.contains(WidgetState.selected)) {
@@ -260,7 +250,6 @@ class AppTheme {
     selectedColor: scheme.secondaryContainer,
   );
 
-  /// Divider theme
   static DividerThemeData _dividerTheme(ColorScheme scheme) =>
       DividerThemeData(color: scheme.outlineVariant, thickness: 1, space: 1);
 }

lib/utils/logger.dart

@@ -4,7 +4,6 @@ import 'package:flutter/foundation.dart';
 import 'package:logger/logger.dart';
 import 'package:spotiflac_android/services/platform_bridge.dart';
 
-/// Log entry with timestamp and level
 class LogEntry {
   final DateTime timestamp;
   final String level;
@@ -38,7 +37,6 @@ class LogEntry {
   }
 }
 
-/// Circular buffer for storing logs in memory
 class LogBuffer extends ChangeNotifier {
   static final LogBuffer _instance = LogBuffer._internal();
   factory LogBuffer() => _instance;
@@ -134,7 +132,6 @@ class LogBuffer extends ChangeNotifier {
       
       _lastGoLogIndex = nextIndex;
     } catch (e) {
-      // Ignore errors - Go backend might not be ready
       if (kDebugMode) {
         debugPrint('Failed to fetch Go logs: $e');
       }
@@ -180,7 +177,6 @@ class LogBuffer extends ChangeNotifier {
   }
 }
 
-/// Custom log output that writes to both console and buffer
 class BufferedOutput extends LogOutput {
   final String tag;
 
@@ -236,9 +232,6 @@ final log = Logger(
   level: Level.debug,
 );
 
-/// Logger with class/tag prefix for better traceability
-/// Now also writes to LogBuffer for in-app viewing
-/// Works in both debug and release mode
 class AppLogger {
   final String _tag;
   late final Logger? _logger;

lib/widgets/cached_cover_image.dart

@@ -0,0 +1,63 @@
+import 'package:flutter/material.dart';
+import 'package:cached_network_image/cached_network_image.dart';
+import 'package:spotiflac_android/services/cover_cache_manager.dart';
+
+class CachedCoverImage extends StatelessWidget {
+  final String imageUrl;
+  final double? width;
+  final double? height;
+  final BoxFit fit;
+  final int? memCacheWidth;
+  final int? memCacheHeight;
+  final Widget Function(BuildContext, String, Object)? errorWidget;
+  final Widget Function(BuildContext, String)? placeholder;
+  final BorderRadius? borderRadius;
+
+  const CachedCoverImage({
+    super.key,
+    required this.imageUrl,
+    this.width,
+    this.height,
+    this.fit = BoxFit.cover,
+    this.memCacheWidth,
+    this.memCacheHeight,
+    this.errorWidget,
+    this.placeholder,
+    this.borderRadius,
+  });
+
+  @override
+  Widget build(BuildContext context) {
+    final image = CachedNetworkImage(
+      imageUrl: imageUrl,
+      width: width,
+      height: height,
+      fit: fit,
+      memCacheWidth: memCacheWidth,
+      memCacheHeight: memCacheHeight,
+      cacheManager: CoverCacheManager.isInitialized 
+          ? CoverCacheManager.instance 
+          : null,
+      errorWidget: errorWidget,
+      placeholder: placeholder,
+    );
+
+    if (borderRadius != null) {
+      return ClipRRect(
+        borderRadius: borderRadius!,
+        child: image,
+      );
+    }
+
+    return image;
+  }
+}
+
+CachedNetworkImageProvider cachedCoverImageProvider(String url) {
+  return CachedNetworkImageProvider(
+    url,
+    cacheManager: CoverCacheManager.isInitialized 
+        ? CoverCacheManager.instance 
+        : null,
+  );
+}

pubspec.lock

@@ -327,7 +327,7 @@ packages:
     source: sdk
     version: "0.0.0"
   flutter_cache_manager:
-    dependency: transitive
+    dependency: "direct main"
     description:
       name: flutter_cache_manager
       sha256: "400b6592f16a4409a7f2bb929a9a7e38c72cceb8ffb99ee57bbf2cb2cecf8386"
@@ -662,7 +662,7 @@ packages:
     source: hosted
     version: "0.3.3+7"
   path:
-    dependency: transitive
+    dependency: "direct main"
     description:
       name: path
       sha256: "75cca69d1490965be98c73ceaea117e8a04dd21217b37b292c9ddbec0d955bc5"

pubspec.yaml

@@ -1,7 +1,7 @@
 name: spotiflac_android
 description: Download Spotify tracks in FLAC from Tidal, Qobuz & Amazon Music
 publish_to: "none"
-version: 3.1.2+61
+version: 3.1.3+62
 
 environment:
   sdk: ^3.10.0
@@ -22,9 +22,10 @@ dependencies:
   # Navigation
   go_router: ^17.0.1
 
-  # Storage & Persistence
+# Storage & Persistence
   shared_preferences: ^2.5.3
   path_provider: ^2.1.5
+  path: ^1.9.0
 
   # HTTP & Network
   http: ^1.6.0
@@ -33,6 +34,7 @@ dependencies:
   # UI Components
   cupertino_icons: ^1.0.8
   cached_network_image: ^3.4.1
+  flutter_cache_manager: ^3.4.1
   flutter_svg: ^2.1.0
 
   # Material Expressive 3 / Dynamic Color

pubspec_ios.yaml

@@ -1,7 +1,7 @@
 name: spotiflac_android
 description: Download Spotify tracks in FLAC from Tidal, Qobuz & Amazon Music
 publish_to: "none"
-version: 3.1.2+61
+version: 3.1.3+62
 
 environment:
   sdk: ^3.10.0
@@ -22,17 +22,19 @@ dependencies:
   # Navigation
   go_router: ^17.0.1
 
-  # Storage & Persistence
+# Storage & Persistence
   shared_preferences: ^2.5.3
   path_provider: ^2.1.5
+  path: ^1.9.0
 
   # HTTP & Network
   http: ^1.6.0
   dio: ^5.8.0
 
-  # UI Components
+# UI Components
   cupertino_icons: ^1.0.8
   cached_network_image: ^3.4.1
+  flutter_cache_manager: ^3.4.1
   flutter_svg: ^2.1.0
 
   # Material Expressive 3 / Dynamic Color