feat: a release catalogue from MusicBrainz; request search asks it directly (M502 #5519)

Minstrel keeps its own record of what artists have released, read from
MusicBrainz, so the wanted list, search and import no longer need Lidarr.

- internal/musicbrainz: searches (artists, release groups, recordings) and
  browses (an artist's release groups; a group's releases with track lists).
  One process-wide pacer at 1.1s, shared with tag enrichment, because
  MusicBrainz's limit is per address. A 503 throttle is retried.
- Migration 0080: mb_artists, mb_release_groups, mb_artist_release_groups
  (a collaboration belongs to each credited artist), mb_releases,
  mb_release_tracks.
- internal/catalogue: Discography and Releases serve the held copy and
  re-read it when older than 7 or 30 days. An unreachable MusicBrainz
  serves the stale copy, marked. An hourly pass re-reads due artists.
- Art for what isn't held comes through /api/catalogue/art from the
  enabled cover-art sources (Cover Art Archive by release group, then the
  name-based sources) and is kept on disk, so the browser never fetches a
  third-party host. A miss is a 404 and the card shows its icon.
- Request search moves from /api/lidarr/search to /api/catalogue/search,
  with the same response shape. Albums are release groups, and "in
  library" matches albums.release_group_mbid. A 10-minute cache absorbs
  search-as-you-type. Discover suggestions point at the art endpoint
  instead of looking up Lidarr.
- Android calls the new path and loads Discover art through ServerImage.
  Installed builds older than this one lose Discover search until they
  update (no compatibility path, rule 22).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

web/src/lib/api/catalogue.test.ts

@@ -9,39 +9,39 @@ vi.mock('./client', () => ({
   }
 }));
 
-import { searchLidarr } from './lidarr';
+import { searchCatalogue } from './catalogue';
 import { api } from './client';
 import { qk } from './queries';
-import type { LidarrSearchResult } from './types';
+import type { CatalogueSearchResult } from './types';
 
 beforeEach(() => {
   vi.clearAllMocks();
 });
 
-describe('searchLidarr', () => {
+describe('searchCatalogue', () => {
   test('builds URL with q and kind query params', async () => {
     (api.get as ReturnType<typeof vi.fn>).mockResolvedValueOnce([]);
-    await searchLidarr('aphex twin', 'artist');
-    expect(api.get).toHaveBeenCalledWith('/api/lidarr/search?q=aphex+twin&kind=artist');
+    await searchCatalogue('aphex twin', 'artist');
+    expect(api.get).toHaveBeenCalledWith('/api/catalogue/search?q=aphex+twin&kind=artist');
   });
 
   test('encodes special characters in q (quotes, ampersands, plus)', async () => {
     (api.get as ReturnType<typeof vi.fn>).mockResolvedValueOnce([]);
-    await searchLidarr('boards of canada & friends', 'album');
+    await searchCatalogue('boards of canada & friends', 'album');
     const calledWith = (api.get as ReturnType<typeof vi.fn>).mock.calls[0][0] as string;
     // URLSearchParams encodes space as '+' and '&' as '%26'.
     expect(calledWith).toBe(
-      '/api/lidarr/search?q=boards+of+canada+%26+friends&kind=album'
+      '/api/catalogue/search?q=boards+of+canada+%26+friends&kind=album'
     );
   });
 
   test('passes through results unchanged', async () => {
-    const fixture: LidarrSearchResult[] = [
+    const fixture: CatalogueSearchResult[] = [
       {
         mbid: 'mbid-1',
         name: 'Aphex Twin',
         secondary_text: 'Electronic',
-        image_url: 'https://example.test/img.jpg',
+        image_url: '/api/catalogue/art/artist/mbid-1?name=Aphex+Twin',
         artist_mbid: '',
         album_mbid: '',
         in_library: false,
@@ -49,24 +49,24 @@ describe('searchLidarr', () => {
       }
     ];
     (api.get as ReturnType<typeof vi.fn>).mockResolvedValueOnce(fixture);
-    const out = await searchLidarr('aphex', 'artist');
+    const out = await searchCatalogue('aphex', 'artist');
     expect(out).toBe(fixture);
   });
 
   test('propagates errors from api.get', async () => {
-    const err = { code: 'lidarr_unavailable', message: 'down', status: 503 };
+    const err = { code: 'musicbrainz_unreachable', message: 'down', status: 503 };
     (api.get as ReturnType<typeof vi.fn>).mockRejectedValueOnce(err);
-    await expect(searchLidarr('x', 'track')).rejects.toMatchObject({
-      code: 'lidarr_unavailable',
+    await expect(searchCatalogue('x', 'track')).rejects.toMatchObject({
+      code: 'musicbrainz_unreachable',
       status: 503
     });
   });
 });
 
-describe('qk.lidarrSearch', () => {
+describe('qk.catalogueSearch', () => {
   test('keys include q + kind', () => {
-    expect(qk.lidarrSearch('foo', 'artist')).toEqual([
-      'lidarrSearch',
+    expect(qk.catalogueSearch('foo', 'artist')).toEqual([
+      'catalogueSearch',
       { q: 'foo', kind: 'artist' }
     ]);
   });

web/src/lib/api/catalogue.ts

@@ -0,0 +1,26 @@
+import { createQuery } from '@tanstack/svelte-query';
+import { api } from './client';
+import { qk } from './queries';
+import type { CatalogueSearchResult, LidarrRequestKind } from './types';
+
+// searchCatalogue asks MusicBrainz through Minstrel's release catalogue
+// (M502 #5519). URLSearchParams handles encoding (spaces, quotes,
+// ampersands) so callers can pass q raw.
+export async function searchCatalogue(
+  q: string,
+  kind: LidarrRequestKind
+): Promise<CatalogueSearchResult[]> {
+  const params = new URLSearchParams({ q, kind });
+  return api.get<CatalogueSearchResult[]>(`/api/catalogue/search?${params.toString()}`);
+}
+
+// MusicBrainz allows a request a second, so a repeated search within a minute
+// is served from the client's cache rather than asked again.
+export function createCatalogueSearchQuery(q: string, kind: LidarrRequestKind) {
+  return createQuery({
+    queryKey: qk.catalogueSearch(q, kind),
+    queryFn: () => searchCatalogue(q, kind),
+    enabled: q.length > 0,
+    staleTime: 60_000
+  });
+}

web/src/lib/api/lidarr.ts

@@ -1,28 +0,0 @@
-import { createQuery } from '@tanstack/svelte-query';
-import { api } from './client';
-import { qk } from './queries';
-import type { LidarrSearchResult, LidarrRequestKind } from './types';
-
-// Search-only. Admin-side Lidarr config + connection probing lives in admin.ts.
-
-// searchLidarr proxies the user-facing Lidarr search endpoint. URLSearchParams
-// handles encoding (spaces, quotes, ampersands) so callers can pass q raw.
-export async function searchLidarr(
-  q: string,
-  kind: LidarrRequestKind
-): Promise<LidarrSearchResult[]> {
-  const params = new URLSearchParams({ q, kind });
-  return api.get<LidarrSearchResult[]>(`/api/lidarr/search?${params.toString()}`);
-}
-
-// staleTime mirrors the spec §11 60s server-side LRU cache: re-issuing the
-// same query within a minute hits cache on the server, so there's no point
-// in marking it stale client-side any sooner.
-export function createLidarrSearchQuery(q: string, kind: LidarrRequestKind) {
-  return createQuery({
-    queryKey: qk.lidarrSearch(q, kind),
-    queryFn: () => searchLidarr(q, kind),
-    enabled: q.length > 0,
-    staleTime: 60_000
-  });
-}

web/src/lib/api/queries.ts

@@ -30,8 +30,8 @@ export const qk = {
   likedArtists:  ()          => ['likedArtists'] as const,
   history:       ()          => ['history'] as const,
   // Lidarr / requests / admin.
-  lidarrSearch:          (q: string, kind: string) =>
-    ['lidarrSearch', { q, kind }] as const,
+  catalogueSearch:       (q: string, kind: string) =>
+    ['catalogueSearch', { q, kind }] as const,
   myRequests:            () => ['myRequests'] as const,
   lidarrConfig:          () => ['lidarrConfig'] as const,
   lidarrQualityProfiles:  () => ['lidarrQualityProfiles'] as const,

web/src/lib/api/types.ts

@@ -146,7 +146,10 @@ export type LidarrRequestStatus =
 
 export type LidarrRequestKind = 'artist' | 'album' | 'track';
 
-export type LidarrSearchResult = {
+// One row of the request search (GET /api/catalogue/search, M502 #5519).
+// An album is a MusicBrainz release group; image_url is Minstrel's own art
+// endpoint, which answers 404 when no source has an image.
+export type CatalogueSearchResult = {
   mbid: string;
   name: string;
   secondary_text: string;

web/src/lib/components/DiscoverResultCard.svelte

@@ -28,12 +28,21 @@
     state: DiscoverCardState;
     attribution?: string;
     onRequest?: () => void;
-    // Omit both to get a card with no snooze affordance — the Lidarr search
+    // Omit both to get a card with no snooze affordance — the catalogue search
     // results reuse this component and have nothing to park.
     onSnooze?: () => void;
     onUnsnooze?: () => void;
   } = $props();
 
+  // Art comes from Minstrel's catalogue endpoint, which answers 404 when no
+  // source has an image (M502 #5519): show the icon then, not a broken image.
+  // Reset when the card is reused for another result.
+  let imageFailed = $state(false);
+  $effect(() => {
+    void imageUrl;
+    imageFailed = false;
+  });
+
   const FallbackIcon = $derived(
     kind === 'artist' ? Disc3 : kind === 'album' ? Album : Music2
   );
@@ -50,12 +59,13 @@
   <div
     class="art flex aspect-square w-full items-center justify-center overflow-hidden rounded-md bg-surface-hover"
   >
-    {#if imageUrl}
+    {#if imageUrl && !imageFailed}
       <img
         src={imageUrl}
         alt=""
         loading="lazy"
         class="h-full w-full object-cover"
+        onerror={() => (imageFailed = true)}
       />
     {:else}
       <FallbackIcon size={32} strokeWidth={1} class="text-text-muted" />

web/src/lib/components/DiscoverResultCard.test.ts

@@ -168,4 +168,20 @@ describe('DiscoverResultCard', () => {
     expect(onUnsnooze).toHaveBeenCalledOnce();
     expect(onRequest).not.toHaveBeenCalled();
   });
+
+  test('an image that fails to load falls back to the icon', async () => {
+    const { container } = render(DiscoverResultCard, {
+      props: {
+        kind: 'artist',
+        title: 'Boards of Canada',
+        state: 'requestable',
+        imageUrl: '/api/catalogue/art/artist/x',
+      },
+    });
+    const img = container.querySelector('img');
+    expect(img).not.toBeNull();
+    await fireEvent.error(img!);
+    expect(container.querySelector('img')).toBeNull();
+    expect(container.querySelector('.art svg')).not.toBeNull();
+  });
 });

web/src/lib/styles/error-copy.json

@@ -30,6 +30,7 @@
   "mbid_required": "An MBID is required for this lookup.",
   "system_playlist_readonly": "System playlists can't be edited directly.",
   "connection_refused": "Couldn't reach the server. Check the URL and try again.",
+  "musicbrainz_unreachable": "MusicBrainz can't be reached right now, so search is unavailable. Try again in a minute.",
   "lidarr_unreachable": "Lidarr is unreachable right now. Try again, or check Admin → Integrations.",
   "lidarr_disabled": "Lidarr integration is not enabled.",
   "lidarr_auth_failed": "Lidarr authentication failed.",