chore: bump version to 3.0.0-alpha.3

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

CHANGELOG.md

@@ -1,5 +1,47 @@
 # Changelog
 
+## [3.0.0-alpha.3] - 2026-01-12
+
+### Added
+
+- **Separate Singles Folder**: Option to organize downloads into Albums/ and Singles/ folders
+  - Based on `album_type` from Spotify/Deezer metadata
+  - Toggle in Settings > Download > Separate Singles Folder
+  - Singles saved to `{output}/Singles/`, albums to `{output}/Albums/`
+- **Browser-like Polyfills**: New global APIs for easier library porting
+  - `fetch()` - Browser-compatible HTTP API with `json()`, `text()`, `arrayBuffer()` methods
+  - `atob()` / `btoa()` - Global Base64 encoding/decoding
+  - `TextEncoder` / `TextDecoder` - UTF-8 text encoding classes
+  - `URL` / `URLSearchParams` - URL parsing and manipulation classes
+  - Makes porting browser libraries (like `youtubei.js`) much easier
+
+### Performance
+
+- **Parallel API Calls**: Download URL fetching now uses parallel requests
+  - Tidal: All 8 APIs requested simultaneously, first success wins
+  - Qobuz: Both APIs requested simultaneously, first success wins
+  - Significantly reduces download URL fetch time
+
+### Fixed
+
+- **Duplicate History Entries**: Fixed duplicate entries when re-downloading same track
+  - Detects existing entries by Spotify ID, Deezer ID, or ISRC
+  - Replaces existing entry and moves to top of list
+  - Auto-deduplicates existing history on app load
+- **Extension Search Fallback**: Fixed error when extension is disabled but still called for search
+  - Now checks if extension is still enabled before calling custom search
+  - Auto-resets search provider to default if extension was disabled
+- **Permission Error Message**: Fixed download showing "Song not found" when actually a permission error
+  - Now shows proper message: "Cannot write to folder, check storage permission"
+  - Added `permission` error type detection in backend
+- **Android 13+ Storage Permission**: Fixed storage permission not working on Android 13+
+  - Android 13+ now requests both `MANAGE_EXTERNAL_STORAGE` and `READ_MEDIA_AUDIO`
+  - `MANAGE_EXTERNAL_STORAGE` opens Settings (system-level, persists across app data clear)
+  - `READ_MEDIA_AUDIO` shows dialog (app-level, resets on app data clear)
+  - Proper permission check before showing "granted" status
+
+---
+
 ## [3.0.0-alpha.2] - 2026-01-12
 
 ### Added

go_backend/deezer.go

@@ -146,6 +146,7 @@ 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
 	Artist       deezerArtist   `json:"artist"`
 	Contributors []deezerArtist `json:"contributors"`
 	Tracks       struct {
@@ -326,6 +327,12 @@ func (c *DeezerClient) GetAlbum(ctx context.Context, albumID string) (*AlbumResp
 	isrcMap := c.fetchISRCsParallel(ctx, album.Tracks.Data)
 
 	tracks := make([]AlbumTrackMetadata, 0, len(album.Tracks.Data))
+	// Normalize record_type (Deezer uses "compile" instead of "compilation")
+	albumType := album.RecordType
+	if albumType == "compile" {
+		albumType = "compilation"
+	}
+
 	for _, track := range album.Tracks.Data {
 		trackIDStr := fmt.Sprintf("%d", track.ID)
 		isrc := isrcMap[trackIDStr]
@@ -345,6 +352,7 @@ func (c *DeezerClient) GetAlbum(ctx context.Context, albumID string) (*AlbumResp
 			ExternalURL: track.Link,
 			ISRC:        isrc,
 			AlbumID:     fmt.Sprintf("deezer:%d", album.ID),
+			AlbumType:   albumType,
 		})
 	}
 

go_backend/exports.go

@@ -1015,6 +1015,12 @@ func errorResponse(msg string) (string, error) {
 		strings.Contains(lowerMsg, "try using vpn") ||
 		strings.Contains(lowerMsg, "change dns") {
 		errorType = "isp_blocked"
+	} else if strings.Contains(lowerMsg, "permission") ||
+		strings.Contains(lowerMsg, "operation not permitted") ||
+		strings.Contains(lowerMsg, "access denied") ||
+		strings.Contains(lowerMsg, "failed to create file") ||
+		strings.Contains(lowerMsg, "failed to create directory") {
+		errorType = "permission"
 	} else if strings.Contains(lowerMsg, "not found") ||
 		strings.Contains(lowerMsg, "not available") ||
 		strings.Contains(lowerMsg, "no results") ||

go_backend/extension_runtime.go

@@ -249,6 +249,25 @@ func (r *ExtensionRuntime) RegisterAPIs(vm *goja.Runtime) {
 	gobackendObj := vm.NewObject()
 	gobackendObj.Set("sanitizeFilename", r.sanitizeFilenameWrapper)
 	vm.Set("gobackend", gobackendObj)
+
+	// ==================== Browser-like Polyfills ====================
+	// These make porting browser/Node.js libraries easier
+
+	// Global fetch() - Promise-style HTTP API (browser-compatible)
+	vm.Set("fetch", r.fetchPolyfill)
+
+	// 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)
 }
 
 // ==================== HTTP API (Sandboxed) ====================
@@ -2274,3 +2293,477 @@ func normalizeStringForMatching(s string) string {
 
 	return strings.TrimSpace(s)
 }
+
+// ==================== Browser-like Polyfills ====================
+// These polyfills make porting browser/Node.js libraries easier
+// without compromising sandbox security
+
+// fetchPolyfill implements browser-compatible fetch() API
+// Returns a Promise-like object with json(), text() methods
+func (r *ExtensionRuntime) fetchPolyfill(call goja.FunctionCall) goja.Value {
+	if len(call.Arguments) < 1 {
+		return r.createFetchError("URL is required")
+	}
+
+	urlStr := call.Arguments[0].String()
+
+	// Validate domain
+	if err := r.validateDomain(urlStr); err != nil {
+		GoLog("[Extension:%s] fetch blocked: %v\n", r.extensionID, err)
+		return r.createFetchError(err.Error())
+	}
+
+	// Parse options
+	method := "GET"
+	var bodyStr string
+	headers := make(map[string]string)
+
+	if len(call.Arguments) > 1 && !goja.IsUndefined(call.Arguments[1]) && !goja.IsNull(call.Arguments[1]) {
+		optionsObj := call.Arguments[1].Export()
+		if opts, ok := optionsObj.(map[string]interface{}); ok {
+			// Method
+			if m, ok := opts["method"].(string); ok {
+				method = strings.ToUpper(m)
+			}
+
+			// Body - support string, object (auto-stringify), or nil
+			if bodyArg, ok := opts["body"]; ok && bodyArg != nil {
+				switch v := bodyArg.(type) {
+				case string:
+					bodyStr = v
+				case map[string]interface{}, []interface{}:
+					jsonBytes, err := json.Marshal(v)
+					if err != nil {
+						return r.createFetchError(fmt.Sprintf("failed to stringify body: %v", err))
+					}
+					bodyStr = string(jsonBytes)
+				default:
+					bodyStr = fmt.Sprintf("%v", v)
+				}
+			}
+
+			// Headers
+			if h, ok := opts["headers"]; ok && h != nil {
+				switch hv := h.(type) {
+				case map[string]interface{}:
+					for k, v := range hv {
+						headers[k] = fmt.Sprintf("%v", v)
+					}
+				}
+			}
+		}
+	}
+
+	// Create HTTP request
+	var reqBody io.Reader
+	if bodyStr != "" {
+		reqBody = strings.NewReader(bodyStr)
+	}
+
+	req, err := http.NewRequest(method, urlStr, reqBody)
+	if err != nil {
+		return r.createFetchError(err.Error())
+	}
+
+	// Set headers - user headers first
+	for k, v := range headers {
+		req.Header.Set(k, v)
+	}
+	// Set defaults if not provided
+	if req.Header.Get("User-Agent") == "" {
+		req.Header.Set("User-Agent", "SpotiFLAC-Extension/1.0")
+	}
+	if bodyStr != "" && req.Header.Get("Content-Type") == "" {
+		req.Header.Set("Content-Type", "application/json")
+	}
+
+	// Execute request
+	resp, err := r.httpClient.Do(req)
+	if err != nil {
+		return r.createFetchError(err.Error())
+	}
+	defer resp.Body.Close()
+
+	// Read body
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return r.createFetchError(err.Error())
+	}
+
+	// Extract response headers
+	respHeaders := make(map[string]interface{})
+	for k, v := range resp.Header {
+		if len(v) == 1 {
+			respHeaders[k] = v[0]
+		} else {
+			respHeaders[k] = v
+		}
+	}
+
+	// Create Response object (browser-compatible)
+	responseObj := r.vm.NewObject()
+	responseObj.Set("ok", resp.StatusCode >= 200 && resp.StatusCode < 300)
+	responseObj.Set("status", resp.StatusCode)
+	responseObj.Set("statusText", http.StatusText(resp.StatusCode))
+	responseObj.Set("headers", respHeaders)
+	responseObj.Set("url", urlStr)
+
+	// Store body for methods
+	bodyString := string(body)
+
+	// text() method - returns body as string
+	responseObj.Set("text", func(call goja.FunctionCall) goja.Value {
+		return r.vm.ToValue(bodyString)
+	})
+
+	// json() method - parses body as JSON
+	responseObj.Set("json", func(call goja.FunctionCall) goja.Value {
+		var result interface{}
+		if err := json.Unmarshal(body, &result); err != nil {
+			GoLog("[Extension:%s] fetch json() parse error: %v\n", r.extensionID, err)
+			return goja.Undefined()
+		}
+		return r.vm.ToValue(result)
+	})
+
+	// arrayBuffer() method - returns body as array (simplified)
+	responseObj.Set("arrayBuffer", func(call goja.FunctionCall) goja.Value {
+		// Return as array of bytes
+		byteArray := make([]interface{}, len(body))
+		for i, b := range body {
+			byteArray[i] = int(b)
+		}
+		return r.vm.ToValue(byteArray)
+	})
+
+	return responseObj
+}
+
+// createFetchError creates a fetch error response
+func (r *ExtensionRuntime) createFetchError(message string) goja.Value {
+	errorObj := r.vm.NewObject()
+	errorObj.Set("ok", false)
+	errorObj.Set("status", 0)
+	errorObj.Set("statusText", "Network Error")
+	errorObj.Set("error", message)
+	errorObj.Set("text", func(call goja.FunctionCall) goja.Value {
+		return r.vm.ToValue("")
+	})
+	errorObj.Set("json", func(call goja.FunctionCall) goja.Value {
+		return goja.Undefined()
+	})
+	return errorObj
+}
+
+// atobPolyfill implements browser atob() - decode base64 to string
+func (r *ExtensionRuntime) atobPolyfill(call goja.FunctionCall) goja.Value {
+	if len(call.Arguments) < 1 {
+		return r.vm.ToValue("")
+	}
+	input := call.Arguments[0].String()
+	decoded, err := base64.StdEncoding.DecodeString(input)
+	if err != nil {
+		// Try URL-safe base64
+		decoded, err = base64.URLEncoding.DecodeString(input)
+		if err != nil {
+			GoLog("[Extension:%s] atob decode error: %v\n", r.extensionID, err)
+			return r.vm.ToValue("")
+		}
+	}
+	return r.vm.ToValue(string(decoded))
+}
+
+// btoaPolyfill implements browser btoa() - encode string to base64
+func (r *ExtensionRuntime) btoaPolyfill(call goja.FunctionCall) goja.Value {
+	if len(call.Arguments) < 1 {
+		return r.vm.ToValue("")
+	}
+	input := call.Arguments[0].String()
+	return r.vm.ToValue(base64.StdEncoding.EncodeToString([]byte(input)))
+}
+
+// registerTextEncoderDecoder registers TextEncoder and TextDecoder classes
+func (r *ExtensionRuntime) registerTextEncoderDecoder(vm *goja.Runtime) {
+	// TextEncoder constructor
+	vm.Set("TextEncoder", func(call goja.ConstructorCall) *goja.Object {
+		encoder := call.This
+		encoder.Set("encoding", "utf-8")
+
+		// encode() method - string to Uint8Array
+		encoder.Set("encode", func(call goja.FunctionCall) goja.Value {
+			if len(call.Arguments) < 1 {
+				return vm.ToValue([]byte{})
+			}
+			input := call.Arguments[0].String()
+			bytes := []byte(input)
+
+			// Return as array (Uint8Array-like)
+			result := make([]interface{}, len(bytes))
+			for i, b := range bytes {
+				result[i] = int(b)
+			}
+			return vm.ToValue(result)
+		})
+
+		// encodeInto() method
+		encoder.Set("encodeInto", func(call goja.FunctionCall) goja.Value {
+			// Simplified implementation
+			if len(call.Arguments) < 2 {
+				return vm.ToValue(map[string]interface{}{"read": 0, "written": 0})
+			}
+			input := call.Arguments[0].String()
+			return vm.ToValue(map[string]interface{}{
+				"read":    len(input),
+				"written": len([]byte(input)),
+			})
+		})
+
+		return nil
+	})
+
+	// TextDecoder constructor
+	vm.Set("TextDecoder", func(call goja.ConstructorCall) *goja.Object {
+		decoder := call.This
+
+		// Get encoding from arguments (default: utf-8)
+		encoding := "utf-8"
+		if len(call.Arguments) > 0 && !goja.IsUndefined(call.Arguments[0]) {
+			encoding = call.Arguments[0].String()
+		}
+		decoder.Set("encoding", encoding)
+		decoder.Set("fatal", false)
+		decoder.Set("ignoreBOM", false)
+
+		// decode() method - Uint8Array to string
+		decoder.Set("decode", func(call goja.FunctionCall) goja.Value {
+			if len(call.Arguments) < 1 {
+				return vm.ToValue("")
+			}
+
+			// Handle different input types
+			input := call.Arguments[0].Export()
+			var bytes []byte
+
+			switch v := input.(type) {
+			case []byte:
+				bytes = v
+			case []interface{}:
+				bytes = make([]byte, len(v))
+				for i, val := range v {
+					switch n := val.(type) {
+					case int64:
+						bytes[i] = byte(n)
+					case float64:
+						bytes[i] = byte(n)
+					case int:
+						bytes[i] = byte(n)
+					}
+				}
+			case string:
+				// Already a string, just return it
+				return vm.ToValue(v)
+			default:
+				return vm.ToValue("")
+			}
+
+			return vm.ToValue(string(bytes))
+		})
+
+		return nil
+	})
+}
+
+// registerURLClass registers the URL class for URL parsing
+func (r *ExtensionRuntime) registerURLClass(vm *goja.Runtime) {
+	vm.Set("URL", func(call goja.ConstructorCall) *goja.Object {
+		urlObj := call.This
+
+		if len(call.Arguments) < 1 {
+			urlObj.Set("href", "")
+			return nil
+		}
+
+		urlStr := call.Arguments[0].String()
+
+		// Handle relative URLs with base
+		if len(call.Arguments) > 1 && !goja.IsUndefined(call.Arguments[1]) {
+			baseStr := call.Arguments[1].String()
+			baseURL, err := url.Parse(baseStr)
+			if err == nil {
+				relURL, err := url.Parse(urlStr)
+				if err == nil {
+					urlStr = baseURL.ResolveReference(relURL).String()
+				}
+			}
+		}
+
+		parsed, err := url.Parse(urlStr)
+		if err != nil {
+			urlObj.Set("href", urlStr)
+			return nil
+		}
+
+		// Set URL properties
+		urlObj.Set("href", parsed.String())
+		urlObj.Set("protocol", parsed.Scheme+":")
+		urlObj.Set("host", parsed.Host)
+		urlObj.Set("hostname", parsed.Hostname())
+		urlObj.Set("port", parsed.Port())
+		urlObj.Set("pathname", parsed.Path)
+		urlObj.Set("search", "")
+		if parsed.RawQuery != "" {
+			urlObj.Set("search", "?"+parsed.RawQuery)
+		}
+		urlObj.Set("hash", "")
+		if parsed.Fragment != "" {
+			urlObj.Set("hash", "#"+parsed.Fragment)
+		}
+		urlObj.Set("origin", parsed.Scheme+"://"+parsed.Host)
+		urlObj.Set("username", parsed.User.Username())
+		password, _ := parsed.User.Password()
+		urlObj.Set("password", password)
+
+		// searchParams object
+		searchParams := vm.NewObject()
+		queryValues := parsed.Query()
+
+		searchParams.Set("get", func(call goja.FunctionCall) goja.Value {
+			if len(call.Arguments) < 1 {
+				return goja.Null()
+			}
+			key := call.Arguments[0].String()
+			if val := queryValues.Get(key); val != "" {
+				return vm.ToValue(val)
+			}
+			return goja.Null()
+		})
+
+		searchParams.Set("getAll", func(call goja.FunctionCall) goja.Value {
+			if len(call.Arguments) < 1 {
+				return vm.ToValue([]string{})
+			}
+			key := call.Arguments[0].String()
+			return vm.ToValue(queryValues[key])
+		})
+
+		searchParams.Set("has", func(call goja.FunctionCall) goja.Value {
+			if len(call.Arguments) < 1 {
+				return vm.ToValue(false)
+			}
+			key := call.Arguments[0].String()
+			return vm.ToValue(queryValues.Has(key))
+		})
+
+		searchParams.Set("toString", func(call goja.FunctionCall) goja.Value {
+			return vm.ToValue(queryValues.Encode())
+		})
+
+		urlObj.Set("searchParams", searchParams)
+
+		// toString method
+		urlObj.Set("toString", func(call goja.FunctionCall) goja.Value {
+			return vm.ToValue(parsed.String())
+		})
+
+		// toJSON method
+		urlObj.Set("toJSON", func(call goja.FunctionCall) goja.Value {
+			return vm.ToValue(parsed.String())
+		})
+
+		return nil
+	})
+
+	// URLSearchParams constructor
+	vm.Set("URLSearchParams", func(call goja.ConstructorCall) *goja.Object {
+		paramsObj := call.This
+		values := url.Values{}
+
+		// Parse initial value if provided
+		if len(call.Arguments) > 0 && !goja.IsUndefined(call.Arguments[0]) {
+			init := call.Arguments[0].Export()
+			switch v := init.(type) {
+			case string:
+				// Parse query string
+				parsed, _ := url.ParseQuery(strings.TrimPrefix(v, "?"))
+				values = parsed
+			case map[string]interface{}:
+				for k, val := range v {
+					values.Set(k, fmt.Sprintf("%v", val))
+				}
+			}
+		}
+
+		paramsObj.Set("append", func(call goja.FunctionCall) goja.Value {
+			if len(call.Arguments) >= 2 {
+				values.Add(call.Arguments[0].String(), call.Arguments[1].String())
+			}
+			return goja.Undefined()
+		})
+
+		paramsObj.Set("delete", func(call goja.FunctionCall) goja.Value {
+			if len(call.Arguments) >= 1 {
+				values.Del(call.Arguments[0].String())
+			}
+			return goja.Undefined()
+		})
+
+		paramsObj.Set("get", func(call goja.FunctionCall) goja.Value {
+			if len(call.Arguments) < 1 {
+				return goja.Null()
+			}
+			if val := values.Get(call.Arguments[0].String()); val != "" {
+				return vm.ToValue(val)
+			}
+			return goja.Null()
+		})
+
+		paramsObj.Set("getAll", func(call goja.FunctionCall) goja.Value {
+			if len(call.Arguments) < 1 {
+				return vm.ToValue([]string{})
+			}
+			return vm.ToValue(values[call.Arguments[0].String()])
+		})
+
+		paramsObj.Set("has", func(call goja.FunctionCall) goja.Value {
+			if len(call.Arguments) < 1 {
+				return vm.ToValue(false)
+			}
+			return vm.ToValue(values.Has(call.Arguments[0].String()))
+		})
+
+		paramsObj.Set("set", func(call goja.FunctionCall) goja.Value {
+			if len(call.Arguments) >= 2 {
+				values.Set(call.Arguments[0].String(), call.Arguments[1].String())
+			}
+			return goja.Undefined()
+		})
+
+		paramsObj.Set("toString", func(call goja.FunctionCall) goja.Value {
+			return vm.ToValue(values.Encode())
+		})
+
+		return nil
+	})
+}
+
+// registerJSONGlobal ensures JSON global is properly set up
+func (r *ExtensionRuntime) registerJSONGlobal(vm *goja.Runtime) {
+	// JSON is already built-in to Goja, but we can enhance it
+	// This ensures JSON.parse and JSON.stringify work as expected
+
+	// The built-in JSON object should already work, but let's verify
+	// and add any missing functionality if needed
+	jsonScript := `
+		if (typeof JSON === 'undefined') {
+			var JSON = {
+				parse: function(text) {
+					return utils.parseJSON(text);
+				},
+				stringify: function(value, replacer, space) {
+					return utils.stringifyJSON(value);
+				}
+			};
+		}
+	`
+	_, _ = vm.RunString(jsonScript)
+}

go_backend/qobuz.go

@@ -12,6 +12,7 @@ import (
 	"path/filepath"
 	"strings"
 	"sync"
+	"time"
 )
 
 // QobuzDownloader handles Qobuz downloads
@@ -635,6 +636,125 @@ func (q *QobuzDownloader) SearchTrackByMetadataWithDuration(trackName, artistNam
 	return nil, fmt.Errorf("no matching track found for: %s - %s", artistName, trackName)
 }
 
+// qobuzAPIResult holds the result from a parallel API request
+type qobuzAPIResult struct {
+	apiURL      string
+	downloadURL string
+	err         error
+	duration    time.Duration
+}
+
+// getQobuzDownloadURLParallel requests download URL from all APIs in parallel
+// "Siapa cepat dia dapat" - first successful response wins
+func getQobuzDownloadURLParallel(apis []string, trackID int64, quality string) (string, string, error) {
+	if len(apis) == 0 {
+		return "", "", fmt.Errorf("no APIs available")
+	}
+
+	GoLog("[Qobuz] Requesting download URL from %d APIs in parallel...\n", len(apis))
+
+	resultChan := make(chan qobuzAPIResult, len(apis))
+	startTime := time.Now()
+
+	// Start all requests in parallel
+	for _, apiURL := range apis {
+		go func(api string) {
+			reqStart := time.Now()
+
+			client := &http.Client{
+				Timeout: 15 * time.Second,
+			}
+
+			reqURL := fmt.Sprintf("%s%d&quality=%s", api, trackID, quality)
+
+			req, err := http.NewRequest("GET", reqURL, nil)
+			if err != nil {
+				resultChan <- qobuzAPIResult{apiURL: api, err: err, duration: time.Since(reqStart)}
+				return
+			}
+
+			resp, err := client.Do(req)
+			if err != nil {
+				resultChan <- qobuzAPIResult{apiURL: api, err: err, duration: time.Since(reqStart)}
+				return
+			}
+			defer resp.Body.Close()
+
+			if resp.StatusCode != 200 {
+				resultChan <- qobuzAPIResult{apiURL: api, err: fmt.Errorf("HTTP %d", resp.StatusCode), duration: time.Since(reqStart)}
+				return
+			}
+
+			body, err := io.ReadAll(resp.Body)
+			if err != nil {
+				resultChan <- qobuzAPIResult{apiURL: api, err: err, duration: time.Since(reqStart)}
+				return
+			}
+
+			// Check if response is HTML (error page)
+			if len(body) > 0 && body[0] == '<' {
+				resultChan <- qobuzAPIResult{apiURL: api, err: fmt.Errorf("received HTML instead of JSON"), duration: time.Since(reqStart)}
+				return
+			}
+
+			// Check for error in JSON response
+			var errorResp struct {
+				Error string `json:"error"`
+			}
+			if json.Unmarshal(body, &errorResp) == nil && errorResp.Error != "" {
+				resultChan <- qobuzAPIResult{apiURL: api, err: fmt.Errorf(errorResp.Error), duration: time.Since(reqStart)}
+				return
+			}
+
+			var result struct {
+				URL string `json:"url"`
+			}
+			if err := json.Unmarshal(body, &result); err != nil {
+				resultChan <- qobuzAPIResult{apiURL: api, err: fmt.Errorf("invalid JSON: %v", err), duration: time.Since(reqStart)}
+				return
+			}
+
+			if result.URL != "" {
+				resultChan <- qobuzAPIResult{apiURL: api, downloadURL: result.URL, err: nil, duration: time.Since(reqStart)}
+				return
+			}
+
+			resultChan <- qobuzAPIResult{apiURL: api, err: fmt.Errorf("no download URL in response"), duration: time.Since(reqStart)}
+		}(apiURL)
+	}
+
+	// Collect results - return first success
+	var errors []string
+	var firstSuccess *qobuzAPIResult
+
+	for i := 0; i < len(apis); i++ {
+		result := <-resultChan
+		if result.err == nil && firstSuccess == nil {
+			firstSuccess = &result
+			GoLog("[Qobuz] [Parallel] ✓ Got response from %s in %v\n", result.apiURL, result.duration)
+
+			// Drain remaining results to avoid goroutine leaks
+			go func(remaining int) {
+				for j := 0; j < remaining; j++ {
+					<-resultChan
+				}
+			}(len(apis) - i - 1)
+
+			GoLog("[Qobuz] [Parallel] Total time: %v (first success)\n", time.Since(startTime))
+			return firstSuccess.apiURL, firstSuccess.downloadURL, nil
+		} else if result.err != nil {
+			errMsg := result.err.Error()
+			if len(errMsg) > 50 {
+				errMsg = errMsg[:50] + "..."
+			}
+			errors = append(errors, fmt.Sprintf("%s: %s", result.apiURL, errMsg))
+		}
+	}
+
+	GoLog("[Qobuz] [Parallel] All %d APIs failed in %v\n", len(apis), time.Since(startTime))
+	return "", "", fmt.Errorf("all %d Qobuz APIs failed. Errors: %v", len(apis), errors)
+}
+
 // getQobuzDownloadURLSequential requests download URL from APIs sequentially
 // Uses same URL format as PC version: /api/stream?trackId={id}&quality={quality}
 func getQobuzDownloadURLSequential(apis []string, trackID int64, quality string) (string, string, error) {
@@ -706,14 +826,16 @@ func getQobuzDownloadURLSequential(apis []string, trackID int64, quality string)
 	return "", "", fmt.Errorf("all %d Qobuz APIs failed. Errors: %v", len(apis), errors)
 }
 
-// GetDownloadURL gets download URL for a track - tries APIs sequentially
+// GetDownloadURL gets download URL for a track - tries ALL APIs in parallel
+// "Siapa cepat dia dapat" - first successful response wins
 func (q *QobuzDownloader) GetDownloadURL(trackID int64, quality string) (string, error) {
 	apis := q.GetAvailableAPIs()
 	if len(apis) == 0 {
 		return "", fmt.Errorf("no Qobuz API available")
 	}
 
-	_, downloadURL, err := getQobuzDownloadURLSequential(apis, trackID, quality)
+	// Use parallel approach - request from all APIs simultaneously
+	_, downloadURL, err := getQobuzDownloadURLParallel(apis, trackID, quality)
 	if err != nil {
 		return "", err
 	}

go_backend/spotify.go

@@ -158,6 +158,7 @@ type TrackMetadata struct {
 	DiscNumber  int    `json:"disc_number,omitempty"`
 	ExternalURL string `json:"external_urls"`
 	ISRC        string `json:"isrc"`
+	AlbumType   string `json:"album_type,omitempty"` // album, single, ep, compilation
 }
 
 // AlbumTrackMetadata holds per-track info for album/playlist
@@ -177,6 +178,7 @@ type AlbumTrackMetadata struct {
 	ISRC        string `json:"isrc"`
 	AlbumID     string `json:"album_id,omitempty"`
 	AlbumURL    string `json:"album_url,omitempty"`
+	AlbumType   string `json:"album_type,omitempty"` // album, single, ep, compilation
 }
 
 // AlbumInfoMetadata holds album information
@@ -301,6 +303,7 @@ type albumSimplified struct {
 	Images      []image     `json:"images"`
 	ExternalURL externalURL `json:"external_urls"`
 	Artists     []artist    `json:"artists"`
+	AlbumType   string      `json:"album_type"` // album, single, compilation
 }
 
 type trackFull struct {
@@ -381,6 +384,7 @@ func (c *SpotifyMetadataClient) SearchTracks(ctx context.Context, query string,
 			DiscNumber:  track.DiscNumber,
 			ExternalURL: track.ExternalURL.Spotify,
 			ISRC:        track.ExternalID.ISRC,
+			AlbumType:   track.Album.AlbumType,
 		})
 	}
 
@@ -448,6 +452,7 @@ func (c *SpotifyMetadataClient) SearchAll(ctx context.Context, query string, tra
 			DiscNumber:  track.DiscNumber,
 			ExternalURL: track.ExternalURL.Spotify,
 			ISRC:        track.ExternalID.ISRC,
+			AlbumType:   track.Album.AlbumType,
 		})
 	}
 

go_backend/tidal.go

@@ -640,20 +640,135 @@ type TidalDownloadInfo struct {
 }
 
 // tidalAPIResult holds the result from a parallel API request
-// Kept for potential future use with _getDownloadURLParallel
-// type tidalAPIResult struct {
-// 	apiURL   string
-// 	info     TidalDownloadInfo
-// 	err      error
-// 	duration time.Duration
-// }
+type tidalAPIResult struct {
+	apiURL   string
+	info     TidalDownloadInfo
+	err      error
+	duration time.Duration
+}
 
-// _getDownloadURLParallel requests download URL from all APIs in parallel
+// getDownloadURLParallel requests download URL from all APIs in parallel
 // Returns the first successful result (supports both v1 and v2 API formats)
-// Kept for potential future use - currently using sequential approach
-// func _getDownloadURLParallel(apis []string, trackID int64, quality string) (string, TidalDownloadInfo, error) {
-// 	... implementation commented out ...
-// }
+// "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")
+	}
+
+	GoLog("[Tidal] Requesting download URL from %d APIs in parallel...\n", len(apis))
+
+	resultChan := make(chan tidalAPIResult, len(apis))
+	startTime := time.Now()
+
+	// Start all requests in parallel
+	for _, apiURL := range apis {
+		go func(api string) {
+			reqStart := time.Now()
+
+			// Create client with timeout for parallel requests
+			client := &http.Client{
+				Timeout: 15 * time.Second,
+			}
+
+			reqURL := fmt.Sprintf("%s/track/?id=%d&quality=%s", api, trackID, quality)
+
+			req, err := http.NewRequest("GET", reqURL, nil)
+			if err != nil {
+				resultChan <- tidalAPIResult{apiURL: api, err: err, duration: time.Since(reqStart)}
+				return
+			}
+
+			resp, err := client.Do(req)
+			if err != nil {
+				resultChan <- tidalAPIResult{apiURL: api, err: err, duration: time.Since(reqStart)}
+				return
+			}
+			defer resp.Body.Close()
+
+			if resp.StatusCode != 200 {
+				resultChan <- tidalAPIResult{apiURL: api, err: fmt.Errorf("HTTP %d", resp.StatusCode), duration: time.Since(reqStart)}
+				return
+			}
+
+			body, err := io.ReadAll(resp.Body)
+			if err != nil {
+				resultChan <- tidalAPIResult{apiURL: api, err: err, duration: time.Since(reqStart)}
+				return
+			}
+
+			// Try v2 format first (object with manifest)
+			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" {
+					resultChan <- tidalAPIResult{apiURL: api, err: fmt.Errorf("returned PREVIEW instead of FULL"), duration: time.Since(reqStart)}
+					return
+				}
+
+				info := TidalDownloadInfo{
+					URL:        "MANIFEST:" + v2Response.Data.Manifest,
+					BitDepth:   v2Response.Data.BitDepth,
+					SampleRate: v2Response.Data.SampleRate,
+				}
+				resultChan <- tidalAPIResult{apiURL: api, info: info, err: nil, duration: time.Since(reqStart)}
+				return
+			}
+
+			// Fallback to v1 format (array with OriginalTrackUrl)
+			var v1Responses []struct {
+				OriginalTrackURL string `json:"OriginalTrackUrl"`
+			}
+			if err := json.Unmarshal(body, &v1Responses); err == nil {
+				for _, item := range v1Responses {
+					if item.OriginalTrackURL != "" {
+						info := TidalDownloadInfo{
+							URL:        item.OriginalTrackURL,
+							BitDepth:   16,
+							SampleRate: 44100,
+						}
+						resultChan <- tidalAPIResult{apiURL: api, info: info, err: nil, duration: time.Since(reqStart)}
+						return
+					}
+				}
+			}
+
+			resultChan <- tidalAPIResult{apiURL: api, err: fmt.Errorf("no download URL or manifest in response"), duration: time.Since(reqStart)}
+		}(apiURL)
+	}
+
+	// Collect results - return first success
+	var errors []string
+	var firstSuccess *tidalAPIResult
+
+	for i := 0; i < len(apis); i++ {
+		result := <-resultChan
+		if result.err == nil && firstSuccess == nil {
+			// First success - use this one
+			firstSuccess = &result
+			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
+				}
+			}(len(apis) - i - 1)
+
+			GoLog("[Tidal] [Parallel] Total time: %v (first success)\n", time.Since(startTime))
+			return firstSuccess.apiURL, firstSuccess.info, nil
+		} else if result.err != nil {
+			errMsg := result.err.Error()
+			if len(errMsg) > 50 {
+				errMsg = errMsg[:50] + "..."
+			}
+			errors = append(errors, fmt.Sprintf("%s: %s", result.apiURL, errMsg))
+		}
+	}
+
+	GoLog("[Tidal] [Parallel] All %d APIs failed in %v\n", len(apis), time.Since(startTime))
+	return "", TidalDownloadInfo{}, fmt.Errorf("all %d Tidal APIs failed. Errors: %v", len(apis), errors)
+}
 
 // getDownloadURLSequential requests download URL from APIs sequentially (fallback)
 // Returns the first successful result (supports both v1 and v2 API formats)
@@ -744,14 +859,16 @@ func getDownloadURLSequential(apis []string, trackID int64, quality string) (str
 	return "", TidalDownloadInfo{}, fmt.Errorf("all %d Tidal APIs failed. Errors: %v", len(apis), errors)
 }
 
-// GetDownloadURL gets download URL for a track - tries APIs sequentially
+// GetDownloadURL gets download URL for a track - tries ALL APIs in parallel
+// "Siapa cepat dia dapat" - first successful response wins
 func (t *TidalDownloader) GetDownloadURL(trackID int64, quality string) (TidalDownloadInfo, error) {
 	apis := t.GetAvailableAPIs()
 	if len(apis) == 0 {
 		return TidalDownloadInfo{}, fmt.Errorf("no API URL configured")
 	}
 
-	_, info, err := getDownloadURLSequential(apis, trackID, quality)
+	// Use parallel approach - request from all APIs simultaneously
+	_, info, err := getDownloadURLParallel(apis, trackID, quality)
 	if err != nil {
 		return TidalDownloadInfo{}, fmt.Errorf("failed to get download URL: %w", err)
 	}

lib/constants/app_info.dart

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

lib/models/download_item.dart

@@ -19,6 +19,7 @@ enum DownloadErrorType {
   notFound,    // Track not found on any service
   rateLimit,   // Rate limited by service
   network,     // Network/connection error
+  permission,  // File/folder permission error
 }
 
 @JsonSerializable()
@@ -88,6 +89,8 @@ class DownloadItem {
         return 'Rate limit reached, try again later';
       case DownloadErrorType.network:
         return 'Connection failed, check your internet';
+      case DownloadErrorType.permission:
+        return 'Cannot write to folder, check storage permission';
       default:
         return error ?? 'An error occurred';
     }

lib/models/download_item.g.dart

@@ -51,4 +51,5 @@ const _$DownloadErrorTypeEnumMap = {
   DownloadErrorType.notFound: 'notFound',
   DownloadErrorType.rateLimit: 'rateLimit',
   DownloadErrorType.network: 'network',
+  DownloadErrorType.permission: 'permission',
 };

lib/models/settings.dart

@@ -27,6 +27,7 @@ class AppSettings {
   final bool enableLogging; // Enable detailed logging for debugging
   final bool useExtensionProviders; // Use extension providers for downloads when available
   final String? searchProvider; // null/empty = default (Deezer/Spotify), otherwise extension ID
+  final bool separateSingles; // Separate singles/EPs into their own folder
 
   const AppSettings({
     this.defaultService = 'tidal',
@@ -52,6 +53,7 @@ class AppSettings {
     this.enableLogging = false, // Default: disabled for performance
     this.useExtensionProviders = true, // Default: use extensions when available
     this.searchProvider, // Default: null (use Deezer/Spotify)
+    this.separateSingles = false, // Default: disabled
   });
 
   AppSettings copyWith({
@@ -78,6 +80,7 @@ class AppSettings {
     bool? enableLogging,
     bool? useExtensionProviders,
     String? searchProvider,
+    bool? separateSingles,
   }) {
     return AppSettings(
       defaultService: defaultService ?? this.defaultService,
@@ -103,6 +106,7 @@ class AppSettings {
       enableLogging: enableLogging ?? this.enableLogging,
       useExtensionProviders: useExtensionProviders ?? this.useExtensionProviders,
       searchProvider: searchProvider ?? this.searchProvider,
+      separateSingles: separateSingles ?? this.separateSingles,
     );
   }
 

lib/models/settings.g.dart

@@ -31,6 +31,7 @@ AppSettings _$AppSettingsFromJson(Map<String, dynamic> json) => AppSettings(
   enableLogging: json['enableLogging'] as bool? ?? false,
   useExtensionProviders: json['useExtensionProviders'] as bool? ?? true,
   searchProvider: json['searchProvider'] as String?,
+  separateSingles: json['separateSingles'] as bool? ?? false,
 );
 
 Map<String, dynamic> _$AppSettingsToJson(AppSettings instance) =>
@@ -58,4 +59,5 @@ Map<String, dynamic> _$AppSettingsToJson(AppSettings instance) =>
       'enableLogging': instance.enableLogging,
       'useExtensionProviders': instance.useExtensionProviders,
       'searchProvider': instance.searchProvider,
+      'separateSingles': instance.separateSingles,
     };

lib/models/track.dart

@@ -19,6 +19,7 @@ class Track {
   final String? deezerId;
   final ServiceAvailability? availability;
   final String? source; // Extension ID that provided this track (null for built-in sources)
+  final String? albumType; // album, single, ep, compilation (from metadata API)
 
   const Track({
     required this.id,
@@ -35,8 +36,12 @@ class Track {
     this.deezerId,
     this.availability,
     this.source,
+    this.albumType,
   });
 
+  /// Check if this track is a single (based on album_type metadata)
+  bool get isSingle => albumType == 'single' || albumType == 'ep';
+
   factory Track.fromJson(Map<String, dynamic> json) => _$TrackFromJson(json);
   Map<String, dynamic> toJson() => _$TrackToJson(this);
   

lib/models/track.g.dart

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

lib/providers/download_queue_provider.dart

@@ -156,8 +156,18 @@ class DownloadHistoryNotifier extends Notifier<DownloadHistoryState> {
         final items = jsonList
             .map((e) => DownloadHistoryItem.fromJson(e as Map<String, dynamic>))
             .toList();
-        state = state.copyWith(items: items);
-        _historyLog.i('Loaded ${items.length} items from storage');
+        
+        // Deduplicate existing history on load
+        final deduplicatedItems = _deduplicateHistory(items);
+        
+        state = state.copyWith(items: deduplicatedItems);
+        _historyLog.i('Loaded ${deduplicatedItems.length} items from storage (original: ${items.length})');
+        
+        // Save if duplicates were removed
+        if (deduplicatedItems.length < items.length) {
+          _historyLog.i('Removed ${items.length - deduplicatedItems.length} duplicate entries');
+          await _saveToStorage();
+        }
       } else {
         _historyLog.d('No history found in storage');
       }
@@ -166,6 +176,46 @@ 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
+    final result = <DownloadHistoryItem>[];
+    
+    for (int i = 0; i < items.length; i++) {
+      final item = items[i];
+      String? key;
+      
+      // Generate unique key based on available identifiers
+      if (item.spotifyId != null && item.spotifyId!.isNotEmpty) {
+        // Extract numeric ID for deezer: prefixed IDs
+        if (item.spotifyId!.startsWith('deezer:')) {
+          key = 'deezer:${item.spotifyId!.substring(7)}';
+        } else {
+          key = 'spotify:${item.spotifyId}';
+        }
+      } else if (item.isrc != null && item.isrc!.isNotEmpty) {
+        key = 'isrc:${item.isrc}';
+      }
+      
+      if (key != null) {
+        if (!seen.containsKey(key)) {
+          // First occurrence - keep it (most recent since list is sorted by date desc)
+          seen[key] = result.length;
+          result.add(item);
+        } else {
+          // Duplicate found - skip (keep the first/most recent one)
+          _historyLog.d('Skipping duplicate: ${item.trackName} (key: $key)');
+        }
+      } else {
+        // No identifier - keep it (can't deduplicate)
+        result.add(item);
+      }
+    }
+    
+    return result;
+  }
+
   Future<void> _saveToStorage() async {
     try {
       final prefs = await SharedPreferences.getInstance();
@@ -183,7 +233,48 @@ class DownloadHistoryNotifier extends Notifier<DownloadHistoryState> {
   }
 
   void addToHistory(DownloadHistoryItem item) {
-    state = state.copyWith(items: [item, ...state.items]);
+    // Check if track already exists in history (by spotifyId, deezerId, or ISRC)
+    final existingIndex = state.items.indexWhere((existing) {
+      // Match by spotifyId (primary identifier - includes deezer:xxx format)
+      if (item.spotifyId != null && 
+          item.spotifyId!.isNotEmpty && 
+          existing.spotifyId == item.spotifyId) {
+        return true;
+      }
+      
+      // Match Deezer tracks: extract numeric ID from "deezer:123456" format
+      if (item.spotifyId != null && item.spotifyId!.startsWith('deezer:') &&
+          existing.spotifyId != null && existing.spotifyId!.startsWith('deezer:')) {
+        final itemDeezerId = item.spotifyId!.substring(7); // Remove "deezer:" prefix
+        final existingDeezerId = existing.spotifyId!.substring(7);
+        if (itemDeezerId == existingDeezerId) {
+          return true;
+        }
+      }
+      
+      // Fallback: match by ISRC if spotifyId not available
+      if (item.isrc != null && 
+          item.isrc!.isNotEmpty && 
+          existing.isrc == item.isrc) {
+        return true;
+      }
+      return false;
+    });
+
+    if (existingIndex >= 0) {
+      // Replace existing entry (update with new download info)
+      final updatedItems = [...state.items];
+      updatedItems[existingIndex] = item;
+      // Move to top of list (most recent)
+      updatedItems.removeAt(existingIndex);
+      updatedItems.insert(0, item);
+      state = state.copyWith(items: updatedItems);
+      _historyLog.d('Updated existing history entry: ${item.trackName}');
+    } else {
+      // Add new entry
+      state = state.copyWith(items: [item, ...state.items]);
+      _historyLog.d('Added new history entry: ${item.trackName}');
+    }
     _saveToStorage();
   }
 
@@ -577,35 +668,55 @@ class DownloadQueueNotifier extends Notifier<DownloadQueueState> {
     state = state.copyWith(outputDir: dir);
   }
 
-  /// Build output directory based on folder organization setting
-  Future<String> _buildOutputDir(Track track, String folderOrganization) async {
+  /// Build output directory based on folder organization setting and separateSingles
+  Future<String> _buildOutputDir(Track track, String folderOrganization, {bool separateSingles = false}) async {
     String baseDir = state.outputDir;
 
-    if (folderOrganization == 'none') {
-      return baseDir;
+    // If separateSingles is enabled, use Albums/Singles structure
+    if (separateSingles) {
+      final isSingle = track.isSingle;
+      
+      if (isSingle) {
+        // Singles go to Singles folder (flat structure)
+        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');
+        }
+        return singlesPath;
+      } else {
+        // Albums go to Albums/Artist/Album structure
+        final artistName = _sanitizeFolderName(track.albumArtist ?? track.artistName);
+        final albumName = _sanitizeFolderName(track.albumName);
+        final 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');
+        }
+        return albumPath;
+      }
     }
 
-    // Sanitize folder names (remove invalid characters)
-    String sanitize(String name) {
-      return name
-          .replaceAll(RegExp(r'[<>:"/\\|?*]'), '_')
-          .replaceAll(RegExp(r'\.+$'), '') // Remove trailing dots
-          .trim();
+    // Original folder organization logic (when separateSingles is disabled)
+    if (folderOrganization == 'none') {
+      return baseDir;
     }
 
     String subPath = '';
     switch (folderOrganization) {
       case 'artist':
-        final artistName = sanitize(track.albumArtist ?? track.artistName);
+        final artistName = _sanitizeFolderName(track.albumArtist ?? track.artistName);
         subPath = artistName;
         break;
       case 'album':
-        final albumName = sanitize(track.albumName);
+        final albumName = _sanitizeFolderName(track.albumName);
         subPath = albumName;
         break;
       case 'artist_album':
-        final artistName = sanitize(track.albumArtist ?? track.artistName);
-        final albumName = sanitize(track.albumName);
+        final artistName = _sanitizeFolderName(track.albumArtist ?? track.artistName);
+        final albumName = _sanitizeFolderName(track.albumName);
         subPath = '$artistName${Platform.pathSeparator}$albumName';
         break;
     }
@@ -623,6 +734,14 @@ class DownloadQueueNotifier extends Notifier<DownloadQueueState> {
     return baseDir;
   }
 
+  /// Sanitize folder names (remove invalid characters)
+  String _sanitizeFolderName(String name) {
+    return name
+        .replaceAll(RegExp(r'[<>:"/\\|?*]'), '_')
+        .replaceAll(RegExp(r'\.+$'), '') // Remove trailing dots
+        .trim();
+  }
+
   void updateSettings(AppSettings settings) {
     state = state.copyWith(
       outputDir: settings.downloadDirectory.isNotEmpty
@@ -1326,6 +1445,7 @@ class DownloadQueueNotifier extends Notifier<DownloadQueueState> {
       final outputDir = await _buildOutputDir(
         trackToDownload,
         settings.folderOrganization,
+        separateSingles: settings.separateSingles,
       );
 
       // Use quality override if set, otherwise use default from settings
@@ -1672,6 +1792,9 @@ class DownloadQueueNotifier extends Notifier<DownloadQueueState> {
           case 'network':
             errorType = DownloadErrorType.network;
             break;
+          case 'permission':
+            errorType = DownloadErrorType.permission;
+            break;
           default:
             errorType = DownloadErrorType.unknown;
         }

lib/providers/settings_provider.dart

@@ -211,6 +211,11 @@ class SettingsNotifier extends Notifier<AppSettings> {
     state = state.copyWith(useExtensionProviders: enabled);
     _saveSettings();
   }
+
+  void setSeparateSingles(bool enabled) {
+    state = state.copyWith(separateSingles: enabled);
+    _saveSettings();
+  }
 }
 
 final settingsProvider = NotifierProvider<SettingsNotifier, AppSettings>(

lib/providers/track_provider.dart

@@ -466,6 +466,7 @@ class TrackNotifier extends Notifier<TrackState> {
       discNumber: data['disc_number'] as int?,
       releaseDate: data['release_date']?.toString(),
       source: source ?? data['source']?.toString() ?? data['provider_id']?.toString(),
+      albumType: data['album_type']?.toString(),
     );
   }
 

lib/screens/settings/download_settings_page.dart

@@ -185,19 +185,31 @@ class DownloadSettingsPage extends ConsumerWidget {
                         : settings.downloadDirectory,
                     onTap: () => _pickDirectory(context, ref),
                   ),
-                  SettingsItem(
-                    icon: Icons.create_new_folder_outlined,
-                    title: 'Folder Organization',
-                    subtitle: _getFolderOrganizationLabel(
-                      settings.folderOrganization,
-                    ),
-                    onTap: () => _showFolderOrganizationPicker(
-                      context,
-                      ref,
-                      settings.folderOrganization,
-                    ),
-                    showDivider: false,
+                  SettingsSwitchItem(
+                    icon: Icons.library_music_outlined,
+                    title: 'Separate Singles Folder',
+                    subtitle: settings.separateSingles
+                        ? 'Albums/ and Singles/ folders'
+                        : 'All files in same structure',
+                    value: settings.separateSingles,
+                    onChanged: (value) => ref
+                        .read(settingsProvider.notifier)
+                        .setSeparateSingles(value),
                   ),
+                  if (!settings.separateSingles)
+                    SettingsItem(
+                      icon: Icons.create_new_folder_outlined,
+                      title: 'Folder Organization',
+                      subtitle: _getFolderOrganizationLabel(
+                        settings.folderOrganization,
+                      ),
+                      onTap: () => _showFolderOrganizationPicker(
+                        context,
+                        ref,
+                        settings.folderOrganization,
+                      ),
+                      showDivider: false,
+                    ),
                 ],
               ),
             ),

lib/screens/setup_screen.dart

@@ -66,24 +66,38 @@ class _SetupScreenState extends ConsumerState<SetupScreen> {
       }
     } else if (Platform.isAndroid) {
       // Check storage permission
-      PermissionStatus storageStatus;
+      bool storageGranted = false;
+      
       if (_androidSdkVersion >= 33) {
-        storageStatus = await Permission.audio.status;
+        // Android 13+: Need BOTH MANAGE_EXTERNAL_STORAGE AND READ_MEDIA_AUDIO
+        final manageStatus = await Permission.manageExternalStorage.status;
+        final audioStatus = await Permission.audio.status;
+        debugPrint('[Permission] Android 13+ check: MANAGE_EXTERNAL_STORAGE=$manageStatus, READ_MEDIA_AUDIO=$audioStatus');
+        storageGranted = manageStatus.isGranted && audioStatus.isGranted;
       } else if (_androidSdkVersion >= 30) {
-        storageStatus = await Permission.manageExternalStorage.status;
+        // Android 11-12: Need MANAGE_EXTERNAL_STORAGE only
+        final manageStatus = await Permission.manageExternalStorage.status;
+        debugPrint('[Permission] Android 11-12 check: MANAGE_EXTERNAL_STORAGE=$manageStatus');
+        storageGranted = manageStatus.isGranted;
       } else {
-        storageStatus = await Permission.storage.status;
+        // Android 10 and below: Use legacy storage permission
+        final storageStatus = await Permission.storage.status;
+        debugPrint('[Permission] Android 10- check: STORAGE=$storageStatus');
+        storageGranted = storageStatus.isGranted;
       }
       
+      debugPrint('[Permission] Final storageGranted=$storageGranted');
+      
       // Check notification permission (Android 13+)
       PermissionStatus notificationStatus = PermissionStatus.granted;
       if (_androidSdkVersion >= 33) {
         notificationStatus = await Permission.notification.status;
+        debugPrint('[Permission] Notification=$notificationStatus');
       }
       
       if (mounted) {
         setState(() {
-          _storagePermissionGranted = storageStatus.isGranted;
+          _storagePermissionGranted = storageGranted;
           _notificationPermissionGranted = notificationStatus.isGranted;
         });
       }
@@ -97,17 +111,57 @@ class _SetupScreenState extends ConsumerState<SetupScreen> {
       if (Platform.isIOS) {
         setState(() => _storagePermissionGranted = true);
       } else if (Platform.isAndroid) {
-        PermissionStatus status;
+        bool allGranted = false;
         
         if (_androidSdkVersion >= 33) {
-          // Android 13+: Use audio permission
-          status = await Permission.audio.request();
+          // Android 13+: Need BOTH MANAGE_EXTERNAL_STORAGE AND READ_MEDIA_AUDIO
+          
+          // First check/request MANAGE_EXTERNAL_STORAGE
+          var manageStatus = await Permission.manageExternalStorage.status;
+          if (!manageStatus.isGranted) {
+            if (mounted) {
+              final shouldOpen = await showDialog<bool>(
+                context: context,
+                builder: (context) => AlertDialog(
+                  title: const Text('Storage Access Required'),
+                  content: const Text(
+                    'SpotiFLAC needs "All files access" permission to save music files to your chosen folder.\n\n'
+                    'Please enable "Allow access to manage all files" in the next screen.',
+                  ),
+                  actions: [
+                    TextButton(
+                      onPressed: () => Navigator.pop(context, false),
+                      child: const Text('Cancel'),
+                    ),
+                    FilledButton(
+                      onPressed: () => Navigator.pop(context, true),
+                      child: const Text('Open Settings'),
+                    ),
+                  ],
+                ),
+              );
+              
+              if (shouldOpen == true) {
+                await Permission.manageExternalStorage.request();
+                // Re-check after returning from settings
+                await Future.delayed(const Duration(milliseconds: 500));
+                manageStatus = await Permission.manageExternalStorage.status;
+              }
+            }
+          }
+          
+          // Then request READ_MEDIA_AUDIO (this shows a dialog)
+          var audioStatus = await Permission.audio.status;
+          if (!audioStatus.isGranted && manageStatus.isGranted) {
+            audioStatus = await Permission.audio.request();
+          }
+          
+          allGranted = manageStatus.isGranted && audioStatus.isGranted;
+          
         } else if (_androidSdkVersion >= 30) {
-          // Android 11-12: Need MANAGE_EXTERNAL_STORAGE
-          // This opens system settings, not a dialog
-          status = await Permission.manageExternalStorage.status;
-          if (!status.isGranted) {
-            // Show explanation dialog first
+          // Android 11-12: Need MANAGE_EXTERNAL_STORAGE only
+          var manageStatus = await Permission.manageExternalStorage.status;
+          if (!manageStatus.isGranted) {
             if (mounted) {
               final shouldOpen = await showDialog<bool>(
                 context: context,
@@ -131,23 +185,33 @@ class _SetupScreenState extends ConsumerState<SetupScreen> {
               );
               
               if (shouldOpen == true) {
-                status = await Permission.manageExternalStorage.request();
+                await Permission.manageExternalStorage.request();
+                // Re-check after returning from settings
+                await Future.delayed(const Duration(milliseconds: 500));
+                manageStatus = await Permission.manageExternalStorage.status;
               }
             }
           }
+          allGranted = manageStatus.isGranted;
+          
         } else {
           // Android 10 and below: Use legacy storage permission
-          status = await Permission.storage.request();
+          final status = await Permission.storage.request();
+          allGranted = status.isGranted;
+          
+          if (status.isPermanentlyDenied) {
+            _showPermissionDeniedDialog('Storage');
+            setState(() => _isLoading = false);
+            return;
+          }
         }
         
-        if (status.isGranted) {
+        if (allGranted) {
           setState(() => _storagePermissionGranted = true);
-        } else if (status.isPermanentlyDenied) {
-          _showPermissionDeniedDialog('Storage');
         } else {
           if (mounted) {
             ScaffoldMessenger.of(context).showSnackBar(
-              const SnackBar(content: Text('Permission denied. Please grant permission to continue.')),
+              const SnackBar(content: Text('Permission denied. Please grant all permissions to continue.')),
             );
           }
         }

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.0.0-alpha.2+51
+version: 3.0.0-alpha.3+52
 
 environment:
   sdk: ^3.10.0