resize too-large cover images

prefer release with no disambiguation, match track counts
text representation and disambiguation to releases
2026-04-22 11:31:52 -07:00 · 2026-04-12 19:42:31 -04:00 · 2026-04-12 19:33:38 -04:00 · 2026-04-10 10:18:19 -04:00 · 2026-04-10 09:43:23 -04:00 · 2026-04-09 19:57:47 -04:00
8 changed files with 844 additions and 445 deletions
--- a/discover.go
+++ b/discover.go
@ -21,10 +21,21 @@ type mbArtistCredit struct {
 	} `json:"artist"`
 }

+type mbMedia struct {
+	Format     string `json:"format"`
+	TrackCount int    `json:"track-count"`
+}
+
 type mbRelease struct {
 	ID             string           `json:"id"`
 	Title          string           `json:"title"`
 	Date           string           `json:"date"`
+	Country        string           `json:"country"`
+	Disambiguation string           `json:"disambiguation"`
+	TextRepresentation struct {
+		Language string `json:"language"`
+	} `json:"text-representation"`
+	Media        []mbMedia        `json:"media"`
 	ArtistCredit []mbArtistCredit `json:"artist-credit"`
 	ReleaseGroup struct {
 		PrimaryType string `json:"primary-type"`
@ -45,6 +56,22 @@ type mbReleaseGroup struct {
 	FirstReleaseDate string `json:"first-release-date"`
 }

+// releaseTrackCount returns the total number of tracks across all media in a release.
+func releaseTrackCount(r mbRelease) int {
+	total := 0
+	for _, m := range r.Media {
+		total += m.TrackCount
+	}
+	return total
+}
+
+// getMBRelease fetches a single release by MBID (with media/track-count included).
+func getMBRelease(mbid string) (*mbRelease, error) {
+	var r mbRelease
+	err := mbGet(fmt.Sprintf("/ws/2/release/%s?fmt=json&inc=media", url.QueryEscape(mbid)), &r)
+	return &r, err
+}
+
 func mbGet(path string, out interface{}) error {
 	req, err := http.NewRequest("GET", "https://musicbrainz.org"+path, nil)
 	if err != nil {
@ -68,7 +95,7 @@ func searchMBReleases(query string) ([]mbRelease, error) {
 	var result struct {
 		Releases []mbRelease `json:"releases"`
 	}
-	err := mbGet("/ws/2/release/?query="+url.QueryEscape(query)+"&fmt=json&limit=20", &result)
+	err := mbGet("/ws/2/release/?query="+url.QueryEscape(query)+"&fmt=json&limit=20&inc=media", &result)
 	return result.Releases, err
 }

@ -80,21 +107,92 @@ func searchMBArtists(query string) ([]mbArtist, error) {
 	return result.Artists, err
 }

-// getFirstReleaseMBID returns the MBID of the first release listed under a
-// release group. This is needed because beets --search-id requires a release
-// MBID, not a release group MBID.
-// Returns empty string on error so callers can fall back gracefully.
-func getFirstReleaseMBID(rgMBID string) string {
+// releaseFormatScore returns a preference score for a release's media format.
+// Higher is better. CD=2, Digital Media=1, anything else=0.
+func releaseFormatScore(r mbRelease) int {
+	for _, m := range r.Media {
+		switch m.Format {
+		case "Digital Media":
+			return 2
+		case "CD":
+			return 1
+		}
+	}
+	return 0
+}
+
+// releaseCountryScore returns a preference score for a release's country.
+// Higher is better. KR=3, JP=2, XW=1, anything else=0.
+func releaseCountryScore(r mbRelease) int {
+	switch r.Country {
+	case "XW":
+		return 2
+	case "KR":
+		return 1
+	}
+	return 0
+}
+
+// returns true if strings formatted 'YYYY-MM-DD" ts1 is before ts2
+func timeStringIsBefore(ts1, ts2 string) (bool, error) {
+	datefmt := "2006-02-01"
+	t1, err := time.Parse(datefmt, ts1)
+	if err != nil {
+		return false, err
+	}
+	t2, err := time.Parse(datefmt, ts2)
+	if err != nil {
+		return false, err
+	}
+	return t1.Unix() <= t2.Unix(), nil
+}
+
+// pickBestRelease selects the preferred release from a list.
+// No disambiguation (canonical release) is the primary sort key;
+// format (CD > Digital Media > *) is secondary; country (KR > XW > *) breaks ties.
+func pickBestRelease(releases []mbRelease) *mbRelease {
+	if len(releases) == 0 {
+		return nil
+	}
+	best := &releases[0]
+	for i := 1; i < len(releases); i++ {
+		r := &releases[i]
+
+		rNoDisamb := r.Disambiguation == ""
+		bestNoDisamb := best.Disambiguation == ""
+
+		// Prefer releases with no disambiguation — they are the canonical default.
+		if rNoDisamb && !bestNoDisamb {
+			best = r
+			continue
+		}
+		if !rNoDisamb && bestNoDisamb {
+			continue
+		}
+
+		// Both have the same disambiguation status; use date/format/country.
+		if before, err := timeStringIsBefore(r.Date, best.Date); before && err == nil {
+			rf, bf := releaseFormatScore(*r), releaseFormatScore(*best)
+			if rf > bf || (rf == bf && releaseCountryScore(*r) > releaseCountryScore(*best)) {
+				best = r
+			}
+		}
+	}
+	return best
+}
+
+// pickBestReleaseForGroup fetches all releases for a release group via the
+// MusicBrainz browse API (with media info) and returns the preferred release.
+// Returns nil on error or when the group has no releases.
+func pickBestReleaseForGroup(rgMBID string) *mbRelease {
 	var result struct {
-		Releases []struct {
-			ID string `json:"id"`
-		} `json:"releases"`
+		Releases []mbRelease `json:"releases"`
 	}
-	path := fmt.Sprintf("/ws/2/release-group/%s?fmt=json&inc=releases", url.QueryEscape(rgMBID))
+	path := fmt.Sprintf("/ws/2/release?release-group=%s&fmt=json&inc=media&limit=100", url.QueryEscape(rgMBID))
 	if err := mbGet(path, &result); err != nil || len(result.Releases) == 0 {
-		return ""
+		return nil
 	}
-	return result.Releases[0].ID
+	return pickBestRelease(result.Releases)
 }

 // getMBArtistReleaseGroups returns all Album and EP release groups for an artist,
@ -153,15 +251,25 @@ func fetchArtist(artistMBID, artistName string, logf func(string)) error {
 	failed := 0
 	for i, rg := range groups {
 		logf(fmt.Sprintf("[%d/%d] %s", i+1, len(groups), rg.Title))
-		// Resolve a release MBID for this release group. beets --search-id
-		// requires a release MBID; release group MBIDs are not accepted.
+		// Pick the best release for this group. beets --search-id requires a
+		// release MBID; release group MBIDs are not accepted.
 		time.Sleep(time.Second) // MusicBrainz rate limit
-		releaseMBID := getFirstReleaseMBID(rg.ID)
-		if releaseMBID == "" {
-			logf(fmt.Sprintf("  ↳ warning: could not resolve release MBID for group %s, beets will search by name", rg.ID))
+		rel := pickBestReleaseForGroup(rg.ID)
+		releaseMBID := ""
+		trackCount := 0
+		if rel == nil {
+			logf(fmt.Sprintf("  ↳ warning: could not resolve release for group %s, beets will search by name", rg.ID))
+		} else {
+			releaseMBID = rel.ID
+			trackCount = releaseTrackCount(*rel)
+			format := ""
+			if len(rel.Media) > 0 {
+				format = rel.Media[0].Format
+			}
+			logf(fmt.Sprintf("  ↳ selected release: %s [%s / %s / %d tracks]", releaseMBID, format, rel.Country, trackCount))
 		}

-		folder, err := fetchRelease(artistName, rg.Title, releaseMBID, logf)
+		folder, err := fetchRelease(artistName, rg.Title, releaseMBID, trackCount, logf)
 		if err != nil {
 			log.Printf("[discover] fetch failed for %q by %s: %v", rg.Title, artistName, err)
 			logf(fmt.Sprintf("  ↳ failed: %v", err))
@ -169,7 +277,7 @@ func fetchArtist(artistMBID, artistName string, logf func(string)) error {
 			continue
 		}
 		// Key the pending download by release group ID for dedup; beets uses releaseMBID.
-		registerDownload(rg.ID, releaseMBID, artistName, rg.Title, folder, nil)
+		registerDownload(rg.ID, releaseMBID, artistName, rg.Title, trackCount, folder, nil)
 		logf(fmt.Sprintf("  ↳ registered for import (release mbid: %s)", releaseMBID))
 	}

@ -308,15 +416,26 @@ func handleDiscoverFetch(w http.ResponseWriter, r *http.Request) {

 	log.Printf("[discover] starting fetch: %q by %s (mbid: %s)", body.Album, body.Artist, body.ID)
 	entry := newFetchEntry(body.ID, body.Artist, body.Album)
+
+	// Look up the expected track count from MusicBrainz so the folder-selection
+	// logic can prefer results that match the release we intend to import.
+	trackCount := 0
+	if rel, err := getMBRelease(body.ID); err == nil {
+		trackCount = releaseTrackCount(*rel)
+		log.Printf("[discover] release %s has %d tracks", body.ID, trackCount)
+	} else {
+		log.Printf("[discover] could not fetch release track count for %s: %v", body.ID, err)
+	}
+
 	go func() {
-		folder, err := fetchRelease(body.Artist, body.Album, body.ID, entry.appendLog)
+		folder, err := fetchRelease(body.Artist, body.Album, body.ID, trackCount, entry.appendLog)
 		if err != nil {
 			log.Printf("[discover] fetch failed for %q by %s: %v", body.Album, body.Artist, err)
 			entry.finish(err)
 			return
 		}
 		log.Printf("[discover] fetch complete for %q by %s, registering for import", body.Album, body.Artist)
-		registerDownload(body.ID, body.ID, body.Artist, body.Album, folder, entry)
+		registerDownload(body.ID, body.ID, body.Artist, body.Album, trackCount, folder, entry)
 		// entry.finish is called by the monitor when import completes
 	}()

--- a/importer.go
+++ b/importer.go
@ -213,11 +213,15 @@ func RunImporter() {

 		fmt.Println("→ Downloading cover art for album:", albumPath)
 		if _, err := FindCoverImage(albumPath); err != nil {
-			if err := DownloadCoverArt(albumPath, md); err != nil {
+			if err := DownloadCoverArt(albumPath, md, ""); err != nil {
 				fmt.Println("Cover art download failed:", err)
 			}
 		}

+		if err := NormalizeCoverArt(albumPath); err != nil {
+			fmt.Println("Cover art normalization warning:", err)
+		}
+
 		fmt.Println("→ Embedding cover art for album:", albumPath)
 		result.CoverArt.Err = EmbedAlbumArtIntoFolder(albumPath)
 		if coverImg, err := FindCoverImage(albumPath); err == nil {
--- a/media.go
+++ b/media.go
@ -57,15 +57,18 @@ func EmbedAlbumArtIntoFolder(albumDir string) error {
 	return err
 }

-// DownloadCoverArt searches MusicBrainz for a release matching md's artist and
-// album, then downloads the front cover from the Cover Art Archive and saves it
-// as cover.jpg inside albumDir. Returns an error if no cover could be found or
-// downloaded.
-func DownloadCoverArt(albumDir string, md *MusicMetadata) error {
-	mbid, err := searchMusicBrainzRelease(md.Artist, md.Album)
+// DownloadCoverArt downloads the front cover from the Cover Art Archive and
+// saves it as cover.jpg/cover.png inside albumDir.
+// If mbid is non-empty it is used directly, bypassing the MusicBrainz search.
+// Otherwise, a search is performed using md's artist and album.
+func DownloadCoverArt(albumDir string, md *MusicMetadata, mbid string) error {
+	if mbid == "" {
+		var err error
+		mbid, err = searchMusicBrainzRelease(md.Artist, md.Album)
 		if err != nil {
 			return fmt.Errorf("MusicBrainz release search failed: %w", err)
 		}
+	}

 	data, ext, err := fetchCoverArtArchiveFront(mbid)
 	if err != nil {
@ -154,6 +157,58 @@ func fetchCoverArtArchiveFront(mbid string) ([]byte, string, error) {
 	return data, ext, nil
 }

+const coverMaxBytes = 5 * 1024 * 1024 // 5 MB
+
+// NormalizeCoverArt checks whether the cover image in albumDir is a large
+// non-JPEG (>5 MB). If so, it converts it to JPEG and resizes it to at most
+// 2000×2000 pixels using ffmpeg, replacing the original file with cover.jpg.
+// The function is a no-op when no cover is found, the cover is already JPEG,
+// or the file is ≤5 MB.
+func NormalizeCoverArt(albumDir string) error {
+	cover, err := FindCoverImage(albumDir)
+	if err != nil {
+		return nil // no cover present, nothing to do
+	}
+
+	// Already JPEG — no conversion needed regardless of size.
+	ext := strings.ToLower(filepath.Ext(cover))
+	if ext == ".jpg" || ext == ".jpeg" {
+		return nil
+	}
+
+	info, err := os.Stat(cover)
+	if err != nil {
+		return fmt.Errorf("stat cover: %w", err)
+	}
+	if info.Size() <= coverMaxBytes {
+		return nil // small enough, leave as-is
+	}
+
+	dest := filepath.Join(albumDir, "cover.jpg")
+	fmt.Printf("→ Cover art is %.1f MB %s; converting to JPEG (max 2000×2000)…\n",
+		float64(info.Size())/(1024*1024), strings.ToUpper(strings.TrimPrefix(ext, ".")))
+
+	// scale=2000:2000:force_original_aspect_ratio=decrease fits the image within
+	// 2000×2000 while preserving aspect ratio, and never upscales smaller images.
+	cmd := exec.Command("ffmpeg", "-y", "-i", cover,
+		"-vf", "scale=2000:2000:force_original_aspect_ratio=decrease",
+		"-q:v", "2",
+		dest,
+	)
+	if out, err := cmd.CombinedOutput(); err != nil {
+		return fmt.Errorf("ffmpeg cover conversion failed: %w\n%s", err, out)
+	}
+
+	if cover != dest {
+		if err := os.Remove(cover); err != nil {
+			fmt.Println("Warning: could not remove original cover:", err)
+		}
+	}
+
+	fmt.Println("→ Converted cover art to JPEG:", filepath.Base(dest))
+	return nil
+}
+
 // -------------------------
 // Find cover image
 // -------------------------
--- a/metadata.go
+++ b/metadata.go
@ -207,7 +207,9 @@ func snapMP3Bitrate(bpsStr string) int {
 // (which exit 0 but produce a "skip" log entry) are detected and
 // returned as errors, triggering the MusicBrainz fallback.
 // If mbid is non-empty it is passed as --search-id to pin beets to a specific
-// MusicBrainz release.
+// MusicBrainz release. In that case, quiet mode is skipped and newlines are
+// piped to stdin so beets auto-accepts the pinned release regardless of
+// confidence score.
 func tagWithBeets(path, mbid string) error {
 	fmt.Println("→ Tagging with beets:", path)

@ -219,15 +221,24 @@ func tagWithBeets(path, mbid string) error {
 	logFile.Close()
 	defer os.Remove(logPath)

-	args := []string{"import", "-Cq", "-l", logPath}
-	// passing mbid to beet removed temporarily
-	// if mbid != "" {
-	// 	args = append(args, "--search-id", mbid)
-	// }
-	args = append(args, path)
+	args := []string{"import", "-C", "-l", logPath}
+	if mbid != "" {
+		// Drop -q so beets doesn't skip on low confidence. Pipe newlines to
+		// auto-accept the interactive prompt for the MBID-pinned release.
+		args = append(args, "--search-id", mbid, path)
+		cmd := exec.Command("beet", args...)
+		cmd.Stdout = os.Stdout
+		cmd.Stderr = os.Stderr
+		cmd.Stdin = strings.NewReader(strings.Repeat("A\n", 20))
+		if err := cmd.Run(); err != nil {
+			return err
+		}
+	} else {
+		args = append(args, "-q", path)
 		if err := runCmd("beet", args...); err != nil {
 			return err
 		}
+	}

 	// Even on exit 0, beets may have skipped the album in quiet mode.
 	// The log format is one entry per line: "<action> <path>"
--- a/monitor.go
+++ b/monitor.go
@ -21,6 +21,7 @@ type pendingDownload struct {
 	Dir       string      // remote directory path on the peer
 	Files     []slskdFile // files that were queued for download
 	Entry     *fetchEntry // fetch card to update with import progress
+	TrackCount int        // expected number of audio tracks (0 = unknown, skip check)
 }

 var (
@ -31,9 +32,11 @@ var (
 // registerDownload records a queued slskd download for monitoring and eventual
 // auto-import. id is used as the dedup key; beetsMBID is the release MBID
 // forwarded to beets --search-id (may be empty or differ from id).
+// trackCount is the expected number of audio tracks from MusicBrainz; 0 means
+// unknown and the sanity check will be skipped at import time.
 // If entry is nil a new fetchEntry is created so the frontend can discover it
 // via /discover/fetch/list.
-func registerDownload(id, beetsMBID, artist, album string, folder *albumFolder, entry *fetchEntry) {
+func registerDownload(id, beetsMBID, artist, album string, trackCount int, folder *albumFolder, entry *fetchEntry) {
 	pd := &pendingDownload{
 		ID:         id,
 		BeetsMBID:  beetsMBID,
@ -43,6 +46,7 @@ func registerDownload(id, beetsMBID, artist, album string, folder *albumFolder,
 		Dir:        folder.Dir,
 		Files:      folder.Files,
 		Entry:      entry,
+		TrackCount: trackCount,
 	}

 	if entry == nil {
@ -56,8 +60,8 @@ func registerDownload(id, beetsMBID, artist, album string, folder *albumFolder,
 	pendingDownloads[id] = pd
 	pendingMu.Unlock()

-	log.Printf("[monitor] registered: %q by %s (id: %s, beets mbid: %s, peer: %s, %d files)",
-		album, artist, id, beetsMBID, folder.Username, len(folder.Files))
+	log.Printf("[monitor] registered: %q by %s (id: %s, beets mbid: %s, peer: %s, %d files, expected tracks: %d)",
+		album, artist, id, beetsMBID, folder.Username, len(folder.Files), trackCount)
 }

 // startMonitor launches a background goroutine that periodically checks whether
@ -215,6 +219,14 @@ func importPendingRelease(pd *pendingDownload, localDir string) {
 	}
 	logf(fmt.Sprintf("Found %d tracks", len(tracks)))

+	if pd.TrackCount > 0 && len(tracks) != pd.TrackCount {
+		entry.finish(fmt.Errorf(
+			"track count mismatch: downloaded %d tracks but release expects %d — aborting to avoid importing wrong edition",
+			len(tracks), pd.TrackCount,
+		))
+		return
+	}
+
 	if err := cleanAlbumTags(localDir); err != nil {
 		logf(fmt.Sprintf("Clean tags warning: %v", err))
 	}
@ -237,11 +249,15 @@ func importPendingRelease(pd *pendingDownload, localDir string) {
 	logf("ReplayGain applied")

 	if _, err := FindCoverImage(localDir); err != nil {
-		if err := DownloadCoverArt(localDir, md); err != nil {
+		if err := DownloadCoverArt(localDir, md, pd.BeetsMBID); err != nil {
 			logf(fmt.Sprintf("Cover art download warning: %v", err))
 		}
 	}

+	if err := NormalizeCoverArt(localDir); err != nil {
+		logf(fmt.Sprintf("Cover art normalization warning: %v", err))
+	}
+
 	if err := EmbedAlbumArtIntoFolder(localDir); err != nil {
 		entry.finish(fmt.Errorf("cover embed failed: %w", err))
 		return
--- a/slskd.go
+++ b/slskd.go
@ -141,7 +141,7 @@ func slskdSearchIsTerminal(state string) bool {
 // then returns the responses from the dedicated /responses sub-endpoint.
 // Each poll check-in is reported via logf.
 func pollSlskdSearch(id string, logf func(string)) ([]slskdPeerResponse, error) {
-	deadline := time.Now().Add(30 * time.Second)
+	deadline := time.Now().Add(60 * time.Second)
 	for {
 		resp, err := slskdDo("GET", "/api/v0/searches/"+id, nil)
 		if err != nil {
@ -384,9 +384,12 @@ func getSlskdTransfers(username string) ([]slskdTransferDir, error) {
 // fetchRelease searches slskd for an album, queues the best-quality match for
 // download, and returns the chosen folder so the caller can monitor completion.
 // mbid, if non-empty, will be stored for use during import (beets --search-id).
-func fetchRelease(artist, album, mbid string, logf func(string)) (*albumFolder, error) {
+// trackCount, if > 0, filters candidate folders to those whose audio file count
+// matches the expected number of tracks on the release, so alternate editions
+// with different track counts are not accidentally selected.
+func fetchRelease(artist, album, mbid string, trackCount int, logf func(string)) (*albumFolder, error) {
 	query := artist + " " + album
-	log.Printf("[discover] fetch started: %q by %s", album, artist)
+	log.Printf("[discover] fetch started: %q by %s (expected tracks: %d)", album, artist, trackCount)
 	logf("Starting fetch for: " + query)

 	logf("Creating slskd search…")
@ -418,7 +421,29 @@ func fetchRelease(artist, album, mbid string, logf func(string)) (*albumFolder,
 		return nil, fmt.Errorf("no audio files found for %q by %s", album, artist)
 	}

-	best := bestAlbumFolder(folders)
+	// When we know the expected track count, prefer folders that match exactly
+	// so we don't accidentally grab a bonus-track edition or a different version
+	// that won't align with the release MBID we pass to beets.
+	candidates := folders
+	if trackCount > 0 {
+		var matched []albumFolder
+		for _, f := range folders {
+			if len(f.Files) == trackCount {
+				matched = append(matched, f)
+			}
+		}
+		if len(matched) > 0 {
+			log.Printf("[discover] %d/%d folders match expected track count (%d)", len(matched), len(folders), trackCount)
+			logf(fmt.Sprintf("Filtered to %d/%d folders matching expected track count (%d)",
+				len(matched), len(folders), trackCount))
+			candidates = matched
+		} else {
+			log.Printf("[discover] no folders matched expected track count (%d); using best available", trackCount)
+			logf(fmt.Sprintf("Warning: no folders matched expected track count (%d); using best available", trackCount))
+		}
+	}
+
+	best := bestAlbumFolder(candidates)
 	log.Printf("[discover] selected folder: %s from %s (%s, %d files)",
 		best.Dir, best.Username, qualityLabel(best.Quality), len(best.Files))
 	logf(fmt.Sprintf("Selected folder: %s", best.Dir))
--- a/static/app.js
+++ b/static/app.js
@ -1,9 +1,9 @@
-'use strict';
+"use strict";

 // IDs of fetch cards we've already created, so we don't duplicate them.
 const knownFetchIds = new Set();

-document.addEventListener('DOMContentLoaded', () => {
+document.addEventListener("DOMContentLoaded", () => {
  initTabs();
  initSearch();
  initFetchList();
@ -12,101 +12,124 @@ document.addEventListener('DOMContentLoaded', () => {
 // ── Tabs ───────────────────────────────────────────────────────────────────────

 function initTabs() {
-  document.querySelector('.tabs').addEventListener('click', e => {
-    const btn = e.target.closest('.tab-btn');
+  document.querySelector(".tabs").addEventListener("click", (e) => {
+    const btn = e.target.closest(".tab-btn");
    if (!btn) return;
    showTab(btn.dataset.tab);
  });
 }

 function showTab(name) {
-  document.querySelectorAll('.tab-pane').forEach(p => p.classList.remove('active'));
-  document.querySelectorAll('.tab-btn').forEach(b => b.classList.remove('active'));
-  document.getElementById('tab-' + name).classList.add('active');
-  document.querySelector(`.tab-btn[data-tab="${name}"]`).classList.add('active');
+  document
+    .querySelectorAll(".tab-pane")
+    .forEach((p) => p.classList.remove("active"));
+  document
+    .querySelectorAll(".tab-btn")
+    .forEach((b) => b.classList.remove("active"));
+  document.getElementById("tab-" + name).classList.add("active");
+  document
+    .querySelector(`.tab-btn[data-tab="${name}"]`)
+    .classList.add("active");
 }

 // ── Search ─────────────────────────────────────────────────────────────────────

-let searchType = 'release';
+let searchType = "release";

 function initSearch() {
-  document.querySelector('.type-toggle').addEventListener('click', e => {
-    const btn = e.target.closest('.type-btn');
+  document.querySelector(".type-toggle").addEventListener("click", (e) => {
+    const btn = e.target.closest(".type-btn");
    if (btn) setSearchType(btn.dataset.type);
  });

-  const searchBtn = document.getElementById('search-btn');
-  const searchInput = document.getElementById('search-q');
-  searchBtn.addEventListener('click', doSearch);
-  searchInput.addEventListener('keydown', e => { if (e.key === 'Enter') doSearch(); });
+  const searchBtn = document.getElementById("search-btn");
+  const searchInput = document.getElementById("search-q");
+  searchBtn.addEventListener("click", doSearch);
+  searchInput.addEventListener("keydown", (e) => {
+    if (e.key === "Enter") doSearch();
+  });

  // Event delegation for dynamically rendered result buttons
-  document.getElementById('search-results').addEventListener('click', e => {
-    const btn = e.target.closest('.fetch-btn');
+  document.getElementById("search-results").addEventListener("click", (e) => {
+    const btn = e.target.closest(".fetch-btn");
    if (!btn || btn.disabled) return;
-    if (btn.dataset.fetchType === 'artist') startArtistFetch(btn);
+    if (btn.dataset.fetchType === "artist") startArtistFetch(btn);
    else startReleaseFetch(btn);
  });
 }

 function setSearchType(type) {
  searchType = type;
-  document.querySelectorAll('.type-btn').forEach(b => {
-    b.classList.toggle('active', b.dataset.type === type);
+  document.querySelectorAll(".type-btn").forEach((b) => {
+    b.classList.toggle("active", b.dataset.type === type);
  });
 }

 function doSearch() {
-  const q = document.getElementById('search-q').value.trim();
+  const q = document.getElementById("search-q").value.trim();
  if (!q) return;

-  const btn = document.getElementById('search-btn');
-  const resultsEl = document.getElementById('search-results');
+  const btn = document.getElementById("search-btn");
+  const resultsEl = document.getElementById("search-results");

  btn.disabled = true;
-  btn.textContent = 'Searching\u2026';
+  btn.textContent = "Searching\u2026";
  resultsEl.innerHTML = '<p class="search-msg">Searching MusicBrainz\u2026</p>';

  fetch(`/discover/search?q=${encodeURIComponent(q)}&type=${searchType}`)
-    .then(r => {
-      if (!r.ok) return r.text().then(t => { throw new Error(t || r.statusText); });
+    .then((r) => {
+      if (!r.ok)
+        return r.text().then((t) => {
+          throw new Error(t || r.statusText);
+        });
      return r.json();
    })
-    .then(data => renderResults(data))
-    .catch(err => {
+    .then((data) => renderResults(data))
+    .catch((err) => {
      resultsEl.innerHTML = `<p class="search-msg error">Error: ${esc(err.message)}</p>`;
    })
    .finally(() => {
      btn.disabled = false;
-      btn.textContent = 'Search';
+      btn.textContent = "Search";
    });
 }

 // ── Results rendering ──────────────────────────────────────────────────────────

 function renderResults(data) {
-  const el = document.getElementById('search-results');
+  const el = document.getElementById("search-results");
  if (!data || data.length === 0) {
    el.innerHTML = '<p class="search-msg">No results found.</p>';
    return;
  }
-  const renderer = searchType === 'artist' ? renderArtist : renderRelease;
-  el.innerHTML = data.map(renderer).join('');
+  const renderer = searchType === "artist" ? renderArtist : renderRelease;
+  el.innerHTML = data.map(renderer).join("");
 }

 function renderRelease(r) {
-  const credits = r['artist-credit'] ?? [];
-  const artist = credits.map(c => c.name || c.artist?.name || '').join('') || 'Unknown Artist';
-  const year = r.date?.substring(0, 4) ?? '';
-  const type = r['release-group']?.['primary-type'] ?? '';
-  const meta = [year, type].filter(Boolean).join(' \u00b7 ');
+  const credits = r["artist-credit"] ?? [];
+  const artist =
+    credits.map((c) => c.name || c.artist?.name || "").join("") ||
+    "Unknown Artist";
+  const year = r.date?.substring(0, 4) ?? "";
+  const type = r["release-group"]?.["primary-type"] ?? "";
+  const country = r.country ?? "";
+  const formats = [
+    ...new Set((r.media ?? []).map((m) => m.format).filter(Boolean)),
+  ].join("+");
+  const lang = r["text-representation"]?.language ?? "";
+  const meta = [year, type, formats, country, lang]
+    .filter(Boolean)
+    .join(" \u00b7 ");
+  const dis = r.disambiguation ? ` (${esc(r.disambiguation)})` : "";
+  const coverUrl = `https://coverartarchive.org/release/${r.id}/front-250`;

  return `
    <div class="result-row">
+      <img class="result-cover" src="${coverUrl}" onerror="this.style.display='none'" loading="lazy" alt="">
      <div class="result-info">
-        <span class="result-title">${esc(artist)} \u2014 ${esc(r.title)}</span>
-        ${meta ? `<span class="result-meta">${esc(meta)}</span>` : ''}
+        <span class="result-title">${esc(artist)} \u2014 ${esc(r.title)}<span class="result-dis">${dis}</span></span>
+        ${meta ? `<span class="result-meta">${esc(meta)}</span>` : ""}
      </div>
      <button class="fetch-btn"
        data-fetch-type="release"
@ -117,12 +140,12 @@ function renderRelease(r) {
 }

 function renderArtist(a) {
-  const dis = a.disambiguation ? ` (${esc(a.disambiguation)})` : '';
+  const dis = a.disambiguation ? ` (${esc(a.disambiguation)})` : "";
  return `
    <div class="result-row">
      <div class="result-info">
        <span class="result-title">${esc(a.name)}${dis}</span>
-        ${a.country ? `<span class="result-meta">${esc(a.country)}</span>` : ''}
+        ${a.country ? `<span class="result-meta">${esc(a.country)}</span>` : ""}
      </div>
      <button class="fetch-btn"
        data-fetch-type="artist"
@ -136,24 +159,27 @@ function renderArtist(a) {
 function startReleaseFetch(btn) {
  const { id, artist, album } = btn.dataset;
  btn.disabled = true;
-  btn.textContent = 'Fetching\u2026';
+  btn.textContent = "Fetching\u2026";

-  fetch('/discover/fetch', {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json' },
+  fetch("/discover/fetch", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ id, artist, album }),
  })
-    .then(r => {
-      if (!r.ok) return r.text().then(t => { throw new Error(t || r.statusText); });
+    .then((r) => {
+      if (!r.ok)
+        return r.text().then((t) => {
+          throw new Error(t || r.statusText);
+        });
      return r.json();
    })
    .then(() => {
      addFetchCard(id, `${artist} \u2014 ${album}`);
      pollFetch(id);
    })
-    .catch(err => {
+    .catch((err) => {
      btn.disabled = false;
-      btn.textContent = 'Fetch';
+      btn.textContent = "Fetch";
      showFetchError(err.message);
    });
 }
@ -161,24 +187,27 @@ function startReleaseFetch(btn) {
 function startArtistFetch(btn) {
  const { id, name } = btn.dataset;
  btn.disabled = true;
-  btn.textContent = 'Fetching\u2026';
+  btn.textContent = "Fetching\u2026";

-  fetch('/discover/fetch/artist', {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json' },
+  fetch("/discover/fetch/artist", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ id, name }),
  })
-    .then(r => {
-      if (!r.ok) return r.text().then(t => { throw new Error(t || r.statusText); });
+    .then((r) => {
+      if (!r.ok)
+        return r.text().then((t) => {
+          throw new Error(t || r.statusText);
+        });
      return r.json();
    })
    .then(() => {
      addFetchCard(id, `${name} \u2014 full discography`);
      pollFetch(id);
    })
-    .catch(err => {
+    .catch((err) => {
      btn.disabled = false;
-      btn.textContent = 'Fetch All';
+      btn.textContent = "Fetch All";
      showFetchError(err.message);
    });
 }
@ -187,9 +216,9 @@ function startArtistFetch(btn) {

 function addFetchCard(id, title) {
  knownFetchIds.add(id);
-  const list = document.getElementById('fetch-list');
-  const card = document.createElement('div');
-  card.className = 'fetch-card';
+  const list = document.getElementById("fetch-list");
+  const card = document.createElement("div");
+  card.className = "fetch-card";
  card.id = `fetch-${id}`;
  card.innerHTML = `
    <div class="fetch-header">
@ -202,28 +231,28 @@ function addFetchCard(id, title) {

 function pollFetch(id) {
  fetch(`/discover/fetch/status?id=${encodeURIComponent(id)}`)
-    .then(r => r.json())
-    .then(data => {
+    .then((r) => r.json())
+    .then((data) => {
      const logEl = document.getElementById(`flog-${id}`);
      const statusEl = document.getElementById(`fstatus-${id}`);
      const card = document.getElementById(`fetch-${id}`);

      if (logEl && data.log) {
        logEl.innerHTML = data.log
-          .map(l => `<div class="log-line">${esc(l)}</div>`)
-          .join('');
+          .map((l) => `<div class="log-line">${esc(l)}</div>`)
+          .join("");
        logEl.scrollTop = logEl.scrollHeight;
      }

      if (data.done) {
        if (data.success) {
-          statusEl?.setAttribute('class', 'fetch-status fetch-status-ok');
-          if (statusEl) statusEl.textContent = '\u2713 done';
-          card?.classList.add('fetch-card-ok');
+          statusEl?.setAttribute("class", "fetch-status fetch-status-ok");
+          if (statusEl) statusEl.textContent = "\u2713 done";
+          card?.classList.add("fetch-card-ok");
        } else {
-          statusEl?.setAttribute('class', 'fetch-status fetch-status-err');
-          if (statusEl) statusEl.textContent = '\u2717 failed';
-          card?.classList.add('fetch-card-err');
+          statusEl?.setAttribute("class", "fetch-status fetch-status-err");
+          if (statusEl) statusEl.textContent = "\u2717 failed";
+          card?.classList.add("fetch-card-err");
          if (data.error && logEl) {
            logEl.innerHTML += `<div class="log-line log-line-err">${esc(data.error)}</div>`;
            logEl.scrollTop = logEl.scrollHeight;
@ -245,9 +274,9 @@ function initFetchList() {
 }

 function pollFetchList() {
-  fetch('/discover/fetch/list')
-    .then(r => r.ok ? r.json() : null)
-    .then(items => {
+  fetch("/discover/fetch/list")
+    .then((r) => (r.ok ? r.json() : null))
+    .then((items) => {
      if (!items) return;
      for (const item of items) {
        if (!knownFetchIds.has(item.id)) {
@ -264,9 +293,9 @@ function pollFetchList() {
 // ── Utilities ──────────────────────────────────────────────────────────────────

 function showFetchError(msg) {
-  const list = document.getElementById('fetch-list');
-  const el = document.createElement('div');
-  el.className = 'fetch-card fetch-card-err';
+  const list = document.getElementById("fetch-list");
+  const el = document.createElement("div");
+  el.className = "fetch-card fetch-card-err";
  el.innerHTML = `<div class="fetch-header">
    <span class="fetch-title">Fetch failed</span>
    <span class="fetch-status fetch-status-err">\u2717 error</span>
@ -276,9 +305,9 @@ function showFetchError(msg) {
 }

 function esc(s) {
-  return String(s ?? '')
-    .replace(/&/g, '&amp;')
-    .replace(/</g, '&lt;')
-    .replace(/>/g, '&gt;')
-    .replace(/"/g, '&quot;');
+  return String(s ?? "")
+    .replace(/&/g, "&amp;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;");
 }
--- a/static/style.css
+++ b/static/style.css
@ -37,10 +37,17 @@

 /* ── Reset & base ─────────────────────────────────────────────────────────── */

-*, *::before, *::after { box-sizing: border-box; }
+*,
+*::before,
+*::after {
+    box-sizing: border-box;
+}

 body {
-  font-family: system-ui, -apple-system, sans-serif;
+    font-family:
+        system-ui,
+        -apple-system,
+        sans-serif;
    background: var(--bg);
    color: var(--text);
    margin: 0;
@ -74,15 +81,21 @@ h1 {
    cursor: pointer;
    background: transparent;
    color: var(--text-muted);
-  transition: background 0.15s, color 0.15s;
+    transition:
+        background 0.15s,
+        color 0.15s;
 }
 .tab-btn.active {
    background: var(--surface-hi);
    color: var(--text);
 }

-.tab-pane         { display: none; }
-.tab-pane.active  { display: block; }
+.tab-pane {
+    display: none;
+}
+.tab-pane.active {
+    display: block;
+}

 /* ── Shared card / content container ─────────────────────────────────────── */

@ -104,7 +117,9 @@ h1 {
    color: #fff;
    transition: opacity 0.15s;
 }
-.run-btn:hover:not(:disabled) { opacity: 0.88; }
+.run-btn:hover:not(:disabled) {
+    opacity: 0.88;
+}
 .run-btn:disabled {
    background: #555;
    cursor: not-allowed;
@ -112,7 +127,9 @@ h1 {

 /* ── Import tab — session summary ────────────────────────────────────────── */

-.session { margin-top: 48px; }
+.session {
+    margin-top: 48px;
+}

 .session-header {
    display: flex;
@ -124,8 +141,15 @@ h1 {
    padding-bottom: 8px;
    margin-bottom: 20px;
 }
-.session-header h2 { margin: 0; font-size: 16px; color: var(--text-secondary); }
-.session-header .duration { font-size: 13px; color: var(--text-dim); }
+.session-header h2 {
+    margin: 0;
+    font-size: 16px;
+    color: var(--text-secondary);
+}
+.session-header .duration {
+    font-size: 13px;
+    color: var(--text-dim);
+}

 /* ── Album card ───────────────────────────────────────────────────────────── */

@ -162,9 +186,18 @@ h1 {
    white-space: nowrap;
    flex-shrink: 0;
 }
-.badge-ok    { background: var(--green-bg);  color: var(--green); }
-.badge-warn  { background: var(--amber-bg);  color: var(--amber); }
-.badge-fatal { background: var(--red-bg);    color: var(--red); }
+.badge-ok {
+    background: var(--green-bg);
+    color: var(--green);
+}
+.badge-warn {
+    background: var(--amber-bg);
+    color: var(--amber);
+}
+.badge-fatal {
+    background: var(--red-bg);
+    color: var(--red);
+}

 /* ── Metadata row ─────────────────────────────────────────────────────────── */

@ -177,7 +210,10 @@ h1 {
    color: var(--text-muted);
    margin-bottom: 12px;
 }
-.metadata-title { color: var(--text-secondary); font-size: 13px; }
+.metadata-title {
+    color: var(--text-secondary);
+    font-size: 13px;
+}

 .metadata-pill {
    display: inline-flex;
@ -188,11 +224,21 @@ h1 {
    padding: 2px 7px;
    font-size: 11px;
 }
-.pill-label        { color: var(--text-dim); }
-.pill-beets        { color: var(--pill-beets); }
-.pill-musicbrainz  { color: var(--pill-mb); }
-.pill-file_tags    { color: var(--pill-tags); }
-.pill-unknown      { color: #888; }
+.pill-label {
+    color: var(--text-dim);
+}
+.pill-beets {
+    color: var(--pill-beets);
+}
+.pill-musicbrainz {
+    color: var(--pill-mb);
+}
+.pill-file_tags {
+    color: var(--pill-tags);
+}
+.pill-unknown {
+    color: #888;
+}

 /* ── Info grid ────────────────────────────────────────────────────────────── */

@ -215,12 +261,27 @@ h1 {
    color: var(--text-dim);
    margin-bottom: 4px;
 }
-.info-card-value { color: var(--text-secondary); font-size: 13px; font-weight: 600; }
-.info-card-sub   { margin-top: 3px; color: var(--text-dim); font-size: 11px; line-height: 1.4; }
+.info-card-value {
+    color: var(--text-secondary);
+    font-size: 13px;
+    font-weight: 600;
+}
+.info-card-sub {
+    margin-top: 3px;
+    color: var(--text-dim);
+    font-size: 11px;
+    line-height: 1.4;
+}

-.info-ok   { color: var(--green); }
-.info-warn { color: var(--amber); }
-.info-dim  { color: var(--text-dim); }
+.info-ok {
+    color: var(--green);
+}
+.info-warn {
+    color: var(--amber);
+}
+.info-dim {
+    color: var(--text-dim);
+}

 /* ── Pipeline steps ───────────────────────────────────────────────────────── */

@ -245,11 +306,24 @@ h1 {
    flex-direction: column;
    gap: 2px;
 }
-.step-label { color: #888; }
-.step-ok    { color: var(--green); }
-.step-warn  { color: var(--amber); }
-.step-fatal { color: var(--red); }
-.step-err   { font-size: 11px; color: var(--red-text); margin-top: 2px; word-break: break-word; }
+.step-label {
+    color: #888;
+}
+.step-ok {
+    color: var(--green);
+}
+.step-warn {
+    color: var(--amber);
+}
+.step-fatal {
+    color: var(--red);
+}
+.step-err {
+    font-size: 11px;
+    color: var(--red-text);
+    margin-top: 2px;
+    word-break: break-word;
+}

 /* ── Discover tab — search form ───────────────────────────────────────────── */

@ -274,7 +348,9 @@ h1 {
    background: var(--surface);
    color: var(--text-muted);
    cursor: pointer;
-  transition: background 0.15s, color 0.15s;
+    transition:
+        background 0.15s,
+        color 0.15s;
    white-space: nowrap;
 }
 .type-btn.active {
@ -295,7 +371,9 @@ h1 {
    outline: none;
    transition: border-color 0.15s;
 }
-.search-input:focus { border-color: var(--border-focus); }
+.search-input:focus {
+    border-color: var(--border-focus);
+}

 .search-btn {
    font-size: 14px;
@ -309,8 +387,13 @@ h1 {
    flex-shrink: 0;
    transition: opacity 0.15s;
 }
-.search-btn:hover:not(:disabled) { opacity: 0.88; }
-.search-btn:disabled { background: #555; cursor: not-allowed; }
+.search-btn:hover:not(:disabled) {
+    opacity: 0.88;
+}
+.search-btn:disabled {
+    background: #555;
+    cursor: not-allowed;
+}

 /* ── Discover tab — search results ───────────────────────────────────────── */

@ -320,7 +403,9 @@ h1 {
    font-size: 14px;
    padding: 32px 0;
 }
-.search-msg.error { color: var(--red); }
+.search-msg.error {
+    color: var(--red);
+}

 .result-row {
    display: flex;
@ -332,7 +417,18 @@ h1 {
    padding: 12px 16px;
    margin-bottom: 8px;
 }
-.result-info { flex: 1; min-width: 0; }
+.result-cover {
+    width: 48px;
+    height: 48px;
+    object-fit: cover;
+    border-radius: var(--radius-sm);
+    flex-shrink: 0;
+    background: var(--surface-hi);
+}
+.result-info {
+    flex: 1;
+    min-width: 0;
+}
 .result-title {
    display: block;
    font-size: 14px;
@ -341,6 +437,9 @@ h1 {
    overflow: hidden;
    text-overflow: ellipsis;
 }
+.result-dis {
+    color: var(--text-dim);
+}
 .result-meta {
    display: block;
    font-size: 12px;
@ -360,12 +459,20 @@ h1 {
    white-space: nowrap;
    transition: background 0.15s;
 }
-.fetch-btn:hover:not(:disabled) { background: var(--green-hover); }
-.fetch-btn:disabled { border-color: #333; color: var(--text-dim); cursor: not-allowed; }
+.fetch-btn:hover:not(:disabled) {
+    background: var(--green-hover);
+}
+.fetch-btn:disabled {
+    border-color: #333;
+    color: var(--text-dim);
+    cursor: not-allowed;
+}

 /* ── Discover tab — fetch log cards ───────────────────────────────────────── */

-.fetch-list { margin-top: 32px; }
+.fetch-list {
+    margin-top: 32px;
+}

 .fetch-card {
    background: var(--surface);
@ -375,8 +482,12 @@ h1 {
    margin-bottom: 10px;
    transition: border-color 0.3s;
 }
-.fetch-card-ok  { border-color: var(--green-bg); }
-.fetch-card-err { border-color: var(--red-bg); }
+.fetch-card-ok {
+    border-color: var(--green-bg);
+}
+.fetch-card-err {
+    border-color: var(--red-bg);
+}

 .fetch-header {
    display: flex;
@ -400,8 +511,12 @@ h1 {
    color: var(--text-dim);
    flex-shrink: 0;
 }
-.fetch-status-ok  { color: var(--green); }
-.fetch-status-err { color: var(--red); }
+.fetch-status-ok {
+    color: var(--green);
+}
+.fetch-status-err {
+    color: var(--red);
+}

 .fetch-log {
    font-size: 12px;
@ -412,8 +527,13 @@ h1 {
    scrollbar-width: thin;
    scrollbar-color: #333 transparent;
 }
-.log-line     { padding: 1px 0; line-height: 1.5; }
-.log-line-err { color: var(--red-text); }
+.log-line {
+    padding: 1px 0;
+    line-height: 1.5;
+}
+.log-line-err {
+    color: var(--red-text);
+}

 /* ── Footer ───────────────────────────────────────────────────────────────── */

@ -431,15 +551,35 @@ footer {
 /* ── Responsive ───────────────────────────────────────────────────────────── */

@media (max-width: 600px) {
-  body { padding: 32px 16px 72px; }
-
-  .tabs { display: flex; width: 100%; }
-  .tab-btn { flex: 1; padding: 0; min-height: 40px; }
-
-  .search-form { flex-wrap: wrap; }
-  .type-toggle { width: 100%; }
-  .type-btn    { flex: 1; min-height: 38px; }
-  .search-btn  { width: 100%; }
-
-  .result-title { white-space: normal; }
+    body {
+        padding: 32px 16px 72px;
+    }
+
+    .tabs {
+        display: flex;
+        width: 100%;
+    }
+    .tab-btn {
+        flex: 1;
+        padding: 0;
+        min-height: 40px;
+    }
+
+    .search-form {
+        flex-wrap: wrap;
+    }
+    .type-toggle {
+        width: 100%;
+    }
+    .type-btn {
+        flex: 1;
+        min-height: 38px;
+    }
+    .search-btn {
+        width: 100%;
+    }
+
+    .result-title {
+        white-space: normal;
+    }
 }
Author	SHA1	Message	Date
Gabe Farrell	93a5fc411e	resize too-large cover images	2026-04-12 19:42:31 -04:00
Gabe Farrell	769f3ff08c	prefer release with no disambiguation, match track counts	2026-04-12 19:33:38 -04:00
Gabe Farrell	b910e32d6c	text representation and disambiguation to releases	2026-04-10 10:18:19 -04:00
Gabe Farrell	a937f4a38e	better artist rg -> release picking	2026-04-10 09:43:23 -04:00
Gabe Farrell	eca7f4ba31	better release search. artist search just ok	2026-04-09 19:57:47 -04:00