v7.1.3

* support for homebrew ffmpeg on macos

* Add build instructions

* Revise README

* Detect homebrew and install ffmpeg with homebrew

---------

Co-authored-by: afkarxyz <mzamzamafkarhadiq@gmail.com>

.github/FUNDING.yml

@@ -1,2 +1 @@
-github: afkarxyz
 ko_fi: afkarxyz

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -0,0 +1,77 @@
+name: Bug Report
+description: Bug Report
+title: "[Bug Report] "
+labels: ["bug"]
+
+body:
+  - type: markdown
+    attributes:
+      value: |
+        > **WARNING: Issues that do not follow this template will be deleted without review.**
+        >
+        > **Please keep `[Bug Report]` in the issue title and only continue after it.**
+
+  - type: textarea
+    id: problem
+    attributes:
+      label: Problem
+      placeholder: e.g. Downloading a playlist stops after the first track with no error message.
+    validations:
+      required: true
+
+  - type: dropdown
+    id: type
+    attributes:
+      label: Type
+      description: Select the Spotify item type related to this bug.
+      options:
+        - Track
+        - Album
+        - Playlist
+        - Artist
+    validations:
+      required: true
+
+  - type: input
+    id: spotify-url
+    attributes:
+      label: Spotify URL
+      placeholder: e.g. https://open.spotify.com/track/4cOdK2wGLETKBW3PvgPWqT
+    validations:
+      required: true
+
+  - type: textarea
+    id: additional-context
+    attributes:
+      label: Additional Context
+      placeholder: e.g. Happens every time on this link. Screenshot or recording attached.
+    validations:
+      required: true
+
+  - type: markdown
+    attributes:
+      value: "### Environment"
+
+  - type: input
+    id: version
+    attributes:
+      label: SpotiFLAC Version
+      placeholder: e.g. v7.1.0
+    validations:
+      required: true
+
+  - type: input
+    id: os
+    attributes:
+      label: OS
+      placeholder: e.g. Windows 11 23H2
+    validations:
+      required: true
+
+  - type: input
+    id: location
+    attributes:
+      label: Location
+      placeholder: e.g. Indonesia
+    validations:
+      required: true

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1 @@
+blank_issues_enabled: false

.github/ISSUE_TEMPLATE/feature_request.yml

@@ -0,0 +1,36 @@
+name: Feature Request
+description: Feature Request
+title: "[Feature Request] "
+labels: ["enhancement"]
+
+body:
+  - type: markdown
+    attributes:
+      value: |
+        > **WARNING: Issues that do not follow this template will be deleted without review.**
+        >
+        > **Please keep `[Feature Request]` in the issue title and only continue after it.**
+
+  - type: textarea
+    id: description
+    attributes:
+      label: Description
+      placeholder: e.g. Add an option to choose the output naming format for downloaded tracks.
+    validations:
+      required: true
+
+  - type: textarea
+    id: use-case
+    attributes:
+      label: Use Case
+      placeholder: e.g. I want downloaded files to follow a custom format like Artist - Title for easier library management.
+    validations:
+      required: true
+
+  - type: textarea
+    id: additional-context
+    attributes:
+      label: Additional Context
+      placeholder: e.g. Similar tools allow custom naming templates. Screenshot or mockup attached if needed.
+    validations:
+      required: true

README.md

@@ -1,36 +1,28 @@
-[![GitHub All Releases](https://img.shields.io/github/downloads/afkarxyz/SpotiFLAC/total?style=for-the-badge)](https://github.com/afkarxyz/SpotiFLAC/releases)
-[![Telegram Channel](https://img.shields.io/badge/CHANNEL-2CA5E0?style=for-the-badge&logo=telegram&logoColor=white)](https://t.me/spotiflac)
-[![Telegram Community](https://img.shields.io/badge/COMMUNITY-2CA5E0?style=for-the-badge&logo=telegram&logoColor=white)](https://t.me/spotiflac_chat)
+# SpotiFLAC
 
-![Image](https://github.com/user-attachments/assets/a6e92fdd-2944-45c1-83e8-e23a26c827af)
+<a href="https://trendshift.io/repositories/15737" target="_blank"><img src="https://trendshift.io/api/badge/repositories/15737" alt="afkarxyz%2FSpotiFLAC | Trendshift" style="width: 250px; height: 55px;" width="250" height="55"/></a>
 
-<div align="center">
-
-Get Spotify tracks in true FLAC from Tidal, Qobuz, Amazon Music & Deezer — no account required.
+Get Spotify tracks in true FLAC from Tidal, Qobuz & Amazon Music — no account required.
 
 ![Windows](https://img.shields.io/badge/Windows-10%2B-0078D6?style=for-the-badge&logo=data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSI1MTIiIGhlaWdodD0iNTEyIiB2aWV3Qm94PSIwIDAgMjAgMjAiPjxwYXRoIGZpbGw9IiNmZmZmZmYiIGZpbGwtcnVsZT0iZXZlbm9kZCIgZD0iTTIwIDEwLjg3M1YyMEw4LjQ3OSAxOC41MzdsLjAwMS03LjY2NEgyMFptLTEzLjEyIDBsLS4wMDEgNy40NjFMMCAxNy40NjF2LTYuNTg4aDYuODhaTTIwIDkuMjczSDguNDhsLS4wMDEtNy44MUwyMCAwdjkuMjczWk02Ljg3OSAxLjY2NmwuMDAxIDcuNjA3SDBWMi41MzlsNi44NzktLjg3M1oiLz48L3N2Zz4=)
 ![macOS](https://img.shields.io/badge/macOS-10.13%2B-000000?style=for-the-badge&logo=apple&logoColor=white)
 ![Linux](https://img.shields.io/badge/Linux-Any-FCC624?style=for-the-badge&logo=linux&logoColor=white)
-
-<a href="https://trendshift.io/repositories/15737" target="_blank"><img src="https://trendshift.io/api/badge/repositories/15737" alt="afkarxyz%2FSpotiFLAC | Trendshift" style="width: 250px; height: 55px;" width="250" height="55"/></a>
-
-</div>
+[![Announcements](https://img.shields.io/badge/ANNOUNCEMENTS-2CA5E0?style=for-the-badge&logo=telegram&logoColor=white)](https://t.me/spotiflac)
+[![Chat](https://img.shields.io/badge/CHAT-2CA5E0?style=for-the-badge&logo=telegram&logoColor=white)](https://t.me/spotiflac_chat)
 
 ### [Download](https://github.com/afkarxyz/SpotiFLAC/releases)
 
-## Screenshot
-
-![Image](https://github.com/user-attachments/assets/adbdc056-bace-44a9-8ba6-898b4526b65a)
+![Image](https://github.com/user-attachments/assets/c2624ca5-8569-49f0-950e-4410b523cea1)
 
 ## Other projects
 
-### [SpotiFLAC Next](https://github.com/spotiverse/SpotiFLAC-Next)
+### [SpotiFLAC Next](https://github.com/afkarxyz/SpotiFLAC-Next)
 
-Get Spotify tracks in Hi-Res lossless FLACs — no account required.
+Get Spotify tracks in true Lossless from Tidal, Qobuz, Amazon Music, Deezer & Apple Music — no account required.
 
 ### [SpotiDownloader](https://github.com/afkarxyz/SpotiDownloader)
 
-Get Spotify tracks in MP3 and FLAC via spotidownloader.com
+Get Spotify tracks, albums, playlists and discography in MP3 and FLAC.
 
 ### [SpotubeDL](https://spotubedl.com)
 
@@ -40,49 +32,75 @@ Download Spotify Tracks, Albums, Playlists as MP3/OGG/Opus with High Quality.
 
 SpotiFLAC for Android & iOS — maintained by [@zarzet](https://github.com/zarzet)
 
+### [SpotiFLAC (CLI)](https://github.com/Nizarberyan/SpotiFLAC)
+
+SpotiFLAC for command-line environments — maintained by [@Nizarberyan](https://github.com/Nizarberyan)
+
+### [SpotiFLAC (Python Module)](https://github.com/ShuShuzinhuu/SpotiFLAC-Module-Version)
+
+SpotiFLAC Python library for SpotiFLAC integration — maintained by [@ShuShuzinhuu](https://github.com/ShuShuzinhuu)
+
 ## FAQ
 
-### Is this software free?
+<details>
+<summary>Is this software free?</summary>
 
 _Yes. This software is completely free.
 You do not need an account, login, or subscription.
 All you need is an internet connection._
 
-### Can using this software get my Spotify account suspended or banned?
+</details>
+
+<details>
+<summary>Can using this software get my Spotify account suspended or banned?</summary>
 
 _No.
 This software has no connection to your Spotify account.
 Spotify data is obtained through reverse engineering of the Spotify Web Player, not through user authentication._
 
-### Where does the audio come from?
+</details>
+
+<details>
+<summary>Where does the audio come from?</summary>
 
 _The audio is fetched using third-party APIs._
 
-### Why does metadata fetching sometimes fail?
+</details>
+
+<details>
+<summary>Why does metadata fetching sometimes fail?</summary>
 
 _This usually happens because your IP address has been rate-limited.
 You can wait and try again later, or use a VPN to bypass the rate limit._
 
-### Why does Windows Defender or antivirus flag or delete the file?
+</details>
+
+<details>
+<summary>Why does Windows Defender or antivirus flag or delete the file?</summary>
 
 _This is a false positive.
 It likely happens because the executable is compressed using UPX._
 
 _If you are concerned, you can fork the repository and build the software yourself from source._
 
-### Want to support the project?
+</details>
+
+<details>
+<summary>Want to support the project?</summary>
 
 _If this software is useful and brings you value,
 consider supporting the project by buying me a coffee.
 Your support helps keep development going._
 
+</details>
+
 [![Ko-fi](https://ko-fi.com/img/githubbutton_sm.svg)](https://ko-fi.com/afkarxyz)
 
 ## Disclaimer
 
 This project is for **educational and private use only**. The developer does not condone or encourage copyright infringement.
 
-**SpotiFLAC** is a third-party tool and is not affiliated with, endorsed by, or connected to Spotify, Tidal, Qobuz, Amazon Music, or any other streaming service.
+**SpotiFLAC** is a third-party tool and is not affiliated with, endorsed by, or connected to Spotify, Tidal, Qobuz, Amazon Music or any other streaming service.
 
 You are solely responsible for:
 
@@ -94,8 +112,10 @@ The software is provided "as is", without warranty of any kind. The author assum
 
 ## API Credits
 
-[MusicBrainz](https://musicbrainz.org) · [Spotify Lyrics API](https://github.akashrchandran.in/spotify-lyrics-api) · [LRCLIB](https://lrclib.net) · [Song.link](https://song.link) · [hifi-api](https://github.com/binimum/hifi-api) · [dabmusic.xyz](https://dabmusic.xyz) · [yoinkify.lol](https://yoinkify.lol)
+[MusicBrainz](https://musicbrainz.org) · [LRCLIB](https://lrclib.net) · [Songlink/Odesli](https://song.link) · [Songstats](https://songstats.com) · [hifi-api](https://github.com/binimum/hifi-api) · [dabmusic.xyz](https://dabmusic.xyz)
 
 > [!TIP]
 >
 > **Star Us**, You will receive all release notifications from GitHub without any delay ~
+
+[![RepoStars](https://repostars.dev/api/embed?repo=afkarxyz%2FSpotiFLAC&theme=forest)](https://repostars.dev/?repos=afkarxyz%2FSpotiFLAC&theme=forest)

app.go

@@ -4,11 +4,15 @@ import (
 	"context"
 	"encoding/base64"
 	"encoding/json"
+	"errors"
 	"fmt"
+	"io"
+	"net/url"
 	"os"
 
 	"path/filepath"
 
+	"net/http"
 	"strings"
 	"time"
 
@@ -21,10 +25,73 @@ type App struct {
 	ctx context.Context
 }
 
+const checkOperationTimeout = 10 * time.Second
+
 func NewApp() *App {
 	return &App{}
 }
 
+type timedResult[T any] struct {
+	value T
+	err   error
+}
+
+func runWithTimeout[T any](timeout time.Duration, fn func() (T, error)) (T, error) {
+	resultCh := make(chan timedResult[T], 1)
+
+	go func() {
+		value, err := fn()
+		resultCh <- timedResult[T]{value: value, err: err}
+	}()
+
+	select {
+	case result := <-resultCh:
+		return result.value, result.err
+	case <-time.After(timeout):
+		var zero T
+		return zero, fmt.Errorf("operation timed out after %s", timeout)
+	}
+}
+
+func containsStreamingURL(body []byte) bool {
+	trimmedBody := strings.TrimSpace(string(body))
+	if trimmedBody == "" {
+		return false
+	}
+
+	var directResp struct {
+		URL string `json:"url"`
+	}
+	if err := json.Unmarshal(body, &directResp); err == nil && isStreamingURL(directResp.URL) {
+		return true
+	}
+
+	var nestedResp struct {
+		Data struct {
+			URL string `json:"url"`
+		} `json:"data"`
+	}
+	if err := json.Unmarshal(body, &nestedResp); err == nil && isStreamingURL(nestedResp.Data.URL) {
+		return true
+	}
+
+	return isStreamingURL(trimmedBody)
+}
+
+func isStreamingURL(raw string) bool {
+	candidate := strings.TrimSpace(raw)
+	if candidate == "" {
+		return false
+	}
+
+	parsed, err := url.Parse(candidate)
+	if err != nil {
+		return false
+	}
+
+	return (parsed.Scheme == "http" || parsed.Scheme == "https") && parsed.Host != ""
+}
+
 func (a *App) getFirstArtist(artistString string) string {
 	if artistString == "" {
 		return ""
@@ -44,17 +111,26 @@ func (a *App) startup(ctx context.Context) {
 	if err := backend.InitHistoryDB("SpotiFLAC"); err != nil {
 		fmt.Printf("Failed to init history DB: %v\n", err)
 	}
+	if err := backend.InitISRCCacheDB(); err != nil {
+		fmt.Printf("Failed to init ISRC cache DB: %v\n", err)
+	}
+	if err := backend.InitProviderPriorityDB(); err != nil {
+		fmt.Printf("Failed to init provider priority DB: %v\n", err)
+	}
 }
 
 func (a *App) shutdown(ctx context.Context) {
 	backend.CloseHistoryDB()
+	backend.CloseISRCCacheDB()
+	backend.CloseProviderPriorityDB()
 }
 
 type SpotifyMetadataRequest struct {
-	URL     string  `json:"url"`
-	Batch   bool    `json:"batch"`
-	Delay   float64 `json:"delay"`
-	Timeout float64 `json:"timeout"`
+	URL       string  `json:"url"`
+	Batch     bool    `json:"batch"`
+	Delay     float64 `json:"delay"`
+	Timeout   float64 `json:"timeout"`
+	Separator string  `json:"separator,omitempty"`
 }
 
 type DownloadRequest struct {
@@ -91,6 +167,7 @@ type DownloadRequest struct {
 	UseFirstArtistOnly   bool   `json:"use_first_artist_only,omitempty"`
 	UseSingleGenre       bool   `json:"use_single_genre,omitempty"`
 	EmbedGenre           bool   `json:"embed_genre,omitempty"`
+	Separator            string `json:"separator,omitempty"`
 }
 
 type DownloadResponse struct {
@@ -102,6 +179,22 @@ type DownloadResponse struct {
 	ItemID        string `json:"item_id,omitempty"`
 }
 
+func cleanupInvalidDownloadArtifacts(paths ...string) {
+	seen := make(map[string]struct{}, len(paths))
+	for _, path := range paths {
+		if path == "" {
+			continue
+		}
+		if _, ok := seen[path]; ok {
+			continue
+		}
+		seen[path] = struct{}{}
+		if err := os.Remove(path); err == nil {
+			fmt.Printf("Removed invalid download artifact: %s\n", path)
+		}
+	}
+}
+
 func (a *App) GetStreamingURLs(spotifyTrackID string, region string) (string, error) {
 	if spotifyTrackID == "" {
 		return "", fmt.Errorf("spotify track ID is required")
@@ -138,12 +231,27 @@ func (a *App) GetSpotifyMetadata(req SpotifyMetadataRequest) (string, error) {
 	defer cancel()
 
 	settings, err := a.LoadSettings()
+	separator := req.Separator
+	if separator == "" {
+		separator = ", "
+		if err == nil && settings != nil {
+			if sep, ok := settings["separator"].(string); ok {
+				if sep == "semicolon" {
+					separator = "; "
+				} else if sep == "comma" {
+					separator = ", "
+				}
+			}
+		}
+	}
 
 	if err == nil && settings != nil {
 		if useAPI, ok := settings["useSpotFetchAPI"].(bool); ok && useAPI {
 			if apiURL, ok := settings["spotFetchAPIUrl"].(string); ok && apiURL != "" {
 
-				data, err := backend.GetSpotifyDataWithAPI(ctx, req.URL, true, apiURL, req.Batch, time.Duration(req.Delay*float64(time.Second)))
+				data, err := backend.GetSpotifyDataWithAPI(ctx, req.URL, true, apiURL, req.Batch, time.Duration(req.Delay*float64(time.Second)), separator, func(tracks interface{}) {
+					runtime.EventsEmit(a.ctx, "metadata-stream", tracks)
+				})
 				if err != nil {
 					return "", fmt.Errorf("failed to fetch metadata from API: %v", err)
 				}
@@ -158,7 +266,9 @@ func (a *App) GetSpotifyMetadata(req SpotifyMetadataRequest) (string, error) {
 		}
 	}
 
-	data, err := backend.GetFilteredSpotifyData(ctx, req.URL, req.Batch, time.Duration(req.Delay*float64(time.Second)))
+	data, err := backend.GetFilteredSpotifyData(ctx, req.URL, req.Batch, time.Duration(req.Delay*float64(time.Second)), separator, func(tracks interface{}) {
+		runtime.EventsEmit(a.ctx, "metadata-stream", tracks)
+	})
 	if err != nil {
 		return "", fmt.Errorf("failed to fetch metadata: %v", err)
 	}
@@ -279,7 +389,21 @@ func (a *App) DownloadTrack(req DownloadRequest) (DownloadResponse, error) {
 		defer cancel()
 
 		trackURL := fmt.Sprintf("https://open.spotify.com/track/%s", req.SpotifyID)
-		trackData, err := backend.GetFilteredSpotifyData(ctx, trackURL, false, 0)
+		metadataSeparator := req.Separator
+		if metadataSeparator == "" {
+			metadataSeparator = ", "
+			metadataSettings, _ := a.LoadSettings()
+			if metadataSettings != nil {
+				if sep, ok := metadataSettings["separator"].(string); ok {
+					if sep == "semicolon" {
+						metadataSeparator = "; "
+					} else if sep == "comma" {
+						metadataSeparator = ", "
+					}
+				}
+			}
+		}
+		trackData, err := backend.GetFilteredSpotifyData(ctx, trackURL, false, 0, metadataSeparator, nil)
 		if err == nil {
 
 			var trackResp struct {
@@ -342,7 +466,7 @@ func (a *App) DownloadTrack(req DownloadRequest) (DownloadResponse, error) {
 		if req.EmbedLyrics {
 			go func() {
 				client := backend.NewLyricsClient()
-				resp, _, err := client.FetchLyricsAllSources(req.SpotifyID, req.TrackName, req.ArtistName, req.Duration)
+				resp, _, err := client.FetchLyricsAllSources(req.SpotifyID, req.TrackName, req.ArtistName, req.AlbumName, req.Duration)
 				if err == nil && resp != nil && len(resp.Lines) > 0 {
 					lrc := client.ConvertToLRC(resp, req.TrackName, req.ArtistName)
 					lyricsChan <- lrc
@@ -354,11 +478,18 @@ func (a *App) DownloadTrack(req DownloadRequest) (DownloadResponse, error) {
 			close(lyricsChan)
 		}
 
-		go func() {
-			client := backend.NewSongLinkClient()
-			isrc, _ := client.GetISRC(req.SpotifyID)
-			isrcChan <- isrc
-		}()
+		if req.Service == "qobuz" {
+			go func() {
+				client := backend.NewSongLinkClient()
+				isrc, err := client.GetISRCDirect(req.SpotifyID)
+				if err != nil {
+					fmt.Printf("Warning: failed to resolve ISRC for Qobuz: %v\n", err)
+				}
+				isrcChan <- isrc
+			}()
+		} else {
+			close(isrcChan)
+		}
 	} else {
 		close(lyricsChan)
 		close(isrcChan)
@@ -400,11 +531,7 @@ func (a *App) DownloadTrack(req DownloadRequest) (DownloadResponse, error) {
 		if quality == "" {
 			quality = "6"
 		}
-		filename, err = downloader.DownloadTrackWithISRC(isrc, req.SpotifyID, req.OutputDir, quality, req.FilenameFormat, req.TrackNumber, req.Position, req.TrackName, req.ArtistName, req.AlbumName, req.AlbumArtist, req.ReleaseDate, req.UseAlbumTrackNumber, req.CoverURL, req.EmbedMaxQualityCover, req.SpotifyTrackNumber, req.SpotifyDiscNumber, req.SpotifyTotalTracks, req.SpotifyTotalDiscs, req.Copyright, req.Publisher, spotifyURL, req.AllowFallback, req.UseFirstArtistOnly, req.UseSingleGenre, req.EmbedGenre)
-
-	case "deezer":
-		downloader := backend.NewDeezerDownloader()
-		filename, err = downloader.Download(req.SpotifyID, req.OutputDir, req.FilenameFormat, req.PlaylistName, req.PlaylistOwner, req.TrackNumber, req.Position, req.TrackName, req.ArtistName, req.AlbumName, req.AlbumArtist, req.ReleaseDate, req.CoverURL, req.SpotifyTrackNumber, req.SpotifyDiscNumber, req.SpotifyTotalTracks, req.EmbedMaxQualityCover, req.SpotifyTotalDiscs, req.Copyright, req.Publisher, spotifyURL, req.UseFirstArtistOnly, req.UseSingleGenre, req.EmbedGenre)
+		filename, err = downloader.DownloadTrackWithISRC(isrc, req.OutputDir, quality, req.FilenameFormat, req.TrackNumber, req.Position, req.TrackName, req.ArtistName, req.AlbumName, req.AlbumArtist, req.ReleaseDate, req.UseAlbumTrackNumber, req.CoverURL, req.EmbedMaxQualityCover, req.SpotifyTrackNumber, req.SpotifyDiscNumber, req.SpotifyTotalTracks, req.SpotifyTotalDiscs, req.Copyright, req.Publisher, spotifyURL, req.AllowFallback, req.UseFirstArtistOnly, req.UseSingleGenre, req.EmbedGenre)
 
 	default:
 		return DownloadResponse{
@@ -439,6 +566,23 @@ func (a *App) DownloadTrack(req DownloadRequest) (DownloadResponse, error) {
 		filename = strings.TrimPrefix(filename, "EXISTS:")
 	}
 
+	if !alreadyExists {
+		validated, validationErr := backend.ValidateDownloadedTrackDuration(filename, req.Duration)
+		if validationErr != nil {
+			cleanupInvalidDownloadArtifacts(filename)
+			errorMessage := validationErr.Error()
+			backend.FailDownloadItem(itemID, errorMessage)
+			return DownloadResponse{
+				Success: false,
+				Error:   errorMessage,
+				ItemID:  itemID,
+			}, errors.New(errorMessage)
+		}
+		if !validated {
+			fmt.Printf("[DownloadValidation] Skipped duration validation for %s (expected=%ds)\n", filename, req.Duration)
+		}
+	}
+
 	if !alreadyExists && req.SpotifyID != "" && req.EmbedLyrics && (strings.HasSuffix(filename, ".flac") || strings.HasSuffix(filename, ".mp3") || strings.HasSuffix(filename, ".m4a")) {
 		fmt.Printf("\nWaiting for lyrics fetch to complete...\n")
 		lyrics := <-lyricsChan
@@ -470,6 +614,14 @@ func (a *App) DownloadTrack(req DownloadRequest) (DownloadResponse, error) {
 		message = "File already exists"
 		backend.SkipDownloadItem(itemID, filename)
 	} else {
+		if strings.EqualFold(filepath.Ext(filename), ".flac") && req.CoverURL != "" {
+			coverClient := backend.NewCoverClient()
+			if iconErr := coverClient.ApplyMacOSFLACFileIcon(filename, req.CoverURL, 256, req.EmbedMaxQualityCover); iconErr != nil {
+				fmt.Printf("Warning: failed to set macOS FLAC file icon: %v\n", iconErr)
+			} else {
+				fmt.Printf("macOS FLAC file icon set: %s\n", filename)
+			}
+		}
 
 		if fileInfo, statErr := os.Stat(filename); statErr == nil {
 			finalSize := float64(fileInfo.Size()) / (1024 * 1024)
@@ -479,15 +631,15 @@ func (a *App) DownloadTrack(req DownloadRequest) (DownloadResponse, error) {
 			backend.CompleteDownloadItem(itemID, filename, 0)
 		}
 
-		go func(fPath, track, artist, album, sID, cover, format string) {
+		go func(fPath, track, artist, album, sID, cover, format, source string) {
+			time.Sleep(2 * time.Second)
+
 			quality := "Unknown"
-			durationStr := "--:--"
+			durationStr := "0:00"
 
 			meta, err := backend.GetTrackMetadata(fPath)
-			if err == nil && meta != nil {
-				if meta.BitsPerSample > 0 {
-					quality = fmt.Sprintf("%d-bit/%.1fkHz", meta.BitsPerSample, float64(meta.SampleRate)/1000.0)
-				} else if meta.Bitrate > 0 {
+			if err == nil {
+				if meta.Bitrate > 0 {
 					quality = fmt.Sprintf("%dkbps/%.1fkHz", meta.Bitrate/1000, float64(meta.SampleRate)/1000.0)
 				} else if meta.SampleRate > 0 {
 					quality = fmt.Sprintf("%.1fkHz", float64(meta.SampleRate)/1000.0)
@@ -508,6 +660,7 @@ func (a *App) DownloadTrack(req DownloadRequest) (DownloadResponse, error) {
 				Quality:     quality,
 				Format:      strings.ToUpper(format),
 				Path:        fPath,
+				Source:      source,
 			}
 
 			if item.Format == "" || item.Format == "LOSSLESS" {
@@ -523,7 +676,7 @@ func (a *App) DownloadTrack(req DownloadRequest) (DownloadResponse, error) {
 			}
 
 			backend.AddHistoryItem(item, "SpotiFLAC")
-		}(filename, req.TrackName, req.ArtistName, req.AlbumName, req.SpotifyID, req.CoverURL, req.AudioFormat)
+		}(filename, req.TrackName, req.ArtistName, req.AlbumName, req.SpotifyID, req.CoverURL, req.AudioFormat, req.Service)
 	}
 
 	return DownloadResponse{
@@ -548,6 +701,14 @@ func (a *App) OpenFolder(path string) error {
 	return nil
 }
 
+func (a *App) OpenConfigFolder() error {
+	configDir, err := backend.EnsureAppDir()
+	if err != nil {
+		return fmt.Errorf("failed to create config directory: %v", err)
+	}
+	return backend.OpenFolderInExplorer(configDir)
+}
+
 func (a *App) SelectFolder(defaultPath string) (string, error) {
 	return backend.SelectFolderDialog(a.ctx, defaultPath)
 }
@@ -660,6 +821,68 @@ func (a *App) ExportFailedDownloads() (string, error) {
 	return fmt.Sprintf("Successfully exported %d failed downloads to %s", count, path), nil
 }
 
+func (a *App) CheckAPIStatus(apiType string, apiURL string) bool {
+	isOnline, err := runWithTimeout(checkOperationTimeout, func() (bool, error) {
+		var checkURL string
+		if apiType == "tidal" {
+			checkURL = fmt.Sprintf("%s/track/?id=441821360&quality=HI_RES_LOSSLESS", apiURL)
+		} else if apiType == "qobuz" {
+			checkURL = fmt.Sprintf("%s/api/stream?trackId=360735657&quality=27", apiURL)
+		} else if apiType == "qbz" {
+			checkURL = fmt.Sprintf("%s/api/track/360735657?quality=27", apiURL)
+		} else if apiType == "amazon" {
+			checkURL = fmt.Sprintf("%s/status", apiURL)
+		} else {
+			checkURL = apiURL
+		}
+
+		client := &http.Client{Timeout: 10 * time.Second}
+		req, err := http.NewRequest("GET", checkURL, nil)
+		if err != nil {
+			return false, err
+		}
+		req.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36")
+
+		maxRetries := 3
+		for i := 0; i < maxRetries; i++ {
+			resp, err := client.Do(req)
+			if err == nil {
+				statusCode := resp.StatusCode
+				body, readErr := io.ReadAll(resp.Body)
+				resp.Body.Close()
+				if readErr != nil {
+					if i < maxRetries-1 {
+						time.Sleep(1 * time.Second)
+					}
+					continue
+				}
+
+				if apiType == "amazon" && statusCode == 200 && strings.Contains(string(body), `"amazonMusic":"up"`) {
+					return true, nil
+				}
+
+				if (apiType == "qobuz" || apiType == "qbz") && statusCode == 200 && containsStreamingURL(body) {
+					return true, nil
+				}
+
+				if apiType != "amazon" && apiType != "qobuz" && apiType != "qbz" && statusCode == 200 {
+					return true, nil
+				}
+			}
+			if i < maxRetries-1 {
+				time.Sleep(1 * time.Second)
+			}
+		}
+		return false, nil
+	})
+	if err != nil {
+		fmt.Printf("CheckAPIStatus timeout/error for %s (%s): %v\n", apiType, apiURL, err)
+		return false
+	}
+
+	return isOnline
+}
+
 func (a *App) Quit() {
 
 	panic("quit")
@@ -697,46 +920,28 @@ func (a *App) ClearFetchHistoryByType(itemType string) error {
 	return backend.ClearFetchHistoryByType(itemType, "SpotiFLAC")
 }
 
-func (a *App) AnalyzeTrack(filePath string) (string, error) {
-	if filePath == "" {
-		return "", fmt.Errorf("file path is required")
+func (a *App) SaveSpectrumImage(audioFilePath string, base64Data string) (string, error) {
+	if audioFilePath == "" || base64Data == "" {
+		return "", fmt.Errorf("file path and image data are required")
 	}
 
-	result, err := backend.AnalyzeTrack(filePath)
+	base64Data = strings.TrimPrefix(base64Data, "data:image/png;base64,")
+
+	data, err := base64.StdEncoding.DecodeString(base64Data)
 	if err != nil {
-		return "", fmt.Errorf("failed to analyze track: %v", err)
+		return "", fmt.Errorf("failed to decode base64 image: %v", err)
 	}
 
-	jsonData, err := json.Marshal(result)
+	ext := filepath.Ext(audioFilePath)
+	baseName := strings.TrimSuffix(filepath.Base(audioFilePath), ext)
+	outPath := filepath.Join(filepath.Dir(audioFilePath), baseName+".png")
+
+	err = os.WriteFile(outPath, data, 0644)
 	if err != nil {
-		return "", fmt.Errorf("failed to encode response: %v", err)
+		return "", fmt.Errorf("failed to save image to disk: %v", err)
 	}
 
-	return string(jsonData), nil
-}
-
-func (a *App) AnalyzeMultipleTracks(filePaths []string) (string, error) {
-	if len(filePaths) == 0 {
-		return "", fmt.Errorf("at least one file path is required")
-	}
-
-	results := make([]*backend.AnalysisResult, 0, len(filePaths))
-
-	for _, filePath := range filePaths {
-		result, err := backend.AnalyzeTrack(filePath)
-		if err != nil {
-
-			continue
-		}
-		results = append(results, result)
-	}
-
-	jsonData, err := json.Marshal(results)
-	if err != nil {
-		return "", fmt.Errorf("failed to encode response: %v", err)
-	}
-
-	return string(jsonData), nil
+	return outPath, nil
 }
 
 type LyricsDownloadRequest struct {
@@ -961,18 +1166,20 @@ func (a *App) CheckTrackAvailability(spotifyTrackID string) (string, error) {
 		return "", fmt.Errorf("spotify track ID is required")
 	}
 
-	client := backend.NewSongLinkClient()
-	availability, err := client.CheckTrackAvailability(spotifyTrackID)
-	if err != nil {
-		return "", err
-	}
+	return runWithTimeout(checkOperationTimeout, func() (string, error) {
+		client := backend.NewSongLinkClient()
+		availability, err := client.CheckTrackAvailability(spotifyTrackID)
+		if err != nil {
+			return "", err
+		}
 
-	jsonData, err := json.Marshal(availability)
-	if err != nil {
-		return "", fmt.Errorf("failed to encode response: %v", err)
-	}
+		jsonData, err := json.Marshal(availability)
+		if err != nil {
+			return "", fmt.Errorf("failed to encode response: %v", err)
+		}
 
-	return string(jsonData), nil
+		return string(jsonData), nil
+	})
 }
 
 func (a *App) IsFFmpegInstalled() (bool, error) {
@@ -983,10 +1190,6 @@ func (a *App) IsFFprobeInstalled() (bool, error) {
 	return backend.IsFFprobeInstalled()
 }
 
-func (a *App) GetFFmpegPath() (string, error) {
-	return backend.GetFFmpegPath()
-}
-
 type DownloadFFmpegRequest struct{}
 
 type DownloadFFmpegResponse struct {
@@ -1015,6 +1218,41 @@ func (a *App) DownloadFFmpeg() DownloadFFmpegResponse {
 	}
 }
 
+func (a *App) GetBrewPath() string {
+	return backend.GetBrewPath()
+}
+
+func (a *App) IsBrewFFmpegInstalled() (bool, error) {
+	return backend.IsBrewFFmpegInstalled()
+}
+
+type InstallFFmpegWithBrewResponse struct {
+	Success bool   `json:"success"`
+	Message string `json:"message"`
+	Error   string `json:"error,omitempty"`
+}
+
+func (a *App) InstallFFmpegWithBrew() InstallFFmpegWithBrewResponse {
+	runtime.EventsEmit(a.ctx, "ffmpeg:status", "Installing FFmpeg via Homebrew...")
+	err := backend.InstallFFmpegWithBrew(func(progress int, status string) {
+		runtime.EventsEmit(a.ctx, "ffmpeg:progress", progress)
+		runtime.EventsEmit(a.ctx, "ffmpeg:status", status)
+	})
+	if err != nil {
+		runtime.EventsEmit(a.ctx, "ffmpeg:status", "failed")
+		return InstallFFmpegWithBrewResponse{
+			Success: false,
+			Error:   err.Error(),
+		}
+	}
+
+	runtime.EventsEmit(a.ctx, "ffmpeg:status", "completed")
+	return InstallFFmpegWithBrewResponse{
+		Success: true,
+		Message: "FFmpeg installed successfully via Homebrew",
+	}
+}
+
 type ConvertAudioRequest struct {
 	InputFiles   []string `json:"input_files"`
 	OutputFormat string   `json:"output_format"`
@@ -1032,6 +1270,21 @@ func (a *App) ConvertAudio(req ConvertAudioRequest) ([]backend.ConvertAudioResul
 	return backend.ConvertAudio(backendReq)
 }
 
+type ResampleAudioRequest struct {
+	InputFiles []string `json:"input_files"`
+	SampleRate string   `json:"sample_rate"`
+	BitDepth   string   `json:"bit_depth"`
+}
+
+func (a *App) ResampleAudio(req ResampleAudioRequest) ([]backend.ResampleResult, error) {
+	backendReq := backend.ResampleRequest{
+		InputFiles: req.InputFiles,
+		SampleRate: req.SampleRate,
+		BitDepth:   req.BitDepth,
+	}
+	return backend.ResampleAudio(backendReq)
+}
+
 func (a *App) SelectAudioFiles() ([]string, error) {
 	files, err := backend.SelectMultipleFiles(a.ctx)
 	if err != nil {
@@ -1040,6 +1293,10 @@ func (a *App) SelectAudioFiles() ([]string, error) {
 	return files, nil
 }
 
+func (a *App) GetFlacInfoBatch(paths []string) []backend.FlacInfo {
+	return backend.GetFlacInfoBatch(paths)
+}
+
 func (a *App) GetFileSizes(files []string) map[string]int64 {
 	return backend.GetFileSizes(files)
 }
@@ -1081,6 +1338,23 @@ func (a *App) ReadTextFile(filePath string) (string, error) {
 	return string(content), nil
 }
 
+func (a *App) ReadFileAsBase64(filePath string) (string, error) {
+	content, err := os.ReadFile(filePath)
+	if err != nil {
+		return "", err
+	}
+
+	return base64.StdEncoding.EncodeToString(content), nil
+}
+
+func (a *App) DecodeAudioForAnalysis(filePath string) (*backend.AnalysisDecodeResponse, error) {
+	if filePath == "" {
+		return nil, fmt.Errorf("file path is required")
+	}
+
+	return backend.DecodeAudioForAnalysis(filePath)
+}
+
 func (a *App) RenameFileTo(oldPath, newName string) error {
 	dir := filepath.Dir(oldPath)
 	ext := filepath.Ext(oldPath)
@@ -1088,23 +1362,6 @@ func (a *App) RenameFileTo(oldPath, newName string) error {
 	return os.Rename(oldPath, newPath)
 }
 
-func (a *App) UploadImage(filePath string) (string, error) {
-	return backend.UploadToSendNow(filePath)
-}
-
-func (a *App) UploadImageBytes(filename string, base64Data string) (string, error) {
-
-	if idx := strings.Index(base64Data, ","); idx != -1 {
-		base64Data = base64Data[idx+1:]
-	}
-
-	data, err := base64.StdEncoding.DecodeString(base64Data)
-	if err != nil {
-		return "", fmt.Errorf("failed to decode base64: %v", err)
-	}
-	return backend.UploadBytesToSendNow(filename, data)
-}
-
 func (a *App) SelectImageVideo() ([]string, error) {
 	return backend.SelectImageVideoDialog(a.ctx)
 }
@@ -1370,10 +1627,6 @@ func (a *App) CheckFFmpegInstalled() (bool, error) {
 	return backend.IsFFmpegInstalled()
 }
 
-func (a *App) GetOSInfo() (string, error) {
-	return backend.GetOSInfo()
-}
-
 func (a *App) CreateM3U8File(m3u8Name string, outputDir string, filePaths []string) error {
 	if len(filePaths) == 0 {
 		return nil

backend/amazon.go

@@ -5,7 +5,6 @@ import (
 	"fmt"
 	"io"
 	"net/http"
-	"net/url"
 	"os"
 	"os/exec"
 	"path/filepath"
@@ -19,12 +18,6 @@ type AmazonDownloader struct {
 	regions []string
 }
 
-type SongLinkResponse struct {
-	LinksByPlatform map[string]struct {
-		URL string `json:"url"`
-	} `json:"linksByPlatform"`
-}
-
 type AmazonStreamResponse struct {
 	StreamURL     string `json:"streamUrl"`
 	DecryptionKey string `json:"decryptionKey"`
@@ -40,65 +33,17 @@ func NewAmazonDownloader() *AmazonDownloader {
 }
 
 func (a *AmazonDownloader) GetAmazonURLFromSpotify(spotifyTrackID string) (string, error) {
-
-	spotifyBase := "https://open.spotify.com/track/"
-	spotifyURL := fmt.Sprintf("%s%s", spotifyBase, spotifyTrackID)
-
-	apiBase := "https://api.song.link/v1-alpha.1/links?url="
-	apiURL := fmt.Sprintf("%s%s", apiBase, url.QueryEscape(spotifyURL))
-
-	req, err := http.NewRequest("GET", apiURL, nil)
-	if err != nil {
-		return "", fmt.Errorf("failed to create request: %w", err)
-	}
-	req.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36")
-
 	fmt.Println("Getting Amazon URL...")
-
-	resp, err := a.client.Do(req)
+	client := NewSongLinkClient()
+	urls, err := client.GetAllURLsFromSpotify(spotifyTrackID, "")
 	if err != nil {
 		return "", fmt.Errorf("failed to get Amazon URL: %w", err)
 	}
-	defer resp.Body.Close()
 
-	if resp.StatusCode != 200 {
-		return "", fmt.Errorf("API returned status %d", resp.StatusCode)
-	}
-
-	body, err := io.ReadAll(resp.Body)
-	if err != nil {
-		return "", fmt.Errorf("failed to read response body: %w", err)
-	}
-
-	if len(body) == 0 {
-		return "", fmt.Errorf("API returned empty response")
-	}
-
-	var songLinkResp SongLinkResponse
-	if err := json.Unmarshal(body, &songLinkResp); err != nil {
-
-		bodyStr := string(body)
-		if len(bodyStr) > 200 {
-			bodyStr = bodyStr[:200] + "..."
-		}
-		return "", fmt.Errorf("failed to decode response: %w (response: %s)", err, bodyStr)
-	}
-
-	amazonLink, ok := songLinkResp.LinksByPlatform["amazonMusic"]
-	if !ok || amazonLink.URL == "" {
+	amazonURL := normalizeAmazonMusicURL(urls.AmazonURL)
+	if amazonURL == "" {
 		return "", fmt.Errorf("amazon Music link not found")
 	}
-
-	amazonURL := amazonLink.URL
-
-	if strings.Contains(amazonURL, "trackAsin=") {
-		parts := strings.Split(amazonURL, "trackAsin=")
-		if len(parts) > 1 {
-			trackAsin := strings.Split(parts[1], "&")[0]
-			amazonURL = fmt.Sprintf("https://music.amazon.com/tracks/%s?musicTerritory=US", trackAsin)
-		}
-	}
-
 	fmt.Printf("Found Amazon URL: %s\n", amazonURL)
 	return amazonURL, nil
 }
@@ -111,7 +56,7 @@ func (a *AmazonDownloader) DownloadFromAfkarXYZ(amazonURL, outputDir, quality st
 		return "", fmt.Errorf("failed to extract ASIN from URL: %s", amazonURL)
 	}
 
-	apiURL := fmt.Sprintf("https://amzn.afkarxyz.fun/api/track/%s", asin)
+	apiURL := fmt.Sprintf("https://amzn.afkarxyz.qzz.io/api/track/%s", asin)
 	req, err := http.NewRequest("GET", apiURL, nil)
 	if err != nil {
 		return "", err
@@ -442,6 +387,7 @@ func (a *AmazonDownloader) DownloadByURL(amazonURL, outputDir, quality, filename
 		DiscNumber:  spotifyDiscNumber,
 		TotalDiscs:  spotifyTotalDiscs,
 		URL:         spotifyURL,
+		Comment:     spotifyURL,
 		Copyright:   spotifyCopyright,
 		Publisher:   spotifyPublisher,
 		Description: "https://github.com/afkarxyz/SpotiFLAC",

backend/analysis.go

@@ -1,171 +1,39 @@
 package backend
 
 import (
+	"bytes"
+	"encoding/base64"
 	"fmt"
-	"math"
 	"os"
 	"os/exec"
 	"strconv"
 	"strings"
 	"time"
-
-	"github.com/go-flac/go-flac"
-	mewflac "github.com/mewkiz/flac"
 )
 
 type AnalysisResult struct {
-	FilePath      string        `json:"file_path"`
-	FileSize      int64         `json:"file_size"`
-	SampleRate    uint32        `json:"sample_rate"`
-	Channels      uint8         `json:"channels"`
-	BitsPerSample uint8         `json:"bits_per_sample"`
-	TotalSamples  uint64        `json:"total_samples"`
-	Duration      float64       `json:"duration"`
-	Bitrate       int           `json:"bit_rate"`
-	BitDepth      string        `json:"bit_depth"`
-	DynamicRange  float64       `json:"dynamic_range"`
-	PeakAmplitude float64       `json:"peak_amplitude"`
-	RMSLevel      float64       `json:"rms_level"`
-	Spectrum      *SpectrumData `json:"spectrum,omitempty"`
+	FilePath      string  `json:"file_path"`
+	FileSize      int64   `json:"file_size"`
+	SampleRate    uint32  `json:"sample_rate"`
+	Channels      uint8   `json:"channels"`
+	BitsPerSample uint8   `json:"bits_per_sample"`
+	TotalSamples  uint64  `json:"total_samples"`
+	Duration      float64 `json:"duration"`
+	Bitrate       int     `json:"bit_rate"`
+	BitDepth      string  `json:"bit_depth"`
+	DynamicRange  float64 `json:"dynamic_range"`
+	PeakAmplitude float64 `json:"peak_amplitude"`
+	RMSLevel      float64 `json:"rms_level"`
 }
 
-func AnalyzeTrack(filepath string) (*AnalysisResult, error) {
-	if !fileExists(filepath) {
-		return nil, fmt.Errorf("file does not exist: %s", filepath)
-	}
-
-	fileInfo, err := os.Stat(filepath)
-	if err != nil {
-		return nil, fmt.Errorf("failed to get file info: %w", err)
-	}
-
-	f, err := flac.ParseFile(filepath)
-	if err != nil {
-		return nil, fmt.Errorf("failed to parse FLAC file: %w", err)
-	}
-
-	result := &AnalysisResult{
-		FilePath: filepath,
-		FileSize: fileInfo.Size(),
-	}
-
-	if len(f.Meta) > 0 {
-		streamInfo := f.Meta[0]
-		if streamInfo.Type == flac.StreamInfo {
-
-			data := streamInfo.Data
-			if len(data) >= 18 {
-
-				result.SampleRate = uint32(data[10])<<12 | uint32(data[11])<<4 | uint32(data[12])>>4
-
-				result.Channels = ((data[12] >> 1) & 0x07) + 1
-
-				result.BitsPerSample = ((data[12]&0x01)<<4 | data[13]>>4) + 1
-
-				result.TotalSamples = uint64(data[13]&0x0F)<<32 |
-					uint64(data[14])<<24 |
-					uint64(data[15])<<16 |
-					uint64(data[16])<<8 |
-					uint64(data[17])
-
-				if result.SampleRate > 0 {
-					result.Duration = float64(result.TotalSamples) / float64(result.SampleRate)
-				}
-
-			}
-		}
-	}
-
-	spectrum, err := AnalyzeSpectrum(filepath)
-	if err != nil {
-
-		fmt.Printf("Warning: failed to analyze spectrum: %v\n", err)
-	} else {
-		result.Spectrum = spectrum
-
-		calculateRealAudioMetrics(result, filepath)
-	}
-
-	result.BitDepth = fmt.Sprintf("%d-bit", result.BitsPerSample)
-
-	return result, nil
-}
-
-func calculateRealAudioMetrics(result *AnalysisResult, filepath string) {
-
-	samples, err := decodeFLACForMetrics(filepath)
-	if err != nil {
-		return
-	}
-
-	var peak float64
-	var sumSquares float64
-
-	for _, sample := range samples {
-		absVal := sample
-		if absVal < 0 {
-			absVal = -absVal
-		}
-		if absVal > peak {
-			peak = absVal
-		}
-		sumSquares += sample * sample
-	}
-
-	peakDB := 20.0 * math.Log10(peak)
-	result.PeakAmplitude = peakDB
-
-	rms := math.Sqrt(sumSquares / float64(len(samples)))
-	rmsDB := 20.0 * math.Log10(rms)
-	result.RMSLevel = rmsDB
-
-	result.DynamicRange = peakDB - rmsDB
-}
-
-func decodeFLACForMetrics(filepath string) ([]float64, error) {
-	stream, err := mewflac.ParseFile(filepath)
-	if err != nil {
-		return nil, err
-	}
-	defer stream.Close()
-
-	maxSamples := 10000000
-	samples := make([]float64, 0, maxSamples)
-
-	for {
-		frame, err := stream.ParseNext()
-		if err != nil {
-			break
-		}
-
-		var channelSamples []int32
-		if len(frame.Subframes) > 0 {
-			channelSamples = frame.Subframes[0].Samples
-		}
-
-		maxVal := float64(int64(1) << (stream.Info.BitsPerSample - 1))
-		for _, sample := range channelSamples {
-			if len(samples) >= maxSamples {
-				return samples, nil
-			}
-			normalized := float64(sample) / maxVal
-			samples = append(samples, normalized)
-		}
-
-		if len(samples) >= maxSamples {
-			break
-		}
-	}
-
-	return samples, nil
-}
-
-func GetFileSize(filepath string) (int64, error) {
-	info, err := os.Stat(filepath)
-	if err != nil {
-		return 0, err
-	}
-	return info.Size(), nil
+type AnalysisDecodeResponse struct {
+	PCMBase64     string  `json:"pcm_base64"`
+	SampleRate    uint32  `json:"sample_rate"`
+	Channels      uint8   `json:"channels"`
+	BitsPerSample uint8   `json:"bits_per_sample"`
+	Duration      float64 `json:"duration"`
+	BitrateKbps   int     `json:"bitrate_kbps,omitempty"`
+	BitDepth      string  `json:"bit_depth,omitempty"`
 }
 
 func GetTrackMetadata(filepath string) (*AnalysisResult, error) {
@@ -194,20 +62,23 @@ func GetMetadataWithFFprobe(filePath string) (*AnalysisResult, error) {
 		"-v", "error",
 		"-select_streams", "a:0",
 		"-show_entries", "stream=sample_rate,channels,bits_per_raw_sample,bits_per_sample,duration,bit_rate",
-		"-of", "default=noprint_wrappers=1:nokey=1",
+		"-of", "default=noprint_wrappers=0",
 		filePath,
 	}
-
 	cmd := exec.Command(ffprobePath, args...)
 	setHideWindow(cmd)
 	output, err := cmd.CombinedOutput()
 	if err != nil {
-		return nil, fmt.Errorf("ffprobe failed: %w - %s", err, string(output))
+		return nil, fmt.Errorf("ffprobe failed: %v - %s", err, string(output))
 	}
 
-	lines := strings.Split(strings.TrimSpace(string(output)), "\n")
-	if len(lines) < 4 {
-		return nil, fmt.Errorf("unexpected ffprobe output: %s", string(output))
+	infoMap := make(map[string]string)
+	lines := strings.Split(string(output), "\n")
+	for _, line := range lines {
+		if strings.Contains(line, "=") {
+			parts := strings.SplitN(line, "=", 2)
+			infoMap[strings.TrimSpace(parts[0])] = strings.TrimSpace(parts[1])
+		}
 	}
 
 	res := &AnalysisResult{
@@ -218,28 +89,6 @@ func GetMetadataWithFFprobe(filePath string) (*AnalysisResult, error) {
 		res.FileSize = info.Size()
 	}
 
-	infoMap := make(map[string]string)
-
-	args = []string{
-		"-v", "error",
-		"-select_streams", "a:0",
-		"-show_entries", "stream=sample_rate,channels,bits_per_raw_sample,bits_per_sample,duration,bit_rate",
-		"-of", "default=noprint_wrappers=0",
-		filePath,
-	}
-	cmd = exec.Command(ffprobePath, args...)
-	setHideWindow(cmd)
-	output, err = cmd.CombinedOutput()
-	if err == nil {
-		lines = strings.Split(string(output), "\n")
-		for _, line := range lines {
-			if strings.Contains(line, "=") {
-				parts := strings.SplitN(line, "=", 2)
-				infoMap[strings.TrimSpace(parts[0])] = strings.TrimSpace(parts[1])
-			}
-		}
-	}
-
 	if val, ok := infoMap["sample_rate"]; ok {
 		s, _ := strconv.Atoi(val)
 		res.SampleRate = uint32(s)
@@ -276,3 +125,90 @@ func GetMetadataWithFFprobe(filePath string) (*AnalysisResult, error) {
 
 	return res, nil
 }
+
+func DecodeAudioForAnalysis(filePath string) (*AnalysisDecodeResponse, error) {
+	metadata, err := GetTrackMetadata(filePath)
+	if err != nil {
+		return nil, err
+	}
+
+	pcmBase64, err := extractAnalysisPCMBase64(filePath)
+	if err != nil {
+		return nil, err
+	}
+
+	resp := &AnalysisDecodeResponse{
+		PCMBase64:     pcmBase64,
+		SampleRate:    metadata.SampleRate,
+		Channels:      metadata.Channels,
+		BitsPerSample: metadata.BitsPerSample,
+		Duration:      metadata.Duration,
+		BitDepth:      metadata.BitDepth,
+	}
+
+	if metadata.Bitrate > 0 {
+		resp.BitrateKbps = metadata.Bitrate / 1000
+	}
+
+	return resp, nil
+}
+
+func extractAnalysisPCMBase64(filePath string) (string, error) {
+	ffmpegPath, err := GetFFmpegPath()
+	if err != nil {
+		return "", err
+	}
+
+	argSets := [][]string{
+		{
+			"-v", "error",
+			"-i", filePath,
+			"-vn",
+			"-map", "0:a:0",
+			"-af", "pan=mono|c0=c0",
+			"-f", "s16le",
+			"-acodec", "pcm_s16le",
+			"pipe:1",
+		},
+		{
+			"-v", "error",
+			"-i", filePath,
+			"-vn",
+			"-map", "0:a:0",
+			"-ac", "1",
+			"-f", "s16le",
+			"-acodec", "pcm_s16le",
+			"pipe:1",
+		},
+	}
+
+	var lastErr error
+
+	for _, args := range argSets {
+		var stdout bytes.Buffer
+		var stderr bytes.Buffer
+
+		cmd := exec.Command(ffmpegPath, args...)
+		setHideWindow(cmd)
+		cmd.Stdout = &stdout
+		cmd.Stderr = &stderr
+
+		if err := cmd.Run(); err != nil {
+			lastErr = fmt.Errorf("ffmpeg analysis decode failed: %w - %s", err, strings.TrimSpace(stderr.String()))
+			continue
+		}
+
+		if stdout.Len() == 0 {
+			lastErr = fmt.Errorf("ffmpeg analysis decode returned empty PCM output")
+			continue
+		}
+
+		return base64.StdEncoding.EncodeToString(stdout.Bytes()), nil
+	}
+
+	if lastErr != nil {
+		return "", lastErr
+	}
+
+	return "", fmt.Errorf("ffmpeg analysis decode failed")
+}

backend/config.go

@@ -1,8 +1,10 @@
 package backend
 
 import (
+	"encoding/json"
 	"os"
 	"path/filepath"
+	"strings"
 )
 
 func GetDefaultMusicPath() string {
@@ -15,3 +17,87 @@ func GetDefaultMusicPath() string {
 
 	return filepath.Join(homeDir, "Music")
 }
+
+func GetConfigPath() (string, error) {
+	dir, err := EnsureAppDir()
+	if err != nil {
+		return "", err
+	}
+
+	return filepath.Join(dir, "config.json"), nil
+}
+
+func LoadConfigSettings() (map[string]interface{}, error) {
+	configPath, err := GetConfigPath()
+	if err != nil {
+		return nil, err
+	}
+
+	if _, err := os.Stat(configPath); os.IsNotExist(err) {
+		return nil, nil
+	}
+
+	data, err := os.ReadFile(configPath)
+	if err != nil {
+		return nil, err
+	}
+
+	var settings map[string]interface{}
+	if err := json.Unmarshal(data, &settings); err != nil {
+		return nil, err
+	}
+
+	return settings, nil
+}
+
+func GetSpotFetchAPISettings() (bool, string) {
+	settings, err := LoadConfigSettings()
+	if err != nil || settings == nil {
+		return false, ""
+	}
+
+	useAPI, _ := settings["useSpotFetchAPI"].(bool)
+	if !useAPI {
+		return false, ""
+	}
+
+	apiURL, _ := settings["spotFetchAPIUrl"].(string)
+	if apiURL == "" {
+		apiURL = "https://sp.afkarxyz.qzz.io/api"
+	}
+
+	return true, apiURL
+}
+
+func GetLinkResolverSetting() string {
+	settings, err := LoadConfigSettings()
+	if err != nil || settings == nil {
+		return linkResolverProviderDeezerSongLink
+	}
+
+	resolver, _ := settings["linkResolver"].(string)
+	switch strings.TrimSpace(strings.ToLower(resolver)) {
+	case "songlink", linkResolverProviderDeezerSongLink:
+		return linkResolverProviderDeezerSongLink
+	case "songstats":
+		return linkResolverProviderSongstats
+	case "":
+		return linkResolverProviderDeezerSongLink
+	default:
+		return linkResolverProviderDeezerSongLink
+	}
+}
+
+func GetLinkResolverAllowFallback() bool {
+	settings, err := LoadConfigSettings()
+	if err != nil || settings == nil {
+		return true
+	}
+
+	allowFallback, ok := settings["allowResolverFallback"].(bool)
+	if !ok {
+		return true
+	}
+
+	return allowFallback
+}

backend/cover.go

@@ -1,7 +1,10 @@
 package backend
 
 import (
+	"bytes"
 	"fmt"
+	"image"
+	"image/png"
 	"io"
 	"net/http"
 	"os"
@@ -9,6 +12,9 @@ import (
 	"regexp"
 	"strings"
 	"time"
+
+	xdraw "golang.org/x/image/draw"
+	_ "image/jpeg"
 )
 
 const (
@@ -117,7 +123,7 @@ func buildCoverFilename(trackName, artistName, albumName, albumArtist, releaseDa
 		}
 	}
 
-	return filename + ".cover.jpg"
+	return filename + ".jpg"
 }
 
 func convertSmallToMedium(imageURL string) string {
@@ -170,6 +176,69 @@ func (c *CoverClient) DownloadCoverToPath(coverURL, outputPath string, embedMaxQ
 	return nil
 }
 
+func (c *CoverClient) ApplyMacOSFLACFileIcon(filePath, coverURL string, iconSize int, embedMaxQualityCover bool) error {
+	if filePath == "" {
+		return fmt.Errorf("file path is required")
+	}
+	if coverURL == "" {
+		return fmt.Errorf("cover URL is required")
+	}
+
+	tmpFile, err := os.CreateTemp("", "spotiflac-file-icon-*.jpg")
+	if err != nil {
+		return fmt.Errorf("failed to create temporary cover file: %w", err)
+	}
+	tmpPath := tmpFile.Name()
+	tmpFile.Close()
+	defer os.Remove(tmpPath)
+
+	if err := c.DownloadCoverToPath(coverURL, tmpPath, embedMaxQualityCover); err != nil {
+		return err
+	}
+
+	return SetMacOSFileIconFromImage(filePath, tmpPath, iconSize)
+}
+
+func ResizeImageForIcon(sourcePath string, iconSize int) (string, error) {
+	if sourcePath == "" {
+		return "", fmt.Errorf("source image path is required")
+	}
+	if iconSize <= 0 {
+		iconSize = 256
+	}
+
+	in, err := os.Open(sourcePath)
+	if err != nil {
+		return "", fmt.Errorf("failed to open source image: %w", err)
+	}
+	defer in.Close()
+
+	srcImage, _, err := image.Decode(in)
+	if err != nil {
+		return "", fmt.Errorf("failed to decode source image: %w", err)
+	}
+
+	dst := image.NewRGBA(image.Rect(0, 0, iconSize, iconSize))
+	xdraw.CatmullRom.Scale(dst, dst.Bounds(), srcImage, srcImage.Bounds(), xdraw.Over, nil)
+
+	tmpFile, err := os.CreateTemp("", "spotiflac-resized-icon-*.png")
+	if err != nil {
+		return "", fmt.Errorf("failed to create resized icon temp file: %w", err)
+	}
+	tmpPath := tmpFile.Name()
+	defer tmpFile.Close()
+
+	var encoded bytes.Buffer
+	if err := png.Encode(&encoded, dst); err != nil {
+		return "", fmt.Errorf("failed to encode resized icon image: %w", err)
+	}
+	if _, err := io.Copy(tmpFile, &encoded); err != nil {
+		return "", fmt.Errorf("failed to write resized icon image: %w", err)
+	}
+
+	return tmpPath, nil
+}
+
 func (c *CoverClient) DownloadCover(req CoverDownloadRequest) (*CoverDownloadResponse, error) {
 	if req.CoverURL == "" {
 		return &CoverDownloadResponse{

backend/deezer.go

@@ -1,273 +0,0 @@
-package backend
-
-import (
-	"bytes"
-	"encoding/json"
-	"fmt"
-	"io"
-	"net/http"
-	"os"
-	"path/filepath"
-	"strings"
-	"time"
-)
-
-type DeezerDownloader struct {
-	client *http.Client
-}
-
-func NewDeezerDownloader() *DeezerDownloader {
-	return &DeezerDownloader{
-		client: &http.Client{
-			Timeout: 300 * time.Second,
-		},
-	}
-}
-
-type YoinkifyRequest struct {
-	URL         string `json:"url"`
-	Format      string `json:"format"`
-	GenreSource string `json:"genreSource"`
-}
-
-func (d *DeezerDownloader) DownloadFromYoinkify(spotifyURL, outputDir string) (string, error) {
-	apiURL := "https://yoinkify.lol/api/download"
-
-	payload := YoinkifyRequest{
-		URL:         spotifyURL,
-		Format:      "flac",
-		GenreSource: "spotify",
-	}
-
-	jsonData, err := json.Marshal(payload)
-	if err != nil {
-		return "", err
-	}
-
-	req, err := http.NewRequest("POST", apiURL, bytes.NewBuffer(jsonData))
-	if err != nil {
-		return "", err
-	}
-	req.Header.Set("Content-Type", "application/json")
-	req.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36")
-
-	fmt.Printf("Fetching from Deezer API (Yoinkify)...\n")
-	resp, err := d.client.Do(req)
-	if err != nil {
-		return "", err
-	}
-	defer resp.Body.Close()
-
-	if resp.StatusCode != 200 {
-		return "", fmt.Errorf("Deezer API returned status %d", resp.StatusCode)
-	}
-
-	tempFileName := fmt.Sprintf("deezer_%d.flac", time.Now().UnixNano())
-	filePath := filepath.Join(outputDir, tempFileName)
-
-	out, err := os.Create(filePath)
-	if err != nil {
-		return "", err
-	}
-	defer out.Close()
-
-	fmt.Printf("Downloading track from Deezer...\n")
-	pw := NewProgressWriter(out)
-	_, err = io.Copy(pw, resp.Body)
-	if err != nil {
-		out.Close()
-		os.Remove(filePath)
-		return "", err
-	}
-
-	fmt.Printf("\rDownloaded: %.2f MB (Complete)\n", float64(pw.GetTotal())/(1024*1024))
-	return filePath, nil
-}
-
-func (d *DeezerDownloader) Download(spotifyID, outputDir, filenameFormat, playlistName, playlistOwner string, includeTrackNumber bool, position int, spotifyTrackName, spotifyArtistName, spotifyAlbumName, spotifyAlbumArtist, spotifyReleaseDate, spotifyCoverURL string, spotifyTrackNumber, spotifyDiscNumber, spotifyTotalTracks int, embedMaxQualityCover bool, spotifyTotalDiscs int, spotifyCopyright, spotifyPublisher, spotifyURL string, useFirstArtistOnly bool, useSingleGenre bool, embedGenre bool) (string, error) {
-
-	if outputDir != "." {
-		if err := os.MkdirAll(outputDir, 0755); err != nil {
-			return "", fmt.Errorf("failed to create output directory: %w", err)
-		}
-	}
-
-	if spotifyTrackName != "" && spotifyArtistName != "" {
-		filenameArtist := spotifyArtistName
-		filenameAlbumArtist := spotifyAlbumArtist
-		if useFirstArtistOnly {
-			filenameArtist = GetFirstArtist(spotifyArtistName)
-			filenameAlbumArtist = GetFirstArtist(spotifyAlbumArtist)
-		}
-		expectedFilename := BuildExpectedFilename(spotifyTrackName, filenameArtist, spotifyAlbumName, filenameAlbumArtist, spotifyReleaseDate, filenameFormat, playlistName, playlistOwner, includeTrackNumber, position, spotifyDiscNumber, false)
-		expectedPath := filepath.Join(outputDir, expectedFilename)
-
-		if fileInfo, err := os.Stat(expectedPath); err == nil && fileInfo.Size() > 0 {
-			fmt.Printf("File already exists: %s (%.2f MB)\n", expectedPath, float64(fileInfo.Size())/(1024*1024))
-			return "EXISTS:" + expectedPath, nil
-		}
-	}
-
-	type mbResult struct {
-		ISRC     string
-		Metadata Metadata
-	}
-
-	metaChan := make(chan mbResult, 1)
-	if (embedGenre || true) && spotifyURL != "" {
-		go func() {
-			res := mbResult{}
-			var isrc string
-			parts := strings.Split(spotifyURL, "/")
-			if len(parts) > 0 {
-				sID := strings.Split(parts[len(parts)-1], "?")[0]
-				if sID != "" {
-					client := NewSongLinkClient()
-					if val, err := client.GetISRC(sID); err == nil {
-						isrc = val
-					}
-				}
-			}
-			res.ISRC = isrc
-			if isrc != "" && embedGenre {
-				fmt.Println("Fetching MusicBrainz metadata...")
-				if fetchedMeta, err := FetchMusicBrainzMetadata(isrc, spotifyTrackName, spotifyArtistName, spotifyAlbumName, useSingleGenre, embedGenre); err == nil {
-					res.Metadata = fetchedMeta
-					fmt.Println("✓ MusicBrainz metadata fetched")
-				} else {
-					fmt.Printf("Warning: Failed to fetch MusicBrainz metadata: %v\n", err)
-				}
-			}
-			metaChan <- res
-		}()
-	} else {
-		close(metaChan)
-	}
-
-	filePath, err := d.DownloadFromYoinkify(spotifyURL, outputDir)
-	if err != nil {
-		return "", err
-	}
-
-	var isrc string
-	var mbMeta Metadata
-	if spotifyURL != "" {
-		result := <-metaChan
-		isrc = result.ISRC
-		mbMeta = result.Metadata
-	}
-
-	if spotifyTrackName != "" && spotifyArtistName != "" {
-		safeArtist := sanitizeFilename(spotifyArtistName)
-		safeAlbumArtist := sanitizeFilename(spotifyAlbumArtist)
-
-		if useFirstArtistOnly {
-			safeArtist = sanitizeFilename(GetFirstArtist(spotifyArtistName))
-			safeAlbumArtist = sanitizeFilename(GetFirstArtist(spotifyAlbumArtist))
-		}
-
-		safeTitle := sanitizeFilename(spotifyTrackName)
-		safeAlbum := sanitizeFilename(spotifyAlbumName)
-
-		year := ""
-		if len(spotifyReleaseDate) >= 4 {
-			year = spotifyReleaseDate[:4]
-		}
-
-		var newFilename string
-
-		if strings.Contains(filenameFormat, "{") {
-			newFilename = filenameFormat
-			newFilename = strings.ReplaceAll(newFilename, "{title}", safeTitle)
-			newFilename = strings.ReplaceAll(newFilename, "{artist}", safeArtist)
-			newFilename = strings.ReplaceAll(newFilename, "{album}", safeAlbum)
-			newFilename = strings.ReplaceAll(newFilename, "{album_artist}", safeAlbumArtist)
-			newFilename = strings.ReplaceAll(newFilename, "{year}", year)
-			newFilename = strings.ReplaceAll(newFilename, "{date}", SanitizeFilename(spotifyReleaseDate))
-
-			if spotifyDiscNumber > 0 {
-				newFilename = strings.ReplaceAll(newFilename, "{disc}", fmt.Sprintf("%d", spotifyDiscNumber))
-			} else {
-				newFilename = strings.ReplaceAll(newFilename, "{disc}", "")
-			}
-
-			if position > 0 {
-				newFilename = strings.ReplaceAll(newFilename, "{track}", fmt.Sprintf("%02d", position))
-			} else {
-				newFilename = strings.ReplaceAll(newFilename, "{track}", "")
-			}
-		} else {
-			switch filenameFormat {
-			case "artist-title":
-				newFilename = fmt.Sprintf("%s - %s", safeArtist, safeTitle)
-			case "title":
-				newFilename = safeTitle
-			default:
-				newFilename = fmt.Sprintf("%s - %s", safeTitle, safeArtist)
-			}
-
-			if includeTrackNumber && position > 0 {
-				newFilename = fmt.Sprintf("%02d. %s", position, newFilename)
-			}
-		}
-
-		ext := ".flac"
-		newFilename = newFilename + ext
-		newFilePath := filepath.Join(outputDir, newFilename)
-
-		if err := os.Rename(filePath, newFilePath); err != nil {
-			fmt.Printf("Warning: Failed to rename file: %v\n", err)
-		} else {
-			filePath = newFilePath
-			fmt.Printf("Renamed to: %s\n", newFilename)
-		}
-	}
-
-	fmt.Println("Embedding Spotify metadata...")
-
-	coverPath := ""
-	if spotifyCoverURL != "" {
-		coverPath = filePath + ".cover.jpg"
-		coverClient := NewCoverClient()
-		if err := coverClient.DownloadCoverToPath(spotifyCoverURL, coverPath, embedMaxQualityCover); err != nil {
-			fmt.Printf("Warning: Failed to download Spotify cover: %v\n", err)
-			coverPath = ""
-		} else {
-			defer os.Remove(coverPath)
-			fmt.Println("Spotify cover downloaded")
-		}
-	}
-
-	trackNumberToEmbed := spotifyTrackNumber
-	if trackNumberToEmbed == 0 {
-		trackNumberToEmbed = 1
-	}
-
-	metadata := Metadata{
-		Title:       spotifyTrackName,
-		Artist:      spotifyArtistName,
-		Album:       spotifyAlbumName,
-		AlbumArtist: spotifyAlbumArtist,
-		Date:        spotifyReleaseDate,
-		TrackNumber: trackNumberToEmbed,
-		TotalTracks: spotifyTotalTracks,
-		DiscNumber:  spotifyDiscNumber,
-		TotalDiscs:  spotifyTotalDiscs,
-		URL:         spotifyURL,
-		Copyright:   spotifyCopyright,
-		Publisher:   spotifyPublisher,
-		Description: "https://github.com/afkarxyz/SpotiFLAC",
-		ISRC:        isrc,
-		Genre:       mbMeta.Genre,
-	}
-
-	if err := EmbedMetadataToConvertedFile(filePath, metadata, coverPath); err != nil {
-		fmt.Printf("Warning: Failed to embed metadata: %v\n", err)
-	} else {
-		fmt.Println("Metadata embedded successfully")
-	}
-
-	fmt.Println("Done")
-	fmt.Println("✓ Downloaded successfully from Deezer")
-	return filePath, nil
-}

backend/download_validation.go

@@ -0,0 +1,44 @@
+package backend
+
+import (
+	"fmt"
+	"math"
+)
+
+const (
+	previewMaxSeconds         = 35
+	previewExpectedMinSeconds = 60
+	largeMismatchMinExpected  = 90
+	minAllowedDurationDiff    = 15
+	durationDiffRatio         = 0.25
+)
+
+func ValidateDownloadedTrackDuration(filePath string, expectedSeconds int) (bool, error) {
+	if filePath == "" || expectedSeconds <= 0 {
+		return false, nil
+	}
+
+	actualDuration, err := GetAudioDuration(filePath)
+	if err != nil || actualDuration <= 0 {
+		return false, nil
+	}
+
+	actualSeconds := int(math.Round(actualDuration))
+	if actualSeconds <= 0 {
+		return false, nil
+	}
+
+	if expectedSeconds >= previewExpectedMinSeconds && actualSeconds <= previewMaxSeconds {
+		return true, fmt.Errorf("detected preview/sample download: file is %ds, expected about %ds. file was removed", actualSeconds, expectedSeconds)
+	}
+
+	if expectedSeconds >= largeMismatchMinExpected {
+		allowedDiff := int(math.Max(minAllowedDurationDiff, math.Round(float64(expectedSeconds)*durationDiffRatio)))
+		diff := int(math.Abs(float64(actualSeconds - expectedSeconds)))
+		if diff > allowedDiff {
+			return true, fmt.Errorf("downloaded file duration mismatch: file is %ds, expected about %ds. file was removed", actualSeconds, expectedSeconds)
+		}
+	}
+
+	return true, nil
+}

backend/ffmpeg.go

@@ -16,6 +16,7 @@ import (
 	"time"
 
 	"github.com/ulikunitz/xz"
+	"golang.org/x/text/unicode/norm"
 )
 
 func ValidateExecutable(path string) error {
@@ -57,7 +58,7 @@ func ValidateExecutable(path string) error {
 	return nil
 }
 
-func GetFFmpegDir() (string, error) {
+func GetAppDir() (string, error) {
 	homeDir, err := os.UserHomeDir()
 	if err != nil {
 		return "", fmt.Errorf("failed to get home directory: %w", err)
@@ -65,6 +66,23 @@ func GetFFmpegDir() (string, error) {
 	return filepath.Join(homeDir, ".spotiflac"), nil
 }
 
+func EnsureAppDir() (string, error) {
+	appDir, err := GetAppDir()
+	if err != nil {
+		return "", err
+	}
+
+	if err := os.MkdirAll(appDir, 0o755); err != nil {
+		return "", fmt.Errorf("failed to create app directory: %w", err)
+	}
+
+	return appDir, nil
+}
+
+func GetFFmpegDir() (string, error) {
+	return EnsureAppDir()
+}
+
 func GetFFmpegPath() (string, error) {
 	ffmpegDir, err := GetFFmpegDir()
 	if err != nil {
@@ -81,6 +99,28 @@ func GetFFmpegPath() (string, error) {
 		return localPath, nil
 	}
 
+	if runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" {
+		homebrewPath := "/opt/homebrew/bin/" + ffmpegName
+		if _, err := os.Stat(homebrewPath); err == nil {
+			return homebrewPath, nil
+		}
+	} else if runtime.GOOS == "darwin" && runtime.GOARCH == "amd64" {
+		homebrewPath := "/usr/local/bin/" + ffmpegName
+		if _, err := os.Stat(homebrewPath); err == nil {
+			return homebrewPath, nil
+		}
+	}
+
+	if runtime.GOOS != "windows" {
+		path, err := exec.Command("which", ffmpegName).Output()
+		if err == nil {
+			trimmed := strings.TrimSpace(string(path))
+			if trimmed != "" {
+				return trimmed, nil
+			}
+		}
+	}
+
 	path, err := exec.LookPath(ffmpegName)
 	if err == nil {
 		return path, nil
@@ -105,6 +145,28 @@ func GetFFprobePath() (string, error) {
 		return localPath, nil
 	}
 
+	if runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" {
+		homebrewPath := "/opt/homebrew/bin/" + ffprobeName
+		if _, err := os.Stat(homebrewPath); err == nil {
+			return homebrewPath, nil
+		}
+	} else if runtime.GOOS == "darwin" && runtime.GOARCH == "amd64" {
+		homebrewPath := "/usr/local/bin/" + ffprobeName
+		if _, err := os.Stat(homebrewPath); err == nil {
+			return homebrewPath, nil
+		}
+	}
+
+	if runtime.GOOS != "windows" {
+		path, err := exec.Command("which", ffprobeName).Output()
+		if err == nil {
+			trimmed := strings.TrimSpace(string(path))
+			if trimmed != "" {
+				return trimmed, nil
+			}
+		}
+	}
+
 	path, err := exec.LookPath(ffprobeName)
 	if err == nil {
 		return path, nil
@@ -146,6 +208,53 @@ func IsFFmpegInstalled() (bool, error) {
 	return err == nil, nil
 }
 
+func GetBrewPath() string {
+	brewPaths := []string{
+		"/opt/homebrew/bin/brew",
+		"/usr/local/bin/brew",
+	}
+
+	for _, path := range brewPaths {
+		if _, err := os.Stat(path); err == nil {
+			return path
+		}
+	}
+
+	return ""
+}
+
+func IsBrewFFmpegInstalled() (bool, error) {
+	brewPath := GetBrewPath()
+	if brewPath == "" {
+		return false, nil
+	}
+
+	cmd := exec.Command(brewPath, "list", "ffmpeg")
+	setHideWindow(cmd)
+	err := cmd.Run()
+	return err == nil, nil
+}
+
+func InstallFFmpegWithBrew(progressCallback func(int, string)) error {
+	brewPath := GetBrewPath()
+	if brewPath == "" {
+		return fmt.Errorf("brew not found")
+	}
+
+	progressCallback(10, "Installing FFmpeg via Homebrew...")
+
+	cmd := exec.Command(brewPath, "install", "ffmpeg")
+	setHideWindow(cmd)
+	output, err := cmd.CombinedOutput()
+	if err != nil {
+		return fmt.Errorf("failed to install ffmpeg: %w - %s", err, string(output))
+	}
+
+	progressCallback(100, "done")
+
+	return nil
+}
+
 const (
 	ffmpegWindowsURL = "https://github.com/afkarxyz/ffmpeg-binaries/releases/download/v8.0/ffmpeg-windows-amd64.zip"
 	ffmpegLinuxURL   = "https://github.com/afkarxyz/ffmpeg-binaries/releases/download/v8.0/ffmpeg-linux-amd64.tar.xz"
@@ -251,7 +360,7 @@ func downloadAndExtract(url, destDir string, progressCallback func(int), progres
 	if err != nil {
 		return fmt.Errorf("failed to create request: %w", err)
 	}
-	req.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36")
+	req.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36")
 
 	resp, err := client.Do(req)
 	if err != nil {
@@ -559,6 +668,7 @@ func ConvertAudio(req ConvertAudioRequest) ([]ConvertAudioResult, error) {
 
 			outputExt := "." + strings.ToLower(req.OutputFormat)
 			outputFile := filepath.Join(outputDir, baseName+outputExt)
+			outputFile = norm.NFC.String(outputFile)
 
 			if inputExt == outputExt {
 				result.Error = "Input and output formats are the same"
@@ -580,7 +690,11 @@ func ConvertAudio(req ConvertAudioRequest) ([]ConvertAudioResult, error) {
 				fmt.Printf("[FFmpeg] Warning: Failed to extract metadata from %s: %v\n", inputFile, err)
 			}
 
-			coverArtPath, _ = ExtractCoverArt(inputFile)
+			inputFile = norm.NFC.String(inputFile)
+			coverArtPath, err = ExtractCoverArt(inputFile)
+			if err != nil {
+				fmt.Printf("[FFmpeg] Warning: Failed to extract cover art from %s: %v\n", inputFile, err)
+			}
 			lyrics, err = ExtractLyrics(inputFile)
 			if err != nil {
 				fmt.Printf("[FFmpeg] Warning: Failed to extract lyrics from %s: %v\n", inputFile, err)

backend/file_dialog.go

@@ -11,8 +11,8 @@ func SelectMultipleFiles(ctx context.Context) ([]string, error) {
 		Title: "Select Audio Files",
 		Filters: []runtime.FileFilter{
 			{
-				DisplayName: "Audio Files (*.mp3, *.m4a, *.flac)",
-				Pattern:     "*.mp3;*.m4a;*.flac",
+				DisplayName: "Audio Files (*.mp3, *.m4a, *.flac, *.aac)",
+				Pattern:     "*.mp3;*.m4a;*.flac;*.aac",
 			},
 			{
 				DisplayName: "MP3 Files (*.mp3)",
@@ -26,6 +26,10 @@ func SelectMultipleFiles(ctx context.Context) ([]string, error) {
 				DisplayName: "FLAC Files (*.flac)",
 				Pattern:     "*.flac",
 			},
+			{
+				DisplayName: "AAC Files (*.aac)",
+				Pattern:     "*.aac",
+			},
 			{
 				DisplayName: "All Files (*.*)",
 				Pattern:     "*.*",

backend/fileicon_darwin.go

@@ -0,0 +1,45 @@
+//go:build darwin
+
+package backend
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"strings"
+)
+
+func SetMacOSFileIconFromImage(filePath, imagePath string, iconSize int) error {
+	if filePath == "" {
+		return fmt.Errorf("file path is required")
+	}
+	if imagePath == "" {
+		return fmt.Errorf("image path is required")
+	}
+
+	resizedPath, err := ResizeImageForIcon(imagePath, iconSize)
+	if err != nil {
+		return err
+	}
+	defer os.Remove(resizedPath)
+
+	script := `
+use framework "AppKit"
+on run argv
+    set imagePath to item 1 of argv
+    set targetPath to item 2 of argv
+    set iconImage to current application's NSImage's alloc()'s initWithContentsOfFile:imagePath
+    if iconImage is missing value then error "Failed to load icon image"
+    set didSet to (current application's NSWorkspace's sharedWorkspace()'s setIcon:iconImage forFile:targetPath options:0) as boolean
+    if didSet is false then error "Failed to set custom file icon"
+end run
+`
+
+	cmd := exec.Command("osascript", "-", resizedPath, filePath)
+	cmd.Stdin = strings.NewReader(script)
+	output, err := cmd.CombinedOutput()
+	if err != nil {
+		return fmt.Errorf("failed to apply macOS file icon: %v (%s)", err, strings.TrimSpace(string(output)))
+	}
+	return nil
+}

backend/fileicon_stub.go

@@ -0,0 +1,7 @@
+//go:build !darwin
+
+package backend
+
+func SetMacOSFileIconFromImage(filePath, imagePath string, iconSize int) error {
+	return nil
+}

backend/filemanager.go

@@ -94,7 +94,7 @@ func ListAudioFiles(dirPath string) ([]FileInfo, error) {
 		}
 
 		ext := strings.ToLower(filepath.Ext(path))
-		if ext == ".flac" || ext == ".mp3" || ext == ".m4a" {
+		if ext == ".flac" || ext == ".mp3" || ext == ".m4a" || ext == ".aac" {
 			result = append(result, FileInfo{
 				Name:  info.Name(),
 				Path:  path,

backend/filename.go

@@ -133,10 +133,26 @@ func GetFirstArtist(artistString string) string {
 }
 
 func NormalizePath(folderPath string) string {
-
 	return strings.ReplaceAll(folderPath, "/", string(filepath.Separator))
 }
 
+func GetSeparator() string {
+	settings, err := LoadConfigSettings()
+	if err != nil || settings == nil {
+		return "; "
+	}
+
+	if sep, ok := settings["separator"].(string); ok {
+		if sep == "comma" {
+			return ", "
+		}
+		if sep == "semicolon" {
+			return "; "
+		}
+	}
+	return "; "
+}
+
 func SanitizeFolderPath(folderPath string) string {
 
 	normalizedPath := strings.ReplaceAll(folderPath, "/", string(filepath.Separator))

backend/folder.go

@@ -50,12 +50,28 @@ func SelectFolderDialog(ctx context.Context, defaultPath string) (string, error)
 
 func SelectFileDialog(ctx context.Context) (string, error) {
 	options := wailsRuntime.OpenDialogOptions{
-		Title: "Select FLAC File for Analysis",
+		Title: "Select Audio File for Analysis",
 		Filters: []wailsRuntime.FileFilter{
+			{
+				DisplayName: "Audio Files (*.flac;*.mp3;*.m4a;*.aac)",
+				Pattern:     "*.flac;*.mp3;*.m4a;*.aac",
+			},
 			{
 				DisplayName: "FLAC Audio Files (*.flac)",
 				Pattern:     "*.flac",
 			},
+			{
+				DisplayName: "MP3 Audio Files (*.mp3)",
+				Pattern:     "*.mp3",
+			},
+			{
+				DisplayName: "M4A Audio Files (*.m4a)",
+				Pattern:     "*.m4a",
+			},
+			{
+				DisplayName: "AAC Audio Files (*.aac)",
+				Pattern:     "*.aac",
+			},
 			{
 				DisplayName: "All Files (*.*)",
 				Pattern:     "*.*",

backend/history.go

@@ -3,7 +3,6 @@ package backend
 import (
 	"encoding/json"
 	"fmt"
-	"os"
 	"path/filepath"
 	"sort"
 	"time"
@@ -22,6 +21,7 @@ type HistoryItem struct {
 	Quality     string `json:"quality"`
 	Format      string `json:"format"`
 	Path        string `json:"path"`
+	Source      string `json:"source"`
 	Timestamp   int64  `json:"timestamp"`
 }
 
@@ -34,13 +34,10 @@ const (
 
 func InitHistoryDB(appName string) error {
 
-	appDir, err := GetFFmpegDir()
+	appDir, err := EnsureAppDir()
 	if err != nil {
 		return err
 	}
-	if _, err := os.Stat(appDir); os.IsNotExist(err) {
-		os.MkdirAll(appDir, 0755)
-	}
 	dbPath := filepath.Join(appDir, "history.db")
 
 	db, err := bolt.Open(dbPath, 0600, &bolt.Options{Timeout: 1 * time.Second})

backend/isrc_cache.go

@@ -0,0 +1,137 @@
+package backend
+
+import (
+	"encoding/json"
+	"fmt"
+	"path/filepath"
+	"strings"
+	"sync"
+	"time"
+
+	bolt "go.etcd.io/bbolt"
+)
+
+const (
+	isrcCacheDBFile = "isrc_cache.db"
+	isrcCacheBucket = "SpotifyTrackISRC"
+)
+
+type isrcCacheEntry struct {
+	TrackID   string `json:"track_id"`
+	ISRC      string `json:"isrc"`
+	UpdatedAt int64  `json:"updated_at"`
+}
+
+var (
+	isrcCacheDB   *bolt.DB
+	isrcCacheDBMu sync.Mutex
+)
+
+func InitISRCCacheDB() error {
+	isrcCacheDBMu.Lock()
+	defer isrcCacheDBMu.Unlock()
+
+	if isrcCacheDB != nil {
+		return nil
+	}
+
+	appDir, err := EnsureAppDir()
+	if err != nil {
+		return err
+	}
+
+	dbPath := filepath.Join(appDir, isrcCacheDBFile)
+	db, err := bolt.Open(dbPath, 0o600, &bolt.Options{Timeout: 1 * time.Second})
+	if err != nil {
+		return err
+	}
+
+	if err := db.Update(func(tx *bolt.Tx) error {
+		_, err := tx.CreateBucketIfNotExists([]byte(isrcCacheBucket))
+		return err
+	}); err != nil {
+		db.Close()
+		return err
+	}
+
+	isrcCacheDB = db
+	return nil
+}
+
+func CloseISRCCacheDB() {
+	isrcCacheDBMu.Lock()
+	defer isrcCacheDBMu.Unlock()
+
+	if isrcCacheDB != nil {
+		_ = isrcCacheDB.Close()
+		isrcCacheDB = nil
+	}
+}
+
+func GetCachedISRC(trackID string) (string, error) {
+	normalizedTrackID := strings.TrimSpace(trackID)
+	if normalizedTrackID == "" {
+		return "", nil
+	}
+
+	if err := InitISRCCacheDB(); err != nil {
+		return "", err
+	}
+
+	var cachedISRC string
+	err := isrcCacheDB.View(func(tx *bolt.Tx) error {
+		bucket := tx.Bucket([]byte(isrcCacheBucket))
+		if bucket == nil {
+			return nil
+		}
+
+		value := bucket.Get([]byte(normalizedTrackID))
+		if len(value) == 0 {
+			return nil
+		}
+
+		var entry isrcCacheEntry
+		if err := json.Unmarshal(value, &entry); err != nil {
+			return err
+		}
+
+		cachedISRC = strings.ToUpper(strings.TrimSpace(entry.ISRC))
+		return nil
+	})
+	if err != nil {
+		return "", err
+	}
+
+	return cachedISRC, nil
+}
+
+func PutCachedISRC(trackID string, isrc string) error {
+	normalizedTrackID := strings.TrimSpace(trackID)
+	normalizedISRC := strings.ToUpper(strings.TrimSpace(isrc))
+	if normalizedTrackID == "" || normalizedISRC == "" {
+		return nil
+	}
+
+	if err := InitISRCCacheDB(); err != nil {
+		return err
+	}
+
+	entry := isrcCacheEntry{
+		TrackID:   normalizedTrackID,
+		ISRC:      normalizedISRC,
+		UpdatedAt: time.Now().Unix(),
+	}
+
+	payload, err := json.Marshal(entry)
+	if err != nil {
+		return fmt.Errorf("failed to encode ISRC cache entry: %w", err)
+	}
+
+	return isrcCacheDB.Update(func(tx *bolt.Tx) error {
+		bucket, err := tx.CreateBucketIfNotExists([]byte(isrcCacheBucket))
+		if err != nil {
+			return err
+		}
+		return bucket.Put([]byte(normalizedTrackID), payload)
+	})
+}

backend/isrc_finder.go

@@ -0,0 +1,572 @@
+package backend
+
+import (
+	"crypto/hmac"
+	"crypto/sha1"
+	"encoding/binary"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"math/big"
+	"net/http"
+	"net/url"
+	"os"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"sync"
+	"time"
+)
+
+const (
+	spotifyServerTimeURL    = "https://open.spotify.com/api/server-time"
+	spotifySessionTokenURL  = "https://open.spotify.com/api/token"
+	spotifyTOTPSecretsURL   = "https://git.gay/thereallo/totp-secrets/raw/branch/main/secrets/secretDict.json"
+	spotifyGIDMetadataURL   = "https://spclient.wg.spotify.com/metadata/4/%s/%s?market=from_token"
+	spotifyTOTPPeriod       = 30
+	spotifyTOTPDigits       = 6
+	spotifyBase62Alphabet   = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
+	spotifyTokenCacheFile   = ".isrc-finder-token.json"
+	spotifySecretsCacheFile = "spotify-secret-dict-cache.json"
+	spotifySecretsCacheTTL  = 24 * time.Hour
+)
+
+var spotifyAnonymousTokenMu sync.Mutex
+
+type spotifyAnonymousToken struct {
+	AccessToken                      string `json:"accessToken"`
+	AccessTokenExpirationTimestampMs int64  `json:"accessTokenExpirationTimestampMs"`
+}
+
+type spotifyServerTimeResponse struct {
+	ServerTime int64 `json:"serverTime"`
+}
+
+type spotifySecretsCache struct {
+	FetchedAtUnix int64            `json:"fetched_at_unix"`
+	Secrets       map[string][]int `json:"secrets"`
+}
+
+type spotifyTrackRawData struct {
+	ExternalID []struct {
+		Type string `json:"type"`
+		ID   string `json:"id"`
+	} `json:"external_id"`
+}
+
+type spotFetchISRCResponse struct {
+	Input        string   `json:"input"`
+	TrackID      string   `json:"track_id"`
+	GID          string   `json:"gid"`
+	CanonicalURI string   `json:"canonical_uri"`
+	Name         string   `json:"name"`
+	Artists      []string `json:"artists"`
+	AlbumName    string   `json:"album_name"`
+	ReleaseDate  string   `json:"release_date"`
+	Label        string   `json:"label"`
+	ISRC         string   `json:"isrc"`
+}
+
+func (s *SongLinkClient) lookupSpotifyISRC(spotifyTrackID string) (string, error) {
+	normalizedTrackID, err := extractSpotifyTrackID(spotifyTrackID)
+	if err != nil {
+		return "", err
+	}
+
+	cachedISRC, err := GetCachedISRC(normalizedTrackID)
+	if err != nil {
+		fmt.Printf("Warning: failed to read ISRC cache: %v\n", err)
+	} else if cachedISRC != "" {
+		fmt.Printf("Found ISRC in cache: %s\n", cachedISRC)
+		return cachedISRC, nil
+	}
+
+	useSpotFetchAPI, spotFetchAPIURL := GetSpotFetchAPISettings()
+	if useSpotFetchAPI {
+		isrc, resolvedTrackID, err := s.lookupSpotifyISRCViaSpotFetchAPI(normalizedTrackID, spotFetchAPIURL)
+		if err == nil && isrc != "" {
+			fmt.Printf("Found ISRC via SpotFetch API: %s\n", isrc)
+			cacheResolvedSpotifyTrackISRC(normalizedTrackID, resolvedTrackID, isrc)
+			return isrc, nil
+		}
+		if err != nil {
+			fmt.Printf("Warning: SpotFetch ISRC lookup failed, falling back to Spotify metadata: %v\n", err)
+		}
+	}
+
+	payload, metadataErr := fetchSpotifyTrackRawData(s.client, normalizedTrackID)
+	if metadataErr == nil {
+		isrc, extractErr := extractSpotifyTrackISRC(payload)
+		if extractErr == nil {
+			fmt.Printf("Found ISRC via Spotify metadata: %s\n", isrc)
+			cacheResolvedSpotifyTrackISRC(normalizedTrackID, "", isrc)
+			return isrc, nil
+		}
+		metadataErr = extractErr
+	}
+
+	if metadataErr != nil {
+		fmt.Printf("Warning: Spotify metadata ISRC lookup failed, falling back to Soundplate: %v\n", metadataErr)
+	}
+
+	isrc, resolvedTrackID, soundplateErr := s.lookupSpotifyISRCViaSoundplate(normalizedTrackID)
+	if soundplateErr == nil && isrc != "" {
+		fmt.Printf("Found ISRC via Soundplate: %s\n", isrc)
+		cacheResolvedSpotifyTrackISRC(normalizedTrackID, resolvedTrackID, isrc)
+		return isrc, nil
+	}
+
+	if metadataErr != nil && soundplateErr != nil {
+		return "", fmt.Errorf("spotify metadata lookup failed: %v | soundplate lookup failed: %w", metadataErr, soundplateErr)
+	}
+	if soundplateErr != nil {
+		return "", soundplateErr
+	}
+	return "", metadataErr
+}
+
+func cacheResolvedSpotifyTrackISRC(trackID string, resolvedTrackID string, isrc string) {
+	if err := PutCachedISRC(trackID, isrc); err != nil {
+		fmt.Printf("Warning: failed to write ISRC cache: %v\n", err)
+	}
+	if resolvedTrackID != "" && resolvedTrackID != trackID {
+		if err := PutCachedISRC(resolvedTrackID, isrc); err != nil {
+			fmt.Printf("Warning: failed to write ISRC cache for resolved track ID: %v\n", err)
+		}
+	}
+}
+
+func (s *SongLinkClient) lookupSpotifyISRCViaSpotFetchAPI(spotifyTrackID string, apiBaseURL string) (string, string, error) {
+	normalizedTrackID := strings.TrimSpace(spotifyTrackID)
+	baseURL := strings.TrimRight(strings.TrimSpace(apiBaseURL), "/")
+	if normalizedTrackID == "" {
+		return "", "", fmt.Errorf("spotify track ID is required")
+	}
+	if baseURL == "" {
+		return "", "", fmt.Errorf("spotfetch api url is required")
+	}
+
+	requestURL := fmt.Sprintf("%s/isrc/%s", baseURL, url.PathEscape(normalizedTrackID))
+	req, err := http.NewRequest(http.MethodGet, requestURL, nil)
+	if err != nil {
+		return "", "", fmt.Errorf("failed to create SpotFetch ISRC request: %w", err)
+	}
+	req.Header.Set("User-Agent", songLinkUserAgent)
+	req.Header.Set("Accept", "application/json")
+
+	client := &http.Client{Timeout: 15 * time.Second}
+	resp, err := client.Do(req)
+	if err != nil {
+		return "", "", fmt.Errorf("SpotFetch ISRC request failed: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		bodyPreview, _ := io.ReadAll(io.LimitReader(resp.Body, 256))
+		return "", "", fmt.Errorf("SpotFetch ISRC returned status %d (%s)", resp.StatusCode, strings.TrimSpace(string(bodyPreview)))
+	}
+
+	var payload spotFetchISRCResponse
+	if err := json.NewDecoder(resp.Body).Decode(&payload); err != nil {
+		return "", "", fmt.Errorf("failed to decode SpotFetch ISRC response: %w", err)
+	}
+
+	isrc := firstISRCMatch(payload.ISRC)
+	if isrc == "" {
+		return "", "", fmt.Errorf("ISRC missing in SpotFetch response")
+	}
+
+	return isrc, strings.TrimSpace(payload.TrackID), nil
+}
+
+func requestSpotifyBytes(client *http.Client, targetURL string, headers map[string]string) ([]byte, error) {
+	req, err := http.NewRequest(http.MethodGet, targetURL, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	for key, value := range headers {
+		req.Header.Set(key, value)
+	}
+
+	resp, err := client.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return nil, err
+	}
+
+	if resp.StatusCode < http.StatusOK || resp.StatusCode >= http.StatusMultipleChoices {
+		details := strings.TrimSpace(string(body))
+		if details == "" {
+			details = resp.Status
+		}
+		return nil, fmt.Errorf("request failed: %s", details)
+	}
+
+	return body, nil
+}
+
+func requestSpotifyJSON(client *http.Client, targetURL string, headers map[string]string, target interface{}) error {
+	body, err := requestSpotifyBytes(client, targetURL, headers)
+	if err != nil {
+		return err
+	}
+
+	if err := json.Unmarshal(body, target); err != nil {
+		return fmt.Errorf("failed to parse JSON response: %w", err)
+	}
+
+	return nil
+}
+
+func loadSpotifyCachedToken() (*spotifyAnonymousToken, error) {
+	cachePath, err := spotifyTokenCachePath()
+	if err != nil {
+		return nil, err
+	}
+
+	body, err := os.ReadFile(cachePath)
+	if err != nil {
+		if errors.Is(err, os.ErrNotExist) {
+			return nil, nil
+		}
+		return nil, fmt.Errorf("failed to read token cache: %w", err)
+	}
+
+	var token spotifyAnonymousToken
+	if err := json.Unmarshal(body, &token); err != nil {
+		return nil, fmt.Errorf("failed to read token cache: %w", err)
+	}
+
+	return &token, nil
+}
+
+func saveSpotifyCachedToken(token *spotifyAnonymousToken) error {
+	cachePath, err := spotifyTokenCachePath()
+	if err != nil {
+		return err
+	}
+
+	if err := os.MkdirAll(filepath.Dir(cachePath), 0o755); err != nil {
+		return fmt.Errorf("failed to create token cache directory: %w", err)
+	}
+
+	body, err := json.MarshalIndent(token, "", "  ")
+	if err != nil {
+		return err
+	}
+
+	if err := os.WriteFile(cachePath, body, 0o644); err != nil {
+		return fmt.Errorf("failed to write token cache: %w", err)
+	}
+
+	return nil
+}
+
+func loadSpotifyCachedSecrets() (*spotifySecretsCache, error) {
+	cachePath, err := spotifySecretsCachePath()
+	if err != nil {
+		return nil, err
+	}
+
+	body, err := os.ReadFile(cachePath)
+	if err != nil {
+		if errors.Is(err, os.ErrNotExist) {
+			return nil, nil
+		}
+		return nil, fmt.Errorf("failed to read secrets cache: %w", err)
+	}
+
+	var cache spotifySecretsCache
+	if err := json.Unmarshal(body, &cache); err != nil {
+		return nil, fmt.Errorf("failed to parse secrets cache: %w", err)
+	}
+
+	return &cache, nil
+}
+
+func saveSpotifyCachedSecrets(cache *spotifySecretsCache) error {
+	cachePath, err := spotifySecretsCachePath()
+	if err != nil {
+		return err
+	}
+
+	if err := os.MkdirAll(filepath.Dir(cachePath), 0o755); err != nil {
+		return fmt.Errorf("failed to create secrets cache directory: %w", err)
+	}
+
+	body, err := json.MarshalIndent(cache, "", "  ")
+	if err != nil {
+		return err
+	}
+
+	if err := os.WriteFile(cachePath, body, 0o644); err != nil {
+		return fmt.Errorf("failed to write secrets cache: %w", err)
+	}
+
+	return nil
+}
+
+func spotifyTokenCachePath() (string, error) {
+	appDir, err := EnsureAppDir()
+	if err != nil {
+		return "", err
+	}
+
+	return filepath.Join(appDir, spotifyTokenCacheFile), nil
+}
+
+func spotifySecretsCachePath() (string, error) {
+	appDir, err := EnsureAppDir()
+	if err != nil {
+		return "", err
+	}
+
+	return filepath.Join(appDir, spotifySecretsCacheFile), nil
+}
+
+func spotifyTokenIsValid(token *spotifyAnonymousToken) bool {
+	if token == nil || token.AccessToken == "" || token.AccessTokenExpirationTimestampMs == 0 {
+		return false
+	}
+
+	return time.Now().UnixMilli() < token.AccessTokenExpirationTimestampMs-30_000
+}
+
+func spotifySecretsCacheIsValid(cache *spotifySecretsCache) bool {
+	if cache == nil || cache.FetchedAtUnix == 0 || len(cache.Secrets) == 0 {
+		return false
+	}
+
+	return time.Since(time.Unix(cache.FetchedAtUnix, 0)) < spotifySecretsCacheTTL
+}
+
+func deriveSpotifyTOTPSecret(ciphertext []int) []byte {
+	var builder strings.Builder
+
+	for index, value := range ciphertext {
+		builder.WriteString(strconv.Itoa(value ^ ((index % 33) + 9)))
+	}
+
+	return []byte(builder.String())
+}
+
+func generateSpotifyTOTP(secret []byte, timestampMs int64) string {
+	counter := timestampMs / 1000 / spotifyTOTPPeriod
+	counterBytes := make([]byte, 8)
+	binary.BigEndian.PutUint64(counterBytes, uint64(counter))
+
+	mac := hmac.New(sha1.New, secret)
+	mac.Write(counterBytes)
+	digest := mac.Sum(nil)
+
+	offset := digest[len(digest)-1] & 0x0f
+	binaryCode := (int(digest[offset])&0x7f)<<24 |
+		(int(digest[offset+1])&0xff)<<16 |
+		(int(digest[offset+2])&0xff)<<8 |
+		(int(digest[offset+3]) & 0xff)
+
+	modulo := 1
+	for i := 0; i < spotifyTOTPDigits; i++ {
+		modulo *= 10
+	}
+
+	return fmt.Sprintf("%0*d", spotifyTOTPDigits, binaryCode%modulo)
+}
+
+func requestSpotifyAnonymousAccessToken(client *http.Client) (string, error) {
+	spotifyAnonymousTokenMu.Lock()
+	defer spotifyAnonymousTokenMu.Unlock()
+
+	cachedToken, err := loadSpotifyCachedToken()
+	if err != nil {
+		return "", err
+	}
+
+	if spotifyTokenIsValid(cachedToken) {
+		return cachedToken.AccessToken, nil
+	}
+
+	var serverTime spotifyServerTimeResponse
+	if err := requestSpotifyJSON(client, spotifyServerTimeURL, nil, &serverTime); err != nil {
+		return "", err
+	}
+
+	var secrets map[string][]int
+	cachedSecrets, err := loadSpotifyCachedSecrets()
+	if err != nil {
+		fmt.Printf("Warning: failed to read Spotify secrets cache: %v\n", err)
+	}
+
+	if spotifySecretsCacheIsValid(cachedSecrets) {
+		secrets = cachedSecrets.Secrets
+	} else {
+		if err := requestSpotifyJSON(client, spotifyTOTPSecretsURL, nil, &secrets); err != nil {
+			if cachedSecrets != nil && len(cachedSecrets.Secrets) > 0 {
+				fmt.Printf("Warning: failed to refresh Spotify secrets cache, using stale cache: %v\n", err)
+				secrets = cachedSecrets.Secrets
+			} else {
+				return "", err
+			}
+		} else {
+			cache := &spotifySecretsCache{
+				FetchedAtUnix: time.Now().Unix(),
+				Secrets:       secrets,
+			}
+			if err := saveSpotifyCachedSecrets(cache); err != nil {
+				fmt.Printf("Warning: failed to write Spotify secrets cache: %v\n", err)
+			}
+		}
+	}
+
+	version, err := latestSpotifySecretVersion(secrets)
+	if err != nil {
+		return "", err
+	}
+
+	secret := deriveSpotifyTOTPSecret(secrets[version])
+	generatedTOTP := generateSpotifyTOTP(secret, serverTime.ServerTime*1000)
+
+	query := url.Values{
+		"reason":      {"init"},
+		"productType": {"web-player"},
+		"totp":        {generatedTOTP},
+		"totpServer":  {generatedTOTP},
+		"totpVer":     {version},
+	}
+
+	var token spotifyAnonymousToken
+	if err := requestSpotifyJSON(client, spotifySessionTokenURL+"?"+query.Encode(), nil, &token); err != nil {
+		return "", err
+	}
+
+	if err := saveSpotifyCachedToken(&token); err != nil {
+		return "", err
+	}
+
+	return token.AccessToken, nil
+}
+
+func latestSpotifySecretVersion(secrets map[string][]int) (string, error) {
+	var (
+		bestVersion string
+		bestNumber  int
+	)
+
+	for version := range secrets {
+		number, err := strconv.Atoi(version)
+		if err != nil {
+			return "", fmt.Errorf("invalid secret version %q: %w", version, err)
+		}
+		if bestVersion == "" || number > bestNumber {
+			bestVersion = version
+			bestNumber = number
+		}
+	}
+
+	if bestVersion == "" {
+		return "", errors.New("no TOTP secret versions available")
+	}
+
+	return bestVersion, nil
+}
+
+func extractSpotifyTrackID(value string) (string, error) {
+	value = strings.TrimSpace(value)
+	if value == "" {
+		return "", errors.New("track input is required")
+	}
+
+	if strings.HasPrefix(value, "spotify:track:") {
+		return value[strings.LastIndex(value, ":")+1:], nil
+	}
+
+	parsed, err := url.Parse(value)
+	if err == nil && (parsed.Scheme == "http" || parsed.Scheme == "https") {
+		parts := strings.Split(strings.Trim(parsed.Path, "/"), "/")
+		if len(parts) >= 2 && parts[0] == "track" {
+			return parts[1], nil
+		}
+		return "", errors.New("expected URL like https://open.spotify.com/track/<id>")
+	}
+
+	if len(value) == 22 {
+		return value, nil
+	}
+
+	return "", errors.New("track must be a Spotify track ID, URL, or URI")
+}
+
+func spotifyTrackIDToGID(trackID string) (string, error) {
+	if trackID == "" {
+		return "", errors.New("track ID is empty")
+	}
+
+	value := big.NewInt(0)
+	base := big.NewInt(62)
+
+	for _, char := range trackID {
+		index := strings.IndexRune(spotifyBase62Alphabet, char)
+		if index < 0 {
+			return "", fmt.Errorf("invalid base62 character: %q", string(char))
+		}
+
+		value.Mul(value, base)
+		value.Add(value, big.NewInt(int64(index)))
+	}
+
+	hexValue := value.Text(16)
+	if len(hexValue) < 32 {
+		hexValue = strings.Repeat("0", 32-len(hexValue)) + hexValue
+	}
+
+	return hexValue, nil
+}
+
+func fetchSpotifyTrackRawData(client *http.Client, trackID string) ([]byte, error) {
+	accessToken, err := requestSpotifyAnonymousAccessToken(client)
+	if err != nil {
+		return nil, err
+	}
+
+	gid, err := spotifyTrackIDToGID(trackID)
+	if err != nil {
+		return nil, err
+	}
+
+	return requestSpotifyBytes(
+		client,
+		fmt.Sprintf(spotifyGIDMetadataURL, "track", gid),
+		map[string]string{
+			"authorization": "Bearer " + accessToken,
+			"accept":        "application/json",
+		},
+	)
+}
+
+func extractSpotifyTrackISRC(payload []byte) (string, error) {
+	var track spotifyTrackRawData
+	if err := json.Unmarshal(payload, &track); err != nil {
+		return "", fmt.Errorf("failed to decode Spotify track metadata: %w", err)
+	}
+
+	for _, externalID := range track.ExternalID {
+		if strings.EqualFold(strings.TrimSpace(externalID.Type), "isrc") {
+			if isrc := firstISRCMatch(externalID.ID); isrc != "" {
+				return isrc, nil
+			}
+		}
+	}
+
+	if fallbackISRC := firstISRCMatch(string(payload)); fallbackISRC != "" {
+		return fallbackISRC, nil
+	}
+
+	return "", fmt.Errorf("ISRC not found in Spotify track metadata")
+}

backend/link_resolver.go

@@ -0,0 +1,154 @@
+package backend
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+)
+
+type resolvedTrackLinks struct {
+	TidalURL  string
+	AmazonURL string
+	DeezerURL string
+	ISRC      string
+}
+
+const (
+	linkResolverProviderSongstats      = "songstats"
+	linkResolverProviderDeezerSongLink = "deezer-songlink"
+)
+
+func (s *SongLinkClient) resolveSpotifyTrackLinks(spotifyTrackID string, region string) (*resolvedTrackLinks, error) {
+	links := &resolvedTrackLinks{}
+	var attempts []string
+
+	isrc, err := s.lookupSpotifyISRC(spotifyTrackID)
+	if err != nil {
+		attempts = append(attempts, fmt.Sprintf("spotify isrc: %v", err))
+	} else {
+		links.ISRC = isrc
+	}
+
+	if links.ISRC != "" {
+		resolvers := orderedLinkResolvers()
+
+		for _, resolver := range resolvers {
+			switch resolver {
+			case linkResolverProviderSongstats:
+				addedData, songstatsErr := s.resolveLinksViaSongstats(links)
+				if songstatsErr != nil {
+					attempts = append(attempts, fmt.Sprintf("songstats: %v", songstatsErr))
+				} else if addedData {
+					fmt.Println("Using Songstats as configured link resolver")
+				}
+			case linkResolverProviderDeezerSongLink:
+				addedData, deezerSongLinkErr := s.resolveLinksViaDeezerSongLink(links, region)
+				if deezerSongLinkErr != nil {
+					attempts = append(attempts, fmt.Sprintf("deezer-songlink: %v", deezerSongLinkErr))
+				} else if addedData {
+					fmt.Println("Using Songlink as configured link resolver")
+				}
+			}
+
+			if links.TidalURL != "" && links.AmazonURL != "" {
+				return links, nil
+			}
+		}
+	}
+
+	if hasAnySongLinkData(links) {
+		return links, nil
+	}
+
+	if len(attempts) == 0 {
+		attempts = append(attempts, "no streaming URLs found")
+	}
+
+	return links, errors.New(strings.Join(attempts, " | "))
+}
+
+func orderedLinkResolvers() []string {
+	preferred := GetLinkResolverSetting()
+	if !GetLinkResolverAllowFallback() {
+		if preferred == linkResolverProviderDeezerSongLink {
+			return []string{linkResolverProviderDeezerSongLink}
+		}
+		return []string{linkResolverProviderSongstats}
+	}
+
+	if preferred == linkResolverProviderDeezerSongLink {
+		return []string{
+			linkResolverProviderDeezerSongLink,
+			linkResolverProviderSongstats,
+		}
+	}
+
+	return []string{
+		linkResolverProviderSongstats,
+		linkResolverProviderDeezerSongLink,
+	}
+}
+
+func (s *SongLinkClient) resolveLinksViaSongstats(links *resolvedTrackLinks) (bool, error) {
+	if links == nil || links.ISRC == "" {
+		return false, fmt.Errorf("ISRC is required for Songstats resolver")
+	}
+
+	before := *links
+
+	fmt.Printf("Fetching Songstats links for ISRC %s\n", links.ISRC)
+	if err := s.populateLinksFromSongstats(links, links.ISRC); err != nil {
+		return false, err
+	}
+
+	return *links != before, nil
+}
+
+func (s *SongLinkClient) resolveLinksViaDeezerSongLink(links *resolvedTrackLinks, region string) (bool, error) {
+	if links == nil || links.ISRC == "" {
+		return false, fmt.Errorf("ISRC is required for Deezer song.link resolver")
+	}
+
+	before := *links
+	var attempts []string
+
+	if links.DeezerURL == "" {
+		fmt.Printf("Resolving Deezer track from ISRC %s\n", links.ISRC)
+		deezerURL, err := s.lookupDeezerTrackURLByISRC(links.ISRC)
+		if err != nil {
+			attempts = append(attempts, fmt.Sprintf("deezer isrc: %v", err))
+		} else {
+			links.DeezerURL = deezerURL
+			fmt.Printf("Found Deezer URL: %s\n", links.DeezerURL)
+		}
+	}
+
+	if links.DeezerURL != "" {
+		fmt.Println("Resolving streaming URLs from song.link via Deezer URL...")
+		deezerResp, err := s.fetchSongLinkLinksByURL(links.DeezerURL, region)
+		if err != nil {
+			attempts = append(attempts, fmt.Sprintf("song.link deezer: %v", err))
+		} else {
+			mergeSongLinkResponse(links, deezerResp)
+		}
+
+		if links.ISRC == "" {
+			if resolvedISRC, deezerISRCErr := getDeezerISRC(links.DeezerURL); deezerISRCErr == nil {
+				links.ISRC = resolvedISRC
+			}
+		}
+	}
+
+	if *links != before {
+		if len(attempts) == 0 {
+			return true, nil
+		}
+		return true, errors.New(strings.Join(attempts, " | "))
+	}
+
+	if len(attempts) == 0 {
+		attempts = append(attempts, "no links found via deezer-songlink")
+	}
+
+	return false, errors.New(strings.Join(attempts, " | "))
+}

backend/lyrics.go

@@ -37,17 +37,6 @@ type LyricsResponse struct {
 	Lines    []LyricsLine `json:"lines"`
 }
 
-type SpotifyLyricsLine struct {
-	TimeTag string `json:"timeTag"`
-	Words   string `json:"words"`
-}
-
-type SpotifyLyricsAPIResponse struct {
-	Error    bool                `json:"error"`
-	SyncType string              `json:"syncType"`
-	Lines    []SpotifyLyricsLine `json:"lines"`
-}
-
 type LyricsDownloadRequest struct {
 	SpotifyID           string `json:"spotify_id"`
 	TrackName           string `json:"track_name"`
@@ -81,12 +70,16 @@ func NewLyricsClient() *LyricsClient {
 	}
 }
 
-func (c *LyricsClient) FetchLyricsWithMetadata(trackName, artistName string, duration int) (*LyricsResponse, error) {
+func (c *LyricsClient) FetchLyricsWithMetadata(trackName, artistName, albumName string, duration int) (*LyricsResponse, error) {
 
 	apiURL := fmt.Sprintf("https://lrclib.net/api/get?artist_name=%s&track_name=%s",
 		url.QueryEscape(artistName),
 		url.QueryEscape(trackName))
 
+	if albumName != "" {
+		apiURL = fmt.Sprintf("%s&album_name=%s", apiURL, url.QueryEscape(albumName))
+	}
+
 	if duration > 0 {
 		apiURL = fmt.Sprintf("%s&duration=%d", apiURL, duration)
 	}
@@ -111,6 +104,10 @@ func (c *LyricsClient) FetchLyricsWithMetadata(trackName, artistName string, dur
 		return nil, fmt.Errorf("failed to parse LRCLIB response: %v", err)
 	}
 
+	if lrcLibResp.SyncedLyrics == "" && lrcLibResp.PlainLyrics == "" {
+		return nil, fmt.Errorf("LRCLIB returned empty lyrics")
+	}
+
 	return c.convertLRCLibToLyricsResponse(&lrcLibResp), nil
 }
 
@@ -174,8 +171,10 @@ func lrcTimestampToMs(timestamp string) int64 {
 }
 
 func (c *LyricsClient) FetchLyricsFromLRCLibSearch(trackName, artistName string) (*LyricsResponse, error) {
-	query := fmt.Sprintf("%s %s", artistName, trackName)
-	apiURL := fmt.Sprintf("https://lrclib.net/api/search?q=%s", url.QueryEscape(query))
+
+	apiURL := fmt.Sprintf("https://lrclib.net/api/search?artist_name=%s&track_name=%s",
+		url.QueryEscape(artistName),
+		url.QueryEscape(trackName))
 
 	resp, err := c.httpClient.Get(apiURL)
 	if err != nil {
@@ -201,79 +200,35 @@ func (c *LyricsClient) FetchLyricsFromLRCLibSearch(trackName, artistName string)
 		return nil, fmt.Errorf("no results found")
 	}
 
-	var best *LRCLibResponse
+	var bestSynced *LRCLibResponse
+	var bestPlain *LRCLibResponse
 	for i := range results {
-		if results[i].SyncedLyrics != "" {
-			best = &results[i]
-			break
+		if results[i].SyncedLyrics != "" && bestSynced == nil {
+			bestSynced = &results[i]
 		}
-		if best == nil && results[i].PlainLyrics != "" {
-			best = &results[i]
+		if results[i].PlainLyrics != "" && bestPlain == nil {
+			bestPlain = &results[i]
+		}
+		if bestSynced != nil {
+			break
 		}
 	}
 
+	best := bestSynced
+	if best == nil {
+		best = bestPlain
+	}
 	if best == nil {
 		best = &results[0]
 	}
 
+	if best.SyncedLyrics == "" && best.PlainLyrics == "" {
+		return nil, fmt.Errorf("no lyrics found in search results")
+	}
+
 	return c.convertLRCLibToLyricsResponse(best), nil
 }
 
-func (c *LyricsClient) FetchLyricsFromSpotifyAPI(spotifyID string) (*LyricsResponse, error) {
-	if spotifyID == "" {
-		return nil, fmt.Errorf("spotify ID is empty")
-	}
-
-	apiURL := fmt.Sprintf("https://spotify-lyrics-api-pi.vercel.app/?trackid=%s&format=lrc", spotifyID)
-
-	resp, err := c.httpClient.Get(apiURL)
-	if err != nil {
-		return nil, fmt.Errorf("failed to fetch from Spotify Lyrics API: %v", err)
-	}
-	defer resp.Body.Close()
-
-	if resp.StatusCode != 200 {
-		return nil, fmt.Errorf("Spotify Lyrics API returned status %d", resp.StatusCode)
-	}
-
-	body, err := io.ReadAll(resp.Body)
-	if err != nil {
-		return nil, fmt.Errorf("failed to read Spotify Lyrics API response: %v", err)
-	}
-
-	var apiResp SpotifyLyricsAPIResponse
-	if err := json.Unmarshal(body, &apiResp); err != nil {
-		return nil, fmt.Errorf("failed to parse Spotify Lyrics API response: %v", err)
-	}
-
-	if apiResp.Error {
-		return nil, fmt.Errorf("Spotify Lyrics API returned error")
-	}
-
-	result := &LyricsResponse{
-		Error:    false,
-		SyncType: apiResp.SyncType,
-		Lines:    []LyricsLine{},
-	}
-
-	for _, line := range apiResp.Lines {
-		if line.TimeTag == "" && line.Words == "" {
-			continue
-		}
-		ms := lrcTimestampToMs(line.TimeTag)
-		result.Lines = append(result.Lines, LyricsLine{
-			StartTimeMs: fmt.Sprintf("%d", ms),
-			Words:       line.Words,
-		})
-	}
-
-	if len(result.Lines) == 0 {
-		return nil, fmt.Errorf("Spotify Lyrics API returned empty lines")
-	}
-
-	return result, nil
-}
-
 func simplifyTrackName(name string) string {
 
 	if idx := strings.Index(name, "("); idx > 0 {
@@ -286,41 +241,88 @@ func simplifyTrackName(name string) string {
 	return name
 }
 
-func (c *LyricsClient) FetchLyricsAllSources(spotifyID, trackName, artistName string, duration int) (*LyricsResponse, string, error) {
+func isSynced(resp *LyricsResponse) bool {
+	return resp != nil && !resp.Error && resp.SyncType == "LINE_SYNCED" && len(resp.Lines) > 0
+}
 
-	resp, err := c.FetchLyricsFromSpotifyAPI(spotifyID)
-	if err == nil && resp != nil && !resp.Error && len(resp.Lines) > 0 {
-		return resp, "Spotify", nil
-	}
-	fmt.Printf("   Spotify Lyrics API: %v\n", err)
+func hasLyrics(resp *LyricsResponse) bool {
+	return resp != nil && !resp.Error && len(resp.Lines) > 0
+}
 
-	resp, err = c.FetchLyricsWithMetadata(trackName, artistName, duration)
-	if err == nil && resp != nil && !resp.Error && len(resp.Lines) > 0 {
-		return resp, "LRCLIB", nil
-	}
-	fmt.Printf("   LRCLIB exact: %v\n", err)
+func (c *LyricsClient) FetchLyricsAllSources(spotifyID, trackName, artistName, albumName string, duration int) (*LyricsResponse, string, error) {
 
-	resp, err = c.FetchLyricsFromLRCLibSearch(trackName, artistName)
-	if err == nil && resp != nil && !resp.Error && len(resp.Lines) > 0 {
-		return resp, "LRCLIB Search", nil
+	var unsyncedFallback *LyricsResponse
+	var unsyncedSource string
+
+	check := func(resp *LyricsResponse, err error, source string) (*LyricsResponse, string, bool) {
+		if err != nil || resp == nil || resp.Error || len(resp.Lines) == 0 {
+			return nil, "", false
+		}
+		if isSynced(resp) {
+			return resp, source, true
+		}
+
+		if unsyncedFallback == nil {
+			unsyncedFallback = resp
+			unsyncedSource = source
+		}
+		return nil, "", false
 	}
-	fmt.Printf("   LRCLIB search: %v\n", err)
+
+	var resp *LyricsResponse
+	var src string
+	var found bool
+
+	resp, _ = c.FetchLyricsWithMetadata(trackName, artistName, albumName, duration)
+	resp, src, found = check(resp, nil, "LRCLIB")
+	if found {
+		fmt.Printf("   [LRCLIB] Synced found via exact match (with album)\n")
+		return resp, src, nil
+	}
+	fmt.Printf("   LRCLIB exact (with album): no synced\n")
+
+	if albumName != "" {
+		resp, _ = c.FetchLyricsWithMetadata(trackName, artistName, "", duration)
+		resp, src, found = check(resp, nil, "LRCLIB (no album)")
+		if found {
+			fmt.Printf("   [LRCLIB] Synced found via exact match (no album)\n")
+			return resp, src, nil
+		}
+		fmt.Printf("   LRCLIB exact (no album): no synced\n")
+	}
+
+	resp, _ = c.FetchLyricsFromLRCLibSearch(trackName, artistName)
+	resp, src, found = check(resp, nil, "LRCLIB Search")
+	if found {
+		fmt.Printf("   [LRCLIB] Synced found via search\n")
+		return resp, src, nil
+	}
+	fmt.Printf("   LRCLIB search: no synced\n")
 
 	simplifiedTrack := simplifyTrackName(trackName)
 	if simplifiedTrack != trackName {
 		fmt.Printf("   Trying simplified name: %s\n", simplifiedTrack)
 
-		resp, err = c.FetchLyricsWithMetadata(simplifiedTrack, artistName, duration)
-		if err == nil && resp != nil && !resp.Error && len(resp.Lines) > 0 {
-			return resp, "LRCLIB (simplified)", nil
+		resp, _ = c.FetchLyricsWithMetadata(simplifiedTrack, artistName, albumName, duration)
+		resp, src, found = check(resp, nil, "LRCLIB (simplified)")
+		if found {
+			fmt.Printf("   [LRCLIB] Synced found via simplified exact\n")
+			return resp, src, nil
 		}
 
-		resp, err = c.FetchLyricsFromLRCLibSearch(simplifiedTrack, artistName)
-		if err == nil && resp != nil && !resp.Error && len(resp.Lines) > 0 {
-			return resp, "LRCLIB Search (simplified)", nil
+		resp, _ = c.FetchLyricsFromLRCLibSearch(simplifiedTrack, artistName)
+		resp, src, found = check(resp, nil, "LRCLIB Search (simplified)")
+		if found {
+			fmt.Printf("   [LRCLIB] Synced found via simplified search\n")
+			return resp, src, nil
 		}
 	}
 
+	if unsyncedFallback != nil {
+		fmt.Printf("   [LRCLIB] No synced found, using unsynced from: %s\n", unsyncedSource)
+		return unsyncedFallback, unsyncedSource + " (unsynced)", nil
+	}
+
 	return nil, "", fmt.Errorf("lyrics not found in any source")
 }
 
@@ -472,25 +474,6 @@ func (c *LyricsClient) DownloadLyrics(req LyricsDownloadRequest) (*LyricsDownloa
 		outputDir = NormalizePath(outputDir)
 	}
 
-	safeArtist := sanitizeFilename(req.AlbumArtist)
-	if safeArtist == "" {
-		safeArtist = sanitizeFilename(req.ArtistName)
-	}
-	safeAlbum := sanitizeFilename(req.AlbumName)
-
-	if safeArtist != "" && safeAlbum != "" {
-		artistAlbumPath := filepath.Join(outputDir, safeArtist, safeAlbum)
-		if info, err := os.Stat(artistAlbumPath); err == nil && info.IsDir() {
-			outputDir = artistAlbumPath
-		} else {
-
-			artistPath := filepath.Join(outputDir, safeArtist)
-			if info, err := os.Stat(artistPath); err == nil && info.IsDir() {
-				outputDir = artistPath
-			}
-		}
-	}
-
 	if err := os.MkdirAll(outputDir, 0755); err != nil {
 		return &LyricsDownloadResponse{
 			Success: false,
@@ -524,7 +507,7 @@ func (c *LyricsClient) DownloadLyrics(req LyricsDownloadRequest) (*LyricsDownloa
 		}
 	}
 
-	lyrics, _, err := c.FetchLyricsAllSources(req.SpotifyID, req.TrackName, req.ArtistName, audioDuration)
+	lyrics, _, err := c.FetchLyricsAllSources(req.SpotifyID, req.TrackName, req.ArtistName, req.AlbumName, audioDuration)
 	if err != nil {
 		return &LyricsDownloadResponse{
 			Success: false,

backend/metadata.go

@@ -13,6 +13,7 @@ import (
 	"github.com/go-flac/flacpicture"
 	"github.com/go-flac/flacvorbis"
 	"github.com/go-flac/go-flac"
+	"golang.org/x/text/unicode/norm"
 )
 
 type Metadata struct {
@@ -27,6 +28,7 @@ type Metadata struct {
 	DiscNumber  int
 	TotalDiscs  int
 	URL         string
+	Comment     string
 	Copyright   string
 	Publisher   string
 	Lyrics      string
@@ -87,6 +89,9 @@ func EmbedMetadata(filepath string, metadata Metadata, coverPath string) error {
 	if metadata.Description != "" {
 		_ = cmt.Add("DESCRIPTION", metadata.Description)
 	}
+	if comment := resolveMetadataComment(metadata); comment != "" {
+		_ = cmt.Add("COMMENT", comment)
+	}
 
 	if metadata.ISRC != "" {
 		_ = cmt.Add("ISRC", metadata.ISRC)
@@ -165,6 +170,14 @@ func extractYear(releaseDate string) string {
 	return releaseDate
 }
 
+func resolveMetadataComment(metadata Metadata) string {
+	if comment := strings.TrimSpace(metadata.Comment); comment != "" {
+		return comment
+	}
+
+	return strings.TrimSpace(metadata.URL)
+}
+
 func EmbedLyricsOnly(filepath string, lyrics string) error {
 	if lyrics == "" {
 		return nil
@@ -218,16 +231,68 @@ func EmbedLyricsOnly(filepath string, lyrics string) error {
 }
 
 func ExtractCoverArt(filePath string) (string, error) {
+	filePath = norm.NFC.String(filePath)
 	ext := strings.ToLower(pathfilepath.Ext(filePath))
 
+	var coverPath string
+	var err error
+
 	switch ext {
 	case ".mp3":
-		return extractCoverFromMp3(filePath)
+		coverPath, err = extractCoverFromMp3(filePath)
 	case ".m4a", ".flac":
-		return extractCoverFromM4AOrFlac(filePath)
+		coverPath, err = extractCoverFromM4AOrFlac(filePath)
 	default:
 		return "", fmt.Errorf("unsupported file format: %s", ext)
 	}
+
+	if err != nil || coverPath == "" {
+		fmt.Printf("[ExtractCoverArt] Library extraction failed for %s, trying FFmpeg fallback...\n", filePath)
+		ffmpegCover, ffmpegErr := extractCoverWithFFmpeg(filePath)
+		if ffmpegErr == nil {
+			return ffmpegCover, nil
+		}
+		return coverPath, err
+	}
+
+	return coverPath, nil
+}
+
+func extractCoverWithFFmpeg(filePath string) (string, error) {
+	ffmpegPath, err := GetFFmpegPath()
+	if err != nil {
+		return "", err
+	}
+
+	tmpFile, err := os.CreateTemp("", "cover-*.jpg")
+	if err != nil {
+		return "", err
+	}
+	tmpPath := tmpFile.Name()
+	tmpFile.Close()
+
+	cmd := exec.Command(ffmpegPath,
+		"-i", filePath,
+		"-an",
+		"-vframes", "1",
+		"-f", "image2",
+		"-update", "1",
+		"-y",
+		tmpPath,
+	)
+
+	setHideWindow(cmd)
+	if output, err := cmd.CombinedOutput(); err != nil {
+		os.Remove(tmpPath)
+		return "", fmt.Errorf("ffmpeg cover extraction failed: %v, output: %s", err, string(output))
+	}
+
+	if info, err := os.Stat(tmpPath); err != nil || info.Size() == 0 {
+		os.Remove(tmpPath)
+		return "", fmt.Errorf("ffmpeg produced empty cover file")
+	}
+
+	return tmpPath, nil
 }
 
 func extractCoverFromMp3(filePath string) (string, error) {
@@ -298,19 +363,71 @@ func extractCoverFromM4AOrFlac(filePath string) (string, error) {
 }
 
 func ExtractLyrics(filePath string) (string, error) {
+	filePath = norm.NFC.String(filePath)
 	ext := strings.ToLower(pathfilepath.Ext(filePath))
 
+	var lyrics string
+	var err error
+
 	switch ext {
 	case ".mp3":
-		return extractLyricsFromMp3(filePath)
+		lyrics, err = extractLyricsFromMp3(filePath)
 	case ".flac":
-		return extractLyricsFromFlac(filePath)
+		lyrics, err = extractLyricsFromFlac(filePath)
 	case ".m4a":
-
 		return "", nil
 	default:
 		return "", fmt.Errorf("unsupported file format: %s", ext)
 	}
+
+	if (err != nil || lyrics == "") && ext != ".m4a" {
+		fmt.Printf("[ExtractLyrics] Library extraction failed for %s, trying ffprobe fallback...\n", filePath)
+		ffprobeLyrics, ffprobeErr := extractLyricsWithFFprobe(filePath)
+		if ffprobeErr == nil && ffprobeLyrics != "" {
+			return ffprobeLyrics, nil
+		}
+	}
+
+	return lyrics, err
+}
+
+func extractLyricsWithFFprobe(filePath string) (string, error) {
+	ffprobePath, err := GetFFprobePath()
+	if err != nil {
+		return "", err
+	}
+
+	cmd := exec.Command(ffprobePath,
+		"-v", "quiet",
+		"-show_entries", "format_tags=lyrics:format_tags=unsyncedlyrics:format_tags=lyric",
+		"-of", "json",
+		filePath,
+	)
+
+	setHideWindow(cmd)
+	output, err := cmd.CombinedOutput()
+	if err != nil {
+		return "", err
+	}
+
+	var result struct {
+		Format struct {
+			Tags map[string]string `json:"tags"`
+		} `json:"format"`
+	}
+
+	if err := json.Unmarshal(output, &result); err != nil {
+		return "", err
+	}
+
+	tags := result.Format.Tags
+	for _, key := range []string{"lyrics", "unsyncedlyrics", "lyric", "LYRICS", "UNSYNCEDLYRICS", "LYRIC"} {
+		if val, ok := tags[key]; ok && val != "" {
+			return val, nil
+		}
+	}
+
+	return "", nil
 }
 
 func extractLyricsFromMp3(filePath string) (string, error) {
@@ -688,6 +805,7 @@ func parseLRCTimestamp(timestamp string) int64 {
 }
 
 func ExtractFullMetadataFromFile(filePath string) (Metadata, error) {
+	filePath = norm.NFC.String(filePath)
 	var metadata Metadata
 
 	ffprobePath, err := GetFFprobePath()
@@ -785,7 +903,11 @@ func ExtractFullMetadataFromFile(filePath string) (Metadata, error) {
 			metadata.Publisher = value
 		case "url":
 			metadata.URL = value
-		case "description", "comment":
+		case "comment", "comments":
+			if metadata.Comment == "" {
+				metadata.Comment = value
+			}
+		case "description":
 			if metadata.Description == "" {
 				metadata.Description = value
 			}
@@ -796,6 +918,7 @@ func ExtractFullMetadataFromFile(filePath string) (Metadata, error) {
 }
 
 func EmbedMetadataToConvertedFile(filePath string, metadata Metadata, coverPath string) error {
+	filePath = norm.NFC.String(filePath)
 	ext := strings.ToLower(pathfilepath.Ext(filePath))
 
 	switch ext {
@@ -875,6 +998,16 @@ func embedMetadataToMP3(filePath string, metadata Metadata, coverPath string) er
 		tag.AddTextFrame("TSRC", id3v2.EncodingUTF8, metadata.ISRC)
 	}
 
+	if comment := resolveMetadataComment(metadata); comment != "" {
+		tag.DeleteFrames(tag.CommonID("Comments"))
+		tag.AddCommentFrame(id3v2.CommentFrame{
+			Encoding:    id3v2.EncodingUTF8,
+			Language:    "eng",
+			Description: "",
+			Text:        comment,
+		})
+	}
+
 	if coverPath != "" && fileExists(coverPath) {
 
 		tag.DeleteFrames(tag.CommonID("Attached picture"))
@@ -961,6 +1094,9 @@ func embedMetadataToM4A(filePath string, metadata Metadata, coverPath string) er
 	if metadata.ISRC != "" {
 		args = append(args, "-metadata", "isrc="+metadata.ISRC)
 	}
+	if comment := resolveMetadataComment(metadata); comment != "" {
+		args = append(args, "-metadata", "comment="+comment)
+	}
 
 	tmpOutputFile := strings.TrimSuffix(filePath, pathfilepath.Ext(filePath)) + ".tmp" + pathfilepath.Ext(filePath)
 	defer func() {

backend/musicbrainz.go

@@ -77,7 +77,7 @@ func FetchMusicBrainzMetadata(isrc, title, artist, album string, useSingleGenre
 		return meta, err
 	}
 
-	req.Header.Set("User-Agent", fmt.Sprintf("SpotiFLAC/%s ( support@exyezed.cc )", AppVersion))
+	req.Header.Set("User-Agent", fmt.Sprintf("SpotiFLAC/%s ( hi@afkarxyz.qzz.io )", AppVersion))
 
 	var resp *http.Response
 	var lastErr error
@@ -146,7 +146,7 @@ func FetchMusicBrainzMetadata(isrc, title, artist, album string, useSingleGenre
 			if len(genres) > 5 {
 				genres = genres[:5]
 			}
-			meta.Genre = strings.Join(genres, "; ")
+			meta.Genre = strings.Join(genres, GetSeparator())
 		}
 	}
 

backend/provider_priority.go

@@ -0,0 +1,215 @@
+package backend
+
+import (
+	"encoding/json"
+	"fmt"
+	"path/filepath"
+	"sort"
+	"strings"
+	"sync"
+	"time"
+
+	bolt "go.etcd.io/bbolt"
+)
+
+const (
+	providerPriorityDBFile = "provider_priority.db"
+	providerPriorityBucket = "ProviderPriority"
+)
+
+type providerPriorityEntry struct {
+	Service      string `json:"service"`
+	Provider     string `json:"provider"`
+	LastOutcome  string `json:"last_outcome"`
+	LastAttempt  int64  `json:"last_attempt"`
+	LastSuccess  int64  `json:"last_success"`
+	LastFailure  int64  `json:"last_failure"`
+	SuccessCount int64  `json:"success_count"`
+	FailureCount int64  `json:"failure_count"`
+}
+
+var (
+	providerPriorityDB   *bolt.DB
+	providerPriorityDBMu sync.Mutex
+)
+
+func InitProviderPriorityDB() error {
+	providerPriorityDBMu.Lock()
+	defer providerPriorityDBMu.Unlock()
+
+	if providerPriorityDB != nil {
+		return nil
+	}
+
+	appDir, err := EnsureAppDir()
+	if err != nil {
+		return err
+	}
+
+	dbPath := filepath.Join(appDir, providerPriorityDBFile)
+	db, err := bolt.Open(dbPath, 0o600, &bolt.Options{Timeout: 1 * time.Second})
+	if err != nil {
+		return err
+	}
+
+	if err := db.Update(func(tx *bolt.Tx) error {
+		_, err := tx.CreateBucketIfNotExists([]byte(providerPriorityBucket))
+		return err
+	}); err != nil {
+		db.Close()
+		return err
+	}
+
+	providerPriorityDB = db
+	return nil
+}
+
+func CloseProviderPriorityDB() {
+	providerPriorityDBMu.Lock()
+	defer providerPriorityDBMu.Unlock()
+
+	if providerPriorityDB != nil {
+		_ = providerPriorityDB.Close()
+		providerPriorityDB = nil
+	}
+}
+
+func prioritizeProviders(service string, providers []string) []string {
+	ordered := append([]string(nil), providers...)
+	if len(ordered) < 2 {
+		return ordered
+	}
+
+	if err := InitProviderPriorityDB(); err != nil {
+		fmt.Printf("Warning: failed to init provider priority DB: %v\n", err)
+		return ordered
+	}
+
+	serviceKey := strings.TrimSpace(strings.ToLower(service))
+	entries := make(map[string]providerPriorityEntry, len(ordered))
+
+	if err := providerPriorityDB.View(func(tx *bolt.Tx) error {
+		bucket := tx.Bucket([]byte(providerPriorityBucket))
+		if bucket == nil {
+			return nil
+		}
+
+		for _, provider := range ordered {
+			if raw := bucket.Get([]byte(providerPriorityKey(serviceKey, provider))); len(raw) > 0 {
+				var entry providerPriorityEntry
+				if err := json.Unmarshal(raw, &entry); err != nil {
+					return err
+				}
+				entries[provider] = entry
+			}
+		}
+		return nil
+	}); err != nil {
+		fmt.Printf("Warning: failed to read provider priority DB: %v\n", err)
+		return ordered
+	}
+
+	originalIndex := make(map[string]int, len(ordered))
+	for idx, provider := range ordered {
+		originalIndex[provider] = idx
+	}
+
+	sort.SliceStable(ordered, func(i, j int) bool {
+		left := entries[ordered[i]]
+		right := entries[ordered[j]]
+
+		leftRank := providerOutcomeRank(left.LastOutcome)
+		rightRank := providerOutcomeRank(right.LastOutcome)
+		if leftRank != rightRank {
+			return leftRank > rightRank
+		}
+
+		if left.LastSuccess != right.LastSuccess {
+			return left.LastSuccess > right.LastSuccess
+		}
+
+		if left.LastAttempt != right.LastAttempt {
+			return left.LastAttempt > right.LastAttempt
+		}
+
+		return originalIndex[ordered[i]] < originalIndex[ordered[j]]
+	})
+
+	return ordered
+}
+
+func recordProviderSuccess(service string, provider string) {
+	recordProviderOutcome(service, provider, true)
+}
+
+func recordProviderFailure(service string, provider string) {
+	recordProviderOutcome(service, provider, false)
+}
+
+func recordProviderOutcome(service string, provider string, success bool) {
+	if strings.TrimSpace(service) == "" || strings.TrimSpace(provider) == "" {
+		return
+	}
+
+	if err := InitProviderPriorityDB(); err != nil {
+		fmt.Printf("Warning: failed to init provider priority DB: %v\n", err)
+		return
+	}
+
+	serviceKey := strings.TrimSpace(strings.ToLower(service))
+	providerKey := providerPriorityKey(serviceKey, provider)
+	now := time.Now().Unix()
+
+	if err := providerPriorityDB.Update(func(tx *bolt.Tx) error {
+		bucket, err := tx.CreateBucketIfNotExists([]byte(providerPriorityBucket))
+		if err != nil {
+			return err
+		}
+
+		entry := providerPriorityEntry{
+			Service:  serviceKey,
+			Provider: provider,
+		}
+
+		if raw := bucket.Get([]byte(providerKey)); len(raw) > 0 {
+			if err := json.Unmarshal(raw, &entry); err != nil {
+				return err
+			}
+		}
+
+		entry.LastAttempt = now
+		if success {
+			entry.LastOutcome = "success"
+			entry.LastSuccess = now
+			entry.SuccessCount++
+		} else {
+			entry.LastOutcome = "failure"
+			entry.LastFailure = now
+			entry.FailureCount++
+		}
+
+		payload, err := json.Marshal(entry)
+		if err != nil {
+			return err
+		}
+
+		return bucket.Put([]byte(providerKey), payload)
+	}); err != nil {
+		fmt.Printf("Warning: failed to update provider priority DB: %v\n", err)
+	}
+}
+
+func providerOutcomeRank(outcome string) int {
+	switch strings.TrimSpace(strings.ToLower(outcome)) {
+	case "success":
+		return 2
+	case "":
+		return 1
+	default:
+		return 0
+	}
+}
+
+func providerPriorityKey(service string, provider string) string {
+	return strings.TrimSpace(strings.ToLower(service)) + "|" + strings.TrimSpace(provider)
+}

backend/qobuz.go

@@ -4,7 +4,6 @@ import (
 	"encoding/json"
 	"fmt"
 	"io"
-	"math/rand"
 	"net/http"
 	"os"
 	"path/filepath"
@@ -118,8 +117,15 @@ func (q *QobuzDownloader) searchByISRC(isrc string) (*QobuzTrack, error) {
 	return &searchResp.Tracks.Items[0], nil
 }
 
+func buildQobuzAPIURL(apiBase string, trackID int64, quality string) string {
+	if strings.Contains(apiBase, "qbz.afkarxyz.qzz.io") {
+		return fmt.Sprintf("%s%d?quality=%s", apiBase, trackID, quality)
+	}
+	return fmt.Sprintf("%s%d&quality=%s", apiBase, trackID, quality)
+}
+
 func (q *QobuzDownloader) DownloadFromStandard(apiBase string, trackID int64, quality string) (string, error) {
-	apiURL := fmt.Sprintf("%s%d&quality=%s", apiBase, trackID, quality)
+	apiURL := buildQobuzAPIURL(apiBase, trackID, quality)
 	resp, err := q.client.Get(apiURL)
 	if err != nil {
 		return "", err
@@ -164,14 +170,16 @@ func (q *QobuzDownloader) GetDownloadURL(trackID int64, quality string, allowFal
 
 	fmt.Printf("Getting download URL for track ID: %d with requested quality: %s\n", trackID, qualityCode)
 
-	standardAPIs := []string{
+	standardAPIs := prioritizeProviders("qobuz", []string{
 		"https://dab.yeet.su/api/stream?trackId=",
 		"https://dabmusic.xyz/api/stream?trackId=",
-	}
+		"https://qbz.afkarxyz.qzz.io/api/track/",
+	})
 
 	downloadFunc := func(qual string) (string, error) {
 		type Provider struct {
 			Name string
+			API  string
 			Func func() (string, error)
 		}
 
@@ -181,27 +189,26 @@ func (q *QobuzDownloader) GetDownloadURL(trackID int64, quality string, allowFal
 			currentAPI := api
 			providers = append(providers, Provider{
 				Name: "Standard(" + currentAPI + ")",
+				API:  currentAPI,
 				Func: func() (string, error) {
 					return q.DownloadFromStandard(currentAPI, trackID, qual)
 				},
 			})
 		}
 
-		rand.Seed(time.Now().UnixNano())
-		rand.Shuffle(len(providers), func(i, j int) { providers[i], providers[j] = providers[j], providers[i] })
-
 		var lastErr error
 		for _, p := range providers {
-
 			fmt.Printf("Trying Provider: %s (Quality: %s)...\n", p.Name, qual)
 
 			url, err := p.Func()
 			if err == nil {
 				fmt.Printf("✓ Success\n")
+				recordProviderSuccess("qobuz", p.API)
 				return url, nil
 			}
 
 			fmt.Printf("Provider failed: %v\n", err)
+			recordProviderFailure("qobuz", p.API)
 			lastErr = err
 		}
 		return "", lastErr
@@ -354,29 +361,29 @@ func buildQobuzFilename(title, artist, album, albumArtist, releaseDate string, t
 }
 
 func (q *QobuzDownloader) DownloadTrack(spotifyID, outputDir, quality, filenameFormat string, includeTrackNumber bool, position int, spotifyTrackName, spotifyArtistName, spotifyAlbumName, spotifyAlbumArtist, spotifyReleaseDate string, useAlbumTrackNumber bool, spotifyCoverURL string, embedMaxQualityCover bool, spotifyTrackNumber, spotifyDiscNumber, spotifyTotalTracks int, spotifyTotalDiscs int, spotifyCopyright, spotifyPublisher, spotifyURL string, allowFallback bool, useFirstArtistOnly bool, useSingleGenre bool, embedGenre bool) (string, error) {
-	var deezerISRC string
+	var isrc string
 	if spotifyID != "" {
-		songlinkClient := NewSongLinkClient()
-		isrc, err := songlinkClient.GetISRC(spotifyID)
+		linkClient := NewSongLinkClient()
+		resolvedISRC, err := linkClient.GetISRCDirect(spotifyID)
 		if err != nil {
 			return "", fmt.Errorf("failed to get ISRC: %v", err)
 		}
-		deezerISRC = isrc
+		isrc = resolvedISRC
 	} else {
 		return "", fmt.Errorf("spotify ID is required for Qobuz download")
 	}
 
-	return q.DownloadTrackWithISRC(deezerISRC, spotifyID, outputDir, quality, filenameFormat, includeTrackNumber, position, spotifyTrackName, spotifyArtistName, spotifyAlbumName, spotifyAlbumArtist, spotifyReleaseDate, useAlbumTrackNumber, spotifyCoverURL, embedMaxQualityCover, spotifyTrackNumber, spotifyDiscNumber, spotifyTotalTracks, spotifyTotalDiscs, spotifyCopyright, spotifyPublisher, spotifyURL, allowFallback, useFirstArtistOnly, useSingleGenre, embedGenre)
+	return q.DownloadTrackWithISRC(isrc, outputDir, quality, filenameFormat, includeTrackNumber, position, spotifyTrackName, spotifyArtistName, spotifyAlbumName, spotifyAlbumArtist, spotifyReleaseDate, useAlbumTrackNumber, spotifyCoverURL, embedMaxQualityCover, spotifyTrackNumber, spotifyDiscNumber, spotifyTotalTracks, spotifyTotalDiscs, spotifyCopyright, spotifyPublisher, spotifyURL, allowFallback, useFirstArtistOnly, useSingleGenre, embedGenre)
 }
 
-func (q *QobuzDownloader) DownloadTrackWithISRC(deezerISRC, spotifyID, outputDir, quality, filenameFormat string, includeTrackNumber bool, position int, spotifyTrackName, spotifyArtistName, spotifyAlbumName, spotifyAlbumArtist, spotifyReleaseDate string, useAlbumTrackNumber bool, spotifyCoverURL string, embedMaxQualityCover bool, spotifyTrackNumber, spotifyDiscNumber, spotifyTotalTracks int, spotifyTotalDiscs int, spotifyCopyright, spotifyPublisher, spotifyURL string, allowFallback bool, useFirstArtistOnly bool, useSingleGenre bool, embedGenre bool) (string, error) {
-	fmt.Printf("Fetching track info for ISRC: %s\n", deezerISRC)
+func (q *QobuzDownloader) DownloadTrackWithISRC(isrc, outputDir, quality, filenameFormat string, includeTrackNumber bool, position int, spotifyTrackName, spotifyArtistName, spotifyAlbumName, spotifyAlbumArtist, spotifyReleaseDate string, useAlbumTrackNumber bool, spotifyCoverURL string, embedMaxQualityCover bool, spotifyTrackNumber, spotifyDiscNumber, spotifyTotalTracks int, spotifyTotalDiscs int, spotifyCopyright, spotifyPublisher, spotifyURL string, allowFallback bool, useFirstArtistOnly bool, useSingleGenre bool, embedGenre bool) (string, error) {
+	fmt.Printf("Fetching track info for ISRC: %s\n", isrc)
 
 	metaChan := make(chan Metadata, 1)
-	if embedGenre && deezerISRC != "" {
+	if embedGenre && isrc != "" {
 		go func() {
 			fmt.Println("Fetching MusicBrainz metadata...")
-			if fetchedMeta, err := FetchMusicBrainzMetadata(deezerISRC, spotifyTrackName, spotifyArtistName, spotifyAlbumName, useSingleGenre, embedGenre); err == nil {
+			if fetchedMeta, err := FetchMusicBrainzMetadata(isrc, spotifyTrackName, spotifyArtistName, spotifyAlbumName, useSingleGenre, embedGenre); err == nil {
 				fmt.Println("✓ MusicBrainz metadata fetched")
 				metaChan <- fetchedMeta
 			} else {
@@ -394,7 +401,7 @@ func (q *QobuzDownloader) DownloadTrackWithISRC(deezerISRC, spotifyID, outputDir
 		}
 	}
 
-	track, err := q.searchByISRC(deezerISRC)
+	track, err := q.searchByISRC(isrc)
 	if err != nil {
 		return "", err
 	}
@@ -469,7 +476,7 @@ func (q *QobuzDownloader) DownloadTrackWithISRC(deezerISRC, spotifyID, outputDir
 	}
 
 	var mbMeta Metadata
-	if deezerISRC != "" {
+	if isrc != "" {
 		mbMeta = <-metaChan
 	}
 
@@ -491,10 +498,11 @@ func (q *QobuzDownloader) DownloadTrackWithISRC(deezerISRC, spotifyID, outputDir
 		DiscNumber:  spotifyDiscNumber,
 		TotalDiscs:  spotifyTotalDiscs,
 		URL:         spotifyURL,
+		Comment:     spotifyURL,
 		Copyright:   spotifyCopyright,
 		Publisher:   spotifyPublisher,
 		Description: "https://github.com/afkarxyz/SpotiFLAC",
-		ISRC:        deezerISRC,
+		ISRC:        isrc,
 		Genre:       mbMeta.Genre,
 	}
 

backend/resample.go

@@ -0,0 +1,223 @@
+package backend
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"sync"
+)
+
+type FlacInfo struct {
+	Path          string `json:"path"`
+	SampleRate    uint32 `json:"sample_rate"`
+	BitsPerSample uint8  `json:"bits_per_sample"`
+}
+
+func GetFlacInfoBatch(paths []string) []FlacInfo {
+	results := make([]FlacInfo, len(paths))
+	var wg sync.WaitGroup
+
+	for i, path := range paths {
+		wg.Add(1)
+		go func(idx int, p string) {
+			defer wg.Done()
+			info := FlacInfo{Path: p}
+
+			ffprobePath, err := GetFFprobePath()
+			if err != nil {
+				results[idx] = info
+				return
+			}
+
+			args := []string{
+				"-v", "error",
+				"-select_streams", "a:0",
+				"-show_entries", "stream=sample_rate,bits_per_raw_sample,bits_per_sample",
+				"-of", "default=noprint_wrappers=0",
+				p,
+			}
+			cmd := exec.Command(ffprobePath, args...)
+			setHideWindow(cmd)
+			out, err := cmd.CombinedOutput()
+			if err != nil {
+				results[idx] = info
+				return
+			}
+
+			kvMap := make(map[string]string)
+			for _, line := range strings.Split(string(out), "\n") {
+				if parts := strings.SplitN(line, "=", 2); len(parts) == 2 {
+					kvMap[strings.TrimSpace(parts[0])] = strings.TrimSpace(parts[1])
+				}
+			}
+
+			if v, ok := kvMap["sample_rate"]; ok {
+				if s, err := strconv.Atoi(v); err == nil {
+					info.SampleRate = uint32(s)
+				}
+			}
+
+			bits := 0
+			if v, ok := kvMap["bits_per_raw_sample"]; ok && v != "N/A" && v != "" {
+				bits, _ = strconv.Atoi(v)
+			}
+			if bits == 0 {
+				if v, ok := kvMap["bits_per_sample"]; ok && v != "N/A" && v != "" {
+					bits, _ = strconv.Atoi(v)
+				}
+			}
+			info.BitsPerSample = uint8(bits)
+
+			results[idx] = info
+		}(i, path)
+	}
+
+	wg.Wait()
+	return results
+}
+
+type ResampleRequest struct {
+	InputFiles []string `json:"input_files"`
+	SampleRate string   `json:"sample_rate"`
+	BitDepth   string   `json:"bit_depth"`
+}
+
+type ResampleResult struct {
+	InputFile  string `json:"input_file"`
+	OutputFile string `json:"output_file"`
+	Success    bool   `json:"success"`
+	Error      string `json:"error,omitempty"`
+}
+
+func buildFolderLabel(sampleRate, bitDepth string) string {
+	var parts []string
+
+	if bitDepth != "" {
+		parts = append(parts, bitDepth+"bit")
+	}
+
+	switch sampleRate {
+	case "44100":
+		parts = append(parts, "44.1kHz")
+	case "48000":
+		parts = append(parts, "48kHz")
+	case "96000":
+		parts = append(parts, "96kHz")
+	case "192000":
+		parts = append(parts, "192kHz")
+	default:
+		if sampleRate != "" {
+			parts = append(parts, sampleRate+"Hz")
+		}
+	}
+
+	if len(parts) == 0 {
+		return "Resampled"
+	}
+	return strings.Join(parts, " ")
+}
+
+func ResampleAudio(req ResampleRequest) ([]ResampleResult, error) {
+	ffmpegPath, err := GetFFmpegPath()
+	if err != nil {
+		return nil, fmt.Errorf("failed to get ffmpeg path: %w", err)
+	}
+
+	if err := ValidateExecutable(ffmpegPath); err != nil {
+		return nil, fmt.Errorf("invalid ffmpeg executable: %w", err)
+	}
+
+	installed, err := IsFFmpegInstalled()
+	if err != nil || !installed {
+		return nil, fmt.Errorf("ffmpeg is not installed")
+	}
+
+	if req.SampleRate == "" && req.BitDepth == "" {
+		return nil, fmt.Errorf("at least one of sample rate or bit depth must be specified")
+	}
+
+	results := make([]ResampleResult, len(req.InputFiles))
+	var wg sync.WaitGroup
+	var mu sync.Mutex
+
+	folderLabel := buildFolderLabel(req.SampleRate, req.BitDepth)
+
+	for i, inputFile := range req.InputFiles {
+		wg.Add(1)
+		go func(idx int, inputFile string) {
+			defer wg.Done()
+
+			result := ResampleResult{
+				InputFile: inputFile,
+			}
+
+			inputExt := strings.ToLower(filepath.Ext(inputFile))
+			baseName := strings.TrimSuffix(filepath.Base(inputFile), inputExt)
+			inputDir := filepath.Dir(inputFile)
+
+			outputDir := filepath.Join(inputDir, folderLabel)
+			if err := os.MkdirAll(outputDir, 0755); err != nil {
+				result.Error = fmt.Sprintf("failed to create output directory: %v", err)
+				result.Success = false
+				mu.Lock()
+				results[idx] = result
+				mu.Unlock()
+				return
+			}
+
+			outputFile := filepath.Join(outputDir, baseName+".flac")
+			result.OutputFile = outputFile
+
+			args := []string{
+				"-i", inputFile,
+				"-y",
+			}
+
+			if req.BitDepth != "" {
+				switch req.BitDepth {
+				case "16":
+					args = append(args, "-c:a", "flac", "-sample_fmt", "s16")
+				case "24":
+					args = append(args, "-c:a", "flac", "-sample_fmt", "s32", "-bits_per_raw_sample", "24")
+				default:
+					args = append(args, "-c:a", "flac")
+				}
+			} else {
+				args = append(args, "-c:a", "flac")
+			}
+
+			if req.SampleRate != "" {
+				args = append(args, "-ar", req.SampleRate)
+			}
+
+			args = append(args, "-map_metadata", "0")
+			args = append(args, outputFile)
+
+			fmt.Printf("[Resample] %s -> %s\n", inputFile, outputFile)
+
+			cmd := exec.Command(ffmpegPath, args...)
+			setHideWindow(cmd)
+			output, err := cmd.CombinedOutput()
+			if err != nil {
+				result.Error = fmt.Sprintf("resampling failed: %s - %s", err.Error(), string(output))
+				result.Success = false
+				mu.Lock()
+				results[idx] = result
+				mu.Unlock()
+				return
+			}
+
+			result.Success = true
+			fmt.Printf("[Resample] Done: %s\n", outputFile)
+			mu.Lock()
+			results[idx] = result
+			mu.Unlock()
+		}(i, inputFile)
+	}
+
+	wg.Wait()
+	return results, nil
+}

backend/songlink.go

@@ -6,15 +6,21 @@ import (
 	"io"
 	"net/http"
 	"net/url"
+	"regexp"
 	"strings"
 	"time"
 )
 
+const songLinkUserAgent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36"
+
+var (
+	isrcPattern          = regexp.MustCompile(`\b([A-Z]{2}[A-Z0-9]{3}\d{7})\b`)
+	amazonAlbumTrackPath = regexp.MustCompile(`/albums/[A-Z0-9]{10}/(B[0-9A-Z]{9})`)
+	amazonTrackPath      = regexp.MustCompile(`/tracks/(B[0-9A-Z]{9})`)
+)
+
 type SongLinkClient struct {
-	client           *http.Client
-	lastAPICallTime  time.Time
-	apiCallCount     int
-	apiCallResetTime time.Time
+	client *http.Client
 }
 
 type SongLinkURLs struct {
@@ -35,136 +41,37 @@ type TrackAvailability struct {
 	DeezerURL string `json:"deezer_url,omitempty"`
 }
 
+type songLinkAPIResponse struct {
+	LinksByPlatform map[string]struct {
+		URL string `json:"url"`
+	} `json:"linksByPlatform"`
+}
+
 func NewSongLinkClient() *SongLinkClient {
 	return &SongLinkClient{
 		client: &http.Client{
 			Timeout: 30 * time.Second,
 		},
-		apiCallResetTime: time.Now(),
 	}
 }
 
 func (s *SongLinkClient) GetAllURLsFromSpotify(spotifyTrackID string, region string) (*SongLinkURLs, error) {
-
-	now := time.Now()
-	if now.Sub(s.apiCallResetTime) >= time.Minute {
-		s.apiCallCount = 0
-		s.apiCallResetTime = now
-	}
-
-	if s.apiCallCount >= 9 {
-		waitTime := time.Minute - now.Sub(s.apiCallResetTime)
-		if waitTime > 0 {
-			fmt.Printf("Rate limit reached, waiting %v...\n", waitTime.Round(time.Second))
-			time.Sleep(waitTime)
-			s.apiCallCount = 0
-			s.apiCallResetTime = time.Now()
-		}
-	}
-
-	if !s.lastAPICallTime.IsZero() {
-		timeSinceLastCall := now.Sub(s.lastAPICallTime)
-		minDelay := 7 * time.Second
-		if timeSinceLastCall < minDelay {
-			waitTime := minDelay - timeSinceLastCall
-			fmt.Printf("Rate limiting: waiting %v...\n", waitTime.Round(time.Second))
-			time.Sleep(waitTime)
-		}
-	}
-
-	spotifyURL := fmt.Sprintf("https://open.spotify.com/track/%s", spotifyTrackID)
-
-	apiURL := fmt.Sprintf("https://api.song.link/v1-alpha.1/links?url=%s", url.QueryEscape(spotifyURL))
-
-	if region != "" {
-		apiURL += fmt.Sprintf("&userCountry=%s", region)
-	}
-
-	req, err := http.NewRequest("GET", apiURL, nil)
-	if err != nil {
-		return nil, fmt.Errorf("failed to create request: %w", err)
-	}
-
-	fmt.Println("Getting streaming URLs from song.link...")
-
-	maxRetries := 3
-	var resp *http.Response
-	for i := 0; i < maxRetries; i++ {
-		resp, err = s.client.Do(req)
-		if err != nil {
-			return nil, fmt.Errorf("failed to get URLs: %w", err)
-		}
-
-		s.lastAPICallTime = time.Now()
-		s.apiCallCount++
-
-		if resp.StatusCode == 429 {
-			resp.Body.Close()
-			if i < maxRetries-1 {
-				waitTime := 15 * time.Second
-				fmt.Printf("Rate limited by API, waiting %v before retry...\n", waitTime)
-				time.Sleep(waitTime)
-				continue
-			}
-			return nil, fmt.Errorf("API rate limit exceeded after %d retries", maxRetries)
-		}
-
-		if resp.StatusCode != 200 {
-			resp.Body.Close()
-			return nil, fmt.Errorf("API returned status %d", resp.StatusCode)
-		}
-
-		break
-	}
-	defer resp.Body.Close()
-
-	var songLinkResp struct {
-		LinksByPlatform map[string]struct {
-			URL string `json:"url"`
-		} `json:"linksByPlatform"`
-	}
-
-	body, err := io.ReadAll(resp.Body)
-	if err != nil {
-		return nil, fmt.Errorf("failed to read response body: %w", err)
-	}
-
-	if len(body) == 0 {
-		return nil, fmt.Errorf("API returned empty response")
-	}
-
-	if err := json.Unmarshal(body, &songLinkResp); err != nil {
-
-		bodyStr := string(body)
-		if len(bodyStr) > 200 {
-			bodyStr = bodyStr[:200] + "..."
-		}
-		return nil, fmt.Errorf("failed to decode response: %w (response: %s)", err, bodyStr)
+	links, err := s.resolveSpotifyTrackLinks(spotifyTrackID, region)
+	if err != nil && (links == nil || (links.TidalURL == "" && links.AmazonURL == "")) {
+		return nil, err
 	}
 
 	urls := &SongLinkURLs{}
-
-	if tidalLink, ok := songLinkResp.LinksByPlatform["tidal"]; ok && tidalLink.URL != "" {
-		urls.TidalURL = tidalLink.URL
-		fmt.Printf("✓ Tidal URL found\n")
-	}
-
-	if amazonLink, ok := songLinkResp.LinksByPlatform["amazonMusic"]; ok && amazonLink.URL != "" {
-		amazonURL := amazonLink.URL
-
-		if len(amazonURL) > 0 {
-			urls.AmazonURL = amazonURL
-			fmt.Printf("✓ Amazon URL found\n")
-		}
-	}
-
-	if deezerLink, ok := songLinkResp.LinksByPlatform["deezer"]; ok && deezerLink.URL != "" {
-		if isrc, err := getDeezerISRC(deezerLink.URL); err == nil && isrc != "" {
-			urls.ISRC = isrc
-		}
+	if links != nil {
+		urls.TidalURL = links.TidalURL
+		urls.AmazonURL = normalizeAmazonMusicURL(links.AmazonURL)
+		urls.ISRC = links.ISRC
 	}
 
 	if urls.TidalURL == "" && urls.AmazonURL == "" {
+		if err != nil {
+			return nil, err
+		}
 		return nil, fmt.Errorf("no streaming URLs found")
 	}
 
@@ -172,133 +79,64 @@ func (s *SongLinkClient) GetAllURLsFromSpotify(spotifyTrackID string, region str
 }
 
 func (s *SongLinkClient) CheckTrackAvailability(spotifyTrackID string) (*TrackAvailability, error) {
-
-	now := time.Now()
-	if now.Sub(s.apiCallResetTime) >= time.Minute {
-		s.apiCallCount = 0
-		s.apiCallResetTime = now
-	}
-
-	if s.apiCallCount >= 9 {
-		waitTime := time.Minute - now.Sub(s.apiCallResetTime)
-		if waitTime > 0 {
-			fmt.Printf("Rate limit reached, waiting %v...\n", waitTime.Round(time.Second))
-			time.Sleep(waitTime)
-			s.apiCallCount = 0
-			s.apiCallResetTime = time.Now()
-		}
-	}
-
-	if !s.lastAPICallTime.IsZero() {
-		timeSinceLastCall := now.Sub(s.lastAPICallTime)
-		minDelay := 7 * time.Second
-		if timeSinceLastCall < minDelay {
-			waitTime := minDelay - timeSinceLastCall
-			fmt.Printf("Rate limiting: waiting %v...\n", waitTime.Round(time.Second))
-			time.Sleep(waitTime)
-		}
-	}
-
-	spotifyURL := fmt.Sprintf("https://open.spotify.com/track/%s", spotifyTrackID)
-
-	apiURL := fmt.Sprintf("https://api.song.link/v1-alpha.1/links?url=%s", url.QueryEscape(spotifyURL))
-
-	req, err := http.NewRequest("GET", apiURL, nil)
-	if err != nil {
-		return nil, fmt.Errorf("failed to create request: %w", err)
-	}
-
-	fmt.Printf("Checking availability for track: %s\n", spotifyTrackID)
-
-	maxRetries := 3
-	var resp *http.Response
-	for i := 0; i < maxRetries; i++ {
-		resp, err = s.client.Do(req)
-		if err != nil {
-			return nil, fmt.Errorf("failed to check availability: %w", err)
-		}
-
-		s.lastAPICallTime = time.Now()
-		s.apiCallCount++
-
-		if resp.StatusCode == 429 {
-			resp.Body.Close()
-			if i < maxRetries-1 {
-				waitTime := 15 * time.Second
-				fmt.Printf("Rate limited by API, waiting %v before retry...\n", waitTime)
-				time.Sleep(waitTime)
-				continue
-			}
-			return nil, fmt.Errorf("API rate limit exceeded after %d retries", maxRetries)
-		}
-
-		if resp.StatusCode != 200 {
-			resp.Body.Close()
-			return nil, fmt.Errorf("API returned status %d", resp.StatusCode)
-		}
-
-		break
-	}
-	defer resp.Body.Close()
-
-	var songLinkResp struct {
-		LinksByPlatform map[string]struct {
-			URL string `json:"url"`
-		} `json:"linksByPlatform"`
-	}
-
-	body, err := io.ReadAll(resp.Body)
-	if err != nil {
-		return nil, fmt.Errorf("failed to read response body: %w", err)
-	}
-
-	if len(body) == 0 {
-		return nil, fmt.Errorf("API returned empty response")
-	}
-
-	if err := json.Unmarshal(body, &songLinkResp); err != nil {
-
-		bodyStr := string(body)
-		if len(bodyStr) > 200 {
-			bodyStr = bodyStr[:200] + "..."
-		}
-		return nil, fmt.Errorf("failed to decode response: %w (response: %s)", err, bodyStr)
-	}
+	links, err := s.resolveSpotifyTrackLinks(spotifyTrackID, "")
 
 	availability := &TrackAvailability{
 		SpotifyID: spotifyTrackID,
 	}
 
-	if tidalLink, ok := songLinkResp.LinksByPlatform["tidal"]; ok && tidalLink.URL != "" {
-		availability.Tidal = true
-		availability.TidalURL = tidalLink.URL
+	if links != nil {
+		availability.TidalURL = links.TidalURL
+		availability.AmazonURL = normalizeAmazonMusicURL(links.AmazonURL)
+		availability.DeezerURL = normalizeDeezerTrackURL(links.DeezerURL)
+		availability.Tidal = availability.TidalURL != ""
+		availability.Amazon = availability.AmazonURL != ""
+		availability.Deezer = availability.DeezerURL != ""
 	}
 
-	if amazonLink, ok := songLinkResp.LinksByPlatform["amazonMusic"]; ok && amazonLink.URL != "" {
-		availability.Amazon = true
-		availability.AmazonURL = amazonLink.URL
+	isrc := ""
+	if links != nil {
+		isrc = strings.TrimSpace(links.ISRC)
 	}
 
-	if deezerLink, ok := songLinkResp.LinksByPlatform["deezer"]; ok && deezerLink.URL != "" {
-		deezerURL := deezerLink.URL
-		availability.Deezer = true
-		availability.DeezerURL = deezerURL
-
-		deezerISRC, err := getDeezerISRC(deezerURL)
-		if err == nil && deezerISRC != "" {
-			qobuzAvailable := checkQobuzAvailability(deezerISRC)
-			availability.Qobuz = qobuzAvailable
+	if isrc == "" && availability.DeezerURL != "" {
+		if resolvedISRC, deezerErr := getDeezerISRC(availability.DeezerURL); deezerErr == nil {
+			isrc = resolvedISRC
 		}
 	}
 
-	return availability, nil
+	if isrc == "" {
+		if fallbackISRC, fallbackErr := s.lookupSpotifyISRC(spotifyTrackID); fallbackErr == nil {
+			isrc = fallbackISRC
+		} else if err == nil {
+			err = fallbackErr
+		}
+	}
+
+	if isrc != "" {
+		availability.Qobuz = checkQobuzAvailability(isrc)
+	}
+
+	if availability.Tidal || availability.Amazon || availability.Deezer || availability.Qobuz {
+		return availability, nil
+	}
+
+	if err != nil {
+		return availability, err
+	}
+
+	return availability, fmt.Errorf("no platforms found")
 }
 
 func checkQobuzAvailability(isrc string) bool {
 	client := &http.Client{Timeout: 10 * time.Second}
 	appID := "798273057"
 
-	searchURL := fmt.Sprintf("https://www.qobuz.com/api.json/0.2/track/search?query=%s&limit=1&app_id=%s", isrc, appID)
+	searchURL := fmt.Sprintf(
+		"https://www.qobuz.com/api.json/0.2/track/search?query=%s&limit=1&app_id=%s",
+		url.QueryEscape(strings.TrimSpace(isrc)),
+		appID,
+	)
 
 	resp, err := client.Get(searchURL)
 	if err != nil {
@@ -306,7 +144,7 @@ func checkQobuzAvailability(isrc string) bool {
 	}
 	defer resp.Body.Close()
 
-	if resp.StatusCode != 200 {
+	if resp.StatusCode != http.StatusOK {
 		return false
 	}
 
@@ -323,107 +161,47 @@ func checkQobuzAvailability(isrc string) bool {
 }
 
 func (s *SongLinkClient) GetDeezerURLFromSpotify(spotifyTrackID string) (string, error) {
-
-	now := time.Now()
-	if now.Sub(s.apiCallResetTime) >= time.Minute {
-		s.apiCallCount = 0
-		s.apiCallResetTime = now
+	links, err := s.resolveSpotifyTrackLinks(spotifyTrackID, "")
+	if links != nil && links.DeezerURL != "" {
+		deezerURL := normalizeDeezerTrackURL(links.DeezerURL)
+		fmt.Printf("Found Deezer URL: %s\n", deezerURL)
+		return deezerURL, nil
 	}
 
-	if s.apiCallCount >= 9 {
-		waitTime := time.Minute - now.Sub(s.apiCallResetTime)
-		if waitTime > 0 {
-			fmt.Printf("Rate limit reached, waiting %v...\n", waitTime.Round(time.Second))
-			time.Sleep(waitTime)
-			s.apiCallCount = 0
-			s.apiCallResetTime = time.Now()
+	isrc := ""
+	if links != nil {
+		isrc = strings.TrimSpace(links.ISRC)
+	}
+	if isrc == "" {
+		fallbackISRC, lookupErr := s.lookupSpotifyISRC(spotifyTrackID)
+		if lookupErr == nil {
+			isrc = fallbackISRC
+		} else if err == nil {
+			err = lookupErr
 		}
 	}
 
-	if !s.lastAPICallTime.IsZero() {
-		timeSinceLastCall := now.Sub(s.lastAPICallTime)
-		minDelay := 7 * time.Second
-		if timeSinceLastCall < minDelay {
-			waitTime := minDelay - timeSinceLastCall
-			fmt.Printf("Rate limiting: waiting %v...\n", waitTime.Round(time.Second))
-			time.Sleep(waitTime)
+	if isrc != "" {
+		deezerURL, deezerErr := s.lookupDeezerTrackURLByISRC(isrc)
+		if deezerErr == nil {
+			fmt.Printf("Found Deezer URL: %s\n", deezerURL)
+			return deezerURL, nil
+		}
+		if err == nil {
+			err = deezerErr
 		}
 	}
 
-	spotifyURL := fmt.Sprintf("https://open.spotify.com/track/%s", spotifyTrackID)
-
-	apiURL := fmt.Sprintf("https://api.song.link/v1-alpha.1/links?url=%s", url.QueryEscape(spotifyURL))
-
-	req, err := http.NewRequest("GET", apiURL, nil)
 	if err != nil {
-		return "", fmt.Errorf("failed to create request: %w", err)
+		return "", err
 	}
-
-	fmt.Println("Getting Deezer URL from song.link...")
-
-	maxRetries := 3
-	var resp *http.Response
-	for i := 0; i < maxRetries; i++ {
-		resp, err = s.client.Do(req)
-		if err != nil {
-			return "", fmt.Errorf("failed to get Deezer URL: %w", err)
-		}
-
-		s.lastAPICallTime = time.Now()
-		s.apiCallCount++
-
-		if resp.StatusCode == 429 {
-			resp.Body.Close()
-			if i < maxRetries-1 {
-				waitTime := 15 * time.Second
-				fmt.Printf("Rate limited by API, waiting %v before retry...\n", waitTime)
-				time.Sleep(waitTime)
-				continue
-			}
-			return "", fmt.Errorf("API rate limit exceeded after %d retries", maxRetries)
-		}
-
-		if resp.StatusCode != 200 {
-			resp.Body.Close()
-			return "", fmt.Errorf("API returned status %d", resp.StatusCode)
-		}
-
-		break
-	}
-	defer resp.Body.Close()
-
-	var songLinkResp struct {
-		LinksByPlatform map[string]struct {
-			URL string `json:"url"`
-		} `json:"linksByPlatform"`
-	}
-	if err := json.NewDecoder(resp.Body).Decode(&songLinkResp); err != nil {
-		return "", fmt.Errorf("failed to decode response: %w", err)
-	}
-
-	deezerLink, ok := songLinkResp.LinksByPlatform["deezer"]
-	if !ok || deezerLink.URL == "" {
-		return "", fmt.Errorf("deezer link not found")
-	}
-
-	deezerURL := deezerLink.URL
-	fmt.Printf("Found Deezer URL: %s\n", deezerURL)
-	return deezerURL, nil
+	return "", fmt.Errorf("deezer link not found")
 }
 
 func getDeezerISRC(deezerURL string) (string, error) {
-
-	var trackID string
-	if strings.Contains(deezerURL, "/track/") {
-		parts := strings.Split(deezerURL, "/track/")
-		if len(parts) > 1 {
-			trackID = strings.Split(parts[1], "?")[0]
-			trackID = strings.TrimSpace(trackID)
-		}
-	}
-
-	if trackID == "" {
-		return "", fmt.Errorf("could not extract track ID from Deezer URL: %s", deezerURL)
+	trackID, err := extractDeezerTrackID(deezerURL)
+	if err != nil {
+		return "", err
 	}
 
 	apiURL := fmt.Sprintf("https://api.deezer.com/track/%s", trackID)
@@ -435,7 +213,7 @@ func getDeezerISRC(deezerURL string) (string, error) {
 	}
 	defer resp.Body.Close()
 
-	if resp.StatusCode != 200 {
+	if resp.StatusCode != http.StatusOK {
 		return "", fmt.Errorf("Deezer API returned status %d", resp.StatusCode)
 	}
 
@@ -453,13 +231,211 @@ func getDeezerISRC(deezerURL string) (string, error) {
 	}
 
 	fmt.Printf("Found ISRC from Deezer: %s (track: %s)\n", deezerTrack.ISRC, deezerTrack.Title)
-	return deezerTrack.ISRC, nil
+	return strings.ToUpper(strings.TrimSpace(deezerTrack.ISRC)), nil
 }
 
 func (s *SongLinkClient) GetISRC(spotifyID string) (string, error) {
-	deezerURL, err := s.GetDeezerURLFromSpotify(spotifyID)
+	links, err := s.resolveSpotifyTrackLinks(spotifyID, "")
+	if links != nil && links.ISRC != "" {
+		return links.ISRC, nil
+	}
+
+	if links != nil && links.DeezerURL != "" {
+		if isrc, deezerErr := getDeezerISRC(links.DeezerURL); deezerErr == nil {
+			return isrc, nil
+		}
+	}
+
+	isrc, lookupErr := s.lookupSpotifyISRC(spotifyID)
+	if lookupErr == nil && isrc != "" {
+		return isrc, nil
+	}
+
+	if err != nil && lookupErr != nil {
+		return "", fmt.Errorf("%v | %v", err, lookupErr)
+	}
 	if err != nil {
 		return "", err
 	}
-	return getDeezerISRC(deezerURL)
+	if lookupErr != nil {
+		return "", lookupErr
+	}
+
+	return "", fmt.Errorf("ISRC not found")
+}
+
+func (s *SongLinkClient) GetISRCDirect(spotifyID string) (string, error) {
+	return s.lookupSpotifyISRC(spotifyID)
+}
+
+func (s *SongLinkClient) fetchSongLinkLinksByURL(rawURL string, region string) (*songLinkAPIResponse, error) {
+	apiURL := fmt.Sprintf("https://api.song.link/v1-alpha.1/links?url=%s", url.QueryEscape(rawURL))
+	if region != "" {
+		apiURL += fmt.Sprintf("&userCountry=%s", url.QueryEscape(region))
+	}
+
+	req, err := http.NewRequest(http.MethodGet, apiURL, nil)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create request: %w", err)
+	}
+	req.Header.Set("User-Agent", songLinkUserAgent)
+
+	resp, err := s.client.Do(req)
+	if err != nil {
+		return nil, fmt.Errorf("failed to call song.link: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		bodyPreview, _ := io.ReadAll(io.LimitReader(resp.Body, 256))
+		return nil, fmt.Errorf("song.link returned status %d (%s)", resp.StatusCode, strings.TrimSpace(string(bodyPreview)))
+	}
+
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return nil, fmt.Errorf("failed to read song.link response: %w", err)
+	}
+	if len(body) == 0 {
+		return nil, fmt.Errorf("song.link returned empty response")
+	}
+
+	var parsed songLinkAPIResponse
+	if err := json.Unmarshal(body, &parsed); err != nil {
+		bodyStr := string(body)
+		if len(bodyStr) > 200 {
+			bodyStr = bodyStr[:200] + "..."
+		}
+		return nil, fmt.Errorf("failed to decode song.link response: %w (response: %s)", err, bodyStr)
+	}
+
+	return &parsed, nil
+}
+
+func (s *SongLinkClient) lookupDeezerTrackURLByISRC(isrc string) (string, error) {
+	apiURL := fmt.Sprintf("https://api.deezer.com/track/isrc:%s", strings.ToUpper(strings.TrimSpace(isrc)))
+
+	req, err := http.NewRequest(http.MethodGet, apiURL, nil)
+	if err != nil {
+		return "", fmt.Errorf("failed to create request: %w", err)
+	}
+	req.Header.Set("User-Agent", songLinkUserAgent)
+
+	resp, err := s.client.Do(req)
+	if err != nil {
+		return "", fmt.Errorf("failed to call Deezer ISRC API: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		return "", fmt.Errorf("Deezer ISRC API returned status %d", resp.StatusCode)
+	}
+
+	var payload struct {
+		ID   int64  `json:"id"`
+		ISRC string `json:"isrc"`
+		Link string `json:"link"`
+	}
+	if err := json.NewDecoder(resp.Body).Decode(&payload); err != nil {
+		return "", fmt.Errorf("failed to decode Deezer ISRC response: %w", err)
+	}
+
+	if payload.Link != "" {
+		return normalizeDeezerTrackURL(payload.Link), nil
+	}
+	if payload.ID > 0 {
+		return normalizeDeezerTrackURL(fmt.Sprintf("https://www.deezer.com/track/%d", payload.ID)), nil
+	}
+
+	return "", fmt.Errorf("deezer track link not found for ISRC %s", isrc)
+}
+
+func mergeSongLinkResponse(links *resolvedTrackLinks, resp *songLinkAPIResponse) {
+	if resp == nil {
+		return
+	}
+
+	if link, ok := resp.LinksByPlatform["tidal"]; ok && link.URL != "" && links.TidalURL == "" {
+		links.TidalURL = strings.TrimSpace(link.URL)
+		fmt.Println("✓ Tidal URL found")
+	}
+
+	if link, ok := resp.LinksByPlatform["amazonMusic"]; ok && link.URL != "" && links.AmazonURL == "" {
+		links.AmazonURL = normalizeAmazonMusicURL(link.URL)
+		fmt.Println("✓ Amazon URL found")
+	}
+
+	if link, ok := resp.LinksByPlatform["deezer"]; ok && link.URL != "" && links.DeezerURL == "" {
+		links.DeezerURL = normalizeDeezerTrackURL(link.URL)
+		fmt.Println("✓ Deezer URL found")
+	}
+}
+
+func normalizeAmazonMusicURL(rawURL string) string {
+	amazonURL := strings.TrimSpace(rawURL)
+	if amazonURL == "" {
+		return ""
+	}
+
+	if strings.Contains(amazonURL, "trackAsin=") {
+		parts := strings.Split(amazonURL, "trackAsin=")
+		if len(parts) > 1 {
+			trackAsin := strings.Split(parts[1], "&")[0]
+			if trackAsin != "" {
+				return fmt.Sprintf("https://music.amazon.com/tracks/%s?musicTerritory=US", trackAsin)
+			}
+		}
+	}
+
+	if match := amazonAlbumTrackPath.FindStringSubmatch(amazonURL); len(match) > 1 {
+		return fmt.Sprintf("https://music.amazon.com/tracks/%s?musicTerritory=US", match[1])
+	}
+
+	if match := amazonTrackPath.FindStringSubmatch(amazonURL); len(match) > 1 {
+		return fmt.Sprintf("https://music.amazon.com/tracks/%s?musicTerritory=US", match[1])
+	}
+
+	return ""
+}
+
+func normalizeDeezerTrackURL(rawURL string) string {
+	trackID, err := extractDeezerTrackID(rawURL)
+	if err != nil {
+		return strings.TrimSpace(rawURL)
+	}
+	return fmt.Sprintf("https://www.deezer.com/track/%s", trackID)
+}
+
+func extractDeezerTrackID(rawURL string) (string, error) {
+	cleanURL := strings.TrimSpace(rawURL)
+	if cleanURL == "" {
+		return "", fmt.Errorf("empty Deezer URL")
+	}
+
+	parts := strings.Split(cleanURL, "/track/")
+	if len(parts) < 2 {
+		return "", fmt.Errorf("could not extract track ID from Deezer URL: %s", rawURL)
+	}
+
+	trackID := strings.Split(parts[1], "?")[0]
+	trackID = strings.Trim(trackID, "/ ")
+	if trackID == "" {
+		return "", fmt.Errorf("could not extract track ID from Deezer URL: %s", rawURL)
+	}
+
+	return trackID, nil
+}
+
+func hasAnySongLinkData(links *resolvedTrackLinks) bool {
+	if links == nil {
+		return false
+	}
+	return links.TidalURL != "" || links.AmazonURL != "" || links.DeezerURL != ""
+}
+
+func firstISRCMatch(body string) string {
+	match := isrcPattern.FindStringSubmatch(strings.ToUpper(body))
+	if len(match) < 2 {
+		return ""
+	}
+	return strings.TrimSpace(match[1])
 }

backend/songstats.go

@@ -0,0 +1,128 @@
+package backend
+
+import (
+	"encoding/json"
+	"fmt"
+	"html"
+	"io"
+	"net/http"
+	"regexp"
+	"strings"
+)
+
+var songstatsScriptPattern = regexp.MustCompile(`(?is)<script[^>]+type=["']application/ld\+json["'][^>]*>(.*?)</script>`)
+
+func (s *SongLinkClient) populateLinksFromSongstats(links *resolvedTrackLinks, isrc string) error {
+	pageURL := fmt.Sprintf("https://songstats.com/%s?ref=ISRCFinder", strings.ToUpper(strings.TrimSpace(isrc)))
+
+	req, err := http.NewRequest(http.MethodGet, pageURL, nil)
+	if err != nil {
+		return fmt.Errorf("failed to create request: %w", err)
+	}
+	req.Header.Set("User-Agent", songLinkUserAgent)
+
+	resp, err := s.client.Do(req)
+	if err != nil {
+		return fmt.Errorf("failed to fetch Songstats page: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		return fmt.Errorf("Songstats returned status %d", resp.StatusCode)
+	}
+
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return fmt.Errorf("failed to read Songstats response: %w", err)
+	}
+
+	matches := songstatsScriptPattern.FindAllStringSubmatch(string(body), -1)
+	if len(matches) == 0 {
+		return fmt.Errorf("Songstats JSON-LD not found")
+	}
+
+	found := false
+	for _, match := range matches {
+		if len(match) < 2 {
+			continue
+		}
+
+		scriptBody := strings.TrimSpace(html.UnescapeString(match[1]))
+		if scriptBody == "" {
+			continue
+		}
+
+		var payload interface{}
+		if err := json.Unmarshal([]byte(scriptBody), &payload); err != nil {
+			continue
+		}
+
+		before := *links
+		collectSongstatsLinks(payload, links)
+		if *links != before {
+			found = true
+		}
+	}
+
+	if !found && !hasAnySongLinkData(links) {
+		return fmt.Errorf("no platform links found in Songstats")
+	}
+
+	return nil
+}
+
+func collectSongstatsLinks(value interface{}, links *resolvedTrackLinks) {
+	switch typed := value.(type) {
+	case map[string]interface{}:
+		if sameAs, ok := typed["sameAs"]; ok {
+			applySongstatsSameAs(sameAs, links)
+		}
+		for _, nested := range typed {
+			collectSongstatsLinks(nested, links)
+		}
+	case []interface{}:
+		for _, nested := range typed {
+			collectSongstatsLinks(nested, links)
+		}
+	}
+}
+
+func applySongstatsSameAs(value interface{}, links *resolvedTrackLinks) {
+	switch typed := value.(type) {
+	case string:
+		assignSongstatsLink(typed, links)
+	case []interface{}:
+		for _, item := range typed {
+			if link, ok := item.(string); ok {
+				assignSongstatsLink(link, links)
+			}
+		}
+	}
+}
+
+func assignSongstatsLink(rawLink string, links *resolvedTrackLinks) {
+	link := strings.TrimSpace(rawLink)
+	if link == "" {
+		return
+	}
+
+	switch {
+	case strings.Contains(link, "listen.tidal.com/track"):
+		if links.TidalURL == "" {
+			links.TidalURL = link
+			fmt.Println("✓ Tidal URL found via Songstats")
+		}
+	case strings.Contains(link, "music.amazon.com"):
+		if links.AmazonURL == "" {
+			if normalized := normalizeAmazonMusicURL(link); normalized != "" {
+				links.AmazonURL = normalized
+				fmt.Println("✓ Amazon URL found via Songstats")
+			}
+		}
+	case strings.Contains(link, "deezer.com"):
+		if links.DeezerURL == "" {
+			links.DeezerURL = normalizeDeezerTrackURL(link)
+			fmt.Println("✓ Deezer URL found via Songstats")
+		}
+	}
+}

backend/soundplate.go

@@ -0,0 +1,95 @@
+package backend
+
+import (
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"strings"
+)
+
+const (
+	soundplateSpotifyAPIURL = "https://phpstack-822472-6184058.cloudwaysapps.com/api/spotify.php"
+	soundplateRefererURL    = "https://phpstack-822472-6184058.cloudwaysapps.com/?"
+	soundplateUserAgent     = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36"
+)
+
+type soundplateSpotifyResponse struct {
+	Name       string `json:"name"`
+	Artist     string `json:"artist"`
+	Album      string `json:"album"`
+	AlbumType  string `json:"album_type"`
+	ArtworkURL string `json:"artwork_url"`
+	ISRC       string `json:"isrc"`
+	Year       string `json:"year"`
+	SpotifyURL string `json:"spotify_url"`
+}
+
+func (s *SongLinkClient) lookupSpotifyISRCViaSoundplate(spotifyTrackID string) (string, string, error) {
+	normalizedTrackID, err := extractSpotifyTrackID(spotifyTrackID)
+	if err != nil {
+		return "", "", err
+	}
+
+	spotifyTrackURL := fmt.Sprintf("https://open.spotify.com/track/%s", normalizedTrackID)
+	query := url.Values{}
+	query.Set("q", spotifyTrackURL)
+
+	req, err := http.NewRequest(http.MethodGet, soundplateSpotifyAPIURL+"?"+query.Encode(), nil)
+	if err != nil {
+		return "", "", fmt.Errorf("failed to create Soundplate ISRC request: %w", err)
+	}
+	req.Header.Set("User-Agent", soundplateUserAgent)
+	req.Header.Set("Accept", "*/*")
+	req.Header.Set("Referer", soundplateRefererURL)
+	req.Header.Set("Accept-Language", "en-US,en;q=0.9,id;q=0.8")
+	req.Header.Set("Sec-CH-UA", "\"Chromium\";v=\"146\", \"Not-A.Brand\";v=\"24\", \"Google Chrome\";v=\"146\"")
+	req.Header.Set("Sec-CH-UA-Mobile", "?0")
+	req.Header.Set("Sec-CH-UA-Platform", "\"Windows\"")
+	req.Header.Set("Sec-Fetch-Dest", "empty")
+	req.Header.Set("Sec-Fetch-Mode", "cors")
+	req.Header.Set("Sec-Fetch-Site", "same-origin")
+	req.Header.Set("Priority", "u=1, i")
+
+	resp, err := s.client.Do(req)
+	if err != nil {
+		return "", "", fmt.Errorf("Soundplate ISRC request failed: %w", err)
+	}
+	defer resp.Body.Close()
+
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return "", "", fmt.Errorf("failed to read Soundplate ISRC response: %w", err)
+	}
+
+	if resp.StatusCode != http.StatusOK {
+		bodyPreview := strings.TrimSpace(string(body))
+		if len(bodyPreview) > 256 {
+			bodyPreview = bodyPreview[:256]
+		}
+		return "", "", fmt.Errorf("Soundplate ISRC returned status %d (%s)", resp.StatusCode, bodyPreview)
+	}
+
+	var payload soundplateSpotifyResponse
+	if err := json.Unmarshal(body, &payload); err != nil {
+		return "", "", fmt.Errorf("failed to decode Soundplate ISRC response: %w", err)
+	}
+
+	isrc := firstISRCMatch(payload.ISRC)
+	if isrc == "" {
+		isrc = firstISRCMatch(string(body))
+	}
+	if isrc == "" {
+		return "", "", fmt.Errorf("ISRC missing in Soundplate response")
+	}
+
+	resolvedTrackID := ""
+	if payload.SpotifyURL != "" {
+		if trackID, err := extractSpotifyTrackID(payload.SpotifyURL); err == nil {
+			resolvedTrackID = trackID
+		}
+	}
+
+	return isrc, resolvedTrackID, nil
+}

backend/spectrum.go

@@ -1,181 +0,0 @@
-package backend
-
-import (
-	"fmt"
-	"math"
-	"math/cmplx"
-
-	"github.com/mewkiz/flac"
-)
-
-type SpectrumData struct {
-	TimeSlices []TimeSlice `json:"time_slices"`
-	SampleRate int         `json:"sample_rate"`
-	FreqBins   int         `json:"freq_bins"`
-	Duration   float64     `json:"duration"`
-	MaxFreq    float64     `json:"max_freq"`
-}
-
-type TimeSlice struct {
-	Time       float64   `json:"time"`
-	Magnitudes []float64 `json:"magnitudes"`
-}
-
-func AnalyzeSpectrum(filepath string) (*SpectrumData, error) {
-
-	stream, err := flac.ParseFile(filepath)
-	if err != nil {
-		return nil, fmt.Errorf("failed to parse FLAC: %w", err)
-	}
-	defer stream.Close()
-
-	info := stream.Info
-	sampleRate := int(info.SampleRate)
-	channels := int(info.NChannels)
-
-	samples, err := readSamples(stream, channels)
-	if err != nil {
-		return nil, fmt.Errorf("failed to read samples: %w", err)
-	}
-
-	if len(samples) == 0 {
-		return nil, fmt.Errorf("no audio samples found")
-	}
-
-	return calculateSpectrum(samples, sampleRate), nil
-}
-
-func readSamples(stream *flac.Stream, channels int) ([]float64, error) {
-	var allSamples []float64
-	maxSamples := 10 * 1024 * 1024
-
-	for {
-		frame, err := stream.ParseNext()
-		if err != nil {
-
-			break
-		}
-
-		for i := 0; i < frame.Subframes[0].NSamples; i++ {
-			var sample float64
-
-			for ch := 0; ch < channels; ch++ {
-				sample += float64(frame.Subframes[ch].Samples[i])
-			}
-			sample /= float64(channels)
-
-			allSamples = append(allSamples, sample)
-
-			if len(allSamples) >= maxSamples {
-				return allSamples, nil
-			}
-		}
-	}
-
-	return allSamples, nil
-}
-
-func calculateSpectrum(samples []float64, sampleRate int) *SpectrumData {
-	fftSize := 8192
-	numTimeSlices := 300
-
-	duration := float64(len(samples)) / float64(sampleRate)
-
-	samplesPerSlice := len(samples) / numTimeSlices
-	if samplesPerSlice < fftSize {
-		samplesPerSlice = fftSize
-		numTimeSlices = len(samples) / fftSize
-	}
-
-	timeSlices := make([]TimeSlice, 0, numTimeSlices)
-	freqBins := fftSize / 2
-	maxFreq := float64(sampleRate) / 2.0
-
-	for i := 0; i < numTimeSlices; i++ {
-		startIdx := i * samplesPerSlice
-		if startIdx+fftSize > len(samples) {
-			break
-		}
-
-		window := samples[startIdx : startIdx+fftSize]
-
-		windowedSamples := applyHannWindow(window)
-
-		spectrum := fft(windowedSamples)
-
-		magnitudes := make([]float64, freqBins)
-		for j := 0; j < freqBins; j++ {
-			magnitude := cmplx.Abs(spectrum[j])
-
-			if magnitude < 1e-10 {
-				magnitude = 1e-10
-			}
-			magnitudes[j] = 20 * math.Log10(magnitude)
-		}
-
-		timeSlice := TimeSlice{
-			Time:       float64(startIdx) / float64(sampleRate),
-			Magnitudes: magnitudes,
-		}
-		timeSlices = append(timeSlices, timeSlice)
-	}
-
-	return &SpectrumData{
-		TimeSlices: timeSlices,
-		SampleRate: sampleRate,
-		FreqBins:   freqBins,
-		Duration:   duration,
-		MaxFreq:    maxFreq,
-	}
-}
-
-func applyHannWindow(samples []float64) []float64 {
-	n := len(samples)
-	windowed := make([]float64, n)
-
-	for i := 0; i < n; i++ {
-		window := 0.5 * (1.0 - math.Cos(2.0*math.Pi*float64(i)/float64(n-1)))
-		windowed[i] = samples[i] * window
-	}
-
-	return windowed
-}
-
-func fft(samples []float64) []complex128 {
-	n := len(samples)
-
-	x := make([]complex128, n)
-	for i := 0; i < n; i++ {
-		x[i] = complex(samples[i], 0)
-	}
-
-	return fftRecursive(x)
-}
-
-func fftRecursive(x []complex128) []complex128 {
-	n := len(x)
-
-	if n <= 1 {
-		return x
-	}
-
-	even := make([]complex128, n/2)
-	odd := make([]complex128, n/2)
-
-	for i := 0; i < n/2; i++ {
-		even[i] = x[2*i]
-		odd[i] = x[2*i+1]
-	}
-
-	evenFFT := fftRecursive(even)
-	oddFFT := fftRecursive(odd)
-
-	result := make([]complex128, n)
-	for k := 0; k < n/2; k++ {
-		t := cmplx.Exp(complex(0, -2*math.Pi*float64(k)/float64(n))) * oddFFT[k]
-		result[k] = evenFFT[k] + t
-		result[k+n/2] = evenFFT[k] - t
-	}
-
-	return result
-}

backend/spotfetch.go

@@ -485,7 +485,7 @@ func extractDuration(ms float64) map[string]interface{} {
 	}
 }
 
-func FilterTrack(data map[string]interface{}, albumFetchData ...map[string]interface{}) map[string]interface{} {
+func FilterTrack(data map[string]interface{}, separator string, albumFetchData ...map[string]interface{}) map[string]interface{} {
 	dataMap := getMap(data, "data")
 	trackData := getMap(dataMap, "trackUnion")
 	if len(trackData) == 0 {
@@ -555,7 +555,7 @@ func FilterTrack(data map[string]interface{}, albumFetchData ...map[string]inter
 		copyrightData := getMap(albumData, "copyright")
 		if len(copyrightData) > 0 {
 			copyrightItems := getSlice(copyrightData, "items")
-			if copyrightItems != nil {
+			if len(copyrightItems) > 0 {
 				for _, item := range copyrightItems {
 					itemMap, ok := item.(map[string]interface{})
 					if !ok {
@@ -574,7 +574,7 @@ func FilterTrack(data map[string]interface{}, albumFetchData ...map[string]inter
 		if len(tracksData) > 0 {
 			discNumbers := make(map[int]bool)
 			trackItems := getSlice(tracksData, "items")
-			if trackItems != nil {
+			if len(trackItems) > 0 {
 				for _, item := range trackItems {
 					itemMap, ok := item.(map[string]interface{})
 					if !ok {
@@ -656,7 +656,7 @@ func FilterTrack(data map[string]interface{}, albumFetchData ...map[string]inter
 
 		albumArtistsString := ""
 		albumLabel := ""
-		if albumFetchDataMap != nil && len(albumFetchDataMap) > 0 {
+		if len(albumFetchDataMap) > 0 {
 			albumUnionData := getMap(getMap(albumFetchDataMap, "data"), "albumUnion")
 			if len(albumUnionData) > 0 {
 				albumArtists := extractArtists(getMap(albumUnionData, "artists"))
@@ -665,7 +665,7 @@ func FilterTrack(data map[string]interface{}, albumFetchData ...map[string]inter
 					for _, artist := range albumArtists {
 						albumArtistNames = append(albumArtistNames, getString(artist, "name"))
 					}
-					albumArtistsString = strings.Join(albumArtistNames, ", ")
+					albumArtistsString = strings.Join(albumArtistNames, separator)
 				}
 				if albumArtistsString == "" {
 					albumArtistsString = getString(albumUnionData, "artists")
@@ -681,7 +681,7 @@ func FilterTrack(data map[string]interface{}, albumFetchData ...map[string]inter
 				for _, artist := range albumArtists {
 					albumArtistNames = append(albumArtistNames, getString(artist, "name"))
 				}
-				albumArtistsString = strings.Join(albumArtistNames, ", ")
+				albumArtistsString = strings.Join(albumArtistNames, separator)
 			}
 		}
 
@@ -715,13 +715,13 @@ func FilterTrack(data map[string]interface{}, albumFetchData ...map[string]inter
 	for _, artist := range artists {
 		artistNames = append(artistNames, getString(artist, "name"))
 	}
-	artistsString := strings.Join(artistNames, ", ")
+	artistsString := strings.Join(artistNames, separator)
 
 	copyrightTexts := []string{}
 	for _, item := range copyrightInfo {
 		copyrightTexts = append(copyrightTexts, getString(item, "text"))
 	}
-	copyrightString := strings.Join(copyrightTexts, ", ")
+	copyrightString := strings.Join(copyrightTexts, GetSeparator())
 
 	discNumber := int(getFloat64(trackData, "discNumber"))
 	if discNumber == 0 {
@@ -802,7 +802,7 @@ func FilterTrack(data map[string]interface{}, albumFetchData ...map[string]inter
 	return filtered
 }
 
-func FilterAlbum(data map[string]interface{}) map[string]interface{} {
+func FilterAlbum(data map[string]interface{}, separator string) map[string]interface{} {
 	dataMap := getMap(data, "data")
 	albumData := getMap(dataMap, "albumUnion")
 	if len(albumData) == 0 {
@@ -814,7 +814,7 @@ func FilterAlbum(data map[string]interface{}) map[string]interface{} {
 	for _, artist := range artists {
 		artistNames = append(artistNames, getString(artist, "name"))
 	}
-	albumArtistsString := strings.Join(artistNames, ", ")
+	albumArtistsString := strings.Join(artistNames, separator)
 
 	coverObj := extractCoverImage(getMap(albumData, "coverArt"))
 	var cover interface{}
@@ -875,7 +875,7 @@ func FilterAlbum(data map[string]interface{}) map[string]interface{} {
 			for _, artist := range trackArtists {
 				trackArtistNames = append(trackArtistNames, getString(artist, "name"))
 			}
-			trackArtistsString := strings.Join(trackArtistNames, ", ")
+			trackArtistsString := strings.Join(trackArtistNames, separator)
 
 			trackURI := getString(track, "uri")
 			trackID := ""
@@ -943,7 +943,7 @@ func FilterAlbum(data map[string]interface{}) map[string]interface{} {
 	return filtered
 }
 
-func FilterPlaylist(data map[string]interface{}) map[string]interface{} {
+func FilterPlaylist(data map[string]interface{}, separator string) map[string]interface{} {
 	dataMap := getMap(data, "data")
 	playlistData := getMap(dataMap, "playlistV2")
 	if len(playlistData) == 0 {
@@ -957,21 +957,9 @@ func FilterPlaylist(data map[string]interface{}) map[string]interface{} {
 		avatarData := getMap(ownerData, "avatar")
 		if len(avatarData) > 0 {
 			sources := getSlice(avatarData, "sources")
-			if sources != nil {
-				for _, source := range sources {
-					sourceMap, ok := source.(map[string]interface{})
-					if !ok {
-						continue
-					}
-					if getFloat64(sourceMap, "width") == 300 {
-						avatarURL = getString(sourceMap, "url")
-						break
-					}
-				}
-				if avatarURL == nil && len(sources) > 0 {
-					if firstSource, ok := sources[0].(map[string]interface{}); ok {
-						avatarURL = getString(firstSource, "url")
-					}
+			if len(sources) > 0 {
+				if firstSource, ok := sources[0].(map[string]interface{}); ok {
+					avatarURL = getString(firstSource, "url")
 				}
 			}
 		}
@@ -1075,7 +1063,7 @@ func FilterPlaylist(data map[string]interface{}) map[string]interface{} {
 			for _, artist := range trackArtists {
 				trackArtistNames = append(trackArtistNames, getString(artist, "name"))
 			}
-			artistsString := strings.Join(trackArtistNames, ", ")
+			artistsString := strings.Join(trackArtistNames, separator)
 
 			trackDurationMs := getFloat64(getMap(trackData, "trackDuration"), "totalMilliseconds")
 			durationObj := extractDuration(trackDurationMs)
@@ -1121,7 +1109,7 @@ func FilterPlaylist(data map[string]interface{}) map[string]interface{} {
 					for _, artist := range albumArtists {
 						albumArtistNames = append(albumArtistNames, getString(artist, "name"))
 					}
-					albumArtistsString = strings.Join(albumArtistNames, ", ")
+					albumArtistsString = strings.Join(albumArtistNames, separator)
 				}
 			}
 
@@ -1291,11 +1279,11 @@ func extractDiscographyItems(itemsData map[string]interface{}) []map[string]inte
 }
 
 func stripHTMLTags(s string) string {
-	re := regexp.MustCompile(`<[^>]*>`)
+	re := regexp.MustCompile(`(?s)<[^>]*>`)
 	return re.ReplaceAllString(s, "")
 }
 
-func FilterArtist(data map[string]interface{}) map[string]interface{} {
+func FilterArtist(data map[string]interface{}, separator string) map[string]interface{} {
 	dataMap := getMap(data, "data")
 	artistData := getMap(dataMap, "artistUnion")
 	if len(artistData) == 0 {
@@ -1424,7 +1412,7 @@ func FilterArtist(data map[string]interface{}) map[string]interface{} {
 	return filtered
 }
 
-func FilterSearch(data map[string]interface{}) map[string]interface{} {
+func FilterSearch(data map[string]interface{}, separator string) map[string]interface{} {
 	dataMap := getMap(data, "data")
 	searchData := getMap(dataMap, "searchV2")
 	if len(searchData) == 0 {
@@ -1514,7 +1502,7 @@ func FilterSearch(data map[string]interface{}) map[string]interface{} {
 			for _, artist := range trackArtists {
 				trackArtistNames = append(trackArtistNames, getString(artist, "name"))
 			}
-			trackArtistsString := strings.Join(trackArtistNames, ", ")
+			trackArtistsString := strings.Join(trackArtistNames, separator)
 
 			durationString := getString(trackDuration, "formatted")
 
@@ -1586,7 +1574,7 @@ func FilterSearch(data map[string]interface{}) map[string]interface{} {
 			for _, artist := range albumArtists {
 				albumArtistNames = append(albumArtistNames, getString(artist, "name"))
 			}
-			albumArtistsString := strings.Join(albumArtistNames, ", ")
+			albumArtistsString := strings.Join(albumArtistNames, separator)
 
 			dateInfo := getMap(album, "date")
 			var year interface{}

backend/spotfetch_api.go

@@ -11,10 +11,37 @@ import (
 	"time"
 )
 
-func GetSpotifyDataWithAPI(ctx context.Context, spotifyURL string, useAPI bool, apiBaseURL string, batch bool, delay time.Duration) (interface{}, error) {
-	if !useAPI || apiBaseURL == "" {
+func streamTrackListChunks(ctx context.Context, tracks []AlbumTrackMetadata, callback MetadataCallback) error {
+	if callback == nil || len(tracks) == 0 {
+		return nil
+	}
 
-		return GetFilteredSpotifyData(ctx, spotifyURL, batch, delay)
+	const chunkSize = 25
+	for start := 0; start < len(tracks); start += chunkSize {
+		select {
+		case <-ctx.Done():
+			return ctx.Err()
+		default:
+		}
+
+		end := start + chunkSize
+		if end > len(tracks) {
+			end = len(tracks)
+		}
+
+		callback(tracks[start:end])
+
+		if end < len(tracks) {
+			time.Sleep(15 * time.Millisecond)
+		}
+	}
+
+	return nil
+}
+
+func GetSpotifyDataWithAPI(ctx context.Context, spotifyURL string, useAPI bool, apiBaseURL string, batch bool, delay time.Duration, separator string, callback MetadataCallback) (interface{}, error) {
+	if !useAPI || apiBaseURL == "" {
+		return GetFilteredSpotifyData(ctx, spotifyURL, batch, delay, separator, callback)
 	}
 
 	spotifyType, id := parseSpotifyURLToTypeAndID(spotifyURL)
@@ -22,6 +49,10 @@ func GetSpotifyDataWithAPI(ctx context.Context, spotifyURL string, useAPI bool,
 		return nil, fmt.Errorf("invalid Spotify URL: %s", spotifyURL)
 	}
 
+	if spotifyType == "artist" {
+		return GetFilteredSpotifyData(ctx, spotifyURL, batch, delay, separator, callback)
+	}
+
 	apiURL := fmt.Sprintf("%s/%s/%s", strings.TrimSuffix(apiBaseURL, "/"), spotifyType, id)
 
 	req, err := http.NewRequestWithContext(ctx, "GET", apiURL, nil)
@@ -63,22 +94,75 @@ func GetSpotifyDataWithAPI(ctx context.Context, spotifyURL string, useAPI bool,
 			return nil, fmt.Errorf("failed to decode album response: %w", err)
 		}
 		data = &albumResp
+		if callback != nil {
+			callback(&AlbumResponsePayload{
+				AlbumInfo: albumResp.AlbumInfo,
+				TrackList: []AlbumTrackMetadata{},
+			})
+			if err := streamTrackListChunks(ctx, albumResp.TrackList, callback); err != nil {
+				return nil, err
+			}
+		}
 	case "playlist":
 		var playlistResp PlaylistResponsePayload
 		if err := json.Unmarshal(bodyBytes, &playlistResp); err != nil {
 			return nil, fmt.Errorf("failed to decode playlist response: %w", err)
 		}
 		data = playlistResp
+		if callback != nil {
+			callback(PlaylistResponsePayload{
+				PlaylistInfo: playlistResp.PlaylistInfo,
+				TrackList:    []AlbumTrackMetadata{},
+			})
+			if err := streamTrackListChunks(ctx, playlistResp.TrackList, callback); err != nil {
+				return nil, err
+			}
+		}
 	case "artist":
 		var artistResp ArtistDiscographyPayload
 		if err := json.Unmarshal(bodyBytes, &artistResp); err != nil {
 			return nil, fmt.Errorf("failed to decode artist response: %w", err)
 		}
 		data = &artistResp
+		if callback != nil {
+			callback(&ArtistDiscographyPayload{
+				ArtistInfo: artistResp.ArtistInfo,
+				AlbumList:  artistResp.AlbumList,
+				TrackList:  []AlbumTrackMetadata{},
+			})
+			if err := streamTrackListChunks(ctx, artistResp.TrackList, callback); err != nil {
+				return nil, err
+			}
+		}
 	default:
 		return nil, fmt.Errorf("unsupported Spotify type: %s", spotifyType)
 	}
 
+	if callback != nil {
+		switch payload := data.(type) {
+		case TrackResponse:
+			t := payload.Track
+			callback([]AlbumTrackMetadata{{
+				SpotifyID:   t.SpotifyID,
+				Artists:     t.Artists,
+				Name:        t.Name,
+				AlbumName:   t.AlbumName,
+				AlbumArtist: t.AlbumArtist,
+				DurationMS:  t.DurationMS,
+				Images:      t.Images,
+				ReleaseDate: t.ReleaseDate,
+				TrackNumber: t.TrackNumber,
+				TotalTracks: t.TotalTracks,
+				DiscNumber:  t.DiscNumber,
+				TotalDiscs:  t.TotalDiscs,
+				ExternalURL: t.ExternalURL,
+				Plays:       t.Plays,
+				PreviewURL:  t.PreviewURL,
+				IsExplicit:  t.IsExplicit,
+			}})
+		}
+	}
+
 	return data, nil
 }
 

backend/spotify_metadata.go

@@ -18,13 +18,17 @@ var (
 	errInvalidSpotifyURL = errors.New("invalid or unsupported Spotify URL")
 )
 
+type MetadataCallback func(data interface{})
+
 type SpotifyMetadataClient struct {
 	httpClient *http.Client
+	Separator  string
 }
 
 func NewSpotifyMetadataClient() *SpotifyMetadataClient {
 	return &SpotifyMetadataClient{
 		httpClient: &http.Client{Timeout: 30 * time.Second},
+		Separator:  ", ",
 	}
 }
 
@@ -342,54 +346,57 @@ type SearchResponse struct {
 	Playlists []SearchResult `json:"playlists"`
 }
 
-func GetFilteredSpotifyData(ctx context.Context, spotifyURL string, batch bool, delay time.Duration) (interface{}, error) {
+func GetFilteredSpotifyData(ctx context.Context, spotifyURL string, batch bool, delay time.Duration, separator string, callback MetadataCallback) (interface{}, error) {
 	client := NewSpotifyMetadataClient()
-	return client.GetFilteredData(ctx, spotifyURL, batch, delay)
+	if separator != "" {
+		client.Separator = separator
+	}
+	return client.GetFilteredData(ctx, spotifyURL, batch, delay, callback)
 }
 
-func (c *SpotifyMetadataClient) GetFilteredData(ctx context.Context, spotifyURL string, batch bool, delay time.Duration) (interface{}, error) {
+func (c *SpotifyMetadataClient) GetFilteredData(ctx context.Context, spotifyURL string, batch bool, delay time.Duration, callback MetadataCallback) (interface{}, error) {
 	parsed, err := parseSpotifyURI(spotifyURL)
 	if err != nil {
 		return nil, err
 	}
 
-	raw, err := c.getRawSpotifyData(ctx, parsed, batch, delay)
+	raw, err := c.getRawSpotifyData(ctx, parsed, batch, delay, callback)
 	if err != nil {
 		return nil, err
 	}
 
-	return c.processSpotifyData(ctx, raw)
+	return c.processSpotifyData(ctx, raw, callback)
 }
 
-func (c *SpotifyMetadataClient) getRawSpotifyData(ctx context.Context, parsed spotifyURI, batch bool, delay time.Duration) (interface{}, error) {
+func (c *SpotifyMetadataClient) getRawSpotifyData(ctx context.Context, parsed spotifyURI, batch bool, delay time.Duration, callback MetadataCallback) (interface{}, error) {
 	switch parsed.Type {
 	case "playlist":
-		return c.fetchPlaylist(ctx, parsed.ID)
+		return c.fetchPlaylist(ctx, parsed.ID, callback)
 	case "album":
-		return c.fetchAlbum(ctx, parsed.ID)
+		return c.fetchAlbum(ctx, parsed.ID, callback)
 	case "track":
 		return c.fetchTrack(ctx, parsed.ID)
 	case "artist_discography":
-		return c.fetchArtistDiscography(ctx, parsed)
+		return c.fetchArtistDiscography(ctx, parsed, callback)
 	case "artist":
 
 		discographyParsed := spotifyURI{Type: "artist_discography", ID: parsed.ID, DiscographyGroup: "all"}
-		return c.fetchArtistDiscography(ctx, discographyParsed)
+		return c.fetchArtistDiscography(ctx, discographyParsed, callback)
 	default:
 		return nil, fmt.Errorf("unsupported Spotify type: %s", parsed.Type)
 	}
 }
 
-func (c *SpotifyMetadataClient) processSpotifyData(ctx context.Context, raw interface{}) (interface{}, error) {
+func (c *SpotifyMetadataClient) processSpotifyData(ctx context.Context, raw interface{}, callback MetadataCallback) (interface{}, error) {
 	switch payload := raw.(type) {
 	case *apiPlaylistResponse:
-		return c.formatPlaylistData(payload), nil
+		return c.formatPlaylistData(payload, callback), nil
 	case *apiAlbumResponse:
-		return c.formatAlbumData(payload)
+		return c.formatAlbumData(payload, callback)
 	case *apiTrackResponse:
 		return c.formatTrackData(payload), nil
 	case *apiArtistResponse:
-		return c.formatArtistDiscographyData(ctx, payload)
+		return c.formatArtistDiscographyData(ctx, payload, callback)
 	default:
 		return nil, errors.New("unknown raw payload type")
 	}
@@ -437,7 +444,7 @@ func (c *SpotifyMetadataClient) fetchTrack(ctx context.Context, trackID string)
 
 				if albumID != "" {
 
-					albumResponse, err := c.fetchAlbumWithClient(ctx, client, albumID)
+					albumResponse, err := c.fetchAlbumWithClient(ctx, client, albumID, nil)
 					if err == nil && albumResponse != nil {
 
 						albumJSON, _ := json.Marshal(albumResponse)
@@ -482,7 +489,7 @@ func (c *SpotifyMetadataClient) fetchTrack(ctx context.Context, trackID string)
 		}
 	}
 
-	filteredData := FilterTrack(data, albumFetchData)
+	filteredData := FilterTrack(data, c.Separator, albumFetchData)
 
 	jsonData, err := json.Marshal(filteredData)
 	if err != nil {
@@ -497,15 +504,15 @@ func (c *SpotifyMetadataClient) fetchTrack(ctx context.Context, trackID string)
 	return &result, nil
 }
 
-func (c *SpotifyMetadataClient) fetchAlbum(ctx context.Context, albumID string) (*apiAlbumResponse, error) {
+func (c *SpotifyMetadataClient) fetchAlbum(ctx context.Context, albumID string, callback MetadataCallback) (*apiAlbumResponse, error) {
 	client := NewSpotifyClient()
 	if err := client.Initialize(); err != nil {
 		return nil, fmt.Errorf("failed to initialize spotify client: %w", err)
 	}
-	return c.fetchAlbumWithClient(ctx, client, albumID)
+	return c.fetchAlbumWithClient(ctx, client, albumID, callback)
 }
 
-func (c *SpotifyMetadataClient) fetchAlbumWithClient(ctx context.Context, client *SpotifyClient, albumID string) (*apiAlbumResponse, error) {
+func (c *SpotifyMetadataClient) fetchAlbumWithClient(ctx context.Context, client *SpotifyClient, albumID string, callback MetadataCallback) (*apiAlbumResponse, error) {
 
 	allItems := []interface{}{}
 	offset := 0
@@ -537,6 +544,15 @@ func (c *SpotifyMetadataClient) fetchAlbumWithClient(ctx context.Context, client
 
 		if data == nil {
 			data = response
+			if callback != nil {
+				filtered := FilterAlbum(data, c.Separator)
+				jsonData, _ := json.Marshal(filtered)
+				var result apiAlbumResponse
+				if json.Unmarshal(jsonData, &result) == nil {
+					formatted, _ := c.formatAlbumData(&result, nil)
+					callback(formatted)
+				}
+			}
 		}
 
 		albumData := getMap(getMap(response, "data"), "albumUnion")
@@ -579,7 +595,7 @@ func (c *SpotifyMetadataClient) fetchAlbumWithClient(ctx context.Context, client
 		tracksV2["totalCount"] = len(allItems)
 	}
 
-	filteredData := FilterAlbum(data)
+	filteredData := FilterAlbum(data, c.Separator)
 
 	jsonData, err := json.Marshal(filteredData)
 	if err != nil {
@@ -594,7 +610,7 @@ func (c *SpotifyMetadataClient) fetchAlbumWithClient(ctx context.Context, client
 	return &result, nil
 }
 
-func (c *SpotifyMetadataClient) fetchPlaylist(ctx context.Context, playlistID string) (*apiPlaylistResponse, error) {
+func (c *SpotifyMetadataClient) fetchPlaylist(ctx context.Context, playlistID string, callback MetadataCallback) (*apiPlaylistResponse, error) {
 	client := NewSpotifyClient()
 	if err := client.Initialize(); err != nil {
 		return nil, fmt.Errorf("failed to initialize spotify client: %w", err)
@@ -630,6 +646,15 @@ func (c *SpotifyMetadataClient) fetchPlaylist(ctx context.Context, playlistID st
 
 		if data == nil {
 			data = response
+			if callback != nil {
+				filtered := FilterPlaylist(data, c.Separator)
+				jsonData, _ := json.Marshal(filtered)
+				var result apiPlaylistResponse
+				if json.Unmarshal(jsonData, &result) == nil {
+					formatted := c.formatPlaylistData(&result, nil)
+					callback(formatted)
+				}
+			}
 		}
 
 		playlistData := getMap(getMap(response, "data"), "playlistV2")
@@ -672,7 +697,7 @@ func (c *SpotifyMetadataClient) fetchPlaylist(ctx context.Context, playlistID st
 		content["totalCount"] = len(allItems)
 	}
 
-	filteredData := FilterPlaylist(data)
+	filteredData := FilterPlaylist(data, c.Separator)
 
 	jsonData, err := json.Marshal(filteredData)
 	if err != nil {
@@ -687,7 +712,7 @@ func (c *SpotifyMetadataClient) fetchPlaylist(ctx context.Context, playlistID st
 	return &result, nil
 }
 
-func (c *SpotifyMetadataClient) fetchArtistDiscography(ctx context.Context, parsed spotifyURI) (*apiArtistResponse, error) {
+func (c *SpotifyMetadataClient) fetchArtistDiscography(ctx context.Context, parsed spotifyURI, callback MetadataCallback) (*apiArtistResponse, error) {
 	client := NewSpotifyClient()
 	if err := client.Initialize(); err != nil {
 		return nil, fmt.Errorf("failed to initialize spotify client: %w", err)
@@ -712,6 +737,16 @@ func (c *SpotifyMetadataClient) fetchArtistDiscography(ctx context.Context, pars
 		return nil, fmt.Errorf("failed to query artist overview: %w", err)
 	}
 
+	if callback != nil {
+		filtered := FilterArtist(data, c.Separator)
+		jsonData, _ := json.Marshal(filtered)
+		var result apiArtistResponse
+		if json.Unmarshal(jsonData, &result) == nil {
+			formatted, _ := c.formatArtistDiscographyData(ctx, &result, nil)
+			callback(formatted)
+		}
+	}
+
 	allDiscographyItems := []interface{}{}
 	offset := 0
 	limit := 50
@@ -841,7 +876,7 @@ func (c *SpotifyMetadataClient) fetchArtistDiscography(ctx context.Context, pars
 		}
 	}
 
-	filteredData := FilterArtist(data)
+	filteredData := FilterArtist(data, c.Separator)
 
 	jsonData, err := json.Marshal(filteredData)
 	if err != nil {
@@ -898,7 +933,7 @@ func (c *SpotifyMetadataClient) formatTrackData(raw *apiTrackResponse) TrackResp
 	}
 }
 
-func (c *SpotifyMetadataClient) formatAlbumData(raw *apiAlbumResponse) (*AlbumResponsePayload, error) {
+func (c *SpotifyMetadataClient) formatAlbumData(raw *apiAlbumResponse, callback MetadataCallback) (*AlbumResponsePayload, error) {
 	var artistID, artistURL string
 
 	info := AlbumInfoMetadata{
@@ -911,6 +946,13 @@ func (c *SpotifyMetadataClient) formatAlbumData(raw *apiAlbumResponse) (*AlbumRe
 		ArtistURL:   artistURL,
 	}
 
+	if callback != nil {
+		callback(AlbumResponsePayload{
+			AlbumInfo: info,
+			TrackList: []AlbumTrackMetadata{},
+		})
+	}
+
 	tracks := make([]AlbumTrackMetadata, 0, len(raw.Tracks))
 	for idx, item := range raw.Tracks {
 		durationMS := parseDuration(item.Duration)
@@ -955,13 +997,17 @@ func (c *SpotifyMetadataClient) formatAlbumData(raw *apiAlbumResponse) (*AlbumRe
 		})
 	}
 
+	if callback != nil {
+		callback(tracks)
+	}
+
 	return &AlbumResponsePayload{
 		AlbumInfo: info,
 		TrackList: tracks,
 	}, nil
 }
 
-func (c *SpotifyMetadataClient) formatPlaylistData(raw *apiPlaylistResponse) PlaylistResponsePayload {
+func (c *SpotifyMetadataClient) formatPlaylistData(raw *apiPlaylistResponse, callback MetadataCallback) PlaylistResponsePayload {
 	var info PlaylistInfoMetadata
 	info.Tracks.Total = raw.Count
 	info.Followers.Total = raw.Followers
@@ -971,6 +1017,13 @@ func (c *SpotifyMetadataClient) formatPlaylistData(raw *apiPlaylistResponse) Pla
 	info.Cover = raw.Cover
 	info.Description = raw.Description
 
+	if callback != nil {
+		callback(PlaylistResponsePayload{
+			PlaylistInfo: info,
+			TrackList:    []AlbumTrackMetadata{},
+		})
+	}
+
 	tracks := make([]AlbumTrackMetadata, 0, len(raw.Tracks))
 	for _, item := range raw.Tracks {
 		durationMS := parseDuration(item.Duration)
@@ -1015,13 +1068,17 @@ func (c *SpotifyMetadataClient) formatPlaylistData(raw *apiPlaylistResponse) Pla
 		})
 	}
 
+	if callback != nil {
+		callback(tracks)
+	}
+
 	return PlaylistResponsePayload{
 		PlaylistInfo: info,
 		TrackList:    tracks,
 	}
 }
 
-func (c *SpotifyMetadataClient) formatArtistDiscographyData(ctx context.Context, raw *apiArtistResponse) (*ArtistDiscographyPayload, error) {
+func (c *SpotifyMetadataClient) formatArtistDiscographyData(ctx context.Context, raw *apiArtistResponse, callback MetadataCallback) (*ArtistDiscographyPayload, error) {
 	discType := "all"
 
 	info := ArtistInfoMetadata{
@@ -1067,7 +1124,17 @@ func (c *SpotifyMetadataClient) formatArtistDiscographyData(ctx context.Context,
 			Images:      alb.Cover,
 			ExternalURL: fmt.Sprintf("https://open.spotify.com/album/%s", alb.ID),
 		})
+	}
 
+	if callback != nil {
+		callback(ArtistDiscographyPayload{
+			ArtistInfo: info,
+			AlbumList:  albumList,
+			TrackList:  []AlbumTrackMetadata{},
+		})
+	}
+
+	for _, alb := range raw.Discography.All {
 		go func(albumID string, albumName string) {
 			sem <- struct{}{}
 
@@ -1081,7 +1148,7 @@ func (c *SpotifyMetadataClient) formatArtistDiscographyData(ctx context.Context,
 			default:
 			}
 
-			albumData, err := c.fetchAlbumWithClient(ctx, sharedClient, albumID)
+			albumData, err := c.fetchAlbumWithClient(ctx, sharedClient, albumID, nil)
 			if err != nil {
 				fmt.Printf("Error getting tracks for album %s: %v\n", albumName, err)
 				resultsChan <- fetchResult{tracks: []AlbumTrackMetadata{}}
@@ -1131,6 +1198,9 @@ func (c *SpotifyMetadataClient) formatArtistDiscographyData(ctx context.Context,
 					IsExplicit:  tr.IsExplicit,
 				})
 			}
+			if callback != nil {
+				callback(tracks)
+			}
 			resultsChan <- fetchResult{tracks: tracks}
 		}(alb.ID, alb.Name)
 	}
@@ -1290,7 +1360,7 @@ func (c *SpotifyMetadataClient) Search(ctx context.Context, query string, limit
 		return nil, fmt.Errorf("failed to query search: %w", err)
 	}
 
-	filteredData := FilterSearch(data)
+	filteredData := FilterSearch(data, c.Separator)
 
 	jsonData, err := json.Marshal(filteredData)
 	if err != nil {
@@ -1407,7 +1477,7 @@ func (c *SpotifyMetadataClient) SearchByType(ctx context.Context, query string,
 		return nil, fmt.Errorf("failed to query search: %w", err)
 	}
 
-	filteredData := FilterSearch(data)
+	filteredData := FilterSearch(data, c.Separator)
 
 	jsonData, err := json.Marshal(filteredData)
 	if err != nil {

backend/system_unix.go

@@ -1,41 +0,0 @@
-//go:build !windows
-
-package backend
-
-import (
-	"fmt"
-	"os/exec"
-	"runtime"
-	"strings"
-)
-
-func GetOSInfo() (string, error) {
-	osType := runtime.GOOS
-	arch := runtime.GOARCH
-
-	switch osType {
-	case "darwin":
-		out, err := exec.Command("sw_vers", "-productVersion").Output()
-		if err != nil {
-			return fmt.Sprintf("macOS %s", arch), nil
-		}
-		version := strings.TrimSpace(string(out))
-		return fmt.Sprintf("macOS %s (%s)", version, arch), nil
-
-	case "linux":
-		out, err := exec.Command("cat", "/etc/os-release").Output()
-		if err == nil {
-			lines := strings.Split(string(out), "\n")
-			for _, line := range lines {
-				if strings.HasPrefix(line, "PRETTY_NAME=") {
-					name := strings.Trim(strings.TrimPrefix(line, "PRETTY_NAME="), "\"")
-					return fmt.Sprintf("%s (%s)", name, arch), nil
-				}
-			}
-		}
-		return fmt.Sprintf("Linux %s", arch), nil
-
-	default:
-		return fmt.Sprintf("%s %s", osType, arch), nil
-	}
-}

backend/system_windows.go

@@ -1,41 +0,0 @@
-package backend
-
-import (
-	"fmt"
-	"os/exec"
-	"runtime"
-	"strings"
-	"syscall"
-)
-
-func GetOSInfo() (string, error) {
-	arch := runtime.GOARCH
-
-	cmd := exec.Command("wmic", "os", "get", "Caption,Version", "/value")
-	cmd.SysProcAttr = &syscall.SysProcAttr{HideWindow: true}
-	out, err := cmd.Output()
-	if err != nil {
-		cmdVer := exec.Command("cmd", "/c", "ver")
-		cmdVer.SysProcAttr = &syscall.SysProcAttr{HideWindow: true}
-		outVer, errVer := cmdVer.Output()
-		if errVer != nil {
-			return fmt.Sprintf("Windows %s", arch), nil
-		}
-		return strings.TrimSpace(string(outVer)), nil
-	}
-
-	lines := strings.Split(string(out), "\n")
-	var caption, version string
-	for _, line := range lines {
-		line = strings.TrimSpace(line)
-		if strings.HasPrefix(line, "Caption=") {
-			caption = strings.TrimPrefix(line, "Caption=")
-		} else if strings.HasPrefix(line, "Version=") {
-			version = strings.TrimPrefix(line, "Version=")
-		}
-	}
-	if caption != "" && version != "" {
-		return fmt.Sprintf("%s (%s, %s)", caption, version, arch), nil
-	}
-	return strings.TrimSpace(string(out)), nil
-}

backend/tidal.go

@@ -6,9 +6,7 @@ import (
 	"encoding/xml"
 	"fmt"
 	"io"
-	"math/rand"
 	"net/http"
-	"net/url"
 	"os"
 	"os/exec"
 	"path/filepath"
@@ -79,55 +77,29 @@ func NewTidalDownloader(apiURL string) *TidalDownloader {
 
 func (t *TidalDownloader) GetAvailableAPIs() ([]string, error) {
 	apis := []string{
-		"https://triton.squid.wtf",
 		"https://hifi-one.spotisaver.net",
 		"https://hifi-two.spotisaver.net",
+		"https://eu-central.monochrome.tf",
+		"https://us-west.monochrome.tf",
+		"https://api.monochrome.tf",
+		"https://monochrome-api.samidy.com",
+		"https://tidal.kinoplus.online",
 	}
-	return apis, nil
+	return prioritizeProviders("tidal", apis), nil
 }
 
 func (t *TidalDownloader) GetTidalURLFromSpotify(spotifyTrackID string) (string, error) {
-
-	spotifyBase := "https://open.spotify.com/track/"
-	spotifyURL := fmt.Sprintf("%s%s", spotifyBase, spotifyTrackID)
-
-	apiBase := "https://api.song.link/v1-alpha.1/links?url="
-	apiURL := fmt.Sprintf("%s%s", apiBase, url.QueryEscape(spotifyURL))
-
-	req, err := http.NewRequest("GET", apiURL, nil)
-	if err != nil {
-		return "", fmt.Errorf("failed to create request: %w", err)
-	}
-
-	req.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36")
-
 	fmt.Println("Getting Tidal URL...")
-
-	resp, err := t.client.Do(req)
+	client := NewSongLinkClient()
+	urls, err := client.GetAllURLsFromSpotify(spotifyTrackID, "")
 	if err != nil {
 		return "", fmt.Errorf("failed to get Tidal URL: %w", err)
 	}
-	defer resp.Body.Close()
 
-	if resp.StatusCode != 200 {
-		return "", fmt.Errorf("API returned status %d", resp.StatusCode)
-	}
-
-	var songLinkResp struct {
-		LinksByPlatform map[string]struct {
-			URL string `json:"url"`
-		} `json:"linksByPlatform"`
-	}
-	if err := json.NewDecoder(resp.Body).Decode(&songLinkResp); err != nil {
-		return "", fmt.Errorf("failed to decode response: %w", err)
-	}
-
-	tidalLink, ok := songLinkResp.LinksByPlatform["tidal"]
-	if !ok || tidalLink.URL == "" {
+	tidalURL := urls.TidalURL
+	if tidalURL == "" {
 		return "", fmt.Errorf("tidal link not found")
 	}
-
-	tidalURL := tidalLink.URL
 	fmt.Printf("Found Tidal URL: %s\n", tidalURL)
 	return tidalURL, nil
 }
@@ -579,6 +551,7 @@ func (t *TidalDownloader) DownloadByURL(tidalURL, outputDir, quality, filenameFo
 		DiscNumber:  spotifyDiscNumber,
 		TotalDiscs:  spotifyTotalDiscs,
 		URL:         spotifyURL,
+		Comment:     spotifyURL,
 		Copyright:   spotifyCopyright,
 		Publisher:   spotifyPublisher,
 		Description: "https://github.com/afkarxyz/SpotiFLAC",
@@ -738,6 +711,7 @@ func (t *TidalDownloader) DownloadByURLWithFallback(tidalURL, outputDir, quality
 		DiscNumber:  spotifyDiscNumber,
 		TotalDiscs:  spotifyTotalDiscs,
 		URL:         spotifyURL,
+		Comment:     spotifyURL,
 		Copyright:   spotifyCopyright,
 		Publisher:   spotifyPublisher,
 		Description: "https://github.com/afkarxyz/SpotiFLAC",
@@ -933,15 +907,13 @@ func getDownloadURLRotated(apis []string, trackID int64, quality string) (string
 		return "", "", fmt.Errorf("no APIs available")
 	}
 
-	rand.Seed(time.Now().UnixNano())
-	rand.Shuffle(len(apis), func(i, j int) { apis[i], apis[j] = apis[j], apis[i] })
-
-	fmt.Printf("Rotating through %d APIs...\n", len(apis))
+	orderedAPIs := prioritizeProviders("tidal", apis)
+	fmt.Printf("Trying %d prioritized APIs...\n", len(orderedAPIs))
 
 	var lastError error
 	var errors []string
 
-	for _, apiURL := range apis {
+	for _, apiURL := range orderedAPIs {
 		fmt.Printf("Trying API: %s\n", apiURL)
 
 		client := &http.Client{
@@ -952,6 +924,7 @@ func getDownloadURLRotated(apis []string, trackID int64, quality string) (string
 		resp, err := client.Get(url)
 		if err != nil {
 			lastError = err
+			recordProviderFailure("tidal", apiURL)
 			errors = append(errors, fmt.Sprintf("%s: %v", apiURL, err))
 			continue
 		}
@@ -959,6 +932,7 @@ func getDownloadURLRotated(apis []string, trackID int64, quality string) (string
 		if resp.StatusCode != 200 {
 			resp.Body.Close()
 			lastError = fmt.Errorf("HTTP %d", resp.StatusCode)
+			recordProviderFailure("tidal", apiURL)
 			errors = append(errors, fmt.Sprintf("%s: %v", apiURL, lastError))
 			continue
 		}
@@ -967,6 +941,7 @@ func getDownloadURLRotated(apis []string, trackID int64, quality string) (string
 		resp.Body.Close()
 		if err != nil {
 			lastError = err
+			recordProviderFailure("tidal", apiURL)
 			errors = append(errors, fmt.Sprintf("%s: read body failed", apiURL))
 			continue
 		}
@@ -974,6 +949,7 @@ func getDownloadURLRotated(apis []string, trackID int64, quality string) (string
 		var v2Response TidalAPIResponseV2
 		if err := json.Unmarshal(body, &v2Response); err == nil && v2Response.Data.Manifest != "" {
 			fmt.Printf("✓ Success with: %s\n", apiURL)
+			recordProviderSuccess("tidal", apiURL)
 			return apiURL, "MANIFEST:" + v2Response.Data.Manifest, nil
 		}
 
@@ -982,12 +958,14 @@ func getDownloadURLRotated(apis []string, trackID int64, quality string) (string
 			for _, item := range v1Responses {
 				if item.OriginalTrackURL != "" {
 					fmt.Printf("✓ Success with: %s\n", apiURL)
+					recordProviderSuccess("tidal", apiURL)
 					return apiURL, item.OriginalTrackURL, nil
 				}
 			}
 		}
 
 		lastError = fmt.Errorf("no download URL or manifest in response")
+		recordProviderFailure("tidal", apiURL)
 		errors = append(errors, fmt.Sprintf("%s: %v", apiURL, lastError))
 	}
 

backend/uploader.go

@@ -1,217 +0,0 @@
-package backend
-
-import (
-	"bytes"
-	"encoding/json"
-	"fmt"
-	"io"
-	"mime/multipart"
-	"net/http"
-	"os"
-	"path/filepath"
-	"regexp"
-	"strings"
-	"time"
-)
-
-type SendNowResponse []struct {
-	FileCode string `json:"file_code"`
-}
-
-func UploadToSendNow(filePath string) (string, error) {
-	file, err := os.Open(filePath)
-	if err != nil {
-		return "", fmt.Errorf("failed to open file: %v", err)
-	}
-	defer file.Close()
-
-	return uploadToService(filepath.Base(filePath), file)
-}
-
-func UploadBytesToSendNow(filename string, data []byte) (string, error) {
-	return uploadToService(filename, bytes.NewReader(data))
-}
-
-func uploadToService(filename string, fileReader io.Reader) (string, error) {
-	body := &bytes.Buffer{}
-	writer := multipart.NewWriter(body)
-
-	fields := map[string]string{
-		"sess_id":          "",
-		"utype":            "anon",
-		"hidden":           "",
-		"enableemail":      "",
-		"link_rcpt":        "",
-		"link_pass":        "",
-		"file_expire_time": "",
-		"file_expire_unit": "DAY",
-		"file_max_dl":      "1",
-		"file_public":      "1",
-		"keepalive":        "1",
-	}
-
-	for key, val := range fields {
-		if err := writer.WriteField(key, val); err != nil {
-			return "", err
-		}
-	}
-
-	part, err := writer.CreateFormFile("file_0", filename)
-	if err != nil {
-		return "", err
-	}
-	if _, err := io.Copy(part, fileReader); err != nil {
-		return "", err
-	}
-
-	writer.Close()
-
-	uploadURL, err := getUploadURL()
-	if err != nil {
-		return "", fmt.Errorf("failed to get upload server: %v", err)
-	}
-
-	req, err := http.NewRequest("POST", uploadURL, body)
-	if err != nil {
-		return "", err
-	}
-
-	req.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36")
-	req.Header.Set("Origin", "https://send.now")
-	req.Header.Set("Referer", "https://send.now/")
-	req.Header.Set("Content-Type", writer.FormDataContentType())
-
-	client := &http.Client{Timeout: 60 * time.Second}
-	resp, err := client.Do(req)
-	if err != nil {
-		return "", fmt.Errorf("upload failed: %v", err)
-	}
-	defer resp.Body.Close()
-
-	if resp.StatusCode != 200 {
-		respBytes, _ := io.ReadAll(resp.Body)
-		return "", fmt.Errorf("server error %d: %s", resp.StatusCode, string(respBytes))
-	}
-
-	respBytes, err := io.ReadAll(resp.Body)
-	if err != nil {
-		return "", err
-	}
-
-	var result SendNowResponse
-	if err := json.Unmarshal(respBytes, &result); err != nil {
-		return "", fmt.Errorf("failed to parse response: %v, raw: %s", err, string(respBytes))
-	}
-
-	if len(result) == 0 || result[0].FileCode == "" {
-		return "", fmt.Errorf("invalid response format")
-	}
-
-	fileCode := result[0].FileCode
-	downloadLink := fmt.Sprintf("https://send.now/%s", fileCode)
-
-	ext := strings.ToLower(filepath.Ext(filename))
-	if ext == ".mp4" || ext == ".mov" || ext == ".mkv" || ext == ".webm" || ext == ".avi" {
-		return fmt.Sprintf("[Video](%s)", downloadLink), nil
-	}
-
-	return fetchDirectImageLink(downloadLink)
-}
-
-func getUploadURL() (string, error) {
-	req, err := http.NewRequest("GET", "https://send.now/", nil)
-	if err != nil {
-		return "", err
-	}
-	req.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36")
-
-	client := &http.Client{Timeout: 30 * time.Second}
-	resp, err := client.Do(req)
-	if err != nil {
-		return "", err
-	}
-	defer resp.Body.Close()
-
-	if resp.StatusCode != 200 {
-		return "", fmt.Errorf("failed to fetch main page: status %d", resp.StatusCode)
-	}
-
-	bodyBytes, err := io.ReadAll(resp.Body)
-	if err != nil {
-		return "", err
-	}
-	body := string(bodyBytes)
-
-	re := regexp.MustCompile(`action=["'](https://[^"']+/cgi-bin/upload\.cgi\?upload_type=file[^"']*)["']`)
-	matches := re.FindStringSubmatch(body)
-	if len(matches) > 1 {
-		return matches[1], nil
-	}
-
-	reFallback := regexp.MustCompile(`action=["'](https://[^"']+/cgi-bin/upload\.cgi)`)
-	matchesFallback := reFallback.FindStringSubmatch(body)
-	if len(matchesFallback) > 1 {
-		return matchesFallback[1] + "?upload_type=file&utype=anon", nil
-	}
-
-	return "", fmt.Errorf("upload URL not found in main page")
-}
-
-func fetchDirectImageLink(url string) (string, error) {
-	req, err := http.NewRequest("GET", url, nil)
-	if err != nil {
-		return "", err
-	}
-	req.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36")
-
-	client := &http.Client{Timeout: 30 * time.Second}
-	resp, err := client.Do(req)
-	if err != nil {
-		return "", err
-	}
-	defer resp.Body.Close()
-
-	htmlBytes, err := io.ReadAll(resp.Body)
-	if err != nil {
-		return "", err
-	}
-	htmlStr := string(htmlBytes)
-
-	reFullRes := regexp.MustCompile(`(?i)<a[^>]+href=["']([^"']+)["'][^>]*title=["']Open image on new tab["']`)
-	matchesFull := reFullRes.FindStringSubmatch(htmlStr)
-	if len(matchesFull) > 1 {
-		return fmt.Sprintf("![image](%s)", matchesFull[1]), nil
-	}
-
-	reClipboard := regexp.MustCompile(`(?s)data-clipboard-text=['"]<a href="[^"]+".*?><img src="([^"]+)"`)
-	matches := reClipboard.FindStringSubmatch(htmlStr)
-	if len(matches) > 1 {
-		return fmt.Sprintf("![image](%s)", matches[1]), nil
-	}
-
-	reImg := regexp.MustCompile(`(?i)<img[^>]+src=["']([^"']*?\.send\.now/i/[^"']+)["']`)
-	matchesImg := reImg.FindStringSubmatch(htmlStr)
-	if len(matchesImg) > 1 {
-		return fmt.Sprintf("![image](%s)", matchesImg[1]), nil
-	}
-
-	reAnchor := regexp.MustCompile(`(?i)<a[^>]+href=["']([^"']+\.(?:jpg|jpeg|png|gif|webp))["']`)
-	matchesAnchor := reAnchor.FindStringSubmatch(htmlStr)
-	if len(matchesAnchor) > 1 {
-		return fmt.Sprintf("![image](%s)", matchesAnchor[1]), nil
-	}
-
-	reGeneric := regexp.MustCompile(`(?i)<img[^>]+src=["']([^"']+\.(?:jpg|jpeg|png|gif|webp))["']`)
-	matchesGeneric := reGeneric.FindAllStringSubmatch(htmlStr, -1)
-	for _, match := range matchesGeneric {
-		if len(match) > 1 {
-			link := match[1]
-
-			if !regexp.MustCompile(`(?i)(logo|icon|button|assets)`).MatchString(filepath.Base(link)) {
-				return fmt.Sprintf("![image](%s)", link), nil
-			}
-		}
-	}
-
-	return fmt.Sprintf("[View File](%s)", url), nil
-}

frontend/package.json

@@ -32,6 +32,7 @@
     "lucide-react": "^0.575.0",
     "motion": "^12.34.3",
     "next-themes": "^0.4.6",
+    "radix-ui": "^1.4.3",
     "react": "^19.2.4",
     "react-dom": "^19.2.4",
     "sonner": "^2.0.7",

frontend/package.json.md5

@@ -1 +1 @@
-3ca7ac3e41fb33a6fc3e30c16b39657b
+867c45db7982e126a7249d80210f23be

frontend/pnpm-lock.yaml

@@ -68,6 +68,9 @@ importers:
       next-themes:
         specifier: ^0.4.6
         version: 0.4.6(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
+      radix-ui:
+        specifier: ^1.4.3
+        version: 1.4.3(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
       react:
         specifier: ^19.2.4
         version: 19.2.4
@@ -616,6 +619,45 @@ packages:
   '@radix-ui/primitive@1.1.3':
     resolution: {integrity: sha512-JTF99U/6XIjCBo0wqkU5sK10glYe27MRRsfwoiq5zzOEZLHU3A3KCMa5X/azekYRCJ0HlwI0crAXS/5dEHTzDg==}
 
+  '@radix-ui/react-accessible-icon@1.1.7':
+    resolution: {integrity: sha512-XM+E4WXl0OqUJFovy6GjmxxFyx9opfCAIUku4dlKRd5YEPqt4kALOkQOp0Of6reHuUkJuiPBEc5k0o4z4lTC8A==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-accordion@1.2.12':
+    resolution: {integrity: sha512-T4nygeh9YE9dLRPhAHSeOZi7HBXo+0kYIPJXayZfvWOWA0+n3dESrZbjfDPUABkUNym6Hd+f2IR113To8D2GPA==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-alert-dialog@1.1.15':
+    resolution: {integrity: sha512-oTVLkEw5GpdRe29BqJ0LSDFWI3qu0vR1M0mUkOQWDIUnY/QIkLpgDMWuKxP94c2NAC2LGcgVhG1ImF3jkZ5wXw==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
   '@radix-ui/react-arrow@1.1.7':
     resolution: {integrity: sha512-F+M1tLhO+mlQaOWspE8Wstg+z6PwxwRd8oQ8IXceWz92kfAmalTRf0EjrouQeo7QssEPfCn05B4Ihs1K9WQ/7w==}
     peerDependencies:
@@ -629,6 +671,32 @@ packages:
       '@types/react-dom':
         optional: true
 
+  '@radix-ui/react-aspect-ratio@1.1.7':
+    resolution: {integrity: sha512-Yq6lvO9HQyPwev1onK1daHCHqXVLzPhSVjmsNjCa2Zcxy2f7uJD2itDtxknv6FzAKCwD1qQkeVDmX/cev13n/g==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-avatar@1.1.10':
+    resolution: {integrity: sha512-V8piFfWapM5OmNCXTzVQY+E1rDa53zY+MQ4Y7356v4fFz6vqCyUtIz2rUD44ZEdwg78/jKmMJHj07+C/Z/rcog==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
   '@radix-ui/react-checkbox@1.3.3':
     resolution: {integrity: sha512-wBbpv+NQftHDdG86Qc0pIyXk5IR3tM8Vd0nWLKDcX8nNn4nXFOFwsKuqw2okA/1D/mpaAkmuyndrPJTYDNZtFw==}
     peerDependencies:
@@ -642,6 +710,19 @@ packages:
       '@types/react-dom':
         optional: true
 
+  '@radix-ui/react-collapsible@1.1.12':
+    resolution: {integrity: sha512-Uu+mSh4agx2ib1uIGPP4/CKNULyajb3p92LsVXmH2EHVMTfZWpll88XJ0j4W0z3f8NK1eYl1+Mf/szHPmcHzyA==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
   '@radix-ui/react-collection@1.1.7':
     resolution: {integrity: sha512-Fh9rGN0MoI4ZFUNyfFVNU4y9LUz93u9/0K+yLgA2bwRojxM8JU1DyvvMBabnZPBgMWREAJvU2jjVzq+LrFUglw==}
     peerDependencies:
@@ -730,6 +811,19 @@ packages:
       '@types/react-dom':
         optional: true
 
+  '@radix-ui/react-dropdown-menu@2.1.16':
+    resolution: {integrity: sha512-1PLGQEynI/3OX/ftV54COn+3Sud/Mn8vALg2rWnBLnRaGtJDduNW/22XjlGgPdpcIbiQxjKtb7BkcjP00nqfJw==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
   '@radix-ui/react-focus-guards@1.1.3':
     resolution: {integrity: sha512-0rFg/Rj2Q62NCm62jZw0QX7a3sz6QCQU0LpZdNrJX8byRGaGVTqbrW9jAoIAHyMQqsNpeZ81YgSizOt5WXq0Pw==}
     peerDependencies:
@@ -752,6 +846,32 @@ packages:
       '@types/react-dom':
         optional: true
 
+  '@radix-ui/react-form@0.1.8':
+    resolution: {integrity: sha512-QM70k4Zwjttifr5a4sZFts9fn8FzHYvQ5PiB19O2HsYibaHSVt9fH9rzB0XZo/YcM+b7t/p7lYCT/F5eOeF5yQ==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-hover-card@1.1.15':
+    resolution: {integrity: sha512-qgTkjNT1CfKMoP0rcasmlH2r1DAiYicWsDsufxl940sT2wHNEWWv6FMWIQXWhVdmC1d/HYfbhQx60KYyAtKxjg==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
   '@radix-ui/react-id@1.1.1':
     resolution: {integrity: sha512-kGkGegYIdQsOb4XjsfM97rXsiHaBwco+hFI66oO4s9LU+PLAC5oJ7khdOVFxkhsmlbpUqDAvXw11CluXP+jkHg==}
     peerDependencies:
@@ -761,6 +881,19 @@ packages:
       '@types/react':
         optional: true
 
+  '@radix-ui/react-label@2.1.7':
+    resolution: {integrity: sha512-YT1GqPSL8kJn20djelMX7/cTRp/Y9w5IZHvfxQTVHrOqa2yMl7i/UfMqKRU5V7mEyKTrUVgJXhNQPVCG8PBLoQ==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
   '@radix-ui/react-label@2.1.8':
     resolution: {integrity: sha512-FmXs37I6hSBVDlO4y764TNz1rLgKwjJMQ0EGte6F3Cb3f4bIuHB/iLa/8I9VKkmOy+gNHq8rql3j686ACVV21A==}
     peerDependencies:
@@ -800,6 +933,58 @@ packages:
       '@types/react-dom':
         optional: true
 
+  '@radix-ui/react-navigation-menu@1.2.14':
+    resolution: {integrity: sha512-YB9mTFQvCOAQMHU+C/jVl96WmuWeltyUEpRJJky51huhds5W2FQr1J8D/16sQlf0ozxkPK8uF3niQMdUwZPv5w==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-one-time-password-field@0.1.8':
+    resolution: {integrity: sha512-ycS4rbwURavDPVjCb5iS3aG4lURFDILi6sKI/WITUMZ13gMmn/xGjpLoqBAalhJaDk8I3UbCM5GzKHrnzwHbvg==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-password-toggle-field@0.1.3':
+    resolution: {integrity: sha512-/UuCrDBWravcaMix4TdT+qlNdVwOM1Nck9kWx/vafXsdfj1ChfhOdfi3cy9SGBpWgTXwYCuboT/oYpJy3clqfw==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-popover@1.1.15':
+    resolution: {integrity: sha512-kr0X2+6Yy/vJzLYJUPCZEc8SfQcf+1COFoAqauJm74umQhta9M7lNJHP7QQS3vkvcGLQUbWpMzwrXYwrYztHKA==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
   '@radix-ui/react-popper@1.2.8':
     resolution: {integrity: sha512-0NJQ4LFFUuWkE7Oxf0htBKS6zLkkjBH+hM1uk7Ng705ReR8m/uelduy1DBo0PyBXPKVnBA6YBlU94MBGXrSBCw==}
     peerDependencies:
@@ -865,6 +1050,19 @@ packages:
       '@types/react-dom':
         optional: true
 
+  '@radix-ui/react-progress@1.1.7':
+    resolution: {integrity: sha512-vPdg/tF6YC/ynuBIJlk1mm7Le0VgW6ub6J2UWnTQ7/D23KXcPI1qy+0vBkgKgd38RCMJavBXpB83HPNFMTb0Fg==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
   '@radix-ui/react-progress@1.1.8':
     resolution: {integrity: sha512-+gISHcSPUJ7ktBy9RnTqbdKW78bcGke3t6taawyZ71pio1JewwGSJizycs7rLhGTvMJYCQB1DBK4KQsxs7U8dA==}
     peerDependencies:
@@ -878,6 +1076,19 @@ packages:
       '@types/react-dom':
         optional: true
 
+  '@radix-ui/react-radio-group@1.3.8':
+    resolution: {integrity: sha512-VBKYIYImA5zsxACdisNQ3BjCBfmbGH3kQlnFVqlWU4tXwjy7cGX8ta80BcrO+WJXIn5iBylEH3K6ZTlee//lgQ==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
   '@radix-ui/react-roving-focus@1.1.11':
     resolution: {integrity: sha512-7A6S9jSgm/S+7MdtNDSb+IU859vQqJ/QAtcYQcfFC6W8RS4IxIZDldLR0xqCFZ6DCyrQLjLPsxtTNch5jVA4lA==}
     peerDependencies:
@@ -917,6 +1128,32 @@ packages:
       '@types/react-dom':
         optional: true
 
+  '@radix-ui/react-separator@1.1.7':
+    resolution: {integrity: sha512-0HEb8R9E8A+jZjvmFCy/J4xhbXy3TV+9XSnGJ3KvTtjlIUy/YQ/p6UYZvi7YbeoeXdyU9+Y3scizK6hkY37baA==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-slider@1.3.6':
+    resolution: {integrity: sha512-JPYb1GuM1bxfjMRlNLE+BcmBC8onfCi60Blk7OBqi2MLTFdS+8401U4uFjnwkOr49BLmXxLC6JHkvAsx5OJvHw==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
   '@radix-ui/react-slot@1.2.3':
     resolution: {integrity: sha512-aeNmHnBxbi2St0au6VBVC7JXFlhLlOnvIIlePNniyUNAClzmtAUEY8/pBiK3iHjufOlwA+c20/8jngo7xcrg8A==}
     peerDependencies:
@@ -961,6 +1198,19 @@ packages:
       '@types/react-dom':
         optional: true
 
+  '@radix-ui/react-toast@1.2.15':
+    resolution: {integrity: sha512-3OSz3TacUWy4WtOXV38DggwxoqJK4+eDkNMl5Z/MJZaoUPaP4/9lf81xXMe1I2ReTAptverZUpbPY4wWwWyL5g==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
   '@radix-ui/react-toggle-group@1.1.11':
     resolution: {integrity: sha512-5umnS0T8JQzQT6HbPyO7Hh9dgd82NmS36DQr+X/YJ9ctFNCiiQd6IJAYYZ33LUwm8M+taCz5t2ui29fHZc4Y6Q==}
     peerDependencies:
@@ -987,6 +1237,19 @@ packages:
       '@types/react-dom':
         optional: true
 
+  '@radix-ui/react-toolbar@1.1.11':
+    resolution: {integrity: sha512-4ol06/1bLoFu1nwUqzdD4Y5RZ9oDdKeiHIsntug54Hcr1pgaHiPqHFEaXI1IFP/EsOfROQZ8Mig9VTIRza6Tjg==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
   '@radix-ui/react-tooltip@1.2.8':
     resolution: {integrity: sha512-tY7sVt1yL9ozIxvmbtN5qtmH2krXcBCfjEiCgKGLqunJHvgvZG2Pcl2oQ3kbcZARb1BGEHdkLzcYGO8ynVlieg==}
     peerDependencies:
@@ -1036,6 +1299,15 @@ packages:
       '@types/react':
         optional: true
 
+  '@radix-ui/react-use-is-hydrated@0.1.0':
+    resolution: {integrity: sha512-U+UORVEq+cTnRIaostJv9AGdV3G6Y+zbVd+12e18jQ5A3c0xL03IhnHuiU4UV69wolOQp5GfR58NW/EgdQhwOA==}
+    peerDependencies:
+      '@types/react': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+
   '@radix-ui/react-use-layout-effect@1.1.1':
     resolution: {integrity: sha512-RbJRS4UWQFkzHTTwVymMTUv8EqYhOp8dOOviLj2ugtTiXRaRQS7GLGxZTLL1jWhMeoSCf5zmcZkqTl9IiYfXcQ==}
     peerDependencies:
@@ -1872,6 +2144,19 @@ packages:
     resolution: {integrity: sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==}
     engines: {node: '>=6'}
 
+  radix-ui@1.4.3:
+    resolution: {integrity: sha512-aWizCQiyeAenIdUbqEpXgRA1ya65P13NKn/W8rWkcN0OPkRDxdBVLWnIEDsS2RpwCK2nobI7oMUSmexzTDyAmA==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
   react-dom@19.2.4:
     resolution: {integrity: sha512-AXJdLo8kgMbimY95O2aKQqsz2iWi9jMgKJhRBAxECE4IFxfcazB2LmzloIoibJI3C12IlY20+KFaLv+71bUJeQ==}
     peerDependencies:
@@ -2028,6 +2313,11 @@ packages:
       '@types/react':
         optional: true
 
+  use-sync-external-store@1.6.0:
+    resolution: {integrity: sha512-Pp6GSwGP/NrPIrxVFAIkOQeyw8lFenOHijQWkUTrDvrF4ALqylP2C/KCkeS9dpUM3KvYRQhna5vt7IL95+ZQ9w==}
+    peerDependencies:
+      react: ^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0
+
   vite@7.3.1:
     resolution: {integrity: sha512-w+N7Hifpc3gRjZ63vYBXA56dvvRlNWRczTdmCBBa+CotUzAPf5b7YMdMR/8CQoeYE5LX3W4wj6RYTgonm1b9DA==}
     engines: {node: ^20.19.0 || >=22.12.0}
@@ -2471,6 +2761,46 @@ snapshots:
 
   '@radix-ui/primitive@1.1.3': {}
 
+  '@radix-ui/react-accessible-icon@1.1.7(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)':
+    dependencies:
+      '@radix-ui/react-visually-hidden': 1.2.3(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
+      react: 19.2.4
+      react-dom: 19.2.4(react@19.2.4)
+    optionalDependencies:
+      '@types/react': 19.2.14
+      '@types/react-dom': 19.2.3(@types/react@19.2.14)
+
+  '@radix-ui/react-accordion@1.2.12(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)':
+    dependencies:
+      '@radix-ui/primitive': 1.1.3
+      '@radix-ui/react-collapsible': 1.1.12(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
+      '@radix-ui/react-collection': 1.1.7(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
+      '@radix-ui/react-compose-refs': 1.1.2(@types/react@19.2.14)(react@19.2.4)
+      '@radix-ui/react-context': 1.1.2(@types/react@19.2.14)(react@19.2.4)
+      '@radix-ui/react-direction': 1.1.1(@types/react@19.2.14)(react@19.2.4)
+      '@radix-ui/react-id': 1.1.1(@types/react@19.2.14)(react@19.2.4)
+      '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
+      '@radix-ui/react-use-controllable-state': 1.2.2(@types/react@19.2.14)(react@19.2.4)
+      react: 19.2.4
+      react-dom: 19.2.4(react@19.2.4)
+    optionalDependencies:
+      '@types/react': 19.2.14
+      '@types/react-dom': 19.2.3(@types/react@19.2.14)
+
+  '@radix-ui/react-alert-dialog@1.1.15(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)':
+    dependencies:
+      '@radix-ui/primitive': 1.1.3
+      '@radix-ui/react-compose-refs': 1.1.2(@types/react@19.2.14)(react@19.2.4)
+      '@radix-ui/react-context': 1.1.2(@types/react@19.2.14)(react@19.2.4)
+      '@radix-ui/react-dialog': 1.1.15(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
+      '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
+      '@radix-ui/react-slot': 1.2.3(@types/react@19.2.14)(react@19.2.4)
+      react: 19.2.4
+      react-dom: 19.2.4(react@19.2.4)
+    optionalDependencies:
+      '@types/react': 19.2.14
+      '@types/react-dom': 19.2.3(@types/react@19.2.14)
+
   '@radix-ui/react-arrow@1.1.7(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)':
     dependencies:
       '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
@@ -2480,6 +2810,28 @@ snapshots:
       '@types/react': 19.2.14
       '@types/react-dom': 19.2.3(@types/react@19.2.14)
 
+  '@radix-ui/react-aspect-ratio@1.1.7(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)':
+    dependencies:
+      '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
+      react: 19.2.4
+      react-dom: 19.2.4(react@19.2.4)
+    optionalDependencies:
+      '@types/react': 19.2.14
+      '@types/react-dom': 19.2.3(@types/react@19.2.14)
+
+  '@radix-ui/react-avatar@1.1.10(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)':
+    dependencies:
+      '@radix-ui/react-context': 1.1.2(@types/react@19.2.14)(react@19.2.4)
+      '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
+      '@radix-ui/react-use-callback-ref': 1.1.1(@types/react@19.2.14)(react@19.2.4)
+      '@radix-ui/react-use-is-hydrated': 0.1.0(@types/react@19.2.14)(react@19.2.4)
+      '@radix-ui/react-use-layout-effect': 1.1.1(@types/react@19.2.14)(react@19.2.4)
+      react: 19.2.4
+      react-dom: 19.2.4(react@19.2.4)
+    optionalDependencies:
+      '@types/react': 19.2.14
+      '@types/react-dom': 19.2.3(@types/react@19.2.14)
+
   '@radix-ui/react-checkbox@1.3.3(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)':
     dependencies:
       '@radix-ui/primitive': 1.1.3
@@ -2496,6 +2848,22 @@ snapshots:
       '@types/react': 19.2.14
       '@types/react-dom': 19.2.3(@types/react@19.2.14)
 
+  '@radix-ui/react-collapsible@1.1.12(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)':
+    dependencies:
+      '@radix-ui/primitive': 1.1.3
+      '@radix-ui/react-compose-refs': 1.1.2(@types/react@19.2.14)(react@19.2.4)
+      '@radix-ui/react-context': 1.1.2(@types/react@19.2.14)(react@19.2.4)
+      '@radix-ui/react-id': 1.1.1(@types/react@19.2.14)(react@19.2.4)
+      '@radix-ui/react-presence': 1.1.5(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
+      '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
+      '@radix-ui/react-use-controllable-state': 1.2.2(@types/react@19.2.14)(react@19.2.4)
+      '@radix-ui/react-use-layout-effect': 1.1.1(@types/react@19.2.14)(react@19.2.4)
+      react: 19.2.4
+      react-dom: 19.2.4(react@19.2.4)
+    optionalDependencies:
+      '@types/react': 19.2.14
+      '@types/react-dom': 19.2.3(@types/react@19.2.14)
+
   '@radix-ui/react-collection@1.1.7(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)':
     dependencies:
       '@radix-ui/react-compose-refs': 1.1.2(@types/react@19.2.14)(react@19.2.4)
@@ -2581,6 +2949,21 @@ snapshots:
       '@types/react': 19.2.14
       '@types/react-dom': 19.2.3(@types/react@19.2.14)
 
+  '@radix-ui/react-dropdown-menu@2.1.16(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)':
+    dependencies:
+      '@radix-ui/primitive': 1.1.3
+      '@radix-ui/react-compose-refs': 1.1.2(@types/react@19.2.14)(react@19.2.4)
+      '@radix-ui/react-context': 1.1.2(@types/react@19.2.14)(react@19.2.4)
+      '@radix-ui/react-id': 1.1.1(@types/react@19.2.14)(react@19.2.4)
+      '@radix-ui/react-menu': 2.1.16(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
+      '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
+      '@radix-ui/react-use-controllable-state': 1.2.2(@types/react@19.2.14)(react@19.2.4)
+      react: 19.2.4
+      react-dom: 19.2.4(react@19.2.4)
+    optionalDependencies:
+      '@types/react': 19.2.14
+      '@types/react-dom': 19.2.3(@types/react@19.2.14)
+
   '@radix-ui/react-focus-guards@1.1.3(@types/react@19.2.14)(react@19.2.4)':
     dependencies:
       react: 19.2.4
@@ -2598,6 +2981,37 @@ snapshots:
       '@types/react': 19.2.14
       '@types/react-dom': 19.2.3(@types/react@19.2.14)
 
+  '@radix-ui/react-form@0.1.8(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)':
+    dependencies:
+      '@radix-ui/primitive': 1.1.3
+      '@radix-ui/react-compose-refs': 1.1.2(@types/react@19.2.14)(react@19.2.4)
+      '@radix-ui/react-context': 1.1.2(@types/react@19.2.14)(react@19.2.4)
+      '@radix-ui/react-id': 1.1.1(@types/react@19.2.14)(react@19.2.4)
+      '@radix-ui/react-label': 2.1.7(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
+      '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
+      react: 19.2.4
+      react-dom: 19.2.4(react@19.2.4)
+    optionalDependencies:
+      '@types/react': 19.2.14
+      '@types/react-dom': 19.2.3(@types/react@19.2.14)
+
+  '@radix-ui/react-hover-card@1.1.15(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)':
+    dependencies:
+      '@radix-ui/primitive': 1.1.3
+      '@radix-ui/react-compose-refs': 1.1.2(@types/react@19.2.14)(react@19.2.4)
+      '@radix-ui/react-context': 1.1.2(@types/react@19.2.14)(react@19.2.4)
+      '@radix-ui/react-dismissable-layer': 1.1.11(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
+      '@radix-ui/react-popper': 1.2.8(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
+      '@radix-ui/react-portal': 1.1.9(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
+      '@radix-ui/react-presence': 1.1.5(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
+      '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
+      '@radix-ui/react-use-controllable-state': 1.2.2(@types/react@19.2.14)(react@19.2.4)
+      react: 19.2.4
+      react-dom: 19.2.4(react@19.2.4)
+    optionalDependencies:
+      '@types/react': 19.2.14
+      '@types/react-dom': 19.2.3(@types/react@19.2.14)
+
   '@radix-ui/react-id@1.1.1(@types/react@19.2.14)(react@19.2.4)':
     dependencies:
       '@radix-ui/react-use-layout-effect': 1.1.1(@types/react@19.2.14)(react@19.2.4)
@@ -2605,6 +3019,15 @@ snapshots:
     optionalDependencies:
       '@types/react': 19.2.14
 
+  '@radix-ui/react-label@2.1.7(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)':
+    dependencies:
+      '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
+      react: 19.2.4
+      react-dom: 19.2.4(react@19.2.4)
+    optionalDependencies:
+      '@types/react': 19.2.14
+      '@types/react-dom': 19.2.3(@types/react@19.2.14)
+
   '@radix-ui/react-label@2.1.8(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)':
     dependencies:
       '@radix-ui/react-primitive': 2.1.4(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
@@ -2658,6 +3081,87 @@ snapshots:
       '@types/react': 19.2.14
       '@types/react-dom': 19.2.3(@types/react@19.2.14)
 
+  '@radix-ui/react-navigation-menu@1.2.14(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)':
+    dependencies:
+      '@radix-ui/primitive': 1.1.3
+      '@radix-ui/react-collection': 1.1.7(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
+      '@radix-ui/react-compose-refs': 1.1.2(@types/react@19.2.14)(react@19.2.4)
+      '@radix-ui/react-context': 1.1.2(@types/react@19.2.14)(react@19.2.4)
+      '@radix-ui/react-direction': 1.1.1(@types/react@19.2.14)(react@19.2.4)
+      '@radix-ui/react-dismissable-layer': 1.1.11(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
+      '@radix-ui/react-id': 1.1.1(@types/react@19.2.14)(react@19.2.4)
+      '@radix-ui/react-presence': 1.1.5(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
+      '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
+      '@radix-ui/react-use-callback-ref': 1.1.1(@types/react@19.2.14)(react@19.2.4)
+      '@radix-ui/react-use-controllable-state': 1.2.2(@types/react@19.2.14)(react@19.2.4)
+      '@radix-ui/react-use-layout-effect': 1.1.1(@types/react@19.2.14)(react@19.2.4)
+      '@radix-ui/react-use-previous': 1.1.1(@types/react@19.2.14)(react@19.2.4)
+      '@radix-ui/react-visually-hidden': 1.2.3(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
+      react: 19.2.4
+      react-dom: 19.2.4(react@19.2.4)
+    optionalDependencies:
+      '@types/react': 19.2.14
+      '@types/react-dom': 19.2.3(@types/react@19.2.14)
+
+  '@radix-ui/react-one-time-password-field@0.1.8(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)':
+    dependencies:
+      '@radix-ui/number': 1.1.1
+      '@radix-ui/primitive': 1.1.3
+      '@radix-ui/react-collection': 1.1.7(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
+      '@radix-ui/react-compose-refs': 1.1.2(@types/react@19.2.14)(react@19.2.4)
+      '@radix-ui/react-context': 1.1.2(@types/react@19.2.14)(react@19.2.4)
+      '@radix-ui/react-direction': 1.1.1(@types/react@19.2.14)(react@19.2.4)
+      '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
+      '@radix-ui/react-roving-focus': 1.1.11(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
+      '@radix-ui/react-use-controllable-state': 1.2.2(@types/react@19.2.14)(react@19.2.4)
+      '@radix-ui/react-use-effect-event': 0.0.2(@types/react@19.2.14)(react@19.2.4)
+      '@radix-ui/react-use-is-hydrated': 0.1.0(@types/react@19.2.14)(react@19.2.4)
+      '@radix-ui/react-use-layout-effect': 1.1.1(@types/react@19.2.14)(react@19.2.4)
+      react: 19.2.4
+      react-dom: 19.2.4(react@19.2.4)
+    optionalDependencies:
+      '@types/react': 19.2.14
+      '@types/react-dom': 19.2.3(@types/react@19.2.14)
+
+  '@radix-ui/react-password-toggle-field@0.1.3(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)':
+    dependencies:
+      '@radix-ui/primitive': 1.1.3
+      '@radix-ui/react-compose-refs': 1.1.2(@types/react@19.2.14)(react@19.2.4)
+      '@radix-ui/react-context': 1.1.2(@types/react@19.2.14)(react@19.2.4)
+      '@radix-ui/react-id': 1.1.1(@types/react@19.2.14)(react@19.2.4)
+      '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
+      '@radix-ui/react-use-controllable-state': 1.2.2(@types/react@19.2.14)(react@19.2.4)
+      '@radix-ui/react-use-effect-event': 0.0.2(@types/react@19.2.14)(react@19.2.4)
+      '@radix-ui/react-use-is-hydrated': 0.1.0(@types/react@19.2.14)(react@19.2.4)
+      react: 19.2.4
+      react-dom: 19.2.4(react@19.2.4)
+    optionalDependencies:
+      '@types/react': 19.2.14
+      '@types/react-dom': 19.2.3(@types/react@19.2.14)
+
+  '@radix-ui/react-popover@1.1.15(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)':
+    dependencies:
+      '@radix-ui/primitive': 1.1.3
+      '@radix-ui/react-compose-refs': 1.1.2(@types/react@19.2.14)(react@19.2.4)
+      '@radix-ui/react-context': 1.1.2(@types/react@19.2.14)(react@19.2.4)
+      '@radix-ui/react-dismissable-layer': 1.1.11(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
+      '@radix-ui/react-focus-guards': 1.1.3(@types/react@19.2.14)(react@19.2.4)
+      '@radix-ui/react-focus-scope': 1.1.7(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
+      '@radix-ui/react-id': 1.1.1(@types/react@19.2.14)(react@19.2.4)
+      '@radix-ui/react-popper': 1.2.8(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
+      '@radix-ui/react-portal': 1.1.9(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
+      '@radix-ui/react-presence': 1.1.5(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
+      '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
+      '@radix-ui/react-slot': 1.2.3(@types/react@19.2.14)(react@19.2.4)
+      '@radix-ui/react-use-controllable-state': 1.2.2(@types/react@19.2.14)(react@19.2.4)
+      aria-hidden: 1.2.6
+      react: 19.2.4
+      react-dom: 19.2.4(react@19.2.4)
+      react-remove-scroll: 2.7.2(@types/react@19.2.14)(react@19.2.4)
+    optionalDependencies:
+      '@types/react': 19.2.14
+      '@types/react-dom': 19.2.3(@types/react@19.2.14)
+
   '@radix-ui/react-popper@1.2.8(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)':
     dependencies:
       '@floating-ui/react-dom': 2.1.7(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
@@ -2714,6 +3218,16 @@ snapshots:
       '@types/react': 19.2.14
       '@types/react-dom': 19.2.3(@types/react@19.2.14)
 
+  '@radix-ui/react-progress@1.1.7(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)':
+    dependencies:
+      '@radix-ui/react-context': 1.1.2(@types/react@19.2.14)(react@19.2.4)
+      '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
+      react: 19.2.4
+      react-dom: 19.2.4(react@19.2.4)
+    optionalDependencies:
+      '@types/react': 19.2.14
+      '@types/react-dom': 19.2.3(@types/react@19.2.14)
+
   '@radix-ui/react-progress@1.1.8(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)':
     dependencies:
       '@radix-ui/react-context': 1.1.3(@types/react@19.2.14)(react@19.2.4)
@@ -2724,6 +3238,24 @@ snapshots:
       '@types/react': 19.2.14
       '@types/react-dom': 19.2.3(@types/react@19.2.14)
 
+  '@radix-ui/react-radio-group@1.3.8(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)':
+    dependencies:
+      '@radix-ui/primitive': 1.1.3
+      '@radix-ui/react-compose-refs': 1.1.2(@types/react@19.2.14)(react@19.2.4)
+      '@radix-ui/react-context': 1.1.2(@types/react@19.2.14)(react@19.2.4)
+      '@radix-ui/react-direction': 1.1.1(@types/react@19.2.14)(react@19.2.4)
+      '@radix-ui/react-presence': 1.1.5(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
+      '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
+      '@radix-ui/react-roving-focus': 1.1.11(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
+      '@radix-ui/react-use-controllable-state': 1.2.2(@types/react@19.2.14)(react@19.2.4)
+      '@radix-ui/react-use-previous': 1.1.1(@types/react@19.2.14)(react@19.2.4)
+      '@radix-ui/react-use-size': 1.1.1(@types/react@19.2.14)(react@19.2.4)
+      react: 19.2.4
+      react-dom: 19.2.4(react@19.2.4)
+    optionalDependencies:
+      '@types/react': 19.2.14
+      '@types/react-dom': 19.2.3(@types/react@19.2.14)
+
   '@radix-ui/react-roving-focus@1.1.11(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)':
     dependencies:
       '@radix-ui/primitive': 1.1.3
@@ -2787,6 +3319,34 @@ snapshots:
       '@types/react': 19.2.14
       '@types/react-dom': 19.2.3(@types/react@19.2.14)
 
+  '@radix-ui/react-separator@1.1.7(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)':
+    dependencies:
+      '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
+      react: 19.2.4
+      react-dom: 19.2.4(react@19.2.4)
+    optionalDependencies:
+      '@types/react': 19.2.14
+      '@types/react-dom': 19.2.3(@types/react@19.2.14)
+
+  '@radix-ui/react-slider@1.3.6(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)':
+    dependencies:
+      '@radix-ui/number': 1.1.1
+      '@radix-ui/primitive': 1.1.3
+      '@radix-ui/react-collection': 1.1.7(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
+      '@radix-ui/react-compose-refs': 1.1.2(@types/react@19.2.14)(react@19.2.4)
+      '@radix-ui/react-context': 1.1.2(@types/react@19.2.14)(react@19.2.4)
+      '@radix-ui/react-direction': 1.1.1(@types/react@19.2.14)(react@19.2.4)
+      '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
+      '@radix-ui/react-use-controllable-state': 1.2.2(@types/react@19.2.14)(react@19.2.4)
+      '@radix-ui/react-use-layout-effect': 1.1.1(@types/react@19.2.14)(react@19.2.4)
+      '@radix-ui/react-use-previous': 1.1.1(@types/react@19.2.14)(react@19.2.4)
+      '@radix-ui/react-use-size': 1.1.1(@types/react@19.2.14)(react@19.2.4)
+      react: 19.2.4
+      react-dom: 19.2.4(react@19.2.4)
+    optionalDependencies:
+      '@types/react': 19.2.14
+      '@types/react-dom': 19.2.3(@types/react@19.2.14)
+
   '@radix-ui/react-slot@1.2.3(@types/react@19.2.14)(react@19.2.4)':
     dependencies:
       '@radix-ui/react-compose-refs': 1.1.2(@types/react@19.2.14)(react@19.2.4)
@@ -2832,6 +3392,26 @@ snapshots:
       '@types/react': 19.2.14
       '@types/react-dom': 19.2.3(@types/react@19.2.14)
 
+  '@radix-ui/react-toast@1.2.15(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)':
+    dependencies:
+      '@radix-ui/primitive': 1.1.3
+      '@radix-ui/react-collection': 1.1.7(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
+      '@radix-ui/react-compose-refs': 1.1.2(@types/react@19.2.14)(react@19.2.4)
+      '@radix-ui/react-context': 1.1.2(@types/react@19.2.14)(react@19.2.4)
+      '@radix-ui/react-dismissable-layer': 1.1.11(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
+      '@radix-ui/react-portal': 1.1.9(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
+      '@radix-ui/react-presence': 1.1.5(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
+      '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
+      '@radix-ui/react-use-callback-ref': 1.1.1(@types/react@19.2.14)(react@19.2.4)
+      '@radix-ui/react-use-controllable-state': 1.2.2(@types/react@19.2.14)(react@19.2.4)
+      '@radix-ui/react-use-layout-effect': 1.1.1(@types/react@19.2.14)(react@19.2.4)
+      '@radix-ui/react-visually-hidden': 1.2.3(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
+      react: 19.2.4
+      react-dom: 19.2.4(react@19.2.4)
+    optionalDependencies:
+      '@types/react': 19.2.14
+      '@types/react-dom': 19.2.3(@types/react@19.2.14)
+
   '@radix-ui/react-toggle-group@1.1.11(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)':
     dependencies:
       '@radix-ui/primitive': 1.1.3
@@ -2858,6 +3438,21 @@ snapshots:
       '@types/react': 19.2.14
       '@types/react-dom': 19.2.3(@types/react@19.2.14)
 
+  '@radix-ui/react-toolbar@1.1.11(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)':
+    dependencies:
+      '@radix-ui/primitive': 1.1.3
+      '@radix-ui/react-context': 1.1.2(@types/react@19.2.14)(react@19.2.4)
+      '@radix-ui/react-direction': 1.1.1(@types/react@19.2.14)(react@19.2.4)
+      '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
+      '@radix-ui/react-roving-focus': 1.1.11(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
+      '@radix-ui/react-separator': 1.1.7(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
+      '@radix-ui/react-toggle-group': 1.1.11(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
+      react: 19.2.4
+      react-dom: 19.2.4(react@19.2.4)
+    optionalDependencies:
+      '@types/react': 19.2.14
+      '@types/react-dom': 19.2.3(@types/react@19.2.14)
+
   '@radix-ui/react-tooltip@1.2.8(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)':
     dependencies:
       '@radix-ui/primitive': 1.1.3
@@ -2906,6 +3501,13 @@ snapshots:
     optionalDependencies:
       '@types/react': 19.2.14
 
+  '@radix-ui/react-use-is-hydrated@0.1.0(@types/react@19.2.14)(react@19.2.4)':
+    dependencies:
+      react: 19.2.4
+      use-sync-external-store: 1.6.0(react@19.2.4)
+    optionalDependencies:
+      '@types/react': 19.2.14
+
   '@radix-ui/react-use-layout-effect@1.1.1(@types/react@19.2.14)(react@19.2.4)':
     dependencies:
       react: 19.2.4
@@ -3636,6 +4238,69 @@ snapshots:
 
   punycode@2.3.1: {}
 
+  radix-ui@1.4.3(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4):
+    dependencies:
+      '@radix-ui/primitive': 1.1.3
+      '@radix-ui/react-accessible-icon': 1.1.7(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
+      '@radix-ui/react-accordion': 1.2.12(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
+      '@radix-ui/react-alert-dialog': 1.1.15(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
+      '@radix-ui/react-arrow': 1.1.7(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
+      '@radix-ui/react-aspect-ratio': 1.1.7(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
+      '@radix-ui/react-avatar': 1.1.10(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
+      '@radix-ui/react-checkbox': 1.3.3(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
+      '@radix-ui/react-collapsible': 1.1.12(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
+      '@radix-ui/react-collection': 1.1.7(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
+      '@radix-ui/react-compose-refs': 1.1.2(@types/react@19.2.14)(react@19.2.4)
+      '@radix-ui/react-context': 1.1.2(@types/react@19.2.14)(react@19.2.4)
+      '@radix-ui/react-context-menu': 2.2.16(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
+      '@radix-ui/react-dialog': 1.1.15(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
+      '@radix-ui/react-direction': 1.1.1(@types/react@19.2.14)(react@19.2.4)
+      '@radix-ui/react-dismissable-layer': 1.1.11(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
+      '@radix-ui/react-dropdown-menu': 2.1.16(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
+      '@radix-ui/react-focus-guards': 1.1.3(@types/react@19.2.14)(react@19.2.4)
+      '@radix-ui/react-focus-scope': 1.1.7(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
+      '@radix-ui/react-form': 0.1.8(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
+      '@radix-ui/react-hover-card': 1.1.15(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
+      '@radix-ui/react-label': 2.1.7(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
+      '@radix-ui/react-menu': 2.1.16(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
+      '@radix-ui/react-menubar': 1.1.16(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
+      '@radix-ui/react-navigation-menu': 1.2.14(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
+      '@radix-ui/react-one-time-password-field': 0.1.8(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
+      '@radix-ui/react-password-toggle-field': 0.1.3(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
+      '@radix-ui/react-popover': 1.1.15(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
+      '@radix-ui/react-popper': 1.2.8(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
+      '@radix-ui/react-portal': 1.1.9(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
+      '@radix-ui/react-presence': 1.1.5(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
+      '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
+      '@radix-ui/react-progress': 1.1.7(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
+      '@radix-ui/react-radio-group': 1.3.8(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
+      '@radix-ui/react-roving-focus': 1.1.11(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
+      '@radix-ui/react-scroll-area': 1.2.10(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
+      '@radix-ui/react-select': 2.2.6(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
+      '@radix-ui/react-separator': 1.1.7(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
+      '@radix-ui/react-slider': 1.3.6(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
+      '@radix-ui/react-slot': 1.2.3(@types/react@19.2.14)(react@19.2.4)
+      '@radix-ui/react-switch': 1.2.6(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
+      '@radix-ui/react-tabs': 1.1.13(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
+      '@radix-ui/react-toast': 1.2.15(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
+      '@radix-ui/react-toggle': 1.1.10(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
+      '@radix-ui/react-toggle-group': 1.1.11(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
+      '@radix-ui/react-toolbar': 1.1.11(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
+      '@radix-ui/react-tooltip': 1.2.8(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
+      '@radix-ui/react-use-callback-ref': 1.1.1(@types/react@19.2.14)(react@19.2.4)
+      '@radix-ui/react-use-controllable-state': 1.2.2(@types/react@19.2.14)(react@19.2.4)
+      '@radix-ui/react-use-effect-event': 0.0.2(@types/react@19.2.14)(react@19.2.4)
+      '@radix-ui/react-use-escape-keydown': 1.1.1(@types/react@19.2.14)(react@19.2.4)
+      '@radix-ui/react-use-is-hydrated': 0.1.0(@types/react@19.2.14)(react@19.2.4)
+      '@radix-ui/react-use-layout-effect': 1.1.1(@types/react@19.2.14)(react@19.2.4)
+      '@radix-ui/react-use-size': 1.1.1(@types/react@19.2.14)(react@19.2.4)
+      '@radix-ui/react-visually-hidden': 1.2.3(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
+      react: 19.2.4
+      react-dom: 19.2.4(react@19.2.4)
+    optionalDependencies:
+      '@types/react': 19.2.14
+      '@types/react-dom': 19.2.3(@types/react@19.2.14)
+
   react-dom@19.2.4(react@19.2.4):
     dependencies:
       react: 19.2.4
@@ -3816,6 +4481,10 @@ snapshots:
     optionalDependencies:
       '@types/react': 19.2.14
 
+  use-sync-external-store@1.6.0(react@19.2.4):
+    dependencies:
+      react: 19.2.4
+
   vite@7.3.1(@types/node@25.3.0)(jiti@2.6.1)(lightningcss@1.31.1):
     dependencies:
       esbuild: 0.27.3

frontend/src/App.tsx

@@ -5,7 +5,7 @@ import { Search, X, ArrowUp } from "lucide-react";
 import { TooltipProvider } from "@/components/ui/tooltip";
 import { getSettings, getSettingsWithDefaults, loadSettings, saveSettings, applyThemeMode, applyFont, updateSettings } from "@/lib/settings";
 import { applyTheme } from "@/lib/themes";
-import { OpenFolder, CheckFFmpegInstalled, DownloadFFmpeg } from "../wailsjs/go/main/App";
+import { OpenFolder, CheckFFmpegInstalled, DownloadFFmpeg, GetBrewPath, InstallFFmpegWithBrew } from "../wailsjs/go/main/App";
 import { EventsOn, EventsOff, Quit } from "../wailsjs/runtime/runtime";
 import { toastWithSound as toast } from "@/lib/toast-with-sound";
 import { TitleBar } from "@/components/TitleBar";
@@ -20,6 +20,7 @@ import { DownloadQueue } from "@/components/DownloadQueue";
 import { DownloadProgressToast } from "@/components/DownloadProgressToast";
 import { AudioAnalysisPage } from "@/components/AudioAnalysisPage";
 import { AudioConverterPage } from "@/components/AudioConverterPage";
+import { AudioResamplerPage } from "@/components/AudioResamplerPage";
 import { FileManagerPage } from "@/components/FileManagerPage";
 import { SettingsPage } from "@/components/SettingsPage";
 import { DebugLoggerPage } from "@/components/DebugLoggerPage";
@@ -31,10 +32,77 @@ import { useMetadata } from "@/hooks/useMetadata";
 import { useLyrics } from "@/hooks/useLyrics";
 import { useCover } from "@/hooks/useCover";
 import { useAvailability } from "@/hooks/useAvailability";
+import { ensureApiStatusCheckStarted } from "@/lib/api-status";
 import { useDownloadQueueDialog } from "@/hooks/useDownloadQueueDialog";
 import { useDownloadProgress } from "@/hooks/useDownloadProgress";
 const HISTORY_KEY = "spotiflac_fetch_history";
 const MAX_HISTORY = 5;
+function extractSpotifyEntityFromURL(url: string): {
+    type: string;
+    id: string;
+} | null {
+    const trimmed = url.trim();
+    if (!trimmed) {
+        return null;
+    }
+    const spotifyUriMatch = trimmed.match(/^spotify:(track|album|playlist|artist):([A-Za-z0-9]+)$/i);
+    if (spotifyUriMatch) {
+        return {
+            type: spotifyUriMatch[1].toLowerCase(),
+            id: spotifyUriMatch[2],
+        };
+    }
+    try {
+        const parsed = new URL(trimmed);
+        const segments = parsed.pathname.split("/").filter(Boolean);
+        const supportedTypes = new Set(["track", "album", "playlist", "artist"]);
+        for (let i = 0; i < segments.length - 1; i++) {
+            const segment = segments[i].toLowerCase();
+            if (!supportedTypes.has(segment)) {
+                continue;
+            }
+            const id = segments[i + 1];
+            if (id) {
+                return { type: segment, id };
+            }
+        }
+    }
+    catch {
+    }
+    return null;
+}
+function normalizeHistoryURL(url: string): string {
+    const trimmed = url.trim();
+    if (!trimmed)
+        return trimmed;
+    const withoutQuery = trimmed.split("?")[0].replace(/\/+$/, "");
+    const spotifyEntity = extractSpotifyEntityFromURL(withoutQuery);
+    if (spotifyEntity) {
+        return `https://open.spotify.com/${spotifyEntity.type}/${spotifyEntity.id}`;
+    }
+    return withoutQuery.replace(/(\/artist\/[A-Za-z0-9]+)\/discography\/all$/i, "$1");
+}
+function getHistoryIdentityKey(type: HistoryItem["type"], url: string): string {
+    const normalizedUrl = normalizeHistoryURL(url);
+    const spotifyEntity = extractSpotifyEntityFromURL(normalizedUrl);
+    if (spotifyEntity) {
+        return `${type}:${spotifyEntity.id}`;
+    }
+    return `${type}:${normalizedUrl}`;
+}
+function dedupeHistoryItems(items: HistoryItem[]): HistoryItem[] {
+    const seen = new Set<string>();
+    const deduped: HistoryItem[] = [];
+    for (const item of items) {
+        const normalizedUrl = normalizeHistoryURL(item.url);
+        const key = getHistoryIdentityKey(item.type, normalizedUrl);
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        deduped.push({ ...item, url: normalizedUrl });
+    }
+    return deduped;
+}
 function App() {
     const [currentPage, setCurrentPage] = useState<PageType>("main");
     const [spotifyUrl, setSpotifyUrl] = useState("");
@@ -65,6 +133,7 @@ function App() {
     const downloadQueue = useDownloadQueueDialog();
     const downloadProgress = useDownloadProgress();
     const [isFFmpegInstalled, setIsFFmpegInstalled] = useState<boolean | null>(null);
+    const [brewPath, setBrewPath] = useState<string>("");
     const [isInstallingFFmpeg, setIsInstallingFFmpeg] = useState(false);
     const [ffmpegInstallProgress, setFfmpegInstallProgress] = useState(0);
     const [ffmpegInstallStatus, setFfmpegInstallStatus] = useState("");
@@ -92,6 +161,8 @@ function App() {
             try {
                 const installed = await CheckFFmpegInstalled();
                 setIsFFmpegInstalled(installed);
+                const brew = await GetBrewPath();
+                setBrewPath(brew);
             }
             catch (err) {
                 console.error("Failed to check FFmpeg:", err);
@@ -109,6 +180,7 @@ function App() {
         };
         mediaQuery.addEventListener("change", handleChange);
         checkForUpdates();
+        ensureApiStatusCheckStarted();
         loadHistory();
         const handleScroll = () => {
             setShowScrollTop(window.scrollY > 300);
@@ -163,14 +235,16 @@ function App() {
         try {
             const saved = localStorage.getItem(HISTORY_KEY);
             if (saved) {
-                setFetchHistory(JSON.parse(saved));
+                const deduped = dedupeHistoryItems(JSON.parse(saved));
+                setFetchHistory(deduped);
+                localStorage.setItem(HISTORY_KEY, JSON.stringify(deduped));
             }
         }
         catch (err) {
             console.error("Failed to load history:", err);
         }
     };
-    const handleInstallFFmpeg = async () => {
+    const handleInstallFFmpeg = async (useBrew: boolean = false) => {
         setIsInstallingFFmpeg(true);
         setFfmpegInstallProgress(0);
         setFfmpegInstallStatus("starting");
@@ -187,11 +261,11 @@ function App() {
             EventsOn("ffmpeg:status", (status: string) => {
                 setFfmpegInstallStatus(status);
             });
-            const response = await DownloadFFmpeg();
+            const response = useBrew ? await InstallFFmpegWithBrew() : await DownloadFFmpeg();
             EventsOff("ffmpeg:progress");
             EventsOff("ffmpeg:status");
             if (response.success) {
-                toast.success("FFmpeg installed successfully!");
+                toast.success(useBrew ? "FFmpeg installed successfully via Homebrew!" : "FFmpeg installed successfully!");
                 setIsFFmpegInstalled(true);
             }
             else {
@@ -218,9 +292,12 @@ function App() {
     };
     const addToHistory = (item: Omit<HistoryItem, "id" | "timestamp">) => {
         setFetchHistory((prev) => {
-            const filtered = prev.filter((h) => h.url !== item.url);
+            const normalizedUrl = normalizeHistoryURL(item.url);
+            const identityKey = getHistoryIdentityKey(item.type, normalizedUrl);
+            const filtered = prev.filter((h) => getHistoryIdentityKey(h.type, h.url) !== identityKey);
             const newItem: HistoryItem = {
                 ...item,
+                url: normalizedUrl,
                 id: crypto.randomUUID(),
                 timestamp: Date.now(),
             };
@@ -336,11 +413,13 @@ function App() {
         if ("track" in metadata.metadata) {
             const { track } = metadata.metadata;
             const trackId = track.spotify_id || "";
-            return (<TrackInfo track={track} isDownloading={download.isDownloading} downloadingTrack={download.downloadingTrack} isDownloaded={download.downloadedTracks.has(trackId)} isFailed={download.failedTracks.has(trackId)} isSkipped={download.skippedTracks.has(trackId)} downloadingLyricsTrack={lyrics.downloadingLyricsTrack} downloadedLyrics={lyrics.downloadedLyrics.has(track.spotify_id || "")} failedLyrics={lyrics.failedLyrics.has(track.spotify_id || "")} skippedLyrics={lyrics.skippedLyrics.has(track.spotify_id || "")} checkingAvailability={availability.checkingTrackId === track.spotify_id} availability={availability.availabilityMap.get(track.spotify_id || "")} downloadingCover={cover.downloadingCoverTrack === (track.spotify_id || `${track.name}-${track.artists}`)} downloadedCover={cover.downloadedCovers.has(track.spotify_id || `${track.name}-${track.artists}`)} failedCover={cover.failedCovers.has(track.spotify_id || `${track.name}-${track.artists}`)} skippedCover={cover.skippedCovers.has(track.spotify_id || `${track.name}-${track.artists}`)} onDownload={download.handleDownloadTrack} onDownloadLyrics={(spotifyId, name, artists, albumName, albumArtist, releaseDate, discNumber) => lyrics.handleDownloadLyrics(spotifyId, name, artists, albumName, track.album_name, undefined, albumArtist, releaseDate, discNumber)} onDownloadCover={(coverUrl, trackName, artistName, albumName, _playlistName, _position, trackId, albumArtist, releaseDate, discNumber) => cover.handleDownloadCover(coverUrl, trackName, artistName, albumName, track.album_name, undefined, trackId, albumArtist, releaseDate, discNumber)} onCheckAvailability={availability.checkAvailability} onOpenFolder={handleOpenFolder} onBack={metadata.resetMetadata}/>);
+            return (<TrackInfo track={track} isDownloading={download.isDownloading} downloadingTrack={download.downloadingTrack} isDownloaded={download.downloadedTracks.has(trackId)} isFailed={download.failedTracks.has(trackId)} isSkipped={download.skippedTracks.has(trackId)} downloadingLyricsTrack={lyrics.downloadingLyricsTrack} downloadedLyrics={lyrics.downloadedLyrics.has(track.spotify_id || "")} failedLyrics={lyrics.failedLyrics.has(track.spotify_id || "")} skippedLyrics={lyrics.skippedLyrics.has(track.spotify_id || "")} checkingAvailability={availability.checkingTrackId === track.spotify_id} availability={availability.availabilityMap.get(track.spotify_id || "")} downloadingCover={cover.downloadingCoverTrack === (track.spotify_id || `${track.name}-${track.artists}`)} downloadedCover={cover.downloadedCovers.has(track.spotify_id || `${track.name}-${track.artists}`)} failedCover={cover.failedCovers.has(track.spotify_id || `${track.name}-${track.artists}`)} skippedCover={cover.skippedCovers.has(track.spotify_id || `${track.name}-${track.artists}`)} onDownload={download.handleDownloadTrack} onDownloadLyrics={(spotifyId, name, artists, albumName, albumArtist, releaseDate, discNumber) => lyrics.handleDownloadLyrics(spotifyId, name, artists, albumName, undefined, undefined, albumArtist, releaseDate, discNumber)} onDownloadCover={(coverUrl, trackName, artistName, albumName, _playlistName, _position, trackId, albumArtist, releaseDate, discNumber) => cover.handleDownloadCover(coverUrl, trackName, artistName, albumName, undefined, undefined, trackId, albumArtist, releaseDate, discNumber)} onCheckAvailability={availability.checkAvailability} onOpenFolder={handleOpenFolder} onBack={metadata.resetMetadata}/>);
         }
         if ("album_info" in metadata.metadata) {
             const { album_info, track_list } = metadata.metadata;
             return (<AlbumInfo albumInfo={album_info} trackList={track_list} searchQuery={searchQuery} sortBy={sortBy} selectedTracks={selectedTracks} downloadedTracks={download.downloadedTracks} failedTracks={download.failedTracks} skippedTracks={download.skippedTracks} downloadingTrack={download.downloadingTrack} isDownloading={download.isDownloading} bulkDownloadType={download.bulkDownloadType} downloadProgress={download.downloadProgress} currentDownloadInfo={download.currentDownloadInfo} currentPage={currentListPage} itemsPerPage={ITEMS_PER_PAGE} downloadedLyrics={lyrics.downloadedLyrics} failedLyrics={lyrics.failedLyrics} skippedLyrics={lyrics.skippedLyrics} downloadingLyricsTrack={lyrics.downloadingLyricsTrack} checkingAvailabilityTrack={availability.checkingTrackId} availabilityMap={availability.availabilityMap} downloadedCovers={cover.downloadedCovers} failedCovers={cover.failedCovers} skippedCovers={cover.skippedCovers} downloadingCoverTrack={cover.downloadingCoverTrack} isBulkDownloadingCovers={cover.isBulkDownloadingCovers} isBulkDownloadingLyrics={lyrics.isBulkDownloadingLyrics} onSearchChange={handleSearchChange} onSortChange={setSortBy} onToggleTrack={toggleTrackSelection} onToggleSelectAll={toggleSelectAll} onDownloadTrack={download.handleDownloadTrack} onDownloadLyrics={(spotifyId, name, artists, albumName, _folderName, _isArtistDiscography, position, albumArtist, releaseDate, discNumber) => lyrics.handleDownloadLyrics(spotifyId, name, artists, albumName, album_info.name, position, albumArtist, releaseDate, discNumber, true)} onDownloadCover={(coverUrl, trackName, artistName, albumName, _folderName, _isArtistDiscography, position, trackId, albumArtist, releaseDate, discNumber) => cover.handleDownloadCover(coverUrl, trackName, artistName, albumName, album_info.name, position, trackId, albumArtist, releaseDate, discNumber, true)} onCheckAvailability={availability.checkAvailability} onDownloadAllLyrics={() => lyrics.handleDownloadAllLyrics(track_list, album_info.name, undefined, true)} onDownloadAllCovers={() => cover.handleDownloadAllCovers(track_list, album_info.name, true)} onDownloadAll={() => download.handleDownloadAll(track_list, album_info.name, true)} onDownloadSelected={() => download.handleDownloadSelected(selectedTracks, track_list, album_info.name, true)} onStopDownload={download.handleStopDownload} onOpenFolder={handleOpenFolder} onPageChange={setCurrentListPage} onBack={metadata.resetMetadata} onArtistClick={async (artist) => {
+                    const pendingArtistUrl = artist.external_urls.replace(/\/$/, "") + "/discography/all";
+                    setSpotifyUrl(pendingArtistUrl);
                     const artistUrl = await metadata.handleArtistClick(artist);
                     if (artistUrl) {
                         setSpotifyUrl(artistUrl);
@@ -355,6 +434,8 @@ function App() {
         if ("playlist_info" in metadata.metadata) {
             const { playlist_info, track_list } = metadata.metadata;
             return (<PlaylistInfo playlistInfo={playlist_info} trackList={track_list} searchQuery={searchQuery} sortBy={sortBy} selectedTracks={selectedTracks} downloadedTracks={download.downloadedTracks} failedTracks={download.failedTracks} skippedTracks={download.skippedTracks} downloadingTrack={download.downloadingTrack} isDownloading={download.isDownloading} bulkDownloadType={download.bulkDownloadType} downloadProgress={download.downloadProgress} currentDownloadInfo={download.currentDownloadInfo} currentPage={currentListPage} itemsPerPage={ITEMS_PER_PAGE} downloadedLyrics={lyrics.downloadedLyrics} failedLyrics={lyrics.failedLyrics} skippedLyrics={lyrics.skippedLyrics} downloadingLyricsTrack={lyrics.downloadingLyricsTrack} checkingAvailabilityTrack={availability.checkingTrackId} availabilityMap={availability.availabilityMap} downloadedCovers={cover.downloadedCovers} failedCovers={cover.failedCovers} skippedCovers={cover.skippedCovers} downloadingCoverTrack={cover.downloadingCoverTrack} isBulkDownloadingCovers={cover.isBulkDownloadingCovers} isBulkDownloadingLyrics={lyrics.isBulkDownloadingLyrics} onSearchChange={handleSearchChange} onSortChange={setSortBy} onToggleTrack={toggleTrackSelection} onToggleSelectAll={toggleSelectAll} onDownloadTrack={download.handleDownloadTrack} onDownloadLyrics={(spotifyId, name, artists, albumName, _folderName, _isArtistDiscography, position, albumArtist, releaseDate, discNumber) => lyrics.handleDownloadLyrics(spotifyId, name, artists, albumName, playlist_info.owner.name, position, albumArtist, releaseDate, discNumber)} onDownloadCover={(coverUrl, trackName, artistName, albumName, _folderName, _isArtistDiscography, position, trackId, albumArtist, releaseDate, discNumber) => cover.handleDownloadCover(coverUrl, trackName, artistName, albumName, playlist_info.owner.name, position, trackId, albumArtist, releaseDate, discNumber)} onCheckAvailability={availability.checkAvailability} onDownloadAllLyrics={() => lyrics.handleDownloadAllLyrics(track_list, playlist_info.owner.name)} onDownloadAllCovers={() => cover.handleDownloadAllCovers(track_list, playlist_info.owner.name)} onDownloadAll={() => download.handleDownloadAll(track_list, playlist_info.owner.name)} onDownloadSelected={() => download.handleDownloadSelected(selectedTracks, track_list, playlist_info.owner.name)} onStopDownload={download.handleStopDownload} onOpenFolder={handleOpenFolder} onPageChange={setCurrentListPage} onBack={metadata.resetMetadata} onAlbumClick={metadata.handleAlbumClick} onArtistClick={async (artist) => {
+                    const pendingArtistUrl = artist.external_urls.replace(/\/$/, "") + "/discography/all";
+                    setSpotifyUrl(pendingArtistUrl);
                     const artistUrl = await metadata.handleArtistClick(artist);
                     if (artistUrl) {
                         setSpotifyUrl(artistUrl);
@@ -369,6 +450,8 @@ function App() {
         if ("artist_info" in metadata.metadata) {
             const { artist_info, album_list, track_list } = metadata.metadata;
             return (<ArtistInfo artistInfo={artist_info} albumList={album_list} trackList={track_list} searchQuery={searchQuery} sortBy={sortBy} selectedTracks={selectedTracks} downloadedTracks={download.downloadedTracks} failedTracks={download.failedTracks} skippedTracks={download.skippedTracks} downloadingTrack={download.downloadingTrack} isDownloading={download.isDownloading} bulkDownloadType={download.bulkDownloadType} downloadProgress={download.downloadProgress} currentDownloadInfo={download.currentDownloadInfo} currentPage={currentListPage} itemsPerPage={ITEMS_PER_PAGE} downloadedLyrics={lyrics.downloadedLyrics} failedLyrics={lyrics.failedLyrics} skippedLyrics={lyrics.skippedLyrics} downloadingLyricsTrack={lyrics.downloadingLyricsTrack} checkingAvailabilityTrack={availability.checkingTrackId} availabilityMap={availability.availabilityMap} downloadedCovers={cover.downloadedCovers} failedCovers={cover.failedCovers} skippedCovers={cover.skippedCovers} downloadingCoverTrack={cover.downloadingCoverTrack} isBulkDownloadingCovers={cover.isBulkDownloadingCovers} isBulkDownloadingLyrics={lyrics.isBulkDownloadingLyrics} onSearchChange={handleSearchChange} onSortChange={setSortBy} onToggleTrack={toggleTrackSelection} onToggleSelectAll={toggleSelectAll} onDownloadTrack={download.handleDownloadTrack} onDownloadLyrics={(spotifyId, name, artists, albumName, _folderName, _isArtistDiscography, position, albumArtist, releaseDate, discNumber) => lyrics.handleDownloadLyrics(spotifyId, name, artists, albumName, artist_info.name, position, albumArtist, releaseDate, discNumber)} onDownloadCover={(coverUrl, trackName, artistName, albumName, _folderName, _isArtistDiscography, position, trackId, albumArtist, releaseDate, discNumber) => cover.handleDownloadCover(coverUrl, trackName, artistName, albumName, artist_info.name, position, trackId, albumArtist, releaseDate, discNumber)} onCheckAvailability={availability.checkAvailability} onDownloadAllLyrics={() => lyrics.handleDownloadAllLyrics(track_list, artist_info.name)} onDownloadAllCovers={() => cover.handleDownloadAllCovers(track_list, artist_info.name)} onDownloadAll={() => download.handleDownloadAll(track_list, artist_info.name)} onDownloadSelected={() => download.handleDownloadSelected(selectedTracks, track_list, artist_info.name)} onStopDownload={download.handleStopDownload} onOpenFolder={handleOpenFolder} onAlbumClick={metadata.handleAlbumClick} onBack={metadata.resetMetadata} onArtistClick={async (artist) => {
+                    const pendingArtistUrl = artist.external_urls.replace(/\/$/, "") + "/discography/all";
+                    setSpotifyUrl(pendingArtistUrl);
                     const artistUrl = await metadata.handleArtistClick(artist);
                     if (artistUrl) {
                         setSpotifyUrl(artistUrl);
@@ -415,7 +498,7 @@ function App() {
             case "debug":
                 return <DebugLoggerPage />;
             case "about":
-                return <AboutPage version={CURRENT_VERSION}/>;
+                return <AboutPage />;
             case "history":
                 return <HistoryPage onHistorySelect={(cachedData) => {
                         metadata.loadFromCache(cachedData);
@@ -425,6 +508,8 @@ function App() {
                 return <AudioAnalysisPage />;
             case "audio-converter":
                 return <AudioConverterPage />;
+            case "audio-resampler":
+                return <AudioResamplerPage />;
             case "file-manager":
                 return <FileManagerPage />;
             default:
@@ -453,6 +538,10 @@ function App() {
                                     Cancel
                                 </Button>
                                 <Button onClick={async () => {
+                        const pendingAlbumUrl = metadata.selectedAlbum?.external_urls;
+                        if (pendingAlbumUrl) {
+                            setSpotifyUrl(pendingAlbumUrl);
+                        }
                         const albumUrl = await metadata.handleConfirmAlbumFetch();
                         if (albumUrl) {
                             setSpotifyUrl(albumUrl);
@@ -522,14 +611,19 @@ function App() {
 
             
             <Dialog open={isFFmpegInstalled === false} onOpenChange={() => { }}>
-                <DialogContent className="max-w-[360px] [&>button]:hidden p-6 gap-5">
+                <DialogContent className="max-w-[450px] [&>button]:hidden p-6 gap-5">
                     <DialogHeader className="space-y-2">
                         <DialogTitle className="text-lg font-bold tracking-tight">
                             FFmpeg Required
                         </DialogTitle>
                         <DialogDescription className="text-sm text-foreground/70 leading-relaxed font-normal">
-                            FFmpeg is essential for SpotiFLAC to function properly.
-                            This setup will download about <span className="text-foreground font-semibold">100-200MB</span> of data.
+                            {brewPath ? (<>
+                                    FFmpeg is essential for SpotiFLAC to function properly.
+                                    Homebrew detected. Recommended: <span className="text-foreground font-semibold">brew install ffmpeg</span>
+                                </>) : (<>
+                                    FFmpeg is essential for SpotiFLAC to function properly.
+                                    This setup will download about <span className="text-foreground font-semibold">100-200MB</span> of data.
+                                </>)}
                         </DialogDescription>
                     </DialogHeader>
 
@@ -557,13 +651,15 @@ function App() {
                                 </div>)}
                         </div>)}
 
-                    <DialogFooter className="flex-row gap-3 pt-2">
+                    <DialogFooter className={`flex-row gap-3 pt-2 ${brewPath ? 'flex-col' : ''}`}>
                         {!isInstallingFFmpeg && (<Button variant="outline" className="flex-1 h-11 text-sm font-bold transition-colors" onClick={() => Quit()}>
                                 Exit
                             </Button>)}
-                        <Button className={`${isInstallingFFmpeg ? 'w-full' : 'flex-1'} h-11 text-sm font-bold shadow-lg shadow-primary/10`} onClick={handleInstallFFmpeg} disabled={isInstallingFFmpeg}>
-                            {isInstallingFFmpeg ? "Installing..." : "Install now"}
-                        </Button>
+                        {brewPath ? (<Button className="flex-1 h-11 text-sm font-bold shadow-lg shadow-primary/10" onClick={() => handleInstallFFmpeg(true)} disabled={isInstallingFFmpeg}>
+                                    {isInstallingFFmpeg ? "Installing..." : "Install via Homebrew"}
+                                </Button>) : (<Button className={`${isInstallingFFmpeg ? 'w-full' : 'flex-1'} h-11 text-sm font-bold shadow-lg shadow-primary/10`} onClick={() => handleInstallFFmpeg(false)} disabled={isInstallingFFmpeg}>
+                                {isInstallingFFmpeg ? "Installing..." : "Install now"}
+                            </Button>)}
                     </DialogFooter>
                 </DialogContent>
             </Dialog>

frontend/src/components/AboutPage.tsx

@@ -1,80 +1,34 @@
 import { useState, useEffect } from "react";
 import { Button } from "@/components/ui/button";
 import { openExternal } from "@/lib/utils";
-import { GetOSInfo } from "../../wailsjs/go/main/App";
 import { Card, CardContent, CardDescription, CardHeader, CardTitle, } from "@/components/ui/card";
-import { Label } from "@/components/ui/label";
-import { Input } from "@/components/ui/input";
-import { Textarea } from "@/components/ui/textarea";
-import { ToggleGroup, ToggleGroupItem } from "@/components/ui/toggle-group";
-import { Bug, Lightbulb, ExternalLink, Star, GitFork, Clock, Download, CircleHelp, Blocks, Heart, } from "lucide-react";
+import { Star, GitFork, Clock, Download, Blocks, Heart, Copy, CircleCheck, Info } from "lucide-react";
 import AudioTTSProIcon from "@/assets/audiotts-pro.webp";
 import ChatGPTTTSIcon from "@/assets/chatgpt-tts.webp";
+import XIcon from "@/assets/x.webp";
 import XProIcon from "@/assets/x-pro.webp";
 import SpotubeDLIcon from "@/assets/icons/spotubedl.svg";
 import SpotiDownloaderIcon from "@/assets/icons/spotidownloader.svg";
 import XBatchDLIcon from "@/assets/icons/xbatchdl.svg";
 import SpotiFLACNextIcon from "@/assets/icons/next.svg";
-import KofiLogo from "@/assets/kofi_symbol.svg";
+import KofiLogo from "@/assets/ko-fi.gif";
+import KofiSvg from "@/assets/kofi_symbol.svg";
+import UsdtBarcode from "@/assets/usdt.jpg";
 import { langColors } from "@/assets/github-lang-colors";
-import { ScrollArea } from "@/components/ui/scroll-area";
-import { DragDropMedia } from "./DragDropTextarea";
-interface AboutPageProps {
-    version: string;
-}
-export function AboutPage({ version }: AboutPageProps) {
-    const [os, setOs] = useState("Unknown");
-    const [location, setLocation] = useState("Unknown");
-    const [activeTab, setActiveTab] = useState<"bug_report" | "feature_request" | "faq" | "projects" | "support">("bug_report");
-    const [bugType, setBugType] = useState("Track");
-    const [problem, setProblem] = useState("");
-    const [spotifyUrl, setSpotifyUrl] = useState("");
-    const [bugContext, setBugContext] = useState("");
-    const [featureDesc, setFeatureDesc] = useState("");
-    const [useCase, setUseCase] = useState("");
-    const [featureContext, setFeatureContext] = useState("");
+const browserExtensionItems = [
+    { icon: AudioTTSProIcon, label: "AudioTTS Pro", alt: "AudioTTS Pro" },
+    { icon: ChatGPTTTSIcon, label: "ChatGPT TTS", alt: "ChatGPT TTS" },
+    { icon: XIcon, label: "Twitter/X Media Batch Downloader", alt: "Twitter/X Media Batch Downloader" },
+    { icon: XProIcon, label: "Twitter/X Media Batch Downloader Pro", alt: "Twitter/X Media Batch Downloader Pro" },
+];
+const projectCardClass = "cursor-pointer transition-colors hover:bg-muted/50 dark:hover:bg-accent/50";
+export function AboutPage() {
+    const [activeTab, setActiveTab] = useState<"projects" | "support">("projects");
     const [repoStats, setRepoStats] = useState<Record<string, any>>({});
+    const [copiedUsdt, setCopiedUsdt] = useState(false);
     useEffect(() => {
-        const fetchOS = async () => {
-            try {
-                const info = await GetOSInfo();
-                setOs(info);
-            }
-            catch (err) {
-                const userAgent = window.navigator.userAgent;
-                if (userAgent.indexOf("Win") !== -1)
-                    setOs("Windows");
-                else if (userAgent.indexOf("Mac") !== -1)
-                    setOs("macOS");
-                else if (userAgent.indexOf("Linux") !== -1)
-                    setOs("Linux");
-            }
-        };
-        fetchOS();
-        const fetchLocation = async () => {
-            try {
-                const response = await fetch("https://ipapi.co/json/");
-                if (response.ok) {
-                    const data = await response.json();
-                    const city = data.city || "";
-                    const region = data.region || "";
-                    const country = data.country_name || "";
-                    const parts = [city, region, country].filter(Boolean);
-                    setLocation(parts.join(", ") || "Unknown");
-                }
-                else {
-                    const timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
-                    setLocation(timezone);
-                }
-            }
-            catch (err) {
-                const timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
-                setLocation(timezone);
-            }
-        };
-        fetchLocation();
         const fetchRepoStats = async () => {
-            const CACHE_KEY = "github_repo_stats";
+            const CACHE_KEY = "github_repo_stats_v4";
             const CACHE_DURATION = 1000 * 60 * 60;
             const cached = localStorage.getItem(CACHE_KEY);
             if (cached) {
@@ -109,13 +63,17 @@ export function AboutPage({ version }: AboutPageProps) {
                         }
                         return;
                     }
-                    if (repoRes.ok && releasesRes.ok && langsRes.ok) {
+                    if (repoRes.ok) {
                         const repoData = await repoRes.json();
-                        const releases = await releasesRes.json();
-                        const languages = await langsRes.json();
+                        const releases = releasesRes.ok ? await releasesRes.json() : [];
+                        const languages = langsRes.ok ? await langsRes.json() : {};
                         let totalDownloads = 0;
                         let latestDownloads = 0;
+                        let latestVersion = "";
+                        let latestReleaseAt = "";
                         if (releases.length > 0) {
+                            latestVersion = releases[0].tag_name || "";
+                            latestReleaseAt = releases[0].published_at || releases[0].created_at || "";
                             latestDownloads =
                                 releases[0].assets?.reduce((sum: number, asset: any) => sum + (asset.download_count || 0), 0) || 0;
                             totalDownloads = releases.reduce((sum: number, release: any) => {
@@ -131,8 +89,11 @@ export function AboutPage({ version }: AboutPageProps) {
                             stars: repoData.stargazers_count,
                             forks: repoData.forks_count,
                             createdAt: repoData.created_at,
+                            description: repoData.description,
                             totalDownloads,
                             latestDownloads,
+                            latestVersion,
+                            latestReleaseAt,
                             languages: topLangs,
                         };
                     }
@@ -151,28 +112,6 @@ export function AboutPage({ version }: AboutPageProps) {
         };
         fetchRepoStats();
     }, []);
-    const faqs = [
-        {
-            q: "Is this software free?",
-            a: "Yes. This software is completely free. You do not need an account, login, or subscription. All you need is an internet connection.",
-        },
-        {
-            q: "Can using this software get my Spotify account suspended or banned?",
-            a: "No. This software has no connection to your Spotify account. Spotify data is obtained through reverse engineering of the Spotify Web Player, not through user authentication.",
-        },
-        {
-            q: "Where does the audio come from?",
-            a: "The audio is fetched using third-party APIs.",
-        },
-        {
-            q: "Why does metadata fetching sometimes fail?",
-            a: "This usually happens because your IP address has been rate-limited. You can wait and try again later, or use a VPN to bypass the rate limit.",
-        },
-        {
-            q: "Why does Windows Defender or antivirus flag or delete the file?",
-            a: "This is a false positive. It likely happens because the executable is compressed using UPX. If you are concerned, you can fork the repository and build the software yourself from source.",
-        },
-    ];
     const formatTimeAgo = (dateString: string): string => {
         const now = new Date();
         const updated = new Date(dateString);
@@ -192,6 +131,39 @@ export function AboutPage({ version }: AboutPageProps) {
         const diffYears = Math.floor(diffMonths / 12);
         return `${diffYears}y`;
     };
+    const formatReleaseTimeAgo = (dateString: string): string => {
+        if (!dateString) {
+            return "";
+        }
+        const now = Date.now();
+        const releasedAt = new Date(dateString).getTime();
+        if (Number.isNaN(releasedAt)) {
+            return "";
+        }
+        const diffMs = Math.max(0, now - releasedAt);
+        const totalMinutes = Math.floor(diffMs / (1000 * 60));
+        const totalHours = Math.floor(totalMinutes / 60);
+        const totalDays = Math.floor(totalHours / 24);
+        const totalMonths = Math.floor(totalDays / 30);
+        const totalYears = Math.floor(totalMonths / 12);
+        if (totalYears > 0) {
+            const remainingMonths = totalMonths % 12;
+            return remainingMonths > 0 ? `${totalYears}y ${remainingMonths}m ago` : `${totalYears}y ago`;
+        }
+        if (totalMonths > 0) {
+            const remainingDays = totalDays % 30;
+            return remainingDays > 0 ? `${totalMonths}m ${remainingDays}d ago` : `${totalMonths}m ago`;
+        }
+        if (totalDays > 0) {
+            const remainingHours = totalHours % 24;
+            return remainingHours > 0 ? `${totalDays}d ${remainingHours}h ago` : `${totalDays}d ago`;
+        }
+        if (totalHours > 0) {
+            const remainingMinutes = totalMinutes % 60;
+            return `${totalHours}h ${remainingMinutes}m ago`;
+        }
+        return `${totalMinutes}m ago`;
+    };
     const formatNumber = (num: number): string => {
         if (num >= 1000) {
             return num.toLocaleString();
@@ -201,74 +173,15 @@ export function AboutPage({ version }: AboutPageProps) {
     const getLangColor = (lang: string): string => {
         return langColors[lang] || "#858585";
     };
-    const handleSubmit = () => {
-        const title = activeTab === "bug_report"
-            ? `[Bug Report] ${problem.substring(0, 50)}${problem.length > 50 ? "..." : ""}`
-            : `[Feature Request] ${featureDesc.substring(0, 50)}${featureDesc.length > 50 ? "..." : ""}`;
-        let bodyContent = "";
-        if (activeTab === "bug_report") {
-            const contextContent = bugContext.trim()
-                ? bugContext.trim()
-                : "Type here or send screenshot/recording";
-            bodyContent = `### [Bug Report]
-
-#### Problem
-${problem || "Type here"}
-
-#### Type
-${bugType}
-
-#### Spotify URL
-${spotifyUrl || "Type here"}
-
-#### Additional Context
-${contextContent}
-
-#### Environment
-- SpotiFLAC Version: ${version}
-- OS: ${os}
-- Location: ${location}`;
-        }
-        else {
-            const contextContent = featureContext.trim()
-                ? featureContext.trim()
-                : "Type here or send screenshot/recording";
-            bodyContent = `### [Feature Request]
-
-#### Description
-${featureDesc || "Type here"}
-
-#### Use Case
-${useCase || "Type here"}
-
-#### Additional Context
-${contextContent}`;
-        }
-        const params = new URLSearchParams({
-            title: title,
-            body: bodyContent,
-        });
-        const url = `https://github.com/afkarxyz/SpotiFLAC/issues/new?${params.toString()}`;
-        openExternal(url);
+    const getRepoDescription = (repoName: string): string => {
+        return repoStats[repoName]?.description || "";
     };
-    return (<div className={`flex flex-col space-y-4 ${activeTab === "faq" ? "h-[calc(100vh-10rem)]" : ""}`}>
+    return (<div className="flex flex-col space-y-4">
       <div className="flex items-center justify-between shrink-0">
         <h2 className="text-2xl font-bold tracking-tight">About</h2>
       </div>
 
       <div className="flex gap-2 border-b shrink-0">
-        <Button variant={activeTab === "bug_report" ? "default" : "ghost"} size="sm" onClick={() => setActiveTab("bug_report")} className="rounded-b-none">
-          <Bug className="h-4 w-4"/>
-          Bug Report
-        </Button>
-        <Button variant={activeTab === "feature_request" ? "default" : "ghost"} size="sm" onClick={() => setActiveTab("feature_request")} className="rounded-b-none">
-          <Lightbulb className="h-4 w-4"/>
-          Feature Request
-        </Button>
-        <Button variant={activeTab === "faq" ? "default" : "ghost"} size="sm" onClick={() => setActiveTab("faq")} className="rounded-b-none">
-          <CircleHelp className="h-4 w-4"/>
-          FAQ
-        </Button>
         <Button variant={activeTab === "projects" ? "default" : "ghost"} size="sm" onClick={() => setActiveTab("projects")} className="rounded-b-none">
           <Blocks className="h-4 w-4"/>
           Other Projects
@@ -279,135 +192,83 @@ ${contextContent}`;
         </Button>
       </div>
 
-      <div className={`flex-1 min-h-0 ${activeTab === "faq" ? "overflow-hidden" : ""}`}>
-        {activeTab === "bug_report" && (<div className="flex flex-col">
-            <div className="space-y-4 pt-4 flex flex-col">
-              <div className="mt-4 pr-2">
-                <div className="grid md:grid-cols-3 gap-6">
-                  <div className="space-y-2 flex flex-col">
-                    <Label>Problem</Label>
-                    <Textarea className="h-56 resize-none" placeholder="Describe the problem..." value={problem} onChange={(e) => setProblem(e.target.value)}/>
-                  </div>
-                  <div className="space-y-2 flex flex-col">
-                    <Label>Additional Context</Label>
-                    <DragDropMedia className="min-h-[14rem]" value={bugContext} onChange={setBugContext}/>
-                  </div>
-                  <div className="space-y-4 flex flex-col">
-                    <div className="space-y-2">
-                      <Label>Type</Label>
-                      <ToggleGroup type="single" value={bugType} onValueChange={(val) => {
-                if (val)
-                    setBugType(val);
-            }} className="justify-start w-full cursor-pointer">
-                        <ToggleGroupItem value="Track" className="flex-1 cursor-pointer" aria-label="Toggle track">
-                          Track
-                        </ToggleGroupItem>
-                        <ToggleGroupItem value="Album" className="flex-1 cursor-pointer" aria-label="Toggle album">
-                          Album
-                        </ToggleGroupItem>
-                        <ToggleGroupItem value="Playlist" className="flex-1 cursor-pointer" aria-label="Toggle playlist">
-                          Playlist
-                        </ToggleGroupItem>
-                        <ToggleGroupItem value="Artist" className="flex-1 cursor-pointer" aria-label="Toggle artist">
-                          Artist
-                        </ToggleGroupItem>
-                      </ToggleGroup>
-                    </div>
-                    <div className="space-y-2">
-                      <Label>Spotify URL</Label>
-                      <Input placeholder="https://open.spotify.com/..." value={spotifyUrl} onChange={(e) => setSpotifyUrl(e.target.value)}/>
-                    </div>
-                  </div>
-                </div>
-              </div>
-            </div>
-            <div className="flex justify-center pt-4 shrink-0">
-              <Button className="w-[200px] cursor-pointer gap-2" onClick={handleSubmit}>
-                <ExternalLink className="h-4 w-4"/> Create Issue on GitHub
-              </Button>
-            </div>
-          </div>)}
+      <div className="flex-1 min-h-0">
 
-        {activeTab === "feature_request" && (<div className="flex flex-col">
-            <div className="space-y-4 pt-4 flex flex-col">
-              <div className="mt-4 pr-2">
-                <div className="grid md:grid-cols-3 gap-6">
-                  <div className="space-y-2 flex flex-col">
-                    <Label>Description</Label>
-                    <Textarea className="h-56 resize-none" placeholder="Describe your feature request..." value={featureDesc} onChange={(e) => setFeatureDesc(e.target.value)}/>
-                  </div>
-                  <div className="space-y-2 flex-col">
-                    <Label>Use Case</Label>
-                    <Textarea className="h-56 resize-none" placeholder="How would this feature be useful?" value={useCase} onChange={(e) => setUseCase(e.target.value)}/>
-                  </div>
-                  <div className="space-y-2 flex-col">
-                    <Label>Additional Context</Label>
-                    <DragDropMedia className="min-h-[14rem]" value={featureContext} onChange={setFeatureContext}/>
-                  </div>
-                </div>
-              </div>
-            </div>
-            <div className="flex justify-center pt-4 shrink-0">
-              <Button className="w-[200px] cursor-pointer gap-2" onClick={handleSubmit}>
-                <ExternalLink className="h-4 w-4"/> Create Issue on GitHub
-              </Button>
-            </div>
-          </div>)}
-
-        {activeTab === "faq" && (<ScrollArea className="h-full">
-            <div className="p-1 pr-4">
-              <Card>
-                <CardHeader>
-                  <CardTitle>Frequently Asked Questions</CardTitle>
-                </CardHeader>
-                <CardContent className="space-y-6">
-                  {faqs.map((faq, index) => (<div key={index} className="space-y-2">
-                      <h3 className="font-medium text-base text-foreground/90">
-                        {faq.q}
-                      </h3>
-                      <p className="text-sm text-muted-foreground leading-relaxed">
-                        {faq.a}
-                      </p>
-                    </div>))}
-                </CardContent>
-              </Card>
-            </div>
-          </ScrollArea>)}
 
         {activeTab === "projects" && (<div className="p-1 pr-2">
             <div className="grid gap-2 grid-cols-4">
-              <div className="flex flex-col gap-2 h-full">
-                <Card className="hover:bg-muted/50 hover:border-primary/50 transition-colors cursor-pointer flex-1" onClick={() => openExternal("https://exyezed.cc/")}>
-                  <CardHeader>
-                    <CardTitle>Browser Extensions & Scripts</CardTitle>
-                    <CardDescription className="flex gap-3 pt-2">
-                      <img src={AudioTTSProIcon} className="h-8 w-8 rounded-md shadow-sm" alt="AudioTTS Pro"/>
-                      <img src={ChatGPTTTSIcon} className="h-8 w-8 rounded-md shadow-sm" alt="ChatGPT TTS"/>
-                      <img src={XProIcon} className="h-8 w-8 rounded-md shadow-sm" alt="X Pro"/>
-                    </CardDescription>
-                  </CardHeader>
-                </Card>
-                <Card className="hover:bg-muted/50 hover:border-primary/50 transition-colors cursor-pointer flex-1" onClick={() => openExternal("https://spotubedl.com/")}>
-                  <CardHeader>
-                    <CardTitle className="flex items-center gap-2">
-                      <img src={SpotubeDLIcon} className="h-5 w-5" alt="SpotubeDL"/>{" "}
-                      SpotubeDL
-                    </CardTitle>
-                    <CardDescription>
-                      Download Spotify Tracks, Albums, Playlists as MP3/OGG/Opus
-                      with High Quality.
-                    </CardDescription>
-                  </CardHeader>
-                </Card>
-              </div>
-              <Card className="hover:bg-muted/50 hover:border-primary/50 transition-colors cursor-pointer" onClick={() => openExternal("https://github.com/afkarxyz/SpotiDownloader")}>
+              <Card className={`gap-2 ${projectCardClass}`} onClick={() => openExternal("https://github.com/spotiverse/SpotiFLAC-Next")}>
                 <CardHeader>
-                  <CardTitle className="flex items-center gap-2">
-                    <img src={SpotiDownloaderIcon} className="h-5 w-5" alt="SpotiDownloader"/>{" "}
+                  <div className="flex justify-between items-start mb-2">
+                    <img src={SpotiFLACNextIcon} className="h-6 w-6 shrink-0" alt="SpotiFLAC Next"/>
+                    <div className="flex items-center gap-2">
+                      {repoStats["SpotiFLAC-Next"]?.latestReleaseAt && (<span className="text-[10px] text-muted-foreground whitespace-nowrap">
+                          {formatReleaseTimeAgo(repoStats["SpotiFLAC-Next"].latestReleaseAt)}
+                        </span>)}
+                      {repoStats["SpotiFLAC-Next"]?.latestVersion && (<span className="text-[10px] bg-primary text-primary-foreground px-1.5 py-0.5 rounded-sm font-mono font-semibold max-w-[80px] truncate">
+                          {repoStats["SpotiFLAC-Next"].latestVersion}
+                        </span>)}
+                    </div>
+                  </div>
+                  <CardTitle className="leading-tight">
+                    SpotiFLAC Next
+                  </CardTitle>
+                  <CardDescription>
+                    {getRepoDescription("SpotiFLAC-Next")}
+                  </CardDescription>
+                </CardHeader>
+                {repoStats["SpotiFLAC-Next"] && (<CardContent className="space-y-2">
+                    {repoStats["SpotiFLAC-Next"].languages?.length > 0 && (<div className="flex flex-wrap gap-2 text-xs">
+                        {repoStats["SpotiFLAC-Next"].languages.map((lang: string) => (<span key={lang} className="px-2 py-0.5 rounded-full font-medium" style={{
+                            backgroundColor: getLangColor(lang) + "20",
+                            color: getLangColor(lang),
+                        }}>
+                            {lang}
+                          </span>))}
+                      </div>)}
+                    <div className="flex items-center gap-4 text-xs text-muted-foreground">
+                      <span className="flex items-center gap-1">
+                        <Star className="h-3.5 w-3.5 fill-amber-500 text-amber-500"/>{" "}
+                        {formatNumber(repoStats["SpotiFLAC-Next"].stars)}
+                      </span>
+                      <span className="flex items-center gap-1">
+                        <GitFork className="h-3.5 w-3.5"/>{" "}
+                        {repoStats["SpotiFLAC-Next"].forks}
+                      </span>
+                      <span className="flex items-center gap-1">
+                        <Clock className="h-3.5 w-3.5"/>{" "}
+                        {formatTimeAgo(repoStats["SpotiFLAC-Next"].createdAt)}
+                      </span>
+                    </div>
+                    <div className="rounded-md border border-sky-500/25 bg-sky-500/8 px-3 py-2">
+                      <div className="mb-1 flex items-center gap-1.5 text-xs font-semibold text-sky-700 dark:text-sky-300">
+                        <Info className="h-3.5 w-3.5"/>
+                        Note
+                      </div>
+                      <p className="text-xs leading-relaxed text-sky-700 dark:text-sky-300">
+                        This project was created as a thank-you to everyone who has supported SpotiFLAC on Ko-fi.
+                      </p>
+                    </div>
+                  </CardContent>)}
+              </Card>
+              <Card className={projectCardClass} onClick={() => openExternal("https://github.com/afkarxyz/SpotiDownloader")}>
+                <CardHeader>
+                  <div className="flex justify-between items-start mb-2">
+                    <img src={SpotiDownloaderIcon} className="h-6 w-6 shrink-0" alt="SpotiDownloader"/>
+                    <div className="flex items-center gap-2">
+                      {repoStats["SpotiDownloader"]?.latestReleaseAt && (<span className="text-[10px] text-muted-foreground whitespace-nowrap">
+                          {formatReleaseTimeAgo(repoStats["SpotiDownloader"].latestReleaseAt)}
+                        </span>)}
+                      {repoStats["SpotiDownloader"]?.latestVersion && (<span className="text-[10px] bg-primary text-primary-foreground px-1.5 py-0.5 rounded-sm font-mono font-semibold max-w-[80px] truncate">
+                          {repoStats["SpotiDownloader"].latestVersion}
+                        </span>)}
+                    </div>
+                  </div>
+                  <CardTitle className="leading-tight">
                     SpotiDownloader
                   </CardTitle>
                   <CardDescription>
-                    Get Spotify tracks in MP3 and FLAC via spotidownloader.com
+                    {getRepoDescription("SpotiDownloader")}
                   </CardDescription>
                 </CardHeader>
                 {repoStats["SpotiDownloader"] && (<CardContent className="space-y-3">
@@ -445,61 +306,24 @@ ${contextContent}`;
                     </div>
                   </CardContent>)}
               </Card>
-              <Card className="hover:bg-muted/50 hover:border-primary/50 transition-colors cursor-pointer" onClick={() => openExternal("https://github.com/spotiverse/SpotiFLAC-Next")}>
+              <Card className={projectCardClass} onClick={() => openExternal("https://github.com/afkarxyz/Twitter-X-Media-Batch-Downloader")}>
                 <CardHeader>
-                  <CardTitle className="flex items-center gap-2">
-                    <img src={SpotiFLACNextIcon} className="h-5 w-5" alt="SpotiFLAC Next"/>{" "}
-                    SpotiFLAC Next
-                  </CardTitle>
-                  <CardDescription>
-                    Get Spotify tracks in Hi-Res lossless FLACs — no account
-                    required.
-                  </CardDescription>
-                </CardHeader>
-                {repoStats["SpotiFLAC-Next"] && (<CardContent className="space-y-3">
-                    <div className="flex flex-wrap gap-2 text-xs">
-                      {repoStats["SpotiFLAC-Next"].languages?.map((lang: string) => (<span key={lang} className="px-2 py-0.5 rounded-full font-medium" style={{
-                        backgroundColor: getLangColor(lang) + "20",
-                        color: getLangColor(lang),
-                    }}>
-                            {lang}
-                          </span>))}
+                  <div className="flex justify-between items-start mb-2">
+                    <img src={XBatchDLIcon} className="h-6 w-6 shrink-0" alt="Twitter/X Media Batch Downloader"/>
+                    <div className="flex items-center gap-2">
+                      {repoStats["Twitter-X-Media-Batch-Downloader"]?.latestReleaseAt && (<span className="text-[10px] text-muted-foreground whitespace-nowrap">
+                          {formatReleaseTimeAgo(repoStats["Twitter-X-Media-Batch-Downloader"].latestReleaseAt)}
+                        </span>)}
+                      {repoStats["Twitter-X-Media-Batch-Downloader"]?.latestVersion && (<span className="text-[10px] bg-primary text-primary-foreground px-1.5 py-0.5 rounded-sm font-mono font-semibold max-w-[80px] truncate">
+                          {repoStats["Twitter-X-Media-Batch-Downloader"].latestVersion}
+                        </span>)}
                     </div>
-                    <div className="flex items-center gap-4 text-xs text-muted-foreground">
-                      <span className="flex items-center gap-1">
-                        <Star className="h-3.5 w-3.5 fill-amber-500 text-amber-500"/>{" "}
-                        {formatNumber(repoStats["SpotiFLAC-Next"].stars)}
-                      </span>
-                      <span className="flex items-center gap-1">
-                        <GitFork className="h-3.5 w-3.5"/>{" "}
-                        {repoStats["SpotiFLAC-Next"].forks}
-                      </span>
-                      <span className="flex items-center gap-1">
-                        <Clock className="h-3.5 w-3.5"/>{" "}
-                        {formatTimeAgo(repoStats["SpotiFLAC-Next"].createdAt)}
-                      </span>
-                    </div>
-                    <div className="flex flex-col gap-1 text-xs text-muted-foreground items-start">
-                      <span className="flex items-center gap-1">
-                        <Download className="h-3.5 w-3.5"/> TOTAL:{" "}
-                        {formatNumber(repoStats["SpotiFLAC-Next"].totalDownloads)}
-                      </span>
-                      <span className="flex items-center gap-1 text-green-600 dark:text-green-400">
-                        <Download className="h-3.5 w-3.5"/> LATEST:{" "}
-                        {formatNumber(repoStats["SpotiFLAC-Next"].latestDownloads)}
-                      </span>
-                    </div>
-                  </CardContent>)}
-              </Card>
-              <Card className="hover:bg-muted/50 hover:border-primary/50 transition-colors cursor-pointer" onClick={() => openExternal("https://github.com/afkarxyz/Twitter-X-Media-Batch-Downloader")}>
-                <CardHeader>
-                  <CardTitle className="flex items-center gap-2">
-                    <img src={XBatchDLIcon} className="h-5 w-5" alt="Twitter/X Media Batch Downloader"/>{" "}
+                  </div>
+                  <CardTitle className="leading-tight">
                     Twitter/X Media Batch Downloader
                   </CardTitle>
                   <CardDescription>
-                    A GUI tool to download original-quality images and videos
-                    from Twitter/X accounts, powered by gallery-dl by @mikf
+                    {getRepoDescription("Twitter-X-Media-Batch-Downloader")}
                   </CardDescription>
                 </CardHeader>
                 {repoStats["Twitter-X-Media-Batch-Downloader"] && (<CardContent className="space-y-3">
@@ -540,24 +364,81 @@ ${contextContent}`;
                     </div>
                   </CardContent>)}
               </Card>
+              <div className="flex flex-col gap-2 h-full">
+                <Card className={`${projectCardClass} flex-1`} onClick={() => openExternal("https://exyezed.qzz.io/")}>
+                    <CardHeader>
+                    <CardTitle>Browser Extensions & Scripts</CardTitle>
+                    <CardDescription className="flex flex-col gap-2 pt-2">
+                      {browserExtensionItems.map((item) => (<div key={item.alt} className="flex items-center gap-2">
+                          <img src={item.icon} className="h-[22px] w-[22px] rounded-sm shadow-sm" alt={item.alt}/>
+                          <span className="text-[11px] leading-tight text-muted-foreground">
+                            {item.label}
+                          </span>
+                        </div>))}
+                    </CardDescription>
+                  </CardHeader>
+                </Card>
+                <Card className={`${projectCardClass} flex-1`} onClick={() => openExternal("https://spotubedl.com/")}>
+                  <CardHeader>
+                    <CardTitle className="flex items-center gap-2">
+                      <img src={SpotubeDLIcon} className="h-5 w-5" alt="SpotubeDL"/>{" "}
+                      SpotubeDL
+                    </CardTitle>
+                    <CardDescription>
+                      Download Spotify Tracks, Albums, Playlists as MP3/OGG/Opus
+                      with High Quality.
+                    </CardDescription>
+                  </CardHeader>
+                </Card>
+              </div>
             </div>
           </div>)}
 
-        {activeTab === "support" && (<div className="flex flex-col items-center justify-center p-8 space-y-8">
-            <div className="text-center space-y-2">
-              <h3 className="text-2xl font-bold tracking-tight">Support Me</h3>
-              <p className="text-muted-foreground max-w-[500px]">
-                If this software is useful and brings you value, consider
-                supporting the project on Ko-fi. Your support helps keep
-                development going.
-              </p>
-            </div>
+        {activeTab === "support" && (<div className="flex flex-col items-center justify-center p-4 space-y-6">
+            <div className="flex flex-col md:flex-row w-full max-w-3xl bg-card rounded-xl border shadow-sm">
+              
+              <div className="flex-1 p-6 flex flex-col items-center justify-between border-b md:border-b-0 md:border-r space-y-6">
+                <div className="flex flex-col items-center space-y-4">
+                  <div className="h-32 flex items-center justify-center w-full relative">
+                    <img src={KofiLogo} className="w-72 absolute pointer-events-none" alt="Ko-fi"/>
+                  </div>
+                  <h4 className="font-semibold text-foreground">Support via Ko-fi</h4>
+                  <p className="text-sm text-muted-foreground text-center px-4">
+                    Enjoying the project? You can support ongoing development by buying me a coffee.
+                  </p>
+                </div>
+                <Button className="h-10 w-full text-sm font-semibold text-white gap-2 group bg-[#72a4f2] hover:bg-[#5f8cd6]" onClick={() => openExternal("https://ko-fi.com/afkarxyz")}>
+                  <img src={KofiSvg} className="w-5 h-5 shrink-0" alt="" aria-hidden="true"/>
+                  Support me on Ko-fi
+                </Button>
+              </div>
 
-            <div className="flex justify-center w-full max-w-lg">
-              <Button size="lg" className="h-16 text-lg font-semibold text-white gap-3 group" style={{ backgroundColor: "#72a4f2" }} onClick={() => openExternal("https://ko-fi.com/afkarxyz")}>
-                <img src={KofiLogo} className="h-8 w-8 transition-transform group-hover:scale-110" alt="Ko-fi"/>
-                Support me on Ko-fi
-              </Button>
+              
+              <div className="flex-1 p-6 flex flex-col items-center justify-between space-y-6">
+                <div className="flex flex-col items-center space-y-4 w-full">
+                  <div className="h-32 flex items-center justify-center">
+                    <div className="p-2 bg-white rounded-xl shadow-sm border">
+                      <img src={UsdtBarcode} className="w-24 h-24 object-contain" alt="USDT Barcode"/>
+                    </div>
+                  </div>
+                  <h4 className="font-semibold text-foreground">USDT (TRC20)</h4>
+                  <p className="text-sm text-muted-foreground text-center px-4">
+                    Crypto donations are also accepted. Scan the QR code or copy the address.
+                  </p>
+                </div>
+                <div className="flex items-center gap-2 bg-muted/50 pl-3 pr-1.5 py-1.5 rounded-lg border w-full justify-between h-10">
+                  <code className="text-xs font-mono text-muted-foreground truncate" title="THnzAAwZgp2Sq5CAXLP2njQDhTvgZG9EWs">
+                    THnzAAwZgp2Sq5CAXLP2njQDhTvgZG9EWs
+                  </code>
+                  <Button variant="ghost" size="icon" className="h-7 w-7 shrink-0 hover:bg-background" onClick={() => {
+                navigator.clipboard.writeText("THnzAAwZgp2Sq5CAXLP2njQDhTvgZG9EWs");
+                setCopiedUsdt(true);
+                setTimeout(() => setCopiedUsdt(false), 500);
+            }}>
+                    {copiedUsdt ? <CircleCheck className="h-3.5 w-3.5 text-green-500"/> : <Copy className="h-3.5 w-3.5"/>}
+                  </Button>
+                </div>
+              </div>
             </div>
           </div>)}
       </div>

frontend/src/components/AlbumInfo.tsx

@@ -6,6 +6,12 @@ import { Tooltip, TooltipContent, TooltipTrigger } from "@/components/ui/tooltip
 import { SearchAndSort } from "./SearchAndSort";
 import { TrackList } from "./TrackList";
 import { DownloadProgress } from "./DownloadProgress";
+import { getSettings } from "@/lib/settings";
+import { downloadCover } from "@/lib/api";
+import { useState } from "react";
+import { toastWithSound as toast } from "@/lib/toast-with-sound";
+import { joinPath, sanitizePath } from "@/lib/utils";
+import { parseTemplate, type TemplateData } from "@/lib/settings";
 import type { TrackMetadata, TrackAvailability } from "@/types/api";
 interface AlbumInfoProps {
     albumInfo: {
@@ -70,6 +76,65 @@ interface AlbumInfoProps {
     onBack?: () => void;
 }
 export function AlbumInfo({ albumInfo, trackList, searchQuery, sortBy, selectedTracks, downloadedTracks, failedTracks, skippedTracks, downloadingTrack, isDownloading, bulkDownloadType, downloadProgress, currentDownloadInfo, currentPage, itemsPerPage, downloadedLyrics, failedLyrics, skippedLyrics, downloadingLyricsTrack, checkingAvailabilityTrack, availabilityMap, downloadedCovers, failedCovers, skippedCovers, downloadingCoverTrack, isBulkDownloadingCovers, isBulkDownloadingLyrics, onSearchChange, onSortChange, onToggleTrack, onToggleSelectAll, onDownloadTrack, onDownloadLyrics, onDownloadCover, onCheckAvailability, onDownloadAllLyrics, onDownloadAllCovers, onDownloadAll, onDownloadSelected, onStopDownload, onOpenFolder, onPageChange, onArtistClick, onTrackClick, onBack, }: AlbumInfoProps) {
+    const settings = getSettings();
+    const [downloadingAlbumCover, setDownloadingAlbumCover] = useState(false);
+    const handleDownloadAlbumCover = async () => {
+        if (!albumInfo.images)
+            return;
+        setDownloadingAlbumCover(true);
+        try {
+            const os = settings.operatingSystem;
+            let outputDir = settings.downloadPath;
+            const albumName = albumInfo.name;
+            const artistName = albumInfo.artists;
+            const placeholder = "__SLASH_PLACEHOLDER__";
+            const templateData: TemplateData = {
+                artist: artistName?.replace(/\//g, placeholder),
+                album: albumName?.replace(/\//g, placeholder),
+                album_artist: artistName?.replace(/\//g, placeholder),
+                title: albumName?.replace(/\//g, placeholder),
+                year: albumInfo.release_date?.substring(0, 4),
+                date: albumInfo.release_date,
+            };
+            if (settings.folderTemplate) {
+                const folderPath = parseTemplate(settings.folderTemplate, templateData);
+                if (folderPath) {
+                    const parts = folderPath.split("/").filter((p: string) => p.trim());
+                    for (const part of parts) {
+                        outputDir = joinPath(os, outputDir, sanitizePath(part.replace(new RegExp(placeholder, "g"), " "), os));
+                    }
+                }
+            }
+            const response = await downloadCover({
+                cover_url: albumInfo.images,
+                track_name: albumName,
+                artist_name: "",
+                album_name: "",
+                album_artist: "",
+                release_date: "",
+                output_dir: outputDir,
+                filename_format: "title",
+                track_number: false,
+                position: 0,
+                disc_number: 0,
+            });
+            if (response.success) {
+                if (response.already_exists)
+                    toast.info("Cover already exists");
+                else
+                    toast.success("Separate album cover downloaded");
+            }
+            else {
+                toast.error(response.error || "Failed to download cover");
+            }
+        }
+        catch (err) {
+            toast.error(err instanceof Error ? err.message : "Failed to download cover");
+        }
+        finally {
+            setDownloadingAlbumCover(false);
+        }
+    };
     return (<div className="space-y-6">
       <Card className="relative">
       {onBack && (<div className="absolute top-4 right-4 z-10">
@@ -79,7 +144,19 @@ export function AlbumInfo({ albumInfo, trackList, searchQuery, sortBy, selectedT
       </div>)}
         <CardContent className="px-6">
           <div className="flex gap-6 items-start">
-            {albumInfo.images && (<img src={albumInfo.images} alt={albumInfo.name} className="w-48 h-48 rounded-md shadow-lg object-cover"/>)}
+            {albumInfo.images && (<div className="relative group shrink-0 w-48 h-48">
+                <img src={albumInfo.images} alt={albumInfo.name} className="w-48 h-48 rounded-md shadow-lg object-cover"/>
+                <div className="absolute inset-0 flex items-center justify-center bg-black/40 opacity-0 group-hover:opacity-100 transition-opacity rounded-md">
+                  <Tooltip>
+                    <TooltipTrigger asChild>
+                      <Button variant="secondary" size="icon" className="h-9 w-9 shadow-lg" onClick={handleDownloadAlbumCover} disabled={downloadingAlbumCover}>
+                        {downloadingAlbumCover ? <Spinner /> : <ImageDown className="h-4 w-4"/>}
+                      </Button>
+                    </TooltipTrigger>
+                    <TooltipContent><p>Download Separate Album Cover</p></TooltipContent>
+                  </Tooltip>
+                </div>
+              </div>)}
             <div className="flex-1 space-y-4">
               <div className="space-y-2">
                 <p className="text-sm font-medium">Album</p>
@@ -126,13 +203,19 @@ export function AlbumInfo({ albumInfo, trackList, searchQuery, sortBy, selectedT
                       </Button>
                     </TooltipTrigger>
                     <TooltipContent>
-                      <p>Download All Covers</p>
+                      <p>Download All Separate Covers</p>
+                    </TooltipContent>
+                  </Tooltip>)}
+                {downloadedTracks.size > 0 && (<Tooltip>
+                    <TooltipTrigger asChild>
+                      <Button onClick={onOpenFolder} variant="outline" size="icon">
+                        <FolderOpen className="h-4 w-4"/>
+                      </Button>
+                    </TooltipTrigger>
+                    <TooltipContent>
+                      <p>Open Folder</p>
                     </TooltipContent>
                   </Tooltip>)}
-                {downloadedTracks.size > 0 && (<Button onClick={onOpenFolder} variant="outline">
-                    <FolderOpen className="h-4 w-4"/>
-                    Open Folder
-                  </Button>)}
               </div>
               {isDownloading && (<DownloadProgress progress={downloadProgress} currentTrack={currentDownloadInfo} onStop={onStopDownload}/>)}
             </div>

frontend/src/components/ApiStatusTab.tsx

@@ -0,0 +1,34 @@
+import { Button } from "@/components/ui/button";
+import { RefreshCw, CheckCircle2, XCircle, Loader2 } from "lucide-react";
+import { TidalIcon, QobuzIcon, AmazonIcon } from "./PlatformIcons";
+import { useApiStatus } from "@/hooks/useApiStatus";
+export function ApiStatusTab() {
+    const { sources, statuses, isCheckingAll, refreshAll } = useApiStatus();
+    return (<div className="space-y-6">
+      <div className="flex items-center justify-end">
+        <Button variant="outline" onClick={() => void refreshAll()} disabled={isCheckingAll} className="gap-2">
+          <RefreshCw className={`h-4 w-4 ${isCheckingAll ? "animate-spin" : ""}`}/>
+          Refresh All
+        </Button>
+      </div>
+
+      <div className="grid grid-cols-4 gap-4">
+        {sources.map((source) => {
+            const status = statuses[source.id] || "idle";
+            return (<div key={source.id} className="flex items-center justify-between p-4 border rounded-lg bg-card text-card-foreground shadow-sm">
+              <div className="flex items-center gap-3">
+                {source.type === "tidal" ? <TidalIcon className="w-5 h-5 shrink-0 text-muted-foreground"/> : source.type === "amazon" ? <AmazonIcon className="w-5 h-5 shrink-0 text-muted-foreground"/> : <QobuzIcon className="w-5 h-5 shrink-0 text-muted-foreground"/>}
+                <p className="font-medium leading-none">{source.name}</p>
+              </div>
+              
+              <div className="flex items-center">
+                {status === "checking" && <Loader2 className="h-5 w-5 animate-spin text-muted-foreground"/>}
+                {status === "online" && <CheckCircle2 className="h-5 w-5 text-emerald-500"/>}
+                {status === "offline" && <XCircle className="h-5 w-5 text-destructive"/>}
+                {status === "idle" && <div className="h-5 w-5 rounded-full bg-muted"/>}
+              </div>
+            </div>);
+        })}
+      </div>
+    </div>);
+}

frontend/src/components/ArtistInfo.tsx

@@ -21,6 +21,7 @@ interface ArtistInfoProps {
         header?: string;
         gallery?: string[];
         followers: number;
+        total_albums?: number;
         genres: string[];
         biography?: string;
         verified?: boolean;
@@ -99,6 +100,31 @@ export function ArtistInfo({ artistInfo, albumList, trackList, searchQuery, sort
     const [downloadingGalleryIndex, setDownloadingGalleryIndex] = useState<number | null>(null);
     const [downloadingAllGallery, setDownloadingAllGallery] = useState(false);
     const [activeTab, setActiveTab] = useState<"albums" | "tracks" | "gallery">("albums");
+    const [activeAlbumFilter, setActiveAlbumFilter] = useState<string>("all");
+    const displayedAlbumCount = artistInfo.total_albums || albumList.length;
+    const albumFilterCounts = useMemo(() => {
+        const counts = new Map<string, number>();
+        counts.set("all", (albumList || []).length);
+        for (const album of albumList || []) {
+            const type = (album.album_type || "").trim().toLowerCase();
+            if (!type)
+                continue;
+            counts.set(type, (counts.get(type) || 0) + 1);
+        }
+        return counts;
+    }, [albumList]);
+    const albumFilters = useMemo(() => {
+        const uniqueTypes = Array.from(new Set((albumList || [])
+            .map((album) => (album.album_type || "").trim().toLowerCase())
+            .filter(Boolean)));
+        return ["all", ...uniqueTypes];
+    }, [albumList]);
+    const filteredAlbums = useMemo(() => {
+        if (activeAlbumFilter === "all") {
+            return albumList || [];
+        }
+        return (albumList || []).filter((album) => (album.album_type || "").trim().toLowerCase() === activeAlbumFilter);
+    }, [albumList, activeAlbumFilter]);
     const filteredAlbumGroups = useMemo(() => {
         const albumTypeMap = new Map(albumList.map(a => [a.name, a.album_type]));
         const albumGroups = trackList.reduce((acc, track) => {
@@ -125,6 +151,17 @@ export function ArtistInfo({ artistInfo, albumList, trackList, searchQuery, sort
             return dateB.localeCompare(dateA);
         });
     }, [trackList, albumList]);
+    const formatAlbumFilterLabel = (value: string) => {
+        const count = albumFilterCounts.get(value) || 0;
+        if (value === "all")
+            return `All (${count})`;
+        const label = value
+            .split(/[_\s]+/)
+            .filter(Boolean)
+            .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+            .join(" ");
+        return `${label} (${count})`;
+    };
     const handleDownloadHeader = async () => {
         if (!artistInfo.header)
             return;
@@ -330,9 +367,9 @@ export function ArtistInfo({ artistInfo, albumList, trackList, searchQuery, sort
                         </>)}
                     </div>
                     <div className="flex items-center gap-2 text-sm flex-wrap text-white/90">
-                      <span>{albumList.length} {albumList.length === 1 ? "album" : "albums"}</span>
+                      <span>{displayedAlbumCount.toLocaleString()} {displayedAlbumCount === 1 ? "album" : "albums"}</span>
                       <span>•</span>
-                      <span>{trackList.length} {trackList.length === 1 ? "track" : "tracks"}</span>
+                      <span>{trackList.length.toLocaleString()} {trackList.length === 1 ? "track" : "tracks"}</span>
                       {artistInfo.genres.length > 0 && (<>
                           <span>•</span>
                           <span>{artistInfo.genres.join(", ")}</span>
@@ -383,9 +420,9 @@ export function ArtistInfo({ artistInfo, albumList, trackList, searchQuery, sort
                     </>)}
                 </div>
                 <div className="flex items-center gap-2 text-sm flex-wrap">
-                  <span>{albumList.length} {albumList.length === 1 ? "album" : "albums"}</span>
+                  <span>{displayedAlbumCount.toLocaleString()} {displayedAlbumCount === 1 ? "album" : "albums"}</span>
                   <span>•</span>
-                  <span>{trackList.length} {trackList.length === 1 ? "track" : "tracks"}</span>
+                  <span>{trackList.length.toLocaleString()} {trackList.length === 1 ? "track" : "tracks"}</span>
                   {artistInfo.genres.length > 0 && (<>
                       <span>•</span>
                       <span>{artistInfo.genres.join(", ")}</span>
@@ -412,7 +449,7 @@ export function ArtistInfo({ artistInfo, albumList, trackList, searchQuery, sort
 
       {activeTab === "gallery" && hasGallery && (<div className="space-y-4">
           <div className="flex items-center justify-between">
-            <h3 className="text-2xl font-bold">Gallery ({artistInfo.gallery!.length})</h3>
+            <h3 className="text-2xl font-bold">Gallery ({artistInfo.gallery!.length.toLocaleString()})</h3>
             <Tooltip>
               <TooltipTrigger asChild>
                 <Button onClick={handleDownloadAllGallery} size="sm" variant="outline" disabled={downloadingAllGallery}>
@@ -459,8 +496,13 @@ export function ArtistInfo({ artistInfo, albumList, trackList, searchQuery, sort
                     </Button>)}
             </div>
           </div>
+          {albumFilters.length > 1 && (<div className="flex flex-wrap gap-2">
+              {albumFilters.map((filter) => (<Button key={filter} size="sm" variant={activeAlbumFilter === filter ? "default" : "outline"} onClick={() => setActiveAlbumFilter(filter)}>
+                  {formatAlbumFilterLabel(filter)}
+                </Button>))}
+            </div>)}
           <div className="grid grid-cols-2 sm:grid-cols-3 md:grid-cols-4 lg:grid-cols-5 gap-4">
-            {albumList.map((album) => {
+            {filteredAlbums.map((album) => {
                 const albumTracks = trackList.filter(t => t.album_name === album.name);
                 const tracksWithId = albumTracks.filter(t => t.spotify_id);
                 const isSelected = tracksWithId.length > 0 && tracksWithId.every(t => selectedTracks.includes(t.spotify_id!));
@@ -493,6 +535,9 @@ export function ArtistInfo({ artistInfo, albumList, trackList, searchQuery, sort
               </div>);
             })}
           </div>
+          {filteredAlbums.length === 0 && (<div className="rounded-lg border border-dashed border-border p-6 text-sm text-muted-foreground">
+              No releases found for the selected discography filter.
+            </div>)}
         </div>)}
 
       {activeTab === "tracks" && trackList.length > 0 && (<div className="space-y-4">
@@ -562,13 +607,19 @@ export function ArtistInfo({ artistInfo, albumList, trackList, searchQuery, sort
                     </Button>
                   </TooltipTrigger>
                   <TooltipContent>
-                    <p>Download All Covers</p>
+                    <p>Download All Separate Covers</p>
+                  </TooltipContent>
+                </Tooltip>)}
+              {downloadedTracks.size > 0 && (<Tooltip>
+                  <TooltipTrigger asChild>
+                    <Button onClick={onOpenFolder} size="icon" variant="outline">
+                      <FolderOpen className="h-4 w-4"/>
+                    </Button>
+                  </TooltipTrigger>
+                  <TooltipContent>
+                    <p>Open Folder</p>
                   </TooltipContent>
                 </Tooltip>)}
-              {downloadedTracks.size > 0 && (<Button onClick={onOpenFolder} size="sm" variant="outline">
-                  <FolderOpen className="h-4 w-4"/>
-                  Open Folder
-                </Button>)}
             </div>
           </div>
           {isDownloading && (<DownloadProgress progress={downloadProgress} currentTrack={currentDownloadInfo} onStop={onStopDownload}/>)}

frontend/src/components/AudioAnalysis.tsx

@@ -1,7 +1,7 @@
 import { Card, CardContent, CardHeader } from "@/components/ui/card";
 import { Spinner } from "@/components/ui/spinner";
 import { Button } from "@/components/ui/button";
-import { Activity, Waves, Radio, TrendingUp, FileAudio, Clock, Gauge, HardDrive } from "lucide-react";
+import { Activity } from "lucide-react";
 import type { AnalysisResult } from "@/types/api";
 interface AudioAnalysisProps {
     result: AnalysisResult | null;
@@ -13,32 +13,32 @@ interface AudioAnalysisProps {
 export function AudioAnalysis({ result, analyzing, onAnalyze, showAnalyzeButton = true, filePath }: AudioAnalysisProps) {
     if (analyzing) {
         return (<Card>
-        <CardContent className="px-6">
-          <div className="flex items-center justify-center py-8 gap-3">
-            <Spinner />
-            <span className="text-muted-foreground">Analyzing audio quality...</span>
-          </div>
-        </CardContent>
-      </Card>);
+                <CardContent className="px-6">
+                    <div className="flex items-center justify-center py-8 gap-3">
+                        <Spinner />
+                        <span className="text-muted-foreground">Analyzing audio quality...</span>
+                    </div>
+                </CardContent>
+            </Card>);
     }
     if (!result && showAnalyzeButton) {
         return (<Card>
-        <CardContent className="px-6">
-          <div className="flex flex-col items-center justify-center py-8 gap-4">
-            <Activity className="h-12 w-12 text-primary"/>
-            <div className="text-center space-y-2">
-              <p className="font-medium">Audio Quality Analysis</p>
-              <p className="text-sm text-muted-foreground">
-                Verify the true lossless quality of downloaded files
-              </p>
-            </div>
-            {onAnalyze && (<Button onClick={onAnalyze}>
-                <Activity className="h-4 w-4"/>
-                Analyze Audio
-              </Button>)}
-          </div>
-        </CardContent>
-      </Card>);
+                <CardContent className="px-6">
+                    <div className="flex flex-col items-center justify-center py-8 gap-4">
+                        <Activity className="h-12 w-12 text-primary"/>
+                        <div className="text-center space-y-2">
+                            <p className="font-medium">Audio Quality Analysis</p>
+                            <p className="text-sm text-muted-foreground">
+                                Inspect spectral content and effective quality of FLAC, MP3, M4A, and AAC files
+                            </p>
+                        </div>
+                        {onAnalyze && (<Button onClick={onAnalyze}>
+                                <Activity className="h-4 w-4"/>
+                                Analyze Audio
+                            </Button>)}
+                    </div>
+                </CardContent>
+            </Card>);
     }
     if (!result) {
         return null;
@@ -46,7 +46,7 @@ export function AudioAnalysis({ result, analyzing, onAnalyze, showAnalyzeButton
     const formatDuration = (seconds: number) => {
         const mins = Math.floor(seconds / 60);
         const secs = Math.floor(seconds % 60);
-        return `${mins}:${secs.toString().padStart(2, '0')}`;
+        return `${mins}:${secs.toString().padStart(2, "0")}`;
     };
     const formatNumber = (num: number) => {
         return num.toFixed(2);
@@ -60,66 +60,120 @@ export function AudioAnalysis({ result, analyzing, onAnalyze, showAnalyzeButton
         return parseFloat((bytes / Math.pow(k, i)).toFixed(1)) + " " + sizes[i];
     };
     const nyquistFreq = result.sample_rate / 2;
+    const totalSamplesText = result.total_samples > 0 ? result.total_samples.toLocaleString() : "N/A";
+    const freqResolutionLabel = result.file_type === "MP3" ? "Freq Res.:" : "Freq Resolution:";
+    const hasCodecMeta = result.file_type === "MP3" && (Boolean(result.codec_mode) ||
+        typeof result.bitrate_kbps === "number" ||
+        typeof result.total_frames === "number" ||
+        Boolean(result.codec_version));
     return (<Card className="gap-2">
-      <CardHeader>
-        {filePath && (<p className="text-sm font-mono break-all">{filePath}</p>)}
-      </CardHeader>
+            <CardHeader className="pb-2">
+                {filePath && (<p className="text-sm font-mono break-all text-muted-foreground">{filePath}</p>)}
+            </CardHeader>
 
-      <CardContent className="space-y-2">
-        
-        <div className="flex flex-wrap items-center gap-x-3 gap-y-1 text-xs">
-          <div className="flex items-center gap-1">
-            <Radio className="h-3 w-3 text-muted-foreground"/>
-            <span className="text-muted-foreground">Sample Rate:</span>
-            <span className="font-semibold">{(result.sample_rate / 1000).toFixed(1)} kHz</span>
-          </div>
-          <div className="flex items-center gap-1">
-            <FileAudio className="h-3 w-3 text-muted-foreground"/>
-            <span className="text-muted-foreground">Bit Depth:</span>
-            <span className="font-semibold">{result.bit_depth}</span>
-          </div>
-          <div className="flex items-center gap-1">
-            <Waves className="h-3 w-3 text-muted-foreground"/>
-            <span className="text-muted-foreground">Channels:</span>
-            <span className="font-semibold">{result.channels === 2 ? "Stereo" : result.channels === 1 ? "Mono" : `${result.channels}`}</span>
-          </div>
-          <div className="flex items-center gap-1">
-            <Clock className="h-3 w-3 text-muted-foreground"/>
-            <span className="text-muted-foreground">Duration:</span>
-            <span className="font-semibold">{formatDuration(result.duration)}</span>
-          </div>
-          <div className="flex items-center gap-1">
-            <Gauge className="h-3 w-3 text-muted-foreground"/>
-            <span className="text-muted-foreground">Nyquist:</span>
-            <span className="font-semibold">{(nyquistFreq / 1000).toFixed(1)} kHz</span>
-          </div>
-          {result.file_size > 0 && (<div className="flex items-center gap-1">
-              <HardDrive className="h-3 w-3 text-muted-foreground"/>
-              <span className="text-muted-foreground">Size:</span>
-              <span className="font-semibold">{formatFileSize(result.file_size)}</span>
-            </div>)}
-        </div>
+            <CardContent>
+                <div className={`grid grid-cols-1 gap-6 md:grid-cols-2 ${hasCodecMeta ? "lg:grid-cols-4" : "lg:grid-cols-3"}`}>
+                    <div className="space-y-2">
+                        <p className="text-xs font-semibold tracking-wider text-muted-foreground uppercase">Format</p>
+                        <ul className="text-sm space-y-1">
+                            {result.file_type && (<li className="flex justify-between">
+                                    <span className="text-muted-foreground">Type:</span>
+                                    <span className="font-medium font-mono">{result.file_type}</span>
+                                </li>)}
+                            <li className="flex justify-between">
+                                <span className="text-muted-foreground">Sample Rate:</span>
+                                <span className="font-medium font-mono">{(result.sample_rate / 1000).toFixed(1)} kHz</span>
+                            </li>
+                            <li className="flex justify-between">
+                                <span className="text-muted-foreground">Bit Depth:</span>
+                                <span className="font-medium font-mono">{result.bit_depth}</span>
+                            </li>
+                            <li className="flex justify-between">
+                                <span className="text-muted-foreground">Channels:</span>
+                                <span className="font-medium font-mono">{result.channels === 2 ? "Stereo" : result.channels === 1 ? "Mono" : `${result.channels}`}</span>
+                            </li>
+                            <li className="flex justify-between">
+                                <span className="text-muted-foreground">Duration:</span>
+                                <span className="font-medium font-mono">{formatDuration(result.duration)}</span>
+                            </li>
+                            {result.file_size > 0 && (<li className="flex justify-between">
+                                    <span className="text-muted-foreground">Size:</span>
+                                    <span className="font-medium font-mono">{formatFileSize(result.file_size)}</span>
+                                </li>)}
+                        </ul>
+                    </div>
 
-        
-        <div className="flex flex-wrap items-center gap-x-3 gap-y-1 text-xs border-t pt-2">
-          <div className="flex items-center gap-1">
-            <TrendingUp className="h-3 w-3 text-muted-foreground"/>
-            <span className="text-muted-foreground">Dynamic Range:</span>
-            <span className="font-semibold">{formatNumber(result.dynamic_range)} dB</span>
-          </div>
-          <div className="flex items-center gap-1">
-            <span className="text-muted-foreground">Peak:</span>
-            <span className="font-semibold">{formatNumber(result.peak_amplitude)} dB</span>
-          </div>
-          <div className="flex items-center gap-1">
-            <span className="text-muted-foreground">RMS:</span>
-            <span className="font-semibold">{formatNumber(result.rms_level)} dB</span>
-          </div>
-          <div className="flex items-center gap-1 ml-auto">
-            <span className="text-muted-foreground">Samples:</span>
-            <span className="font-semibold">{result.total_samples.toLocaleString()}</span>
-          </div>
-        </div>
-      </CardContent>
-    </Card>);
+                    <div className="space-y-2">
+                        <p className="text-xs font-semibold tracking-wider text-muted-foreground uppercase">Signal Analytics</p>
+                        <ul className="text-sm space-y-1">
+                            <li className="flex justify-between">
+                                <span className="text-muted-foreground">Nyquist:</span>
+                                <span className="font-medium font-mono">{(nyquistFreq / 1000).toFixed(1)} kHz</span>
+                            </li>
+                            <li className="flex justify-between">
+                                <span className="text-muted-foreground">Dynamic Range:</span>
+                                <span className="font-medium font-mono">{formatNumber(result.dynamic_range)} dB</span>
+                            </li>
+                            <li className="flex justify-between">
+                                <span className="text-muted-foreground">Peak Amplitude:</span>
+                                <span className="font-medium font-mono">{formatNumber(result.peak_amplitude)} dB</span>
+                            </li>
+                            <li className="flex justify-between">
+                                <span className="text-muted-foreground">RMS Level:</span>
+                                <span className="font-medium font-mono">{formatNumber(result.rms_level)} dB</span>
+                            </li>
+                            <li className="flex justify-between">
+                                <span className="text-muted-foreground">Total Samples:</span>
+                                <span className="font-medium font-mono">{totalSamplesText}</span>
+                            </li>
+                        </ul>
+                    </div>
+
+                    {hasCodecMeta && (<div className="space-y-2">
+                            <p className="text-xs font-semibold tracking-wider text-muted-foreground uppercase">MP3 Meta</p>
+                            <ul className="text-sm space-y-1">
+                                {result.codec_mode && (<li className="flex justify-between">
+                                        <span className="text-muted-foreground">Mode:</span>
+                                        <span className="font-medium font-mono">{result.codec_mode}</span>
+                                    </li>)}
+                                {typeof result.bitrate_kbps === "number" && (<li className="flex justify-between">
+                                        <span className="text-muted-foreground">Bitrate:</span>
+                                        <span className="font-medium font-mono">{result.bitrate_kbps} kbps</span>
+                                    </li>)}
+                                {typeof result.total_frames === "number" && result.total_frames > 0 && (<li className="flex justify-between">
+                                        <span className="text-muted-foreground">Frames:</span>
+                                        <span className="font-medium font-mono">{result.total_frames.toLocaleString()}</span>
+                                    </li>)}
+                                {result.codec_version && (<li className="flex justify-between">
+                                        <span className="text-muted-foreground">Version:</span>
+                                        <span className="font-medium font-mono">{result.codec_version}</span>
+                                    </li>)}
+                            </ul>
+                        </div>)}
+
+                    {result.spectrum && (() => {
+            const frames = result.spectrum.time_slices.length;
+            const fftSize = (result.spectrum.freq_bins - 1) * 2;
+            const freqRes = result.sample_rate / fftSize;
+            return (<div className="space-y-2">
+                                <p className="text-xs font-semibold tracking-wider text-muted-foreground uppercase">Spectrum Meta</p>
+                                <ul className="text-sm space-y-1">
+                                    <li className="flex justify-between">
+                                        <span className="text-muted-foreground">Display Frames:</span>
+                                        <span className="font-medium font-mono">{frames.toLocaleString()}</span>
+                                    </li>
+                                    <li className="flex justify-between">
+                                        <span className="text-muted-foreground">FFT Size:</span>
+                                        <span className="font-medium font-mono">{fftSize.toLocaleString()}</span>
+                                    </li>
+                                    <li className="flex justify-between">
+                                        <span className="text-muted-foreground">{freqResolutionLabel}</span>
+                                        <span className="font-medium font-mono">{freqRes.toFixed(2)} Hz/bin</span>
+                                    </li>
+                                </ul>
+                            </div>);
+        })()}
+                </div>
+            </CardContent>
+        </Card>);
 }

frontend/src/components/AudioAnalysisPage.tsx

@@ -1,113 +1,884 @@
-import { useState, useCallback, useEffect } from "react";
+import { useState, useCallback, useRef, useEffect, type ChangeEvent, type CSSProperties, type DragEvent } from "react";
 import { Button } from "@/components/ui/button";
-import { Upload, ArrowLeft, Trash2 } from "lucide-react";
+import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card";
+import { DropdownMenu, DropdownMenuContent, DropdownMenuItem, DropdownMenuTrigger } from "@/components/ui/dropdown-menu";
+import { Progress } from "@/components/ui/progress";
+import { Spinner } from "@/components/ui/spinner";
+import { Upload, ArrowLeft, Trash2, Download, FolderOpen, X, AlertCircle, CheckCircle2, FileMusic, ChevronDown, Play, StopCircle } from "lucide-react";
 import { AudioAnalysis } from "@/components/AudioAnalysis";
-import { SpectrumVisualization } from "@/components/SpectrumVisualization";
+import { SpectrumVisualization, createSpectrogramDataURL, type SpectrumVisualizationHandle } from "@/components/SpectrumVisualization";
 import { useAudioAnalysis } from "@/hooks/useAudioAnalysis";
-import { SelectFile } from "../../wailsjs/go/main/App";
+import type { AnalysisResult } from "@/types/api";
+import { loadAudioAnalysisPreferences } from "@/lib/audio-analysis-preferences";
 import { toastWithSound as toast } from "@/lib/toast-with-sound";
+import { GetFileSizes, ListAudioFilesInDir, SaveSpectrumImage, SelectAudioFiles, SelectFolder } from "../../wailsjs/go/main/App";
 import { OnFileDrop, OnFileDropOff } from "../../wailsjs/runtime/runtime";
 interface AudioAnalysisPageProps {
     onBack?: () => void;
 }
+type BatchItemStatus = "pending" | "analyzing" | "success" | "error";
+type BatchItemSource = "path" | "browser";
+interface BatchAnalysisItem {
+    id: string;
+    source: BatchItemSource;
+    path: string;
+    name: string;
+    size: number;
+    status: BatchItemStatus;
+    error?: string;
+    result?: AnalysisResult;
+    file?: File;
+}
+interface QueueProgressState {
+    completed: number;
+    total: number;
+    fileName: string;
+}
+const EMPTY_PROGRESS_STATE: QueueProgressState = {
+    completed: 0,
+    total: 0,
+    fileName: "",
+};
+const SUPPORTED_AUDIO_EXTENSIONS = [".flac", ".mp3", ".m4a", ".aac"];
+const SUPPORTED_AUDIO_ACCEPT = [
+    ".flac",
+    ".mp3",
+    ".m4a",
+    ".aac",
+    "audio/flac",
+    "audio/x-flac",
+    "audio/mpeg",
+    "audio/mp3",
+    "audio/mp4",
+    "audio/x-m4a",
+    "audio/aac",
+    "audio/aacp",
+].join(",");
+const SUPPORTED_AUDIO_LABEL = "FLAC, MP3, M4A, or AAC";
+function isSupportedAudioPath(filePath: string): boolean {
+    const normalized = filePath.toLowerCase();
+    return SUPPORTED_AUDIO_EXTENSIONS.some((ext) => normalized.endsWith(ext));
+}
+function isSupportedAudioFile(file: File): boolean {
+    const normalizedName = file.name.toLowerCase();
+    const normalizedType = file.type.toLowerCase();
+    return (SUPPORTED_AUDIO_EXTENSIONS.some((ext) => normalizedName.endsWith(ext)) ||
+        normalizedType === "audio/flac" ||
+        normalizedType === "audio/x-flac" ||
+        normalizedType === "audio/mpeg" ||
+        normalizedType === "audio/mp3" ||
+        normalizedType === "audio/mp4" ||
+        normalizedType === "audio/x-m4a" ||
+        normalizedType === "audio/aac" ||
+        normalizedType === "audio/aacp");
+}
+function isAbsolutePath(filePath: string): boolean {
+    return /^(?:[a-zA-Z]:[\\/]|\\\\|\/)/.test(filePath);
+}
+function fileNameFromPath(filePath: string): string {
+    const parts = filePath.split(/[/\\]/);
+    return parts[parts.length - 1] || filePath;
+}
+function browserFileId(file: File): string {
+    return `browser:${file.name}:${file.size}:${file.lastModified}`;
+}
+function downloadDataURL(dataUrl: string, fileName: string): void {
+    const link = document.createElement("a");
+    link.href = dataUrl;
+    link.download = fileName;
+    document.body.appendChild(link);
+    link.click();
+    document.body.removeChild(link);
+}
+function formatFileSize(bytes: number): string {
+    if (bytes <= 0) {
+        return "0 B";
+    }
+    const k = 1024;
+    const sizes = ["B", "KB", "MB", "GB"];
+    const index = Math.min(sizes.length - 1, Math.floor(Math.log(bytes) / Math.log(k)));
+    return `${parseFloat((bytes / Math.pow(k, index)).toFixed(1))} ${sizes[index]}`;
+}
+function formatDuration(seconds: number): string {
+    const mins = Math.floor(seconds / 60);
+    const secs = Math.floor(seconds % 60);
+    return `${mins}:${secs.toString().padStart(2, "0")}`;
+}
+function itemMetaLine(item: BatchAnalysisItem): string {
+    if (item.result) {
+        const parts = [
+            item.result.file_type ?? "Audio",
+            `${(item.result.sample_rate / 1000).toFixed(1)} kHz`,
+            formatDuration(item.result.duration),
+        ];
+        if (typeof item.result.bitrate_kbps === "number" && item.result.bitrate_kbps > 0) {
+            parts.push(`${item.result.bitrate_kbps} kbps`);
+        }
+        return parts.join(" • ");
+    }
+    switch (item.status) {
+        case "analyzing":
+            return "Analyzing audio quality...";
+        case "error":
+            return item.error || "Analysis failed";
+        case "pending":
+        default:
+            return "Waiting to be analyzed";
+    }
+}
+function statusIcon(status: BatchItemStatus) {
+    switch (status) {
+        case "analyzing":
+            return <Spinner className="h-4 w-4 text-primary"/>;
+        case "success":
+            return <CheckCircle2 className="h-4 w-4 text-green-500"/>;
+        case "error":
+            return <AlertCircle className="h-4 w-4 text-destructive"/>;
+        case "pending":
+        default:
+            return <FileMusic className="h-4 w-4 text-muted-foreground"/>;
+    }
+}
 export function AudioAnalysisPage({ onBack }: AudioAnalysisPageProps) {
-    const { analyzing, result, analyzeFile, clearResult, selectedFilePath, spectrumLoading } = useAudioAnalysis();
+    const { analysisProgress, spectrumLoading, spectrumProgress, analyzeFile, analyzeFilePath, cancelAnalysis, loadStoredAnalysis, clearStoredAnalysis, reAnalyzeSpectrum, clearResult, } = useAudioAnalysis();
+    const [items, setItems] = useState<BatchAnalysisItem[]>([]);
+    const [activeItemId, setActiveItemId] = useState<string | null>(null);
     const [isDragging, setIsDragging] = useState(false);
-    const handleSelectFile = async () => {
+    const [isExportingSelected, setIsExportingSelected] = useState(false);
+    const [isExportingBatch, setIsExportingBatch] = useState(false);
+    const [isBatchRunning, setIsBatchRunning] = useState(false);
+    const [batchProgress, setBatchProgress] = useState<QueueProgressState>(EMPTY_PROGRESS_STATE);
+    const [exportProgress, setExportProgress] = useState<QueueProgressState>(EMPTY_PROGRESS_STATE);
+    const fileInputRef = useRef<HTMLInputElement>(null);
+    const spectrumRef = useRef<SpectrumVisualizationHandle>(null);
+    const batchRunIdRef = useRef(0);
+    const itemsRef = useRef(items);
+    const activeItemIdRef = useRef<string | null>(activeItemId);
+    useEffect(() => {
+        itemsRef.current = items;
+    }, [items]);
+    useEffect(() => {
+        activeItemIdRef.current = activeItemId;
+    }, [activeItemId]);
+    const setActiveSelection = useCallback((nextId: string | null) => {
+        activeItemIdRef.current = nextId;
+        setActiveItemId(nextId);
+    }, []);
+    const activeItem = items.find((item) => item.id === activeItemId) ?? null;
+    const successItems = items.filter((item) => item.status === "success" && item.result?.spectrum);
+    const pendingItems = items.filter((item) => item.status === "pending");
+    const isSingleMode = items.length === 1;
+    const isBatchMode = items.length > 1;
+    const canResumeBatch = isBatchMode && !isBatchRunning && pendingItems.length > 0;
+    const batchPercent = batchProgress.total > 0
+        ? Math.round(Math.max(0, Math.min(100, ((batchProgress.completed + (isBatchRunning ? analysisProgress.percent / 100 : 0)) / batchProgress.total) * 100)))
+        : 0;
+    const exportPercent = exportProgress.total > 0
+        ? Math.round(Math.max(0, Math.min(100, (exportProgress.completed / exportProgress.total) * 100)))
+        : 0;
+    useEffect(() => {
+        if (!activeItem?.result) {
+            return;
+        }
+        loadStoredAnalysis(activeItem.id, activeItem.result, activeItem.path);
+    }, [activeItem, loadStoredAnalysis]);
+    const runBatchAnalysis = useCallback(async (entries: BatchAnalysisItem[]) => {
+        if (entries.length === 0) {
+            return;
+        }
+        const runId = batchRunIdRef.current + 1;
+        batchRunIdRef.current = runId;
+        setIsBatchRunning(true);
+        setBatchProgress({
+            completed: 0,
+            total: entries.length,
+            fileName: entries[0]?.name ?? "",
+        });
+        let successCount = 0;
+        let failCount = 0;
         try {
-            const filePath = await SelectFile();
-            if (filePath) {
-                await analyzeFile(filePath);
+            for (let index = 0; index < entries.length; index++) {
+                if (batchRunIdRef.current !== runId) {
+                    return;
+                }
+                const entry = entries[index];
+                setBatchProgress({
+                    completed: index,
+                    total: entries.length,
+                    fileName: entry.name,
+                });
+                setItems((prev) => prev.map((item) => item.id === entry.id
+                    ? { ...item, status: "analyzing", error: undefined }
+                    : item));
+                const outcome = entry.source === "browser" && entry.file
+                    ? await analyzeFile(entry.file, {
+                        analysisKey: entry.id,
+                        displayPath: entry.path,
+                        suppressToast: true,
+                    })
+                    : await analyzeFilePath(entry.path, {
+                        analysisKey: entry.id,
+                        displayPath: entry.path,
+                        suppressToast: true,
+                    });
+                if (batchRunIdRef.current !== runId) {
+                    return;
+                }
+                if (outcome.cancelled) {
+                    return;
+                }
+                if (outcome.result) {
+                    const analysisResult = outcome.result;
+                    successCount++;
+                    setItems((prev) => prev.map((item) => item.id === entry.id
+                        ? {
+                            ...item,
+                            status: "success",
+                            error: undefined,
+                            result: analysisResult,
+                            size: analysisResult.file_size || item.size,
+                        }
+                        : item));
+                    const hasSelectedSuccess = itemsRef.current.some((item) => item.id === activeItemIdRef.current && item.status === "success" && item.result);
+                    if (!hasSelectedSuccess) {
+                        setActiveSelection(entry.id);
+                    }
+                }
+                else {
+                    failCount++;
+                    setItems((prev) => prev.map((item) => item.id === entry.id
+                        ? {
+                            ...item,
+                            status: "error",
+                            error: outcome.error || "Analysis failed",
+                        }
+                        : item));
+                    if (!activeItemIdRef.current) {
+                        setActiveSelection(entry.id);
+                    }
+                }
+            }
+            if (batchRunIdRef.current === runId) {
+                setBatchProgress({
+                    completed: entries.length,
+                    total: entries.length,
+                    fileName: "",
+                });
+                if (successCount > 0) {
+                    toast.success("Batch Analysis Complete", {
+                        description: `Successfully analyzed ${successCount} file(s)${failCount > 0 ? `, ${failCount} failed` : ""}`,
+                    });
+                }
+                else if (failCount > 0) {
+                    toast.error("Batch Analysis Failed", {
+                        description: `All ${failCount} file(s) failed to analyze`,
+                    });
+                }
             }
         }
+        finally {
+            if (batchRunIdRef.current === runId) {
+                setIsBatchRunning(false);
+            }
+        }
+    }, [analyzeFile, analyzeFilePath, setActiveSelection]);
+    const ensureIdleQueue = useCallback(() => {
+        if (!isBatchRunning) {
+            return true;
+        }
+        toast.info("Analysis in progress", {
+            description: "Please wait for the current batch to finish or clear it first.",
+        });
+        return false;
+    }, [isBatchRunning]);
+    const addPathItems = useCallback(async (paths: string[]) => {
+        if (!ensureIdleQueue()) {
+            return;
+        }
+        const uniquePaths = Array.from(new Set(paths.filter(Boolean)));
+        const invalidCount = uniquePaths.filter((path) => !isSupportedAudioPath(path)).length;
+        const validPaths = uniquePaths.filter(isSupportedAudioPath);
+        if (invalidCount > 0) {
+            toast.error("Unsupported format", {
+                description: `Only ${SUPPORTED_AUDIO_LABEL} files can be analyzed.`,
+            });
+        }
+        if (validPaths.length === 0) {
+            return;
+        }
+        const existingIds = new Set(itemsRef.current.map((item) => item.id));
+        const newPaths = validPaths.filter((path) => !existingIds.has(path));
+        if (newPaths.length === 0) {
+            toast.info("No new files added", {
+                description: "All selected files were already in the batch queue.",
+            });
+            return;
+        }
+        const fileSizes = await GetFileSizes(newPaths);
+        const newItems = newPaths.map((path) => ({
+            id: path,
+            source: "path" as const,
+            path,
+            name: fileNameFromPath(path),
+            size: fileSizes[path] || 0,
+            status: "pending" as const,
+        }));
+        if (validPaths.length !== newPaths.length) {
+            toast.info("Some files skipped", {
+                description: `${validPaths.length - newPaths.length} file(s) were already queued.`,
+            });
+        }
+        setItems((prev) => [...prev, ...newItems]);
+        if (!activeItemIdRef.current) {
+            setActiveSelection(newItems[0]?.id ?? null);
+        }
+        void runBatchAnalysis(newItems);
+    }, [ensureIdleQueue, runBatchAnalysis, setActiveSelection]);
+    const addBrowserFiles = useCallback(async (files: File[]) => {
+        if (!ensureIdleQueue()) {
+            return;
+        }
+        const validFiles = files.filter(isSupportedAudioFile);
+        const invalidCount = files.length - validFiles.length;
+        if (invalidCount > 0) {
+            toast.error("Unsupported format", {
+                description: `Only ${SUPPORTED_AUDIO_LABEL} files can be analyzed.`,
+            });
+        }
+        if (validFiles.length === 0) {
+            return;
+        }
+        const existingIds = new Set(itemsRef.current.map((item) => item.id));
+        const newItems = validFiles
+            .map((file) => ({
+            id: browserFileId(file),
+            source: "browser" as const,
+            path: file.name,
+            name: file.name,
+            size: file.size,
+            status: "pending" as const,
+            file,
+        }))
+            .filter((item) => !existingIds.has(item.id));
+        if (newItems.length === 0) {
+            toast.info("No new files added", {
+                description: "All selected files were already in the batch queue.",
+            });
+            return;
+        }
+        if (validFiles.length !== newItems.length) {
+            toast.info("Some files skipped", {
+                description: `${validFiles.length - newItems.length} file(s) were already queued.`,
+            });
+        }
+        setItems((prev) => [...prev, ...newItems]);
+        if (!activeItemIdRef.current) {
+            setActiveSelection(newItems[0]?.id ?? null);
+        }
+        void runBatchAnalysis(newItems);
+    }, [ensureIdleQueue, runBatchAnalysis, setActiveSelection]);
+    const handleSelectFiles = useCallback(async () => {
+        if (!ensureIdleQueue()) {
+            return;
+        }
+        try {
+            const selectedPaths = await SelectAudioFiles();
+            if (selectedPaths && selectedPaths.length > 0) {
+                await addPathItems(selectedPaths);
+            }
+            return;
+        }
+        catch {
+            fileInputRef.current?.click();
+            return;
+        }
+    }, [addPathItems, ensureIdleQueue]);
+    const handleSelectFolder = useCallback(async () => {
+        if (!ensureIdleQueue()) {
+            return;
+        }
+        try {
+            const selectedFolder = await SelectFolder("");
+            if (!selectedFolder) {
+                return;
+            }
+            const folderFiles = await ListAudioFilesInDir(selectedFolder);
+            if (!folderFiles || folderFiles.length === 0) {
+                toast.info("No audio files found", {
+                    description: `No ${SUPPORTED_AUDIO_LABEL} files were found in the selected folder.`,
+                });
+                return;
+            }
+            await addPathItems(folderFiles.map((file) => file.path));
+        }
         catch (err) {
-            toast.error("File Selection Failed", {
-                description: err instanceof Error ? err.message : "Failed to select file",
+            toast.error("Folder Selection Failed", {
+                description: err instanceof Error ? err.message : "Failed to select folder",
             });
         }
-    };
-    const handleFileDrop = useCallback(async (_x: number, _y: number, paths: string[]) => {
+    }, [addPathItems, ensureIdleQueue]);
+    const handleInputChange = useCallback(async (event: ChangeEvent<HTMLInputElement>) => {
+        const files = Array.from(event.target.files ?? []);
+        event.target.value = "";
+        if (files.length === 0) {
+            return;
+        }
+        await addBrowserFiles(files);
+    }, [addBrowserFiles]);
+    const handleHtmlDrop = useCallback(async (event: DragEvent<HTMLDivElement>) => {
+        event.preventDefault();
         setIsDragging(false);
-        if (paths.length === 0)
-            return;
-        const filePath = paths[0];
-        if (!filePath.toLowerCase().endsWith(".flac")) {
-            toast.error("Invalid File Type", {
-                description: "Please drop a FLAC file for analysis",
-            });
+        const files = Array.from(event.dataTransfer.files ?? []);
+        if (files.length === 0) {
             return;
         }
-        await analyzeFile(filePath);
-    }, [analyzeFile]);
+        await addBrowserFiles(files);
+    }, [addBrowserFiles]);
     useEffect(() => {
-        OnFileDrop((x, y, paths) => {
-            handleFileDrop(x, y, paths);
+        OnFileDrop((_x, _y, paths) => {
+            setIsDragging(false);
+            if (!paths || paths.length === 0) {
+                return;
+            }
+            void addPathItems(paths);
         }, true);
         return () => {
             OnFileDropOff();
         };
-    }, [handleFileDrop]);
-    const handleAnalyzeAnother = () => {
+    }, [addPathItems]);
+    const handleSelectItem = useCallback((itemId: string) => {
+        setActiveSelection(itemId);
+    }, [setActiveSelection]);
+    const handleRemoveItem = useCallback((itemId: string) => {
+        if (isBatchRunning || isExportingBatch || isExportingSelected || spectrumLoading) {
+            return;
+        }
+        clearStoredAnalysis(itemId);
+        const nextItems = itemsRef.current.filter((item) => item.id !== itemId);
+        itemsRef.current = nextItems;
+        setItems(nextItems);
+        if (activeItemIdRef.current === itemId) {
+            const nextActive = nextItems.find((item) => item.status === "success" && item.result) ?? nextItems[0] ?? null;
+            setActiveSelection(nextActive?.id ?? null);
+            if (!nextActive) {
+                clearResult();
+            }
+        }
+    }, [clearResult, clearStoredAnalysis, isBatchRunning, isExportingBatch, isExportingSelected, setActiveSelection, spectrumLoading]);
+    const handleClearAll = useCallback(() => {
+        if (isExportingBatch || isExportingSelected) {
+            return;
+        }
+        batchRunIdRef.current += 1;
+        itemsRef.current = [];
+        setItems([]);
+        setActiveSelection(null);
+        clearStoredAnalysis();
         clearResult();
-    };
+        setIsBatchRunning(false);
+        setBatchProgress(EMPTY_PROGRESS_STATE);
+        setExportProgress(EMPTY_PROGRESS_STATE);
+        setIsDragging(false);
+    }, [clearResult, clearStoredAnalysis, isExportingBatch, isExportingSelected, setActiveSelection]);
+    const handleStopBatch = useCallback(() => {
+        if (!isBatchRunning) {
+            return;
+        }
+        batchRunIdRef.current += 1;
+        cancelAnalysis();
+        setIsBatchRunning(false);
+        setBatchProgress(EMPTY_PROGRESS_STATE);
+        setItems((prev) => prev.map((item) => item.status === "analyzing"
+            ? {
+                ...item,
+                status: "pending",
+            }
+            : item));
+        toast.info("Batch analysis stopped", {
+            description: "Click Analyze to continue the remaining files.",
+        });
+    }, [cancelAnalysis, isBatchRunning]);
+    const handleAnalyzePending = useCallback(() => {
+        if (isBatchRunning || isExportingBatch || isExportingSelected || spectrumLoading) {
+            return;
+        }
+        const nextPendingItems = itemsRef.current.filter((item) => item.status === "pending");
+        if (nextPendingItems.length === 0) {
+            return;
+        }
+        void runBatchAnalysis(nextPendingItems);
+    }, [isBatchRunning, isExportingBatch, isExportingSelected, runBatchAnalysis, spectrumLoading]);
+    const handleExportSelected = useCallback(async () => {
+        if (!activeItem?.result?.spectrum || !spectrumRef.current) {
+            return;
+        }
+        const dataUrl = spectrumRef.current.getCanvasDataURL();
+        if (!dataUrl) {
+            toast.error("Export Failed", {
+                description: "Cannot get canvas data",
+            });
+            return;
+        }
+        setIsExportingSelected(true);
+        try {
+            if (activeItem.source === "path" && isAbsolutePath(activeItem.path)) {
+                const outPath = await SaveSpectrumImage(activeItem.path, dataUrl);
+                toast.success("PNG Exported", {
+                    description: `Saved to: ${outPath}`,
+                });
+                return;
+            }
+            const baseName = activeItem.name.replace(/\.[^/.]+$/, "") || "spectrogram";
+            downloadDataURL(dataUrl, `${baseName}_spectrogram.png`);
+            toast.success("PNG Exported", {
+                description: "Spectrogram image downloaded",
+            });
+        }
+        catch (err) {
+            toast.error("Export Failed", {
+                description: err instanceof Error ? err.message : "Failed to export image",
+            });
+        }
+        finally {
+            setIsExportingSelected(false);
+        }
+    }, [activeItem]);
+    const handleBatchExport = useCallback(async () => {
+        const exportableItems = itemsRef.current.filter((item) => item.status === "success" && item.result?.spectrum);
+        if (exportableItems.length === 0) {
+            toast.error("Nothing to export", {
+                description: "Analyze at least one file successfully before exporting PNGs.",
+            });
+            return;
+        }
+        const preferences = loadAudioAnalysisPreferences();
+        setIsExportingBatch(true);
+        setExportProgress({
+            completed: 0,
+            total: exportableItems.length,
+            fileName: exportableItems[0]?.name ?? "",
+        });
+        let successCount = 0;
+        let failCount = 0;
+        try {
+            for (let index = 0; index < exportableItems.length; index++) {
+                const item = exportableItems[index];
+                const result = item.result;
+                if (!result?.spectrum) {
+                    failCount++;
+                    continue;
+                }
+                setExportProgress({
+                    completed: index,
+                    total: exportableItems.length,
+                    fileName: item.name,
+                });
+                try {
+                    const dataUrl = await createSpectrogramDataURL({
+                        spectrumData: result.spectrum,
+                        sampleRate: result.sample_rate,
+                        duration: result.duration,
+                        freqScale: preferences.freqScale,
+                        colorScheme: preferences.colorScheme,
+                        fileName: item.name,
+                    });
+                    if (item.source === "path" && isAbsolutePath(item.path)) {
+                        await SaveSpectrumImage(item.path, dataUrl);
+                    }
+                    else {
+                        const baseName = item.name.replace(/\.[^/.]+$/, "") || "spectrogram";
+                        downloadDataURL(dataUrl, `${baseName}_spectrogram.png`);
+                    }
+                    successCount++;
+                }
+                catch {
+                    failCount++;
+                }
+                await new Promise((resolve) => setTimeout(resolve, 0));
+            }
+            setExportProgress({
+                completed: exportableItems.length,
+                total: exportableItems.length,
+                fileName: "",
+            });
+            if (successCount > 0) {
+                toast.success("Batch PNG Export Complete", {
+                    description: `Exported ${successCount} spectrogram PNG file(s)${failCount > 0 ? `, ${failCount} failed` : ""}`,
+                });
+            }
+            else {
+                toast.error("Batch PNG Export Failed", {
+                    description: "No spectrogram PNG files were exported.",
+                });
+            }
+        }
+        finally {
+            setIsExportingBatch(false);
+        }
+    }, []);
+    const handleReAnalyzeSelectedSpectrum = useCallback(async (fftSize: number, windowFunction: string) => {
+        if (!activeItem?.result) {
+            return;
+        }
+        const nextResult = await reAnalyzeSpectrum(fftSize, windowFunction);
+        if (!nextResult) {
+            return;
+        }
+        setItems((prev) => prev.map((item) => item.id === activeItem.id
+            ? {
+                ...item,
+                result: nextResult,
+                status: "success",
+                error: undefined,
+            }
+            : item));
+    }, [activeItem, reAnalyzeSpectrum]);
+    const batchDetailContent = !activeItem ? (<Card>
+            <CardContent className="flex min-h-[320px] items-center justify-center px-6 py-10">
+                <p className="text-sm text-muted-foreground">
+                    Select a file from the batch queue to inspect its analysis result.
+                </p>
+            </CardContent>
+        </Card>) : activeItem.status !== "success" || !activeItem.result ? (<Card>
+            <CardHeader className="pb-3">
+                <CardTitle className="text-base">{activeItem.name}</CardTitle>
+                <p className="break-all font-mono text-sm text-muted-foreground">{activeItem.path}</p>
+            </CardHeader>
+            <CardContent className="space-y-4">
+                {activeItem.status === "analyzing" && (<div className="space-y-3">
+                        <div className="flex items-center gap-3">
+                            <Spinner />
+                            <span className="text-sm text-muted-foreground">Analyzing audio quality...</span>
+                        </div>
+                        <Progress value={analysisProgress.percent} className="h-2 w-full"/>
+                        <p className="text-xs text-muted-foreground">{analysisProgress.message}</p>
+                    </div>)}
+                {activeItem.status === "pending" && (<p className="text-sm text-muted-foreground">
+                        This file is queued and waiting for batch analysis to start.
+                    </p>)}
+                {activeItem.status === "error" && (<div className="rounded-lg border border-destructive/30 bg-destructive/5 p-4 text-sm text-destructive">
+                        {activeItem.error || "Analysis failed"}
+                    </div>)}
+            </CardContent>
+        </Card>) : (<div className="space-y-4">
+            <AudioAnalysis result={activeItem.result} analyzing={false} showAnalyzeButton={false} filePath={activeItem.path}/>
+
+            <SpectrumVisualization ref={spectrumRef} sampleRate={activeItem.result.sample_rate} duration={activeItem.result.duration} spectrumData={activeItem.result.spectrum} fileName={activeItem.name} onReAnalyze={handleReAnalyzeSelectedSpectrum} isAnalyzingSpectrum={spectrumLoading} spectrumProgress={spectrumProgress}/>
+        </div>);
+    const singleModeContent = !activeItem ? null : activeItem.status === "success" && activeItem.result ? (<div className="mx-auto w-full max-w-6xl space-y-4">
+            <AudioAnalysis result={activeItem.result} analyzing={false} showAnalyzeButton={false} filePath={activeItem.path}/>
+
+            <SpectrumVisualization ref={spectrumRef} sampleRate={activeItem.result.sample_rate} duration={activeItem.result.duration} spectrumData={activeItem.result.spectrum} fileName={activeItem.name} onReAnalyze={handleReAnalyzeSelectedSpectrum} isAnalyzingSpectrum={spectrumLoading} spectrumProgress={spectrumProgress}/>
+        </div>) : activeItem.status === "analyzing" || activeItem.status === "pending" ? (<div className="flex h-[400px] items-center justify-center">
+            <div className="w-full max-w-md space-y-2">
+                <div className="flex items-center justify-between text-sm text-muted-foreground">
+                    <span>{activeItem.status === "pending" ? "Preparing..." : "Processing..."}</span>
+                    <span className="tabular-nums">{analysisProgress.percent}%</span>
+                </div>
+                <Progress value={analysisProgress.percent} className="h-2 w-full"/>
+                <p className="text-center text-xs text-muted-foreground">{analysisProgress.message}</p>
+            </div>
+        </div>) : (<div className="flex h-[400px] items-center justify-center">
+            <div className="w-full max-w-md rounded-lg border border-destructive/30 bg-destructive/5 p-4 text-sm text-destructive">
+                {activeItem.error || "Analysis failed"}
+            </div>
+        </div>);
+    const showSingleModeActions = isSingleMode && activeItem?.status === "success" && activeItem.result;
     return (<div className="space-y-6">
-      
-      <div className="flex items-center justify-between">
-        <div className="flex items-center gap-4">
-          {onBack && (<Button variant="ghost" size="icon" onClick={onBack}>
-              <ArrowLeft className="h-5 w-5"/>
-            </Button>)}
-          <h1 className="text-2xl font-bold">Audio Quality Analyzer</h1>
-        </div>
-        {result && (<Button onClick={handleAnalyzeAnother} variant="outline" size="sm">
-            <Trash2 className="h-4 w-4"/>
-            Clear
-          </Button>)}
-      </div>
+            <input ref={fileInputRef} type="file" multiple accept={SUPPORTED_AUDIO_ACCEPT} className="hidden" onChange={handleInputChange}/>
 
-      
-      {!result && !analyzing && (<div className={`flex flex-col items-center justify-center h-[400px] border-2 border-dashed rounded-lg transition-colors ${isDragging
-                ? "border-primary bg-primary/10"
-                : "border-muted-foreground/30"}`} onDragOver={(e) => {
-                e.preventDefault();
+            <div className="flex flex-wrap items-center justify-between gap-3">
+                <div className="flex items-center gap-4">
+                    {onBack && (<Button variant="ghost" size="icon" onClick={onBack}>
+                            <ArrowLeft className="h-5 w-5"/>
+                        </Button>)}
+                    <h1 className="text-2xl font-bold">Audio Quality Analyzer</h1>
+                </div>
+
+                <div className="flex flex-wrap gap-2">
+                    {isBatchMode && isBatchRunning && (<Button onClick={handleStopBatch} variant="destructive" size="sm" disabled={isExportingBatch || isExportingSelected} className="gap-1.5">
+                            <StopCircle className="h-4 w-4"/>
+                            Stop
+                        </Button>)}
+                    {canResumeBatch && (<Button onClick={handleAnalyzePending} variant="outline" size="sm" disabled={isExportingBatch || isExportingSelected || spectrumLoading}>
+                            <Play className="h-4 w-4"/>
+                            Analyze
+                        </Button>)}
+                    {isBatchMode && (<DropdownMenu>
+                            <DropdownMenuTrigger asChild>
+                                <Button variant="outline" size="sm" disabled={isBatchRunning || isExportingBatch || isExportingSelected}>
+                                    <Upload className="h-4 w-4 mr-1"/>
+                                    Add
+                                    <ChevronDown className="ml-1 h-4 w-4"/>
+                                </Button>
+                            </DropdownMenuTrigger>
+                            <DropdownMenuContent align="end" className="min-w-[180px]">
+                                <DropdownMenuItem onClick={handleSelectFiles} className="cursor-pointer">
+                                    <Upload className="h-4 w-4"/>
+                                    Add Files
+                                </DropdownMenuItem>
+                                <DropdownMenuItem onClick={handleSelectFolder} className="cursor-pointer">
+                                    <FolderOpen className="h-4 w-4"/>
+                                    Add Folder
+                                </DropdownMenuItem>
+                            </DropdownMenuContent>
+                        </DropdownMenu>)}
+                    {showSingleModeActions && (<Button onClick={handleExportSelected} variant="outline" size="sm" disabled={isExportingSelected || spectrumLoading}>
+                            <Download className="h-4 w-4 mr-1"/>
+                            {isExportingSelected ? "Exporting..." : "Export PNG"}
+                        </Button>)}
+                    {isBatchMode && (<DropdownMenu>
+                            <DropdownMenuTrigger asChild>
+                                <Button variant="outline" size="sm" disabled={successItems.length === 0 || isExportingBatch || isExportingSelected || isBatchRunning || spectrumLoading}>
+                                    <Download className="h-4 w-4 mr-1"/>
+                                    {isExportingBatch ? "Exporting..." : isExportingSelected ? "Exporting..." : "Export"}
+                                    <ChevronDown className="ml-1 h-4 w-4"/>
+                                </Button>
+                            </DropdownMenuTrigger>
+                            <DropdownMenuContent align="end" className="min-w-[200px]">
+                                <DropdownMenuItem onClick={handleExportSelected} className="cursor-pointer" disabled={!activeItem?.result?.spectrum}>
+                                    <Download className="h-4 w-4"/>
+                                    Export Selected PNG
+                                </DropdownMenuItem>
+                                <DropdownMenuItem onClick={handleBatchExport} className="cursor-pointer" disabled={successItems.length === 0}>
+                                    <Download className="h-4 w-4"/>
+                                    Export All PNG
+                                </DropdownMenuItem>
+                            </DropdownMenuContent>
+                        </DropdownMenu>)}
+                    {showSingleModeActions && (<Button onClick={handleClearAll} variant="outline" size="sm" disabled={isExportingSelected}>
+                            <Trash2 className="h-4 w-4 mr-1"/>
+                            Clear
+                        </Button>)}
+                    {isBatchMode && (<Button onClick={handleClearAll} variant="outline" size="sm" disabled={isExportingBatch || isExportingSelected}>
+                            <Trash2 className="h-4 w-4 mr-1"/>
+                            Clear
+                        </Button>)}
+                </div>
+            </div>
+
+            {items.length === 0 && (<div className={`flex h-[400px] flex-col items-center justify-center rounded-lg border-2 border-dashed transition-all ${isDragging ? "border-primary bg-primary/10" : "border-muted-foreground/30"}`} onDragOver={(event) => {
+                event.preventDefault();
                 setIsDragging(true);
-            }} onDragLeave={(e) => {
-                e.preventDefault();
+            }} onDragLeave={(event) => {
+                event.preventDefault();
                 setIsDragging(false);
-            }} onDrop={(e) => {
-                e.preventDefault();
-                setIsDragging(false);
-            }} style={{ "--wails-drop-target": "drop" } as React.CSSProperties}>
-          <div className="mb-4 flex h-16 w-16 items-center justify-center rounded-full bg-muted">
-            <Upload className="h-8 w-8 text-primary"/>
-          </div>
-          <p className="text-sm text-muted-foreground mb-4 text-center">
-            {isDragging
-                ? "Drop your FLAC file here"
-                : "Drag and drop a FLAC file here, or click the button below to select"}
-          </p>
-          <Button onClick={handleSelectFile} size="lg">
-            <Upload className="h-5 w-5"/>
-            Select FLAC File
-          </Button>
-        </div>)}
+            }} onDrop={handleHtmlDrop} style={{ "--wails-drop-target": "drop" } as CSSProperties}>
+                    <div className="mb-4 flex h-16 w-16 items-center justify-center rounded-full bg-muted">
+                        <Upload className="h-8 w-8 text-primary"/>
+                    </div>
+                    <p className="text-sm text-muted-foreground mb-4 text-center">
+                        {isDragging
+                ? "Drop your audio files here"
+                : "Drag and drop audio files here, or click the button below to select"}
+                    </p>
+                    <div className="flex gap-3">
+                        <Button onClick={handleSelectFiles} size="lg">
+                            <Upload className="h-5 w-5"/>
+                            Select Files
+                        </Button>
+                        <Button onClick={handleSelectFolder} size="lg" variant="outline">
+                            <Upload className="h-5 w-5"/>
+                            Select Folder
+                        </Button>
+                    </div>
+                    <p className="text-xs text-muted-foreground mt-4 text-center">
+                        Supported formats: FLAC, MP3, M4A, AAC
+                    </p>
+                </div>)}
 
-      
-      {analyzing && !result && (<div className="flex flex-col items-center justify-center py-16">
-          <div className="animate-spin rounded-full h-12 w-12 border-b-2 border-primary mb-4"></div>
-          <p className="text-sm text-muted-foreground">Analyzing audio file...</p>
-        </div>)}
+            {isSingleMode && (<div className="space-y-4">
+                    {singleModeContent}
+                </div>)}
 
-      
-      {result && (<div className="space-y-4">
-          
-          <AudioAnalysis result={result} analyzing={analyzing} showAnalyzeButton={false} filePath={selectedFilePath}/>
+            {isBatchMode && (<div className="grid gap-4 xl:grid-cols-[360px,minmax(0,1fr)]">
+                    <div className="space-y-3">
+                        {(isBatchRunning || isExportingBatch) && (<Card className="gap-2 py-4">
+                                <CardHeader className="px-4 pb-0">
+                                    <CardTitle className="text-sm">
+                                        {isExportingBatch ? "Batch PNG Export" : "Batch Analysis"}
+                                    </CardTitle>
+                                </CardHeader>
+                                <CardContent className="space-y-2 px-4">
+                                    <div className="flex items-center justify-between text-xs text-muted-foreground">
+                                        <span className="truncate pr-3">
+                                            {isExportingBatch
+                    ? exportProgress.fileName || "Preparing export..."
+                    : batchProgress.fileName || analysisProgress.message}
+                                        </span>
+                                        <span className="tabular-nums">
+                                            {isExportingBatch
+                    ? `${exportProgress.completed}/${exportProgress.total}`
+                    : `${Math.min(batchProgress.completed + (isBatchRunning ? 1 : 0), batchProgress.total)}/${batchProgress.total}`}
+                                        </span>
+                                    </div>
+                                    <Progress value={isExportingBatch ? exportPercent : batchPercent} className="h-1.5 w-full"/>
+                                    {!isExportingBatch && (<div className="flex items-center justify-between text-xs text-muted-foreground">
+                                            <span>{analysisProgress.message}</span>
+                                            <span className="tabular-nums">{analysisProgress.percent}%</span>
+                                        </div>)}
+                                </CardContent>
+                            </Card>)}
 
-          
-          {spectrumLoading ? (<div className="flex flex-col items-center justify-center py-16 border rounded-lg">
-              <div className="animate-spin rounded-full h-8 w-8 border-b-2 border-primary mb-2"></div>
-              <p className="text-sm text-muted-foreground">Loading spectrum data...</p>
-            </div>) : (<SpectrumVisualization sampleRate={result.sample_rate} bitsPerSample={result.bits_per_sample} duration={result.duration} spectrumData={result.spectrum}/>)}
-        </div>)}
-    </div>);
+                        <Card className="gap-2 overflow-hidden py-4">
+                            <CardHeader className="px-4 pb-0">
+                                <div className="flex items-center justify-between gap-3">
+                                    <CardTitle className="text-sm">Batch Queue</CardTitle>
+                                    <p className="text-xs text-muted-foreground">
+                                        {items.length} queued • {successItems.length} ready
+                                    </p>
+                                </div>
+                            </CardHeader>
+                            <CardContent className="px-4">
+                                <div className="max-h-[232px] space-y-2 overflow-y-auto pr-1">
+                                    {items.map((item) => {
+                const isActive = item.id === activeItemId;
+                const isSelectable = item.status !== "pending";
+                return (<div key={item.id} role={isSelectable ? "button" : undefined} tabIndex={isSelectable ? 0 : -1} className={`flex w-full items-start gap-2.5 rounded-lg border px-3 py-2.5 text-left transition-colors ${isActive
+                        ? "border-primary bg-primary/5"
+                        : isSelectable
+                            ? "border-border hover:border-primary/40"
+                            : "border-border"}`} onClick={() => {
+                        if (!isSelectable) {
+                            return;
+                        }
+                        handleSelectItem(item.id);
+                    }} onKeyDown={(event) => {
+                        if (!isSelectable) {
+                            return;
+                        }
+                        if (event.key === "Enter" || event.key === " ") {
+                            event.preventDefault();
+                            handleSelectItem(item.id);
+                        }
+                    }}>
+                                                <div className="mt-0.5 shrink-0">{statusIcon(item.status)}</div>
+                                                <div className="min-w-0 flex-1">
+                                                    <p className="truncate text-sm font-medium">{item.name}</p>
+                                                    <p className={`truncate text-xs ${item.status === "error" ? "text-destructive" : "text-muted-foreground"}`}>
+                                                        {itemMetaLine(item)}
+                                                    </p>
+                                                    <div className="mt-1 flex flex-wrap items-center gap-2 text-[11px] text-muted-foreground">
+                                                        <span>{formatFileSize(item.size)}</span>
+                                                        <span>{fileNameFromPath(item.path).split(".").pop()?.toUpperCase() || "AUDIO"}</span>
+                                                    </div>
+                                                </div>
+                                                <Button type="button" variant="ghost" size="icon" className="h-8 w-8 shrink-0" onClick={(event) => {
+                        event.stopPropagation();
+                        handleRemoveItem(item.id);
+                    }} disabled={isBatchRunning || isExportingBatch || isExportingSelected || spectrumLoading}>
+                                                    <X className="h-4 w-4"/>
+                                                </Button>
+                                            </div>);
+            })}
+                                </div>
+                            </CardContent>
+                        </Card>
+                    </div>
+
+                    <div className="space-y-4">
+                        {batchDetailContent}
+                    </div>
+                </div>)}
+        </div>);
 }

frontend/src/components/AudioResamplerPage.tsx

@@ -0,0 +1,468 @@
+import { useState, useCallback, useEffect } from "react";
+import { Button } from "@/components/ui/button";
+import { Label } from "@/components/ui/label";
+import { ToggleGroup, ToggleGroupItem } from "@/components/ui/toggle-group";
+import { Upload, X, CheckCircle2, AlertCircle, Trash2, FileMusic } from "lucide-react";
+import { Spinner } from "@/components/ui/spinner";
+import { SelectAudioFiles, SelectFolder, ListAudioFilesInDir, ResampleAudio } from "../../wailsjs/go/main/App";
+import { toastWithSound as toast } from "@/lib/toast-with-sound";
+import { OnFileDrop, OnFileDropOff } from "../../wailsjs/runtime/runtime";
+import { AudioLinesIcon } from "@/components/ui/audio-lines";
+interface AudioFile {
+    path: string;
+    name: string;
+    format: string;
+    size: number;
+    status: "pending" | "resampling" | "success" | "error";
+    error?: string;
+    outputPath?: string;
+    srcSampleRate?: number;
+    srcBitDepth?: number;
+}
+function formatFileSize(bytes: number): string {
+    if (bytes === 0)
+        return "0 B";
+    const k = 1024;
+    const sizes = ["B", "KB", "MB", "GB"];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return parseFloat((bytes / Math.pow(k, i)).toFixed(1)) + " " + sizes[i];
+}
+function formatSampleRate(sr: number): string {
+    if (!sr)
+        return "";
+    if (sr === 44100)
+        return "44.1kHz";
+    if (sr >= 1000)
+        return `${sr / 1000}kHz`;
+    return `${sr}Hz`;
+}
+const SAMPLE_RATE_OPTIONS = [
+    { value: "44100", label: "44.1kHz" },
+    { value: "48000", label: "48kHz" },
+    { value: "96000", label: "96kHz" },
+    { value: "192000", label: "192kHz" },
+];
+const BIT_DEPTH_OPTIONS = [
+    { value: "16", label: "16-bit" },
+    { value: "24", label: "24-bit" },
+];
+const STORAGE_KEY = "spotiflac_audio_resampler_state";
+export function AudioResamplerPage() {
+    const [files, setFiles] = useState<AudioFile[]>(() => {
+        try {
+            const saved = sessionStorage.getItem(STORAGE_KEY);
+            if (saved) {
+                const parsed = JSON.parse(saved);
+                if (parsed.files && Array.isArray(parsed.files) && parsed.files.length > 0) {
+                    return parsed.files;
+                }
+            }
+        }
+        catch (err) {
+            console.error("Failed to load saved state:", err);
+        }
+        return [];
+    });
+    const [sampleRate, setSampleRate] = useState(() => {
+        try {
+            const saved = sessionStorage.getItem(STORAGE_KEY);
+            if (saved) {
+                const parsed = JSON.parse(saved);
+                if (parsed.sampleRate)
+                    return parsed.sampleRate;
+            }
+        }
+        catch (err) {
+        }
+        return "44100";
+    });
+    const [bitDepth, setBitDepth] = useState(() => {
+        try {
+            const saved = sessionStorage.getItem(STORAGE_KEY);
+            if (saved) {
+                const parsed = JSON.parse(saved);
+                if (parsed.bitDepth)
+                    return parsed.bitDepth;
+            }
+        }
+        catch (err) {
+        }
+        return "16";
+    });
+    const [resampling, setResampling] = useState(false);
+    const [isDragging, setIsDragging] = useState(false);
+    const [isFullscreen, setIsFullscreen] = useState(false);
+    const saveState = useCallback((stateToSave: {
+        files: AudioFile[];
+        sampleRate: string;
+        bitDepth: string;
+    }) => {
+        try {
+            sessionStorage.setItem(STORAGE_KEY, JSON.stringify(stateToSave));
+        }
+        catch (err) {
+            console.error("Failed to save state:", err);
+        }
+    }, []);
+    useEffect(() => {
+        saveState({ files, sampleRate, bitDepth });
+    }, [files, sampleRate, bitDepth, saveState]);
+    useEffect(() => {
+        const checkFullscreen = () => {
+            const isMaximized = window.innerHeight >= window.screen.height * 0.9;
+            setIsFullscreen(isMaximized);
+        };
+        checkFullscreen();
+        window.addEventListener("resize", checkFullscreen);
+        window.addEventListener("focus", checkFullscreen);
+        return () => {
+            window.removeEventListener("resize", checkFullscreen);
+            window.removeEventListener("focus", checkFullscreen);
+        };
+    }, []);
+    const fetchAudioInfo = useCallback(async (paths: string[]) => {
+        if (paths.length === 0)
+            return;
+        try {
+            const GetFlacInfoBatch = (window as any)["go"]["main"]["App"]["GetFlacInfoBatch"];
+            const infos: Array<{
+                path: string;
+                sample_rate: number;
+                bits_per_sample: number;
+            }> = await GetFlacInfoBatch(paths);
+            setFiles((prev) => prev.map((f) => {
+                const info = infos.find((i) => i.path === f.path || i.path.toLowerCase() === f.path.toLowerCase());
+                if (info) {
+                    return {
+                        ...f,
+                        srcSampleRate: info.sample_rate || undefined,
+                        srcBitDepth: info.bits_per_sample || undefined,
+                    };
+                }
+                return f;
+            }));
+        }
+        catch (err) {
+            console.error("Failed to fetch audio info:", err);
+        }
+    }, []);
+    const handleSelectFiles = async () => {
+        try {
+            const selectedFiles = await SelectAudioFiles();
+            if (selectedFiles && selectedFiles.length > 0) {
+                addFiles(selectedFiles);
+            }
+        }
+        catch (err) {
+            toast.error("File Selection Failed", {
+                description: err instanceof Error ? err.message : "Failed to select files",
+            });
+        }
+    };
+    const handleSelectFolder = async () => {
+        try {
+            const selectedFolder = await SelectFolder("");
+            if (selectedFolder) {
+                const folderFiles = await ListAudioFilesInDir(selectedFolder);
+                if (folderFiles && folderFiles.length > 0) {
+                    addFiles(folderFiles.map((f) => f.path));
+                }
+                else {
+                    toast.info("No audio files found", {
+                        description: "No FLAC files found in the selected folder.",
+                    });
+                }
+            }
+        }
+        catch (err) {
+            toast.error("Folder Selection Failed", {
+                description: err instanceof Error ? err.message : "Failed to select folder",
+            });
+        }
+    };
+    const addFiles = useCallback(async (paths: string[]) => {
+        const validExtensions = [".flac"];
+        const invalidFiles = paths.filter((path) => {
+            const ext = path.toLowerCase().slice(path.lastIndexOf("."));
+            return !validExtensions.includes(ext);
+        });
+        if (invalidFiles.length > 0) {
+            toast.error("Unsupported format", {
+                description: "Only FLAC files are supported for resampling.",
+            });
+        }
+        const GetFileSizes = (files: string[]): Promise<Record<string, number>> => (window as any)["go"]["main"]["App"]["GetFileSizes"](files);
+        const validPaths = paths.filter((path) => {
+            const ext = path.toLowerCase().slice(path.lastIndexOf("."));
+            return validExtensions.includes(ext);
+        });
+        const fileSizes = validPaths.length > 0 ? await GetFileSizes(validPaths) : {};
+        let newlyAddedPaths: string[] = [];
+        setFiles((prev) => {
+            const newFiles: AudioFile[] = validPaths
+                .filter((path) => !prev.some((f) => f.path === path))
+                .map((path) => {
+                const name = path.split(/[/\\]/).pop() || path;
+                const ext = name.slice(name.lastIndexOf(".") + 1).toLowerCase();
+                return {
+                    path,
+                    name,
+                    format: ext,
+                    size: fileSizes[path] || 0,
+                    status: "pending" as const,
+                };
+            });
+            newlyAddedPaths = newFiles.map((f) => f.path);
+            if (newFiles.length > 0) {
+                if (paths.length > newFiles.length + invalidFiles.length) {
+                    const skipped = paths.length - newFiles.length - invalidFiles.length;
+                    toast.info("Some files skipped", {
+                        description: `${skipped} file(s) were already added`,
+                    });
+                }
+                return [...prev, ...newFiles];
+            }
+            if (validPaths.length > 0 && newFiles.length === 0) {
+                toast.info("No new files added", {
+                    description: "All valid files were already added",
+                });
+            }
+            return prev;
+        });
+        setTimeout(() => {
+            if (newlyAddedPaths.length > 0) {
+                fetchAudioInfo(newlyAddedPaths);
+            }
+        }, 50);
+    }, [fetchAudioInfo]);
+    const handleFileDrop = useCallback(async (_x: number, _y: number, paths: string[]) => {
+        setIsDragging(false);
+        if (paths.length === 0)
+            return;
+        addFiles(paths);
+    }, [addFiles]);
+    useEffect(() => {
+        OnFileDrop((x, y, paths) => {
+            handleFileDrop(x, y, paths);
+        }, true);
+        return () => {
+            OnFileDropOff();
+        };
+    }, [handleFileDrop]);
+    const removeFile = (path: string) => {
+        setFiles((prev) => prev.filter((f) => f.path !== path));
+    };
+    const clearFiles = () => {
+        setFiles([]);
+    };
+    const handleResample = async () => {
+        if (files.length === 0) {
+            toast.error("No files selected", {
+                description: "Please add FLAC files to resample",
+            });
+            return;
+        }
+        setResampling(true);
+        try {
+            const inputPaths = files.map((f) => f.path);
+            setFiles((prev) => prev.map((f) => {
+                if (inputPaths.includes(f.path)) {
+                    return { ...f, status: "resampling" as const, error: undefined };
+                }
+                return f;
+            }));
+            const results = await ResampleAudio({
+                input_files: inputPaths,
+                sample_rate: sampleRate,
+                bit_depth: bitDepth,
+            });
+            setFiles((prev) => prev.map((f) => {
+                const result = results.find((r: any) => r.input_file === f.path || r.input_file.toLowerCase() === f.path.toLowerCase());
+                if (result) {
+                    return {
+                        ...f,
+                        status: result.success ? "success" : "error",
+                        error: result.error,
+                        outputPath: result.output_file,
+                    };
+                }
+                return f;
+            }));
+            const successCount = results.filter((r: any) => r.success).length;
+            const failCount = results.filter((r: any) => !r.success).length;
+            if (successCount > 0) {
+                toast.success("Resampling Complete", {
+                    description: `Successfully resampled ${successCount} file(s)${failCount > 0 ? `, ${failCount} failed` : ""}`,
+                });
+            }
+            else if (failCount > 0) {
+                toast.error("Resampling Failed", {
+                    description: `All ${failCount} file(s) failed to resample`,
+                });
+            }
+        }
+        catch (err) {
+            toast.error("Resampling Error", {
+                description: err instanceof Error ? err.message : "Unknown error",
+            });
+            setFiles((prev) => prev.map((f) => ({ ...f, status: "error" as const, error: "Resampling failed" })));
+        }
+        finally {
+            setResampling(false);
+        }
+    };
+    const getStatusIcon = (status: AudioFile["status"]) => {
+        switch (status) {
+            case "resampling":
+                return <Spinner className="h-4 w-4 text-primary"/>;
+            case "success":
+                return <CheckCircle2 className="h-4 w-4 text-green-500"/>;
+            case "error":
+                return <AlertCircle className="h-4 w-4 text-destructive"/>;
+            default:
+                return <FileMusic className="h-4 w-4 text-muted-foreground"/>;
+        }
+    };
+    const resampleableCount = files.filter((f) => f.status === "pending" || f.status === "success").length;
+    const successCount = files.filter((f) => f.status === "success").length;
+    return (<div className={`space-y-6 ${isFullscreen ? "h-full flex flex-col" : ""}`}>
+
+        <div className="flex items-center justify-between">
+            <h1 className="text-2xl font-bold">Audio Resampler</h1>
+            {files.length > 0 && (<div className="flex gap-2">
+                <Button variant="outline" size="sm" onClick={handleSelectFiles}>
+                    <Upload className="h-4 w-4"/>
+                    Add Files
+                </Button>
+                <Button variant="outline" size="sm" onClick={handleSelectFolder}>
+                    <Upload className="h-4 w-4"/>
+                    Add Folder
+                </Button>
+                <Button variant="outline" size="sm" onClick={clearFiles} disabled={resampling}>
+                    <Trash2 className="h-4 w-4"/>
+                    Clear All
+                </Button>
+            </div>)}
+        </div>
+
+        <div className={`flex flex-col items-center justify-center border-2 border-dashed rounded-lg transition-all ${isFullscreen ? "flex-1 min-h-[400px]" : "h-[400px]"} ${isDragging
+            ? "border-primary bg-primary/10"
+            : "border-muted-foreground/30"}`} onDragOver={(e) => {
+            e.preventDefault();
+            setIsDragging(true);
+        }} onDragLeave={(e) => {
+            e.preventDefault();
+            setIsDragging(false);
+        }} onDrop={(e) => {
+            e.preventDefault();
+            setIsDragging(false);
+        }} style={{ "--wails-drop-target": "drop" } as React.CSSProperties}>
+            {files.length === 0 ? (<>
+                <div className="mb-4 flex h-16 w-16 items-center justify-center rounded-full bg-muted">
+                    <Upload className="h-8 w-8 text-primary"/>
+                </div>
+                <p className="text-sm text-muted-foreground mb-4 text-center">
+                    {isDragging
+                ? "Drop your audio files here"
+                : "Drag and drop audio files here, or click the button below to select"}
+                </p>
+                <div className="flex gap-3">
+                    <Button onClick={handleSelectFiles} size="lg">
+                        <Upload className="h-5 w-5"/>
+                        Select Files
+                    </Button>
+                    <Button onClick={handleSelectFolder} size="lg" variant="outline">
+                        <Upload className="h-5 w-5"/>
+                        Select Folder
+                    </Button>
+                </div>
+                <p className="text-xs text-muted-foreground mt-4 text-center">
+                    Supported format: FLAC
+                </p>
+            </>) : (<div className="w-full h-full p-6 space-y-4 flex flex-col">
+                <div className="space-y-2 pb-4 border-b shrink-0">
+                    <div className="flex flex-wrap items-center gap-4">
+                        <div className="flex items-center gap-2">
+                            <Label className="whitespace-nowrap">Bit Depth:</Label>
+                            <ToggleGroup type="single" variant="outline" value={bitDepth} onValueChange={(value) => {
+                if (value)
+                    setBitDepth(value);
+            }}>
+                                {BIT_DEPTH_OPTIONS.map((option) => (<ToggleGroupItem key={option.value} value={option.value} aria-label={option.label}>
+                                        {option.label}
+                                    </ToggleGroupItem>))}
+                            </ToggleGroup>
+                        </div>
+
+                        <div className="flex items-center gap-2">
+                            <Label className="whitespace-nowrap">Sample Rate:</Label>
+                            <ToggleGroup type="single" variant="outline" value={sampleRate} onValueChange={(value) => {
+                if (value)
+                    setSampleRate(value);
+            }}>
+                                {SAMPLE_RATE_OPTIONS.map((option) => (<ToggleGroupItem key={option.value} value={option.value} aria-label={option.label}>
+                                        {option.label}
+                                    </ToggleGroupItem>))}
+                            </ToggleGroup>
+                        </div>
+                    </div>
+                </div>
+
+                <div className="flex items-center justify-between shrink-0">
+                    <div className="text-sm text-muted-foreground">
+                        {files.length} file(s) • {successCount} resampled
+                    </div>
+                </div>
+
+                <div className="flex-1 space-y-2 overflow-y-auto min-h-0">
+                    {files.map((file) => {
+                const srcParts: string[] = [];
+                if (file.srcBitDepth)
+                    srcParts.push(`${file.srcBitDepth}-bit`);
+                if (file.srcSampleRate)
+                    srcParts.push(formatSampleRate(file.srcSampleRate));
+                const srcSpec = srcParts.join(" / ");
+                return (<div key={file.path} className="flex items-center gap-3 rounded-lg border p-3">
+                                    {getStatusIcon(file.status)}
+                                    <div className="flex-1 min-w-0">
+                                        <p className="truncate text-sm font-medium">{file.name}</p>
+                                        {file.error && (<p className="truncate text-xs text-destructive">
+                                                {file.error}
+                                            </p>)}
+                                    </div>
+
+                                    {srcSpec ? (<span className="text-xs font-medium text-primary bg-primary/10 rounded px-1.5 py-0.5 whitespace-nowrap shrink-0">
+                                            {srcSpec}
+                                        </span>) : file.status === "pending" ? (<span className="text-xs text-muted-foreground/50 whitespace-nowrap shrink-0">
+                                            reading...
+                                        </span>) : null}
+
+                                    <span className="text-xs text-muted-foreground shrink-0">
+                                        {formatFileSize(file.size)}
+                                    </span>
+                                    <span className="text-xs uppercase text-muted-foreground shrink-0">
+                                        {file.format}
+                                    </span>
+                                    {file.status !== "resampling" && (<Button variant="ghost" size="icon" className="h-8 w-8 shrink-0" onClick={() => removeFile(file.path)} disabled={resampling}>
+                                            <X className="h-4 w-4"/>
+                                        </Button>)}
+                                </div>);
+            })}
+                </div>
+
+                <div className="flex justify-center pt-4 border-t shrink-0">
+                    <Button onClick={handleResample} disabled={resampling || resampleableCount === 0} size="lg">
+                        {resampling ? (<>
+                                <Spinner className="h-4 w-4"/>
+                                Resampling...
+                            </>) : (<>
+                                <AudioLinesIcon size={16} className="text-primary-foreground"/>
+                                Resample{" "}
+                                {resampleableCount > 0 ? `${resampleableCount} File(s)` : ""}
+                            </>)}
+                    </Button>
+                </div>
+            </div>)}
+        </div>
+    </div>);
+}

frontend/src/components/DebugLoggerPage.tsx

@@ -2,6 +2,7 @@ import { useState, useEffect, useRef } from "react";
 import { Trash2, Copy, Check, FileDown } from "lucide-react";
 import { Button } from "@/components/ui/button";
 import { logger, type LogEntry } from "@/lib/logger";
+import { useDownloadQueueData } from "@/hooks/useDownloadQueueData";
 import { ExportFailedDownloads } from "../../wailsjs/go/main/App";
 import { toastWithSound as toast } from "@/lib/toast-with-sound";
 const levelColors: Record<string, string> = {
@@ -23,6 +24,13 @@ export function DebugLoggerPage() {
     const [logs, setLogs] = useState<LogEntry[]>([]);
     const [copied, setCopied] = useState(false);
     const scrollRef = useRef<HTMLDivElement>(null);
+    const queueInfo = useDownloadQueueData();
+    const hasDownloadActivity = queueInfo.queue.length > 0 ||
+        queueInfo.queued_count > 0 ||
+        queueInfo.completed_count > 0 ||
+        queueInfo.failed_count > 0 ||
+        queueInfo.skipped_count > 0;
+    const canExportFailed = hasDownloadActivity && queueInfo.failed_count > 0;
     useEffect(() => {
         const unsubscribe = logger.subscribe(() => {
             setLogs(logger.getLogs());
@@ -54,6 +62,9 @@ export function DebugLoggerPage() {
         }
     };
     const handleExportFailed = async () => {
+        if (!canExportFailed) {
+            return;
+        }
         try {
             const message = await ExportFailedDownloads();
             if (message.startsWith("Successfully")) {
@@ -72,7 +83,7 @@ export function DebugLoggerPage() {
       <div className="flex items-center justify-between">
         <h1 className="text-2xl font-bold">Debug Logs</h1>
         <div className="flex items-center gap-2">
-          <Button variant="outline" size="sm" className="gap-1.5" onClick={handleExportFailed}>
+          <Button variant="outline" size="sm" className="gap-1.5" onClick={handleExportFailed} disabled={!canExportFailed}>
             <FileDown className="h-4 w-4"/>
             Export Failed
           </Button>

frontend/src/components/DownloadProgressToast.tsx

@@ -13,18 +13,18 @@ export function DownloadProgressToast({ onClick }: DownloadProgressToastProps) {
         return null;
     }
     return (<div className="fixed bottom-4 left-[calc(56px+1rem)] z-50 animate-in slide-in-from-bottom-5 data-[state=closed]:animate-out data-[state=closed]:slide-out-to-bottom-5">
-      <Button variant="outline" className="bg-background border rounded-lg shadow-lg p-3 h-auto hover:bg-muted/50 transition-colors cursor-pointer" onClick={onClick}>
+      <Button variant="outline" className="h-auto cursor-pointer rounded-lg border-border bg-background p-3 text-foreground shadow-lg transition-colors hover:bg-muted dark:border-blue-800 dark:bg-blue-950 dark:text-blue-100 dark:hover:bg-blue-900" onClick={onClick}>
         <div className="flex items-center gap-3">
-          <Download className={`h-4 w-4 text-primary ${progress.is_downloading ? 'animate-bounce' : ''}`}/>
+          <Download className={`h-4 w-4 text-blue-600 dark:text-blue-400 ${progress.is_downloading ? 'animate-bounce' : ''}`}/>
           <div className="flex flex-col min-w-[80px]">
             <p className="text-sm font-medium font-mono tabular-nums">
               {progress.mb_downloaded.toFixed(2)} MB
             </p>
-            {progress.speed_mbps > 0 && (<p className="text-xs text-muted-foreground font-mono tabular-nums">
+            {progress.speed_mbps > 0 && (<p className="text-xs font-mono tabular-nums text-muted-foreground dark:text-blue-300">
                 {progress.speed_mbps.toFixed(2)} MB/s
               </p>)}
           </div>
-          <ChevronRight className="h-4 w-4 text-muted-foreground ml-1"/>
+          <ChevronRight className="ml-1 h-4 w-4 text-muted-foreground dark:text-blue-300"/>
         </div>
       </Button>
     </div>);

frontend/src/components/DragDropTextarea.tsx

@@ -1,182 +0,0 @@
-import { useState, useEffect } from "react";
-import type { DragEvent } from "react";
-import { UploadImageBytes, UploadImage, SelectImageVideo } from "../../wailsjs/go/main/App";
-import { Upload, Loader2, ImagePlus, X, Check, FileVideo, ImageIcon } from "lucide-react";
-import { cn } from "@/lib/utils";
-import { Button } from "@/components/ui/button";
-interface UploadedFile {
-    id: string;
-    name: string;
-    url: string;
-    type: 'image' | 'video' | 'unknown';
-    status: 'uploading' | 'done' | 'error';
-    error?: string;
-}
-interface DragDropMediaProps {
-    value: string;
-    onChange: (value: string) => void;
-    className?: string;
-}
-export function DragDropMedia({ value, onChange, className }: DragDropMediaProps) {
-    const [isDragging, setIsDragging] = useState(false);
-    const [files, setFiles] = useState<UploadedFile[]>(() => {
-        if (!value)
-            return [];
-        return value.split('\n').filter(line => line.trim()).map((line, i) => {
-            const match = line.match(/!\[(.*?)\]\((.*?)\)/);
-            if (match) {
-                return {
-                    id: `init-${i}-${Date.now()}`,
-                    name: match[1] === 'image' || match[1] === 'video' ? `file-${i}` : match[1],
-                    url: match[2] || line,
-                    type: (match[2] && match[2].match(/\.(mp4|mkv|webm|mov)$/i)) ? 'video' : 'image',
-                    status: 'done'
-                };
-            }
-            return {
-                id: `init-${i}-${Date.now()}`,
-                name: 'unknown',
-                url: line,
-                type: 'image',
-                status: 'done'
-            };
-        });
-    });
-    useEffect(() => {
-        const newValue = files
-            .filter(f => f.status === 'done' && f.url)
-            .map(f => f.url)
-            .join('\n');
-        if (newValue !== value) {
-            onChange(newValue);
-        }
-    }, [files]);
-    const handleDragOver = (e: DragEvent<HTMLDivElement>) => {
-        e.preventDefault();
-        e.stopPropagation();
-        setIsDragging(true);
-    };
-    const handleDragLeave = (e: DragEvent<HTMLDivElement>) => {
-        e.preventDefault();
-        e.stopPropagation();
-        setIsDragging(false);
-    };
-    const handleDrop = async (e: DragEvent<HTMLDivElement>) => {
-        e.preventDefault();
-        e.stopPropagation();
-        setIsDragging(false);
-        if (e.dataTransfer.files && e.dataTransfer.files.length > 0) {
-            await handleFiles(Array.from(e.dataTransfer.files));
-        }
-    };
-    const handleFiles = async (fileList: File[]) => {
-        const timestamp = Date.now();
-        const newFiles: UploadedFile[] = fileList.map((f, i) => ({
-            id: `drop-${timestamp}-${i}`,
-            name: f.name,
-            url: '',
-            type: f.type.startsWith('video') ? 'video' : 'image',
-            status: 'uploading'
-        }));
-        setFiles(prev => [...prev, ...newFiles]);
-        for (let i = 0; i < fileList.length; i++) {
-            const file = fileList[i];
-            const fileId = newFiles[i].id;
-            try {
-                const base64 = await fileToBase64(file);
-                const result = await UploadImageBytes(file.name, base64);
-                setFiles(prev => prev.map(f => f.id === fileId
-                    ? { ...f, status: 'done', url: result }
-                    : f));
-            }
-            catch (err: any) {
-                console.error("Upload failed", err);
-                setFiles(prev => prev.map(f => f.id === fileId
-                    ? { ...f, status: 'error', error: err.message || "Upload failed" }
-                    : f));
-            }
-        }
-    };
-    const handleSelectFile = async () => {
-        try {
-            const paths = await SelectImageVideo();
-            if (paths && paths.length > 0) {
-                const timestamp = Date.now();
-                const newFiles: UploadedFile[] = paths.map((p, i) => ({
-                    id: `select-${timestamp}-${i}`,
-                    name: p.split(/[\\/]/).pop() || 'unknown',
-                    url: '',
-                    type: p.match(/\.(mp4|mkv|webm|mov)$/i) ? 'video' : 'image',
-                    status: 'uploading'
-                }));
-                setFiles(prev => [...prev, ...newFiles]);
-                for (let i = 0; i < paths.length; i++) {
-                    const path = paths[i];
-                    const fileId = newFiles[i].id;
-                    try {
-                        const result = await UploadImage(path);
-                        setFiles(prev => prev.map(f => f.id === fileId
-                            ? { ...f, status: 'done', url: result }
-                            : f));
-                    }
-                    catch (err: any) {
-                        setFiles(prev => prev.map(f => f.id === fileId
-                            ? { ...f, status: 'error', error: err.message }
-                            : f));
-                    }
-                }
-            }
-        }
-        catch (err: any) {
-            console.error("Select file failed", err);
-        }
-    };
-    const removeFile = (index: number) => {
-        setFiles(prev => prev.filter((_, i) => i !== index));
-    };
-    return (<div className={cn("relative group flex flex-col gap-2 p-4 border-2 border-dashed rounded-lg transition-colors border-muted-foreground/25 hover:border-primary/50 min-h-[14rem]", isDragging ? "border-primary bg-primary/10" : "bg-muted/5", className)} onDragOver={handleDragOver} onDragLeave={handleDragLeave} onDrop={handleDrop} onClick={(e) => {
-            if (e.target === e.currentTarget)
-                handleSelectFile();
-        }}>
-            {files.length === 0 && (<div className="absolute inset-0 flex flex-col items-center justify-center pointer-events-none opacity-50">
-                    <ImagePlus className="h-10 w-10 mb-2"/>
-                    <span className="text-sm font-medium">Drop media here or click to browse</span>
-                    <span className="text-xs text-muted-foreground mt-1">Supports PNG, JPG, MP4, MOV</span>
-                </div>)}
-
-            <div className="flex flex-col gap-2 z-10 w-full">
-                {files.map((file, i) => (<div key={i} className="flex items-center gap-3 p-2 rounded-md bg-background/80 backdrop-blur-sm border shadow-sm animate-in fade-in slide-in-from-bottom-2">
-                        {file.type === 'video' ? <FileVideo className="h-8 w-8 text-primary"/> : <ImageIcon className="h-8 w-8 text-primary"/>}
-                        
-                        <div className="flex-1 min-w-0">
-                            <div className="text-sm font-medium truncate">{file.name}</div>
-                            <div className="text-xs text-muted-foreground flex items-center gap-1">
-                                {file.status === 'uploading' && <span className="text-yellow-500 flex items-center"><Loader2 className="h-3 w-3 animate-spin mr-1"/> Uploading...</span>}
-                                {file.status === 'done' && <span className="text-green-500 flex items-center"><Check className="h-3 w-3 mr-1"/> Ready</span>}
-                                {file.status === 'error' && <span className="text-red-500">{file.error || 'Failed'}</span>}
-                            </div>
-                        </div>
-
-                        <Button variant="ghost" size="icon" className="h-8 w-8 text-muted-foreground hover:text-destructive" onClick={(e) => { e.stopPropagation(); removeFile(i); }}>
-                            <X className="h-4 w-4"/>
-                        </Button>
-                    </div>))}
-            </div>
-
-            
-            {isDragging && (<div className="absolute inset-0 flex items-center justify-center bg-background/50 rounded-lg pointer-events-none z-20">
-                    <div className="flex flex-col items-center text-primary font-medium">
-                        <Upload className="h-10 w-10 mb-2 animate-bounce"/>
-                        <span>Drop files to add</span>
-                    </div>
-                </div>)}
-        </div>);
-}
-const fileToBase64 = (file: File): Promise<string> => {
-    return new Promise((resolve, reject) => {
-        const reader = new FileReader();
-        reader.readAsDataURL(file);
-        reader.onload = () => resolve(reader.result as string);
-        reader.onerror = (error) => reject(error);
-    });
-};

frontend/src/components/FileManagerPage.tsx

@@ -549,7 +549,7 @@ export function FileManagerPage() {
             <Info className="h-3.5 w-3.5 text-muted-foreground cursor-help"/>
           </TooltipTrigger>
           <TooltipContent side="right">
-            <p className="text-xs whitespace-nowrap">Variables: {"{title}"}, {"{artist}"}, {"{album}"}, {"{album_artist}"}, {"{track}"}, {"{disc}"}, {"{year}"}</p>
+            <p className="text-xs whitespace-nowrap">Variables: {"{title}"}, {"{artist}"}, {"{album}"}, {"{album_artist}"}, {"{track}"}, {"{disc}"}, {"{year}"}, {"{date}"}</p>
           </TooltipContent>
         </Tooltip>
       </div>
@@ -571,7 +571,7 @@ export function FileManagerPage() {
         </Tooltip>
       </div>
       <p className="text-xs text-muted-foreground">
-        Preview: <span className="font-mono">{renameFormat.replace(/\{title\}/g, "All The Stars").replace(/\{artist\}/g, "Kendrick Lamar, SZA").replace(/\{album\}/g, "Black Panther").replace(/\{album_artist\}/g, "Kendrick Lamar").replace(/\{track\}/g, "01").replace(/\{disc\}/g, "1").replace(/\{year\}/g, "2018")}.flac</span>
+        Preview: <span className="font-mono">{renameFormat.replace(/\{title\}/g, "All The Stars").replace(/\{artist\}/g, "Kendrick Lamar, SZA").replace(/\{album\}/g, "Black Panther").replace(/\{album_artist\}/g, "Kendrick Lamar").replace(/\{track\}/g, "01").replace(/\{disc\}/g, "1").replace(/\{year\}/g, "2018").replace(/\{date\}/g, "2018-02-09")}.flac</span>
       </p>
     </div>)}
 

frontend/src/components/Header.tsx

@@ -35,7 +35,7 @@ export function Header({ version, hasUpdate, releaseDate }: HeaderProps) {
           </div>
         </div>
         <p className="text-muted-foreground">
-          Get Spotify tracks in true FLAC from Tidal, Qobuz, Amazon Music & Deezer — no account required.
+          Get Spotify tracks in true FLAC from Tidal, Qobuz & Amazon Music — no account required.
         </p>
       </div>
     </div>);

frontend/src/components/HistoryPage.tsx

@@ -9,6 +9,8 @@ import { Pagination, PaginationContent, PaginationEllipsis, PaginationItem, Pagi
 import { GetDownloadHistory, ClearDownloadHistory, GetPreviewURL, GetFetchHistory, DeleteDownloadHistoryItem, DeleteFetchHistoryItem, ClearFetchHistoryByType } from "../../wailsjs/go/main/App";
 import { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger } from "@/components/ui/tooltip";
 import { openExternal } from "@/lib/utils";
+import { SPOTIFY_PREVIEW_VOLUME } from "@/lib/preview";
+import { TidalIcon, QobuzIcon, AmazonIcon } from "./PlatformIcons";
 const formatDate = (timestamp: number) => {
     const date = new Date(timestamp * 1000);
     const year = date.getFullYear();
@@ -30,6 +32,7 @@ interface DownloadHistoryItem {
     quality: string;
     format: string;
     path: string;
+    source: string;
     timestamp: number;
 }
 interface FetchHistoryItem {
@@ -62,10 +65,35 @@ export function HistoryPage({ onHistorySelect }: HistoryPageProps) {
     const [fetchSearchQuery, setFetchSearchQuery] = useState("");
     const [fetchCurrentPage, setFetchCurrentPage] = useState(1);
     const ITEMS_PER_PAGE = 50;
+    const getTrackLink = (spotifyId: string) => {
+        if (spotifyId?.startsWith("tidal_"))
+            return { url: `https://listen.tidal.com/track/${spotifyId.replace("tidal_", "")}`, label: "Open in Tidal" };
+        if (spotifyId?.startsWith("qobuz_"))
+            return { url: `https://www.qobuz.com/track/${spotifyId.replace("qobuz_", "")}`, label: "Open in Qobuz" };
+        if (spotifyId?.startsWith("amazon_"))
+            return { url: `https://music.amazon.com/tracks/${spotifyId.replace("amazon_", "")}`, label: "Open in Amazon Music" };
+        if (spotifyId?.startsWith("deezer_"))
+            return { url: `https://www.deezer.com/track/${spotifyId.replace("deezer_", "")}`, label: "Open in Deezer" };
+        return { url: `https://open.spotify.com/track/${spotifyId}`, label: "Open in Spotify" };
+    };
+    const getSourceIcon = (source: string) => {
+        const s = source?.toLowerCase() || "";
+        if (s.includes("tidal"))
+            return <TidalIcon className="h-4 w-4 object-contain rounded"/>;
+        if (s.includes("qobuz"))
+            return <QobuzIcon className="h-4 w-4 object-contain"/>;
+        if (s.includes("amazon"))
+            return <AmazonIcon className="h-4 w-4 object-contain rounded"/>;
+        if (s.includes("deezer"))
+            return <Music2 className="h-4 w-4"/>;
+        if (s.includes("spotify"))
+            return <Music2 className="h-4 w-4"/>;
+        return <Music2 className="h-4 w-4 opacity-50"/>;
+    };
     const fetchDownloadHistory = async () => {
         try {
             const items = await GetDownloadHistory();
-            setDownloadHistory(items || []);
+            setDownloadHistory((items || []) as unknown as DownloadHistoryItem[]);
         }
         catch (err) {
             console.error("Failed to fetch download history:", err);
@@ -164,7 +192,7 @@ export function HistoryPage({ onHistorySelect }: HistoryPageProps) {
             if (url) {
                 const audio = new Audio(url);
                 audioRef.current = audio;
-                audio.volume = 0.5;
+                audio.volume = SPOTIFY_PREVIEW_VOLUME;
                 audio.onended = () => setPlayingPreviewId(null);
                 audio.play();
                 setPlayingPreviewId(id);
@@ -228,8 +256,8 @@ export function HistoryPage({ onHistorySelect }: HistoryPageProps) {
                      <div className="flex items-center justify-between">
                         <div className="flex items-center gap-2">
                              <h2 className="text-xl font-bold tracking-tight">Downloads</h2>
-                             {downloadHistory.length > 0 && (<Badge variant="secondary" className="font-mono">
-                                    {downloadHistory.length.toLocaleString('en-US')}
+                             {filteredDownloadHistory.length > 0 && (<Badge variant="secondary" className="font-mono">
+                                    {filteredDownloadHistory.length.toLocaleString('en-US')}
                                 </Badge>)}
                         </div>
                         <Button variant="outline" size="sm" onClick={() => setShowClearDownloadConfirm(true)} disabled={downloadHistory.length === 0} className="cursor-pointer gap-2">
@@ -275,11 +303,12 @@ export function HistoryPage({ onHistorySelect }: HistoryPageProps) {
                              <thead>
                                 <tr className="border-b bg-muted/50">
                                     <th className="h-10 px-4 text-left align-middle font-medium text-muted-foreground w-12 text-xs uppercase">#</th>
-                                    <th className="h-10 px-4 text-left align-middle font-medium text-muted-foreground text-xs uppercase">Title</th>
-                                    <th className="h-10 px-4 text-left align-middle font-medium text-muted-foreground hidden md:table-cell text-xs uppercase w-1/4">Album</th>
+                                    <th className="h-10 px-4 text-left align-middle font-medium text-muted-foreground text-xs uppercase w-[35%]">Title</th>
+                                    <th className="h-10 px-4 text-left align-middle font-medium text-muted-foreground hidden md:table-cell text-xs uppercase w-48 lg:w-48 xl:w-56">Album</th>
                                     <th className="h-10 px-4 text-left align-middle font-medium text-muted-foreground hidden lg:table-cell w-32 text-xs uppercase">Format</th>
                                     <th className="h-10 px-4 text-left align-middle font-medium text-muted-foreground hidden xl:table-cell w-16 text-xs uppercase text-nowrap">Dur</th>
                                     <th className="h-10 px-4 text-left align-middle font-medium text-muted-foreground hidden md:table-cell w-36 text-xs uppercase text-nowrap">Downloaded At</th>
+                                    <th className="h-10 px-4 text-center align-middle font-medium text-muted-foreground w-16 text-xs uppercase text-nowrap">Source</th>
                                     <th className="h-10 px-4 text-center align-middle font-medium text-muted-foreground w-32 text-xs uppercase text-nowrap">Actions</th>
                                 </tr>
                             </thead>
@@ -311,36 +340,52 @@ export function HistoryPage({ onHistorySelect }: HistoryPageProps) {
                                         <td className="p-3 align-middle text-sm text-muted-foreground text-left hidden xl:table-cell font-mono">
                                             {item.duration_str}
                                         </td>
-                                         <td className="p-3 align-middle text-xs text-muted-foreground hidden md:table-cell whitespace-nowrap">
+                                         <td className="p-3 align-middle text-xs text-muted-foreground hidden md:table-cell whitespace-nowrap text-left">
                                             <div className="flex flex-col">
                                                 <span>{formatDate(item.timestamp).split(' ')[0]}</span>
                                                 <span className="text-[10px] text-muted-foreground">{formatDate(item.timestamp).split(' ')[1]}</span>
                                             </div>
                                         </td>
                                         <td className="p-3 align-middle text-center">
-                                            <div className="flex items-center justify-center gap-1">
+                                            <div className="flex items-center justify-center">
                                                 <TooltipProvider>
                                                     <Tooltip delayDuration={0}>
                                                         <TooltipTrigger asChild>
-                                                            <Button variant="ghost" size="icon" className="h-8 w-8 cursor-pointer" onClick={() => handlePreview(item.id, item.spotify_id)} disabled={!item.spotify_id}>
-                                                                {playingPreviewId === item.id ? <Pause className="h-4 w-4"/> : <Play className="h-4 w-4"/>}
-                                                            </Button>
+                                                            <div className="flex items-center justify-center">
+                                                                {getSourceIcon(item.source)}
+                                                            </div>
                                                         </TooltipTrigger>
                                                         <TooltipContent>
-                                                            <p>{playingPreviewId === item.id ? "Pause Preview" : "Play Preview"}</p>
+                                                            <p className="capitalize">{item.source || "Unknown"}</p>
                                                         </TooltipContent>
                                                     </Tooltip>
                                                 </TooltipProvider>
+                                            </div>
+                                        </td>
+                                        <td className="p-3 align-middle text-center">
+                                            <div className="flex items-center justify-center gap-1">
+                                                {!(item.spotify_id?.startsWith('tidal_') || item.spotify_id?.startsWith('qobuz_') || item.spotify_id?.startsWith('amazon_') || item.spotify_id?.startsWith('deezer_')) && (<TooltipProvider>
+                                                        <Tooltip delayDuration={0}>
+                                                            <TooltipTrigger asChild>
+                                                                <Button variant="ghost" size="icon" className="h-8 w-8 cursor-pointer" onClick={() => handlePreview(item.id, item.spotify_id)} disabled={!item.spotify_id}>
+                                                                    {playingPreviewId === item.id ? <Pause className="h-4 w-4"/> : <Play className="h-4 w-4"/>}
+                                                                </Button>
+                                                            </TooltipTrigger>
+                                                            <TooltipContent>
+                                                                <p>{playingPreviewId === item.id ? "Pause Preview" : "Play Preview"}</p>
+                                                            </TooltipContent>
+                                                        </Tooltip>
+                                                    </TooltipProvider>)}
 
                                                 <TooltipProvider>
                                                     <Tooltip delayDuration={0}>
                                                         <TooltipTrigger asChild>
-                                                            <Button variant="ghost" size="icon" className="h-8 w-8 cursor-pointer" onClick={() => openExternal(`https://open.spotify.com/track/${item.spotify_id}`)}>
+                                                            <Button variant="ghost" size="icon" className="h-8 w-8 cursor-pointer" onClick={() => openExternal(getTrackLink(item.spotify_id).url)}>
                                                                 <ExternalLink className="h-4 w-4"/>
                                                             </Button>
                                                         </TooltipTrigger>
                                                         <TooltipContent>
-                                                            <p>Open in Spotify</p>
+                                                            <p>{getTrackLink(item.spotify_id).label}</p>
                                                         </TooltipContent>
                                                     </Tooltip>
                                                 </TooltipProvider>

frontend/src/components/PlatformIcons.tsx

@@ -1,23 +1,77 @@
-export const TidalIcon = ({ className = "w-4 h-4" }: {
+import amazonMusicIcon from "../assets/icons/amazon-music.png";
+import qobuzIcon from "../assets/icons/qobuz.png";
+import tidalIcon from "../assets/icons/tidal.png";
+const PLATFORM_ICON_URLS = {
+    tidal: tidalIcon,
+    qobuz: qobuzIcon,
+    amazon: amazonMusicIcon,
+} as const;
+type PlatformIconProps = {
     className?: string;
-}) => (<svg viewBox="0 0 24 24" className={`${className} fill-current`}>
-    <path d="M4.022 4.5 0 8.516l3.997 3.99 3.997-3.984L4.022 4.5Zm7.956 0L7.994 8.522l4.003 3.984L16 8.484 11.978 4.5Zm8.007 0L24 8.528l-4.003 3.978L16 8.484 19.985 4.5Z"></path>
-    <path d="m8.012 16.534 3.991 3.966L16 16.49l-4.003-3.984-3.985 4.028Z"></path>
-  </svg>);
-export const QobuzIcon = ({ className = "w-4 h-4" }: {
+};
+function sanitizeClassName(className: string): string {
+    return className
+        .split(/\s+/)
+        .filter(Boolean)
+        .filter((part) => part !== "fill-current" && part !== "fill-muted-foreground" && !part.startsWith("text-"))
+        .join(" ");
+}
+function hasRoundedClass(className: string): boolean {
+    return className
+        .split(/\s+/)
+        .some((part) => part.startsWith("rounded"));
+}
+function getStatusClasses(className: string): string {
+    if (className.includes("text-green-500")) {
+        return "ring-2 ring-green-500 rounded-sm";
+    }
+    if (className.includes("text-red-500")) {
+        return "ring-2 ring-red-500 rounded-sm opacity-70";
+    }
+    return "";
+}
+function PlatformIcon({ src, alt, className = "w-4 h-4", defaultClassName = "" }: {
+    src: string;
+    alt: string;
     className?: string;
-}) => (<svg viewBox="0 0 24 24" className={`${className} fill-current`}>
-    <path d="M21.744 9.815C19.836 1.261 8.393-1 3.55 6.64-.618 13.214 4 22 11.988 22c2.387 0 4.63-.83 6.394-2.304l2.252 2.252 1.224-1.224-2.252-2.253c1.983-2.407 2.823-5.586 2.138-8.656Zm-3.508 7.297L16.4 15.275c-.786-.787-2.017.432-1.224 1.225L17 18.326C10.29 23.656.5 16 5.16 7.667c3.502-6.264 13.172-4.348 14.707 2.574.529 2.385-.06 4.987-1.63 6.87Z"></path>
-    <path d="M13.4 8.684a3.59 3.59 0 0 0-4.712 1.9 3.59 3.59 0 0 0 1.9 4.712 3.594 3.594 0 0 0 4.711-1.89 3.598 3.598 0 0 0-1.9-4.722Zm-.737 3.591a.727.727 0 0 1-.965.384.727.727 0 0 1-.384-.965.727.727 0 0 1 .965-.384.73.73 0 0 1 .384.965Z"></path>
-  </svg>);
-export const AmazonIcon = ({ className = "w-4 h-4" }: {
-    className?: string;
-}) => (<svg viewBox="0 0 24 24" className={`${className} fill-current`}>
-    <path fillRule="evenodd" d="M15.62 11.13c-.15.1-.37.18-.64.18-.42 0-.82-.05-1.21-.18l-.22-.04c-.08 0-.1.04-.1.14v.25c0 .08.02.12.05.17.02.03.07.08.15.1.4.18.84.25 1.33.25.52 0 .91-.12 1.24-.37.32-.25.47-.57.47-.99 0-.3-.08-.52-.23-.72-.15-.17-.4-.34-.74-.47l-.7-.27c-.26-.1-.46-.2-.53-.3a.47.47 0 0 1-.15-.36c0-.38.27-.57.84-.57.32 0 .64.05.94.15l.2.04c.07 0 .12-.04.12-.14v-.25c0-.08-.03-.12-.05-.17-.03-.05-.08-.08-.15-.1-.37-.13-.74-.2-1.11-.2-.47 0-.87.12-1.16.35-.3.22-.45.54-.45.91 0 .57.32.99.97 1.24l.74.27c.24.1.4.17.5.27.09.1.12.2.12.35 0 .2-.08.37-.23.46Zm-3.88-3.55v3.28c-.42.28-.84.42-1.26.42-.27 0-.47-.07-.6-.22-.11-.15-.16-.37-.16-.7V7.59c0-.13-.05-.18-.18-.18h-.52c-.12 0-.17.05-.17.18v3.06c0 .42.1.77.32.99.22.22.55.35.97.35.56 0 1.13-.2 1.68-.6l.05.3c0 .07.02.1.07.12.02.03.07.03.15.03h.37c.12 0 .17-.05.17-.18V7.58c0-.13-.05-.18-.17-.18h-.52c-.15 0-.2.08-.2.18Zm-4.69 4.27h.52c.12 0 .17-.05.17-.17v-3.1c0-.41-.1-.73-.32-.95a1.25 1.25 0 0 0-.94-.35c-.57 0-1.16.2-1.73.62-.2-.42-.57-.62-1.11-.62-.55 0-1.1.2-1.64.57l-.04-.27c0-.08-.03-.1-.08-.13-.02-.02-.07-.02-.12-.02h-.4c-.12 0-.17.05-.17.17v4.1c0 .13.05.18.17.18h.52c.12 0 .17-.05.17-.18V8.37c.42-.25.84-.4 1.29-.4.25 0 .42.08.52.22.1.15.17.35.17.65v2.84c0 .12.05.17.17.17h.52c.13 0 .18-.05.18-.17V8.37c.44-.27.86-.4 1.28-.4.25 0 .42.08.52.22.1.15.17.35.17.65v2.84c0 .12.05.17.18.17Zm13.47 3.29a21.8 21.8 0 0 1-8.3 1.7c-3.96 0-7.8-1.08-10.88-2.89a.35.35 0 0 0-.15-.05c-.17 0-.27.2-.1.37a16.11 16.11 0 0 0 10.87 4.16c3.02 0 6.5-.94 8.9-2.72.42-.3.08-.74-.34-.57Zm-.08-6.74c.22-.26.57-.38 1.06-.38.25 0 .5.03.72.1l.15.02c.07 0 .12-.04.12-.17v-.25c0-.07-.02-.14-.05-.17a.54.54 0 0 0-.12-.1c-.32-.07-.64-.15-.94-.15-.7 0-1.21.2-1.6.62-.38.4-.57 1-.57 1.73 0 .74.17 1.31.54 1.7.37.4.89.6 1.58.6.37 0 .72-.05.99-.17.07-.03.12-.05.15-.1.02-.03.02-.1.02-.17v-.25c0-.13-.05-.17-.12-.17-.03 0-.07 0-.12.02-.28.07-.55.12-.8.12-.46 0-.81-.12-1.03-.37-.23-.24-.32-.64-.32-1.16v-.12c.02-.55.12-.94.34-1.19Z" clipRule="evenodd"></path>
-    <path fillRule="evenodd" d="M21.55 17.46c1.29-1.09 1.64-3.33 1.36-3.68-.12-.15-.71-.3-1.45-.3-.8 0-1.73.18-2.45.67-.22.15-.17.35.05.32.76-.1 2.5-.3 2.82.1.3.4-.35 2.03-.65 2.74-.07.23.1.3.32.15ZM18.12 7.4h-.52c-.12 0-.17.05-.17.18v4.1c0 .12.05.17.17.17h.52c.12 0 .17-.05.17-.17v-4.1c0-.1-.05-.18-.17-.18Zm.15-1.68a.58.58 0 0 0-.42-.15c-.18 0-.3.05-.4.15a.5.5 0 0 0-.15.37c0 .15.05.3.15.37.1.1.22.15.4.15.17 0 .3-.05.4-.15a.5.5 0 0 0 .14-.37c0-.15-.02-.3-.12-.37Z" clipRule="evenodd"></path>
-  </svg>);
-export const DeezerIcon = ({ className = "w-4 h-4" }: {
-    className?: string;
-}) => (<svg viewBox="0 0 512 512" className={`${className} fill-current`}>
-    <path d="M14.8 101.1C6.6 101.1 0 127.6 0 160.3s6.6 59.2 14.8 59.2s14.8-26.5 14.8-59.2s-6.6-59.2-14.8-59.2m433.9-60.2c-7.7 0-14.5 17.1-19.4 44.1c-7.7-46.7-20.2-77-34.2-77c-16.8 0-31.1 42.9-38 105.4c-6.6-45.4-16.8-74.2-28.3-74.2c-16.1 0-29.6 56.9-34.7 136.2c-9.4-40.8-23.2-66.3-38.3-66.3s-28.8 25.5-38.3 66.3c-5.1-79.3-18.6-136.2-34.7-136.2c-11.5 0-21.7 28.8-28.3 74.2C147.9 50.9 133.3 8 116.7 8c-14 0-26.5 30.4-34.2 77c-4.8-27-11.7-44.1-19.4-44.1c-14.3 0-26 59.2-26 132.1S49 305.2 63.3 305.2c5.9 0 11.5-9.9 15.8-26.8c6.9 61.7 21.2 104.1 38 104.1c13 0 24.5-25.5 32.1-65.6c5.4 76.3 18.6 130.4 34.2 130.4c9.7 0 18.6-21.4 25.3-56.4c7.9 72.2 26.3 122.7 47.7 122.7s39.5-50.5 47.7-122.7c6.6 35 15.6 56.4 25.3 56.4c15.6 0 28.8-54.1 34.2-130.4c7.7 40.1 19.4 65.6 32.1 65.6c16.6 0 30.9-42.3 38-104.1c4.3 16.8 9.7 26.8 15.8 26.8c14.3 0 26-59.2 26-132.1S463 40.9 448.7 40.9m48.5 60.2c-8.2 0-14.8 26.5-14.8 59.2s6.6 59.2 14.8 59.2S512 193 512 160.3s-6.6-59.2-14.8-59.2"/>
-  </svg>);
+    defaultClassName?: string;
+}) {
+    const cleanedClassName = sanitizeClassName(className);
+    const statusClasses = getStatusClasses(className);
+    const imageClassName = [
+        cleanedClassName || "w-4 h-4",
+        "inline-block shrink-0 object-contain",
+        !hasRoundedClass(cleanedClassName) ? defaultClassName : "",
+        statusClasses,
+    ]
+        .filter(Boolean)
+        .join(" ");
+    return <img src={src} alt={alt} className={imageClassName} loading="lazy" referrerPolicy="no-referrer"/>;
+}
+export function TidalIcon({ className = "w-4 h-4" }: PlatformIconProps) {
+    return <PlatformIcon src={PLATFORM_ICON_URLS.tidal} alt="Tidal" className={className} defaultClassName="rounded-[4px]"/>;
+}
+export function QobuzIcon({ className = "w-4 h-4" }: PlatformIconProps) {
+    return <PlatformIcon src={PLATFORM_ICON_URLS.qobuz} alt="Qobuz" className={className}/>;
+}
+export function AmazonIcon({ className = "w-4 h-4" }: PlatformIconProps) {
+    return <PlatformIcon src={PLATFORM_ICON_URLS.amazon} alt="Amazon Music" className={className} defaultClassName="rounded-[4px]"/>;
+}
+export function TidalAvailabilityIcon({ className = "w-4 h-4" }: PlatformIconProps) {
+    return <svg viewBox="0 0 24 24" className={`${className} fill-current`}>
+        <path d="M4.022 4.5 0 8.516l3.997 3.99 3.997-3.984L4.022 4.5Zm7.956 0L7.994 8.522l4.003 3.984L16 8.484 11.978 4.5Zm8.007 0L24 8.528l-4.003 3.978L16 8.484 19.985 4.5Z"></path>
+        <path d="m8.012 16.534 3.991 3.966L16 16.49l-4.003-3.984-3.985 4.028Z"></path>
+    </svg>;
+}
+export function QobuzAvailabilityIcon({ className = "w-4 h-4" }: PlatformIconProps) {
+    return <svg viewBox="0 0 24 24" className={`${className} fill-current`}>
+        <path d="M21.744 9.815C19.836 1.261 8.393-1 3.55 6.64-.618 13.214 4 22 11.988 22c2.387 0 4.63-.83 6.394-2.304l2.252 2.252 1.224-1.224-2.252-2.253c1.983-2.407 2.823-5.586 2.138-8.656Zm-3.508 7.297L16.4 15.275c-.786-.787-2.017.432-1.224 1.225L17 18.326C10.29 23.656.5 16 5.16 7.667c3.502-6.264 13.172-4.348 14.707 2.574.529 2.385-.06 4.987-1.63 6.87Z"></path>
+        <path d="M13.4 8.684a3.59 3.59 0 0 0-4.712 1.9 3.59 3.59 0 0 0 1.9 4.712 3.594 3.594 0 0 0 4.711-1.89 3.598 3.598 0 0 0-1.9-4.722Zm-.737 3.591a.727.727 0 0 1-.965.384.727.727 0 0 1-.384-.965.727.727 0 0 1 .965-.384.73.73 0 0 1 .384.965Z"></path>
+    </svg>;
+}
+export function AmazonAvailabilityIcon({ className = "w-4 h-4" }: PlatformIconProps) {
+    return <svg viewBox="0 0 24 24" className={`${className} fill-current`}>
+        <path fillRule="evenodd" d="M15.62 11.13c-.15.1-.37.18-.64.18-.42 0-.82-.05-1.21-.18l-.22-.04c-.08 0-.1.04-.1.14v.25c0 .08.02.12.05.17.02.03.07.08.15.1.4.18.84.25 1.33.25.52 0 .91-.12 1.24-.37.32-.25.47-.57.47-.99 0-.3-.08-.52-.23-.72-.15-.17-.4-.34-.74-.47l-.7-.27c-.26-.1-.46-.2-.53-.3a.47.47 0 0 1-.15-.36c0-.38.27-.57.84-.57.32 0 .64.05.94.15l.2.04c.07 0 .12-.04.12-.14v-.25c0-.08-.03-.12-.05-.17-.03-.05-.08-.08-.15-.1-.37-.13-.74-.2-1.11-.2-.47 0-.87.12-1.16.35-.3.22-.45.54-.45.91 0 .57.32.99.97 1.24l.74.27c.24.1.4.17.5.27.09.1.12.2.12.35 0 .2-.08.37-.23.46Zm-3.88-3.55v3.28c-.42.28-.84.42-1.26.42-.27 0-.47-.07-.6-.22-.11-.15-.16-.37-.16-.7V7.59c0-.13-.05-.18-.18-.18h-.52c-.12 0-.17.05-.17.18v3.06c0 .42.1.77.32.99.22.22.55.35.97.35.56 0 1.13-.2 1.68-.6l.05.3c0 .07.02.1.07.12.02.03.07.03.15.03h.37c.12 0 .17-.05.17-.18V7.58c0-.13-.05-.18-.17-.18h-.52c-.15 0-.2.08-.2.18Zm-4.69 4.27h.52c.12 0 .17-.05.17-.17v-3.1c0-.41-.1-.73-.32-.95a1.25 1.25 0 0 0-.94-.35c-.57 0-1.16.2-1.73.62-.2-.42-.57-.62-1.11-.62-.55 0-1.1.2-1.64.57l-.04-.27c0-.08-.03-.1-.08-.13-.02-.02-.07-.02-.12-.02h-.4c-.12 0-.17.05-.17.17v4.1c0 .13.05.18.17.18h.52c.12 0 .17-.05.17-.18V8.37c.42-.25.84-.4 1.29-.4.25 0 .42.08.52.22.1.15.17.35.17.65v2.84c0 .12.05.17.17.17h.52c.13 0 .18-.05.18-.17V8.37c.44-.27.86-.4 1.28-.4.25 0 .42.08.52.22.1.15.17.35.17.65v2.84c0 .12.05.17.18.17Zm13.47 3.29a21.8 21.8 0 0 1-8.3 1.7c-3.96 0-7.8-1.08-10.88-2.89a.35.35 0 0 0-.15-.05c-.17 0-.27.2-.1.37a16.11 16.11 0 0 0 10.87 4.16c3.02 0 6.5-.94 8.9-2.72.42-.3.08-.74-.34-.57Zm-.08-6.74c.22-.26.57-.38 1.06-.38.25 0 .5.03.72.1l.15.02c.07 0 .12-.04.12-.17v-.25c0-.07-.02-.14-.05-.17a.54.54 0 0 0-.12-.1c-.32-.07-.64-.15-.94-.15-.7 0-1.21.2-1.6.62-.38.4-.57 1-.57 1.73 0 .74.17 1.31.54 1.7.37.4.89.6 1.58.6.37 0 .72-.05.99-.17.07-.03.12-.05.15-.1.02-.03.02-.1.02-.17v-.25c0-.13-.05-.17-.12-.17-.03 0-.07 0-.12.02-.28.07-.55.12-.8.12-.46 0-.81-.12-1.03-.37-.23-.24-.32-.64-.32-1.16v-.12c.02-.55.12-.94.34-1.19Z" clipRule="evenodd"></path>
+        <path fillRule="evenodd" d="M21.55 17.46c1.29-1.09 1.64-3.33 1.36-3.68-.12-.15-.71-.3-1.45-.3-.8 0-1.73.18-2.45.67-.22.15-.17.35.05.32.76-.1 2.5-.3 2.82.1.3.4-.35 2.03-.65 2.74-.07.23.1.3.32.15ZM18.12 7.4h-.52c-.12 0-.17.05-.17.18v4.1c0 .12.05.17.17.17h.52c.12 0 .17-.05.17-.17v-4.1c0-.1-.05-.18-.17-.18Zm.15-1.68a.58.58 0 0 0-.42-.15c-.18 0-.3.05-.4.15a.5.5 0 0 0-.15.37c0 .15.05.3.15.37.1.1.22.15.4.15.17 0 .3-.05.4-.15a.5.5 0 0 0 .14-.37c0-.15-.02-.3-.12-.37Z" clipRule="evenodd"></path>
+    </svg>;
+}

frontend/src/components/PlaylistInfo.tsx

@@ -6,6 +6,12 @@ import { Tooltip, TooltipContent, TooltipTrigger } from "@/components/ui/tooltip
 import { SearchAndSort } from "./SearchAndSort";
 import { TrackList } from "./TrackList";
 import { DownloadProgress } from "./DownloadProgress";
+import { getSettings } from "@/lib/settings";
+import { downloadCover } from "@/lib/api";
+import { useState } from "react";
+import { toastWithSound as toast } from "@/lib/toast-with-sound";
+import { joinPath, sanitizePath } from "@/lib/utils";
+import { parseTemplate, type TemplateData } from "@/lib/settings";
 import type { TrackMetadata, TrackAvailability } from "@/types/api";
 interface PlaylistInfoProps {
     playlistInfo: {
@@ -81,6 +87,66 @@ interface PlaylistInfoProps {
     onBack?: () => void;
 }
 export function PlaylistInfo({ playlistInfo, trackList, searchQuery, sortBy, selectedTracks, downloadedTracks, failedTracks, skippedTracks, downloadingTrack, isDownloading, bulkDownloadType, downloadProgress, currentDownloadInfo, currentPage, itemsPerPage, downloadedLyrics, failedLyrics, skippedLyrics, downloadingLyricsTrack, checkingAvailabilityTrack, availabilityMap, downloadedCovers, failedCovers, skippedCovers, downloadingCoverTrack, isBulkDownloadingCovers, isBulkDownloadingLyrics, onSearchChange, onSortChange, onToggleTrack, onToggleSelectAll, onDownloadTrack, onDownloadLyrics, onDownloadCover, onCheckAvailability, onDownloadAllLyrics, onDownloadAllCovers, onDownloadAll, onDownloadSelected, onStopDownload, onOpenFolder, onPageChange, onAlbumClick, onArtistClick, onTrackClick, onBack, }: PlaylistInfoProps) {
+    const settings = getSettings();
+    const [downloadingPlaylistCover, setDownloadingPlaylistCover] = useState(false);
+    const handleDownloadPlaylistCover = async () => {
+        if (!playlistInfo.cover)
+            return;
+        setDownloadingPlaylistCover(true);
+        try {
+            const os = settings.operatingSystem;
+            let outputDir = settings.downloadPath;
+            const playlistName = playlistInfo.owner.name;
+            const placeholder = "__SLASH_PLACEHOLDER__";
+            const templateData: TemplateData = {
+                artist: "",
+                album: "",
+                album_artist: "",
+                title: playlistName.replace(/\//g, placeholder),
+                playlist: playlistName.replace(/\//g, placeholder),
+            };
+            if (settings.createPlaylistFolder && playlistName) {
+                outputDir = joinPath(os, outputDir, sanitizePath(playlistName.replace(/\//g, " "), os));
+            }
+            if (settings.folderTemplate) {
+                const folderPath = parseTemplate(settings.folderTemplate, templateData);
+                if (folderPath) {
+                    const parts = folderPath.split("/").filter((p: string) => p.trim());
+                    for (const part of parts) {
+                        outputDir = joinPath(os, outputDir, sanitizePath(part.replace(new RegExp(placeholder, "g"), " "), os));
+                    }
+                }
+            }
+            const response = await downloadCover({
+                cover_url: playlistInfo.cover,
+                track_name: playlistName,
+                artist_name: "",
+                album_name: "",
+                album_artist: "",
+                release_date: "",
+                output_dir: outputDir,
+                filename_format: "title",
+                track_number: false,
+                position: 0,
+                disc_number: 0,
+            });
+            if (response.success) {
+                if (response.already_exists)
+                    toast.info("Cover already exists");
+                else
+                    toast.success("Separate playlist cover downloaded");
+            }
+            else {
+                toast.error(response.error || "Failed to download cover");
+            }
+        }
+        catch (err) {
+            toast.error(err instanceof Error ? err.message : "Failed to download cover");
+        }
+        finally {
+            setDownloadingPlaylistCover(false);
+        }
+    };
     return (<div className="space-y-6">
       <Card className="relative">
       {onBack && (<div className="absolute top-4 right-4 z-10">
@@ -90,7 +156,19 @@ export function PlaylistInfo({ playlistInfo, trackList, searchQuery, sortBy, sel
       </div>)}
         <CardContent className="px-6">
           <div className="flex gap-6 items-start">
-            {playlistInfo.cover && (<img src={playlistInfo.cover} alt={playlistInfo.owner.name} className="w-48 h-48 rounded-md shadow-lg object-cover"/>)}
+            {playlistInfo.cover && (<div className="relative group shrink-0 w-48 h-48">
+                <img src={playlistInfo.cover} alt={playlistInfo.owner.name} className="w-48 h-48 rounded-md shadow-lg object-cover"/>
+                <div className="absolute inset-0 flex items-center justify-center bg-black/40 opacity-0 group-hover:opacity-100 transition-opacity rounded-md">
+                  <Tooltip>
+                    <TooltipTrigger asChild>
+                      <Button variant="secondary" size="icon" className="h-9 w-9 shadow-lg" onClick={handleDownloadPlaylistCover} disabled={downloadingPlaylistCover}>
+                        {downloadingPlaylistCover ? <Spinner /> : <ImageDown className="h-4 w-4"/>}
+                      </Button>
+                    </TooltipTrigger>
+                    <TooltipContent><p>Download Separate Playlist Cover</p></TooltipContent>
+                  </Tooltip>
+                </div>
+              </div>)}
             <div className="flex-1 space-y-4">
               <div className="space-y-2">
                 <p className="text-sm font-medium">Playlist</p>
@@ -135,13 +213,19 @@ export function PlaylistInfo({ playlistInfo, trackList, searchQuery, sortBy, sel
                       </Button>
                     </TooltipTrigger>
                     <TooltipContent>
-                      <p>Download All Covers</p>
+                      <p>Download All Separate Covers</p>
+                    </TooltipContent>
+                  </Tooltip>)}
+                {downloadedTracks.size > 0 && (<Tooltip>
+                    <TooltipTrigger asChild>
+                      <Button onClick={onOpenFolder} variant="outline" size="icon">
+                        <FolderOpen className="h-4 w-4"/>
+                      </Button>
+                    </TooltipTrigger>
+                    <TooltipContent>
+                      <p>Open Folder</p>
                     </TooltipContent>
                   </Tooltip>)}
-                {downloadedTracks.size > 0 && (<Button onClick={onOpenFolder} variant="outline">
-                    <FolderOpen className="h-4 w-4"/>
-                    Open Folder
-                  </Button>)}
               </div>
               {isDownloading && (<DownloadProgress progress={downloadProgress} currentTrack={currentDownloadInfo} onStop={onStopDownload}/>)}
             </div>

frontend/src/components/SearchBar.tsx

@@ -1,7 +1,8 @@
-import { useState, useEffect, useRef } from "react";
+import { useState, useEffect, useRef, useMemo } from "react";
 import { Button } from "@/components/ui/button";
+import { Input } from "@/components/ui/input";
 import { InputWithContext } from "@/components/ui/input-with-context";
-import { CloudDownload, XCircle, Link, Search, X, ChevronDown, } from "lucide-react";
+import { CloudDownload, XCircle, Link, Search, X, ChevronDown, ArrowUpDown, } from "lucide-react";
 import { Spinner } from "@/components/ui/spinner";
 import { Tooltip, TooltipContent, TooltipTrigger, } from "@/components/ui/tooltip";
 import { FetchHistory } from "@/components/FetchHistory";
@@ -10,6 +11,7 @@ import { SearchSpotify, SearchSpotifyByType } from "../../wailsjs/go/main/App";
 import { backend } from "../../wailsjs/go/models";
 import { cn } from "@/lib/utils";
 import { useTypingEffect } from "@/hooks/useTypingEffect";
+import { getSettings, type Settings } from "@/lib/settings";
 import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue, } from "@/components/ui/select";
 import { Dialog, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogTitle, } from "@/components/ui/dialog";
 const FETCH_PLACEHOLDERS = [
@@ -244,6 +246,14 @@ interface SearchBarProps {
 export function SearchBar({ url, loading, onUrlChange, onFetch, onFetchUrl, history, onHistorySelect, onHistoryRemove, hasResult, searchMode, onSearchModeChange, region, onRegionChange, }: SearchBarProps) {
     const [searchQuery, setSearchQuery] = useState("");
     const [searchResults, setSearchResults] = useState<backend.SearchResponse | null>(null);
+    const [showRegionSelector, setShowRegionSelector] = useState(() => getSettings().linkResolver === "songlink");
+    const [resultFilter, setResultFilter] = useState("");
+    const [sortOrders, setSortOrders] = useState<Record<ResultTab, string>>({
+        tracks: "default",
+        albums: "default",
+        artists: "default",
+        playlists: "default",
+    });
     const [isSearching, setIsSearching] = useState(false);
     const [isLoadingMore, setIsLoadingMore] = useState(false);
     const [lastSearchedQuery, setLastSearchedQuery] = useState("");
@@ -271,6 +281,18 @@ export function SearchBar({ url, loading, onUrlChange, onFetch, onFetchUrl, hist
             console.error("Failed to load recent searches:", error);
         }
     }, []);
+    useEffect(() => {
+        const syncRegionVisibility = (settings?: Partial<Settings>) => {
+            const resolver = settings?.linkResolver ?? getSettings().linkResolver;
+            setShowRegionSelector(resolver === "songlink");
+        };
+        syncRegionVisibility();
+        const handleSettingsUpdate = (event: Event) => {
+            syncRegionVisibility((event as CustomEvent<Partial<Settings>>).detail);
+        };
+        window.addEventListener("settingsUpdated", handleSettingsUpdate);
+        return () => window.removeEventListener("settingsUpdated", handleSettingsUpdate);
+    }, []);
     const saveRecentSearch = (query: string) => {
         const trimmed = query.trim();
         if (!trimmed)
@@ -317,6 +339,7 @@ export function SearchBar({ url, loading, onUrlChange, onFetch, onFetchUrl, hist
                     limit: SEARCH_LIMIT,
                 });
                 setSearchResults(results);
+                setResultFilter("");
                 setLastSearchedQuery(searchQuery.trim());
                 saveRecentSearch(searchQuery.trim());
                 setHasMore({
@@ -456,6 +479,88 @@ export function SearchBar({ url, loading, onUrlChange, onFetch, onFetchUrl, hist
                 return searchResults.playlists.length;
         }
     };
+    const sortedResults = useMemo(() => {
+        if (!searchResults)
+            return { tracks: [], albums: [], artists: [], playlists: [] };
+        const filterStr = resultFilter.toLowerCase();
+        let tracks = [...searchResults.tracks];
+        if (filterStr) {
+            tracks = tracks.filter(t => (t.name || '').toLowerCase().includes(filterStr) || (t.artists || '').toLowerCase().includes(filterStr));
+        }
+        const tSort = sortOrders.tracks;
+        if (tSort !== 'default') {
+            tracks.sort((a, b) => {
+                if (tSort === 'title-asc')
+                    return (a.name || '').localeCompare(b.name || '');
+                if (tSort === 'title-desc')
+                    return (b.name || '').localeCompare(a.name || '');
+                if (tSort === 'artist-asc')
+                    return (a.artists || '').localeCompare(b.artists || '');
+                if (tSort === 'artist-desc')
+                    return (b.artists || '').localeCompare(a.artists || '');
+                if (tSort === 'duration-desc')
+                    return (b.duration_ms || 0) - (a.duration_ms || 0);
+                if (tSort === 'duration-asc')
+                    return (a.duration_ms || 0) - (b.duration_ms || 0);
+                return 0;
+            });
+        }
+        let albums = [...searchResults.albums];
+        if (filterStr) {
+            albums = albums.filter(a => (a.name || '').toLowerCase().includes(filterStr) || (a.artists || '').toLowerCase().includes(filterStr));
+        }
+        const alSort = sortOrders.albums;
+        if (alSort !== 'default') {
+            albums.sort((a, b) => {
+                if (alSort === 'title-asc')
+                    return (a.name || '').localeCompare(b.name || '');
+                if (alSort === 'title-desc')
+                    return (b.name || '').localeCompare(a.name || '');
+                if (alSort === 'artist-asc')
+                    return (a.artists || '').localeCompare(b.artists || '');
+                if (alSort === 'artist-desc')
+                    return (b.artists || '').localeCompare(a.artists || '');
+                if (alSort === 'year-desc')
+                    return (b.release_date || '').localeCompare(a.release_date || '');
+                if (alSort === 'year-asc')
+                    return (a.release_date || '').localeCompare(b.release_date || '');
+                return 0;
+            });
+        }
+        let artists = [...searchResults.artists];
+        if (filterStr) {
+            artists = artists.filter(a => (a.name || '').toLowerCase().includes(filterStr));
+        }
+        const arSort = sortOrders.artists;
+        if (arSort !== 'default') {
+            artists.sort((a, b) => {
+                if (arSort === 'name-asc')
+                    return (a.name || '').localeCompare(b.name || '');
+                if (arSort === 'name-desc')
+                    return (b.name || '').localeCompare(a.name || '');
+                return 0;
+            });
+        }
+        let playlists = [...searchResults.playlists];
+        if (filterStr) {
+            playlists = playlists.filter(p => (p.name || '').toLowerCase().includes(filterStr) || (p.owner || '').toLowerCase().includes(filterStr));
+        }
+        const pSort = sortOrders.playlists;
+        if (pSort !== 'default') {
+            playlists.sort((a, b) => {
+                if (pSort === 'title-asc')
+                    return (a.name || '').localeCompare(b.name || '');
+                if (pSort === 'title-desc')
+                    return (b.name || '').localeCompare(a.name || '');
+                if (pSort === 'owner-asc')
+                    return (a.owner || '').localeCompare(b.owner || '');
+                if (pSort === 'owner-desc')
+                    return (b.owner || '').localeCompare(a.owner || '');
+                return 0;
+            });
+        }
+        return { tracks, albums, artists, playlists };
+    }, [searchResults, sortOrders, resultFilter]);
     const tabs: {
         key: ResultTab;
         label: string;
@@ -490,6 +595,7 @@ export function SearchBar({ url, loading, onUrlChange, onFetch, onFetchUrl, hist
                     setSearchQuery("");
                     setSearchResults(null);
                     setLastSearchedQuery("");
+                    setResultFilter("");
                 }}>
                   <XCircle className="h-4 w-4"/>
                 </button>)}
@@ -497,19 +603,19 @@ export function SearchBar({ url, loading, onUrlChange, onFetch, onFetchUrl, hist
         </div>
 
         {!searchMode && (<>
-            <Select value={region} onValueChange={onRegionChange}>
-              <SelectTrigger className="w-[70px] shrink-0">
-                <SelectValue placeholder="Region"/>
-              </SelectTrigger>
-              <SelectContent className="max-h-[300px]">
-                {REGIONS.map((r) => (<SelectItem key={r} value={r} textValue={r}>
-                    {r}{" "}
-                    <span className="text-muted-foreground">
-                      ({getRegionName(r)})
-                    </span>
-                  </SelectItem>))}
-              </SelectContent>
-            </Select>
+            {showRegionSelector && (<Select value={region} onValueChange={onRegionChange}>
+                <SelectTrigger className="w-[70px] shrink-0">
+                  <SelectValue placeholder="Region"/>
+                </SelectTrigger>
+                <SelectContent className="max-h-[300px]">
+                  {REGIONS.map((r) => (<SelectItem key={r} value={r} textValue={r}>
+                      {r}{" "}
+                      <span className="text-muted-foreground">
+                        ({getRegionName(r)})
+                      </span>
+                    </SelectItem>))}
+                </SelectContent>
+              </Select>)}
             <Button onClick={handleFetchWithValidation} disabled={loading}>
               {loading ? (<>
                   <Spinner />
@@ -550,7 +656,7 @@ export function SearchBar({ url, loading, onUrlChange, onFetch, onFetchUrl, hist
             </div>)}
 
           {!isSearching && hasAnyResults && (<>
-              <div className="flex gap-1 border-b">
+              <div className="flex gap-1 border-b mb-4">
                 {tabs.map((tab) => {
                     const count = getTabCount(tab.key);
                     if (count === 0)
@@ -563,9 +669,54 @@ export function SearchBar({ url, loading, onUrlChange, onFetch, onFetchUrl, hist
                 })}
               </div>
 
+              <div className="flex gap-2 mb-4">
+                <div className="relative flex-1">
+                  <Search className="absolute left-3 top-1/2 transform -translate-y-1/2 h-4 w-4 text-muted-foreground"/>
+                  <Input placeholder={`Search ${activeTab}...`} value={resultFilter} onChange={(e) => setResultFilter(e.target.value)} className="pl-10 pr-8"/>
+                  {resultFilter && (<button type="button" className="absolute right-2 top-1/2 -translate-y-1/2 text-muted-foreground hover:text-foreground transition-colors cursor-pointer" onClick={() => setResultFilter("")}>
+                      <XCircle className="h-4 w-4"/>
+                    </button>)}
+                </div>
+                <Select value={sortOrders[activeTab]} onValueChange={(val) => setSortOrders(prev => ({ ...prev, [activeTab]: val }))}>
+                  <SelectTrigger className="w-[170px] bg-background gap-1.5">
+                    <ArrowUpDown className="h-4 w-4 text-muted-foreground"/>
+                    <SelectValue placeholder="Sort by"/>
+                  </SelectTrigger>
+                    <SelectContent>
+                      <SelectItem value="default">Default</SelectItem>
+                      {activeTab === 'tracks' && (<>
+                          <SelectItem value="title-asc">Title (A-Z)</SelectItem>
+                          <SelectItem value="title-desc">Title (Z-A)</SelectItem>
+                          <SelectItem value="artist-asc">Artist (A-Z)</SelectItem>
+                          <SelectItem value="artist-desc">Artist (Z-A)</SelectItem>
+                          <SelectItem value="duration-desc">Duration (Longest)</SelectItem>
+                          <SelectItem value="duration-asc">Duration (Shortest)</SelectItem>
+                        </>)}
+                      {activeTab === 'albums' && (<>
+                          <SelectItem value="title-asc">Title (A-Z)</SelectItem>
+                          <SelectItem value="title-desc">Title (Z-A)</SelectItem>
+                          <SelectItem value="artist-asc">Artist (A-Z)</SelectItem>
+                          <SelectItem value="artist-desc">Artist (Z-A)</SelectItem>
+                          <SelectItem value="year-desc">Year (Newest)</SelectItem>
+                          <SelectItem value="year-asc">Year (Oldest)</SelectItem>
+                        </>)}
+                      {activeTab === 'artists' && (<>
+                          <SelectItem value="name-asc">Name (A-Z)</SelectItem>
+                          <SelectItem value="name-desc">Name (Z-A)</SelectItem>
+                        </>)}
+                      {activeTab === 'playlists' && (<>
+                          <SelectItem value="title-asc">Title (A-Z)</SelectItem>
+                          <SelectItem value="title-desc">Title (Z-A)</SelectItem>
+                          <SelectItem value="owner-asc">Owner (A-Z)</SelectItem>
+                          <SelectItem value="owner-desc">Owner (Z-A)</SelectItem>
+                        </>)}
+                    </SelectContent>
+                  </Select>
+              </div>
+
               <div className="grid gap-2">
                 {activeTab === "tracks" &&
-                    searchResults?.tracks.map((track) => (<button key={track.id} type="button" className="flex items-center gap-3 p-3 rounded-lg bg-card hover:bg-accent border cursor-pointer text-left transition-colors" onClick={() => handleResultClick(track.external_urls)}>
+                    sortedResults.tracks.map((track) => (<button key={track.id} type="button" className="flex items-center gap-3 p-3 rounded-lg bg-card hover:bg-accent border cursor-pointer text-left transition-colors" onClick={() => handleResultClick(track.external_urls)}>
                       {track.images ? (<img src={track.images} alt="" className="w-12 h-12 rounded object-cover shrink-0"/>) : (<div className="w-12 h-12 rounded bg-muted shrink-0"/>)}
                       <div className="flex-1 min-w-0">
                         <div className="flex items-center gap-1.5 min-w-0">
@@ -584,7 +735,7 @@ export function SearchBar({ url, loading, onUrlChange, onFetch, onFetchUrl, hist
                     </button>))}
 
                 {activeTab === "albums" &&
-                    searchResults?.albums.map((album) => (<button key={album.id} type="button" className="flex items-center gap-3 p-3 rounded-lg bg-card hover:bg-accent border cursor-pointer text-left transition-colors" onClick={() => handleResultClick(album.external_urls)}>
+                    sortedResults.albums.map((album) => (<button key={album.id} type="button" className="flex items-center gap-3 p-3 rounded-lg bg-card hover:bg-accent border cursor-pointer text-left transition-colors" onClick={() => handleResultClick(album.external_urls)}>
                       {album.images ? (<img src={album.images} alt="" className="w-12 h-12 rounded object-cover shrink-0"/>) : (<div className="w-12 h-12 rounded bg-muted shrink-0"/>)}
                       <div className="flex-1 min-w-0">
                         <p className="font-medium truncate">{album.name}</p>
@@ -598,7 +749,7 @@ export function SearchBar({ url, loading, onUrlChange, onFetch, onFetchUrl, hist
                     </button>))}
 
                 {activeTab === "artists" &&
-                    searchResults?.artists.map((artist) => (<button key={artist.id} type="button" className="flex items-center gap-3 p-3 rounded-lg bg-card hover:bg-accent border cursor-pointer text-left transition-colors" onClick={() => handleResultClick(artist.external_urls)}>
+                    sortedResults.artists.map((artist) => (<button key={artist.id} type="button" className="flex items-center gap-3 p-3 rounded-lg bg-card hover:bg-accent border cursor-pointer text-left transition-colors" onClick={() => handleResultClick(artist.external_urls)}>
                       {artist.images ? (<img src={artist.images} alt="" className="w-12 h-12 rounded-full object-cover shrink-0"/>) : (<div className="w-12 h-12 rounded-full bg-muted shrink-0"/>)}
                       <div className="flex-1 min-w-0">
                         <p className="font-medium truncate">{artist.name}</p>
@@ -607,7 +758,7 @@ export function SearchBar({ url, loading, onUrlChange, onFetch, onFetchUrl, hist
                     </button>))}
 
                 {activeTab === "playlists" &&
-                    searchResults?.playlists.map((playlist) => (<button key={playlist.id} type="button" className="flex items-center gap-3 p-3 rounded-lg bg-card hover:bg-accent border cursor-pointer text-left transition-colors" onClick={() => handleResultClick(playlist.external_urls)}>
+                    sortedResults.playlists.map((playlist) => (<button key={playlist.id} type="button" className="flex items-center gap-3 p-3 rounded-lg bg-card hover:bg-accent border cursor-pointer text-left transition-colors" onClick={() => handleResultClick(playlist.external_urls)}>
                       {playlist.images ? (<img src={playlist.images} alt="" className="w-12 h-12 rounded object-cover shrink-0"/>) : (<div className="w-12 h-12 rounded bg-muted shrink-0"/>)}
                       <div className="flex-1 min-w-0">
                         <p className="font-medium truncate">{playlist.name}</p>

frontend/src/components/SettingsPage.tsx

@@ -5,36 +5,17 @@ import { InputWithContext } from "@/components/ui/input-with-context";
 import { Label } from "@/components/ui/label";
 import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue, } from "@/components/ui/select";
 import { Tooltip, TooltipContent, TooltipTrigger, } from "@/components/ui/tooltip";
-import { FolderOpen, Save, RotateCcw, Info, ArrowRight, Settings, FolderCog, } from "lucide-react";
+import { FolderOpen, Save, RotateCcw, Info, ArrowRight, MonitorCog, FolderCog, Router, FolderLock } from "lucide-react";
 import { Dialog, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogTitle, } from "@/components/ui/dialog";
 import { Switch } from "@/components/ui/switch";
 import { getSettings, getSettingsWithDefaults, saveSettings, resetToDefaultSettings, applyThemeMode, applyFont, FONT_OPTIONS, FOLDER_PRESETS, FILENAME_PRESETS, TEMPLATE_VARIABLES, type Settings as SettingsType, type FontFamily, type FolderPreset, type FilenamePreset, } from "@/lib/settings";
 import { themes, applyTheme } from "@/lib/themes";
-import { SelectFolder } from "../../wailsjs/go/main/App";
+import { SelectFolder, OpenConfigFolder } from "../../wailsjs/go/main/App";
 import { toastWithSound as toast } from "@/lib/toast-with-sound";
-const TidalIcon = ({ className }: {
-    className?: string;
-}) => (<svg viewBox="0 0 24 24" className={`inline-block w-[1.1em] h-[1.1em] mr-2 ${className || "fill-muted-foreground"}`}>
-    <path d="M4.022 4.5 0 8.516l3.997 3.99 3.997-3.984L4.022 4.5Zm7.956 0L7.994 8.522l4.003 3.984L16 8.484 11.978 4.5Zm8.007 0L24 8.528l-4.003 3.978L16 8.484 19.985 4.5Z"></path>
-    <path d="m8.012 16.534 3.991 3.966L16 16.49l-4.003-3.984-3.985 4.028Z"></path>
-  </svg>);
-const QobuzIcon = ({ className }: {
-    className?: string;
-}) => (<svg viewBox="0 0 24 24" className={`inline-block w-[1.1em] h-[1.1em] mr-2 ${className || "fill-muted-foreground"}`}>
-    <path d="M21.744 9.815C19.836 1.261 8.393-1 3.55 6.64-.618 13.214 4 22 11.988 22c2.387 0 4.63-.83 6.394-2.304l2.252 2.252 1.224-1.224-2.252-2.253c1.983-2.407 2.823-5.586 2.138-8.656Zm-3.508 7.297L16.4 15.275c-.786-.787-2.017.432-1.224 1.225L17 18.326C10.29 23.656.5 16 5.16 7.667c3.502-6.264 13.172-4.348 14.707 2.574.529 2.385-.06 4.987-1.63 6.87Z"></path>
-    <path d="M13.4 8.684a3.59 3.59 0 0 0-4.712 1.9 3.59 3.59 0 0 0 1.9 4.712 3.594 3.594 0 0 0 4.711-1.89 3.598 3.598 0 0 0-1.9-4.722Zm-.737 3.591a.727.727 0 0 1-.965.384.727.727 0 0 1-.384-.965.727.727 0 0 1 .965-.384.73.73 0 0 1 .384.965Z"></path>
-  </svg>);
-const AmazonIcon = ({ className }: {
-    className?: string;
-}) => (<svg viewBox="0 0 24 24" className={`inline-block w-[1.1em] h-[1.1em] mr-2 ${className || "fill-muted-foreground"}`}>
-    <path fillRule="evenodd" d="M15.62 11.13c-.15.1-.37.18-.64.18-.42 0-.82-.05-1.21-.18l-.22-.04c-.08 0-.1.04-.1.14v.25c0 .08.02.12.05.17.02.03.07.08.15.1.4.18.84.25 1.33.25.52 0 .91-.12 1.24-.37.32-.25.47-.57.47-.99 0-.3-.08-.52-.23-.72-.15-.17-.4-.34-.74-.47l-.7-.27c-.26-.1-.46-.2-.53-.3a.47.47 0 0 1-.15-.36c0-.38.27-.57.84-.57.32 0 .64.05.94.15l.2.04c.07 0 .12-.04.12-.14v-.25c0-.08-.03-.12-.05-.17-.03-.05-.08-.08-.15-.1-.37-.13-.74-.2-1.11-.2-.47 0-.87.12-1.16.35-.3.22-.45.54-.45.91 0 .57.32.99.97 1.24l.74.27c.24.1.4.17.5.27.09.1.12.2.12.35 0 .2-.08.37-.23.46Zm-3.88-3.55v3.28c-.42.28-.84.42-1.26.42-.27 0-.47-.07-.6-.22-.11-.15-.16-.37-.16-.7V7.59c0-.13-.05-.18-.18-.18h-.52c-.12 0-.17.05-.17.18v3.06c0 .42.1.77.32.99.22.22.55.35.97.35.56 0 1.13-.2 1.68-.6l.05.3c0 .07.02.1.07.12.02.03.07.03.15.03h.37c.12 0 .17-.05.17-.18V7.58c0-.13-.05-.18-.17-.18h-.52c-.15 0-.2.08-.2.18Zm-4.69 4.27h.52c.12 0 .17-.05.17-.17v-3.1c0-.41-.1-.73-.32-.95a1.25 1.25 0 0 0-.94-.35c-.57 0-1.16.2-1.73.62-.2-.42-.57-.62-1.11-.62-.55 0-1.1.2-1.64.57l-.04-.27c0-.08-.03-.1-.08-.13-.02-.02-.07-.02-.12-.02h-.4c-.12 0-.17.05-.17.17v4.1c0 .13.05.18.17.18h.52c.12 0 .17-.05.17-.18V8.37c.42-.25.84-.4 1.29-.4.25 0 .42.08.52.22.1.15.17.35.17.65v2.84c0 .12.05.17.17.17h.52c.13 0 .18-.05.18-.17V8.37c.44-.27.86-.4 1.28-.4.25 0 .42.08.52.22.1.15.17.35.17.65v2.84c0 .12.05.17.18.17Zm13.47 3.29a21.8 21.8 0 0 1-8.3 1.7c-3.96 0-7.8-1.08-10.88-2.89a.35.35 0 0 0-.15-.05c-.17 0-.27.2-.1.37a16.11 16.11 0 0 0 10.87 4.16c3.02 0 6.5-.94 8.9-2.72.42-.3.08-.74-.34-.57Zm-.08-6.74c.22-.26.57-.38 1.06-.38.25 0 .5.03.72.1l.15.02c.07 0 .12-.04.12-.17v-.25c0-.07-.02-.14-.05-.17a.54.54 0 0 0-.12-.1c-.32-.07-.64-.15-.94-.15-.7 0-1.21.2-1.6.62-.38.4-.57 1-.57 1.73 0 .74.17 1.31.54 1.7.37.4.89.6 1.58.6.37 0 .72-.05.99-.17.07-.03.12-.05.15-.1.02-.03.02-.1.02-.17v-.25c0-.13-.05-.17-.12-.17-.03 0-.07 0-.12.02-.28.07-.55.12-.8.12-.46 0-.81-.12-1.03-.37-.23-.24-.32-.64-.32-1.16v-.12c.02-.55.12-.94.34-1.19Z" clipRule="evenodd"></path>
-    <path fillRule="evenodd" d="M21.55 17.46c1.29-1.09 1.64-3.33 1.36-3.68-.12-.15-.71-.3-1.45-.3-.8 0-1.73.18-2.45.67-.22.15-.17.35.05.32.76-.1 2.5-.3 2.82.1.3.4-.35 2.03-.65 2.74-.07.23.1.3.32.15ZM18.12 7.4h-.52c-.12 0-.17.05-.17.18v4.1c0 .12.05.17.17.17h.52c.12 0 .17-.05.17-.17v-4.1c0-.1-.05-.18-.17-.18Zm.15-1.68a.58.58 0 0 0-.42-.15c-.18 0-.3.05-.4.15a.5.5 0 0 0-.15.37c0 .15.05.3.15.37.1.1.22.15.4.15.17 0 .3-.05.4-.15a.5.5 0 0 0 .14-.37c0-.15-.02-.3-.12-.37Z" clipRule="evenodd"></path>
-  </svg>);
-const DeezerIcon = ({ className }: {
-    className?: string;
-}) => (<svg viewBox="0 0 512 512" className={`inline-block w-[1.1em] h-[1.1em] mr-2 ${className || "fill-muted-foreground"}`}>
-    <path fill="currentColor" d="M14.8 101.1C6.6 101.1 0 127.6 0 160.3s6.6 59.2 14.8 59.2s14.8-26.5 14.8-59.2s-6.6-59.2-14.8-59.2m433.9-60.2c-7.7 0-14.5 17.1-19.4 44.1c-7.7-46.7-20.2-77-34.2-77c-16.8 0-31.1 42.9-38 105.4c-6.6-45.4-16.8-74.2-28.3-74.2c-16.1 0-29.6 56.9-34.7 136.2c-9.4-40.8-23.2-66.3-38.3-66.3s-28.8 25.5-38.3 66.3c-5.1-79.3-18.6-136.2-34.7-136.2c-11.5 0-21.7 28.8-28.3 74.2C147.9 50.9 133.3 8 116.7 8c-14 0-26.5 30.4-34.2 77c-4.8-27-11.7-44.1-19.4-44.1c-14.3 0-26 59.2-26 132.1S49 305.2 63.3 305.2c5.9 0 11.5-9.9 15.8-26.8c6.9 61.7 21.2 104.1 38 104.1c13 0 24.5-25.5 32.1-65.6c5.4 76.3 18.6 130.4 34.2 130.4c9.7 0 18.6-21.4 25.3-56.4c7.9 72.2 26.3 122.7 47.7 122.7s39.5-50.5 47.7-122.7c6.6 35 15.6 56.4 25.3 56.4c15.6 0 28.8-54.1 34.2-130.4c7.7 40.1 19.4 65.6 32.1 65.6c16.6 0 30.9-42.3 38-104.1c4.3 16.8 9.7 26.8 15.8 26.8c14.3 0 26-59.2 26-132.1S463 40.9 448.7 40.9m48.5 60.2c-8.2 0-14.8 26.5-14.8 59.2s6.6 59.2 14.8 59.2S512 193 512 160.3s-6.6-59.2-14.8-59.2"/>
-  </svg>);
+import { ApiStatusTab } from "./ApiStatusTab";
+import { AmazonIcon, QobuzIcon, TidalIcon } from "./PlatformIcons";
+import songlinkIcon from "@/assets/icons/songlink.ico";
+import songstatsIcon from "@/assets/icons/songstats.png";
 interface SettingsPageProps {
     onUnsavedChangesChange?: (hasUnsavedChanges: boolean) => void;
     onResetRequest?: (resetFn: () => void) => void;
@@ -129,11 +110,22 @@ export function SettingsPage({ onUnsavedChangesChange, onResetRequest, }: Settin
     const handleAutoQualityChange = async (value: "16" | "24") => {
         setTempSettings((prev) => ({ ...prev, autoQuality: value }));
     };
-    const [activeTab, setActiveTab] = useState<"general" | "files">("general");
+    const [activeTab, setActiveTab] = useState<"general" | "files" | "api">("general");
     return (<div className="space-y-4 h-full flex flex-col">
       <div className="flex items-center justify-between shrink-0">
         <h1 className="text-2xl font-bold">Settings</h1>
         <div className="flex gap-2">
+          <Button variant="outline" onClick={async () => {
+            try {
+                await OpenConfigFolder();
+            }
+            catch (e) {
+                toast.error(`Failed to open config folder: ${e}`);
+            }
+        }} className="gap-1.5">
+            <FolderLock className="h-4 w-4"/>
+            Open Config Folder
+          </Button>
           <Button variant="outline" onClick={() => setShowResetConfirm(true)} className="gap-1.5">
             <RotateCcw className="h-4 w-4"/>
             Reset to Default
@@ -147,13 +139,17 @@ export function SettingsPage({ onUnsavedChangesChange, onResetRequest, }: Settin
 
       <div className="flex gap-2 border-b shrink-0">
         <Button variant={activeTab === "general" ? "default" : "ghost"} size="sm" onClick={() => setActiveTab("general")} className="rounded-b-none gap-2">
-          <Settings className="h-4 w-4"/>
+          <MonitorCog className="h-4 w-4"/>
           General
         </Button>
         <Button variant={activeTab === "files" ? "default" : "ghost"} size="sm" onClick={() => setActiveTab("files")} className="rounded-b-none gap-2">
           <FolderCog className="h-4 w-4"/>
           File Management
         </Button>
+        <Button variant={activeTab === "api" ? "default" : "ghost"} size="sm" onClick={() => setActiveTab("api")} className="rounded-b-none gap-2">
+          <Router className="h-4 w-4"/>
+          Status
+        </Button>
       </div>
 
       <div className="flex-1 overflow-y-auto pt-4">
@@ -236,6 +232,44 @@ export function SettingsPage({ onUnsavedChangesChange, onResetRequest, }: Settin
             </div>
 
             <div className="space-y-4">
+              <div className="space-y-2">
+                <Label htmlFor="link-resolver">Link Resolver</Label>
+                <div className="flex items-center gap-3 flex-wrap">
+                  <Select value={tempSettings.linkResolver} onValueChange={(value: "songstats" | "songlink") => setTempSettings((prev) => ({
+                ...prev,
+                linkResolver: value,
+            }))}>
+                    <SelectTrigger id="link-resolver" className="h-9 w-fit min-w-[140px]">
+                      <SelectValue placeholder="Select a link resolver"/>
+                    </SelectTrigger>
+                    <SelectContent>
+                      <SelectItem value="songlink">
+                        <span className="flex items-center gap-2">
+                          <img src={songlinkIcon} alt="Songlink" className="h-4 w-4 shrink-0 rounded-[3px] object-contain" loading="lazy"/>
+                          Songlink
+                        </span>
+                      </SelectItem>
+                      <SelectItem value="songstats">
+                        <span className="flex items-center gap-2">
+                          <img src={songstatsIcon} alt="Songstats" className="h-4 w-4 shrink-0 rounded-[3px] object-contain" loading="lazy"/>
+                          Songstats
+                        </span>
+                      </SelectItem>
+                    </SelectContent>
+                  </Select>
+
+                  <div className="flex items-center gap-3">
+                    <Switch id="allow-link-resolver-fallback" checked={tempSettings.allowResolverFallback} onCheckedChange={(checked) => setTempSettings((prev) => ({
+                ...prev,
+                allowResolverFallback: checked,
+            }))}/>
+                    <Label htmlFor="allow-link-resolver-fallback" className="text-sm font-normal cursor-pointer">
+                      Allow Fallback
+                    </Label>
+                  </div>
+                </div>
+              </div>
+
               <div className="space-y-2">
                 <Label htmlFor="downloader">Source</Label>
                 <div className="flex gap-2 flex-wrap">
@@ -249,29 +283,24 @@ export function SettingsPage({ onUnsavedChangesChange, onResetRequest, }: Settin
                     <SelectContent>
                       <SelectItem value="auto">Auto</SelectItem>
                       <SelectItem value="tidal">
-                        <span className="flex items-center">
+                        <span className="flex items-center gap-2">
                           <TidalIcon />
                           Tidal
                         </span>
                       </SelectItem>
                       <SelectItem value="qobuz">
-                        <span className="flex items-center">
+                        <span className="flex items-center gap-2">
                           <QobuzIcon />
                           Qobuz
                         </span>
                       </SelectItem>
                       <SelectItem value="amazon">
-                        <span className="flex items-center">
+                        <span className="flex items-center gap-2">
                           <AmazonIcon />
                           Amazon Music
                         </span>
                       </SelectItem>
-                      <SelectItem value="deezer">
-                        <span className="flex items-center">
-                          <DeezerIcon />
-                          Deezer
-                        </span>
-                      </SelectItem>
+
                     </SelectContent>
                   </Select>
 
@@ -285,139 +314,6 @@ export function SettingsPage({ onUnsavedChangesChange, onResetRequest, }: Settin
                         </SelectTrigger>
                         <SelectContent>
                           
-                          <SelectItem value="tidal-qobuz-amazon-deezer">
-                            <span className="flex items-center gap-1.5">
-                              <TidalIcon className="fill-current"/>
-                              <ArrowRight className="h-3 w-3 text-muted-foreground"/>
-                              <QobuzIcon className="fill-current"/>
-                              <ArrowRight className="h-3 w-3 text-muted-foreground"/>
-                              <AmazonIcon className="fill-current"/>
-                              <ArrowRight className="h-3 w-3 text-muted-foreground"/>
-                              <DeezerIcon className="fill-current"/>
-                            </span>
-                          </SelectItem>
-                          <SelectItem value="tidal-qobuz-deezer-amazon">
-                            <span className="flex items-center gap-1.5">
-                              <TidalIcon className="fill-current"/>
-                              <ArrowRight className="h-3 w-3 text-muted-foreground"/>
-                              <QobuzIcon className="fill-current"/>
-                              <ArrowRight className="h-3 w-3 text-muted-foreground"/>
-                              <DeezerIcon className="fill-current"/>
-                              <ArrowRight className="h-3 w-3 text-muted-foreground"/>
-                              <AmazonIcon className="fill-current"/>
-                            </span>
-                          </SelectItem>
-                          <SelectItem value="qobuz-tidal-amazon-deezer">
-                            <span className="flex items-center gap-1.5">
-                              <QobuzIcon className="fill-current"/>
-                              <ArrowRight className="h-3 w-3 text-muted-foreground"/>
-                              <TidalIcon className="fill-current"/>
-                              <ArrowRight className="h-3 w-3 text-muted-foreground"/>
-                              <AmazonIcon className="fill-current"/>
-                              <ArrowRight className="h-3 w-3 text-muted-foreground"/>
-                              <DeezerIcon className="fill-current"/>
-                            </span>
-                          </SelectItem>
-                          <SelectItem value="amazon-tidal-qobuz-deezer">
-                            <span className="flex items-center gap-1.5">
-                              <AmazonIcon className="fill-current"/>
-                              <ArrowRight className="h-3 w-3 text-muted-foreground"/>
-                              <TidalIcon className="fill-current"/>
-                              <ArrowRight className="h-3 w-3 text-muted-foreground"/>
-                              <QobuzIcon className="fill-current"/>
-                              <ArrowRight className="h-3 w-3 text-muted-foreground"/>
-                              <DeezerIcon className="fill-current"/>
-                            </span>
-                          </SelectItem>
-                          <SelectItem value="deezer-tidal-qobuz-amazon">
-                            <span className="flex items-center gap-1.5">
-                              <DeezerIcon className="fill-current"/>
-                              <ArrowRight className="h-3 w-3 text-muted-foreground"/>
-                              <TidalIcon className="fill-current"/>
-                              <ArrowRight className="h-3 w-3 text-muted-foreground"/>
-                              <QobuzIcon className="fill-current"/>
-                              <ArrowRight className="h-3 w-3 text-muted-foreground"/>
-                              <AmazonIcon className="fill-current"/>
-                            </span>
-                          </SelectItem>
-                          <SelectItem value="deezer-qobuz-amazon-tidal">
-                            <span className="flex items-center gap-1.5">
-                              <DeezerIcon className="fill-current"/>
-                              <ArrowRight className="h-3 w-3 text-muted-foreground"/>
-                              <QobuzIcon className="fill-current"/>
-                              <ArrowRight className="h-3 w-3 text-muted-foreground"/>
-                              <AmazonIcon className="fill-current"/>
-                              <ArrowRight className="h-3 w-3 text-muted-foreground"/>
-                              <TidalIcon className="fill-current"/>
-                            </span>
-                          </SelectItem>
-                          <SelectItem value="deezer-amazon-tidal-qobuz">
-                            <span className="flex items-center gap-1.5">
-                              <DeezerIcon className="fill-current"/>
-                              <ArrowRight className="h-3 w-3 text-muted-foreground"/>
-                              <AmazonIcon className="fill-current"/>
-                              <ArrowRight className="h-3 w-3 text-muted-foreground"/>
-                              <TidalIcon className="fill-current"/>
-                              <ArrowRight className="h-3 w-3 text-muted-foreground"/>
-                              <QobuzIcon className="fill-current"/>
-                            </span>
-                          </SelectItem>
-
-                          
-                          <SelectItem value="tidal-qobuz-deezer">
-                            <span className="flex items-center gap-1.5">
-                              <TidalIcon className="fill-current"/>
-                              <ArrowRight className="h-3 w-3 text-muted-foreground"/>
-                              <QobuzIcon className="fill-current"/>
-                              <ArrowRight className="h-3 w-3 text-muted-foreground"/>
-                              <DeezerIcon className="fill-current"/>
-                            </span>
-                          </SelectItem>
-                          <SelectItem value="tidal-amazon-deezer">
-                            <span className="flex items-center gap-1.5">
-                              <TidalIcon className="fill-current"/>
-                              <ArrowRight className="h-3 w-3 text-muted-foreground"/>
-                              <AmazonIcon className="fill-current"/>
-                              <ArrowRight className="h-3 w-3 text-muted-foreground"/>
-                              <DeezerIcon className="fill-current"/>
-                            </span>
-                          </SelectItem>
-                          <SelectItem value="qobuz-amazon-deezer">
-                            <span className="flex items-center gap-1.5">
-                              <QobuzIcon className="fill-current"/>
-                              <ArrowRight className="h-3 w-3 text-muted-foreground"/>
-                              <AmazonIcon className="fill-current"/>
-                              <ArrowRight className="h-3 w-3 text-muted-foreground"/>
-                              <DeezerIcon className="fill-current"/>
-                            </span>
-                          </SelectItem>
-                          <SelectItem value="amazon-qobuz-deezer">
-                            <span className="flex items-center gap-1.5">
-                              <AmazonIcon className="fill-current"/>
-                              <ArrowRight className="h-3 w-3 text-muted-foreground"/>
-                              <QobuzIcon className="fill-current"/>
-                              <ArrowRight className="h-3 w-3 text-muted-foreground"/>
-                              <DeezerIcon className="fill-current"/>
-                            </span>
-                          </SelectItem>
-                          <SelectItem value="amazon-tidal-deezer">
-                            <span className="flex items-center gap-1.5">
-                              <AmazonIcon className="fill-current"/>
-                              <ArrowRight className="h-3 w-3 text-muted-foreground"/>
-                              <TidalIcon className="fill-current"/>
-                              <ArrowRight className="h-3 w-3 text-muted-foreground"/>
-                              <DeezerIcon className="fill-current"/>
-                            </span>
-                          </SelectItem>
-                          <SelectItem value="deezer-qobuz-amazon">
-                            <span className="flex items-center gap-1.5">
-                              <DeezerIcon className="fill-current"/>
-                              <ArrowRight className="h-3 w-3 text-muted-foreground"/>
-                              <QobuzIcon className="fill-current"/>
-                              <ArrowRight className="h-3 w-3 text-muted-foreground"/>
-                              <AmazonIcon className="fill-current"/>
-                            </span>
-                          </SelectItem>
                           <SelectItem value="tidal-qobuz-amazon">
                             <span className="flex items-center gap-1.5">
                               <TidalIcon className="fill-current"/>
@@ -427,50 +323,53 @@ export function SettingsPage({ onUnsavedChangesChange, onResetRequest, }: Settin
                               <AmazonIcon className="fill-current"/>
                             </span>
                           </SelectItem>
+                          <SelectItem value="tidal-amazon-qobuz">
+                            <span className="flex items-center gap-1.5">
+                              <TidalIcon className="fill-current"/>
+                              <ArrowRight className="h-3 w-3 text-muted-foreground"/>
+                              <AmazonIcon className="fill-current"/>
+                              <ArrowRight className="h-3 w-3 text-muted-foreground"/>
+                              <QobuzIcon className="fill-current"/>
+                            </span>
+                          </SelectItem>
+                          <SelectItem value="qobuz-tidal-amazon">
+                            <span className="flex items-center gap-1.5">
+                              <QobuzIcon className="fill-current"/>
+                              <ArrowRight className="h-3 w-3 text-muted-foreground"/>
+                              <TidalIcon className="fill-current"/>
+                              <ArrowRight className="h-3 w-3 text-muted-foreground"/>
+                              <AmazonIcon className="fill-current"/>
+                            </span>
+                          </SelectItem>
+                          <SelectItem value="qobuz-amazon-tidal">
+                            <span className="flex items-center gap-1.5">
+                              <QobuzIcon className="fill-current"/>
+                              <ArrowRight className="h-3 w-3 text-muted-foreground"/>
+                              <AmazonIcon className="fill-current"/>
+                              <ArrowRight className="h-3 w-3 text-muted-foreground"/>
+                              <TidalIcon className="fill-current"/>
+                            </span>
+                          </SelectItem>
+                          <SelectItem value="amazon-tidal-qobuz">
+                            <span className="flex items-center gap-1.5">
+                              <AmazonIcon className="fill-current"/>
+                              <ArrowRight className="h-3 w-3 text-muted-foreground"/>
+                              <TidalIcon className="fill-current"/>
+                              <ArrowRight className="h-3 w-3 text-muted-foreground"/>
+                              <QobuzIcon className="fill-current"/>
+                            </span>
+                          </SelectItem>
+                          <SelectItem value="amazon-qobuz-tidal">
+                            <span className="flex items-center gap-1.5">
+                              <AmazonIcon className="fill-current"/>
+                              <ArrowRight className="h-3 w-3 text-muted-foreground"/>
+                              <QobuzIcon className="fill-current"/>
+                              <ArrowRight className="h-3 w-3 text-muted-foreground"/>
+                              <TidalIcon className="fill-current"/>
+                            </span>
+                          </SelectItem>
 
                           
-                          <SelectItem value="tidal-deezer">
-                            <span className="flex items-center gap-1.5">
-                              <TidalIcon className="fill-current"/>
-                              <ArrowRight className="h-3 w-3 text-muted-foreground"/>
-                              <DeezerIcon className="fill-current"/>
-                            </span>
-                          </SelectItem>
-                          <SelectItem value="qobuz-deezer">
-                            <span className="flex items-center gap-1.5">
-                              <QobuzIcon className="fill-current"/>
-                              <ArrowRight className="h-3 w-3 text-muted-foreground"/>
-                              <DeezerIcon className="fill-current"/>
-                            </span>
-                          </SelectItem>
-                          <SelectItem value="amazon-deezer">
-                            <span className="flex items-center gap-1.5">
-                              <AmazonIcon className="fill-current"/>
-                              <ArrowRight className="h-3 w-3 text-muted-foreground"/>
-                              <DeezerIcon className="fill-current"/>
-                            </span>
-                          </SelectItem>
-                          <SelectItem value="deezer-tidal">
-                            <span className="flex items-center gap-1.5">
-                              <DeezerIcon className="fill-current"/>
-                              <ArrowRight className="h-3 w-3 text-muted-foreground"/>
-                              <TidalIcon className="fill-current"/>
-                            </span>
-                          </SelectItem>
-                          <SelectItem value="deezer-qobuz">
-                            <span className="flex items-center gap-1.5">
-                              <DeezerIcon className="fill-current"/>
-                              <ArrowRight className="h-3 w-3 text-muted-foreground"/>
-                              <QobuzIcon className="fill-current"/>
-                            </span>
-                          </SelectItem>
-                          <SelectItem value="deezer-amazon">
-                            <span className="flex items-center gap-1.5">
-                              <DeezerIcon className="fill-current"/>
-                              <ArrowRight className="h-3 w-3 text-muted-foreground"/>
-                              <AmazonIcon className="fill-current"/>
-                            </span>
-                          </SelectItem>
                           <SelectItem value="tidal-qobuz">
                             <span className="flex items-center gap-1.5">
                               <TidalIcon className="fill-current"/>
@@ -552,9 +451,7 @@ export function SettingsPage({ onUnsavedChangesChange, onResetRequest, }: Settin
                   {tempSettings.downloader === "amazon" && (<div className="h-9 px-3 flex items-center text-sm font-medium border border-input rounded-md bg-muted/30 text-muted-foreground whitespace-nowrap cursor-default">
                       16-bit - 24-bit/44.1kHz - 192kHz
                     </div>)}
-                  {tempSettings.downloader === "deezer" && (<div className="h-9 px-3 flex items-center text-sm font-medium border border-input rounded-md bg-muted/30 text-muted-foreground whitespace-nowrap cursor-default">
-                      16-bit/44.1kHz
-                    </div>)}
+
                 </div>
 
                 {((tempSettings.downloader === "tidal" &&
@@ -664,9 +561,12 @@ export function SettingsPage({ onUnsavedChangesChange, onResetRequest, }: Settin
                     Preview:{" "}
                     <span className="font-mono">
                       {tempSettings.folderTemplate
-                    .replace(/\{artist\}/g, "Kendrick Lamar, SZA")
+                    .replace(/\{artist\}/g, tempSettings.separator === "comma" ? "Kendrick Lamar, SZA" : "Kendrick Lamar; SZA")
                     .replace(/\{album\}/g, "Black Panther")
                     .replace(/\{album_artist\}/g, "Kendrick Lamar")
+                    .replace(/\{title\}/g, "All The Stars")
+                    .replace(/\{track\}/g, "01")
+                    .replace(/\{disc\}/g, "1")
                     .replace(/\{year\}/g, "2018")
                     .replace(/\{date\}/g, "2018-02-09")}
                       /
@@ -747,12 +647,31 @@ export function SettingsPage({ onUnsavedChangesChange, onResetRequest, }: Settin
                     filenameTemplate: e.target.value,
                 }))} placeholder="{track}. {title}" className="h-9 text-sm flex-1"/>)}
               </div>
+              <div className="space-y-2 pt-2">
+                <Label className="text-sm">Separator</Label>
+                <div className="flex gap-2">
+                  <Select value={tempSettings.separator} onValueChange={(value: "comma" | "semicolon") => setTempSettings((prev) => ({
+                ...prev,
+                separator: value,
+            }))}>
+                    <SelectTrigger className="h-9 w-fit">
+                      <SelectValue />
+                    </SelectTrigger>
+                    <SelectContent>
+                      <SelectItem value="comma">Comma (,)</SelectItem>
+                      <SelectItem value="semicolon">Semicolon (;)</SelectItem>
+                    </SelectContent>
+                  </Select>
+                </div>
+              </div>
+
               {tempSettings.filenameTemplate && (<p className="text-xs text-muted-foreground">
                   Preview:{" "}
                   <span className="font-mono">
                     {tempSettings.filenameTemplate
-                    .replace(/\{artist\}/g, "Kendrick Lamar, SZA")
+                    .replace(/\{artist\}/g, tempSettings.separator === "comma" ? "Kendrick Lamar, SZA" : "Kendrick Lamar; SZA")
                     .replace(/\{album_artist\}/g, "Kendrick Lamar")
+                    .replace(/\{album\}/g, "Black Panther")
                     .replace(/\{title\}/g, "All The Stars")
                     .replace(/\{track\}/g, "01")
                     .replace(/\{disc\}/g, "1")
@@ -761,8 +680,11 @@ export function SettingsPage({ onUnsavedChangesChange, onResetRequest, }: Settin
                     .flac
                   </span>
                 </p>)}
+                
             </div>
           </div>)}
+        
+        {activeTab === "api" && (<ApiStatusTab />)}
       </div>
 
       <Dialog open={showResetConfirm} onOpenChange={setShowResetConfirm}>

frontend/src/components/Sidebar.tsx

@@ -1,122 +1,200 @@
+import { useRef, useState, type RefObject } from "react";
 import { HomeIcon } from "@/components/ui/home";
 import { HistoryIcon } from "@/components/ui/history-icon";
 import { SettingsIcon } from "@/components/ui/settings";
-import { ActivityIcon } from "@/components/ui/activity";
+import { ActivityIcon, type ActivityIconHandle } from "@/components/ui/activity";
 import { TerminalIcon } from "@/components/ui/terminal";
-import { FileMusicIcon } from "@/components/ui/file-music";
-import { FilePenIcon } from "@/components/ui/file-pen";
+import { FileMusicIcon, type FileMusicIconHandle } from "@/components/ui/file-music";
+import { FilePenIcon, type FilePenIconHandle } from "@/components/ui/file-pen";
 import { CoffeeIcon } from "@/components/ui/coffee";
 import { BadgeAlertIcon } from "@/components/ui/badge-alert";
+import { GithubIcon } from "@/components/ui/github";
+import { BlocksIcon } from "@/components/ui/blocks-icon";
+import { AudioLinesIcon, type AudioLinesIconHandle } from "@/components/ui/audio-lines";
+import { DropdownMenu, DropdownMenuContent, DropdownMenuItem, DropdownMenuTrigger } from "@/components/ui/dropdown-menu";
+import { Dialog, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogTitle } from "@/components/ui/dialog";
+import { Checkbox } from "@/components/ui/checkbox";
 import { Tooltip, TooltipContent, TooltipTrigger, } from "@/components/ui/tooltip";
 import { Button } from "@/components/ui/button";
 import { openExternal } from "@/lib/utils";
-export type PageType = "main" | "settings" | "debug" | "audio-analysis" | "audio-converter" | "file-manager" | "about" | "history";
+export type PageType = "main" | "settings" | "debug" | "audio-analysis" | "audio-converter" | "audio-resampler" | "file-manager" | "about" | "history";
 interface SidebarProps {
     currentPage: PageType;
     onPageChange: (page: PageType) => void;
 }
-export function Sidebar({ currentPage, onPageChange }: SidebarProps) {
-    return (<div className="fixed left-0 top-0 h-full w-14 bg-card border-r border-border flex flex-col items-center py-14 z-30">
-      <div className="flex flex-col gap-2 flex-1">
-        <Tooltip delayDuration={0}>
-          <TooltipTrigger asChild>
-            <Button variant={currentPage === "main" ? "secondary" : "ghost"} size="icon" className={`h-10 w-10 ${currentPage === "main" ? "bg-primary/10 text-primary hover:bg-primary/20" : "hover:bg-primary/10 hover:text-primary"}`} onClick={() => onPageChange("main")}>
-              <HomeIcon size={20}/>
-            </Button>
-          </TooltipTrigger>
-          <TooltipContent side="right">
-            <p>Home</p>
-          </TooltipContent>
-        </Tooltip>
-
-        <Tooltip delayDuration={0}>
-          <TooltipTrigger asChild>
-            <Button variant={currentPage === "history" ? "secondary" : "ghost"} size="icon" className={`h-10 w-10 ${currentPage === "history" ? "bg-primary/10 text-primary hover:bg-primary/20" : "hover:bg-primary/10 hover:text-primary"}`} onClick={() => onPageChange("history")}>
-              <HistoryIcon size={20}/>
-            </Button>
-          </TooltipTrigger>
-          <TooltipContent side="right">
-            <p>History</p>
-          </TooltipContent>
-        </Tooltip>
-
-        <Tooltip delayDuration={0}>
-          <TooltipTrigger asChild>
-            <Button variant={currentPage === "audio-analysis" ? "secondary" : "ghost"} size="icon" className={`h-10 w-10 ${currentPage === "audio-analysis" ? "bg-primary/10 text-primary hover:bg-primary/20" : "hover:bg-primary/10 hover:text-primary"}`} onClick={() => onPageChange("audio-analysis")}>
-              <ActivityIcon size={20}/>
-            </Button>
-          </TooltipTrigger>
-          <TooltipContent side="right">
-            <p>Audio Quality Analyzer</p>
-          </TooltipContent>
-        </Tooltip>
-
-        <Tooltip delayDuration={0}>
-          <TooltipTrigger asChild>
-            <Button variant={currentPage === "audio-converter" ? "secondary" : "ghost"} size="icon" className={`h-10 w-10 ${currentPage === "audio-converter" ? "bg-primary/10 text-primary hover:bg-primary/20" : "hover:bg-primary/10 hover:text-primary"}`} onClick={() => onPageChange("audio-converter")}>
-              <FileMusicIcon size={20}/>
-            </Button>
-          </TooltipTrigger>
-          <TooltipContent side="right">
-            <p>Audio Converter</p>
-          </TooltipContent>
-        </Tooltip>
-
-        <Tooltip delayDuration={0}>
-          <TooltipTrigger asChild>
-            <Button variant={currentPage === "file-manager" ? "secondary" : "ghost"} size="icon" className={`h-10 w-10 ${currentPage === "file-manager" ? "bg-primary/10 text-primary hover:bg-primary/20" : "hover:bg-primary/10 hover:text-primary"}`} onClick={() => onPageChange("file-manager")}>
-              <FilePenIcon size={20}/>
-            </Button>
-          </TooltipTrigger>
-          <TooltipContent side="right">
-            <p>File Manager</p>
-          </TooltipContent>
-        </Tooltip>
-
-        <Tooltip delayDuration={0}>
-          <TooltipTrigger asChild>
-            <Button variant={currentPage === "debug" ? "secondary" : "ghost"} size="icon" className={`h-10 w-10 ${currentPage === "debug" ? "bg-primary/10 text-primary hover:bg-primary/20" : "hover:bg-primary/10 hover:text-primary"}`} onClick={() => onPageChange("debug")}>
-              <TerminalIcon size={20} loop={true}/>
-            </Button>
-          </TooltipTrigger>
-          <TooltipContent side="right">
-            <p>Debug Logs</p>
-          </TooltipContent>
-        </Tooltip>
-
-        <Tooltip delayDuration={0}>
-          <TooltipTrigger asChild>
-            <Button variant={currentPage === "settings" ? "secondary" : "ghost"} size="icon" className={`h-10 w-10 ${currentPage === "settings" ? "bg-primary/10 text-primary hover:bg-primary/20" : "hover:bg-primary/10 hover:text-primary"}`} onClick={() => onPageChange("settings")}>
-              <SettingsIcon size={20}/>
-            </Button>
-          </TooltipTrigger>
-          <TooltipContent side="right">
-            <p>Settings</p>
-          </TooltipContent>
-        </Tooltip>
-      </div>
-
-      <div className="mt-auto flex flex-col gap-2">
-        <Tooltip delayDuration={0}>
-          <TooltipTrigger asChild>
-            <Button variant={currentPage === "about" ? "secondary" : "ghost"} size="icon" className={`h-10 w-10 ${currentPage === "about" ? "bg-primary/10 text-primary hover:bg-primary/20" : "hover:bg-primary/10 hover:text-primary"}`} onClick={() => onPageChange("about")}>
-              <BadgeAlertIcon size={20}/>
-            </Button>
-          </TooltipTrigger>
-          <TooltipContent side="right">
-            <p>About</p>
-          </TooltipContent>
-        </Tooltip>
-        <Tooltip delayDuration={0}>
-          <TooltipTrigger asChild>
-            <Button variant="ghost" size="icon" className="h-10 w-10 hover:bg-primary/10 hover:text-primary" onClick={() => openExternal("https://ko-fi.com/afkarxyz")}>
-              <CoffeeIcon size={20} loop={true}/>
-            </Button>
-          </TooltipTrigger>
-          <TooltipContent side="right">
-            <p>Support me on Ko-fi</p>
-          </TooltipContent>
-        </Tooltip>
-      </div>
-    </div>);
+interface AnimatedIconHandle {
+    startAnimation: () => void;
+    stopAnimation: () => void;
+}
+export function Sidebar({ currentPage, onPageChange }: SidebarProps) {
+    const [isIssuesDialogOpen, setIsIssuesDialogOpen] = useState(false);
+    const [hasIssueAgreement, setHasIssueAgreement] = useState(false);
+    const analyzerIconRef = useRef<ActivityIconHandle>(null);
+    const resamplerIconRef = useRef<AudioLinesIconHandle>(null);
+    const converterIconRef = useRef<FileMusicIconHandle>(null);
+    const fileManagerIconRef = useRef<FilePenIconHandle>(null);
+    const handleIssuesDialogChange = (open: boolean) => {
+        setIsIssuesDialogOpen(open);
+        if (!open) {
+            setHasIssueAgreement(false);
+        }
+    };
+    const handleOpenIssues = () => {
+        openExternal("https://github.com/afkarxyz/SpotiFLAC/issues");
+        handleIssuesDialogChange(false);
+    };
+    const getAnimatedItemHandlers = <T extends AnimatedIconHandle>(iconRef: RefObject<T | null>) => ({
+        onMouseEnter: () => iconRef.current?.startAnimation(),
+        onMouseLeave: () => iconRef.current?.stopAnimation(),
+        onFocus: () => iconRef.current?.startAnimation(),
+        onBlur: () => iconRef.current?.stopAnimation(),
+    });
+    return (<div className="fixed left-0 top-0 h-full w-14 bg-card border-r border-border flex flex-col items-center py-14 z-30">
+            <div className="flex flex-col gap-2 flex-1">
+                <Tooltip delayDuration={0}>
+                    <TooltipTrigger asChild>
+                        <Button variant={currentPage === "main" ? "secondary" : "ghost"} size="icon" className={`h-10 w-10 ${currentPage === "main" ? "bg-primary/10 text-primary hover:bg-primary/20" : "hover:bg-primary/10 hover:text-primary"}`} onClick={() => onPageChange("main")}>
+                            <HomeIcon size={20}/>
+                        </Button>
+                    </TooltipTrigger>
+                    <TooltipContent side="right">
+                        <p>Home</p>
+                    </TooltipContent>
+                </Tooltip>
+
+                <Tooltip delayDuration={0}>
+                    <TooltipTrigger asChild>
+                        <Button variant={currentPage === "history" ? "secondary" : "ghost"} size="icon" className={`h-10 w-10 ${currentPage === "history" ? "bg-primary/10 text-primary hover:bg-primary/20" : "hover:bg-primary/10 hover:text-primary"}`} onClick={() => onPageChange("history")}>
+                            <HistoryIcon size={20}/>
+                        </Button>
+                    </TooltipTrigger>
+                    <TooltipContent side="right">
+                        <p>History</p>
+                    </TooltipContent>
+                </Tooltip>
+
+                <Tooltip delayDuration={0}>
+                    <TooltipTrigger asChild>
+                        <Button variant={currentPage === "settings" ? "secondary" : "ghost"} size="icon" className={`h-10 w-10 ${currentPage === "settings" ? "bg-primary/10 text-primary hover:bg-primary/20" : "hover:bg-primary/10 hover:text-primary"}`} onClick={() => onPageChange("settings")}>
+                            <SettingsIcon size={20}/>
+                        </Button>
+                    </TooltipTrigger>
+                    <TooltipContent side="right">
+                        <p>Settings</p>
+                    </TooltipContent>
+                </Tooltip>
+
+                <Tooltip delayDuration={0}>
+                    <TooltipTrigger asChild>
+                        <Button variant={currentPage === "debug" ? "secondary" : "ghost"} size="icon" className={`h-10 w-10 ${currentPage === "debug" ? "bg-primary/10 text-primary hover:bg-primary/20" : "hover:bg-primary/10 hover:text-primary"}`} onClick={() => onPageChange("debug")}>
+                            <TerminalIcon size={20} loop={true}/>
+                        </Button>
+                    </TooltipTrigger>
+                    <TooltipContent side="right">
+                        <p>Debug Logs</p>
+                    </TooltipContent>
+                </Tooltip>
+
+                <DropdownMenu>
+                    <Tooltip delayDuration={0}>
+                        <DropdownMenuTrigger asChild>
+                            <TooltipTrigger asChild>
+                                <Button variant={["audio-analysis", "audio-converter", "audio-resampler", "file-manager"].includes(currentPage) ? "secondary" : "ghost"} size="icon" className={`h-10 w-10 ${["audio-analysis", "audio-converter", "audio-resampler", "file-manager"].includes(currentPage) ? "bg-primary/10 text-primary hover:bg-primary/20" : "hover:bg-primary/10 hover:text-primary"}`}>
+                                    <BlocksIcon size={20} loop={true}/>
+                                </Button>
+                            </TooltipTrigger>
+                        </DropdownMenuTrigger>
+                        <TooltipContent side="right">
+                            <p>Tools</p>
+                        </TooltipContent>
+                    </Tooltip>
+                    <DropdownMenuContent side="right" sideOffset={14} className="min-w-[200px] ml-2">
+                        <DropdownMenuItem onClick={() => onPageChange("audio-analysis")} className="gap-3 cursor-pointer py-2 px-3" {...getAnimatedItemHandlers(analyzerIconRef)}>
+                            <ActivityIcon ref={analyzerIconRef} size={16}/>
+                            <span>Audio Quality Analyzer</span>
+                        </DropdownMenuItem>
+                        <DropdownMenuItem onClick={() => onPageChange("audio-resampler")} className="gap-3 cursor-pointer py-2 px-3" {...getAnimatedItemHandlers(resamplerIconRef)}>
+                            <AudioLinesIcon ref={resamplerIconRef} size={16}/>
+                            <span>Audio Resampler</span>
+                        </DropdownMenuItem>
+                        <DropdownMenuItem onClick={() => onPageChange("audio-converter")} className="gap-3 cursor-pointer py-2 px-3" {...getAnimatedItemHandlers(converterIconRef)}>
+                            <FileMusicIcon ref={converterIconRef} size={16}/>
+                            <span>Audio Converter</span>
+                        </DropdownMenuItem>
+                        <DropdownMenuItem onClick={() => onPageChange("file-manager")} className="gap-3 cursor-pointer py-2 px-3" {...getAnimatedItemHandlers(fileManagerIconRef)}>
+                            <FilePenIcon ref={fileManagerIconRef} size={16}/>
+                            <span>File Manager</span>
+                        </DropdownMenuItem>
+                    </DropdownMenuContent>
+                </DropdownMenu>
+            </div>
+
+            <div className="mt-auto flex flex-col gap-2">
+                <Dialog open={isIssuesDialogOpen} onOpenChange={handleIssuesDialogChange}>
+                    <Tooltip delayDuration={0}>
+                        <TooltipTrigger asChild>
+                            <Button variant="ghost" size="icon" className="h-10 w-10 hover:bg-primary/10 hover:text-primary" onClick={() => setIsIssuesDialogOpen(true)}>
+                                <GithubIcon size={20}/>
+                            </Button>
+                        </TooltipTrigger>
+                        <TooltipContent side="right">
+                            <p>Report Bugs or Request Features</p>
+                        </TooltipContent>
+                    </Tooltip>
+                    <DialogContent className="max-w-xl">
+                        <DialogHeader>
+                            <DialogTitle>Before Opening GitHub Issues</DialogTitle>
+                            <DialogDescription />
+                        </DialogHeader>
+
+                        <div className="space-y-4 text-sm">
+                            <div className="rounded-lg border border-amber-500/40 bg-amber-500/10 p-4">
+                                <p className="font-semibold text-amber-900 dark:text-amber-200">Important</p>
+                                <p className="mt-1 text-amber-950/90 dark:text-amber-100/90">
+                                    Search existing issues first and use the issue template when opening a new report or request.
+                                </p>
+                            </div>
+
+                            <label className="flex cursor-pointer items-center gap-3 rounded-lg border p-4">
+                                <Checkbox className="shrink-0" checked={hasIssueAgreement} onCheckedChange={(checked) => setHasIssueAgreement(checked === true)}/>
+                                <span className="leading-5 text-foreground/90">
+                                    I understand that I should use the issue template and avoid duplicate issues.
+                                </span>
+                            </label>
+                        </div>
+
+                        <DialogFooter className="sm:justify-between gap-2">
+                            <Button variant="outline" onClick={() => handleIssuesDialogChange(false)}>
+                                Cancel
+                            </Button>
+                            <Button disabled={!hasIssueAgreement} onClick={handleOpenIssues}>
+                                Open Issues
+                            </Button>
+                        </DialogFooter>
+                    </DialogContent>
+                </Dialog>
+
+                <Tooltip delayDuration={0}>
+                    <TooltipTrigger asChild>
+                        <Button variant={currentPage === "about" ? "secondary" : "ghost"} size="icon" className={`h-10 w-10 ${currentPage === "about" ? "bg-primary/10 text-primary hover:bg-primary/20" : "hover:bg-primary/10 hover:text-primary"}`} onClick={() => onPageChange("about")}>
+                            <BadgeAlertIcon size={20}/>
+                        </Button>
+                    </TooltipTrigger>
+                    <TooltipContent side="right">
+                        <p>About</p>
+                    </TooltipContent>
+                </Tooltip>
+
+                <Tooltip delayDuration={0}>
+                    <TooltipTrigger asChild>
+                        <Button variant="ghost" size="icon" className="h-10 w-10 hover:bg-primary/10 hover:text-primary" onClick={() => openExternal("https://ko-fi.com/afkarxyz")}>
+                            <CoffeeIcon size={20} loop={true}/>
+                        </Button>
+                    </TooltipTrigger>
+                    <TooltipContent side="right">
+                        <p>Support me on Ko-fi</p>
+                    </TooltipContent>
+                </Tooltip>
+            </div>
+        </div>);
 }

frontend/src/components/SpectrumVisualization.tsx

@@ -1,13 +1,486 @@
-import { useEffect, useRef } from "react";
+import { useEffect, useRef, useState, forwardRef, useImperativeHandle } from "react";
 import type { SpectrumData } from "@/types/api";
+import { Label } from "@/components/ui/label";
+import { Progress } from "@/components/ui/progress";
+import { loadAudioAnalysisPreferences, saveAudioAnalysisPreferences, type AnalyzerColorScheme, type AnalyzerFreqScale, type AnalyzerWindowFunction, } from "@/lib/audio-analysis-preferences";
+import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue, } from "@/components/ui/select";
+export interface SpectrumVisualizationHandle {
+    getCanvasDataURL: () => string | null;
+}
+type ColorScheme = AnalyzerColorScheme;
+type FreqScale = AnalyzerFreqScale;
+type WindowFunction = AnalyzerWindowFunction;
+export interface SpectrogramRenderOptions {
+    spectrumData: SpectrumData;
+    sampleRate: number;
+    duration: number;
+    freqScale: FreqScale;
+    colorScheme: ColorScheme;
+    fileName?: string;
+    shouldCancel?: () => boolean;
+}
 interface SpectrumVisualizationProps {
     sampleRate: number;
-    bitsPerSample: number;
     duration: number;
     spectrumData?: SpectrumData;
+    fileName?: string;
+    onReAnalyze?: (fftSize: number, windowFunction: string) => void;
+    isAnalyzingSpectrum?: boolean;
+    spectrumProgress?: {
+        percent: number;
+        message: string;
+    };
 }
-export function SpectrumVisualization({ sampleRate, bitsPerSample, duration, spectrumData, }: SpectrumVisualizationProps) {
+const MARGIN = { top: 50, right: 120, bottom: 70, left: 90 };
+const CANVAS_W = 1100;
+const CANVAS_H = 600;
+const MAX_RENDER_HEIGHT = 1080;
+function clamp01(value: number): number {
+    return Math.max(0, Math.min(1, value));
+}
+function spekColorMap(t: number): [
+    number,
+    number,
+    number
+] {
+    const colors: Array<[
+        number,
+        number,
+        number
+    ]> = [
+        [0, 0, 0],
+        [0, 0, 25],
+        [0, 0, 50],
+        [0, 0, 80],
+        [20, 0, 120],
+        [50, 0, 150],
+        [80, 0, 180],
+        [120, 0, 120],
+        [150, 0, 80],
+        [180, 0, 40],
+        [210, 0, 0],
+        [240, 30, 0],
+        [255, 60, 0],
+        [255, 100, 0],
+        [255, 140, 0],
+        [255, 180, 0],
+        [255, 210, 0],
+        [255, 235, 0],
+        [255, 250, 50],
+        [255, 255, 100],
+        [255, 255, 150],
+        [255, 255, 200],
+        [255, 255, 255],
+    ];
+    const scaled = t * (colors.length - 1);
+    const idx = Math.floor(scaled);
+    const fraction = scaled - idx;
+    if (idx >= colors.length - 1) {
+        return colors[colors.length - 1];
+    }
+    const c1 = colors[idx];
+    const c2 = colors[idx + 1];
+    return [
+        Math.round(c1[0] + (c2[0] - c1[0]) * fraction),
+        Math.round(c1[1] + (c2[1] - c1[1]) * fraction),
+        Math.round(c1[2] + (c2[2] - c1[2]) * fraction),
+    ];
+}
+function viridisColorMap(t: number): [
+    number,
+    number,
+    number
+] {
+    const colors: Array<[
+        number,
+        number,
+        number
+    ]> = [
+        [68, 1, 84],
+        [70, 20, 100],
+        [72, 40, 120],
+        [67, 62, 133],
+        [62, 74, 137],
+        [55, 89, 140],
+        [49, 104, 142],
+        [43, 117, 142],
+        [38, 130, 142],
+        [35, 144, 140],
+        [31, 158, 137],
+        [42, 171, 129],
+        [53, 183, 121],
+        [81, 194, 105],
+        [109, 205, 89],
+        [144, 214, 67],
+        [180, 222, 44],
+        [216, 227, 41],
+        [253, 231, 37],
+    ];
+    const scaled = t * (colors.length - 1);
+    const idx = Math.floor(scaled);
+    const fraction = scaled - idx;
+    if (idx >= colors.length - 1) {
+        return colors[colors.length - 1];
+    }
+    const c1 = colors[idx];
+    const c2 = colors[idx + 1];
+    return [
+        Math.floor(c1[0] + (c2[0] - c1[0]) * fraction),
+        Math.floor(c1[1] + (c2[1] - c1[1]) * fraction),
+        Math.floor(c1[2] + (c2[2] - c1[2]) * fraction),
+    ];
+}
+function hotColorMap(t: number): [
+    number,
+    number,
+    number
+] {
+    if (t < 0.33) {
+        return [Math.floor(t * 3 * 255), 0, 0];
+    }
+    if (t < 0.66) {
+        return [255, Math.floor((t - 0.33) * 3 * 255), 0];
+    }
+    return [255, 255, Math.floor((t - 0.66) * 3 * 255)];
+}
+function coolColorMap(t: number): [
+    number,
+    number,
+    number
+] {
+    return [Math.floor(t * 255), Math.floor((1 - t) * 255), 255];
+}
+function getColorValues(norm: number, scheme: ColorScheme): [
+    number,
+    number,
+    number
+] {
+    const value = clamp01(norm);
+    switch (scheme) {
+        case "spek":
+            return spekColorMap(value);
+        case "viridis":
+            return viridisColorMap(value);
+        case "hot":
+            return hotColorMap(value);
+        case "cool":
+            return coolColorMap(value);
+        case "grayscale":
+        default: {
+            const gray = Math.floor(value * 255);
+            return [gray, gray, gray];
+        }
+    }
+}
+function getColorString(norm: number, scheme: ColorScheme): string {
+    const [r, g, b] = getColorValues(norm, scheme);
+    return `rgb(${r},${g},${b})`;
+}
+function addAxisLabels(ctx: CanvasRenderingContext2D, plotWidth: number, plotHeight: number, sampleRate: number, duration: number, freqScale: FreqScale, fileName?: string) {
+    ctx.fillStyle = "#ffffff";
+    ctx.font = "12px Segoe UI";
+    ctx.textAlign = "center";
+    const widthFactor = plotWidth / 1000;
+    let timeStep: number;
+    if (duration <= 10) {
+        timeStep = widthFactor >= 1.8 ? 0.25 : (widthFactor >= 1.3 ? 0.5 : 0.5);
+    }
+    else if (duration <= 30) {
+        timeStep = widthFactor >= 1.8 ? 0.5 : (widthFactor >= 1.3 ? 1 : 1);
+    }
+    else if (duration <= 120) {
+        timeStep = widthFactor >= 1.8 ? 3 : (widthFactor >= 1.3 ? 4 : 5);
+    }
+    else if (duration <= 600) {
+        timeStep = widthFactor >= 1.8 ? 10 : (widthFactor >= 1.3 ? 15 : 20);
+    }
+    else {
+        timeStep = widthFactor >= 1.8 ? 20 : (widthFactor >= 1.3 ? 30 : 40);
+    }
+    if (duration > 0) {
+        for (let time = 0; time <= duration + 1e-9; time += timeStep) {
+            const timeProgress = time / duration;
+            const x = MARGIN.left + timeProgress * (plotWidth - 1);
+            const y = CANVAS_H - MARGIN.bottom + 20;
+            ctx.strokeStyle = "#ffffff";
+            ctx.lineWidth = 1;
+            ctx.beginPath();
+            ctx.moveTo(x, MARGIN.top + plotHeight);
+            ctx.lineTo(x, MARGIN.top + plotHeight + 5);
+            ctx.stroke();
+            let label: string;
+            if (timeStep >= 60) {
+                const minutes = Math.floor(time / 60);
+                const seconds = time % 60;
+                label = seconds === 0 ? `${minutes}m` : `${minutes}m${seconds}s`;
+            }
+            else {
+                label = `${time}s`;
+            }
+            ctx.fillText(label, x, y);
+        }
+    }
+    ctx.textAlign = "right";
+    const maxFreq = sampleRate / 2;
+    if (freqScale === "log2") {
+        const heightFactor = plotHeight / 500;
+        const minFreq = 20;
+        const frequencies: number[] = [];
+        const octaveStep = heightFactor >= 1.5 ? 1 : (heightFactor >= 1.0 ? 1 : 2);
+        let octaveCount = 0;
+        for (let freq = minFreq; freq <= maxFreq; freq *= 2) {
+            if (octaveCount % octaveStep === 0) {
+                frequencies.push(freq);
+            }
+            octaveCount++;
+        }
+        for (const freq of frequencies) {
+            const freqNormalized = Math.log2(freq / minFreq) / Math.log2(maxFreq / minFreq);
+            const y = MARGIN.top + plotHeight * (1 - freqNormalized);
+            ctx.strokeStyle = "#ffffff";
+            ctx.lineWidth = 1;
+            ctx.beginPath();
+            ctx.moveTo(MARGIN.left - 5, y);
+            ctx.lineTo(MARGIN.left, y);
+            ctx.stroke();
+            const label = freq >= 1000 ? `${(freq / 1000).toFixed(1)}k` : `${freq}`;
+            ctx.fillText(label, MARGIN.left - 10, y + 4);
+        }
+    }
+    else {
+        const heightFactor = plotHeight / 500;
+        let freqStep: number;
+        if (maxFreq <= 8000) {
+            freqStep = heightFactor >= 1.8 ? 250 : (heightFactor >= 1.3 ? 400 : 500);
+        }
+        else if (maxFreq <= 16000) {
+            freqStep = heightFactor >= 1.8 ? 500 : (heightFactor >= 1.3 ? 800 : 1000);
+        }
+        else if (maxFreq <= 24000) {
+            freqStep = heightFactor >= 1.8 ? 1000 : (heightFactor >= 1.3 ? 1500 : 2000);
+        }
+        else {
+            freqStep = heightFactor >= 1.8 ? 2000 : (heightFactor >= 1.3 ? 2500 : 4000);
+        }
+        for (let freq = 0; freq <= maxFreq; freq += freqStep) {
+            const y = MARGIN.top + plotHeight - (freq / maxFreq) * plotHeight + 4;
+            const x = MARGIN.left - 15;
+            ctx.strokeStyle = "#ffffff";
+            ctx.lineWidth = 1;
+            ctx.beginPath();
+            ctx.moveTo(MARGIN.left - 5, y - 4);
+            ctx.lineTo(MARGIN.left, y - 4);
+            ctx.stroke();
+            let label: string;
+            if (freq === 0) {
+                label = "0";
+            }
+            else if (freq >= 1000) {
+                label = freq % 1000 === 0 ? `${freq / 1000}k` : `${(freq / 1000).toFixed(1)}k`;
+            }
+            else {
+                label = `${freq}`;
+            }
+            ctx.fillText(label, x, y);
+        }
+    }
+    ctx.textAlign = "center";
+    ctx.font = "14px Segoe UI";
+    ctx.fillText("Time (seconds)", CANVAS_W / 2, CANVAS_H - 15);
+    ctx.save();
+    ctx.translate(25, CANVAS_H / 2);
+    ctx.rotate(-Math.PI / 2);
+    ctx.fillText("Frequency (Hz)", 0, 0);
+    ctx.restore();
+    ctx.font = "12px Segoe UI";
+    if (fileName) {
+        ctx.textAlign = "left";
+        ctx.fillText(fileName, MARGIN.left + 15, 25);
+    }
+    ctx.textAlign = "right";
+    ctx.fillText(`Sample Rate: ${sampleRate} Hz`, CANVAS_W - 20, 25);
+}
+function drawColorBar(ctx: CanvasRenderingContext2D, plotHeight: number, colorScheme: ColorScheme) {
+    const colorBarWidth = 20;
+    const colorBarX = CANVAS_W - MARGIN.right + 30;
+    const colorBarY = MARGIN.top;
+    const gradient = ctx.createLinearGradient(0, colorBarY + plotHeight, 0, colorBarY);
+    for (let i = 0; i <= 100; i++) {
+        const value = i / 100;
+        gradient.addColorStop(value, getColorString(value, colorScheme));
+    }
+    ctx.fillStyle = gradient;
+    ctx.fillRect(colorBarX, colorBarY, colorBarWidth, plotHeight);
+    ctx.strokeStyle = "#ffffff";
+    ctx.lineWidth = 1;
+    ctx.strokeRect(colorBarX, colorBarY, colorBarWidth, plotHeight);
+    ctx.fillStyle = "#ffffff";
+    ctx.font = "10px Segoe UI";
+    ctx.textAlign = "left";
+    ctx.fillText("High", colorBarX + colorBarWidth + 5, colorBarY + 12);
+    ctx.fillText("Low", colorBarX + colorBarWidth + 5, colorBarY + plotHeight - 5);
+}
+async function renderSpectrogram(ctx: CanvasRenderingContext2D, spectrum: SpectrumData, sampleRate: number, duration: number, freqScale: FreqScale, colorScheme: ColorScheme, fileName: string | undefined, shouldCancel: () => boolean) {
+    const plotWidth = CANVAS_W - MARGIN.left - MARGIN.right;
+    const plotHeight = CANVAS_H - MARGIN.top - MARGIN.bottom;
+    ctx.fillStyle = "#000000";
+    ctx.fillRect(0, 0, CANVAS_W, CANVAS_H);
+    const spectrogramData = spectrum.time_slices;
+    const numTimeFrames = spectrogramData.length;
+    const numFreqBins = spectrogramData[0]?.magnitudes.length ?? 0;
+    if (numTimeFrames === 0 || numFreqBins === 0) {
+        return;
+    }
+    let minMag = Number.POSITIVE_INFINITY;
+    let maxMag = Number.NEGATIVE_INFINITY;
+    const sampleStep = numTimeFrames > 10000 ? Math.floor(numTimeFrames / 5000) : 1;
+    for (let i = 0; i < numTimeFrames; i += sampleStep) {
+        const frame = spectrogramData[i].magnitudes;
+        for (const mag of frame) {
+            if (Number.isFinite(mag)) {
+                if (mag < minMag)
+                    minMag = mag;
+                if (mag > maxMag)
+                    maxMag = mag;
+            }
+        }
+    }
+    if (!Number.isFinite(minMag) || !Number.isFinite(maxMag)) {
+        minMag = -120;
+        maxMag = 0;
+    }
+    const magRange = maxMag - minMag;
+    const safeMagRange = magRange > 0 ? magRange : 1;
+    const highResImageData = ctx.createImageData(plotWidth, MAX_RENDER_HEIGHT);
+    const highResData = highResImageData.data;
+    const CHUNK_SIZE = 50;
+    for (let xStart = 0; xStart < plotWidth; xStart += CHUNK_SIZE) {
+        if (shouldCancel()) {
+            return;
+        }
+        const xEnd = Math.min(xStart + CHUNK_SIZE, plotWidth);
+        for (let x = xStart; x < xEnd; x++) {
+            const timeProgress = x / (plotWidth - 1);
+            const exactTimePos = timeProgress * (numTimeFrames - 1);
+            const timeIdx = Math.floor(exactTimePos);
+            const timeIdx2 = Math.min(timeIdx + 1, numTimeFrames - 1);
+            const timeFrac = exactTimePos - timeIdx;
+            const frame1 = spectrogramData[timeIdx]?.magnitudes ?? spectrogramData[0].magnitudes;
+            const frame2 = spectrogramData[timeIdx2]?.magnitudes ?? frame1;
+            for (let y = 0; y < MAX_RENDER_HEIGHT; y++) {
+                let freqProgress = (MAX_RENDER_HEIGHT - 1 - y) / (MAX_RENDER_HEIGHT - 1);
+                if (freqScale === "log2") {
+                    const minFreq = 20;
+                    const maxFreq = sampleRate / 2;
+                    const octaves = Math.log2(maxFreq / minFreq);
+                    const octave = freqProgress * octaves;
+                    const freq = minFreq * Math.pow(2, octave);
+                    freqProgress = freq / maxFreq;
+                }
+                const exactFreqPos = freqProgress * (numFreqBins - 1);
+                const freqIdx = Math.floor(exactFreqPos);
+                const freqIdx2 = Math.min(freqIdx + 1, numFreqBins - 1);
+                const freqFrac = exactFreqPos - freqIdx;
+                let magnitude: number;
+                if (timeFrac === 0 && freqFrac === 0) {
+                    magnitude = frame1[freqIdx] ?? 0;
+                }
+                else {
+                    const mag11 = frame1[freqIdx] ?? 0;
+                    const mag12 = frame1[freqIdx2] ?? 0;
+                    const mag21 = frame2[freqIdx] ?? 0;
+                    const mag22 = frame2[freqIdx2] ?? 0;
+                    const magT1 = mag11 * (1 - freqFrac) + mag12 * freqFrac;
+                    const magT2 = mag21 * (1 - freqFrac) + mag22 * freqFrac;
+                    magnitude = magT1 * (1 - timeFrac) + magT2 * timeFrac;
+                }
+                const normalizedMag = clamp01((magnitude - minMag) / safeMagRange);
+                const [r, g, b] = getColorValues(normalizedMag, colorScheme);
+                const pixelIdx = (y * plotWidth + x) * 4;
+                highResData[pixelIdx] = r;
+                highResData[pixelIdx + 1] = g;
+                highResData[pixelIdx + 2] = b;
+                highResData[pixelIdx + 3] = 255;
+            }
+        }
+        if (xStart + CHUNK_SIZE < plotWidth) {
+            await new Promise((resolve) => setTimeout(resolve, 1));
+        }
+    }
+    if (shouldCancel()) {
+        return;
+    }
+    const finalImageData = ctx.createImageData(plotWidth, plotHeight);
+    const finalData = finalImageData.data;
+    for (let y = 0; y < plotHeight; y++) {
+        for (let x = 0; x < plotWidth; x++) {
+            const highResY = Math.round((y / plotHeight) * MAX_RENDER_HEIGHT);
+            const highResIdx = (highResY * plotWidth + x) * 4;
+            const finalIdx = (y * plotWidth + x) * 4;
+            if (highResIdx < highResData.length) {
+                finalData[finalIdx] = highResData[highResIdx];
+                finalData[finalIdx + 1] = highResData[highResIdx + 1];
+                finalData[finalIdx + 2] = highResData[highResIdx + 2];
+                finalData[finalIdx + 3] = highResData[highResIdx + 3];
+            }
+        }
+    }
+    ctx.putImageData(finalImageData, MARGIN.left, MARGIN.top);
+    addAxisLabels(ctx, plotWidth, plotHeight, sampleRate, duration, freqScale, fileName);
+    drawColorBar(ctx, plotHeight, colorScheme);
+}
+export async function renderSpectrogramToCanvas(canvas: HTMLCanvasElement, options: SpectrogramRenderOptions): Promise<void> {
+    canvas.width = CANVAS_W;
+    canvas.height = CANVAS_H;
+    const ctx = canvas.getContext("2d");
+    if (!ctx) {
+        throw new Error("Cannot get 2D canvas context");
+    }
+    await renderSpectrogram(ctx, options.spectrumData, options.sampleRate, options.duration, options.freqScale, options.colorScheme, options.fileName, options.shouldCancel ?? (() => false));
+}
+export async function createSpectrogramDataURL(options: SpectrogramRenderOptions): Promise<string> {
+    const canvas = document.createElement("canvas");
+    await renderSpectrogramToCanvas(canvas, options);
+    return canvas.toDataURL("image/png");
+}
+const COLOR_SCHEMES: {
+    value: ColorScheme;
+    label: string;
+    gradient: string;
+}[] = [
+    { value: "spek", label: "Spek", gradient: "linear-gradient(to right, #0f0040, #1e0080, #4000ff, #8000ff, #ff0080, #ff4000, #ff8000, #ffff00)" },
+    { value: "viridis", label: "Viridis", gradient: "linear-gradient(to right, #440154, #31688e, #35b779, #fde725)" },
+    { value: "hot", label: "Hot", gradient: "linear-gradient(to right, #000000, #ff0000, #ffff00, #ffffff)" },
+    { value: "cool", label: "Cool", gradient: "linear-gradient(to right, #000080, #0000ff, #00ffff, #ffffff)" },
+    { value: "grayscale", label: "Grayscale", gradient: "linear-gradient(to right, #000000, #ffffff)" },
+];
+export const SpectrumVisualization = forwardRef<SpectrumVisualizationHandle, SpectrumVisualizationProps>(({ sampleRate, duration, spectrumData, fileName, onReAnalyze, isAnalyzingSpectrum, spectrumProgress, }, ref) => {
     const canvasRef = useRef<HTMLCanvasElement>(null);
+    const preferencesRef = useRef(loadAudioAnalysisPreferences());
+    useImperativeHandle(ref, () => ({
+        getCanvasDataURL: () => {
+            if (!canvasRef.current)
+                return null;
+            return canvasRef.current.toDataURL("image/png");
+        },
+    }));
+    const [freqScale, setFreqScale] = useState<FreqScale>(preferencesRef.current.freqScale);
+    const [colorScheme, setColorScheme] = useState<ColorScheme>(preferencesRef.current.colorScheme);
+    const [fftSize, setFftSize] = useState<string>(() => String(preferencesRef.current.fftSize));
+    const [windowFunction, setWindowFunction] = useState<WindowFunction>(preferencesRef.current.windowFunction);
+    useEffect(() => {
+        if (spectrumData?.freq_bins) {
+            setFftSize(String((spectrumData.freq_bins - 1) * 2));
+        }
+    }, [spectrumData]);
+    useEffect(() => {
+        saveAudioAnalysisPreferences({
+            colorScheme,
+            freqScale,
+            fftSize: Number(fftSize),
+            windowFunction,
+        });
+    }, [colorScheme, freqScale, fftSize, windowFunction]);
     useEffect(() => {
         const canvas = canvasRef.current;
         if (!canvas)
@@ -15,179 +488,115 @@ export function SpectrumVisualization({ sampleRate, bitsPerSample, duration, spe
         const ctx = canvas.getContext("2d");
         if (!ctx)
             return;
-        const width = canvas.width;
-        const height = canvas.height;
-        const marginLeft = 70;
-        const marginRight = 70;
-        const marginTop = 30;
-        const marginBottom = 65;
-        const plotWidth = width - marginLeft - marginRight;
-        const plotHeight = height - marginTop - marginBottom;
-        ctx.fillStyle = "#000000";
-        ctx.fillRect(0, 0, width, height);
-        const nyquistFreq = sampleRate / 2;
+        let canceled = false;
+        const shouldCancel = () => canceled;
         if (spectrumData) {
-            drawRealSpectrum(ctx, marginLeft, marginTop, plotWidth, plotHeight, spectrumData);
-        }
-        drawAxesAndLabels(ctx, marginLeft, marginTop, plotWidth, plotHeight, nyquistFreq, duration, sampleRate);
-        drawColorBar(ctx, marginLeft + plotWidth + 15, marginTop, 20, plotHeight);
-    }, [sampleRate, bitsPerSample, duration, spectrumData]);
-    const drawRealSpectrum = (ctx: CanvasRenderingContext2D, x: number, y: number, width: number, height: number, spectrum: SpectrumData) => {
-        const timeSlices = spectrum.time_slices;
-        if (timeSlices.length === 0)
-            return;
-        const freqBins = timeSlices[0].magnitudes.length;
-        const nyquistFreq = spectrum.max_freq;
-        let minDB = 0;
-        let maxDB = -200;
-        timeSlices.forEach((slice) => {
-            slice.magnitudes.forEach((db) => {
-                if (db > maxDB)
-                    maxDB = db;
-                if (db < minDB && db > -200)
-                    minDB = db;
+            void renderSpectrogramToCanvas(canvas, {
+                spectrumData,
+                sampleRate,
+                duration,
+                freqScale,
+                colorScheme,
+                fileName,
+                shouldCancel,
             });
-        });
-        minDB = Math.max(minDB, maxDB - 90);
-        const dbRange = maxDB - minDB;
-        const sliceWidth = Math.ceil(width / timeSlices.length);
-        for (let t = 0; t < timeSlices.length; t++) {
-            const slice = timeSlices[t];
-            const xPos = x + (t / timeSlices.length) * width;
-            for (let f = 0; f < freqBins && f < slice.magnitudes.length; f++) {
-                const db = slice.magnitudes[f];
-                const freq = (f / freqBins) * nyquistFreq;
-                const freqRatio = freq / nyquistFreq;
-                const yPos = y + height - (freqRatio * height);
-                const nextFreq = ((f + 1) / freqBins) * nyquistFreq;
-                const nextFreqRatio = nextFreq / nyquistFreq;
-                const nextYPos = y + height - (nextFreqRatio * height);
-                const binHeight = Math.max(1, Math.abs(yPos - nextYPos) + 1);
-                const intensity = Math.max(0, Math.min(1, (db - minDB) / dbRange));
-                const color = getSpekColor(intensity);
-                ctx.fillStyle = color;
-                ctx.fillRect(xPos, nextYPos, sliceWidth, binHeight);
-            }
-        }
-    };
-    const getSpekColor = (intensity: number): string => {
-        if (intensity < 0.08) {
-            const t = intensity / 0.08;
-            return `rgb(0, 0, ${Math.floor(t * 80)})`;
-        }
-        else if (intensity < 0.18) {
-            const t = (intensity - 0.08) / 0.10;
-            return `rgb(${Math.floor(t * 50)}, ${Math.floor(t * 30)}, ${Math.floor(80 + t * 175)})`;
-        }
-        else if (intensity < 0.28) {
-            const t = (intensity - 0.18) / 0.10;
-            return `rgb(${Math.floor(50 + t * 150)}, ${Math.floor(30 - t * 30)}, ${Math.floor(255 - t * 55)})`;
-        }
-        else if (intensity < 0.40) {
-            const t = (intensity - 0.28) / 0.12;
-            return `rgb(${Math.floor(200 + t * 55)}, 0, ${Math.floor(200 - t * 200)})`;
-        }
-        else if (intensity < 0.52) {
-            const t = (intensity - 0.40) / 0.12;
-            return `rgb(255, ${Math.floor(t * 100)}, 0)`;
-        }
-        else if (intensity < 0.65) {
-            const t = (intensity - 0.52) / 0.13;
-            return `rgb(255, ${Math.floor(100 + t * 80)}, 0)`;
-        }
-        else if (intensity < 0.78) {
-            const t = (intensity - 0.65) / 0.13;
-            return `rgb(255, ${Math.floor(180 + t * 55)}, ${Math.floor(t * 30)})`;
-        }
-        else if (intensity < 0.90) {
-            const t = (intensity - 0.78) / 0.12;
-            return `rgb(255, ${Math.floor(235 + t * 20)}, ${Math.floor(30 + t * 100)})`;
         }
         else {
-            const t = (intensity - 0.90) / 0.10;
-            return `rgb(255, 255, ${Math.floor(130 + t * 125)})`;
+            ctx.fillStyle = "#000000";
+            ctx.fillRect(0, 0, CANVAS_W, CANVAS_H);
+            ctx.fillStyle = "#444444";
+            ctx.font = "16px Arial";
+            ctx.textAlign = "center";
+            ctx.fillText("No spectrum data", CANVAS_W / 2, CANVAS_H / 2);
+        }
+        return () => {
+            canceled = true;
+        };
+    }, [spectrumData, sampleRate, duration, freqScale, colorScheme, fileName]);
+    const handleReAnalyze = (newFftSize: string, newWindowFunc: string) => {
+        setFftSize(newFftSize);
+        setWindowFunction(newWindowFunc as WindowFunction);
+        if (onReAnalyze) {
+            onReAnalyze(parseInt(newFftSize, 10), newWindowFunc);
         }
     };
-    const drawAxesAndLabels = (ctx: CanvasRenderingContext2D, x: number, y: number, width: number, height: number, nyquistFreq: number, duration: number, sampleRate: number) => {
-        ctx.fillStyle = "#CCCCCC";
-        ctx.font = "12px Arial";
-        ctx.textAlign = "right";
-        ctx.textBaseline = "middle";
-        const freqLabels = generateFreqLabels(nyquistFreq);
-        freqLabels.forEach(freq => {
-            if (freq <= nyquistFreq) {
-                const freqRatio = freq / nyquistFreq;
-                const yPos = y + height - (freqRatio * height);
-                const label = freq >= 1000 ? `${freq / 1000}k` : `${freq}`;
-                ctx.fillText(label, x - 8, yPos);
-            }
-        });
-        ctx.fillText("0", x - 8, y + height);
-        ctx.textAlign = "center";
-        ctx.textBaseline = "top";
-        const timeStep = getTimeStep(duration);
-        for (let t = 0; t <= duration; t += timeStep) {
-            const xPos = x + (t / duration) * width;
-            ctx.fillText(`${Math.round(t)}s`, xPos, y + height + 8);
-        }
-        ctx.fillStyle = "#FFFFFF";
-        ctx.font = "13px Arial";
-        ctx.save();
-        ctx.translate(12, y + height / 2);
-        ctx.rotate(-Math.PI / 2);
-        ctx.textAlign = "center";
-        ctx.fillText("Frequency (Hz)", 0, 0);
-        ctx.restore();
-        ctx.textAlign = "center";
-        ctx.fillText("Time (seconds)", x + width / 2, y + height + 35);
-        ctx.textAlign = "right";
-        ctx.fillStyle = "#CCCCCC";
-        ctx.font = "12px Arial";
-        ctx.fillText(`Sample Rate: ${sampleRate} Hz`, x + width - 5, y - 3);
-    };
-    const generateFreqLabels = (nyquistFreq: number): number[] => {
-        if (nyquistFreq <= 24000) {
-            return [2000, 4000, 6000, 8000, 10000, 12000, 14000, 16000, 18000, 20000, 22000];
-        }
-        else if (nyquistFreq <= 48000) {
-            return [5000, 10000, 15000, 20000, 25000, 30000, 35000, 40000, 45000];
-        }
-        else if (nyquistFreq <= 96000) {
-            return [10000, 20000, 30000, 40000, 50000, 60000, 70000, 80000, 90000];
-        }
-        else {
-            return [20000, 40000, 60000, 80000, 100000, 120000, 140000, 160000, 180000];
-        }
-    };
-    const getTimeStep = (duration: number): number => {
-        if (duration <= 60)
-            return 15;
-        if (duration <= 120)
-            return 30;
-        if (duration <= 300)
-            return 30;
-        if (duration <= 600)
-            return 60;
-        return 60;
-    };
-    const drawColorBar = (ctx: CanvasRenderingContext2D, x: number, y: number, width: number, height: number) => {
-        for (let i = 0; i < height; i++) {
-            const intensity = 1 - (i / height);
-            const color = getSpekColor(intensity);
-            ctx.fillStyle = color;
-            ctx.fillRect(x, y + i, width, 1);
-        }
-        ctx.strokeStyle = "#666666";
-        ctx.lineWidth = 1;
-        ctx.strokeRect(x, y, width, height);
-        ctx.fillStyle = "#FFFFFF";
-        ctx.font = "11px Arial";
-        ctx.textAlign = "left";
-        ctx.textBaseline = "middle";
-        ctx.fillText("High", x + width + 5, y + 10);
-        ctx.fillText("Low", x + width + 5, y + height - 10);
-    };
-    return (<div className="border border-white/10 rounded-lg overflow-hidden bg-black shadow-xl">
-      <canvas ref={canvasRef} width={1200} height={600} className="w-full h-auto" style={{ imageRendering: "auto" }}/>
-    </div>);
-}
+    const spectrumPercent = Math.round(Math.max(0, Math.min(100, spectrumProgress?.percent ?? 0)));
+    return (<div className="space-y-4">
+            <div className="flex flex-wrap items-center gap-3 sm:gap-4 p-1">
+                <div className="flex items-center gap-2">
+                    <Label className="whitespace-nowrap text-sm font-medium">Color Scheme:</Label>
+                    <Select value={colorScheme} onValueChange={(v) => setColorScheme(v as ColorScheme)} disabled={isAnalyzingSpectrum}>
+                        <SelectTrigger className="h-8 w-[130px] text-sm">
+                            <SelectValue />
+                        </SelectTrigger>
+                        <SelectContent>
+                            {COLOR_SCHEMES.map((scheme) => (<SelectItem key={scheme.value} value={scheme.value}>
+                                    <div className="flex items-center gap-2">
+                                        <div className="h-4 w-4 rounded-sm border opacity-90" style={{ backgroundImage: scheme.gradient }}/>
+                                        <span>{scheme.label}</span>
+                                    </div>
+                                </SelectItem>))}
+                        </SelectContent>
+                    </Select>
+                </div>
+
+                <div className="h-6 w-px bg-border hidden sm:block mx-1"></div>
+
+                <div className="flex items-center gap-2">
+                    <Label className="whitespace-nowrap text-sm font-medium">Freq Scale:</Label>
+                    <Select value={freqScale} onValueChange={(v) => setFreqScale(v as FreqScale)} disabled={isAnalyzingSpectrum}>
+                        <SelectTrigger className="h-8 w-[95px] text-sm">
+                            <SelectValue />
+                        </SelectTrigger>
+                        <SelectContent>
+                            <SelectItem value="linear">Linear</SelectItem>
+                            <SelectItem value="log2">Log2</SelectItem>
+                        </SelectContent>
+                    </Select>
+                </div>
+
+                <div className="flex items-center gap-2">
+                    <Label className="whitespace-nowrap text-sm font-medium">FFT Size:</Label>
+                    <Select value={fftSize} onValueChange={(v) => handleReAnalyze(v, windowFunction)} disabled={isAnalyzingSpectrum}>
+                        <SelectTrigger className="h-8 w-[90px] text-sm">
+                            <SelectValue />
+                        </SelectTrigger>
+                        <SelectContent>
+                            <SelectItem value="512">512</SelectItem>
+                            <SelectItem value="1024">1024</SelectItem>
+                            <SelectItem value="2048">2048</SelectItem>
+                            <SelectItem value="4096">4096</SelectItem>
+                        </SelectContent>
+                    </Select>
+                </div>
+
+                <div className="flex items-center gap-2">
+                    <Label className="whitespace-nowrap text-sm font-medium">Window:</Label>
+                    <Select value={windowFunction} onValueChange={(v) => handleReAnalyze(fftSize, v)} disabled={isAnalyzingSpectrum}>
+                        <SelectTrigger className="h-8 w-[120px] text-sm capitalize">
+                            <SelectValue />
+                        </SelectTrigger>
+                        <SelectContent>
+                            <SelectItem value="hann">Hann</SelectItem>
+                            <SelectItem value="hamming">Hamming</SelectItem>
+                            <SelectItem value="blackman">Blackman</SelectItem>
+                            <SelectItem value="rectangular">Rectangular</SelectItem>
+                        </SelectContent>
+                    </Select>
+                </div>
+            </div>
+
+            <div className="relative border border-white/10 rounded-lg overflow-hidden bg-black shadow-xl">
+                {isAnalyzingSpectrum && (<div className="absolute inset-0 z-10 grid place-items-center bg-black/60 backdrop-blur-sm">
+                        <div className="w-full max-w-xs space-y-2 px-4">
+                            <div className="flex items-center justify-between text-sm text-foreground/90">
+                                <span>Processing...</span>
+                                <span className="tabular-nums">{spectrumPercent}%</span>
+                            </div>
+                            <Progress value={spectrumPercent} className="h-2 w-full"/>
+                        </div>
+                    </div>)}
+                <canvas ref={canvasRef} width={CANVAS_W} height={CANVAS_H} className="w-full h-auto" style={{ imageRendering: "auto" }}/>
+            </div>
+        </div>);
+});

frontend/src/components/TitleBar.tsx

@@ -1,8 +1,9 @@
-import { X, Minus, Maximize, Settings, Info } from "lucide-react";
+import { X, Minus, Maximize, SlidersHorizontal, Info, Globe } from "lucide-react";
 import { WindowMinimise, WindowToggleMaximise, Quit } from "../../wailsjs/runtime/runtime";
 import { Menubar, MenubarContent, MenubarMenu, MenubarItem, MenubarTrigger, MenubarLabel, MenubarSeparator } from "@/components/ui/menubar";
 import { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger } from "@/components/ui/tooltip";
 import { getSettings, updateSettings } from "@/lib/settings";
+import { openExternal } from "@/lib/utils";
 import { useState, useEffect } from "react";
 export function TitleBar() {
     const [useSpotFetchAPI, setUseSpotFetchAPI] = useState(false);
@@ -43,7 +44,7 @@ export function TitleBar() {
         <Menubar className="border-none bg-transparent shadow-none px-0 mr-1" style={{ "--wails-draggable": "no-drag" } as React.CSSProperties}>
             <MenubarMenu>
                 <MenubarTrigger className="cursor-pointer w-8 h-7 p-0 flex items-center justify-center hover:bg-muted transition-colors rounded data-[state=open]:bg-muted">
-                    <Settings className="w-3.5 h-3.5"/>
+                    <SlidersHorizontal className="w-3.5 h-3.5"/>
                 </MenubarTrigger>
                 <MenubarContent align="end" className="min-w-[200px]">
                     <div className="flex items-center gap-1.5 px-2 py-1.5">
@@ -65,6 +66,11 @@ export function TitleBar() {
                         <span>Use SpotFetch API</span>
                         <span className="ml-4">{useSpotFetchAPI ? "✓" : ""}</span>
                     </MenubarItem>
+                    <MenubarSeparator />
+                    <MenubarItem onClick={() => openExternal("https://afkarxyz.qzz.io")} className="gap-2">
+                        <Globe className="w-4 h-4 opacity-70"/>
+                        <span>Website</span>
+                    </MenubarItem>
                 </MenubarContent>
             </MenubarMenu>
         </Menubar>

frontend/src/components/TrackInfo.tsx

@@ -4,7 +4,7 @@ import { Download, FolderOpen, CheckCircle, XCircle, FileText, FileCheck, Globe,
 import { Spinner } from "@/components/ui/spinner";
 import { Tooltip, TooltipContent, TooltipTrigger, } from "@/components/ui/tooltip";
 import type { TrackMetadata, TrackAvailability } from "@/types/api";
-import { TidalIcon, QobuzIcon, AmazonIcon, DeezerIcon } from "./PlatformIcons";
+import { TidalAvailabilityIcon, QobuzAvailabilityIcon, AmazonAvailabilityIcon } from "./PlatformIcons";
 import { usePreview } from "@/hooks/usePreview";
 interface TrackInfoProps {
     track: TrackMetadata & {
@@ -119,7 +119,7 @@ export function TrackInfo({ track, isDownloading, downloadingTrack, isDownloaded
                 </Button>
               </TooltipTrigger>
               <TooltipContent>
-                <p>Download Lyric</p>
+                <p>Download Separate Lyric</p>
               </TooltipContent>
             </Tooltip>)}
             {track.images && onDownloadCover && (<Tooltip>
@@ -129,7 +129,7 @@ export function TrackInfo({ track, isDownloading, downloadingTrack, isDownloaded
                 </Button>
               </TooltipTrigger>
               <TooltipContent>
-                <p>Download Cover</p>
+                <p>Download Separate Cover</p>
               </TooltipContent>
             </Tooltip>)}
             {track.spotify_id && onCheckAvailability && (<Tooltip>
@@ -139,18 +139,23 @@ export function TrackInfo({ track, isDownloading, downloadingTrack, isDownloaded
                 </Button>
               </TooltipTrigger>
               <TooltipContent>
-                {availability ? (<div className="flex items-center gap-2">
-                  <TidalIcon className={`w-4 h-4 ${availability.tidal ? "text-green-500" : "text-red-500"}`}/>
-                  <QobuzIcon className={`w-4 h-4 ${availability.qobuz ? "text-green-500" : "text-red-500"}`}/>
-                  <AmazonIcon className={`w-4 h-4 ${availability.amazon ? "text-green-500" : "text-red-500"}`}/>
-                  <DeezerIcon className={`w-4 h-4 ${availability.deezer ? "text-green-500" : "text-red-500"}`}/>
+                  {availability ? (<div className="flex items-center gap-2">
+                  <TidalAvailabilityIcon className={`w-4 h-4 ${availability.tidal ? "text-green-500" : "text-red-500"}`}/>
+                  <QobuzAvailabilityIcon className={`w-4 h-4 ${availability.qobuz ? "text-green-500" : "text-red-500"}`}/>
+                  <AmazonAvailabilityIcon className={`w-4 h-4 ${availability.amazon ? "text-green-500" : "text-red-500"}`}/>
                 </div>) : (<p>Check Availability</p>)}
               </TooltipContent>
             </Tooltip>)}
-            {isDownloaded && (<Button onClick={onOpenFolder} variant="outline">
-              <FolderOpen className="h-4 w-4"/>
-              Open Folder
-            </Button>)}
+            {isDownloaded && (<Tooltip>
+              <TooltipTrigger asChild>
+                <Button onClick={onOpenFolder} variant="outline" size="icon">
+                  <FolderOpen className="h-4 w-4"/>
+                </Button>
+              </TooltipTrigger>
+              <TooltipContent>
+                <p>Open Folder</p>
+              </TooltipContent>
+            </Tooltip>)}
           </div>)}
         </div>
       </div>

frontend/src/components/TrackList.tsx

@@ -5,7 +5,7 @@ import { Spinner } from "@/components/ui/spinner";
 import { Tooltip, TooltipContent, TooltipTrigger, } from "@/components/ui/tooltip";
 import { Pagination, PaginationContent, PaginationEllipsis, PaginationItem, PaginationLink, PaginationNext, PaginationPrevious, } from "@/components/ui/pagination";
 import type { TrackMetadata, TrackAvailability } from "@/types/api";
-import { TidalIcon, QobuzIcon, AmazonIcon, DeezerIcon } from "./PlatformIcons";
+import { TidalAvailabilityIcon, QobuzAvailabilityIcon, AmazonAvailabilityIcon } from "./PlatformIcons";
 import { usePreview } from "@/hooks/usePreview";
 interface TrackListProps {
     tracks: TrackMetadata[];
@@ -304,7 +304,7 @@ export function TrackList({ tracks, searchQuery, sortBy, selectedTracks, downloa
                       </Button>
                     </TooltipTrigger>
                     <TooltipContent>
-                      <p>Download Lyric</p>
+                      <p>Download Separate Lyric</p>
                     </TooltipContent>
                   </Tooltip>)}
                   {track.images && onDownloadCover && (<Tooltip>
@@ -317,7 +317,7 @@ export function TrackList({ tracks, searchQuery, sortBy, selectedTracks, downloa
                       </Button>
                     </TooltipTrigger>
                     <TooltipContent>
-                      <p>Download Cover</p>
+                      <p>Download Separate Cover</p>
                     </TooltipContent>
                   </Tooltip>)}
                   {track.spotify_id && onCheckAvailability && (<Tooltip>
@@ -328,10 +328,9 @@ export function TrackList({ tracks, searchQuery, sortBy, selectedTracks, downloa
                     </TooltipTrigger>
                     <TooltipContent>
                       {availabilityMap?.has(track.spotify_id) ? (<div className="flex items-center gap-2">
-                        <TidalIcon className={`w-4 h-4 ${availabilityMap.get(track.spotify_id)?.tidal ? "text-green-500" : "text-red-500"}`}/>
-                        <QobuzIcon className={`w-4 h-4 ${availabilityMap.get(track.spotify_id)?.qobuz ? "text-green-500" : "text-red-500"}`}/>
-                        <AmazonIcon className={`w-4 h-4 ${availabilityMap.get(track.spotify_id)?.amazon ? "text-green-500" : "text-red-500"}`}/>
-                        <DeezerIcon className={`w-4 h-4 ${availabilityMap.get(track.spotify_id)?.deezer ? "text-green-500" : "text-red-500"}`}/>
+                        <TidalAvailabilityIcon className={`w-4 h-4 ${availabilityMap.get(track.spotify_id)?.tidal ? "text-green-500" : "text-red-500"}`}/>
+                        <QobuzAvailabilityIcon className={`w-4 h-4 ${availabilityMap.get(track.spotify_id)?.qobuz ? "text-green-500" : "text-red-500"}`}/>
+                        <AmazonAvailabilityIcon className={`w-4 h-4 ${availabilityMap.get(track.spotify_id)?.amazon ? "text-green-500" : "text-red-500"}`}/>
                       </div>) : (<p>Check Availability</p>)}
                     </TooltipContent>
                   </Tooltip>)}

frontend/src/components/ui/audio-lines.tsx

@@ -0,0 +1,87 @@
+"use client";
+import { motion, useAnimation } from "motion/react";
+import type { HTMLAttributes } from "react";
+import { forwardRef, useCallback, useImperativeHandle, useRef } from "react";
+import { cn } from "@/lib/utils";
+export interface AudioLinesIconHandle {
+    startAnimation: () => void;
+    stopAnimation: () => void;
+}
+interface AudioLinesIconProps extends HTMLAttributes<HTMLDivElement> {
+    size?: number;
+}
+const AudioLinesIcon = forwardRef<AudioLinesIconHandle, AudioLinesIconProps>(({ onMouseEnter, onMouseLeave, className, size = 28, ...props }, ref) => {
+    const controls = useAnimation();
+    const isControlledRef = useRef(false);
+    useImperativeHandle(ref, () => {
+        isControlledRef.current = true;
+        return {
+            startAnimation: () => controls.start("animate"),
+            stopAnimation: () => controls.start("normal"),
+        };
+    });
+    const handleMouseEnter = useCallback((e: React.MouseEvent<HTMLDivElement>) => {
+        if (isControlledRef.current) {
+            onMouseEnter?.(e);
+        }
+        else {
+            controls.start("animate");
+        }
+    }, [controls, onMouseEnter]);
+    const handleMouseLeave = useCallback((e: React.MouseEvent<HTMLDivElement>) => {
+        if (isControlledRef.current) {
+            onMouseLeave?.(e);
+        }
+        else {
+            controls.start("normal");
+        }
+    }, [controls, onMouseLeave]);
+    return (<div className={cn(className)} onMouseEnter={handleMouseEnter} onMouseLeave={handleMouseLeave} {...props}>
+        <svg fill="none" height={size} stroke="currentColor" strokeLinecap="round" strokeLinejoin="round" strokeWidth="2" viewBox="0 0 24 24" width={size} xmlns="http://www.w3.org/2000/svg">
+          <path d="M2 10v3"/>
+          <motion.path animate={controls} d="M6 6v11" variants={{
+            normal: { d: "M6 6v11" },
+            animate: {
+                d: ["M6 6v11", "M6 10v3", "M6 6v11"],
+                transition: {
+                    duration: 1.5,
+                    repeat: Number.POSITIVE_INFINITY,
+                },
+            },
+        }}/>
+          <motion.path animate={controls} d="M10 3v18" variants={{
+            normal: { d: "M10 3v18" },
+            animate: {
+                d: ["M10 3v18", "M10 9v5", "M10 3v18"],
+                transition: {
+                    duration: 1,
+                    repeat: Number.POSITIVE_INFINITY,
+                },
+            },
+        }}/>
+          <motion.path animate={controls} d="M14 8v7" variants={{
+            normal: { d: "M14 8v7" },
+            animate: {
+                d: ["M14 8v7", "M14 6v11", "M14 8v7"],
+                transition: {
+                    duration: 0.8,
+                    repeat: Number.POSITIVE_INFINITY,
+                },
+            },
+        }}/>
+          <motion.path animate={controls} d="M18 5v13" variants={{
+            normal: { d: "M18 5v13" },
+            animate: {
+                d: ["M18 5v13", "M18 7v9", "M18 5v13"],
+                transition: {
+                    duration: 1.5,
+                    repeat: Number.POSITIVE_INFINITY,
+                },
+            },
+        }}/>
+          <path d="M22 10v3"/>
+        </svg>
+      </div>);
+});
+AudioLinesIcon.displayName = "AudioLinesIcon";
+export { AudioLinesIcon };

frontend/src/components/ui/blocks-icon.tsx

@@ -0,0 +1,53 @@
+"use client";
+import type { Variants } from "motion/react";
+import { motion, useAnimation } from "motion/react";
+import type { HTMLAttributes } from "react";
+import { forwardRef, useCallback, useImperativeHandle, useRef } from "react";
+import { cn } from "@/lib/utils";
+export interface BlocksIconHandle {
+    startAnimation: () => void;
+    stopAnimation: () => void;
+}
+interface BlocksIconProps extends HTMLAttributes<HTMLDivElement> {
+    size?: number;
+    loop?: boolean;
+}
+const VARIANTS: Variants = {
+    normal: { translateX: 0, translateY: 0 },
+    animate: { translateX: -4, translateY: 4 },
+};
+const BlocksIcon = forwardRef<BlocksIconHandle, BlocksIconProps>(({ onMouseEnter, onMouseLeave, className, size = 28, loop = false, ...props }, ref) => {
+    const controls = useAnimation();
+    const isControlledRef = useRef(false);
+    useImperativeHandle(ref, () => {
+        isControlledRef.current = true;
+        return {
+            startAnimation: () => controls.start("animate"),
+            stopAnimation: () => controls.start("normal"),
+        };
+    });
+    const handleMouseEnter = useCallback((e: React.MouseEvent<HTMLDivElement>) => {
+        if (isControlledRef.current) {
+            onMouseEnter?.(e);
+        }
+        else {
+            controls.start("animate");
+        }
+    }, [controls, onMouseEnter]);
+    const handleMouseLeave = useCallback((e: React.MouseEvent<HTMLDivElement>) => {
+        if (isControlledRef.current) {
+            onMouseLeave?.(e);
+        }
+        else {
+            controls.start("normal");
+        }
+    }, [controls, onMouseLeave]);
+    return (<div className={cn("flex items-center justify-center", className)} onMouseEnter={handleMouseEnter} onMouseLeave={handleMouseLeave} {...props}>
+        <svg fill="none" height={size} stroke="currentColor" strokeLinecap="round" strokeLinejoin="round" strokeWidth="2" viewBox="0 0 24 24" width={size} xmlns="http://www.w3.org/2000/svg">
+          <path d="M10 21V8a1 1 0 0 0-1-1H4a1 1 0 0 0-1 1v12a1 1 0 0 0 1 1h12a1 1 0 0 0 1-1v-5a1 1 0 0 0-1-1H3"/>
+          <motion.path animate={controls} d="M14 3h7v7h-7z" variants={VARIANTS}/>
+        </svg>
+      </div>);
+});
+BlocksIcon.displayName = "BlocksIcon";
+export { BlocksIcon };

frontend/src/components/ui/dropdown-menu.tsx

@@ -0,0 +1,76 @@
+import * as React from "react";
+import { CheckIcon, ChevronRightIcon, CircleIcon } from "lucide-react";
+import { DropdownMenu as DropdownMenuPrimitive } from "radix-ui";
+import { cn } from "@/lib/utils";
+function DropdownMenu({ ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Root>) {
+    return <DropdownMenuPrimitive.Root data-slot="dropdown-menu" {...props}/>;
+}
+function DropdownMenuPortal({ ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Portal>) {
+    return (<DropdownMenuPrimitive.Portal data-slot="dropdown-menu-portal" {...props}/>);
+}
+function DropdownMenuTrigger({ ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Trigger>) {
+    return (<DropdownMenuPrimitive.Trigger data-slot="dropdown-menu-trigger" {...props}/>);
+}
+function DropdownMenuContent({ className, sideOffset = 4, ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Content>) {
+    return (<DropdownMenuPrimitive.Portal>
+      <DropdownMenuPrimitive.Content data-slot="dropdown-menu-content" sideOffset={sideOffset} className={cn("z-50 max-h-(--radix-dropdown-menu-content-available-height) min-w-[8rem] origin-(--radix-dropdown-menu-content-transform-origin) overflow-x-hidden overflow-y-auto rounded-md border bg-popover p-1 text-popover-foreground shadow-md data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=closed]:zoom-out-95 data-[state=open]:animate-in data-[state=open]:fade-in-0 data-[state=open]:zoom-in-95", className)} {...props}/>
+    </DropdownMenuPrimitive.Portal>);
+}
+function DropdownMenuGroup({ ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Group>) {
+    return (<DropdownMenuPrimitive.Group data-slot="dropdown-menu-group" {...props}/>);
+}
+function DropdownMenuItem({ className, inset, variant = "default", ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Item> & {
+    inset?: boolean;
+    variant?: "default" | "destructive";
+}) {
+    return (<DropdownMenuPrimitive.Item data-slot="dropdown-menu-item" data-inset={inset} data-variant={variant} className={cn("relative flex cursor-default items-center gap-2 rounded-sm px-2 py-1.5 text-sm outline-hidden select-none focus:bg-accent focus:text-accent-foreground data-[disabled]:pointer-events-none data-[disabled]:opacity-50 data-[inset]:pl-8 data-[variant=destructive]:text-destructive data-[variant=destructive]:focus:bg-destructive/10 data-[variant=destructive]:focus:text-destructive dark:data-[variant=destructive]:focus:bg-destructive/20 [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4 [&_svg:not([class*='text-'])]:text-muted-foreground data-[variant=destructive]:*:[svg]:text-destructive!", className)} {...props}/>);
+}
+function DropdownMenuCheckboxItem({ className, children, checked, ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.CheckboxItem>) {
+    return (<DropdownMenuPrimitive.CheckboxItem data-slot="dropdown-menu-checkbox-item" className={cn("relative flex cursor-default items-center gap-2 rounded-sm py-1.5 pr-2 pl-8 text-sm outline-hidden select-none focus:bg-accent focus:text-accent-foreground data-[disabled]:pointer-events-none data-[disabled]:opacity-50 [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4", className)} checked={checked} {...props}>
+      <span className="pointer-events-none absolute left-2 flex size-3.5 items-center justify-center">
+        <DropdownMenuPrimitive.ItemIndicator>
+          <CheckIcon className="size-4"/>
+        </DropdownMenuPrimitive.ItemIndicator>
+      </span>
+      {children}
+    </DropdownMenuPrimitive.CheckboxItem>);
+}
+function DropdownMenuRadioGroup({ ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.RadioGroup>) {
+    return (<DropdownMenuPrimitive.RadioGroup data-slot="dropdown-menu-radio-group" {...props}/>);
+}
+function DropdownMenuRadioItem({ className, children, ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.RadioItem>) {
+    return (<DropdownMenuPrimitive.RadioItem data-slot="dropdown-menu-radio-item" className={cn("relative flex cursor-default items-center gap-2 rounded-sm py-1.5 pr-2 pl-8 text-sm outline-hidden select-none focus:bg-accent focus:text-accent-foreground data-[disabled]:pointer-events-none data-[disabled]:opacity-50 [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4", className)} {...props}>
+      <span className="pointer-events-none absolute left-2 flex size-3.5 items-center justify-center">
+        <DropdownMenuPrimitive.ItemIndicator>
+          <CircleIcon className="size-2 fill-current"/>
+        </DropdownMenuPrimitive.ItemIndicator>
+      </span>
+      {children}
+    </DropdownMenuPrimitive.RadioItem>);
+}
+function DropdownMenuLabel({ className, inset, ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Label> & {
+    inset?: boolean;
+}) {
+    return (<DropdownMenuPrimitive.Label data-slot="dropdown-menu-label" data-inset={inset} className={cn("px-2 py-1.5 text-sm font-medium data-[inset]:pl-8", className)} {...props}/>);
+}
+function DropdownMenuSeparator({ className, ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Separator>) {
+    return (<DropdownMenuPrimitive.Separator data-slot="dropdown-menu-separator" className={cn("-mx-1 my-1 h-px bg-border", className)} {...props}/>);
+}
+function DropdownMenuShortcut({ className, ...props }: React.ComponentProps<"span">) {
+    return (<span data-slot="dropdown-menu-shortcut" className={cn("ml-auto text-xs tracking-widest text-muted-foreground", className)} {...props}/>);
+}
+function DropdownMenuSub({ ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Sub>) {
+    return <DropdownMenuPrimitive.Sub data-slot="dropdown-menu-sub" {...props}/>;
+}
+function DropdownMenuSubTrigger({ className, inset, children, ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.SubTrigger> & {
+    inset?: boolean;
+}) {
+    return (<DropdownMenuPrimitive.SubTrigger data-slot="dropdown-menu-sub-trigger" data-inset={inset} className={cn("flex cursor-default items-center gap-2 rounded-sm px-2 py-1.5 text-sm outline-hidden select-none focus:bg-accent focus:text-accent-foreground data-[inset]:pl-8 data-[state=open]:bg-accent data-[state=open]:text-accent-foreground [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4 [&_svg:not([class*='text-'])]:text-muted-foreground", className)} {...props}>
+      {children}
+      <ChevronRightIcon className="ml-auto size-4"/>
+    </DropdownMenuPrimitive.SubTrigger>);
+}
+function DropdownMenuSubContent({ className, ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.SubContent>) {
+    return (<DropdownMenuPrimitive.SubContent data-slot="dropdown-menu-sub-content" className={cn("z-50 min-w-[8rem] origin-(--radix-dropdown-menu-content-transform-origin) overflow-hidden rounded-md border bg-popover p-1 text-popover-foreground shadow-lg data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=closed]:zoom-out-95 data-[state=open]:animate-in data-[state=open]:fade-in-0 data-[state=open]:zoom-in-95", className)} {...props}/>);
+}
+export { DropdownMenu, DropdownMenuPortal, DropdownMenuTrigger, DropdownMenuContent, DropdownMenuGroup, DropdownMenuLabel, DropdownMenuItem, DropdownMenuCheckboxItem, DropdownMenuRadioGroup, DropdownMenuRadioItem, DropdownMenuSeparator, DropdownMenuShortcut, DropdownMenuSub, DropdownMenuSubTrigger, DropdownMenuSubContent, };

frontend/src/components/ui/github.tsx

@@ -0,0 +1,102 @@
+"use client";
+import type { Variants } from "motion/react";
+import { motion, useAnimation } from "motion/react";
+import type { HTMLAttributes } from "react";
+import { forwardRef, useCallback, useImperativeHandle, useRef } from "react";
+import { cn } from "@/lib/utils";
+export interface GithubIconHandle {
+    startAnimation: () => void;
+    stopAnimation: () => void;
+}
+interface GithubIconProps extends HTMLAttributes<HTMLDivElement> {
+    size?: number;
+}
+const BODY_VARIANTS: Variants = {
+    normal: {
+        opacity: 1,
+        pathLength: 1,
+        scale: 1,
+        transition: {
+            duration: 0.3,
+        },
+    },
+    animate: {
+        opacity: [0, 1],
+        pathLength: [0, 1],
+        scale: [0.9, 1],
+        transition: {
+            duration: 0.4,
+        },
+    },
+};
+const TAIL_VARIANTS: Variants = {
+    normal: {
+        pathLength: 1,
+        rotate: 0,
+        transition: {
+            duration: 0.3,
+        },
+    },
+    draw: {
+        pathLength: [0, 1],
+        rotate: 0,
+        transition: {
+            duration: 0.5,
+        },
+    },
+    wag: {
+        pathLength: 1,
+        rotate: [0, -15, 15, -10, 10, -5, 5],
+        transition: {
+            duration: 2.5,
+            ease: "easeInOut",
+            repeat: Number.POSITIVE_INFINITY,
+        },
+    },
+};
+const GithubIcon = forwardRef<GithubIconHandle, GithubIconProps>(({ onMouseEnter, onMouseLeave, className, size = 28, ...props }, ref) => {
+    const bodyControls = useAnimation();
+    const tailControls = useAnimation();
+    const isControlledRef = useRef(false);
+    useImperativeHandle(ref, () => {
+        isControlledRef.current = true;
+        return {
+            startAnimation: async () => {
+                bodyControls.start("animate");
+                await tailControls.start("draw");
+                tailControls.start("wag");
+            },
+            stopAnimation: () => {
+                bodyControls.start("normal");
+                tailControls.start("normal");
+            },
+        };
+    });
+    const handleMouseEnter = useCallback(async (e: React.MouseEvent<HTMLDivElement>) => {
+        if (isControlledRef.current) {
+            onMouseEnter?.(e);
+        }
+        else {
+            bodyControls.start("animate");
+            await tailControls.start("draw");
+            tailControls.start("wag");
+        }
+    }, [bodyControls, onMouseEnter, tailControls]);
+    const handleMouseLeave = useCallback((e: React.MouseEvent<HTMLDivElement>) => {
+        if (isControlledRef.current) {
+            onMouseLeave?.(e);
+        }
+        else {
+            bodyControls.start("normal");
+            tailControls.start("normal");
+        }
+    }, [bodyControls, tailControls, onMouseLeave]);
+    return (<div className={cn(className)} onMouseEnter={handleMouseEnter} onMouseLeave={handleMouseLeave} {...props}>
+        <svg fill="none" height={size} stroke="currentColor" strokeLinecap="round" strokeLinejoin="round" strokeWidth="2" viewBox="0 0 24 24" width={size} xmlns="http://www.w3.org/2000/svg">
+          <motion.path animate={bodyControls} d="M15 22v-4a4.8 4.8 0 0 0-1-3.5c3 0 6-2 6-5.5.08-1.25-.27-2.48-1-3.5.28-1.15.28-2.35 0-3.5 0 0-1 0-3 1.5-2.64-.5-5.36-.5-8 0C6 2 5 2 5 2c-.3 1.15-.3 2.35 0 3.5A5.403 5.403 0 0 0 4 9c0 3.5 3 5.5 6 5.5-.39.49-.68 1.05-.85 1.65-.17.6-.22 1.23-.15 1.85v4" initial="normal" variants={BODY_VARIANTS}/>
+          <motion.path animate={tailControls} d="M9 18c-4.51 2-5-2-7-2" initial="normal" variants={TAIL_VARIANTS}/>
+        </svg>
+      </div>);
+});
+GithubIcon.displayName = "GithubIcon";
+export { GithubIcon };

frontend/src/hooks/useApiStatus.ts

@@ -0,0 +1,16 @@
+import { useEffect, useState } from "react";
+import { API_SOURCES, checkAllApiStatuses, ensureApiStatusCheckStarted, getApiStatusState, subscribeApiStatus, } from "@/lib/api-status";
+export function useApiStatus() {
+    const [state, setState] = useState(getApiStatusState);
+    useEffect(() => {
+        ensureApiStatusCheckStarted();
+        return subscribeApiStatus(() => {
+            setState(getApiStatusState());
+        });
+    }, []);
+    return {
+        ...state,
+        sources: API_SOURCES,
+        refreshAll: checkAllApiStatuses,
+    };
+}

frontend/src/hooks/useAudioAnalysis.ts

@@ -1,147 +1,550 @@
-import { useState, useCallback, useEffect } from "react";
-import { AnalyzeTrack } from "../../wailsjs/go/main/App";
+import { useState, useCallback, useRef, useEffect, type MutableRefObject } from "react";
 import type { AnalysisResult } from "@/types/api";
 import { logger } from "@/lib/logger";
 import { toastWithSound as toast } from "@/lib/toast-with-sound";
-import { setSpectrumCache, getSpectrumCache, clearSpectrumCache } from "@/lib/spectrum-cache";
-const STORAGE_KEY = "spotiflac_audio_analysis_state";
+import { analyzeAudioArrayBuffer, analyzeAudioFile, analyzeDecodedSamples, analyzeSpectrumFromSamples, parseAudioMetadataFromInput, pcm16MonoArrayBufferToFloat32Samples, type AnalysisProgress, type FrontendAnalysisPayload, type ParsedAudioMetadata, } from "@/lib/flac-analysis";
+import { loadAudioAnalysisPreferences } from "@/lib/audio-analysis-preferences";
+type WindowFunction = "hann" | "hamming" | "blackman" | "rectangular";
+function toWindowFunction(value: string): WindowFunction {
+    switch (value) {
+        case "hamming":
+        case "blackman":
+        case "rectangular":
+            return value;
+        case "hann":
+        default:
+            return "hann";
+    }
+}
+function fileNameFromPath(filePath: string): string {
+    const parts = filePath.split(/[/\\]/);
+    return parts[parts.length - 1] || filePath;
+}
+function nextUiTick(): Promise<void> {
+    return new Promise((resolve) => setTimeout(resolve, 0));
+}
+async function base64ToArrayBuffer(base64: string, shouldCancel?: () => boolean): Promise<ArrayBuffer> {
+    const clean = base64.includes(",") ? base64.split(",")[1] : base64;
+    const padding = clean.endsWith("==") ? 2 : clean.endsWith("=") ? 1 : 0;
+    const outputLength = Math.floor((clean.length * 3) / 4) - padding;
+    const bytes = new Uint8Array(outputLength);
+    const chunkSize = 4 * 16384;
+    let writeOffset = 0;
+    for (let offset = 0; offset < clean.length; offset += chunkSize) {
+        if (shouldCancel?.()) {
+            throw new Error("Analysis cancelled");
+        }
+        const chunk = clean.slice(offset, Math.min(clean.length, offset + chunkSize));
+        const binary = atob(chunk);
+        for (let i = 0; i < binary.length; i++) {
+            bytes[writeOffset++] = binary.charCodeAt(i);
+        }
+        if ((offset / chunkSize) % 4 === 0) {
+            await nextUiTick();
+        }
+    }
+    return bytes.buffer;
+}
+let sessionResult: AnalysisResult | null = null;
+let sessionSelectedFilePath = "";
+let sessionError: string | null = null;
+let sessionSamples: Float32Array | null = null;
+let sessionCurrentAnalysisKey = "";
+const sessionSamplesByKey = new Map<string, Float32Array>();
+interface ProgressState {
+    percent: number;
+    message: string;
+}
+const DEFAULT_PROGRESS_STATE: ProgressState = {
+    percent: 0,
+    message: "Preparing analysis...",
+};
+interface CancelToken {
+    cancelled: boolean;
+}
+interface AnalyzeExecutionOptions {
+    analysisKey?: string;
+    displayPath?: string;
+    suppressToast?: boolean;
+}
+export interface AnalyzeExecutionOutcome {
+    result: AnalysisResult | null;
+    error: string | null;
+    cancelled: boolean;
+}
+interface WailsWindow extends Window {
+    go?: {
+        main?: {
+            App?: {
+                ReadFileAsBase64?: (path: string) => Promise<string>;
+                DecodeAudioForAnalysis?: (path: string) => Promise<BackendAnalysisDecodeResponse>;
+            };
+        };
+    };
+}
+interface BackendAnalysisDecodeResponse {
+    pcm_base64: string;
+    sample_rate: number;
+    channels: number;
+    bits_per_sample: number;
+    duration: number;
+    bitrate_kbps?: number;
+    bit_depth?: string;
+}
+function cancelToken(tokenRef: MutableRefObject<CancelToken | null>): void {
+    if (tokenRef.current) {
+        tokenRef.current.cancelled = true;
+        tokenRef.current = null;
+    }
+}
+function createToken(tokenRef: MutableRefObject<CancelToken | null>): CancelToken {
+    cancelToken(tokenRef);
+    const token: CancelToken = { cancelled: false };
+    tokenRef.current = token;
+    return token;
+}
+function isCancelledError(error: unknown): boolean {
+    return error instanceof Error && error.message === "Analysis cancelled";
+}
+function toProgressState(progress: AnalysisProgress): ProgressState {
+    return {
+        percent: Math.round(Math.max(0, Math.min(100, progress.percent))),
+        message: progress.message,
+    };
+}
+function isDecodeFailure(error: unknown): boolean {
+    return error instanceof Error && /decode/i.test(error.message);
+}
+function mergeBackendDecodedMetadata(parsed: ParsedAudioMetadata, decoded: BackendAnalysisDecodeResponse): ParsedAudioMetadata {
+    const sampleRate = decoded.sample_rate > 0 ? decoded.sample_rate : parsed.sampleRate;
+    const bitsPerSample = decoded.bits_per_sample > 0 ? decoded.bits_per_sample : parsed.bitsPerSample;
+    const duration = decoded.duration > 0 ? decoded.duration : parsed.duration;
+    return {
+        ...parsed,
+        sampleRate,
+        channels: decoded.channels > 0 ? decoded.channels : parsed.channels,
+        bitsPerSample,
+        totalSamples: duration > 0 && sampleRate > 0 ? Math.floor(duration * sampleRate) : parsed.totalSamples,
+        duration,
+        bitrateKbps: decoded.bitrate_kbps ?? parsed.bitrateKbps,
+    };
+}
 export function useAudioAnalysis() {
     const [analyzing, setAnalyzing] = useState(false);
-    const [result, setResult] = useState<AnalysisResult | null>(() => {
-        try {
-            const saved = sessionStorage.getItem(STORAGE_KEY);
-            if (saved) {
-                const parsed = JSON.parse(saved);
-                if (parsed.filePath && parsed.result) {
-                    return {
-                        ...parsed.result,
-                        spectrum: undefined,
-                    };
-                }
-            }
-        }
-        catch (err) {
-            console.error("Failed to load saved analysis state:", err);
-        }
-        return null;
-    });
-    const [selectedFilePath, setSelectedFilePath] = useState<string>(() => {
-        try {
-            const saved = sessionStorage.getItem(STORAGE_KEY);
-            if (saved) {
-                const parsed = JSON.parse(saved);
-                return parsed.filePath || "";
-            }
-        }
-        catch (err) {
-        }
-        return "";
-    });
-    const [error, setError] = useState<string | null>(null);
-    const [spectrumLoading, setSpectrumLoading] = useState(() => {
-        try {
-            const saved = sessionStorage.getItem(STORAGE_KEY);
-            if (saved) {
-                const parsed = JSON.parse(saved);
-                if (parsed.filePath && parsed.result) {
-                    return true;
-                }
-            }
-        }
-        catch (err) {
-        }
-        return false;
-    });
-    const analyzeFile = useCallback(async (filePath: string) => {
-        if (!filePath) {
-            setError("No file path provided");
-            return null;
+    const [analysisProgress, setAnalysisProgress] = useState<ProgressState>(DEFAULT_PROGRESS_STATE);
+    const [result, setResult] = useState<AnalysisResult | null>(() => sessionResult);
+    const [selectedFilePath, setSelectedFilePath] = useState(() => sessionSelectedFilePath);
+    const [error, setError] = useState<string | null>(() => sessionError);
+    const [spectrumLoading, setSpectrumLoading] = useState(false);
+    const [spectrumProgress, setSpectrumProgress] = useState<ProgressState>(DEFAULT_PROGRESS_STATE);
+    const samplesRef = useRef<Float32Array | null>(sessionSamples);
+    const currentAnalysisKeyRef = useRef(sessionCurrentAnalysisKey);
+    const analysisTokenRef = useRef<CancelToken | null>(null);
+    const spectrumTokenRef = useRef<CancelToken | null>(null);
+    useEffect(() => {
+        return () => {
+            cancelToken(analysisTokenRef);
+            cancelToken(spectrumTokenRef);
+        };
+    }, []);
+    const setResultWithSession = useCallback((next: AnalysisResult | null) => {
+        sessionResult = next;
+        setResult(next);
+    }, []);
+    const setSelectedFilePathWithSession = useCallback((next: string) => {
+        sessionSelectedFilePath = next;
+        setSelectedFilePath(next);
+    }, []);
+    const setErrorWithSession = useCallback((next: string | null) => {
+        sessionError = next;
+        setError(next);
+    }, []);
+    const setCurrentAnalysisKey = useCallback((analysisKey: string) => {
+        currentAnalysisKeyRef.current = analysisKey;
+        sessionCurrentAnalysisKey = analysisKey;
+    }, []);
+    const storeSuccessfulAnalysis = useCallback((analysisKey: string, displayPath: string, payload: FrontendAnalysisPayload) => {
+        sessionSamplesByKey.set(analysisKey, payload.samples);
+        samplesRef.current = payload.samples;
+        sessionSamples = payload.samples;
+        setCurrentAnalysisKey(analysisKey);
+        setResultWithSession(payload.result);
+        setSelectedFilePathWithSession(displayPath);
+        setErrorWithSession(null);
+    }, [setCurrentAnalysisKey, setErrorWithSession, setResultWithSession, setSelectedFilePathWithSession]);
+    const analyzeFile = useCallback(async (file: File, options?: AnalyzeExecutionOptions): Promise<AnalyzeExecutionOutcome> => {
+        if (!file) {
+            const errorMessage = "No file provided";
+            setErrorWithSession(errorMessage);
+            return {
+                result: null,
+                error: errorMessage,
+                cancelled: false,
+            };
         }
+        const token = createToken(analysisTokenRef);
+        const analysisKey = options?.analysisKey || file.name;
+        const displayPath = options?.displayPath || file.name;
+        cancelToken(spectrumTokenRef);
         setAnalyzing(true);
-        setError(null);
-        setResult(null);
-        setSelectedFilePath(filePath);
+        setAnalysisProgress({
+            percent: 1,
+            message: "Preparing file...",
+        });
+        setErrorWithSession(null);
+        setResultWithSession(null);
+        setSelectedFilePathWithSession(displayPath);
+        setCurrentAnalysisKey(analysisKey);
         try {
-            logger.info(`Analyzing audio file: ${filePath}`);
-            const startTime = Date.now();
-            const response = await AnalyzeTrack(filePath);
-            const analysisResult: AnalysisResult = JSON.parse(response);
-            const elapsed = ((Date.now() - startTime) / 1000).toFixed(2);
+            logger.info(`Analyzing audio file (frontend): ${displayPath}`);
+            const start = Date.now();
+            const prefs = loadAudioAnalysisPreferences();
+            const payload = await analyzeAudioFile(file, {
+                fftSize: prefs.fftSize,
+                windowFunction: prefs.windowFunction,
+            }, (progress) => {
+                if (token.cancelled) {
+                    return;
+                }
+                setAnalysisProgress(toProgressState(progress));
+            }, () => token.cancelled);
+            if (token.cancelled) {
+                return {
+                    result: null,
+                    error: null,
+                    cancelled: true,
+                };
+            }
+            storeSuccessfulAnalysis(analysisKey, displayPath, payload);
+            const elapsed = ((Date.now() - start) / 1000).toFixed(2);
             logger.success(`Audio analysis completed in ${elapsed}s`);
-            if (analysisResult.spectrum) {
-                setSpectrumCache(filePath, analysisResult.spectrum);
-            }
-            const { spectrum, ...detailResult } = analysisResult;
-            try {
-                sessionStorage.setItem(STORAGE_KEY, JSON.stringify({
-                    filePath,
-                    result: detailResult,
-                }));
-            }
-            catch (err) {
-                console.error("Failed to save analysis state:", err);
-            }
-            setResult(analysisResult);
-            setSpectrumLoading(false);
-            return analysisResult;
+            return {
+                result: payload.result,
+                error: null,
+                cancelled: false,
+            };
         }
         catch (err) {
+            if (isCancelledError(err)) {
+                return {
+                    result: null,
+                    error: null,
+                    cancelled: true,
+                };
+            }
             const errorMessage = err instanceof Error ? err.message : "Failed to analyze audio file";
             logger.error(`Analysis error: ${errorMessage}`);
-            setError(errorMessage);
-            toast.error("Audio Analysis Failed", {
+            setErrorWithSession(errorMessage);
+            setAnalysisProgress({
+                percent: 0,
+                message: "Analysis failed",
+            });
+            if (!options?.suppressToast) {
+                toast.error("Audio Analysis Failed", {
+                    description: errorMessage,
+                });
+            }
+            return {
+                result: null,
+                error: errorMessage,
+                cancelled: false,
+            };
+        }
+        finally {
+            if (analysisTokenRef.current === token) {
+                analysisTokenRef.current = null;
+                setAnalyzing(false);
+            }
+        }
+    }, [setCurrentAnalysisKey, setErrorWithSession, setResultWithSession, setSelectedFilePathWithSession, storeSuccessfulAnalysis]);
+    const analyzeFilePath = useCallback(async (filePath: string, options?: AnalyzeExecutionOptions): Promise<AnalyzeExecutionOutcome> => {
+        if (!filePath) {
+            const errorMessage = "No file path provided";
+            setErrorWithSession(errorMessage);
+            return {
+                result: null,
+                error: errorMessage,
+                cancelled: false,
+            };
+        }
+        const token = createToken(analysisTokenRef);
+        const analysisKey = options?.analysisKey || filePath;
+        const displayPath = options?.displayPath || filePath;
+        cancelToken(spectrumTokenRef);
+        setAnalyzing(true);
+        setAnalysisProgress({
+            percent: 1,
+            message: "Reading file from disk...",
+        });
+        setErrorWithSession(null);
+        setResultWithSession(null);
+        setSelectedFilePathWithSession(displayPath);
+        setCurrentAnalysisKey(analysisKey);
+        try {
+            logger.info(`Analyzing audio file (frontend from path): ${filePath}`);
+            const start = Date.now();
+            const prefs = loadAudioAnalysisPreferences();
+            const readFileAsBase64 = (window as WailsWindow).go?.main?.App?.ReadFileAsBase64;
+            if (!readFileAsBase64) {
+                throw new Error("ReadFileAsBase64 backend method is unavailable");
+            }
+            let base64Data = await readFileAsBase64(filePath);
+            if (token.cancelled) {
+                return {
+                    result: null,
+                    error: null,
+                    cancelled: true,
+                };
+            }
+            setAnalysisProgress({
+                percent: 10,
+                message: "File loaded",
+            });
+            const arrayBuffer = await base64ToArrayBuffer(base64Data, () => token.cancelled);
+            base64Data = "";
+            if (token.cancelled) {
+                return {
+                    result: null,
+                    error: null,
+                    cancelled: true,
+                };
+            }
+            setAnalysisProgress({
+                percent: 15,
+                message: "Preparing audio buffer...",
+            });
+            const fileName = fileNameFromPath(filePath);
+            const input = {
+                fileName,
+                fileSize: arrayBuffer.byteLength,
+                arrayBuffer,
+            };
+            const analysisParams = {
+                fftSize: prefs.fftSize,
+                windowFunction: prefs.windowFunction,
+            } as const;
+            const updateProgress = (progress: AnalysisProgress) => {
+                if (token.cancelled) {
+                    return;
+                }
+                const mappedPercent = 10 + (progress.percent * 0.9);
+                setAnalysisProgress({
+                    percent: Math.round(Math.max(0, Math.min(100, mappedPercent))),
+                    message: progress.message,
+                });
+            };
+            let payload: FrontendAnalysisPayload;
+            try {
+                payload = await analyzeAudioArrayBuffer(input, analysisParams, updateProgress, () => token.cancelled);
+            }
+            catch (err) {
+                if (!isDecodeFailure(err)) {
+                    throw err;
+                }
+                const decodeAudioForAnalysis = (window as WailsWindow).go?.main?.App?.DecodeAudioForAnalysis;
+                if (!decodeAudioForAnalysis) {
+                    throw err;
+                }
+                logger.warning(`Browser decoder failed for ${fileName}; trying FFmpeg fallback`);
+                setAnalysisProgress({
+                    percent: 18,
+                    message: "Browser decoder failed, trying FFmpeg fallback...",
+                });
+                const decoded = await decodeAudioForAnalysis(filePath);
+                if (token.cancelled) {
+                    return {
+                        result: null,
+                        error: null,
+                        cancelled: true,
+                    };
+                }
+                setAnalysisProgress({
+                    percent: 24,
+                    message: "Decoding audio with FFmpeg...",
+                });
+                const pcmBase64 = decoded.pcm_base64 || "";
+                if (!pcmBase64) {
+                    throw new Error("FFmpeg analysis decode returned no PCM data");
+                }
+                const pcmBuffer = await base64ToArrayBuffer(pcmBase64, () => token.cancelled);
+                if (token.cancelled) {
+                    return {
+                        result: null,
+                        error: null,
+                        cancelled: true,
+                    };
+                }
+                const parsedMetadata = parseAudioMetadataFromInput(input);
+                const mergedMetadata = mergeBackendDecodedMetadata(parsedMetadata, decoded);
+                const samples = pcm16MonoArrayBufferToFloat32Samples(pcmBuffer);
+                payload = await analyzeDecodedSamples(input, mergedMetadata, samples, analysisParams, updateProgress, () => token.cancelled, mergedMetadata.duration);
+            }
+            if (token.cancelled) {
+                return {
+                    result: null,
+                    error: null,
+                    cancelled: true,
+                };
+            }
+            storeSuccessfulAnalysis(analysisKey, displayPath, payload);
+            const elapsed = ((Date.now() - start) / 1000).toFixed(2);
+            logger.success(`Audio analysis completed in ${elapsed}s`);
+            return {
+                result: payload.result,
+                error: null,
+                cancelled: false,
+            };
+        }
+        catch (err) {
+            if (isCancelledError(err)) {
+                return {
+                    result: null,
+                    error: null,
+                    cancelled: true,
+                };
+            }
+            const errorMessage = err instanceof Error ? err.message : "Failed to analyze audio file";
+            logger.error(`Analysis error: ${errorMessage}`);
+            setErrorWithSession(errorMessage);
+            setAnalysisProgress({
+                percent: 0,
+                message: "Analysis failed",
+            });
+            if (!options?.suppressToast) {
+                toast.error("Audio Analysis Failed", {
+                    description: errorMessage,
+                });
+            }
+            return {
+                result: null,
+                error: errorMessage,
+                cancelled: false,
+            };
+        }
+        finally {
+            if (analysisTokenRef.current === token) {
+                analysisTokenRef.current = null;
+                setAnalyzing(false);
+            }
+        }
+    }, [setCurrentAnalysisKey, setErrorWithSession, setResultWithSession, setSelectedFilePathWithSession, storeSuccessfulAnalysis]);
+    const loadStoredAnalysis = useCallback((analysisKey: string, nextResult: AnalysisResult, displayPath: string) => {
+        setCurrentAnalysisKey(analysisKey);
+        samplesRef.current = sessionSamplesByKey.get(analysisKey) ?? null;
+        sessionSamples = samplesRef.current;
+        setResultWithSession(nextResult);
+        setSelectedFilePathWithSession(displayPath);
+        setErrorWithSession(null);
+    }, [setCurrentAnalysisKey, setErrorWithSession, setResultWithSession, setSelectedFilePathWithSession]);
+    const clearStoredAnalysis = useCallback((analysisKey?: string) => {
+        if (analysisKey) {
+            sessionSamplesByKey.delete(analysisKey);
+            if (currentAnalysisKeyRef.current === analysisKey) {
+                currentAnalysisKeyRef.current = "";
+                sessionCurrentAnalysisKey = "";
+                samplesRef.current = null;
+                sessionSamples = null;
+            }
+            return;
+        }
+        sessionSamplesByKey.clear();
+        currentAnalysisKeyRef.current = "";
+        sessionCurrentAnalysisKey = "";
+        samplesRef.current = null;
+        sessionSamples = null;
+    }, []);
+    const cancelAnalysis = useCallback(() => {
+        cancelToken(analysisTokenRef);
+        setAnalyzing(false);
+        setAnalysisProgress((prev) => prev.percent > 0
+            ? {
+                percent: prev.percent,
+                message: "Analysis stopped",
+            }
+            : DEFAULT_PROGRESS_STATE);
+    }, []);
+    const reAnalyzeSpectrum = useCallback(async (fftSize: number, windowFunction: string) => {
+        if (!result || !samplesRef.current) {
+            return null;
+        }
+        const token = createToken(spectrumTokenRef);
+        setSpectrumLoading(true);
+        setSpectrumProgress({
+            percent: 0,
+            message: "Preparing FFT...",
+        });
+        try {
+            await new Promise<void>((resolve) => setTimeout(resolve, 0));
+            const spectrum = await analyzeSpectrumFromSamples(samplesRef.current, result.sample_rate, {
+                fftSize,
+                windowFunction: toWindowFunction(windowFunction),
+            }, (progress) => {
+                if (token.cancelled) {
+                    return;
+                }
+                setSpectrumProgress(toProgressState(progress));
+            }, () => token.cancelled);
+            if (token.cancelled) {
+                return null;
+            }
+            const nextResult = {
+                ...result,
+                spectrum,
+            };
+            setResultWithSession(nextResult);
+            return nextResult;
+        }
+        catch (err) {
+            if (isCancelledError(err)) {
+                return null;
+            }
+            const errorMessage = err instanceof Error ? err.message : "Failed to re-analyze spectrum";
+            logger.error(`Spectrum re-analysis error: ${errorMessage}`);
+            setSpectrumProgress({
+                percent: 0,
+                message: "Spectrum analysis failed",
+            });
+            toast.error("Spectrum Analysis Failed", {
                 description: errorMessage,
             });
             return null;
         }
         finally {
-            setAnalyzing(false);
-        }
-    }, []);
-    const clearResult = useCallback(() => {
-        setResult(null);
-        setError(null);
-        setSelectedFilePath("");
-        try {
-            sessionStorage.removeItem(STORAGE_KEY);
-        }
-        catch (err) {
-        }
-        clearSpectrumCache();
-    }, []);
-    useEffect(() => {
-        if (!result || !selectedFilePath || result.spectrum || !spectrumLoading) {
-            return;
-        }
-        let rafId: number;
-        const loadSpectrum = () => {
-            rafId = requestAnimationFrame(() => {
-                const cachedSpectrum = getSpectrumCache(selectedFilePath);
-                if (cachedSpectrum) {
-                    setResult(prev => prev ? { ...prev, spectrum: cachedSpectrum } : null);
-                    setSpectrumLoading(false);
-                }
-                else {
-                    setSpectrumLoading(false);
-                }
-            });
-        };
-        requestAnimationFrame(() => {
-            requestAnimationFrame(loadSpectrum);
-        });
-        return () => {
-            if (rafId) {
-                cancelAnimationFrame(rafId);
+            if (spectrumTokenRef.current === token) {
+                spectrumTokenRef.current = null;
+                setSpectrumLoading(false);
             }
-        };
-    }, [result, selectedFilePath, spectrumLoading]);
+        }
+    }, [result, setResultWithSession]);
+    const clearResult = useCallback(() => {
+        cancelToken(analysisTokenRef);
+        cancelToken(spectrumTokenRef);
+        setAnalyzing(false);
+        setResultWithSession(null);
+        setErrorWithSession(null);
+        setSelectedFilePathWithSession("");
+        setSpectrumLoading(false);
+        setAnalysisProgress(DEFAULT_PROGRESS_STATE);
+        setSpectrumProgress(DEFAULT_PROGRESS_STATE);
+        currentAnalysisKeyRef.current = "";
+        sessionCurrentAnalysisKey = "";
+        samplesRef.current = null;
+        sessionSamples = null;
+    }, [setErrorWithSession, setResultWithSession, setSelectedFilePathWithSession]);
     return {
         analyzing,
+        analysisProgress,
         result,
         error,
         selectedFilePath,
         spectrumLoading,
+        spectrumProgress,
         analyzeFile,
+        analyzeFilePath,
+        cancelAnalysis,
+        loadStoredAnalysis,
+        clearStoredAnalysis,
+        reAnalyzeSpectrum,
         clearResult,
     };
 }

frontend/src/hooks/useAvailability.ts

@@ -2,6 +2,7 @@ import { useState, useCallback } from "react";
 import { CheckTrackAvailability } from "../../wailsjs/go/main/App";
 import type { TrackAvailability } from "@/types/api";
 import { logger } from "@/lib/logger";
+import { CHECK_TIMEOUT_MS, withTimeout } from "@/lib/async-timeout";
 export function useAvailability() {
     const [checking, setChecking] = useState(false);
     const [checkingTrackId, setCheckingTrackId] = useState<string | null>(null);
@@ -20,7 +21,7 @@ export function useAvailability() {
         setError(null);
         try {
             logger.info(`Checking availability for track: ${spotifyId}`);
-            const response = await CheckTrackAvailability(spotifyId);
+            const response = await withTimeout(CheckTrackAvailability(spotifyId), CHECK_TIMEOUT_MS, `Availability check timed out after 10 seconds for ${spotifyId}`);
             const availability: TrackAvailability = JSON.parse(response);
             setAvailabilityMap((prev) => {
                 const newMap = new Map(prev);

frontend/src/hooks/useCover.ts

@@ -43,7 +43,7 @@ export function useCover() {
             };
             const folderTemplate = settings.folderTemplate || "";
             const useAlbumSubfolder = folderTemplate.includes("{album}") || folderTemplate.includes("{album_artist}") || folderTemplate.includes("{playlist}");
-            if (playlistName && (!isAlbum || !useAlbumSubfolder)) {
+            if (settings.createPlaylistFolder && playlistName && (!isAlbum || !useAlbumSubfolder)) {
                 outputDir = joinPath(os, outputDir, sanitizePath(playlistName.replace(/\//g, " "), os));
             }
             if (settings.folderTemplate) {
@@ -145,7 +145,7 @@ export function useCover() {
                 };
                 const folderTemplate = settings.folderTemplate || "";
                 const useAlbumSubfolder = folderTemplate.includes("{album}") || folderTemplate.includes("{album_artist}") || folderTemplate.includes("{playlist}");
-                if (playlistName && (!isAlbum || !useAlbumSubfolder)) {
+                if (settings.createPlaylistFolder && playlistName && (!isAlbum || !useAlbumSubfolder)) {
                     outputDir = joinPath(os, outputDir, sanitizePath(playlistName.replace(/\//g, " "), os));
                 }
                 if (settings.folderTemplate) {

frontend/src/hooks/useDownload.ts

@@ -306,54 +306,6 @@ export function useDownload(region: string) {
                         lastResponse = { success: false, error: String(err) };
                     }
                 }
-                else if (s === "deezer") {
-                    try {
-                        logger.debug(`trying deezer for: ${trackName} - ${artistName}`);
-                        const response = await downloadTrack({
-                            service: "deezer",
-                            query,
-                            track_name: trackName,
-                            artist_name: displayArtist,
-                            album_name: albumName,
-                            album_artist: displayAlbumArtist,
-                            release_date: finalReleaseDate || releaseDate,
-                            cover_url: coverUrl,
-                            output_dir: outputDir,
-                            filename_format: settings.filenameTemplate,
-                            track_number: settings.trackNumber,
-                            position,
-                            use_album_track_number: useAlbumTrackNumber,
-                            spotify_id: spotifyId,
-                            embed_lyrics: settings.embedLyrics,
-                            embed_max_quality_cover: settings.embedMaxQualityCover,
-                            duration: durationSeconds,
-                            item_id: itemID,
-                            audio_format: "flac",
-                            spotify_track_number: spotifyTrackNumber,
-                            spotify_disc_number: spotifyDiscNumber,
-                            spotify_total_tracks: spotifyTotalTracks,
-                            spotify_total_discs: spotifyTotalDiscs,
-                            copyright: copyright,
-                            publisher: publisher,
-                            use_first_artist_only: settings.useFirstArtistOnly,
-                            use_single_genre: settings.useSingleGenre,
-                            embed_genre: settings.embedGenre,
-                        });
-                        if (response.success) {
-                            logger.success(`deezer: ${trackName} - ${artistName}`);
-                            return response;
-                        }
-                        const errMsg = response.error || response.message || "Failed";
-                        fallbackErrors.push(`[Deezer] ${errMsg}`);
-                        lastResponse = response;
-                        logger.warning(`deezer failed, trying next...`);
-                    }
-                    catch (err) {
-                        logger.error(`deezer error: ${err}`);
-                        fallbackErrors.push(`[Deezer] ${String(err)}`);
-                        lastResponse = { success: false, error: String(err) };
-                    }
-                }
             }
             if (itemID) {
                 const { MarkDownloadItemFailed } = await import("../../wailsjs/go/main/App");
@@ -375,7 +327,7 @@ export function useDownload(region: string) {
         }
         logger.debug(`trying ${service} for: ${trackName} - ${artistName}`);
         const singleServiceResponse = await downloadTrack({
-            service: service as "tidal" | "qobuz" | "amazon" | "deezer",
+            service: service as "tidal" | "qobuz" | "amazon",
             query,
             track_name: trackName,
             artist_name: displayArtist,
@@ -632,54 +584,6 @@ export function useDownload(region: string) {
                         lastResponse = { success: false, error: String(err) };
                     }
                 }
-                else if (s === "deezer") {
-                    try {
-                        logger.debug(`trying deezer for: ${trackName} - ${artistName}`);
-                        const response = await downloadTrack({
-                            service: "deezer",
-                            query,
-                            track_name: trackName,
-                            artist_name: displayArtist,
-                            album_name: albumName,
-                            album_artist: displayAlbumArtist,
-                            release_date: finalReleaseDate || releaseDate,
-                            cover_url: coverUrl,
-                            output_dir: outputDir,
-                            filename_format: settings.filenameTemplate,
-                            track_number: settings.trackNumber,
-                            position: trackNumberForTemplate,
-                            use_album_track_number: useAlbumTrackNumber,
-                            spotify_id: spotifyId,
-                            embed_lyrics: settings.embedLyrics,
-                            embed_max_quality_cover: settings.embedMaxQualityCover,
-                            duration: durationSeconds,
-                            item_id: itemID,
-                            audio_format: "flac",
-                            spotify_track_number: spotifyTrackNumber,
-                            spotify_disc_number: spotifyDiscNumber,
-                            spotify_total_tracks: spotifyTotalTracks,
-                            spotify_total_discs: spotifyTotalDiscs,
-                            copyright: copyright,
-                            publisher: publisher,
-                            use_first_artist_only: settings.useFirstArtistOnly,
-                            use_single_genre: settings.useSingleGenre,
-                            embed_genre: settings.embedGenre,
-                        });
-                        if (response.success) {
-                            logger.success(`deezer: ${trackName} - ${artistName}`);
-                            return response;
-                        }
-                        const errMsg = response.error || response.message || "Failed";
-                        fallbackErrors.push(`[Deezer] ${errMsg}`);
-                        lastResponse = response;
-                        logger.warning(`deezer failed, trying next...`);
-                    }
-                    catch (err) {
-                        logger.error(`deezer error: ${err}`);
-                        fallbackErrors.push(`[Deezer] ${String(err)}`);
-                        lastResponse = { success: false, error: String(err) };
-                    }
-                }
             }
             if (!lastResponse.success && itemID) {
                 const { MarkDownloadItemFailed } = await import("../../wailsjs/go/main/App");
@@ -696,11 +600,8 @@ export function useDownload(region: string) {
         else if (service === "qobuz") {
             audioFormat = settings.qobuzQuality || "6";
         }
-        else if (service === "deezer") {
-            audioFormat = "flac";
-        }
         const singleServiceResponse = await downloadTrack({
-            service: service as "tidal" | "qobuz" | "amazon" | "deezer",
+            service: service as "tidal" | "qobuz" | "amazon",
             query,
             track_name: trackName,
             artist_name: displayArtist,

frontend/src/hooks/useLyrics.ts

@@ -40,7 +40,7 @@ export function useLyrics() {
             };
             const folderTemplate = settings.folderTemplate || "";
             const useAlbumSubfolder = folderTemplate.includes("{album}") || folderTemplate.includes("{album_artist}") || folderTemplate.includes("{playlist}");
-            if (playlistName && (!isAlbum || !useAlbumSubfolder)) {
+            if (settings.createPlaylistFolder && playlistName && (!isAlbum || !useAlbumSubfolder)) {
                 outputDir = joinPath(os, outputDir, sanitizePath(playlistName.replace(/\//g, " "), os));
             }
             if (settings.folderTemplate) {
@@ -141,7 +141,7 @@ export function useLyrics() {
                 };
                 const folderTemplate = settings.folderTemplate || "";
                 const useAlbumSubfolder = folderTemplate.includes("{album}") || folderTemplate.includes("{album_artist}") || folderTemplate.includes("{playlist}");
-                if (playlistName && (!isAlbum || !useAlbumSubfolder)) {
+                if (settings.createPlaylistFolder && playlistName && (!isAlbum || !useAlbumSubfolder)) {
                     outputDir = joinPath(os, outputDir, sanitizePath(playlistName.replace(/\//g, " "), os));
                 }
                 if (settings.folderTemplate) {

frontend/src/hooks/useMetadata.ts

@@ -1,13 +1,17 @@
-import { useState } from "react";
+import { useEffect, useRef, useState } from "react";
 import { getSettings } from "@/lib/settings";
 import { fetchSpotifyMetadata } from "@/lib/api";
 import { toastWithSound as toast } from "@/lib/toast-with-sound";
 import { logger } from "@/lib/logger";
 import { AddFetchHistory } from "../../wailsjs/go/main/App";
+import { EventsOff, EventsOn } from "../../wailsjs/runtime/runtime";
 import type { SpotifyMetadataResponse } from "@/types/api";
 export function useMetadata() {
     const [loading, setLoading] = useState(false);
     const [metadata, setMetadata] = useState<SpotifyMetadataResponse | null>(null);
+    const loadingToastId = useRef<string | number | null>(null);
+    const fetchedCount = useRef(0);
+    const currentName = useRef("");
     const [showApiModal, setShowApiModal] = useState(false);
     const [showAlbumDialog, setShowAlbumDialog] = useState(false);
     const [selectedAlbum, setSelectedAlbum] = useState<{
@@ -16,6 +20,73 @@ export function useMetadata() {
         external_urls: string;
     } | null>(null);
     const [pendingArtistName, setPendingArtistName] = useState<string | null>(null);
+    useEffect(() => {
+        if (loading) {
+            fetchedCount.current = 0;
+            currentName.current = "";
+            loadingToastId.current = toast.silentInfo("fetching metadata...", {
+                duration: Infinity,
+                description: "please wait while we retrieve the information"
+            });
+            return;
+        }
+        if (loadingToastId.current) {
+            toast.dismiss(loadingToastId.current);
+            loadingToastId.current = null;
+        }
+    }, [loading]);
+    useEffect(() => {
+        const handler = (data: any) => {
+            if (!data) {
+                return;
+            }
+            if (Array.isArray(data)) {
+                fetchedCount.current += data.length;
+                if (loadingToastId.current && currentName.current) {
+                    toast.silentInfo(`fetching tracks for ${currentName.current.toLowerCase()}...`, {
+                        id: loadingToastId.current,
+                        description: `${fetchedCount.current.toLocaleString()} tracks fetched`
+                    });
+                }
+            }
+            else {
+                const baseInfo = data;
+                const name = "artist_info" in baseInfo ? baseInfo.artist_info.name :
+                    "album_info" in baseInfo ? baseInfo.album_info.name :
+                        "playlist_info" in baseInfo ? (baseInfo.playlist_info.name || baseInfo.playlist_info.owner.name) : "";
+                if (name) {
+                    currentName.current = name;
+                    if (loadingToastId.current) {
+                        toast.silentInfo(`fetching tracks for ${name.toLowerCase()}...`, {
+                            id: loadingToastId.current,
+                            description: `${fetchedCount.current.toLocaleString()} tracks fetched`
+                        });
+                    }
+                }
+            }
+            setMetadata(prev => {
+                if (Array.isArray(data)) {
+                    if (!prev || !("track_list" in prev)) {
+                        return prev;
+                    }
+                    return {
+                        ...prev,
+                        track_list: [...prev.track_list, ...data]
+                    };
+                }
+                if (prev && "track_list" in prev && prev.track_list.length > 0) {
+                    return prev;
+                }
+                const baseInfo = data;
+                if (!("track_list" in baseInfo)) {
+                    baseInfo.track_list = [];
+                }
+                return baseInfo;
+            });
+        };
+        EventsOn("metadata-stream", handler);
+        return () => EventsOff("metadata-stream");
+    }, []);
     const getUrlType = (url: string): string => {
         if (url.includes("/track/"))
             return "track";

frontend/src/hooks/usePreview.ts

@@ -1,5 +1,6 @@
 import { useState, useEffect } from "react";
 import { GetPreviewURL } from "@/../wailsjs/go/main/App";
+import { SPOTIFY_PREVIEW_VOLUME } from "@/lib/preview";
 import { toast } from "sonner";
 export function usePreview() {
     const [loadingPreview, setLoadingPreview] = useState<string | null>(null);
@@ -38,6 +39,7 @@ export function usePreview() {
                 return;
             }
             const audio = new Audio(previewURL);
+            audio.volume = SPOTIFY_PREVIEW_VOLUME;
             audio.addEventListener("loadeddata", () => {
                 setLoadingPreview(null);
                 setPlayingTrack(trackId);

frontend/src/lib/api-status.ts

@@ -0,0 +1,111 @@
+import { CheckAPIStatus } from "../../wailsjs/go/main/App";
+import { CHECK_TIMEOUT_MS, withTimeout } from "@/lib/async-timeout";
+export type ApiCheckStatus = "checking" | "online" | "offline" | "idle";
+export interface ApiSource {
+    id: string;
+    type: string;
+    name: string;
+    url: string;
+}
+export const API_SOURCES: ApiSource[] = [
+    { id: "tidal1", type: "tidal", name: "Tidal A", url: "https://hifi-one.spotisaver.net" },
+    { id: "tidal2", type: "tidal", name: "Tidal B", url: "https://hifi-two.spotisaver.net" },
+    { id: "tidal3", type: "tidal", name: "Tidal C", url: "https://eu-central.monochrome.tf" },
+    { id: "tidal4", type: "tidal", name: "Tidal D", url: "https://us-west.monochrome.tf" },
+    { id: "tidal5", type: "tidal", name: "Tidal E", url: "https://api.monochrome.tf" },
+    { id: "tidal6", type: "tidal", name: "Tidal F", url: "https://monochrome-api.samidy.com" },
+    { id: "tidal7", type: "tidal", name: "Tidal G", url: "https://tidal.kinoplus.online" },
+    { id: "qobuz1", type: "qobuz", name: "Qobuz A", url: "https://dab.yeet.su" },
+    { id: "qobuz2", type: "qobuz", name: "Qobuz B", url: "https://dabmusic.xyz" },
+    { id: "qobuz3", type: "qbz", name: "Qobuz C", url: "https://qbz.afkarxyz.qzz.io" },
+    { id: "amazon1", type: "amazon", name: "Amazon Music", url: "https://amzn.afkarxyz.qzz.io" },
+];
+type ApiStatusState = {
+    isCheckingAll: boolean;
+    statuses: Record<string, ApiCheckStatus>;
+};
+let apiStatusState: ApiStatusState = {
+    isCheckingAll: false,
+    statuses: {},
+};
+let activeCheckAll: Promise<void> | null = null;
+const listeners = new Set<() => void>();
+function emitApiStatusChange() {
+    for (const listener of listeners) {
+        listener();
+    }
+}
+function setApiStatusState(updater: (current: ApiStatusState) => ApiStatusState) {
+    apiStatusState = updater(apiStatusState);
+    emitApiStatusChange();
+}
+async function checkSingleApiStatus(source: ApiSource): Promise<void> {
+    setApiStatusState((current) => ({
+        ...current,
+        statuses: {
+            ...current.statuses,
+            [source.id]: "checking",
+        },
+    }));
+    try {
+        const isOnline = await withTimeout(CheckAPIStatus(source.type, source.url), CHECK_TIMEOUT_MS, `API status check timed out after 10 seconds for ${source.url}`);
+        setApiStatusState((current) => ({
+            ...current,
+            statuses: {
+                ...current.statuses,
+                [source.id]: isOnline ? "online" : "offline",
+            },
+        }));
+    }
+    catch {
+        setApiStatusState((current) => ({
+            ...current,
+            statuses: {
+                ...current.statuses,
+                [source.id]: "offline",
+            },
+        }));
+    }
+}
+export function getApiStatusState(): ApiStatusState {
+    return apiStatusState;
+}
+export function subscribeApiStatus(listener: () => void): () => void {
+    listeners.add(listener);
+    return () => {
+        listeners.delete(listener);
+    };
+}
+export function hasApiStatusResults(): boolean {
+    return API_SOURCES.some((source) => {
+        const status = apiStatusState.statuses[source.id];
+        return status === "online" || status === "offline";
+    });
+}
+export function ensureApiStatusCheckStarted(): void {
+    if (!activeCheckAll && !hasApiStatusResults()) {
+        void checkAllApiStatuses();
+    }
+}
+export async function checkAllApiStatuses(): Promise<void> {
+    if (activeCheckAll) {
+        return activeCheckAll;
+    }
+    activeCheckAll = (async () => {
+        setApiStatusState((current) => ({
+            ...current,
+            isCheckingAll: true,
+        }));
+        try {
+            await Promise.allSettled(API_SOURCES.map((source) => checkSingleApiStatus(source)));
+        }
+        finally {
+            setApiStatusState((current) => ({
+                ...current,
+                isCheckingAll: false,
+            }));
+            activeCheckAll = null;
+        }
+    })();
+    return activeCheckAll;
+}

frontend/src/lib/async-timeout.ts

@@ -0,0 +1,17 @@
+export const CHECK_TIMEOUT_MS = 10 * 1000;
+export function withTimeout<T>(promise: Promise<T>, timeoutMs: number = CHECK_TIMEOUT_MS, message: string = `Operation timed out after ${Math.round(timeoutMs / 1000)} seconds`): Promise<T> {
+    return new Promise<T>((resolve, reject) => {
+        const timer = window.setTimeout(() => {
+            reject(new Error(message));
+        }, timeoutMs);
+        promise
+            .then((value) => {
+            window.clearTimeout(timer);
+            resolve(value);
+        })
+            .catch((error) => {
+            window.clearTimeout(timer);
+            reject(error);
+        });
+    });
+}

frontend/src/lib/audio-analysis-preferences.ts

@@ -0,0 +1,63 @@
+export type AnalyzerColorScheme = "spek" | "viridis" | "hot" | "cool" | "grayscale";
+export type AnalyzerFreqScale = "linear" | "log2";
+export type AnalyzerWindowFunction = "hann" | "hamming" | "blackman" | "rectangular";
+export interface AudioAnalysisPreferences {
+    colorScheme: AnalyzerColorScheme;
+    freqScale: AnalyzerFreqScale;
+    fftSize: number;
+    windowFunction: AnalyzerWindowFunction;
+}
+const STORAGE_KEY = "spotiflac_audio_analysis_preferences";
+const DEFAULT_PREFERENCES: AudioAnalysisPreferences = {
+    colorScheme: "spek",
+    freqScale: "linear",
+    fftSize: 4096,
+    windowFunction: "hann",
+};
+const FFT_SIZE_SET = new Set([512, 1024, 2048, 4096]);
+function toColorScheme(value: unknown): AnalyzerColorScheme {
+    return value === "viridis" || value === "hot" || value === "cool" || value === "grayscale"
+        ? value
+        : "spek";
+}
+function toFreqScale(value: unknown): AnalyzerFreqScale {
+    return value === "log2" ? "log2" : "linear";
+}
+function toFFTSize(value: unknown): number {
+    const num = typeof value === "number" ? value : Number(value);
+    return FFT_SIZE_SET.has(num) ? num : 4096;
+}
+function toWindowFunction(value: unknown): AnalyzerWindowFunction {
+    return value === "hamming" || value === "blackman" || value === "rectangular"
+        ? value
+        : "hann";
+}
+export function loadAudioAnalysisPreferences(): AudioAnalysisPreferences {
+    try {
+        const raw = localStorage.getItem(STORAGE_KEY);
+        if (!raw)
+            return DEFAULT_PREFERENCES;
+        const parsed = JSON.parse(raw) as Partial<AudioAnalysisPreferences>;
+        return {
+            colorScheme: toColorScheme(parsed.colorScheme),
+            freqScale: toFreqScale(parsed.freqScale),
+            fftSize: toFFTSize(parsed.fftSize),
+            windowFunction: toWindowFunction(parsed.windowFunction),
+        };
+    }
+    catch {
+        return DEFAULT_PREFERENCES;
+    }
+}
+export function saveAudioAnalysisPreferences(preferences: AudioAnalysisPreferences): void {
+    try {
+        localStorage.setItem(STORAGE_KEY, JSON.stringify({
+            colorScheme: toColorScheme(preferences.colorScheme),
+            freqScale: toFreqScale(preferences.freqScale),
+            fftSize: toFFTSize(preferences.fftSize),
+            windowFunction: toWindowFunction(preferences.windowFunction),
+        }));
+    }
+    catch {
+    }
+}

frontend/src/lib/flac-analysis.ts

@@ -0,0 +1,747 @@
+import type { AnalysisResult, SpectrumData, TimeSlice } from "@/types/api";
+export interface SpectrumParams {
+    fftSize: number;
+    windowFunction: "hann" | "hamming" | "blackman" | "rectangular";
+}
+const DEFAULT_PARAMS: SpectrumParams = {
+    fftSize: 4096,
+    windowFunction: "hann",
+};
+const MAX_SPECTRUM_FRAMES = 2200;
+const METRICS_CHUNK_SIZE = 262144;
+const AAC_SAMPLE_RATES = [
+    96000, 88200, 64000, 48000, 44100, 32000, 24000,
+    22050, 16000, 12000, 11025, 8000, 7350,
+] as const;
+const MP4_CONTAINER_TYPES = new Set([
+    "moov", "trak", "mdia", "minf", "stbl", "edts", "dinf",
+    "udta", "ilst", "meta", "stsd", "wave",
+]);
+export type SupportedAudioFileType = "FLAC" | "MP3" | "M4A" | "AAC";
+export interface ParsedAudioMetadata {
+    fileType: SupportedAudioFileType;
+    sampleRate: number;
+    channels: number;
+    bitsPerSample: number;
+    totalSamples: number;
+    duration: number;
+    codecMode?: string;
+    bitrateKbps?: number;
+    totalFrames?: number;
+    codecVersion?: string;
+}
+interface Mp4BoxInfo {
+    offset: number;
+    size: number;
+    headerSize: number;
+    type: string;
+}
+export interface FrontendAnalysisPayload {
+    result: AnalysisResult;
+    samples: Float32Array;
+}
+export interface AudioArrayBufferInput {
+    fileName: string;
+    fileSize: number;
+    arrayBuffer: ArrayBuffer;
+}
+export type AnalysisPhase = "read" | "parse" | "decode" | "metrics" | "spectrum" | "finalize";
+export interface AnalysisProgress {
+    phase: AnalysisPhase;
+    percent: number;
+    message: string;
+}
+export type AnalysisProgressCallback = (progress: AnalysisProgress) => void;
+export type AnalysisCancelCheck = () => boolean;
+function reportProgress(callback: AnalysisProgressCallback | undefined, phase: AnalysisPhase, percent: number, message: string): void {
+    if (!callback)
+        return;
+    callback({
+        phase,
+        percent: Math.max(0, Math.min(100, percent)),
+        message,
+    });
+}
+function throwIfCancelled(cancelCheck?: AnalysisCancelCheck): void {
+    if (cancelCheck?.()) {
+        throw new Error("Analysis cancelled");
+    }
+}
+function nowMs(): number {
+    return typeof performance !== "undefined" ? performance.now() : Date.now();
+}
+function nextTick(): Promise<void> {
+    if (typeof requestAnimationFrame === "function") {
+        return new Promise((resolve) => requestAnimationFrame(() => resolve()));
+    }
+    return new Promise((resolve) => setTimeout(resolve, 0));
+}
+function readFourCC(view: DataView, offset: number): string {
+    return String.fromCharCode(view.getUint8(offset), view.getUint8(offset + 1), view.getUint8(offset + 2), view.getUint8(offset + 3));
+}
+function fileExtension(fileName: string): string {
+    const normalized = fileName.toLowerCase();
+    const dotIndex = normalized.lastIndexOf(".");
+    return dotIndex >= 0 ? normalized.slice(dotIndex) : "";
+}
+function detectAudioFileType(buffer: ArrayBuffer, fileName = ""): SupportedAudioFileType {
+    const view = new DataView(buffer);
+    if (view.byteLength >= 4 && view.getUint32(0, false) === 0x664c6143) {
+        return "FLAC";
+    }
+    if (view.byteLength >= 3 &&
+        view.getUint8(0) === 0x49 &&
+        view.getUint8(1) === 0x44 &&
+        view.getUint8(2) === 0x33) {
+        return "MP3";
+    }
+    if (view.byteLength >= 8 && readFourCC(view, 4) === "ftyp") {
+        return "M4A";
+    }
+    if (view.byteLength >= 2 && view.getUint8(0) === 0xff && (view.getUint8(1) & 0xf6) === 0xf0) {
+        return "AAC";
+    }
+    for (let offset = 0; offset < Math.min(4096, view.byteLength - 4); offset++) {
+        const header = view.getUint32(offset, false);
+        if ((header >>> 21) === 0x7ff) {
+            const version = (header >>> 19) & 0x03;
+            const layer = (header >>> 17) & 0x03;
+            const sampleRateIndex = (header >>> 10) & 0x03;
+            if (version !== 1 && layer !== 0 && sampleRateIndex !== 3) {
+                return "MP3";
+            }
+        }
+    }
+    switch (fileExtension(fileName)) {
+        case ".flac": return "FLAC";
+        case ".mp3": return "MP3";
+        case ".m4a":
+        case ".mp4": return "M4A";
+        case ".aac": return "AAC";
+        default: throw new Error(`Unsupported audio format: ${fileName || "unknown"}`);
+    }
+}
+function parseFlacMetadata(buffer: ArrayBuffer): ParsedAudioMetadata {
+    const data = new Uint8Array(buffer);
+    if (data.length < 4 || data[0] !== 0x66 || data[1] !== 0x4c || data[2] !== 0x61 || data[3] !== 0x43) {
+        throw new Error("Invalid FLAC file");
+    }
+    let offset = 4;
+    while (offset + 4 <= data.length) {
+        const blockHeader = data[offset];
+        const blockType = blockHeader & 0x7f;
+        const blockLength = (data[offset + 1] << 16) | (data[offset + 2] << 8) | data[offset + 3];
+        offset += 4;
+        if (offset + blockLength > data.length)
+            break;
+        if (blockType === 0 && blockLength >= 18) {
+            const streamInfo = data.subarray(offset, offset + blockLength);
+            const sampleRate = (streamInfo[10] << 12) | (streamInfo[11] << 4) | (streamInfo[12] >> 4);
+            const channels = ((streamInfo[12] >> 1) & 0x07) + 1;
+            const bitsPerSample = (((streamInfo[12] & 0x01) << 4) | (streamInfo[13] >> 4)) + 1;
+            const totalSamplesBig = (BigInt(streamInfo[13] & 0x0f) << 32n) |
+                (BigInt(streamInfo[14]) << 24n) |
+                (BigInt(streamInfo[15]) << 16n) |
+                (BigInt(streamInfo[16]) << 8n) |
+                BigInt(streamInfo[17]);
+            const totalSamples = Number(totalSamplesBig);
+            const duration = sampleRate > 0 && totalSamples > 0 ? totalSamples / sampleRate : 0;
+            return {
+                fileType: "FLAC",
+                sampleRate,
+                channels,
+                bitsPerSample,
+                totalSamples,
+                duration,
+            };
+        }
+        offset += blockLength;
+    }
+    throw new Error("FLAC STREAMINFO metadata not found");
+}
+function skipId3v2Tag(view: DataView): number {
+    if (view.byteLength < 10 ||
+        view.getUint8(0) !== 0x49 ||
+        view.getUint8(1) !== 0x44 ||
+        view.getUint8(2) !== 0x33) {
+        return 0;
+    }
+    const size = ((view.getUint8(6) & 0x7f) << 21) |
+        ((view.getUint8(7) & 0x7f) << 14) |
+        ((view.getUint8(8) & 0x7f) << 7) |
+        (view.getUint8(9) & 0x7f);
+    let offset = 10 + size;
+    if ((view.getUint8(5) & 0x10) !== 0) {
+        offset += 10;
+    }
+    return offset < view.byteLength ? offset : 0;
+}
+function getMp3Bitrate(version: number, layer: number, bitrateIndex: number): number {
+    const tables: Record<number, Record<number, number[]>> = {
+        1: {
+            1: [0, 32, 64, 96, 128, 160, 192, 224, 256, 288, 320, 352, 384, 416, 448, 0],
+            2: [0, 32, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 384, 0],
+            3: [0, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 0],
+        },
+        2: {
+            1: [0, 32, 48, 56, 64, 80, 96, 112, 128, 144, 160, 176, 192, 224, 256, 0],
+            2: [0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160, 0],
+            3: [0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160, 0],
+        },
+    };
+    const normalizedVersion = version === 2.5 ? 2 : version;
+    return tables[normalizedVersion]?.[layer]?.[bitrateIndex] ?? 0;
+}
+function getMp3SamplesPerFrame(version: number, layer: number): number {
+    if (layer === 1)
+        return 384;
+    if (version === 1)
+        return 1152;
+    return 576;
+}
+interface Mp3FrameInfo {
+    version: number;
+    versionName: string;
+    layer: number;
+    sampleRate: number;
+    bitrate: number;
+    channels: number;
+    frameSize: number;
+    samplesPerFrame: number;
+}
+function parseMp3FrameHeader(header: number): Mp3FrameInfo | null {
+    if (((header >>> 21) & 0x7ff) !== 0x7ff)
+        return null;
+    const versionBits = (header >>> 19) & 0x03;
+    const layerBits = (header >>> 17) & 0x03;
+    const bitrateIndex = (header >>> 12) & 0x0f;
+    const sampleRateIndex = (header >>> 10) & 0x03;
+    const padding = (header >>> 9) & 0x01;
+    const channelMode = (header >>> 6) & 0x03;
+    const versions = [2.5, null, 2, 1] as const;
+    const layers = [null, 3, 2, 1] as const;
+    const version = versions[versionBits];
+    const layer = layers[layerBits];
+    if (version === null || layer === null || sampleRateIndex === 3)
+        return null;
+    const sampleRateTables: Record<1 | 2 | 25, [
+        number,
+        number,
+        number
+    ]> = {
+        1: [44100, 48000, 32000],
+        2: [22050, 24000, 16000],
+        25: [11025, 12000, 8000],
+    };
+    const sampleRateKey = version === 2.5 ? 25 : (version as 1 | 2);
+    const sampleRate = sampleRateTables[sampleRateKey][sampleRateIndex];
+    const bitrate = getMp3Bitrate(version, layer, bitrateIndex);
+    const samplesPerFrame = getMp3SamplesPerFrame(version, layer);
+    if (!sampleRate || !bitrate || !samplesPerFrame)
+        return null;
+    return {
+        version,
+        versionName: `MPEG-${version === 1 ? "1" : version === 2 ? "2" : "2.5"}`,
+        layer,
+        sampleRate,
+        bitrate,
+        channels: channelMode === 3 ? 1 : 2,
+        frameSize: Math.floor((samplesPerFrame / 8 * bitrate * 1000) / sampleRate) + padding,
+        samplesPerFrame,
+    };
+}
+function getMp3SideInfoSize(frameInfo: Mp3FrameInfo): number {
+    if (frameInfo.version === 1) {
+        return frameInfo.channels === 1 ? 17 : 32;
+    }
+    return frameInfo.channels === 1 ? 9 : 17;
+}
+function parseMp3XingHeader(view: DataView, offset: number, frameInfo: Mp3FrameInfo) {
+    if (offset + 16 > view.byteLength)
+        return null;
+    const flags = view.getUint32(offset + 4, false);
+    let pos = offset + 8;
+    let totalFrames = 0;
+    let totalBytes = 0;
+    if ((flags & 0x01) !== 0 && pos + 4 <= view.byteLength) {
+        totalFrames = view.getUint32(pos, false);
+        pos += 4;
+    }
+    if ((flags & 0x02) !== 0 && pos + 4 <= view.byteLength) {
+        totalBytes = view.getUint32(pos, false);
+    }
+    const duration = totalFrames > 0 ? (totalFrames * frameInfo.samplesPerFrame) / frameInfo.sampleRate : 0;
+    const avgBitrate = duration > 0 && totalBytes > 0 ? Math.round((totalBytes * 8) / duration / 1000) : frameInfo.bitrate;
+    return {
+        codecMode: "VBR (Xing)",
+        totalFrames,
+        duration,
+        bitrateKbps: avgBitrate,
+    };
+}
+function parseMp3VbriHeader(view: DataView, offset: number, frameInfo: Mp3FrameInfo) {
+    if (offset + 18 > view.byteLength)
+        return null;
+    const totalBytes = view.getUint32(offset + 10, false);
+    const totalFrames = view.getUint32(offset + 14, false);
+    const duration = totalFrames > 0 ? (totalFrames * frameInfo.samplesPerFrame) / frameInfo.sampleRate : 0;
+    const bitrateKbps = duration > 0 && totalBytes > 0 ? Math.round((totalBytes * 8) / duration / 1000) : frameInfo.bitrate;
+    return {
+        codecMode: "VBR (VBRI)",
+        totalFrames,
+        duration,
+        bitrateKbps,
+    };
+}
+function parseMp3VbrInfo(view: DataView, frameOffset: number, frameInfo: Mp3FrameInfo) {
+    const sideInfoSize = getMp3SideInfoSize(frameInfo);
+    const xingOffset = frameOffset + 4 + sideInfoSize;
+    if (xingOffset + 4 <= view.byteLength) {
+        const xingTag = String.fromCharCode(view.getUint8(xingOffset), view.getUint8(xingOffset + 1), view.getUint8(xingOffset + 2), view.getUint8(xingOffset + 3));
+        if (xingTag === "Xing" || xingTag === "Info") {
+            return parseMp3XingHeader(view, xingOffset, frameInfo);
+        }
+    }
+    const vbriOffset = frameOffset + 36;
+    if (vbriOffset + 4 <= view.byteLength) {
+        const vbriTag = String.fromCharCode(view.getUint8(vbriOffset), view.getUint8(vbriOffset + 1), view.getUint8(vbriOffset + 2), view.getUint8(vbriOffset + 3));
+        if (vbriTag === "VBRI") {
+            return parseMp3VbriHeader(view, vbriOffset, frameInfo);
+        }
+    }
+    return null;
+}
+function parseMp3Metadata(buffer: ArrayBuffer): ParsedAudioMetadata {
+    const view = new DataView(buffer);
+    const startOffset = skipId3v2Tag(view);
+    for (let offset = startOffset; offset <= view.byteLength - 4; offset++) {
+        const header = view.getUint32(offset, false);
+        const frameInfo = parseMp3FrameHeader(header);
+        if (frameInfo) {
+            const vbrInfo = parseMp3VbrInfo(view, offset, frameInfo);
+            const estimatedAudioDataSize = Math.max(0, view.byteLength - offset);
+            const estimatedFrameSize = frameInfo.frameSize > 0 ? frameInfo.frameSize : 1;
+            const totalFrames = vbrInfo?.totalFrames ?? Math.floor(estimatedAudioDataSize / estimatedFrameSize);
+            const duration = vbrInfo?.duration ?? ((totalFrames * frameInfo.samplesPerFrame) / frameInfo.sampleRate);
+            const bitrateKbps = vbrInfo?.bitrateKbps ?? frameInfo.bitrate;
+            return {
+                fileType: "MP3",
+                sampleRate: frameInfo.sampleRate,
+                channels: frameInfo.channels,
+                bitsPerSample: 16,
+                totalSamples: duration > 0 ? Math.floor(duration * frameInfo.sampleRate) : 0,
+                duration,
+                codecMode: vbrInfo?.codecMode ?? "CBR",
+                bitrateKbps,
+                totalFrames,
+                codecVersion: frameInfo.versionName,
+            };
+        }
+    }
+    throw new Error("No valid MP3 frame found");
+}
+function parseAacMetadata(buffer: ArrayBuffer): ParsedAudioMetadata {
+    const data = new Uint8Array(buffer);
+    for (let offset = 0; offset <= data.length - 7; offset++) {
+        if (data[offset] !== 0xff || (data[offset + 1] & 0xf6) !== 0xf0)
+            continue;
+        const sampleRateIndex = (data[offset + 2] >> 2) & 0x0f;
+        const sampleRate = AAC_SAMPLE_RATES[sampleRateIndex];
+        const channels = ((data[offset + 2] & 0x01) << 2) | ((data[offset + 3] >> 6) & 0x03);
+        if (!sampleRate)
+            continue;
+        return {
+            fileType: "AAC",
+            sampleRate,
+            channels: channels || 2,
+            bitsPerSample: 16,
+            totalSamples: 0,
+            duration: 0,
+        };
+    }
+    throw new Error("No valid AAC ADTS header found");
+}
+function readMp4Box(view: DataView, offset: number, limit: number): Mp4BoxInfo | null {
+    if (offset + 8 > limit)
+        return null;
+    let size = view.getUint32(offset, false);
+    const type = readFourCC(view, offset + 4);
+    let headerSize = 8;
+    if (size === 1) {
+        if (offset + 16 > limit)
+            return null;
+        const high = view.getUint32(offset + 8, false);
+        const low = view.getUint32(offset + 12, false);
+        size = high * 4294967296 + low;
+        headerSize = 16;
+    }
+    else if (size === 0) {
+        size = limit - offset;
+    }
+    if (size < headerSize || offset + size > limit)
+        return null;
+    return { offset, size, headerSize, type };
+}
+function parseM4aMetadata(buffer: ArrayBuffer): ParsedAudioMetadata {
+    const view = new DataView(buffer);
+    let sampleRate = 0;
+    let channels = 0;
+    let bitsPerSample = 0;
+    let duration = 0;
+    const scanBoxes = (start: number, end: number): void => {
+        let offset = start;
+        while (offset + 8 <= end) {
+            const box = readMp4Box(view, offset, end);
+            if (!box)
+                break;
+            const boxEnd = box.offset + box.size;
+            const contentStart = box.offset + box.headerSize;
+            if (box.type === "mdhd" && contentStart + 24 <= boxEnd) {
+                const version = view.getUint8(contentStart);
+                if (version === 0 && contentStart + 24 <= boxEnd) {
+                    const timeScale = view.getUint32(contentStart + 12, false);
+                    const durationValue = view.getUint32(contentStart + 16, false);
+                    if (timeScale > 0) {
+                        sampleRate = timeScale;
+                        duration = durationValue / timeScale;
+                    }
+                }
+                else if (version === 1 && contentStart + 36 <= boxEnd) {
+                    const timeScale = view.getUint32(contentStart + 20, false);
+                    const durationHigh = view.getUint32(contentStart + 24, false);
+                    const durationLow = view.getUint32(contentStart + 28, false);
+                    const durationValue = durationHigh * 4294967296 + durationLow;
+                    if (timeScale > 0) {
+                        sampleRate = timeScale;
+                        duration = durationValue / timeScale;
+                    }
+                }
+            }
+            else if ((box.type === "mp4a" || box.type === "aac " || box.type === "alac") && box.offset + 36 <= boxEnd) {
+                channels = view.getUint16(box.offset + 24, false) || channels;
+                bitsPerSample = view.getUint16(box.offset + 26, false) || bitsPerSample;
+                if (!sampleRate) {
+                    const fixedPointSampleRate = view.getUint32(box.offset + 32, false);
+                    if (fixedPointSampleRate > 0) {
+                        sampleRate = Math.floor(fixedPointSampleRate / 65536);
+                    }
+                }
+            }
+            if (MP4_CONTAINER_TYPES.has(box.type)) {
+                let childStart = contentStart;
+                if (box.type === "meta")
+                    childStart = Math.min(boxEnd, contentStart + 4);
+                else if (box.type === "stsd")
+                    childStart = Math.min(boxEnd, contentStart + 8);
+                if (childStart < boxEnd)
+                    scanBoxes(childStart, boxEnd);
+            }
+            offset = boxEnd;
+        }
+    };
+    scanBoxes(0, view.byteLength);
+    if (sampleRate <= 0)
+        sampleRate = 44100;
+    if (channels <= 0)
+        channels = 2;
+    if (bitsPerSample <= 0)
+        bitsPerSample = 16;
+    return {
+        fileType: "M4A",
+        sampleRate,
+        channels,
+        bitsPerSample,
+        totalSamples: duration > 0 ? Math.floor(duration * sampleRate) : 0,
+        duration,
+    };
+}
+export function parseAudioMetadataFromInput(input: AudioArrayBufferInput): ParsedAudioMetadata {
+    const fileType = detectAudioFileType(input.arrayBuffer, input.fileName);
+    switch (fileType) {
+        case "FLAC": return parseFlacMetadata(input.arrayBuffer);
+        case "MP3": return parseMp3Metadata(input.arrayBuffer);
+        case "M4A": return parseM4aMetadata(input.arrayBuffer);
+        case "AAC": return parseAacMetadata(input.arrayBuffer);
+        default: throw new Error(`Unsupported audio format: ${input.fileName || "unknown"}`);
+    }
+}
+export function pcm16MonoArrayBufferToFloat32Samples(buffer: ArrayBuffer): Float32Array {
+    const sampleCount = Math.floor(buffer.byteLength / 2);
+    const samples = new Float32Array(sampleCount);
+    const view = new DataView(buffer);
+    for (let i = 0; i < sampleCount; i++) {
+        samples[i] = view.getInt16(i * 2, true) / 32768;
+    }
+    return samples;
+}
+function buildWindowCoefficients(size: number, windowFunction: SpectrumParams["windowFunction"]): Float32Array {
+    const coeffs = new Float32Array(size);
+    if (size <= 1) {
+        coeffs.fill(1);
+        return coeffs;
+    }
+    for (let i = 0; i < size; i++) {
+        switch (windowFunction) {
+            case "hamming":
+                coeffs[i] = 0.54 - 0.46 * Math.cos((2 * Math.PI * i) / (size - 1));
+                break;
+            case "blackman":
+                coeffs[i] =
+                    0.42 -
+                        0.5 * Math.cos((2 * Math.PI * i) / (size - 1)) +
+                        0.08 * Math.cos((4 * Math.PI * i) / (size - 1));
+                break;
+            case "rectangular":
+                coeffs[i] = 1;
+                break;
+            case "hann":
+            default:
+                coeffs[i] = 0.5 * (1 - Math.cos((2 * Math.PI * i) / (size - 1)));
+                break;
+        }
+    }
+    return coeffs;
+}
+function buildBitReversal(size: number): Uint32Array {
+    let bits = 0;
+    while ((1 << bits) < size)
+        bits++;
+    const out = new Uint32Array(size);
+    for (let i = 0; i < size; i++) {
+        let x = i;
+        let rev = 0;
+        for (let b = 0; b < bits; b++) {
+            rev = (rev << 1) | (x & 1);
+            x >>= 1;
+        }
+        out[i] = rev;
+    }
+    return out;
+}
+function fftInPlace(real: Float32Array, imag: Float32Array, bitReversal: Uint32Array): void {
+    const size = real.length;
+    for (let i = 1; i < size; i++) {
+        const j = bitReversal[i];
+        if (i < j) {
+            const tr = real[i];
+            real[i] = real[j];
+            real[j] = tr;
+            const ti = imag[i];
+            imag[i] = imag[j];
+            imag[j] = ti;
+        }
+    }
+    for (let len = 2; len <= size; len <<= 1) {
+        const wLen = (-2 * Math.PI) / len;
+        const wLenReal = Math.cos(wLen);
+        const wLenImag = Math.sin(wLen);
+        for (let i = 0; i < size; i += len) {
+            let wReal = 1;
+            let wImag = 0;
+            const half = len >> 1;
+            for (let j = 0; j < half; j++) {
+                const uReal = real[i + j];
+                const uImag = imag[i + j];
+                const vReal = real[i + j + half] * wReal - imag[i + j + half] * wImag;
+                const vImag = real[i + j + half] * wImag + imag[i + j + half] * wReal;
+                real[i + j] = uReal + vReal;
+                imag[i + j] = uImag + vImag;
+                real[i + j + half] = uReal - vReal;
+                imag[i + j + half] = uImag - vImag;
+                const tempReal = wReal * wLenReal - wImag * wLenImag;
+                wImag = wReal * wLenImag + wImag * wLenReal;
+                wReal = tempReal;
+            }
+        }
+    }
+}
+export async function analyzeSpectrumFromSamples(samples: Float32Array, sampleRate: number, params: SpectrumParams, onProgress?: AnalysisProgressCallback, shouldCancel?: AnalysisCancelCheck): Promise<SpectrumData> {
+    throwIfCancelled(shouldCancel);
+    const fftSize = params.fftSize;
+    const hopSize = Math.max(1, Math.floor(fftSize / 4));
+    const rawWindows = Math.floor((samples.length - fftSize) / hopSize);
+    const numWindows = Math.max(1, rawWindows);
+    const frameStride = Math.max(1, Math.ceil(numWindows / MAX_SPECTRUM_FRAMES));
+    const freqBins = Math.floor(fftSize / 2) + 1;
+    const duration = sampleRate > 0 ? samples.length / sampleRate : 0;
+    const maxFreq = sampleRate / 2;
+    const windowCoeffs = buildWindowCoefficients(fftSize, params.windowFunction);
+    const bitReversal = buildBitReversal(fftSize);
+    const real = new Float32Array(fftSize);
+    const imag = new Float32Array(fftSize);
+    const invFFTSizeSquared = 1 / (fftSize * fftSize);
+    reportProgress(onProgress, "spectrum", 0, "Preparing FFT...");
+    const windowIndices: number[] = [];
+    for (let windowIndex = 0; windowIndex < numWindows; windowIndex += frameStride) {
+        windowIndices.push(windowIndex);
+    }
+    if (windowIndices[windowIndices.length - 1] !== numWindows - 1) {
+        windowIndices.push(numWindows - 1);
+    }
+    const totalSlices = windowIndices.length;
+    const timeSlices: TimeSlice[] = new Array(totalSlices);
+    let lastReportedPercent = -1;
+    let lastYieldAt = nowMs();
+    for (let i = 0; i < totalSlices; i++) {
+        throwIfCancelled(shouldCancel);
+        const windowIndex = windowIndices[i];
+        const start = windowIndex * hopSize;
+        const remaining = samples.length - start;
+        const copyLen = Math.max(0, Math.min(fftSize, remaining));
+        for (let j = 0; j < copyLen; j++) {
+            real[j] = samples[start + j] * windowCoeffs[j];
+            imag[j] = 0;
+        }
+        for (let j = copyLen; j < fftSize; j++) {
+            real[j] = 0;
+            imag[j] = 0;
+        }
+        fftInPlace(real, imag, bitReversal);
+        const magnitudes = new Float32Array(freqBins);
+        for (let j = 0; j < freqBins; j++) {
+            const power = (real[j] * real[j] + imag[j] * imag[j]) * invFFTSizeSquared;
+            magnitudes[j] = power > 1e-12 ? 10 * Math.log10(power) : -120;
+        }
+        timeSlices[i] = {
+            time: sampleRate > 0 ? start / sampleRate : 0,
+            magnitudes,
+        };
+        const currentPercent = Math.floor(((i + 1) / totalSlices) * 100);
+        if (currentPercent > lastReportedPercent) {
+            lastReportedPercent = currentPercent;
+            reportProgress(onProgress, "spectrum", currentPercent, "Analyzing spectrum...");
+        }
+        if ((i + 1) % 8 === 0) {
+            const now = nowMs();
+            if (now - lastYieldAt >= 16) {
+                await nextTick();
+                lastYieldAt = nowMs();
+                throwIfCancelled(shouldCancel);
+            }
+        }
+    }
+    reportProgress(onProgress, "spectrum", 100, "Spectrum analysis complete");
+    return {
+        time_slices: timeSlices,
+        sample_rate: sampleRate,
+        freq_bins: freqBins,
+        duration,
+        max_freq: maxFreq,
+    };
+}
+function createAnalysisAudioContext(sampleRate: number): AudioContext {
+    if (sampleRate > 0) {
+        try {
+            return new AudioContext({ sampleRate });
+        }
+        catch {
+            return new AudioContext();
+        }
+    }
+    return new AudioContext();
+}
+export async function analyzeAudioFile(file: File, params: SpectrumParams = DEFAULT_PARAMS, onProgress?: AnalysisProgressCallback, shouldCancel?: AnalysisCancelCheck): Promise<FrontendAnalysisPayload> {
+    throwIfCancelled(shouldCancel);
+    reportProgress(onProgress, "read", 2, "Reading file...");
+    const arrayBuffer = await file.arrayBuffer();
+    throwIfCancelled(shouldCancel);
+    reportProgress(onProgress, "read", 10, "File loaded");
+    return analyzeAudioArrayBuffer({
+        fileName: file.name,
+        fileSize: file.size,
+        arrayBuffer,
+    }, params, (progress) => {
+        const mappedPercent = 10 + (progress.percent * 0.9);
+        reportProgress(onProgress, progress.phase, mappedPercent, progress.message);
+    }, shouldCancel);
+}
+export async function analyzeAudioArrayBuffer(input: AudioArrayBufferInput, params: SpectrumParams = DEFAULT_PARAMS, onProgress?: AnalysisProgressCallback, shouldCancel?: AnalysisCancelCheck): Promise<FrontendAnalysisPayload> {
+    throwIfCancelled(shouldCancel);
+    reportProgress(onProgress, "parse", 5, "Parsing audio metadata...");
+    const metadata = parseAudioMetadataFromInput(input);
+    throwIfCancelled(shouldCancel);
+    reportProgress(onProgress, "decode", 15, "Decoding audio stream...");
+    const audioContext = createAnalysisAudioContext(metadata.sampleRate);
+    try {
+        const audioBuffer = await audioContext.decodeAudioData(input.arrayBuffer.slice(0));
+        throwIfCancelled(shouldCancel);
+        reportProgress(onProgress, "decode", 35, "Audio decoded");
+        const samples = audioBuffer.getChannelData(0);
+        return analyzeDecodedSamples(input, metadata, samples, params, onProgress, shouldCancel, audioBuffer.duration);
+    }
+    finally {
+        await audioContext.close();
+    }
+}
+export async function analyzeDecodedSamples(input: AudioArrayBufferInput, metadata: ParsedAudioMetadata, samples: Float32Array, params: SpectrumParams = DEFAULT_PARAMS, onProgress?: AnalysisProgressCallback, shouldCancel?: AnalysisCancelCheck, durationOverride?: number): Promise<FrontendAnalysisPayload> {
+    throwIfCancelled(shouldCancel);
+    const analysisSampleRate = metadata.sampleRate > 0 ? metadata.sampleRate : 44100;
+    const analysisChannels = metadata.channels > 0 ? metadata.channels : 1;
+    const bitDepthLabel = metadata.bitsPerSample > 0 ? `${metadata.bitsPerSample}-bit` : "Unknown";
+    reportProgress(onProgress, "metrics", 40, "Calculating peak/RMS...");
+    let peak = 0;
+    let sumSquares = 0;
+    let lastMetricsYieldAt = nowMs();
+    for (let i = 0; i < samples.length; i++) {
+        throwIfCancelled(shouldCancel);
+        const sample = samples[i];
+        const absSample = Math.abs(sample);
+        if (absSample > peak)
+            peak = absSample;
+        sumSquares += sample * sample;
+        if ((i + 1) % METRICS_CHUNK_SIZE === 0 || i === samples.length - 1) {
+            const metricsProgress = 40 + (((i + 1) / Math.max(1, samples.length)) * 10);
+            reportProgress(onProgress, "metrics", metricsProgress, "Calculating peak/RMS...");
+            const now = nowMs();
+            if (now - lastMetricsYieldAt >= 16) {
+                await nextTick();
+                lastMetricsYieldAt = nowMs();
+                throwIfCancelled(shouldCancel);
+            }
+        }
+    }
+    const peakDB = peak > 0 ? 20 * Math.log10(peak) : -120;
+    const rms = samples.length > 0 ? Math.sqrt(sumSquares / samples.length) : 0;
+    const rmsDB = rms > 0 ? 20 * Math.log10(rms) : -120;
+    const dynamicRange = peakDB - rmsDB;
+    const duration = durationOverride && durationOverride > 0
+        ? durationOverride
+        : (metadata.duration > 0
+            ? metadata.duration
+            : (analysisSampleRate > 0 ? samples.length / analysisSampleRate : 0));
+    const totalSamples = metadata.totalSamples > 0
+        ? metadata.totalSamples
+        : (duration > 0 ? Math.floor(duration * analysisSampleRate) : samples.length);
+    reportProgress(onProgress, "metrics", 50, "Signal metrics complete");
+    const spectrum = await analyzeSpectrumFromSamples(samples, analysisSampleRate, params, (progress) => {
+        const mappedPercent = 50 + (progress.percent * 0.45);
+        reportProgress(onProgress, "spectrum", mappedPercent, progress.message);
+    }, shouldCancel);
+    reportProgress(onProgress, "finalize", 97, "Finalizing result...");
+    const payload: FrontendAnalysisPayload = {
+        result: {
+            file_path: input.fileName,
+            file_size: input.fileSize,
+            file_type: metadata.fileType,
+            sample_rate: analysisSampleRate,
+            channels: analysisChannels,
+            bits_per_sample: metadata.bitsPerSample,
+            total_samples: totalSamples,
+            duration,
+            bit_depth: bitDepthLabel,
+            dynamic_range: dynamicRange,
+            peak_amplitude: peakDB,
+            rms_level: rmsDB,
+            codec_mode: metadata.codecMode,
+            bitrate_kbps: metadata.bitrateKbps,
+            total_frames: metadata.totalFrames,
+            codec_version: metadata.codecVersion,
+            spectrum,
+        },
+        samples,
+    };
+    reportProgress(onProgress, "finalize", 100, "Analysis complete");
+    return payload;
+}
+export const analyzeFlacFile = analyzeAudioFile;
+export const analyzeFlacArrayBuffer = analyzeAudioArrayBuffer;

frontend/src/lib/preview.ts

@@ -0,0 +1 @@
+export const SPOTIFY_PREVIEW_VOLUME = 1;

frontend/src/lib/settings.ts

@@ -4,7 +4,9 @@ export type FolderPreset = "none" | "artist" | "album" | "year-album" | "year-ar
 export type FilenamePreset = "title" | "title-artist" | "artist-title" | "track-title" | "track-title-artist" | "track-artist-title" | "title-album-artist" | "track-title-album-artist" | "artist-album-title" | "track-dash-title" | "disc-track-title" | "disc-track-title-artist" | "custom";
 export interface Settings {
     downloadPath: string;
-    downloader: "auto" | "tidal" | "qobuz" | "amazon" | "deezer";
+    downloader: "auto" | "tidal" | "qobuz" | "amazon";
+    linkResolver: "songstats" | "songlink";
+    allowResolverFallback: boolean;
     theme: string;
     themeMode: "auto" | "light" | "dark";
     fontFamily: FontFamily;
@@ -23,7 +25,7 @@ export interface Settings {
     tidalQuality: "LOSSLESS" | "HI_RES_LOSSLESS";
     qobuzQuality: "6" | "7" | "27";
     amazonQuality: "original";
-    autoOrder: "tidal-qobuz-amazon-deezer" | "tidal-qobuz-deezer-amazon" | "tidal-amazon-qobuz-deezer" | "tidal-amazon-deezer-qobuz" | "tidal-deezer-qobuz-amazon" | "tidal-deezer-amazon-qobuz" | "qobuz-tidal-amazon-deezer" | "qobuz-tidal-deezer-amazon" | "qobuz-amazon-tidal-deezer" | "qobuz-amazon-deezer-tidal" | "qobuz-deezer-tidal-amazon" | "qobuz-deezer-amazon-tidal" | "amazon-tidal-qobuz-deezer" | "amazon-tidal-deezer-qobuz" | "amazon-qobuz-tidal-deezer" | "amazon-qobuz-deezer-tidal" | "amazon-deezer-tidal-qobuz" | "amazon-deezer-qobuz-tidal" | "deezer-tidal-qobuz-amazon" | "deezer-tidal-amazon-qobuz" | "deezer-qobuz-tidal-amazon" | "deezer-qobuz-amazon-tidal" | "deezer-amazon-tidal-qobuz" | "deezer-amazon-qobuz-tidal" | string;
+    autoOrder: "tidal-qobuz-amazon" | "tidal-amazon-qobuz" | "qobuz-tidal-amazon" | "qobuz-amazon-tidal" | "amazon-tidal-qobuz" | "amazon-qobuz-tidal" | string;
     autoQuality: "16" | "24";
     allowFallback: boolean;
     useSpotFetchAPI: boolean;
@@ -33,6 +35,7 @@ export interface Settings {
     useFirstArtistOnly: boolean;
     useSingleGenre: boolean;
     embedGenre: boolean;
+    separator: "comma" | "semicolon";
 }
 export const FOLDER_PRESETS: Record<FolderPreset, {
     label: string;
@@ -92,6 +95,8 @@ function detectOS(): "Windows" | "linux/MacOS" {
 export const DEFAULT_SETTINGS: Settings = {
     downloadPath: "",
     downloader: "auto",
+    linkResolver: "songlink",
+    allowResolverFallback: true,
     theme: "yellow",
     themeMode: "auto",
     fontFamily: "google-sans",
@@ -107,16 +112,17 @@ export const DEFAULT_SETTINGS: Settings = {
     tidalQuality: "LOSSLESS",
     qobuzQuality: "6",
     amazonQuality: "original",
-    autoOrder: "tidal-qobuz-amazon-deezer",
+    autoOrder: "tidal-qobuz-amazon",
     autoQuality: "16",
     allowFallback: true,
     useSpotFetchAPI: false,
-    spotFetchAPIUrl: "https://spotify.afkarxyz.fun/api",
+    spotFetchAPIUrl: "https://sp.afkarxyz.qzz.io/api",
     createPlaylistFolder: true,
     createM3u8File: false,
     useFirstArtistOnly: false,
     useSingleGenre: false,
-    embedGenre: true
+    embedGenre: true,
+    separator: "semicolon"
 };
 export const FONT_OPTIONS: {
     value: FontFamily;
@@ -223,6 +229,15 @@ function getSettingsFromLocalStorage(): Settings {
             if (!('allowFallback' in parsed)) {
                 parsed.allowFallback = true;
             }
+            if (!('linkResolver' in parsed)) {
+                parsed.linkResolver = "songlink";
+            }
+            if (!('allowResolverFallback' in parsed)) {
+                parsed.allowResolverFallback = true;
+            }
+            if (!('separator' in parsed)) {
+                parsed.separator = "semicolon";
+            }
             return { ...DEFAULT_SETTINGS, ...parsed };
         }
     }
@@ -299,6 +314,12 @@ export async function loadSettings(): Promise<Settings> {
             if (!('allowFallback' in parsed)) {
                 parsed.allowFallback = true;
             }
+            if (!('linkResolver' in parsed)) {
+                parsed.linkResolver = "songlink";
+            }
+            if (!('allowResolverFallback' in parsed)) {
+                parsed.allowResolverFallback = true;
+            }
             if (!('createPlaylistFolder' in parsed)) {
                 parsed.createPlaylistFolder = true;
             }
@@ -314,6 +335,9 @@ export async function loadSettings(): Promise<Settings> {
             if (!('embedGenre' in parsed)) {
                 parsed.embedGenre = true;
             }
+            if (!('separator' in parsed)) {
+                parsed.separator = "semicolon";
+            }
             cachedSettings = { ...DEFAULT_SETTINGS, ...parsed };
             return cachedSettings!;
         }

frontend/src/lib/toast-with-sound.ts

@@ -5,41 +5,49 @@ import { getSettings } from "./settings";
 const toastStyle = {
     className: "font-mono lowercase",
 };
+type ToastData = Parameters<typeof toast.success>[1];
 const isSfxEnabled = () => getSettings().sfxEnabled;
 export const toastWithSound = {
-    success: (message: string, data?: any) => {
+    success: (message: string, data?: ToastData) => {
         const msg = message.toLowerCase();
         logger.success(msg);
         if (isSfxEnabled())
             playSuccessSound();
         return toast.success(msg, { ...toastStyle, ...data });
     },
-    error: (message: string, data?: any) => {
+    error: (message: string, data?: ToastData) => {
         const msg = message.toLowerCase();
         logger.error(msg);
         if (isSfxEnabled())
             playErrorSound();
         return toast.error(msg, { ...toastStyle, ...data });
     },
-    warning: (message: string, data?: any) => {
+    warning: (message: string, data?: ToastData) => {
         const msg = message.toLowerCase();
         logger.warning(msg);
         if (isSfxEnabled())
             playWarningSound();
         return toast.warning(msg, { ...toastStyle, ...data });
     },
-    info: (message: string, data?: any) => {
+    info: (message: string, data?: ToastData) => {
         const msg = message.toLowerCase();
         logger.info(msg);
         if (isSfxEnabled())
             playInfoSound();
         return toast.info(msg, { ...toastStyle, ...data });
     },
-    message: (message: string, data?: any) => {
+    message: (message: string, data?: ToastData) => {
         const msg = message.toLowerCase();
         logger.info(msg);
         if (isSfxEnabled())
             playInfoSound();
         return toast(msg, { ...toastStyle, ...data });
     },
+    silentInfo: (message: string, data?: ToastData) => {
+        const msg = message.toLowerCase();
+        logger.info(msg);
+        return toast.info(msg, { ...toastStyle, ...data });
+    },
+    dismiss: (id?: string | number) => toast.dismiss(id),
+    toast: toast,
 };

frontend/src/types/api.ts

@@ -108,7 +108,7 @@ export interface ArtistResponse {
 }
 export type SpotifyMetadataResponse = TrackResponse | AlbumResponse | PlaylistResponse | ArtistDiscographyResponse | ArtistResponse;
 export interface DownloadRequest {
-    service: "tidal" | "qobuz" | "amazon" | "deezer";
+    service: "tidal" | "qobuz" | "amazon";
     query?: string;
     track_name?: string;
     artist_name?: string;
@@ -155,7 +155,7 @@ export interface HealthResponse {
 }
 export interface TimeSlice {
     time: number;
-    magnitudes: number[];
+    magnitudes: number[] | Float32Array;
 }
 export interface SpectrumData {
     time_slices: TimeSlice[];
@@ -167,6 +167,7 @@ export interface SpectrumData {
 export interface AnalysisResult {
     file_path: string;
     file_size: number;
+    file_type?: "FLAC" | "MP3" | "M4A" | "AAC";
     sample_rate: number;
     channels: number;
     bits_per_sample: number;
@@ -176,6 +177,10 @@ export interface AnalysisResult {
     dynamic_range: number;
     peak_amplitude: number;
     rms_level: number;
+    codec_mode?: string;
+    bitrate_kbps?: number;
+    total_frames?: number;
+    codec_version?: string;
     spectrum?: SpectrumData;
 }
 export interface LyricsDownloadRequest {
@@ -204,11 +209,9 @@ export interface TrackAvailability {
     tidal: boolean;
     amazon: boolean;
     qobuz: boolean;
-    deezer: boolean;
     tidal_url?: string;
     amazon_url?: string;
     qobuz_url?: string;
-    deezer_url?: string;
 }
 export interface CoverDownloadRequest {
     cover_url: string;

go.mod

@@ -7,11 +7,11 @@ require (
 	github.com/go-flac/flacpicture v0.3.0
 	github.com/go-flac/flacvorbis v0.2.0
 	github.com/go-flac/go-flac v1.0.0
-	github.com/mewkiz/flac v1.0.13
 	github.com/pquerna/otp v1.5.0
 	github.com/ulikunitz/xz v0.5.15
 	github.com/wailsapp/wails/v2 v2.11.0
 	go.etcd.io/bbolt v1.4.3
+	golang.org/x/image v0.12.0
 	golang.org/x/text v0.31.0
 )
 
@@ -22,7 +22,6 @@ require (
 	github.com/godbus/dbus/v5 v5.2.0 // indirect
 	github.com/google/uuid v1.6.0 // indirect
 	github.com/gorilla/websocket v1.5.3 // indirect
-	github.com/icza/bitio v1.1.0 // indirect
 	github.com/jchv/go-winloader v0.0.0-20250406163304-c1995be93bd1 // indirect
 	github.com/labstack/echo/v4 v4.13.4 // indirect
 	github.com/labstack/gommon v0.4.2 // indirect
@@ -32,8 +31,6 @@ require (
 	github.com/leaanthony/u v1.1.1 // indirect
 	github.com/mattn/go-colorable v0.1.14 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
-	github.com/mewkiz/pkg v0.0.0-20250417130911-3f050ff8c56d // indirect
-	github.com/mewpkg/term v0.0.0-20241026122259-37a80af23985 // indirect
 	github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c // indirect
 	github.com/pkg/errors v0.9.1 // indirect
 	github.com/rivo/uniseg v0.4.7 // indirect

go.sum

@@ -21,10 +21,6 @@ github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
 github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/gorilla/websocket v1.5.3 h1:saDtZ6Pbx/0u+bgYQ3q96pZgCzfhKXGPqt7kZ72aNNg=
 github.com/gorilla/websocket v1.5.3/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
-github.com/icza/bitio v1.1.0 h1:ysX4vtldjdi3Ygai5m1cWy4oLkhWTAi+SyO6HC8L9T0=
-github.com/icza/bitio v1.1.0/go.mod h1:0jGnlLAx8MKMr9VGnn/4YrvZiprkvBelsVIbA9Jjr9A=
-github.com/icza/mighty v0.0.0-20180919140131-cfd07d671de6 h1:8UsGZ2rr2ksmEru6lToqnXgA8Mz1DP11X4zSJ159C3k=
-github.com/icza/mighty v0.0.0-20180919140131-cfd07d671de6/go.mod h1:xQig96I1VNBDIWGCdTt54nHt6EeI639SmHycLYL7FkA=
 github.com/jchv/go-winloader v0.0.0-20250406163304-c1995be93bd1 h1:njuLRcjAuMKr7kI3D85AXWkw6/+v9PwtV6M6o11sWHQ=
 github.com/jchv/go-winloader v0.0.0-20250406163304-c1995be93bd1/go.mod h1:alcuEEnZsY1WQsagKhZDsoPCRoOijYqhZvPwLG0kzVs=
 github.com/labstack/echo/v4 v4.13.4 h1:oTZZW+T3s9gAu5L8vmzihV7/lkXGZuITzTQkTEhcXEA=
@@ -48,12 +44,6 @@ github.com/mattn/go-colorable v0.1.14 h1:9A9LHSqF/7dyVVX6g0U9cwm9pG3kP9gSzcuIPHP
 github.com/mattn/go-colorable v0.1.14/go.mod h1:6LmQG8QLFO4G5z1gPvYEzlUgJ2wF+stgPZH1UqBm1s8=
 github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
 github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
-github.com/mewkiz/flac v1.0.13 h1:6wF8rRQKBFW159Daqx6Ro7K5ZnlVhHUKfS5aTsC4oXs=
-github.com/mewkiz/flac v1.0.13/go.mod h1:HfPYDA+oxjyuqMu2V+cyKcxF51KM6incpw5eZXmfA6k=
-github.com/mewkiz/pkg v0.0.0-20250417130911-3f050ff8c56d h1:IL2tii4jXLdhCeQN69HNzYYW1kl0meSG0wt5+sLwszU=
-github.com/mewkiz/pkg v0.0.0-20250417130911-3f050ff8c56d/go.mod h1:SIpumAnUWSy0q9RzKD3pyH3g1t5vdawUAPcW5tQrUtI=
-github.com/mewpkg/term v0.0.0-20241026122259-37a80af23985 h1:h8O1byDZ1uk6RUXMhj1QJU3VXFKXHDZxr4TXRPGeBa8=
-github.com/mewpkg/term v0.0.0-20241026122259-37a80af23985/go.mod h1:uiPmbdUbdt1NkGApKl7htQjZ8S7XaGUAVulJUJ9v6q4=
 github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c h1:+mdjkGKdHQG3305AYmdv1U2eRNDiU2ErMBj1gwrq8eQ=
 github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c/go.mod h1:7rwL4CYBLnjLxUqIJNnCWiEdr3bn6IUYi15bNlnbCCU=
 github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
@@ -92,15 +82,20 @@ golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACk
 golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
 golang.org/x/crypto v0.45.0 h1:jMBrvKuj23MTlT0bQEOBcAE0mjg8mK9RXFhRH6nyF3Q=
 golang.org/x/crypto v0.45.0/go.mod h1:XTGrrkGJve7CYK7J8PEww4aY7gM3qMCElcJQ8n8JdX4=
+golang.org/x/image v0.12.0 h1:w13vZbU4o5rKOFFR8y7M+c4A5jXDC0uXTdHYRP8X2DQ=
+golang.org/x/image v0.12.0/go.mod h1:Lu90jvHG7GfemOIcldsh9A2hS01ocl6oNO7ype5mEnk=
 golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
+golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
 golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
 golang.org/x/net v0.0.0-20210505024714-0287a6fb4125/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
 golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
+golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=
 golang.org/x/net v0.47.0 h1:Mx+4dIFzqraBXUugkia1OOvlD6LemFo1ALMHjrXDOhY=
 golang.org/x/net v0.47.0/go.mod h1:/jNxtkgq5yWUGYkaZGqo27cfGZ1c5Nen03aYrrKpVRU=
 golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.18.0 h1:kr88TuHDroi+UVf+0hZnirlk8o8T+4MrK6mr60WkH/I=
 golang.org/x/sync v0.18.0/go.mod h1:9KTHXmSnoGruLpwFjVSX0lNNA75CykiMECbovNTZqGI=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
@@ -111,21 +106,26 @@ golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBc
 golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.1.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.38.0 h1:3yZWxaJjBmCWXqhN1qh02AkOnCQ1poK6oF+a7xWL6Gc=
 golang.org/x/sys v0.38.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
+golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
 golang.org/x/text v0.3.8/go.mod h1:E6s5w1FMmriuDzIBO73fBruAKo1PCIq6d2Q6DHfQ8WQ=
+golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
+golang.org/x/text v0.13.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE=
 golang.org/x/text v0.31.0 h1:aC8ghyu4JhP8VojJ2lEHBnochRno1sgL6nEi9WGFGMM=
 golang.org/x/text v0.31.0/go.mod h1:tKRAlv61yKIjGGHX/4tP1LTbc13YSec1pxVEWXzfoeM=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
 golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
+golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

wails.json

@@ -12,7 +12,7 @@
   },
   "info": {
     "productName": "SpotiFLAC",
-    "productVersion": "7.1.0",
+    "productVersion": "7.1.3",
     "copyright": "© 2026 afkarxyz"
   },
   "wailsjsdir": "./frontend",