From 55b85ac28f336c6048c661a0f75f5cbee9476ebd Mon Sep 17 00:00:00 2001
From: "r.osipin" <r.osipin@whyhappen.ru>
Date: Sun, 31 May 2026 23:13:07 +0300
Subject: [PATCH 1/3] Add Discogs release review UI

---
 src/App.discogs-release-autocomplete.test.tsx | 266 ++++++++++
 .../catalog/api/catalogEntityMappers.ts       |   1 +
 src/features/catalog/api/catalogTypes.ts      |   2 +
 .../catalog/api/externalMetadataClient.ts     | 150 ++++++
 src/features/catalog/api/httpClient.ts        |  12 +-
 src/features/catalog/api/releaseClient.ts     |   6 +
 .../catalog/catalogApi.mutations.test.ts      |  54 ++
 src/features/catalog/catalogApi.ts            |   1 +
 .../catalog/externalMetadataClient.test.ts    | 189 +++++++
 .../releases/DiscogsReleaseLookupPanel.tsx    | 468 ++++++++++++++++++
 src/features/releases/ReleaseDetail.tsx       |  15 +-
 src/features/releases/ReleaseEntryForm.tsx    | 156 +++++-
 .../releases/ReleaseEntryFormTypes.ts         |   1 +
 src/features/releases/ReleasesWorkspace.tsx   |  20 +-
 src/features/releases/release-form.css        | 185 +++++++
 src/features/releases/release-tracklist.css   |  27 +
 src/features/releases/releaseSubmit.ts        |   3 +
 src/features/releases/releasesData.ts         |   6 +-
 .../releases/useReleaseTrackDrafts.ts         |   6 +
 src/styles/responsive.css                     |   4 +
 20 files changed, 1565 insertions(+), 7 deletions(-)
 create mode 100644 src/App.discogs-release-autocomplete.test.tsx
 create mode 100644 src/features/catalog/api/externalMetadataClient.ts
 create mode 100644 src/features/catalog/externalMetadataClient.test.ts
 create mode 100644 src/features/releases/DiscogsReleaseLookupPanel.tsx

diff --git a/src/App.discogs-release-autocomplete.test.tsx b/src/App.discogs-release-autocomplete.test.tsx
new file mode 100644
index 0000000..4f5e2c6
--- /dev/null
+++ b/src/App.discogs-release-autocomplete.test.tsx
@@ -0,0 +1,266 @@
+import { describe, expect, it } from 'vitest'
+import * as h from './test/appTestHarness'
+
+h.setupAppTestHooks()
+
+describe('App Discogs release autocomplete', () => {
+  it('searches release candidates and prefills a new release only after review apply', async () => {
+    window.history.pushState({}, '', '/releases')
+    const fetchMock = h.vi.fn<Window['fetch']>().mockImplementation((input) => {
+      const url = requestUrl(input)
+
+      if (url.pathname === '/api/external-metadata/discogs/releases') {
+        return Promise.resolve(
+          h.jsonResponse({
+            items: [
+              {
+                source: source('249504'),
+                title: 'Blue Monday',
+                artists: ['New Order'],
+                year: 1983,
+                labels: ['Factory'],
+                formats: ['Vinyl', '12"'],
+                catalogNumber: 'FAC 73',
+                barcodes: ['5016839200371'],
+              },
+            ],
+            limit: 25,
+            total: 1,
+          }),
+        )
+      }
+
+      if (url.pathname === '/api/external-metadata/discogs/releases/249504') {
+        return Promise.resolve(h.jsonResponse(releaseDetail()))
+      }
+
+      throw new Error(`Unexpected request: ${url.pathname}`)
+    })
+    h.vi.stubGlobal('fetch', fetchMock)
+    const user = h.userEvent.setup()
+    h.render(<h.App />)
+
+    await user.click(h.screen.getByRole('button', { name: 'Add release' }))
+    const form = h.screen.getByRole('form', { name: 'Add release' })
+
+    await user.type(
+      h.within(form).getByLabelText('Title'),
+      'Local working title',
+    )
+    await user.click(
+      h.within(form).getByRole('button', { name: 'Search Discogs' }),
+    )
+
+    const lookup = h.within(form).getByRole('region', {
+      name: 'Discogs release lookup',
+    })
+    await user.click(
+      h.within(lookup).getByRole('button', { name: 'Search Discogs releases' }),
+    )
+    await user.click(
+      await h.within(lookup).findByRole('button', {
+        name: /review blue monday/i,
+      }),
+    )
+
+    expect(h.within(form).getByLabelText('Title')).toHaveValue(
+      'Local working title',
+    )
+    expect(
+      await h.within(lookup).findByRole('heading', {
+        name: 'Review Discogs candidate',
+      }),
+    ).toBeInTheDocument()
+    expect(
+      h.within(lookup).getAllByText('Data provided by Discogs.').length,
+    ).toBeGreaterThan(0)
+    expect(
+      h.within(lookup).getByRole('link', { name: 'Open Discogs source' }),
+    ).toHaveAttribute('href', 'https://www.discogs.com/release/249504')
+
+    await user.click(
+      h.within(lookup).getByRole('button', {
+        name: 'Apply selected Discogs fields',
+      }),
+    )
+
+    expect(h.within(form).getByLabelText('Title')).toHaveValue('Blue Monday')
+    expect(h.within(form).getByText('Factory')).toBeInTheDocument()
+    expect(h.within(form).getByText('FAC 73')).toBeInTheDocument()
+    expect(h.within(form).getAllByText('Blue Monday').length).toBeGreaterThan(0)
+    expect(
+      h.within(form).getByRole('button', { name: 'Add record' }),
+    ).toBeDisabled()
+    expect(
+      h.screen.queryByRole('complementary', { name: 'Blue Monday' }),
+    ).not.toBeInTheDocument()
+  })
+
+  it('reviews an existing release update before applying selected field groups and provenance', async () => {
+    window.history.pushState({}, '', '/releases?release=blue-monday')
+    const fetchMock = h.vi.fn<Window['fetch']>().mockImplementation((input) => {
+      const url = requestUrl(input)
+
+      if (url.pathname === '/api/external-metadata/discogs/releases') {
+        return Promise.resolve(
+          h.jsonResponse({
+            items: [
+              {
+                source: source('249504'),
+                title: 'Blue Monday 12"',
+                artists: ['New Order'],
+                year: 1983,
+                labels: ['Factory'],
+                formats: ['Vinyl', '12"'],
+                catalogNumber: 'FAC 73',
+                barcodes: [],
+              },
+            ],
+            limit: 25,
+            total: 1,
+          }),
+        )
+      }
+
+      if (url.pathname === '/api/external-metadata/discogs/releases/249504') {
+        return Promise.resolve(
+          h.jsonResponse({
+            ...releaseDetail(),
+            title: 'Blue Monday 12"',
+            draft: {
+              ...releaseDetail().draft,
+              title: 'Blue Monday 12"',
+            },
+          }),
+        )
+      }
+
+      throw new Error(`Unexpected request: ${url.pathname}`)
+    })
+    h.vi.stubGlobal('fetch', fetchMock)
+    const user = h.userEvent.setup()
+    h.render(<h.App />)
+
+    await user.click(
+      h.screen.getByRole('button', { name: 'Update via Discogs' }),
+    )
+    const form = h.screen.getByRole('form', { name: 'Edit release' })
+    const lookup = h.within(form).getByRole('region', {
+      name: 'Discogs release lookup',
+    })
+
+    await user.click(
+      h.within(lookup).getByRole('button', { name: 'Search Discogs releases' }),
+    )
+    await user.click(
+      await h.within(lookup).findByRole('button', {
+        name: /review blue monday 12/i,
+      }),
+    )
+
+    expect(h.within(form).getByLabelText('Title')).toHaveValue('Blue Monday')
+
+    await user.click(h.within(lookup).getByLabelText('Apply Core'))
+    await user.click(h.within(lookup).getByLabelText('Apply External Source'))
+    await user.click(
+      h.within(lookup).getByRole('button', {
+        name: 'Apply selected Discogs fields',
+      }),
+    )
+
+    expect(h.within(form).getByLabelText('Title')).toHaveValue(
+      'Blue Monday 12"',
+    )
+
+    await user.click(
+      h.within(form).getByRole('button', { name: 'Save record' }),
+    )
+
+    const updatedRelease = h
+      .getInitialCatalogStateForTests()
+      ?.releases.find((release) => release.id === 'blue-monday')
+    expect(updatedRelease).toMatchObject({
+      title: 'Blue Monday 12"',
+      externalSources: [
+        {
+          providerName: 'discogs',
+          resourceType: 'release',
+          externalId: '249504',
+          sourceUrl: 'https://www.discogs.com/release/249504',
+        },
+      ],
+    })
+    expect(updatedRelease?.externalSources?.[0].appliedAt).toMatch(
+      /^\d{4}-\d{2}-\d{2}T/,
+    )
+  })
+})
+
+function requestUrl(input: Parameters<Window['fetch']>[0]) {
+  if (typeof input === 'string' || input instanceof URL) {
+    return new URL(input, 'http://localhost')
+  }
+
+  return new URL(input.url, 'http://localhost')
+}
+
+function source(externalId: string) {
+  return {
+    providerName: 'discogs',
+    resourceType: 'release',
+    externalId,
+    sourceUrl: `https://www.discogs.com/release/${externalId}`,
+    attribution: 'Data provided by Discogs.',
+  }
+}
+
+function releaseDetail() {
+  return {
+    source: source('249504'),
+    title: 'Blue Monday',
+    artists: ['New Order'],
+    year: 1983,
+    labels: ['Factory'],
+    formats: ['Vinyl', '12"'],
+    tracklist: [
+      {
+        title: 'Blue Monday',
+        position: 'A',
+        durationSeconds: 449,
+        artists: ['New Order'],
+      },
+    ],
+    identifiers: [{ type: 'Barcode', value: '5016839200371' }],
+    barcodes: ['5016839200371'],
+    catalogNumber: 'FAC 73',
+    credits: [{ name: 'New Order', role: 'Written-By' }],
+    draft: {
+      title: 'Blue Monday',
+      year: 1983,
+      artistCredits: [{ name: 'New Order', role: 'mainArtist' }],
+      labels: [
+        {
+          name: 'Factory',
+          catalogNumber: 'FAC 73',
+          hasNoCatalogNumber: false,
+        },
+      ],
+      tracklist: [
+        {
+          title: 'Blue Monday',
+          position: 1,
+          durationSeconds: 449,
+          artistCredits: [{ name: 'New Order', role: 'mainArtist' }],
+        },
+      ],
+      externalSources: [
+        {
+          providerName: 'discogs',
+          resourceType: 'release',
+          externalId: '249504',
+          sourceUrl: 'https://www.discogs.com/release/249504',
+        },
+      ],
+    },
+  }
+}
diff --git a/src/features/catalog/api/catalogEntityMappers.ts b/src/features/catalog/api/catalogEntityMappers.ts
index 2a22457..be00879 100644
--- a/src/features/catalog/api/catalogEntityMappers.ts
+++ b/src/features/catalog/api/catalogEntityMappers.ts
@@ -185,6 +185,7 @@ export function toReleaseRecord(
     coverImage: release.coverImage
       ? toReleaseCoverImage(release.coverImage)
       : undefined,
+    externalSources: release.externalSources ?? [],
     ownedCopies: [
       ...ownedItems
         .filter(
diff --git a/src/features/catalog/api/catalogTypes.ts b/src/features/catalog/api/catalogTypes.ts
index 4691027..f54119a 100644
--- a/src/features/catalog/api/catalogTypes.ts
+++ b/src/features/catalog/api/catalogTypes.ts
@@ -8,6 +8,7 @@ import type {
 import type { ReleaseRecord } from '../../releases/releasesData'
 import type { RelationRecord } from '../../relations/relationsData'
 import type { TrackRecord } from '../../tracks/tracksData'
+import type { ExternalSourceReference } from './externalMetadataClient'
 
 export const pageSize = 100
 
@@ -337,6 +338,7 @@ export type ReleaseDto = {
   artistCredits?: ReleaseArtistCreditDto[]
   labels?: ReleaseLabelDto[]
   tracklist?: ReleaseTracklistItemDto[]
+  externalSources?: ExternalSourceReference[] | null
 }
 
 export type ReleaseCoverImageDto = {
diff --git a/src/features/catalog/api/externalMetadataClient.ts b/src/features/catalog/api/externalMetadataClient.ts
new file mode 100644
index 0000000..d8dbd35
--- /dev/null
+++ b/src/features/catalog/api/externalMetadataClient.ts
@@ -0,0 +1,150 @@
+import { assertNoCollectionIds, CatalogApiError } from './httpClient'
+
+export type ExternalMetadataSourceDto = {
+  providerName: string
+  resourceType: string
+  externalId: string
+  sourceUrl: string
+  attribution: string
+}
+
+export type ExternalSourceReference = {
+  providerName: string
+  resourceType: string
+  externalId: string
+  sourceUrl: string
+  appliedAt?: string
+}
+
+export type DiscogsReleaseSearchParams = {
+  query?: string
+  artist?: string
+  title?: string
+  year?: string
+  barcode?: string
+  catalogNumber?: string
+  limit?: number
+}
+
+export type DiscogsReleaseSearchResponse = {
+  items: ExternalMetadataReleaseCandidateDto[]
+  limit: number
+  total: number
+}
+
+export type ExternalMetadataReleaseCandidateDto = {
+  source: ExternalMetadataSourceDto
+  title: string
+  artists: string[]
+  year?: number | null
+  labels: string[]
+  formats: string[]
+  catalogNumber?: string | null
+  barcodes: string[]
+}
+
+export type ExternalMetadataReleaseDetailDto =
+  ExternalMetadataReleaseCandidateDto & {
+    tracklist: ExternalMetadataReleaseTrackDto[]
+    identifiers: ExternalMetadataReleaseIdentifierDto[]
+    credits: ExternalMetadataReleaseCreditDto[]
+    draft: ExternalMetadataReleaseDraftDto
+  }
+
+export type ExternalMetadataReleaseTrackDto = {
+  title: string
+  position?: string | null
+  durationSeconds?: number | null
+  artists: string[]
+}
+
+export type ExternalMetadataReleaseIdentifierDto = {
+  type: string
+  value: string
+}
+
+export type ExternalMetadataReleaseCreditDto = {
+  name: string
+  role: string
+  trackTitle?: string | null
+  trackPosition?: string | null
+}
+
+export type ExternalMetadataReleaseDraftDto = {
+  title: string
+  year?: number | null
+  artistCredits: ExternalMetadataReleaseDraftArtistCreditDto[]
+  labels: ExternalMetadataReleaseDraftLabelDto[]
+  tracklist: ExternalMetadataReleaseDraftTrackDto[]
+  externalSources: ExternalSourceReference[]
+}
+
+export type ExternalMetadataReleaseDraftArtistCreditDto = {
+  name: string
+  role: string
+}
+
+export type ExternalMetadataReleaseDraftLabelDto = {
+  name: string
+  catalogNumber?: string | null
+  hasNoCatalogNumber: boolean
+}
+
+export type ExternalMetadataReleaseDraftTrackDto = {
+  title: string
+  position: number
+  durationSeconds?: number | null
+  artistCredits: ExternalMetadataReleaseDraftArtistCreditDto[]
+}
+
+export async function searchDiscogsReleases(
+  params: DiscogsReleaseSearchParams,
+) {
+  const query = new URLSearchParams()
+  appendTrimmed(query, 'query', params.query)
+  appendTrimmed(query, 'artist', params.artist)
+  appendTrimmed(query, 'title', params.title)
+  appendTrimmed(query, 'year', params.year)
+  appendTrimmed(query, 'barcode', params.barcode)
+  appendTrimmed(query, 'catalogNumber', params.catalogNumber)
+  query.set('limit', String(params.limit ?? 25))
+
+  return getExternalMetadataJson<DiscogsReleaseSearchResponse>(
+    `/api/external-metadata/discogs/releases?${query.toString()}`,
+  )
+}
+
+export async function getDiscogsRelease(externalId: string) {
+  return getExternalMetadataJson<ExternalMetadataReleaseDetailDto>(
+    `/api/external-metadata/discogs/releases/${encodeURIComponent(
+      externalId.trim(),
+    )}`,
+  )
+}
+
+async function getExternalMetadataJson<T>(path: string): Promise<T> {
+  const response = await fetch(path, {
+    credentials: 'include',
+    method: 'GET',
+  })
+
+  if (!response.ok) {
+    throw await CatalogApiError.fromResponse(response)
+  }
+
+  const body = (await response.json()) as T
+  assertNoCollectionIds(body)
+
+  return body
+}
+
+function appendTrimmed(
+  query: URLSearchParams,
+  name: string,
+  value: string | undefined,
+) {
+  const trimmed = value?.trim()
+  if (trimmed) {
+    query.set(name, trimmed)
+  }
+}
diff --git a/src/features/catalog/api/httpClient.ts b/src/features/catalog/api/httpClient.ts
index 7766cf1..a6388f6 100644
--- a/src/features/catalog/api/httpClient.ts
+++ b/src/features/catalog/api/httpClient.ts
@@ -162,11 +162,18 @@ export async function readJsonBody<T>(response: Response): Promise<T | null> {
 export class CatalogApiError extends Error {
   readonly status: number
   readonly code: string | null
-
-  private constructor(status: number, code: string | null, message: string) {
+  readonly retryAfter: string | null
+
+  private constructor(
+    status: number,
+    code: string | null,
+    message: string,
+    retryAfter: string | null,
+  ) {
     super(message)
     this.status = status
     this.code = code
+    this.retryAfter = retryAfter
   }
 
   static async fromResponse(response: Response) {
@@ -177,6 +184,7 @@ export class CatalogApiError extends Error {
       body?.code ?? null,
       body?.message ??
         `Catalog API request failed with HTTP ${response.status}.`,
+      response.headers.get('Retry-After'),
     )
   }
 }
diff --git a/src/features/catalog/api/releaseClient.ts b/src/features/catalog/api/releaseClient.ts
index 61aeea0..9a716d1 100644
--- a/src/features/catalog/api/releaseClient.ts
+++ b/src/features/catalog/api/releaseClient.ts
@@ -71,6 +71,9 @@ export async function createRelease(
     releaseDate: release.releaseDate ?? null,
     genres: release.genres,
     tags: release.tags,
+    ...(release.externalSources === undefined
+      ? {}
+      : { externalSources: release.externalSources }),
     tracklist: tracks.map(toReleaseTracklistRequest),
     ownedCopy: release.ownedCopies[0]
       ? {
@@ -154,6 +157,9 @@ export async function updateRelease(
     releaseDate: release.releaseDate ?? null,
     genres: release.genres,
     tags: release.tags,
+    ...(release.externalSources === undefined
+      ? {}
+      : { externalSources: release.externalSources }),
     ...(tracks === undefined
       ? {}
       : { tracklist: tracks.map(toReleaseTracklistRequest) }),
diff --git a/src/features/catalog/catalogApi.mutations.test.ts b/src/features/catalog/catalogApi.mutations.test.ts
index 0c91371..e515ff1 100644
--- a/src/features/catalog/catalogApi.mutations.test.ts
+++ b/src/features/catalog/catalogApi.mutations.test.ts
@@ -1,10 +1,64 @@
 import { describe, expect, it, vi } from 'vitest'
 import * as api from './catalogApi'
 import * as h from './catalogApiTestHarness'
+import type { ReleaseRecord } from '../releases/releasesData'
 
 h.setupCatalogApiAdapterTests()
 
 describe('catalog API adapter mutations and covers', () => {
+  it('sends release-level external sources on create and update', async () => {
+    const fetchMock = vi.fn<Window['fetch']>()
+    fetchMock
+      .mockResolvedValueOnce(h.jsonResponse({ id: 'release-id' }, 201))
+      .mockResolvedValueOnce(h.jsonResponse({ id: 'release-id' }))
+    vi.stubGlobal('fetch', fetchMock)
+    const release: ReleaseRecord = {
+      id: 'release-id',
+      title: 'Discogs Sourced EP',
+      artist: 'Source Artist',
+      artistCredits: [{ artist: 'Source Artist', role: 'Main artist' }],
+      type: 'EP',
+      year: '2026',
+      label: 'Source Label',
+      labels: [
+        {
+          name: 'Source Label',
+          catalogNumber: 'SRC-1',
+          hasNoCatalogNumber: false,
+        },
+      ],
+      genres: ['Electronic'],
+      tags: [],
+      releaseNotes: '',
+      ownedCopies: [],
+      externalSources: [
+        {
+          providerName: 'discogs',
+          resourceType: 'release',
+          externalId: '249504',
+          sourceUrl: 'https://www.discogs.com/release/249504',
+          appliedAt: '2026-05-31T19:00:00.000Z',
+        },
+      ],
+    }
+
+    await api.createRelease(release, [])
+    await api.updateRelease(release, [])
+
+    expect(fetchMock.mock.calls[0][0]).toBe('/api/releases')
+    expect(fetchMock.mock.calls[1][0]).toBe('/api/releases/release-id')
+    expect(
+      h.requestPayload<Record<string, unknown>>(fetchMock.mock.calls[0][1]),
+    ).toMatchObject({
+      externalSources: release.externalSources,
+    })
+    expect(
+      h.requestPayload<Record<string, unknown>>(fetchMock.mock.calls[1][1]),
+    ).toMatchObject({
+      externalSources: release.externalSources,
+    })
+  })
+
   it('rejects invalid rating values before sending a request', async () => {
     const fetchMock = vi.fn<Window['fetch']>()
     vi.stubGlobal('fetch', fetchMock)
diff --git a/src/features/catalog/catalogApi.ts b/src/features/catalog/catalogApi.ts
index bdb9678..4966dad 100644
--- a/src/features/catalog/catalogApi.ts
+++ b/src/features/catalog/catalogApi.ts
@@ -3,6 +3,7 @@ export * from './api/catalogDefaults'
 export * from './api/catalogLoadClient'
 export * from './api/catalogTypes'
 export * from './api/httpClient'
+export * from './api/externalMetadataClient'
 export * from './api/importsExportsClient'
 export * from './api/ownedRelationsClient'
 export * from './api/ownedItemsClient'
diff --git a/src/features/catalog/externalMetadataClient.test.ts b/src/features/catalog/externalMetadataClient.test.ts
new file mode 100644
index 0000000..26909f1
--- /dev/null
+++ b/src/features/catalog/externalMetadataClient.test.ts
@@ -0,0 +1,189 @@
+import { describe, expect, it, vi } from 'vitest'
+import {
+  getDiscogsRelease,
+  searchDiscogsReleases,
+} from './api/externalMetadataClient'
+import { CatalogApiError } from './api/httpClient'
+import * as h from './catalogApiTestHarness'
+
+h.setupCatalogApiAdapterTests()
+
+describe('external metadata API client', () => {
+  it('searches Discogs releases with trimmed collection-scoped query params', async () => {
+    const fetchMock = vi.fn<Window['fetch']>().mockResolvedValue(
+      h.jsonResponse({
+        items: [
+          {
+            source: source('release', '249504'),
+            title: 'Blue Monday',
+            artists: ['New Order'],
+            year: 1983,
+            labels: ['Factory'],
+            formats: ['Vinyl', '12"'],
+            catalogNumber: 'FAC 73',
+            barcodes: ['5016839200371'],
+          },
+        ],
+        limit: 25,
+        total: 1,
+      }),
+    )
+    vi.stubGlobal('fetch', fetchMock)
+
+    const result = await searchDiscogsReleases({
+      query: ' factory ',
+      artist: ' New Order ',
+      title: ' Blue Monday ',
+      year: ' 1983 ',
+      barcode: ' 5016839200371 ',
+      catalogNumber: ' FAC 73 ',
+      limit: 25,
+    })
+
+    const url = requestUrl(fetchMock.mock.calls[0][0])
+    expect(url.pathname).toBe('/api/external-metadata/discogs/releases')
+    expect(url.searchParams.get('query')).toBe('factory')
+    expect(url.searchParams.get('artist')).toBe('New Order')
+    expect(url.searchParams.get('title')).toBe('Blue Monday')
+    expect(url.searchParams.get('year')).toBe('1983')
+    expect(url.searchParams.get('barcode')).toBe('5016839200371')
+    expect(url.searchParams.get('catalogNumber')).toBe('FAC 73')
+    expect(url.searchParams.get('limit')).toBe('25')
+    expect(fetchMock.mock.calls[0][1]).toMatchObject({
+      credentials: 'include',
+      method: 'GET',
+    })
+    expect(result.items[0]).toMatchObject({
+      title: 'Blue Monday',
+      source: {
+        providerName: 'discogs',
+        attribution: 'Data provided by Discogs.',
+      },
+    })
+  })
+
+  it('loads Discogs release detail draft data and rejects collection id leaks', async () => {
+    const fetchMock = vi.fn<Window['fetch']>()
+    fetchMock
+      .mockResolvedValueOnce(
+        h.jsonResponse({
+          source: source('release', '249504'),
+          title: 'Blue Monday',
+          artists: ['New Order'],
+          year: 1983,
+          labels: ['Factory'],
+          formats: ['Vinyl', '12"'],
+          tracklist: [
+            {
+              title: 'Blue Monday',
+              position: 'A',
+              durationSeconds: 449,
+              artists: ['New Order'],
+            },
+          ],
+          identifiers: [{ type: 'Barcode', value: '5016839200371' }],
+          barcodes: ['5016839200371'],
+          catalogNumber: 'FAC 73',
+          credits: [{ name: 'New Order', role: 'Written-By' }],
+          draft: {
+            title: 'Blue Monday',
+            year: 1983,
+            artistCredits: [{ name: 'New Order', role: 'mainArtist' }],
+            labels: [
+              {
+                name: 'Factory',
+                catalogNumber: 'FAC 73',
+                hasNoCatalogNumber: false,
+              },
+            ],
+            tracklist: [
+              {
+                title: 'Blue Monday',
+                position: 1,
+                durationSeconds: 449,
+                artistCredits: [{ name: 'New Order', role: 'mainArtist' }],
+              },
+            ],
+            externalSources: [
+              {
+                providerName: 'discogs',
+                resourceType: 'release',
+                externalId: '249504',
+                sourceUrl: 'https://www.discogs.com/release/249504',
+              },
+            ],
+          },
+        }),
+      )
+      .mockResolvedValueOnce(
+        h.jsonResponse({
+          collectionId: '00000000-0000-7000-8000-000000000099',
+        }),
+      )
+    vi.stubGlobal('fetch', fetchMock)
+
+    const detail = await getDiscogsRelease('249504')
+
+    expect(fetchMock.mock.calls[0][0]).toBe(
+      '/api/external-metadata/discogs/releases/249504',
+    )
+    expect(detail.draft.tracklist[0]).toMatchObject({
+      title: 'Blue Monday',
+      position: 1,
+      durationSeconds: 449,
+    })
+    expect(detail.draft.externalSources[0]).toMatchObject({
+      providerName: 'discogs',
+      resourceType: 'release',
+      externalId: '249504',
+    })
+    await expect(getDiscogsRelease('leaky')).rejects.toThrow(/collection ids/i)
+  })
+
+  it('surfaces safe provider errors without losing retry-after', async () => {
+    vi.stubGlobal(
+      'fetch',
+      vi.fn<Window['fetch']>().mockResolvedValue(
+        new Response(
+          JSON.stringify({
+            code: 'external_metadata.rate_limited',
+            message: 'External metadata provider is rate limited',
+          }),
+          {
+            headers: {
+              'Content-Type': 'application/json',
+              'Retry-After': '60',
+            },
+            status: 429,
+          },
+        ),
+      ),
+    )
+
+    await expect(
+      searchDiscogsReleases({ query: 'Factory' }),
+    ).rejects.toMatchObject({
+      status: 429,
+      code: 'external_metadata.rate_limited',
+      retryAfter: '60',
+    } satisfies Partial<CatalogApiError>)
+  })
+})
+
+function source(resourceType: string, externalId: string) {
+  return {
+    providerName: 'discogs',
+    resourceType,
+    externalId,
+    sourceUrl: `https://www.discogs.com/${resourceType}/${externalId}`,
+    attribution: 'Data provided by Discogs.',
+  }
+}
+
+function requestUrl(input: Parameters<Window['fetch']>[0]) {
+  if (typeof input === 'string' || input instanceof URL) {
+    return new URL(input, 'http://localhost')
+  }
+
+  return new URL(input.url, 'http://localhost')
+}
diff --git a/src/features/releases/DiscogsReleaseLookupPanel.tsx b/src/features/releases/DiscogsReleaseLookupPanel.tsx
new file mode 100644
index 0000000..7fb8cac
--- /dev/null
+++ b/src/features/releases/DiscogsReleaseLookupPanel.tsx
@@ -0,0 +1,468 @@
+import { Search } from 'lucide-react'
+import { useEffect, useRef, useState } from 'react'
+import {
+  CatalogApiError,
+  getDiscogsRelease,
+  searchDiscogsReleases,
+  type ExternalMetadataReleaseCandidateDto,
+  type ExternalMetadataReleaseDetailDto,
+} from '../catalog/catalogApi'
+
+export type DiscogsApplyGroups = {
+  core: boolean
+  artists: boolean
+  labels: boolean
+  tracklist: boolean
+  externalSource: boolean
+}
+
+export type DiscogsSearchSeed = {
+  artist: string
+  catalogNumber: string
+  title: string
+  year: string
+}
+
+export type DiscogsCurrentRelease = {
+  artists: string
+  externalSourceCount: number
+  labels: string
+  title: string
+  trackCount: number
+  year: string
+}
+
+type DiscogsReleaseLookupPanelProps = {
+  current: DiscogsCurrentRelease
+  isOpen: boolean
+  mode: 'create' | 'update'
+  searchSeed: DiscogsSearchSeed
+  onApplyDraft: (
+    detail: ExternalMetadataReleaseDetailDto,
+    groups: DiscogsApplyGroups,
+  ) => void
+  onOpenChange: (isOpen: boolean) => void
+}
+
+const emptyGroups: DiscogsApplyGroups = {
+  core: false,
+  artists: false,
+  labels: false,
+  tracklist: false,
+  externalSource: false,
+}
+
+export function DiscogsReleaseLookupPanel({
+  current,
+  isOpen,
+  mode,
+  searchSeed,
+  onApplyDraft,
+  onOpenChange,
+}: DiscogsReleaseLookupPanelProps) {
+  const [query, setQuery] = useState('')
+  const [artist, setArtist] = useState(searchSeed.artist)
+  const [title, setTitle] = useState(searchSeed.title)
+  const [year, setYear] = useState(searchSeed.year)
+  const [barcode, setBarcode] = useState('')
+  const [catalogNumber, setCatalogNumber] = useState(searchSeed.catalogNumber)
+  const [status, setStatus] = useState('')
+  const [candidates, setCandidates] = useState<
+    ExternalMetadataReleaseCandidateDto[]
+  >([])
+  const [selectedDetail, setSelectedDetail] =
+    useState<ExternalMetadataReleaseDetailDto | null>(null)
+  const [applyGroups, setApplyGroups] = useState<DiscogsApplyGroups>(() =>
+    defaultGroups(mode),
+  )
+  const wasOpen = useRef(false)
+
+  useEffect(() => {
+    if (isOpen && !wasOpen.current) {
+      setArtist(searchSeed.artist)
+      setTitle(searchSeed.title)
+      setYear(searchSeed.year)
+      setCatalogNumber(searchSeed.catalogNumber)
+    }
+
+    wasOpen.current = isOpen
+  }, [isOpen, searchSeed])
+
+  async function handleSearch() {
+    setStatus('Searching Discogs release candidates.')
+    setSelectedDetail(null)
+
+    try {
+      const result = await searchDiscogsReleases({
+        query,
+        artist,
+        title,
+        year,
+        barcode,
+        catalogNumber,
+        limit: 25,
+      })
+
+      setCandidates(result.items)
+      setStatus(
+        result.items.length > 0
+          ? `${result.total} candidate${result.total === 1 ? '' : 's'} found.`
+          : 'No Discogs release candidates found.',
+      )
+    } catch (error) {
+      setCandidates([])
+      setStatus(externalMetadataErrorMessage(error))
+    }
+  }
+
+  async function reviewCandidate(
+    candidate: ExternalMetadataReleaseCandidateDto,
+  ) {
+    setStatus(`Loading Discogs detail for ${candidate.title}.`)
+
+    try {
+      const detail = await getDiscogsRelease(candidate.source.externalId)
+      setSelectedDetail(detail)
+      setApplyGroups(defaultGroups(mode))
+      setStatus(`Review loaded for ${detail.title}.`)
+    } catch (error) {
+      setSelectedDetail(null)
+      setStatus(externalMetadataErrorMessage(error))
+    }
+  }
+
+  function updateApplyGroup(group: keyof DiscogsApplyGroups, checked: boolean) {
+    setApplyGroups((groups) => ({ ...groups, [group]: checked }))
+  }
+
+  const hasSelectedGroup = Object.values(applyGroups).some(Boolean)
+
+  return (
+    <section
+      className="manual-entry-wide release-form-section discogs-release-lookup"
+      aria-label="Discogs release lookup"
+      role="region"
+    >
+      <div className="release-form-section-header">
+        <div>
+          <h3>Discogs</h3>
+          <p>Search release candidates and review fields before applying.</p>
+        </div>
+        <button
+          className="button button-secondary button-compact"
+          type="button"
+          onClick={() => onOpenChange(!isOpen)}
+        >
+          <Search size={14} aria-hidden="true" />
+          {isOpen ? 'Hide Discogs' : 'Search Discogs'}
+        </button>
+      </div>
+
+      {isOpen ? (
+        <>
+          <div className="discogs-search-form">
+            <label>
+              <span>Discogs query</span>
+              <input
+                aria-label="Discogs query"
+                value={query}
+                onChange={(event) => setQuery(event.target.value)}
+              />
+            </label>
+            <label>
+              <span>Discogs artist</span>
+              <input
+                aria-label="Discogs artist"
+                value={artist}
+                onChange={(event) => setArtist(event.target.value)}
+              />
+            </label>
+            <label>
+              <span>Discogs title</span>
+              <input
+                aria-label="Discogs title"
+                value={title}
+                onChange={(event) => setTitle(event.target.value)}
+              />
+            </label>
+            <label>
+              <span>Discogs year</span>
+              <input
+                aria-label="Discogs year"
+                inputMode="numeric"
+                value={year}
+                onChange={(event) => setYear(event.target.value)}
+              />
+            </label>
+            <label>
+              <span>Discogs barcode</span>
+              <input
+                aria-label="Discogs barcode"
+                value={barcode}
+                onChange={(event) => setBarcode(event.target.value)}
+              />
+            </label>
+            <label>
+              <span>Discogs catalog number</span>
+              <input
+                aria-label="Discogs catalog number"
+                value={catalogNumber}
+                onChange={(event) => setCatalogNumber(event.target.value)}
+              />
+            </label>
+            <button
+              className="button button-secondary button-compact"
+              type="button"
+              onClick={() => {
+                void handleSearch()
+              }}
+            >
+              <Search size={14} aria-hidden="true" />
+              Search Discogs releases
+            </button>
+          </div>
+
+          {status ? (
+            <p className="discogs-lookup-status" role="status">
+              {status}
+            </p>
+          ) : null}
+
+          {candidates.length > 0 ? (
+            <div className="discogs-candidate-list">
+              {candidates.map((candidate) => (
+                <article
+                  className="discogs-candidate"
+                  key={candidate.source.externalId}
+                >
+                  <div>
+                    <strong>{candidate.title}</strong>
+                    <p>
+                      {candidate.artists.join(', ') || 'Unknown artist'} ·{' '}
+                      {candidate.year ?? 'Unknown year'} ·{' '}
+                      {candidate.labels.join(', ') || 'Unknown label'}
+                    </p>
+                    <p>
+                      {[...candidate.formats, candidate.catalogNumber]
+                        .filter(Boolean)
+                        .join(' · ')}
+                    </p>
+                    {candidate.barcodes.length > 0 ? (
+                      <p>Barcodes: {candidate.barcodes.join(', ')}</p>
+                    ) : null}
+                    <p>{candidate.source.attribution}</p>
+                  </div>
+                  <div className="discogs-candidate-actions">
+                    <a
+                      className="detail-link"
+                      href={candidate.source.sourceUrl}
+                      target="_blank"
+                      rel="noreferrer"
+                    >
+                      Open candidate Discogs source
+                    </a>
+                    <button
+                      className="button button-secondary button-compact"
+                      type="button"
+                      onClick={() => {
+                        void reviewCandidate(candidate)
+                      }}
+                    >
+                      Review {candidate.title}
+                    </button>
+                  </div>
+                </article>
+              ))}
+            </div>
+          ) : null}
+
+          {selectedDetail ? (
+            <div className="discogs-review-panel">
+              <div className="release-form-section-header">
+                <div>
+                  <h3>Review Discogs candidate</h3>
+                  <p>
+                    {selectedDetail.source.attribution}{' '}
+                    <a
+                      className="detail-link"
+                      href={selectedDetail.source.sourceUrl}
+                      target="_blank"
+                      rel="noreferrer"
+                    >
+                      Open Discogs source
+                    </a>
+                  </p>
+                </div>
+              </div>
+
+              <div className="discogs-review-grid">
+                <ReviewColumn
+                  title="Current local release"
+                  rows={currentRows(current)}
+                />
+                <ReviewColumn
+                  title="Discogs draft"
+                  rows={discogsRows(selectedDetail)}
+                />
+              </div>
+
+              <fieldset className="discogs-apply-groups">
+                <legend>Apply groups</legend>
+                <ApplyGroup
+                  checked={applyGroups.core}
+                  label="Apply Core"
+                  onChange={(checked) => updateApplyGroup('core', checked)}
+                />
+                <ApplyGroup
+                  checked={applyGroups.artists}
+                  label="Apply Artists"
+                  onChange={(checked) => updateApplyGroup('artists', checked)}
+                />
+                <ApplyGroup
+                  checked={applyGroups.labels}
+                  label="Apply Labels"
+                  onChange={(checked) => updateApplyGroup('labels', checked)}
+                />
+                <ApplyGroup
+                  checked={applyGroups.tracklist}
+                  label="Apply Tracklist"
+                  onChange={(checked) => updateApplyGroup('tracklist', checked)}
+                />
+                <ApplyGroup
+                  checked={applyGroups.externalSource}
+                  label="Apply External Source"
+                  onChange={(checked) =>
+                    updateApplyGroup('externalSource', checked)
+                  }
+                />
+              </fieldset>
+
+              <button
+                className="button button-primary button-compact"
+                type="button"
+                disabled={!hasSelectedGroup}
+                onClick={() => onApplyDraft(selectedDetail, applyGroups)}
+              >
+                Apply selected Discogs fields
+              </button>
+            </div>
+          ) : null}
+        </>
+      ) : (
+        <p className="release-section-note">
+          Discogs lookup is optional and never saves data until the release form
+          is submitted.
+        </p>
+      )}
+    </section>
+  )
+}
+
+function defaultGroups(mode: 'create' | 'update'): DiscogsApplyGroups {
+  return mode === 'create'
+    ? {
+        core: true,
+        artists: true,
+        labels: true,
+        tracklist: true,
+        externalSource: true,
+      }
+    : emptyGroups
+}
+
+function externalMetadataErrorMessage(error: unknown) {
+  if (error instanceof CatalogApiError) {
+    const retry =
+      error.retryAfter && error.status === 429
+        ? ` Retry after ${error.retryAfter} seconds.`
+        : ''
+
+    return `${error.message}${retry}`
+  }
+
+  return 'External metadata provider is unavailable.'
+}
+
+function currentRows(current: DiscogsCurrentRelease) {
+  return [
+    ['Title', current.title || 'Not recorded'],
+    ['Artist', current.artists || 'Not recorded'],
+    ['Year', current.year || 'Not recorded'],
+    ['Labels', current.labels || 'Not recorded'],
+    ['Tracklist', `${current.trackCount} rows`],
+    ['Sources', `${current.externalSourceCount} sources`],
+  ]
+}
+
+function discogsRows(detail: ExternalMetadataReleaseDetailDto) {
+  return [
+    ['Title', detail.draft.title || 'Not recorded'],
+    [
+      'Artist',
+      detail.draft.artistCredits.map((credit) => credit.name).join(', ') ||
+        'Not recorded',
+    ],
+    ['Year', detail.draft.year?.toString() ?? 'Not recorded'],
+    [
+      'Labels',
+      detail.draft.labels
+        .map((label) =>
+          [label.name, label.catalogNumber].filter(Boolean).join(' '),
+        )
+        .join(', ') || 'Not recorded',
+    ],
+    ['Tracklist', `${detail.draft.tracklist.length} rows`],
+    ['Formats', detail.formats.join(', ') || 'Not recorded'],
+    ['Barcodes', detail.barcodes.join(', ') || 'Not recorded'],
+    [
+      'Identifiers',
+      detail.identifiers
+        .map((identifier) => `${identifier.type}: ${identifier.value}`)
+        .join(', ') || 'Not recorded',
+    ],
+    [
+      'Credits',
+      detail.credits
+        .map((credit) => [credit.name, credit.role].filter(Boolean).join(' - '))
+        .join(', ') || 'Not recorded',
+    ],
+    ['Sources', `${detail.draft.externalSources.length} sources`],
+  ]
+}
+
+function ReviewColumn({ title, rows }: { title: string; rows: string[][] }) {
+  return (
+    <div className="discogs-review-column">
+      <h4>{title}</h4>
+      <dl>
+        {rows.map(([label, value]) => (
+          <div key={label}>
+            <dt>{label}</dt>
+            <dd>{value}</dd>
+          </div>
+        ))}
+      </dl>
+    </div>
+  )
+}
+
+function ApplyGroup({
+  checked,
+  label,
+  onChange,
+}: {
+  checked: boolean
+  label: string
+  onChange: (checked: boolean) => void
+}) {
+  return (
+    <label className="compact-checkbox">
+      <input
+        type="checkbox"
+        checked={checked}
+        onChange={(event) => onChange(event.target.checked)}
+      />
+      <span>{label}</span>
+    </label>
+  )
+}
diff --git a/src/features/releases/ReleaseDetail.tsx b/src/features/releases/ReleaseDetail.tsx
index 6c68a51..445b13c 100644
--- a/src/features/releases/ReleaseDetail.tsx
+++ b/src/features/releases/ReleaseDetail.tsx
@@ -30,6 +30,7 @@ type ReleaseDetailProps = {
   onEdit?: () => void
   onEditLocalFiles?: (tracks: TrackRecord[]) => void
   onRemoveCover?: (releaseId: string) => Promise<void> | void
+  onUpdateViaDiscogs?: () => void
   onUploadCover?: (releaseId: string, file: File) => Promise<void> | void
   playlists: PlaylistRecord[]
   release: ReleaseRecord
@@ -55,6 +56,7 @@ export function ReleaseDetail({
   onEdit,
   onEditLocalFiles,
   onRemoveCover,
+  onUpdateViaDiscogs,
   onUploadCover,
   playlists,
   release,
@@ -105,7 +107,9 @@ export function ReleaseDetail({
         </div>
         <h2 id="release-detail-title">{release.title}</h2>
         <p>{release.artist}</p>
-        {onEdit || (onEditLocalFiles && localTracks.length > 0) ? (
+        {onEdit ||
+        onUpdateViaDiscogs ||
+        (onEditLocalFiles && localTracks.length > 0) ? (
           <div className="detail-actions">
             {onEdit ? (
               <button
@@ -116,6 +120,15 @@ export function ReleaseDetail({
                 Edit record
               </button>
             ) : null}
+            {onUpdateViaDiscogs ? (
+              <button
+                className="button button-secondary"
+                type="button"
+                onClick={onUpdateViaDiscogs}
+              >
+                Update via Discogs
+              </button>
+            ) : null}
             {onEditLocalFiles && localTracks.length > 0 ? (
               <button
                 className="button button-secondary"
diff --git a/src/features/releases/ReleaseEntryForm.tsx b/src/features/releases/ReleaseEntryForm.tsx
index 6b06d20..e965807 100644
--- a/src/features/releases/ReleaseEntryForm.tsx
+++ b/src/features/releases/ReleaseEntryForm.tsx
@@ -2,13 +2,25 @@ import { useState } from 'react'
 import './releases.css'
 import { ManualEntryPanel } from '../manualEntry/ManualEntryPanel'
 import { createManualRecordId } from '../manualEntry/manualEntryUtils'
-import { activeDictionaryLabels } from '../catalog/catalogApi'
+import {
+  activeDictionaryLabels,
+  type ExternalMetadataReleaseDetailDto,
+} from '../catalog/catalogApi'
+import {
+  durationSecondsToParts,
+  emptyDurationParts,
+} from '../catalog/durationFormat'
 import type { OwnedCopy, ReleaseType } from './releasesData'
 import {
+  type DraftTrackRow,
   type EditableArtistCredit,
   type EditableReleaseLabel,
   type ReleaseEntryFormProps,
 } from './ReleaseEntryFormTypes'
+import {
+  DiscogsReleaseLookupPanel,
+  type DiscogsApplyGroups,
+} from './DiscogsReleaseLookupPanel'
 import { ReleaseArtistCreditsSection } from './ReleaseArtistCreditsSection'
 import { ReleaseClassificationSection } from './ReleaseClassificationSection'
 import { ReleaseCoreSection } from './ReleaseCoreSection'
@@ -27,6 +39,7 @@ export function ReleaseEntryForm({
   artists,
   dictionaries,
   initialRelease,
+  initialShowDiscogsLookup,
   releases,
   tracks,
   onCancel,
@@ -111,6 +124,13 @@ export function ReleaseEntryForm({
   )
   const [tags, setTags] = useState(initialRelease?.tags.join(', ') ?? '')
   const [releaseNotes] = useState(initialRelease?.releaseNotes ?? '')
+  const [externalSources, setExternalSources] = useState(
+    initialRelease?.externalSources,
+  )
+  const [discogsLookupOpenPreference, setDiscogsLookupOpenPreference] =
+    useState<boolean | null>(null)
+  const isDiscogsLookupOpen =
+    discogsLookupOpenPreference ?? Boolean(initialShowDiscogsLookup)
   const effectiveArtistCredits = artistCredits
   const draftReleaseLabel: EditableReleaseLabel | undefined =
     draftLabel.trim().length > 0
@@ -142,6 +162,7 @@ export function ReleaseEntryForm({
     handleTrackDraftArtistChange,
     removeDraftTrack,
     removeTrackArtist,
+    replaceDraftTracks,
     selectExistingTrack,
     selectedCustomTrackCredits,
     selectedDraftTrack,
@@ -304,6 +325,7 @@ export function ReleaseEntryForm({
       draftTracks,
       effectiveArtistCredits,
       effectiveLabels,
+      externalSources,
       firstCopy,
       genres,
       includeOwnedCopy,
@@ -323,6 +345,112 @@ export function ReleaseEntryForm({
     onSubmit(release, submittedTracks)
   }
 
+  function handleApplyDiscogsDraft(
+    detail: ExternalMetadataReleaseDetailDto,
+    groups: DiscogsApplyGroups,
+  ) {
+    const draft = detail.draft
+
+    if (groups.core) {
+      setTitle(draft.title)
+      setYear(draft.year?.toString() ?? '')
+    }
+
+    if (groups.artists) {
+      setIsVariousArtists(false)
+      setArtistCredits(
+        draft.artistCredits.map((credit, index) =>
+          editableCreditFromDiscogsCredit(credit.name, credit.role, index),
+        ),
+      )
+      setDraftArtist('')
+      setDraftArtistId('')
+    }
+
+    if (groups.labels) {
+      setNotOnLabel(false)
+      setDraftLabel('')
+      setDraftCatalogNumber('')
+      setDraftHasNoCatalogNumber(false)
+      setLabels(
+        draft.labels.map((label, index) => ({
+          id: createManualRecordId('release-label', `discogs-${index + 1}`),
+          label: label.name,
+          catalogNumber: label.catalogNumber ?? '',
+          hasNoCatalogNumber: label.hasNoCatalogNumber,
+        })),
+      )
+    }
+
+    if (groups.tracklist) {
+      replaceDraftTracks(
+        draft.tracklist.map(
+          (track, index): DraftTrackRow => ({
+            id: createManualRecordId(
+              'draft-track',
+              `discogs-${track.position || index + 1}`,
+            ),
+            existingTrackQuery: '',
+            position: String(track.position || index + 1),
+            title: track.title,
+            durationParts: track.durationSeconds
+              ? durationSecondsToParts(track.durationSeconds)
+              : { ...emptyDurationParts },
+            inheritReleaseArtistCredits: track.artistCredits.length === 0,
+            artistCredits: track.artistCredits.map((credit, creditIndex) =>
+              editableCreditFromDiscogsCredit(
+                credit.name,
+                credit.role,
+                creditIndex,
+                `track-${index + 1}`,
+              ),
+            ),
+            draftArtist: '',
+            draftArtistId: '',
+            versionNote: '',
+          }),
+        ),
+      )
+    }
+
+    if (groups.externalSource) {
+      setExternalSources(
+        draft.externalSources.map((source) => ({
+          ...source,
+          appliedAt: new Date().toISOString(),
+        })),
+      )
+    }
+  }
+
+  function editableCreditFromDiscogsCredit(
+    name: string,
+    role: string,
+    index: number,
+    prefix = 'release',
+  ): EditableArtistCredit {
+    const trimmedName = name.trim()
+    const existingArtist = artists.find(
+      (artist) => artist.name.toLowerCase() === trimmedName.toLowerCase(),
+    )
+
+    return {
+      id: createManualRecordId(
+        `${prefix}-artist-credit`,
+        `discogs-${index + 1}`,
+      ),
+      artistId: existingArtist?.id ?? '',
+      artist: existingArtist ? '' : trimmedName,
+      role: creditRoleLabelFromCode(role),
+    }
+  }
+
+  function creditRoleLabelFromCode(role: string) {
+    return (
+      dictionaries.creditRole.find((entry) => entry.code === role)?.name ?? role
+    )
+  }
+
   return (
     <ManualEntryPanel
       title={formTitle}
@@ -342,6 +470,32 @@ export function ReleaseEntryForm({
         type={type}
         year={year}
       />
+      <DiscogsReleaseLookupPanel
+        current={{
+          artists: releaseArtist,
+          externalSourceCount: externalSources?.length ?? 0,
+          labels: effectiveLabels
+            .map((label) =>
+              [label.label, label.catalogNumber].filter(Boolean).join(' '),
+            )
+            .join(', '),
+          title,
+          trackCount: draftTracks.filter(isDraftTrackIncluded).length,
+          year,
+        }}
+        isOpen={isDiscogsLookupOpen}
+        mode={initialRelease ? 'update' : 'create'}
+        searchSeed={{
+          artist: releaseArtist,
+          catalogNumber:
+            labels.find((label) => label.catalogNumber.trim().length > 0)
+              ?.catalogNumber ?? draftCatalogNumber,
+          title,
+          year: /^\d{4}$/.test(year) ? year : '',
+        }}
+        onApplyDraft={handleApplyDiscogsDraft}
+        onOpenChange={setDiscogsLookupOpenPreference}
+      />
       <ReleaseArtistCreditsSection
         addDraftArtistCredit={addDraftArtistCredit}
         artistCredits={artistCredits}
diff --git a/src/features/releases/ReleaseEntryFormTypes.ts b/src/features/releases/ReleaseEntryFormTypes.ts
index f8e50fc..5cf3c8d 100644
--- a/src/features/releases/ReleaseEntryFormTypes.ts
+++ b/src/features/releases/ReleaseEntryFormTypes.ts
@@ -8,6 +8,7 @@ export type ReleaseEntryFormProps = {
   artists: ArtistRecord[]
   dictionaries: CatalogDictionaries
   initialRelease?: ReleaseRecord
+  initialShowDiscogsLookup?: boolean
   releases: ReleaseRecord[]
   tracks: TrackRecord[]
   onCancel: () => void
diff --git a/src/features/releases/ReleasesWorkspace.tsx b/src/features/releases/ReleasesWorkspace.tsx
index 3874a29..2bbd14a 100644
--- a/src/features/releases/ReleasesWorkspace.tsx
+++ b/src/features/releases/ReleasesWorkspace.tsx
@@ -98,6 +98,7 @@ export function ReleasesWorkspace({
   })
   const [manualReleases, setManualReleases] = useState<ReleaseRecord[]>([])
   const [editingReleaseId, setEditingReleaseId] = useState('')
+  const [discogsLookupReleaseId, setDiscogsLookupReleaseId] = useState('')
   const [localEditFiles, setLocalEditFiles] = useState<LocalEditableFile[]>([])
   const [ratingColumnIds, setRatingColumnIds] = useState(() =>
     readRatingColumnIds('discweave.releaseRatingColumns'),
@@ -163,6 +164,7 @@ export function ReleasesWorkspace({
     setQuery('')
     selectRelease(release.id)
     setEditingReleaseId('')
+    setDiscogsLookupReleaseId('')
   }
 
   function handleDeleteRelease(releaseId: string) {
@@ -176,6 +178,7 @@ export function ReleasesWorkspace({
 
     setQuery('')
     setEditingReleaseId('')
+    setDiscogsLookupReleaseId('')
   }
 
   async function handleUploadReleaseCover(releaseId: string, file: File) {
@@ -319,10 +322,16 @@ export function ReleasesWorkspace({
             artists={artists}
             dictionaries={dictionaries}
             initialRelease={editingRelease}
+            initialShowDiscogsLookup={
+              editingRelease.id === discogsLookupReleaseId
+            }
             key={editingRelease.id}
             releases={releases}
             tracks={tracks}
-            onCancel={() => setEditingReleaseId('')}
+            onCancel={() => {
+              setEditingReleaseId('')
+              setDiscogsLookupReleaseId('')
+            }}
             onSubmit={handleUpdateRelease}
           />
         ) : null}
@@ -347,7 +356,10 @@ export function ReleasesWorkspace({
       {selectedRelease ? (
         <ReleaseDetail
           ownedItems={ownedItems}
-          onEdit={() => setEditingReleaseId(selectedRelease.id)}
+          onEdit={() => {
+            setEditingReleaseId(selectedRelease.id)
+            setDiscogsLookupReleaseId('')
+          }}
           onDelete={() => handleDeleteRelease(selectedRelease.id)}
           onEditLocalFiles={
             canEditLocalFiles
@@ -357,6 +369,10 @@ export function ReleasesWorkspace({
               : undefined
           }
           onRemoveCover={handleRemoveReleaseCover}
+          onUpdateViaDiscogs={() => {
+            setEditingReleaseId(selectedRelease.id)
+            setDiscogsLookupReleaseId(selectedRelease.id)
+          }}
           onUploadCover={handleUploadReleaseCover}
           playlists={playlists}
           release={selectedRelease}
diff --git a/src/features/releases/release-form.css b/src/features/releases/release-form.css
index bdb2110..cec6192 100644
--- a/src/features/releases/release-form.css
+++ b/src/features/releases/release-form.css
@@ -37,6 +37,143 @@
   gap: 8px;
 }
 
+.discogs-release-lookup {
+  border: 1px solid var(--color-border);
+  border-radius: var(--radius-sm);
+  background: #fbfcfa;
+  padding: 12px;
+}
+
+.discogs-search-form {
+  display: grid;
+  grid-template-columns: repeat(3, minmax(0, 1fr)) auto;
+  gap: 8px;
+  align-items: end;
+}
+
+.discogs-search-form label {
+  min-width: 0;
+}
+
+.discogs-lookup-status {
+  margin: 0;
+  color: var(--color-muted);
+  font-size: 12px;
+  font-weight: 650;
+}
+
+.discogs-candidate-list,
+.discogs-review-panel {
+  display: grid;
+  gap: 8px;
+  min-width: 0;
+}
+
+.discogs-candidate {
+  display: grid;
+  grid-template-columns: minmax(0, 1fr) auto;
+  gap: 12px;
+  align-items: start;
+  border: 1px solid var(--color-border);
+  border-radius: var(--radius-sm);
+  background: var(--color-surface);
+  padding: 10px;
+}
+
+.discogs-candidate strong,
+.discogs-review-column h4 {
+  color: var(--color-heading);
+  font-size: 13px;
+}
+
+.discogs-candidate p {
+  margin: 2px 0 0;
+  color: var(--color-muted);
+  font-size: 12px;
+}
+
+.discogs-candidate-actions {
+  display: grid;
+  justify-items: end;
+  gap: 8px;
+}
+
+.discogs-candidate-actions .detail-link {
+  overflow-wrap: anywhere;
+  text-align: right;
+}
+
+.discogs-review-panel {
+  border-top: 1px solid var(--color-border);
+  padding-top: 10px;
+}
+
+.discogs-review-grid {
+  display: grid;
+  grid-template-columns: repeat(2, minmax(0, 1fr));
+  gap: 10px;
+}
+
+.discogs-review-column {
+  display: grid;
+  gap: 7px;
+  min-width: 0;
+  border: 1px solid var(--color-border);
+  border-radius: var(--radius-sm);
+  background: var(--color-surface);
+  padding: 10px;
+}
+
+.discogs-review-column h4 {
+  margin: 0;
+}
+
+.discogs-review-column dl {
+  display: grid;
+  gap: 7px;
+  margin: 0;
+}
+
+.discogs-review-column dl div {
+  display: grid;
+  gap: 2px;
+}
+
+.discogs-review-column dt {
+  color: var(--color-soft);
+  font-size: 10px;
+  font-weight: 780;
+  letter-spacing: 0.06em;
+  text-transform: uppercase;
+}
+
+.discogs-review-column dd {
+  min-width: 0;
+  margin: 0;
+  overflow-wrap: anywhere;
+  color: var(--color-heading);
+  font-size: 12px;
+}
+
+.discogs-apply-groups {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 8px 12px;
+  min-width: 0;
+  border: 0;
+  margin: 0;
+  padding: 0;
+}
+
+.discogs-apply-groups legend {
+  width: 100%;
+  color: var(--color-soft);
+  font-size: 11px;
+  font-weight: 780;
+  letter-spacing: 0.06em;
+  text-transform: uppercase;
+}
+
 .button-compact {
   min-height: 30px;
   padding: 0 10px;
@@ -332,3 +469,51 @@
 .release-track-version-field {
   min-width: 0;
 }
+
+@media (max-width: 860px) {
+  .release-core-grid,
+  .release-owned-copy-grid,
+  .release-artist-composer,
+  .release-label-composer,
+  .release-artist-row,
+  .release-label-row {
+    grid-template-columns: 1fr;
+  }
+
+  .release-row-checkbox {
+    padding-top: 0;
+  }
+
+  .discogs-search-form {
+    grid-template-columns: repeat(2, minmax(0, 1fr));
+  }
+
+  .discogs-search-form > .button {
+    justify-self: start;
+  }
+
+  .discogs-candidate,
+  .discogs-review-grid {
+    grid-template-columns: 1fr;
+  }
+
+  .discogs-candidate-actions {
+    justify-items: start;
+  }
+
+  .discogs-candidate-actions .detail-link {
+    text-align: left;
+  }
+}
+
+@media (max-width: 560px) {
+  .discogs-search-form {
+    grid-template-columns: 1fr;
+  }
+
+  .release-form-section-header,
+  .release-section-actions {
+    align-items: stretch;
+    flex-direction: column;
+  }
+}
diff --git a/src/features/releases/release-tracklist.css b/src/features/releases/release-tracklist.css
index 1dd9255..76f9c87 100644
--- a/src/features/releases/release-tracklist.css
+++ b/src/features/releases/release-tracklist.css
@@ -353,3 +353,30 @@
   min-height: 30px;
   margin-top: 18px;
 }
+
+@media (max-width: 860px) {
+  .release-tracklist-layout,
+  .release-track-detail-grid {
+    grid-template-columns: 1fr;
+  }
+
+  .release-tracklist-toolbar,
+  .release-tracklist-detail-header {
+    align-items: stretch;
+    flex-direction: column;
+  }
+
+  .release-track-detail-actions {
+    justify-content: flex-start;
+  }
+
+  .existing-track-summary span:not(.badge),
+  .existing-track-results span {
+    overflow-wrap: anywhere;
+    white-space: normal;
+  }
+
+  .track-duration-control {
+    grid-template-columns: repeat(3, minmax(0, 1fr));
+  }
+}
diff --git a/src/features/releases/releaseSubmit.ts b/src/features/releases/releaseSubmit.ts
index 184bb5d..7528b33 100644
--- a/src/features/releases/releaseSubmit.ts
+++ b/src/features/releases/releaseSubmit.ts
@@ -32,6 +32,7 @@ type BuildReleaseSubmissionInput = {
   draftTracks: DraftTrackRow[]
   effectiveArtistCredits: EditableArtistCredit[]
   effectiveLabels: EditableReleaseLabel[]
+  externalSources?: ReleaseRecord['externalSources']
   firstCopy?: OwnedCopy
   genres: string[]
   includeOwnedCopy: boolean
@@ -53,6 +54,7 @@ export function buildReleaseSubmission({
   draftTracks,
   effectiveArtistCredits,
   effectiveLabels,
+  externalSources,
   firstCopy,
   genres,
   includeOwnedCopy,
@@ -134,6 +136,7 @@ export function buildReleaseSubmission({
     tags: splitCommaList(tags),
     releaseNotes,
     ownedCopies,
+    externalSources,
   }
   const submittedTracks = draftTracks
     .filter(isDraftTrackIncluded)
diff --git a/src/features/releases/releasesData.ts b/src/features/releases/releasesData.ts
index 746ed3b..6ec999c 100644
--- a/src/features/releases/releasesData.ts
+++ b/src/features/releases/releasesData.ts
@@ -1,5 +1,8 @@
 import type { CreditRole } from '../catalog/creditRoles'
-import type { EntityRating } from '../catalog/catalogApi'
+import type {
+  EntityRating,
+  ExternalSourceReference,
+} from '../catalog/catalogApi'
 
 export type ReleaseType = string
 
@@ -51,6 +54,7 @@ export type ReleaseRecord = {
   releaseNotes: string
   ownedCopies: OwnedCopy[]
   coverImage?: ReleaseCoverImage
+  externalSources?: ExternalSourceReference[]
   ratings?: EntityRating[]
 }
 
diff --git a/src/features/releases/useReleaseTrackDrafts.ts b/src/features/releases/useReleaseTrackDrafts.ts
index 02ea8be..a1dabd1 100644
--- a/src/features/releases/useReleaseTrackDrafts.ts
+++ b/src/features/releases/useReleaseTrackDrafts.ts
@@ -354,6 +354,11 @@ export function useReleaseTrackDrafts({
     }
   }
 
+  function replaceDraftTracks(nextTracks: DraftTrackRow[]) {
+    setDraftTracks(nextTracks)
+    setSelectedDraftTrackId(nextTracks[0]?.id ?? null)
+  }
+
   function draftTrackArtistSummary(track: DraftTrackRow) {
     if (track.existingTrackId) {
       const linkedTrack = tracks.find(
@@ -409,6 +414,7 @@ export function useReleaseTrackDrafts({
     handleTrackDraftArtistChange,
     removeDraftTrack,
     removeTrackArtist,
+    replaceDraftTracks,
     selectExistingTrack,
     selectedCustomTrackCredits,
     selectedDraftTrack,
diff --git a/src/styles/responsive.css b/src/styles/responsive.css
index 9ba27f0..73ae9e5 100644
--- a/src/styles/responsive.css
+++ b/src/styles/responsive.css
@@ -263,6 +263,10 @@
     min-width: 0;
   }
 
+  .table-scroll > .catalog-table {
+    min-width: 0;
+  }
+
   .catalog-table thead {
     display: none;
   }

From 7a7fa5010c11e2e17308bab5c0766c570b08824c Mon Sep 17 00:00:00 2001
From: "r.osipin" <r.osipin@whyhappen.ru>
Date: Thu, 4 Jun 2026 09:54:05 +0300
Subject: [PATCH 2/3] Add Discogs artist and track review UI

---
 .superdesign/design-system.md                 |  14 +
 src/App.auth.test.tsx                         | 106 ++-
 src/App.catalog-actions.test.tsx              |  21 +-
 src/App.discogs-artist-autocomplete.test.tsx  | 211 ++++++
 src/App.discogs-release-autocomplete.test.tsx | 239 +++++-
 src/App.discogs-track-autocomplete.test.tsx   | 299 ++++++++
 src/App.owned-items-inventory.test.tsx        |  83 ++-
 src/App.relation-credit-navigation.test.tsx   |  57 +-
 src/App.search-v1.test.tsx                    |  85 ++-
 src/App.server-navigation.test.tsx            | 254 +++----
 src/app/AuthenticatedApp.tsx                  |  10 +-
 src/app/renderWorkspace.tsx                   | 112 +--
 src/features/artists/ArtistDetail.tsx         |  11 +
 src/features/artists/ArtistsWorkspace.tsx     |  62 +-
 .../artists/DiscogsArtistLookupPanel.tsx      | 342 +++++++++
 src/features/artists/artistsData.ts           |   6 +-
 src/features/catalog/api/artistLabelClient.ts |   6 +
 .../catalog/api/catalogEntityMappers.ts       |   6 +
 .../catalog/api/catalogRequestMappers.ts      |  13 +-
 src/features/catalog/api/catalogTypes.ts      |   5 +
 .../catalog/api/catalogValueMappers.ts        |  47 +-
 .../catalog/api/externalMetadataClient.ts     | 124 ++++
 src/features/catalog/api/trackClient.ts       |   6 +
 .../catalog/catalogApi.mutations.test.ts      | 105 +++
 .../catalog/externalMetadataClient.test.ts    | 153 ++++
 src/features/manualEntry/manual-entry.css     |  12 +
 src/features/releases/CreditRolePicker.tsx    |  44 ++
 .../releases/DiscogsReleaseLookupPanel.tsx    | 681 +++++++++++++-----
 .../releases/ReleaseArtistCreditsSection.tsx  | 105 ++-
 src/features/releases/ReleaseCoreSection.tsx  |  13 +
 src/features/releases/ReleaseDetail.tsx       |  10 +-
 src/features/releases/ReleaseEntryForm.tsx    | 201 +++++-
 .../releases/ReleaseEntryFormTypes.ts         |   1 +
 .../releases/ReleaseTrackArtistCreditChip.tsx |  73 +-
 src/features/releases/ReleaseTrackDetail.tsx  |   2 +-
 .../releases/ReleaseTracklistSection.tsx      |   2 +-
 .../releases/discogsReleaseTrackRows.test.ts  |  32 +
 .../releases/discogsReleaseTrackRows.ts       |  26 +
 src/features/releases/release-form.css        | 372 ++++++++--
 src/features/releases/releaseFormHelpers.ts   |  11 +-
 src/features/releases/releaseSubmit.ts        |  24 +-
 src/features/releases/releasesData.ts         |   1 +
 .../releases/useReleaseTrackDrafts.ts         |  14 +-
 .../tracks/DiscogsTrackLookupPanel.tsx        | 594 +++++++++++++++
 src/features/tracks/TrackDetail.tsx           |  20 +-
 src/features/tracks/TrackEntryForm.tsx        | 227 +++++-
 src/features/tracks/TracksWorkspace.tsx       |  32 +-
 src/features/tracks/trackDisplayHelpers.ts    |  11 +-
 src/features/tracks/tracks.css                |  43 ++
 src/features/tracks/tracksData.ts             |   7 +-
 vitest.config.ts                              |   2 +
 51 files changed, 4221 insertions(+), 716 deletions(-)
 create mode 100644 src/App.discogs-artist-autocomplete.test.tsx
 create mode 100644 src/App.discogs-track-autocomplete.test.tsx
 create mode 100644 src/features/artists/DiscogsArtistLookupPanel.tsx
 create mode 100644 src/features/releases/CreditRolePicker.tsx
 create mode 100644 src/features/releases/discogsReleaseTrackRows.test.ts
 create mode 100644 src/features/releases/discogsReleaseTrackRows.ts
 create mode 100644 src/features/tracks/DiscogsTrackLookupPanel.tsx

diff --git a/.superdesign/design-system.md b/.superdesign/design-system.md
index c206a99..0374de6 100644
--- a/.superdesign/design-system.md
+++ b/.superdesign/design-system.md
@@ -21,3 +21,17 @@ DiscWeave is a dense personal music archive for collectors. The UI should stay c
 - Standard fields should be offered as curated options.
 - Custom field should be an explicit text input with validation hint, not hidden behind a select.
 - Compatibility copy must clarify that custom fields are best-effort and format-specific.
+
+## Discogs Release Review Requirements
+
+- Discogs lookup must stay inside the release form, not in a modal.
+- Keep the flow dense and review-oriented: search, candidates, selected review, group apply, then normal form save.
+- Do not show barcode search fields, barcode values, or raw identifier lists in release lookup/review UI unless a future product task makes them first-class fields.
+- Candidate rows should prioritize title, artists, year, labels, formats, catalog number, source link, and Discogs attribution.
+- Selecting a candidate must reveal the review immediately near the selected candidate or in a clearly visible review rail; users should not need to discover it by scrolling.
+- Review must make apply consequences explicit for Core, Artists, Labels, Tracklist, and External Source.
+- Artist role suggestions that are not already in local dictionaries should be presented as roles that will be added/accepted with the release update, not as unexplained raw Discogs strings.
+- Multiple Discogs artist credits must be shown as separate rows grouped under Artists, with each artist name, one or more roles, and a clear existing-role/new-role status. Do not collapse mixed artist roles into a single comma-separated sentence.
+- Tracklist review must clearly state whether tracks will be created, replaced, preserved, or updated before the user applies a group.
+- Tracklist impact must show representative per-track rows, not only a count. Each row should show position, title, duration when available, track artist credits, and whether those artists/roles are matched, new, or accepted.
+- Compilation and Various Artists cases must be explicit: when Discogs track rows have track-specific artists different from release artists, review should show that the release will be treated as Various Artists or that track-level artist credits will be applied. Do not hide compilation behavior behind a generic "Tracklist" checkbox.
diff --git a/src/App.auth.test.tsx b/src/App.auth.test.tsx
index 0d06121..a40adc8 100644
--- a/src/App.auth.test.tsx
+++ b/src/App.auth.test.tsx
@@ -192,7 +192,7 @@ describe('App auth', () => {
     ])
   })
 
-  it('opens artist records after login through server search without full catalog hydration', async () => {
+  it('opens artist records after login through the editable catalog workspace', async () => {
     h.clearCatalogForTests()
     h.clearAuthSessionForTests()
     window.history.pushState({}, '', '/artists')
@@ -208,7 +208,7 @@ describe('App auth', () => {
         email: 'collector@discweave.local',
         roles: ['Admin'],
       }),
-      h.emptySearchResponse(),
+      ...h.emptyCatalogLoadResponses(),
     )
     const user = h.userEvent.setup()
     h.render(<h.App />)
@@ -230,12 +230,8 @@ describe('App auth', () => {
 
     const urls = requestUrls(fetchMock)
     expect(urls.slice(0, 2)).toEqual(['/api/auth/session', '/api/auth/login'])
-    expect(
-      h
-        .searchRequestUrls(fetchMock)
-        .some((url) => url.searchParams.get('entityType') === 'artist'),
-    ).toBe(true)
-    expect(urls.some((url) => url.startsWith('/api/artists?'))).toBe(false)
+    expect(urls.some((url) => url.startsWith('/api/artists?'))).toBe(true)
+    expect(h.searchRequestUrls(fetchMock)).toHaveLength(0)
   })
 
   it('shows an accessible error after invalid login', async () => {
@@ -328,16 +324,31 @@ describe('App auth', () => {
     ).toBeEnabled()
   })
 
-  it('shows a server search error for entity workspaces', async () => {
+  it('shows a catalog load error for entity workspaces', async () => {
     h.clearCatalogForTests()
     window.history.pushState({}, '', '/tracks')
-    const fetchMock = h.mockFetch(
-      h.jsonResponse(
-        { code: 'catalog.server_error', message: 'Catalog unavailable' },
-        500,
-      ),
-      ...h.emptyCatalogLoadResponses().slice(1),
-    )
+    const fetchMock = h.vi.fn<Window['fetch']>(async (input) => {
+      const url = typeof input === 'string' ? input : (input as Request).url
+      await Promise.resolve()
+
+      if (url.startsWith('/api/tracks?')) {
+        return h.jsonResponse(
+          { code: 'catalog.server_error', message: 'Catalog unavailable' },
+          500,
+        )
+      }
+
+      if (url.startsWith('/api/settings/dictionaries?')) {
+        return h.defaultDictionaryListResponse()
+      }
+
+      if (url.startsWith('/api/rating-criteria?')) {
+        return h.defaultRatingCriteriaListResponse()
+      }
+
+      return h.emptyCatalogListResponse()
+    })
+    h.vi.stubGlobal('fetch', fetchMock)
 
     h.render(<h.App />)
 
@@ -345,11 +356,11 @@ describe('App auth', () => {
       await h.screen.findByRole('heading', { name: 'Tracks' }),
     ).toBeInTheDocument()
     expect(await h.screen.findByRole('alert')).toHaveTextContent(
-      'Catalog unavailable',
+      'Catalog request failed. Try again.',
     )
     expect(
       requestUrls(fetchMock).some((url) => url.startsWith('/api/tracks?')),
-    ).toBe(false)
+    ).toBe(true)
   })
 
   it('returns to sign in when a catalog mutation expires the session', async () => {
@@ -359,17 +370,20 @@ describe('App auth', () => {
       const url = typeof input === 'string' ? input : (input as Request).url
       await Promise.resolve()
 
-      if (url.startsWith('/api/search?')) {
-        return h.emptySearchResponse()
-      }
       if (url === '/api/artists') {
         return h.jsonResponse(
           { code: 'auth.unauthenticated', message: 'Session expired' },
           401,
         )
       }
+      if (url.startsWith('/api/settings/dictionaries?')) {
+        return h.defaultDictionaryListResponse()
+      }
+      if (url.startsWith('/api/rating-criteria?')) {
+        return h.defaultRatingCriteriaListResponse()
+      }
 
-      return h.emptySearchResponse()
+      return h.emptyCatalogListResponse()
     })
     h.vi.stubGlobal('fetch', fetchMock)
     const user = h.userEvent.setup()
@@ -390,19 +404,43 @@ describe('App auth', () => {
   it('keeps the loaded workspace available when a catalog refresh fails after a mutation', async () => {
     h.clearCatalogForTests()
     window.history.pushState({}, '', '/labels')
-    h.mockFetch(
-      h.emptySearchResponse(),
-      ...h.emptyCatalogLoadResponses(),
-      h.jsonResponse({
-        id: '00000000-0000-7000-8000-000000000010',
-        name: 'Refresh Failure Label',
+    let artistListRequests = 0
+    h.vi.stubGlobal(
+      'fetch',
+      h.vi.fn<Window['fetch']>(async (input, init) => {
+        const url = typeof input === 'string' ? input : (input as Request).url
+        await Promise.resolve()
+
+        if (url === '/api/labels' && init?.method === 'POST') {
+          return h.jsonResponse({
+            id: '00000000-0000-7000-8000-000000000010',
+            name: 'Refresh Failure Label',
+          })
+        }
+
+        if (url.startsWith('/api/artists?')) {
+          artistListRequests += 1
+          if (artistListRequests === 2) {
+            return h.jsonResponse(
+              {
+                code: 'catalog.server_error',
+                message: 'Catalog refresh failed',
+              },
+              500,
+            )
+          }
+        }
+
+        if (url.startsWith('/api/settings/dictionaries?')) {
+          return h.defaultDictionaryListResponse()
+        }
+
+        if (url.startsWith('/api/rating-criteria?')) {
+          return h.defaultRatingCriteriaListResponse()
+        }
+
+        return h.emptyCatalogListResponse()
       }),
-      h.jsonResponse(
-        { code: 'catalog.server_error', message: 'Catalog refresh failed' },
-        500,
-      ),
-      ...h.emptyCatalogLoadResponses().slice(1),
-      ...h.emptyCatalogLoadResponses(),
     )
     const user = h.userEvent.setup()
     h.render(<h.App />)
diff --git a/src/App.catalog-actions.test.tsx b/src/App.catalog-actions.test.tsx
index 1335cee..fe8e1e2 100644
--- a/src/App.catalog-actions.test.tsx
+++ b/src/App.catalog-actions.test.tsx
@@ -154,8 +154,22 @@ describe('App catalog actions', () => {
       if (url === '/api/catalog-graph/label/label-1') {
         return h.graphResponseForLabel()
       }
+      if (url.startsWith('/api/labels?')) {
+        return h.jsonResponse({
+          items: [{ id: 'label-1', name: 'Factory Records' }],
+          limit: 100,
+          offset: 0,
+          total: 1,
+        })
+      }
+      if (url.startsWith('/api/settings/dictionaries?')) {
+        return h.defaultDictionaryListResponse()
+      }
+      if (url.startsWith('/api/rating-criteria?')) {
+        return h.defaultRatingCriteriaListResponse()
+      }
 
-      return h.emptySearchResponse()
+      return h.emptyCatalogListResponse()
     })
     h.vi.stubGlobal('fetch', fetchMock)
     const user = h.userEvent.setup()
@@ -178,12 +192,15 @@ describe('App catalog actions', () => {
     expect(
       await h.screen.findByRole('complementary', { name: 'Factory Records' }),
     ).toBeInTheDocument()
+    expect(
+      h.screen.getByRole('button', { name: 'Edit record' }),
+    ).toBeInTheDocument()
     expect(
       fetchMock.mock.calls.some(
         ([input]) =>
           typeof input === 'string' && input.startsWith('/api/labels?'),
       ),
-    ).toBe(false)
+    ).toBe(true)
   })
 
   it('keeps label owned coverage tied to release ids instead of shared titles', async () => {
diff --git a/src/App.discogs-artist-autocomplete.test.tsx b/src/App.discogs-artist-autocomplete.test.tsx
new file mode 100644
index 0000000..b655b7e
--- /dev/null
+++ b/src/App.discogs-artist-autocomplete.test.tsx
@@ -0,0 +1,211 @@
+import { describe, expect, it } from 'vitest'
+import * as h from './test/appTestHarness'
+
+h.setupAppTestHooks()
+
+describe('App Discogs artist autocomplete', () => {
+  it('searches artist candidates and prefills a new artist only after review apply', async () => {
+    window.history.pushState({}, '', '/artists')
+    const fetchMock = h.vi.fn<Window['fetch']>().mockImplementation((input) => {
+      const url = requestUrl(input)
+
+      if (url.pathname === '/api/external-metadata/discogs/artists') {
+        return Promise.resolve(
+          h.jsonResponse({
+            items: [
+              {
+                source: source('5876'),
+                name: 'Arthur Baker',
+                profile: 'Producer and remixer.',
+                nameVariations: ['A. Baker'],
+              },
+            ],
+            limit: 25,
+            total: 1,
+          }),
+        )
+      }
+
+      if (url.pathname === '/api/external-metadata/discogs/artists/5876') {
+        return Promise.resolve(h.jsonResponse(artistDetail()))
+      }
+
+      throw new Error(`Unexpected request: ${url.pathname}`)
+    })
+    h.vi.stubGlobal('fetch', fetchMock)
+    const user = h.userEvent.setup()
+    h.render(<h.App />)
+
+    await user.click(h.screen.getByRole('button', { name: 'Add artist' }))
+    const form = h.screen.getByRole('form', { name: 'Add artist' })
+
+    await user.type(h.within(form).getByLabelText('Name'), 'Local Artist')
+    await user.click(
+      h.within(form).getByRole('button', { name: 'Search Discogs' }),
+    )
+
+    const lookup = h.within(form).getByRole('region', {
+      name: 'Discogs artist lookup',
+    })
+    await user.click(
+      h.within(lookup).getByRole('button', { name: 'Search Discogs artists' }),
+    )
+    await user.click(
+      await h.within(lookup).findByRole('button', {
+        name: /review arthur baker/i,
+      }),
+    )
+
+    expect(h.within(form).getByLabelText('Name')).toHaveValue('Local Artist')
+    expect(
+      await h.within(lookup).findByRole('heading', {
+        name: 'Review Discogs artist',
+      }),
+    ).toBeInTheDocument()
+    expect(h.within(lookup).getByText('Arthur Baker III')).toBeInTheDocument()
+    expect(
+      h
+        .within(lookup)
+        .getByRole('link', { name: 'Open Discogs artist source' }),
+    ).toHaveAttribute('href', 'https://www.discogs.com/artist/5876')
+
+    await user.click(
+      h.within(lookup).getByRole('button', {
+        name: 'Apply selected Discogs fields',
+      }),
+    )
+
+    expect(h.within(form).getByLabelText('Name')).toHaveValue('Arthur Baker')
+    await user.click(h.within(form).getByRole('button', { name: 'Add record' }))
+
+    const createdArtist = h
+      .getInitialCatalogStateForTests()
+      ?.artists.find((artist) => artist.name === 'Arthur Baker')
+    expect(createdArtist?.externalSources?.[0]).toMatchObject({
+      providerName: 'discogs',
+      resourceType: 'artist',
+      externalId: '5876',
+      sourceUrl: 'https://www.discogs.com/artist/5876',
+    })
+    expect(createdArtist?.externalSources?.[0].appliedAt).toMatch(
+      /^\d{4}-\d{2}-\d{2}T/,
+    )
+  })
+
+  it('reviews an existing artist update before applying selected groups', async () => {
+    window.history.pushState({}, '', '/artists?artist=new-order')
+    const fetchMock = h.vi.fn<Window['fetch']>().mockImplementation((input) => {
+      const url = requestUrl(input)
+
+      if (url.pathname === '/api/external-metadata/discogs/artists') {
+        return Promise.resolve(
+          h.jsonResponse({
+            items: [
+              {
+                source: source('3909'),
+                name: 'New Order',
+                profile: 'English rock band.',
+                nameVariations: ['N.O.'],
+              },
+            ],
+            limit: 25,
+            total: 1,
+          }),
+        )
+      }
+
+      if (url.pathname === '/api/external-metadata/discogs/artists/3909') {
+        return Promise.resolve(
+          h.jsonResponse({
+            ...artistDetail('3909', 'New Order'),
+            profile: 'English rock band.',
+            aliases: ['NO'],
+            members: ['Bernard Sumner'],
+            nameVariations: ['N.O.'],
+          }),
+        )
+      }
+
+      throw new Error(`Unexpected request: ${url.pathname}`)
+    })
+    h.vi.stubGlobal('fetch', fetchMock)
+    const user = h.userEvent.setup()
+    h.render(<h.App />)
+
+    await user.click(
+      h.screen.getByRole('button', { name: 'Update via Discogs' }),
+    )
+    const form = h.screen.getByRole('form', { name: 'Edit artist' })
+    const lookup = h.within(form).getByRole('region', {
+      name: 'Discogs artist lookup',
+    })
+
+    await user.click(
+      h.within(lookup).getByRole('button', { name: 'Search Discogs artists' }),
+    )
+    await user.click(
+      await h.within(lookup).findByRole('button', {
+        name: /review new order/i,
+      }),
+    )
+    await user.click(h.within(lookup).getByLabelText('Apply Core'))
+    await user.click(h.within(lookup).getByLabelText('Apply External Source'))
+    await user.click(
+      h.within(lookup).getByRole('button', {
+        name: 'Apply selected Discogs fields',
+      }),
+    )
+    await user.click(
+      h.within(form).getByRole('button', { name: 'Save record' }),
+    )
+
+    const updatedArtist = h
+      .getInitialCatalogStateForTests()
+      ?.artists.find((artist) => artist.id === 'new-order')
+    expect(updatedArtist?.externalSources?.[0]).toMatchObject({
+      providerName: 'discogs',
+      resourceType: 'artist',
+      externalId: '3909',
+    })
+  })
+})
+
+function requestUrl(input: Parameters<Window['fetch']>[0]) {
+  if (typeof input === 'string' || input instanceof URL) {
+    return new URL(input, 'http://localhost')
+  }
+
+  return new URL(input.url, 'http://localhost')
+}
+
+function source(externalId: string) {
+  return {
+    providerName: 'discogs',
+    resourceType: 'artist',
+    externalId,
+    sourceUrl: `https://www.discogs.com/artist/${externalId}`,
+    attribution: 'Data provided by Discogs.',
+  }
+}
+
+function artistDetail(externalId = '5876', name = 'Arthur Baker') {
+  return {
+    source: source(externalId),
+    name,
+    profile: 'Producer and remixer.',
+    aliases: ['Arthur Baker III'],
+    members: ['Rockers Revenge'],
+    nameVariations: ['A. Baker'],
+    draft: {
+      name,
+      externalSources: [
+        {
+          providerName: 'discogs',
+          resourceType: 'artist',
+          externalId,
+          sourceUrl: `https://www.discogs.com/artist/${externalId}`,
+        },
+      ],
+    },
+  }
+}
diff --git a/src/App.discogs-release-autocomplete.test.tsx b/src/App.discogs-release-autocomplete.test.tsx
index 4f5e2c6..ce03c39 100644
--- a/src/App.discogs-release-autocomplete.test.tsx
+++ b/src/App.discogs-release-autocomplete.test.tsx
@@ -57,6 +57,14 @@ describe('App Discogs release autocomplete', () => {
     await user.click(
       h.within(lookup).getByRole('button', { name: 'Search Discogs releases' }),
     )
+    const searchUrl = fetchMock.mock.calls
+      .map(([input]) => requestUrl(input))
+      .find((url) => url.pathname === '/api/external-metadata/discogs/releases')
+    expect(searchUrl?.searchParams.get('barcode')).toBeNull()
+    expect(h.within(lookup).queryByLabelText('Discogs barcode')).toBeNull()
+    expect(h.within(lookup).queryByText('5016839200371')).toBeNull()
+    expect(h.within(lookup).queryByText('Factory')).toBeNull()
+
     await user.click(
       await h.within(lookup).findByRole('button', {
         name: /review blue monday/i,
@@ -77,6 +85,12 @@ describe('App Discogs release autocomplete', () => {
     expect(
       h.within(lookup).getByRole('link', { name: 'Open Discogs source' }),
     ).toHaveAttribute('href', 'https://www.discogs.com/release/249504')
+    expect(h.within(lookup).queryByText(/Identifiers/i)).toBeNull()
+    expect(h.within(lookup).queryByText(/Barcodes/i)).toBeNull()
+    expect(h.within(lookup).queryByText(/External source/i)).toBeNull()
+    expect(h.within(lookup).getByText('Written-By')).toBeInTheDocument()
+    expect(h.within(lookup).queryByText('New role accepted')).toBeNull()
+    expect(h.within(lookup).queryByText('Matched local artist')).toBeNull()
 
     await user.click(
       h.within(lookup).getByRole('button', {
@@ -84,13 +98,31 @@ describe('App Discogs release autocomplete', () => {
       }),
     )
 
+    expect(
+      h.within(lookup).queryByRole('heading', {
+        name: 'Review Discogs candidate',
+      }),
+    ).not.toBeInTheDocument()
+    expect(
+      h
+        .within(lookup)
+        .getByText(
+          'Applied Discogs core, artists, labels, classification and tracklist to the form. Save record to persist changes.',
+        ),
+    ).toBeInTheDocument()
     expect(h.within(form).getByLabelText('Title')).toHaveValue('Blue Monday')
+    expect(h.within(form).getByLabelText('Release date')).toHaveValue(
+      '1983-03-07',
+    )
+    expect(h.within(form).getByLabelText('Type')).toHaveValue('single')
+    expect(h.within(form).getByLabelText('Genre Electronic')).toBeChecked()
+    expect(h.within(form).getByLabelText('Genre Leftfield')).toBeChecked()
     expect(h.within(form).getByText('Factory')).toBeInTheDocument()
     expect(h.within(form).getByText('FAC 73')).toBeInTheDocument()
     expect(h.within(form).getAllByText('Blue Monday').length).toBeGreaterThan(0)
     expect(
       h.within(form).getByRole('button', { name: 'Add record' }),
-    ).toBeDisabled()
+    ).toBeEnabled()
     expect(
       h.screen.queryByRole('complementary', { name: 'Blue Monday' }),
     ).not.toBeInTheDocument()
@@ -161,13 +193,22 @@ describe('App Discogs release autocomplete', () => {
     expect(h.within(form).getByLabelText('Title')).toHaveValue('Blue Monday')
 
     await user.click(h.within(lookup).getByLabelText('Apply Core'))
-    await user.click(h.within(lookup).getByLabelText('Apply External Source'))
+    expect(
+      h.within(lookup).queryByLabelText('Apply External Source'),
+    ).toBeNull()
     await user.click(
       h.within(lookup).getByRole('button', {
         name: 'Apply selected Discogs fields',
       }),
     )
 
+    expect(
+      h
+        .within(lookup)
+        .getByText(
+          'Applied Discogs core to the form. Save record to persist changes.',
+        ),
+    ).toBeInTheDocument()
     expect(h.within(form).getByLabelText('Title')).toHaveValue(
       'Blue Monday 12"',
     )
@@ -181,6 +222,7 @@ describe('App Discogs release autocomplete', () => {
       ?.releases.find((release) => release.id === 'blue-monday')
     expect(updatedRelease).toMatchObject({
       title: 'Blue Monday 12"',
+      releaseDate: '1983-03-07',
       externalSources: [
         {
           providerName: 'discogs',
@@ -194,6 +236,107 @@ describe('App Discogs release autocomplete', () => {
       /^\d{4}-\d{2}-\d{2}T/,
     )
   })
+
+  it('shows track artist and compilation impact before applying a Discogs tracklist', async () => {
+    window.history.pushState({}, '', '/releases')
+    const fetchMock = h.vi.fn<Window['fetch']>().mockImplementation((input) => {
+      const url = requestUrl(input)
+
+      if (url.pathname === '/api/external-metadata/discogs/releases') {
+        return Promise.resolve(
+          h.jsonResponse({
+            items: [
+              {
+                source: source('orb-1991'),
+                title: "The Orb's Adventures Beyond The Ultraworld",
+                artists: ['The Orb'],
+                year: 1991,
+                labels: ['Big Life'],
+                formats: ['CD', 'Album'],
+                catalogNumber: 'BLRCD 5',
+                barcodes: ['042284796323'],
+              },
+            ],
+            limit: 25,
+            total: 1,
+          }),
+        )
+      }
+
+      if (url.pathname === '/api/external-metadata/discogs/releases/orb-1991') {
+        return Promise.resolve(h.jsonResponse(compilationReleaseDetail()))
+      }
+
+      throw new Error(`Unexpected request: ${url.pathname}`)
+    })
+    h.vi.stubGlobal('fetch', fetchMock)
+    const user = h.userEvent.setup()
+    h.render(<h.App />)
+
+    await user.click(h.screen.getByRole('button', { name: 'Add release' }))
+    const form = h.screen.getByRole('form', { name: 'Add release' })
+
+    await user.type(
+      h.within(form).getByLabelText('Title'),
+      "The Orb's Adventures",
+    )
+    await user.click(
+      h.within(form).getByRole('button', { name: 'Search Discogs' }),
+    )
+
+    const lookup = h.within(form).getByRole('region', {
+      name: 'Discogs release lookup',
+    })
+    await user.click(
+      h.within(lookup).getByRole('button', { name: 'Search Discogs releases' }),
+    )
+    await user.click(
+      await h.within(lookup).findByRole('button', {
+        name: /review the orb's adventures/i,
+      }),
+    )
+
+    expect(
+      h.within(lookup).getByText(/Compilation detected/i),
+    ).toBeInTheDocument()
+    expect(h.within(lookup).queryByText(/Discogs heading row/i)).toBeNull()
+    expect(h.within(lookup).queryByText('Orbit Compact Disc')).toBeNull()
+    expect(
+      h.within(lookup).getByText('Little Fluffy Clouds'),
+    ).toBeInTheDocument()
+    expect(h.within(lookup).getByText('Earth (Gaia)')).toBeInTheDocument()
+    expect(h.within(lookup).getByText('Perpetual Dawn')).toBeInTheDocument()
+    expect(h.within(lookup).getAllByText('Main artist').length).toBeGreaterThan(
+      0,
+    )
+    expect(h.within(lookup).getByText('Engineer')).toBeInTheDocument()
+    expect(h.within(lookup).getByText('Guitar')).toBeInTheDocument()
+    expect(h.within(lookup).getByText('Producer')).toBeInTheDocument()
+    expect(h.within(lookup).getAllByText('Steve Hillage')).toHaveLength(1)
+    expect(h.within(lookup).queryByText('New role accepted')).toBeNull()
+    expect(h.within(lookup).queryByText('Matched local artist')).toBeNull()
+    expect(h.within(lookup).queryByText('042284796323')).toBeNull()
+
+    await user.click(
+      h.within(lookup).getByRole('button', {
+        name: 'Show 1 more Discogs track row',
+      }),
+    )
+    expect(
+      h.within(lookup).getByText('Into The Fourth Dimension'),
+    ).toBeInTheDocument()
+
+    await user.click(
+      h.within(lookup).getByRole('button', {
+        name: 'Apply selected Discogs fields',
+      }),
+    )
+
+    expect(h.within(form).getByLabelText('Various Artists')).toBeChecked()
+    expect(
+      h.within(form).getByText('Track rows must include their own artists.'),
+    ).toBeInTheDocument()
+  })
 })
 
 function requestUrl(input: Parameters<Window['fetch']>[0]) {
@@ -236,7 +379,10 @@ function releaseDetail() {
     credits: [{ name: 'New Order', role: 'Written-By' }],
     draft: {
       title: 'Blue Monday',
+      type: 'single',
+      genres: ['Electronic', 'Leftfield'],
       year: 1983,
+      releaseDate: '1983-03-07',
       artistCredits: [{ name: 'New Order', role: 'mainArtist' }],
       labels: [
         {
@@ -250,7 +396,10 @@ function releaseDetail() {
           title: 'Blue Monday',
           position: 1,
           durationSeconds: 449,
-          artistCredits: [{ name: 'New Order', role: 'mainArtist' }],
+          artistCredits: [
+            { name: 'New Order', role: 'mainArtist' },
+            { name: 'New Order', role: 'Written-By' },
+          ],
         },
       ],
       externalSources: [
@@ -264,3 +413,87 @@ function releaseDetail() {
     },
   }
 }
+
+function compilationReleaseDetail() {
+  return {
+    source: source('orb-1991'),
+    title: "The Orb's Adventures Beyond The Ultraworld",
+    artists: ['The Orb'],
+    year: 1991,
+    labels: ['Big Life'],
+    formats: ['CD', 'Album'],
+    tracklist: [],
+    identifiers: [{ type: 'Barcode', value: '042284796323' }],
+    barcodes: ['042284796323'],
+    catalogNumber: 'BLRCD 5',
+    credits: [],
+    draft: {
+      title: "The Orb's Adventures Beyond The Ultraworld",
+      genres: ['Electronic'],
+      year: 1991,
+      artistCredits: [{ name: 'The Orb', role: 'mainArtist' }],
+      labels: [
+        {
+          name: 'Big Life',
+          catalogNumber: 'BLRCD 5',
+          hasNoCatalogNumber: false,
+        },
+      ],
+      tracklist: [
+        {
+          title: 'Orbit Compact Disc',
+          position: 1,
+          durationSeconds: null,
+          artistCredits: [
+            { name: 'Heading Credit', role: 'Design [Not a track]' },
+          ],
+        },
+        {
+          title: 'Little Fluffy Clouds',
+          position: 2,
+          durationSeconds: 269,
+          artistCredits: [{ name: 'The Orb', role: 'mainArtist' }],
+        },
+        {
+          title: 'Earth (Gaia)',
+          position: 3,
+          durationSeconds: 580,
+          artistCredits: [
+            { name: 'The Orb', role: 'mainArtist' },
+            { name: 'Andy Falconer', role: 'engineer' },
+          ],
+        },
+        {
+          title: 'Perpetual Dawn',
+          position: 4,
+          durationSeconds: 568,
+          artistCredits: [
+            { name: 'The Orb', role: 'mainArtist' },
+            { name: 'Steve Hillage', role: 'Guitar' },
+            { name: 'Steve Hillage', role: 'Producer' },
+          ],
+        },
+        {
+          title: 'Back Side Of The Moon',
+          position: 5,
+          durationSeconds: 826,
+          artistCredits: [{ name: 'Thomas Fehlmann', role: 'mainArtist' }],
+        },
+        {
+          title: 'Into The Fourth Dimension',
+          position: 6,
+          durationSeconds: 572,
+          artistCredits: [{ name: 'The Orb', role: 'mainArtist' }],
+        },
+      ],
+      externalSources: [
+        {
+          providerName: 'discogs',
+          resourceType: 'release',
+          externalId: 'orb-1991',
+          sourceUrl: 'https://www.discogs.com/release/orb-1991',
+        },
+      ],
+    },
+  }
+}
diff --git a/src/App.discogs-track-autocomplete.test.tsx b/src/App.discogs-track-autocomplete.test.tsx
new file mode 100644
index 0000000..ecebd2a
--- /dev/null
+++ b/src/App.discogs-track-autocomplete.test.tsx
@@ -0,0 +1,299 @@
+import { describe, expect, it } from 'vitest'
+import * as h from './test/appTestHarness'
+
+h.setupAppTestHooks()
+
+describe('App Discogs track autocomplete', () => {
+  it('searches track candidates and prefills a new track only after review apply', async () => {
+    window.history.pushState({}, '', '/tracks')
+    const fetchMock = h.vi.fn<Window['fetch']>().mockImplementation((input) => {
+      const url = requestUrl(input)
+
+      if (url.pathname === '/api/external-metadata/discogs/tracks') {
+        return Promise.resolve(
+          h.jsonResponse({
+            items: [trackCandidate()],
+            limit: 25,
+            total: 1,
+          }),
+        )
+      }
+
+      if (
+        url.pathname ===
+        `/api/external-metadata/discogs/tracks/${encodeURIComponent(trackId)}`
+      ) {
+        return Promise.resolve(h.jsonResponse(trackDetail()))
+      }
+
+      throw new Error(`Unexpected request: ${url.pathname}`)
+    })
+    h.vi.stubGlobal('fetch', fetchMock)
+    const user = h.userEvent.setup()
+    h.render(<h.App />)
+
+    await user.click(h.screen.getByRole('button', { name: 'Add track' }))
+    const form = h.screen.getByRole('form', { name: 'Add track' })
+
+    await user.type(h.within(form).getByLabelText('Title'), 'Working track')
+    await user.click(
+      h.within(form).getByRole('button', { name: 'Search Discogs' }),
+    )
+
+    const lookup = h.within(form).getByRole('region', {
+      name: 'Discogs track lookup',
+    })
+    expect(h.within(lookup).queryByLabelText('Discogs barcode')).toBeNull()
+    await user.click(
+      h.within(lookup).getByRole('button', { name: 'Search Discogs tracks' }),
+    )
+    expect(
+      requestUrl(fetchMock.mock.calls[0]?.[0]).searchParams.has('barcode'),
+    ).toBe(false)
+    await user.click(
+      await h.within(lookup).findByRole('button', {
+        name: /review blue monday/i,
+      }),
+    )
+
+    expect(h.within(form).getByLabelText('Title')).toHaveValue('Working track')
+    expect(
+      await h.within(lookup).findByRole('heading', {
+        name: 'Review Discogs track',
+      }),
+    ).toBeInTheDocument()
+    expect(h.within(lookup).getAllByText('New Order').length).toBeGreaterThan(0)
+    expect(
+      h.within(lookup).getAllByText('Data provided by Discogs.').length,
+    ).toBeGreaterThan(0)
+    expect(
+      h.within(lookup).getByRole('link', { name: 'Open Discogs track source' }),
+    ).toHaveAttribute('href', 'https://www.discogs.com/release/249504')
+    expect(h.within(lookup).getByText('Producer')).toBeInTheDocument()
+    expect(
+      h.within(lookup).queryByLabelText('Apply External Source'),
+    ).toBeNull()
+
+    await user.click(
+      h.within(lookup).getByRole('button', {
+        name: 'Apply selected Discogs fields',
+      }),
+    )
+
+    expect(h.within(form).getByLabelText('Title')).toHaveValue('Blue Monday')
+    expect(h.within(form).getByLabelText('Track duration minutes')).toHaveValue(
+      7,
+    )
+    expect(h.within(form).getByLabelText('Track duration seconds')).toHaveValue(
+      29,
+    )
+    expect(
+      h
+        .within(lookup)
+        .getByText(/Applied Discogs core and credits to the form/i),
+    ).toBeInTheDocument()
+    expect(
+      h.within(lookup).queryByRole('heading', {
+        name: 'Review Discogs track',
+      }),
+    ).toBeNull()
+
+    await user.click(h.within(form).getByRole('button', { name: 'Add record' }))
+
+    const createdTrack = h
+      .getInitialCatalogStateForTests()
+      ?.tracks.filter((track) => track.title === 'Blue Monday')
+      .slice(-1)[0]
+    expect(createdTrack?.externalSources?.[0]).toMatchObject({
+      providerName: 'discogs',
+      resourceType: 'track',
+      externalId: trackId,
+      sourceUrl: 'https://www.discogs.com/release/249504',
+    })
+    expect(createdTrack?.externalSources?.[0].appliedAt).toMatch(
+      /^\d{4}-\d{2}-\d{2}T/,
+    )
+    expect(createdTrack?.credits).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          artist: 'New Order',
+          role: 'Main artist',
+          roles: ['Main artist', 'Producer'],
+        }),
+      ]),
+    )
+  })
+
+  it('reviews an existing track update before applying selected groups', async () => {
+    window.history.pushState({}, '', '/tracks?track=blue-monday')
+    const fetchMock = h.vi.fn<Window['fetch']>().mockImplementation((input) => {
+      const url = requestUrl(input)
+
+      if (url.pathname === '/api/external-metadata/discogs/tracks') {
+        return Promise.resolve(
+          h.jsonResponse({
+            items: [
+              {
+                ...trackCandidate(),
+                title: 'Blue Monday (Factory Mix)',
+              },
+            ],
+            limit: 25,
+            total: 1,
+          }),
+        )
+      }
+
+      if (
+        url.pathname ===
+        `/api/external-metadata/discogs/tracks/${encodeURIComponent(trackId)}`
+      ) {
+        return Promise.resolve(
+          h.jsonResponse({
+            ...trackDetail(),
+            title: 'Blue Monday (Factory Mix)',
+            draft: {
+              ...trackDetail().draft,
+              title: 'Blue Monday (Factory Mix)',
+            },
+          }),
+        )
+      }
+
+      throw new Error(`Unexpected request: ${url.pathname}`)
+    })
+    h.vi.stubGlobal('fetch', fetchMock)
+    const user = h.userEvent.setup()
+    h.render(<h.App />)
+
+    await user.click(
+      h.screen.getByRole('button', { name: 'Update via Discogs' }),
+    )
+    const form = h.screen.getByRole('form', { name: 'Edit track' })
+    const lookup = h.within(form).getByRole('region', {
+      name: 'Discogs track lookup',
+    })
+
+    await user.click(
+      h.within(lookup).getByRole('button', { name: 'Search Discogs tracks' }),
+    )
+    await user.click(
+      await h.within(lookup).findByRole('button', {
+        name: /review blue monday/i,
+      }),
+    )
+
+    expect(h.within(form).getByLabelText('Title')).toHaveValue('Blue Monday')
+
+    await user.click(h.within(lookup).getByLabelText('Apply Core'))
+    await user.click(h.within(lookup).getByLabelText('Apply Credits'))
+    expect(
+      h.within(lookup).queryByLabelText('Apply External Source'),
+    ).toBeNull()
+    await user.click(
+      h.within(lookup).getByRole('button', {
+        name: 'Apply selected Discogs fields',
+      }),
+    )
+    expect(
+      h
+        .within(lookup)
+        .getByText(/Applied Discogs core and credits to the form/i),
+    ).toBeInTheDocument()
+    await user.click(
+      h.within(form).getByRole('button', { name: 'Save record' }),
+    )
+
+    const updatedTrack = h
+      .getInitialCatalogStateForTests()
+      ?.tracks.find((track) => track.id === 'blue-monday')
+    expect(updatedTrack).toMatchObject({
+      title: 'Blue Monday (Factory Mix)',
+      credits: [
+        {
+          artist: 'New Order',
+          role: 'Main artist',
+          roles: ['Main artist', 'Producer'],
+        },
+      ],
+      externalSources: [
+        {
+          providerName: 'discogs',
+          resourceType: 'track',
+          externalId: trackId,
+          sourceUrl: 'https://www.discogs.com/release/249504',
+        },
+      ],
+    })
+  })
+})
+
+const trackId = '249504:A:Blue-Monday'
+
+function requestUrl(input: Parameters<Window['fetch']>[0]) {
+  if (typeof input === 'string' || input instanceof URL) {
+    return new URL(input, 'http://localhost')
+  }
+
+  return new URL(input.url, 'http://localhost')
+}
+
+function source(externalId: string, resourceType = 'track') {
+  return {
+    providerName: 'discogs',
+    resourceType,
+    externalId,
+    sourceUrl: 'https://www.discogs.com/release/249504',
+    attribution: 'Data provided by Discogs.',
+  }
+}
+
+function trackCandidate() {
+  return {
+    source: source(trackId),
+    title: 'Blue Monday',
+    position: 'A',
+    durationSeconds: 449,
+    artists: ['New Order'],
+    release: {
+      source: source('249504', 'release'),
+      title: 'Blue Monday',
+      year: 1983,
+      artists: ['New Order'],
+    },
+  }
+}
+
+function trackDetail() {
+  return {
+    ...trackCandidate(),
+    credits: [
+      {
+        name: 'New Order',
+        role: 'Producer',
+      },
+    ],
+    draft: {
+      title: 'Blue Monday',
+      durationSeconds: 449,
+      artistCredits: [
+        {
+          name: 'New Order',
+          role: 'Main artist',
+        },
+        {
+          name: 'New Order',
+          role: 'Producer',
+        },
+      ],
+      externalSources: [
+        {
+          providerName: 'discogs',
+          resourceType: 'track',
+          externalId: trackId,
+          sourceUrl: 'https://www.discogs.com/release/249504',
+        },
+      ],
+    },
+  }
+}
diff --git a/src/App.owned-items-inventory.test.tsx b/src/App.owned-items-inventory.test.tsx
index ded2e7e..1cb6c10 100644
--- a/src/App.owned-items-inventory.test.tsx
+++ b/src/App.owned-items-inventory.test.tsx
@@ -4,21 +4,94 @@ import * as h from './test/appTestHarness'
 h.setupAppTestHooks()
 
 describe('App owned item workspace', () => {
-  it('loads owned item inventory through the paged server endpoint by default', async () => {
+  it('loads owned items into the editable workspace by default', async () => {
     window.history.pushState({}, '', '/owned-items')
     h.clearCatalogForTests()
-    const fetchMock = h.mockFetch(h.emptyCatalogListResponse())
+    const fetchMock = h.vi.fn<Window['fetch']>(async (input) => {
+      const url = typeof input === 'string' ? input : (input as Request).url
+      await Promise.resolve()
+
+      if (url.startsWith('/api/releases?')) {
+        return h.jsonResponse({
+          items: [
+            {
+              id: 'release-blue-monday',
+              title: 'Blue Monday',
+              type: 'single',
+              year: 1983,
+              releaseDate: null,
+              genres: [],
+              tags: [],
+              artistCredits: [],
+              labels: [],
+              tracklist: [],
+            },
+          ],
+          limit: 100,
+          offset: 0,
+          total: 1,
+        })
+      }
+      if (url.startsWith('/api/owned-items?')) {
+        return h.jsonResponse({
+          items: [
+            {
+              id: 'owned-blue-monday-vinyl',
+              targetType: 'release',
+              targetId: 'release-blue-monday',
+              target: {
+                type: 'release',
+                id: 'release-blue-monday',
+                title: 'Blue Monday',
+                subtitle: 'New Order',
+                releaseId: 'release-blue-monday',
+                releaseTitle: 'Blue Monday',
+              },
+              status: 'owned',
+              medium: {
+                type: 'vinyl',
+                description: null,
+                path: null,
+                format: null,
+                discCount: null,
+              },
+              condition: 'veryGood',
+              storageLocation: 'Shelf A3',
+              inventorySignals: ['physicalWithoutDigital'],
+            },
+          ],
+          limit: 100,
+          offset: 0,
+          total: 1,
+        })
+      }
+      if (url.startsWith('/api/settings/dictionaries?')) {
+        return h.defaultDictionaryListResponse()
+      }
+      if (url.startsWith('/api/rating-criteria?')) {
+        return h.defaultRatingCriteriaListResponse()
+      }
+
+      return h.emptyCatalogListResponse()
+    })
+    h.vi.stubGlobal('fetch', fetchMock)
 
     h.render(<h.App />)
 
     expect(
-      await h.screen.findByRole('heading', { name: 'Owned item inventory' }),
+      await h.screen.findByRole('heading', { name: 'Owned item records' }),
+    ).toBeInTheDocument()
+    expect(
+      await h.screen.findByRole('complementary', { name: 'Blue Monday' }),
+    ).toBeInTheDocument()
+    expect(
+      h.screen.getByRole('button', { name: 'Edit record' }),
     ).toBeInTheDocument()
 
     const urls = requestUrls(fetchMock)
     expect(urls).toContain('/api/owned-items?limit=100&offset=0')
-    expect(urls.some((url) => url.startsWith('/api/releases?'))).toBe(false)
-    expect(urls.some((url) => url.startsWith('/api/tracks?'))).toBe(false)
+    expect(urls.some((url) => url.startsWith('/api/releases?'))).toBe(true)
+    expect(urls.some((url) => url.startsWith('/api/tracks?'))).toBe(true)
   })
 
   it('renders release and track target links from owned item summaries', async () => {
diff --git a/src/App.relation-credit-navigation.test.tsx b/src/App.relation-credit-navigation.test.tsx
index 62cba78..d841ce8 100644
--- a/src/App.relation-credit-navigation.test.tsx
+++ b/src/App.relation-credit-navigation.test.tsx
@@ -87,11 +87,44 @@ describe('App relation and credit navigation', () => {
       if (url === '/api/catalog-graph/artist/artist-1') {
         return f.graphResponseForArtistNavigation()
       }
-      if (url === '/api/artist-relations/artist-relation-1') {
-        return f.artistRelationDetailResponse()
+      if (url.startsWith('/api/artists?')) {
+        return h.jsonResponse({
+          items: [
+            { id: 'artist-1', name: 'Arthur Baker', type: 'person' },
+            { id: 'artist-2', name: 'New Order', type: 'group' },
+          ],
+          limit: 100,
+          offset: 0,
+          total: 2,
+        })
+      }
+      if (url.startsWith('/api/artist-relations?')) {
+        return h.jsonResponse({
+          items: [
+            {
+              id: 'artist-relation-1',
+              sourceArtistId: 'artist-1',
+              targetArtistId: 'artist-2',
+              type: 'collaboration',
+              startYear: 1983,
+              endYear: null,
+              sourceArtistName: 'Arthur Baker',
+              targetArtistName: 'New Order',
+            },
+          ],
+          limit: 100,
+          offset: 0,
+          total: 1,
+        })
+      }
+      if (url.startsWith('/api/settings/dictionaries?')) {
+        return h.defaultDictionaryListResponse()
+      }
+      if (url.startsWith('/api/rating-criteria?')) {
+        return h.defaultRatingCriteriaListResponse()
       }
 
-      return h.emptySearchResponse()
+      return h.emptyCatalogListResponse()
     })
     h.vi.stubGlobal('fetch', fetchMock)
     const user = h.userEvent.setup()
@@ -113,9 +146,21 @@ describe('App relation and credit navigation', () => {
       }),
     ).toBeInTheDocument()
     expect(
-      h
-        .searchRequestUrls(fetchMock)
-        .some((url) => url.searchParams.get('savedView') === 'credits'),
+      h.screen.getByRole('button', { name: 'Edit record' }),
+    ).toBeInTheDocument()
+    expect(
+      fetchMock.mock.calls.some(
+        ([input]) =>
+          typeof input === 'string' &&
+          input.startsWith('/api/artist-relations?'),
+      ),
     ).toBe(true)
+    expect(
+      fetchMock.mock.calls.some(
+        ([input]) =>
+          typeof input === 'string' &&
+          input === '/api/artist-relations/artist-relation-1',
+      ),
+    ).toBe(false)
   })
 })
diff --git a/src/App.search-v1.test.tsx b/src/App.search-v1.test.tsx
index 36b4a5e..8ffa988 100644
--- a/src/App.search-v1.test.tsx
+++ b/src/App.search-v1.test.tsx
@@ -94,14 +94,54 @@ describe('App search v1 UI', () => {
       if (url === '/api/catalog-graph/track/track-producer') {
         return graphResponseWithRelation()
       }
-      if (url === '/api/artist-relations/private-relation') {
-        return h.jsonResponse({}, 404)
+      if (url.startsWith('/api/tracks?')) {
+        return h.jsonResponse({
+          items: [
+            {
+              id: 'track-producer',
+              title: 'Archive Producer Cut',
+              durationSeconds: null,
+              genres: [],
+              tags: [],
+            },
+            {
+              id: 'track-private-dub',
+              title: 'Private Dub',
+              durationSeconds: null,
+              genres: [],
+              tags: [],
+            },
+          ],
+          limit: 100,
+          offset: 0,
+          total: 2,
+        })
+      }
+      if (url.startsWith('/api/track-relations?')) {
+        return h.jsonResponse({
+          items: [
+            {
+              id: 'private-relation',
+              sourceTrackId: 'track-producer',
+              targetTrackId: 'track-private-dub',
+              type: 'remixOf',
+              sourceTrackTitle: 'Archive Producer Cut',
+              targetTrackTitle: 'Private Dub',
+            },
+          ],
+          limit: 100,
+          offset: 0,
+          total: 1,
+        })
+      }
+      if (url.startsWith('/api/settings/dictionaries?')) {
+        return h.defaultDictionaryListResponse()
       }
-      if (url === '/api/track-relations/private-relation') {
-        return trackRelationDetailResponse()
+      if (url.startsWith('/api/rating-criteria?')) {
+        return h.defaultRatingCriteriaListResponse()
       }
 
-      return h.emptySearchResponse()
+      return h.emptyCatalogListResponse()
     })
     h.vi.stubGlobal('fetch', fetchMock)
     const user = h.userEvent.setup()
@@ -117,19 +157,29 @@ describe('App search v1 UI', () => {
     await h.waitFor(() => {
       expect(window.location.pathname).toBe('/relations')
     })
-    await h.waitFor(() => {
-      expect(
-        h
-          .searchRequestUrls(fetchMock)
-          .some((url) => url.searchParams.get('savedView') === 'credits'),
-      ).toBe(true)
-    })
+    expect(
+      fetchMock.mock.calls.some(
+        ([input]) =>
+          typeof input === 'string' &&
+          input.startsWith('/api/track-relations?'),
+      ),
+    ).toBe(true)
+    expect(
+      fetchMock.mock.calls.some(
+        ([input]) =>
+          typeof input === 'string' &&
+          input === '/api/track-relations/private-relation',
+      ),
+    ).toBe(false)
 
     expect(
       await h.screen.findByRole('heading', {
         name: 'Archive Producer Cut to Private Dub',
       }),
     ).toBeInTheDocument()
+    expect(
+      h.screen.getByRole('button', { name: 'Edit record' }),
+    ).toBeInTheDocument()
   })
 })
 
@@ -246,14 +296,3 @@ function graphResponseWithRelation() {
     collectorSignals: ['Physical media without digital copy'],
   })
 }
-
-function trackRelationDetailResponse() {
-  return h.jsonResponse({
-    id: 'private-relation',
-    sourceTrackId: 'track-producer',
-    targetTrackId: 'track-private-dub',
-    type: 'remixOf',
-    sourceTrackTitle: 'Archive Producer Cut',
-    targetTrackTitle: 'Private Dub',
-  })
-}
diff --git a/src/App.server-navigation.test.tsx b/src/App.server-navigation.test.tsx
index 7e09218..0704277 100644
--- a/src/App.server-navigation.test.tsx
+++ b/src/App.server-navigation.test.tsx
@@ -35,10 +35,64 @@ describe('App workspace navigation', () => {
     })
   })
 
-  it('renders releases through paged server search without hydrating the full catalog', async () => {
+  it('renders releases as an editable release workspace after hydrating the catalog', async () => {
     window.history.pushState({}, '', '/releases')
     h.clearCatalogForTests()
-    const fetchMock = h.mockFetch(h.emptySearchResponse())
+    const fetchMock = h.vi.fn<Window['fetch']>(async (input) => {
+      const url = typeof input === 'string' ? input : (input as Request).url
+      await Promise.resolve()
+
+      if (url.startsWith('/api/artists?')) {
+        return listResponse([
+          { id: 'artist-orb', type: 'group', name: 'The Orb' },
+        ])
+      }
+
+      if (url.startsWith('/api/labels?')) {
+        return listResponse([{ id: 'label-big-life', name: 'Big Life' }])
+      }
+
+      if (url.startsWith('/api/releases?')) {
+        return listResponse([
+          {
+            id: 'release-orb',
+            title: "The Orb's Adventures Beyond the Ultraworld",
+            type: 'album',
+            year: 1991,
+            releaseDate: null,
+            genres: ['Electronic'],
+            tags: [],
+            artistCredits: [
+              {
+                artistId: 'artist-orb',
+                artistName: 'The Orb',
+                role: 'mainArtist',
+              },
+            ],
+            labels: [
+              {
+                labelId: 'label-big-life',
+                name: 'Big Life',
+                catalogNumber: 'BLRCD 5',
+                hasNoCatalogNumber: false,
+              },
+            ],
+            tracklist: [],
+          },
+        ])
+      }
+
+      if (url.startsWith('/api/settings/dictionaries?')) {
+        return h.defaultDictionaryListResponse()
+      }
+
+      if (url.startsWith('/api/rating-criteria?')) {
+        return h.defaultRatingCriteriaListResponse()
+      }
+
+      return h.emptyCatalogListResponse()
+    })
+    h.vi.stubGlobal('fetch', fetchMock)
 
     h.render(<h.App />)
 
@@ -46,122 +100,103 @@ describe('App workspace navigation', () => {
       await h.screen.findByRole('heading', { name: 'Releases' }),
     ).toBeInTheDocument()
     expect(
-      h.screen.getByRole('heading', { name: 'Catalog results' }),
+      await h.screen.findByRole('heading', { name: 'Release records' }),
     ).toBeInTheDocument()
-
-    const urls = requestUrls(fetchMock)
-    expect(searchUrls(fetchMock)).toHaveLength(1)
-    expect(searchUrls(fetchMock)[0].searchParams.get('entityType')).toBe(
-      'release',
-    )
-    expect(searchUrls(fetchMock)[0].searchParams.get('limit')).toBe('100')
-    expect(searchUrls(fetchMock)[0].searchParams.get('offset')).toBe('0')
-    expect(urls.some((url) => url.startsWith('/api/releases?'))).toBe(false)
-    expect(urls.some((url) => url.startsWith('/api/tracks?'))).toBe(false)
-    expect(urls.some((url) => url.startsWith('/api/owned-items?'))).toBe(false)
-  })
-
-  it('keeps entity navigation on server search without full catalog hydration', async () => {
-    h.clearCatalogForTests()
-    const fetchMock = h.mockFetch(
-      h.emptySearchResponse(),
-      h.emptySearchResponse(),
-      h.emptySearchResponse(),
-    )
-    const user = h.userEvent.setup()
-    h.render(<h.App />)
-
-    await h.screen.findByText('No matching catalog entries.')
-    await user.click(h.screen.getByRole('link', { name: 'Releases' }))
-
     expect(
-      await h.screen.findByRole('heading', { name: 'Catalog results' }),
+      h.screen.queryByRole('heading', { name: 'Catalog results' }),
+    ).not.toBeInTheDocument()
+    expect(
+      h.screen.getByRole('columnheader', { name: 'Catalog #' }),
     ).toBeInTheDocument()
-
-    await user.click(h.screen.getByRole('link', { name: 'Tracks' }))
-
     expect(
-      await h.screen.findByRole('heading', { name: 'Catalog results' }),
+      h.screen.getByRole('row', {
+        name: /The Orb's Adventures Beyond the Ultraworld/i,
+      }),
+    ).toBeInTheDocument()
+    expect(
+      h.screen.getByRole('button', { name: 'Edit record' }),
     ).toBeInTheDocument()
 
     const urls = requestUrls(fetchMock)
+    expect(urls.some((url) => url.startsWith('/api/releases?'))).toBe(true)
     expect(
-      searchUrls(fetchMock).map((url) => url.searchParams.get('entityType')),
-    ).toEqual([null, 'release', 'track'])
-    expect(urls.some((url) => url.startsWith('/api/releases?'))).toBe(false)
-    expect(urls.some((url) => url.startsWith('/api/tracks?'))).toBe(false)
-    expect(urls.some((url) => url.startsWith('/api/owned-items?'))).toBe(false)
+      searchUrls(fetchMock).some(
+        (url) => url.searchParams.get('entityType') === 'release',
+      ),
+    ).toBe(false)
   })
 
-  it('requests the next release page from the server instead of preloading all releases', async () => {
-    window.history.pushState({}, '', '/releases')
+  it('hydrates the full catalog when navigating from catalog search into entity workspaces', async () => {
     h.clearCatalogForTests()
     const fetchMock = h.vi.fn<Window['fetch']>(async (input) => {
       const url = typeof input === 'string' ? input : (input as Request).url
       await Promise.resolve()
 
       if (url.startsWith('/api/search?')) {
-        const params = new URL(url, window.location.origin).searchParams
-
-        return params.get('offset') === '100'
-          ? releaseSearchResponse({
-              id: 'release-101',
-              title: 'Seed Release 00101',
-              offset: 100,
-            })
-          : releaseSearchResponse({
-              id: 'release-1',
-              title: 'Seed Release 00001',
-            })
+        return h.emptySearchResponse()
       }
-      if (url === '/api/catalog-graph/release/release-101') {
-        return graphResponseForRelease('release-101', 'Seed Release 00101')
+
+      if (url.startsWith('/api/settings/dictionaries?')) {
+        return h.defaultDictionaryListResponse()
       }
-      if (url === '/api/catalog-graph/release/release-1') {
-        return graphResponseForRelease('release-1', 'Seed Release 00001')
+
+      if (url.startsWith('/api/rating-criteria?')) {
+        return h.defaultRatingCriteriaListResponse()
       }
 
-      return h.emptySearchResponse()
+      return h.emptyCatalogListResponse()
     })
     h.vi.stubGlobal('fetch', fetchMock)
     const user = h.userEvent.setup()
-
     h.render(<h.App />)
 
+    await h.screen.findByText('No matching catalog entries.')
+    await user.click(h.screen.getByRole('link', { name: 'Releases' }))
+
     expect(
-      await h.screen.findByRole('row', { name: /Seed Release 00001/i }),
+      await h.screen.findByRole('heading', { name: 'Release records' }),
     ).toBeInTheDocument()
-    await h.waitFor(() => {
-      expect(requestUrls(fetchMock)).toContain(
-        '/api/catalog-graph/release/release-1',
-      )
-    })
 
-    await user.click(h.screen.getByRole('button', { name: 'Next page' }))
+    await user.click(h.screen.getByRole('link', { name: 'Tracks' }))
 
     expect(
-      await h.screen.findByRole('row', { name: /Seed Release 00101/i }),
+      await h.screen.findByRole('heading', { name: 'Track records' }),
     ).toBeInTheDocument()
 
-    const urls = searchUrls(fetchMock)
-    expect(urls.at(-1)?.searchParams.get('entityType')).toBe('release')
-    expect(urls.at(-1)?.searchParams.get('limit')).toBe('100')
-    expect(urls.at(-1)?.searchParams.get('offset')).toBe('100')
+    const urls = requestUrls(fetchMock)
     expect(
-      requestUrls(fetchMock).some((url) => url.startsWith('/api/releases?')),
-    ).toBe(false)
+      searchUrls(fetchMock).map((url) => url.searchParams.get('entityType')),
+    ).toEqual([null])
+    expect(urls.some((url) => url.startsWith('/api/releases?'))).toBe(true)
+    expect(urls.some((url) => url.startsWith('/api/tracks?'))).toBe(true)
+    expect(urls.some((url) => url.startsWith('/api/owned-items?'))).toBe(true)
   })
 
   it('shows mutation errors in editable workspaces', async () => {
     window.history.pushState({}, '', '/artists')
     h.clearCatalogForTests()
-    const fetchMock = h.mockFetch(
-      h.emptyCatalogListResponse(),
-      h.jsonResponse(
-        { code: 'catalog.server_error', message: 'Save failed' },
-        500,
-      ),
-    )
+    const fetchMock = h.vi.fn<Window['fetch']>(async (input, init) => {
+      const url = typeof input === 'string' ? input : (input as Request).url
+      await Promise.resolve()
+
+      if (url === '/api/artists' && init?.method === 'POST') {
+        return h.jsonResponse(
+          { code: 'catalog.server_error', message: 'Save failed' },
+          500,
+        )
+      }
+
+      if (url.startsWith('/api/settings/dictionaries?')) {
+        return h.defaultDictionaryListResponse()
+      }
+
+      if (url.startsWith('/api/rating-criteria?')) {
+        return h.defaultRatingCriteriaListResponse()
+      }
+
+      return h.emptyCatalogListResponse()
+    })
+    h.vi.stubGlobal('fetch', fetchMock)
     const user = h.userEvent.setup()
     h.render(<h.App />)
 
@@ -193,62 +228,11 @@ function searchUrls(fetchMock: ReturnType<typeof h.mockFetch>) {
     .map((url) => new URL(url, window.location.origin))
 }
 
-function releaseSearchResponse({
-  id,
-  title,
-  offset = 0,
-}: {
-  id: string
-  title: string
-  offset?: number
-}) {
+function listResponse(items: unknown[]) {
   return h.jsonResponse({
-    items: [
-      {
-        id,
-        type: 'release',
-        title,
-        subtitle: 'Various Artists',
-        summary: 'Album',
-        matchedFields: ['title'],
-        snippets: [title],
-        facets: {
-          roles: [],
-          media: ['digital'],
-          statuses: ['owned'],
-          tags: [],
-          labelId: null,
-          collectorSignals: [],
-        },
-        rank: 1,
-      },
-    ],
+    items,
     limit: 100,
-    offset,
-    total: 150,
-  })
-}
-
-function graphResponseForRelease(id: string, title: string) {
-  return h.jsonResponse({
-    entity: {
-      id,
-      type: 'release',
-      title,
-      subtitle: 'Various Artists',
-      summary: 'Album',
-    },
-    sections: {
-      artists: [],
-      releases: [],
-      tracks: [],
-      ownedCopies: [],
-      labels: [],
-      playlists: [],
-      credits: [],
-      relations: [],
-      media: [],
-    },
-    collectorSignals: [],
+    offset: 0,
+    total: items.length,
   })
 }
diff --git a/src/app/AuthenticatedApp.tsx b/src/app/AuthenticatedApp.tsx
index 3884b2a..6e5c8b2 100644
--- a/src/app/AuthenticatedApp.tsx
+++ b/src/app/AuthenticatedApp.tsx
@@ -591,7 +591,15 @@ export function AuthenticatedApp({
   )
 }
 
-const fullCatalogRoutes = new Set<AppRoutePath>()
+const fullCatalogRoutes = new Set<AppRoutePath>([
+  '/artists',
+  '/labels',
+  '/owned-items',
+  '/playlists',
+  '/relations',
+  '/releases',
+  '/tracks',
+])
 
 function routeRequiresFullCatalog(path: AppRoutePath) {
   return fullCatalogRoutes.has(path)
diff --git a/src/app/renderWorkspace.tsx b/src/app/renderWorkspace.tsx
index 3957237..8ed2ff7 100644
--- a/src/app/renderWorkspace.tsx
+++ b/src/app/renderWorkspace.tsx
@@ -2,10 +2,8 @@ import { resolveRoute, type AppRoutePath } from './routes'
 import type { ReactNode } from 'react'
 import type { ArtistRecord } from '../features/artists/artistsData'
 import { ArtistsWorkspace } from '../features/artists/ArtistsWorkspace'
-import { ServerArtistsWorkspace } from '../features/artists/ServerArtistsWorkspace'
 import { CatalogAddEntryFlow } from '../features/catalog/CatalogAddEntryFlow'
 import { CatalogWorkspace } from '../features/catalog/CatalogWorkspace'
-import { ServerEntityWorkspace } from '../features/catalog/ServerEntityWorkspace'
 import type {
   CatalogState,
   DictionaryEntry,
@@ -15,7 +13,6 @@ import type {
   RatingCriterionRequest,
   RatingCriterionUpdateRequest,
   RatingTargetType,
-  SearchEntityType,
 } from '../features/catalog/catalogApi'
 import { ExportsWorkspace } from '../features/exports/ExportsWorkspace'
 import { ImportsWorkspace } from '../features/imports/ImportsWorkspace'
@@ -23,7 +20,6 @@ import type { LabelRecord } from '../features/labels/labelsData'
 import { LabelsWorkspace } from '../features/labels/LabelsWorkspace'
 import type { OwnedItemRecord } from '../features/ownedItems/ownedItemsData'
 import { OwnedItemsWorkspace } from '../features/ownedItems/OwnedItemsWorkspace'
-import { ServerOwnedItemsWorkspace } from '../features/ownedItems/ServerOwnedItemsWorkspace'
 import type { PlaylistRecord } from '../features/playlists/playlistsData'
 import { PlaylistsWorkspace } from '../features/playlists/PlaylistsWorkspace'
 import type { ReleaseRecord } from '../features/releases/releasesData'
@@ -46,62 +42,6 @@ export const manualEntryRoutes = new Set<AppRoutePath>([
   '/playlists',
 ])
 
-type ServerEntityWorkspaceConfig = {
-  ariaLabel: string
-  entityType?: SearchEntityType
-  placeholder: string
-  queryParam: string
-  savedView?: string
-  searchLabel: string
-}
-
-const serverEntityWorkspaceConfigs: Partial<
-  Record<AppRoutePath, ServerEntityWorkspaceConfig>
-> = {
-  '/releases': {
-    ariaLabel: 'Releases workspace',
-    entityType: 'release',
-    placeholder: 'Release, artist, label, year, medium, tag or status',
-    queryParam: 'release',
-    searchLabel: 'Search releases',
-  },
-  '/tracks': {
-    ariaLabel: 'Tracks workspace',
-    entityType: 'track',
-    placeholder: 'Track, artist, release, role, medium, tag or status',
-    queryParam: 'track',
-    searchLabel: 'Search tracks',
-  },
-  '/labels': {
-    ariaLabel: 'Labels workspace',
-    entityType: 'label',
-    placeholder: 'Label, release, artist, catalog number, tag or status',
-    queryParam: 'label',
-    searchLabel: 'Search labels',
-  },
-  '/playlists': {
-    ariaLabel: 'Playlists workspace',
-    entityType: 'playlist',
-    placeholder: 'Playlist, rule, tag, media, ownership status or note',
-    queryParam: 'playlist',
-    searchLabel: 'Search playlists',
-  },
-  '/owned-items': {
-    ariaLabel: 'Owned items workspace',
-    entityType: 'ownedItem',
-    placeholder: 'Owned copy, release, track, medium, storage, tag or status',
-    queryParam: 'ownedItem',
-    searchLabel: 'Search owned items',
-  },
-  '/relations': {
-    ariaLabel: 'Relations workspace',
-    placeholder: 'Artist, track, role, relation, remix or version',
-    queryParam: 'relation',
-    savedView: 'credits',
-    searchLabel: 'Search relations',
-  },
-}
-
 export function renderWorkspace(
   path: AppRoutePath,
   isManualEntryOpen: boolean,
@@ -183,19 +123,6 @@ export function renderWorkspace(
 ) {
   const shouldUseServerWorkspace =
     catalogState.serverBackedCatalog && !catalogState.hasLoadedFullCatalog
-  const serverEntityConfig = serverEntityWorkspaceConfigs[path]
-  const serverEntityWorkspace = serverEntityConfig ? (
-    <ServerEntityWorkspace
-      key={path}
-      {...serverEntityConfig}
-      locationSearch={catalogState.locationSearch}
-      dictionaries={catalogState.dictionaries}
-      onRemoveReleaseCover={catalogState.onRemoveReleaseCover}
-      onUploadReleaseCover={catalogState.onUploadReleaseCover}
-      routePath={path}
-      searchRefreshKey={catalogState.searchRefreshKey}
-    />
-  ) : null
 
   switch (path) {
     case '/catalog':
@@ -239,16 +166,7 @@ export function renderWorkspace(
         />
       )
     case '/artists':
-      return catalogState.serverBackedCatalog &&
-        !catalogState.hasLoadedFullCatalog ? (
-        <ServerArtistsWorkspace
-          isManualEntryOpen={isManualEntryOpen}
-          locationSearch={catalogState.locationSearch}
-          onAddArtist={catalogState.onAddArtist}
-          onManualEntryClose={onManualEntryClose}
-          searchRefreshKey={catalogState.searchRefreshKey}
-        />
-      ) : (
+      return (
         <ArtistsWorkspace
           artists={catalogState.artists}
           isManualEntryOpen={isManualEntryOpen}
@@ -268,9 +186,7 @@ export function renderWorkspace(
         />
       )
     case '/releases':
-      return shouldUseServerWorkspace && serverEntityWorkspace ? (
-        serverEntityWorkspace
-      ) : (
+      return (
         <ReleasesWorkspace
           artists={catalogState.artists}
           isManualEntryOpen={isManualEntryOpen}
@@ -294,9 +210,7 @@ export function renderWorkspace(
         />
       )
     case '/tracks':
-      return shouldUseServerWorkspace && serverEntityWorkspace ? (
-        serverEntityWorkspace
-      ) : (
+      return (
         <TracksWorkspace
           artists={catalogState.artists}
           isManualEntryOpen={isManualEntryOpen}
@@ -317,9 +231,7 @@ export function renderWorkspace(
         />
       )
     case '/playlists':
-      return shouldUseServerWorkspace && serverEntityWorkspace ? (
-        serverEntityWorkspace
-      ) : (
+      return (
         <PlaylistsWorkspace
           isManualEntryOpen={isManualEntryOpen}
           locationSearch={catalogState.locationSearch}
@@ -337,9 +249,7 @@ export function renderWorkspace(
         />
       )
     case '/labels':
-      return shouldUseServerWorkspace && serverEntityWorkspace ? (
-        serverEntityWorkspace
-      ) : (
+      return (
         <LabelsWorkspace
           isManualEntryOpen={isManualEntryOpen}
           labels={catalogState.labels}
@@ -353,13 +263,7 @@ export function renderWorkspace(
         />
       )
     case '/owned-items':
-      return shouldUseServerWorkspace ? (
-        <ServerOwnedItemsWorkspace
-          locationSearch={catalogState.locationSearch}
-          onSessionExpired={catalogState.onSessionExpired}
-          searchRefreshKey={catalogState.searchRefreshKey}
-        />
-      ) : (
+      return (
         <OwnedItemsWorkspace
           isManualEntryOpen={isManualEntryOpen}
           items={catalogState.ownedItems}
@@ -376,9 +280,7 @@ export function renderWorkspace(
         />
       )
     case '/relations':
-      return shouldUseServerWorkspace && serverEntityWorkspace ? (
-        serverEntityWorkspace
-      ) : (
+      return (
         <RelationsWorkspace
           artists={catalogState.artists}
           isManualEntryOpen={isManualEntryOpen}
diff --git a/src/features/artists/ArtistDetail.tsx b/src/features/artists/ArtistDetail.tsx
index 08ded40..1902db2 100644
--- a/src/features/artists/ArtistDetail.tsx
+++ b/src/features/artists/ArtistDetail.tsx
@@ -13,6 +13,7 @@ type ArtistDetailProps = {
   catalogData: CatalogLinkData
   onDelete?: () => void
   onEdit?: () => void
+  onUpdateViaDiscogs?: () => void
   ratingCriteria: RatingCriterion[]
   onDeleteRating?: (
     targetType: RatingTargetType,
@@ -32,6 +33,7 @@ export function ArtistDetail({
   catalogData,
   onDelete,
   onEdit,
+  onUpdateViaDiscogs,
   ratingCriteria,
   onDeleteRating,
   onRateTarget,
@@ -70,6 +72,15 @@ export function ArtistDetail({
             >
               Edit record
             </button>
+            {onUpdateViaDiscogs ? (
+              <button
+                className="button button-secondary"
+                type="button"
+                onClick={onUpdateViaDiscogs}
+              >
+                Update via Discogs
+              </button>
+            ) : null}
             {onDelete ? (
               <DeleteSessionRecordButton
                 confirmationMessage="Delete this artist and remove their credits and relations?"
diff --git a/src/features/artists/ArtistsWorkspace.tsx b/src/features/artists/ArtistsWorkspace.tsx
index b052bb1..33fe13c 100644
--- a/src/features/artists/ArtistsWorkspace.tsx
+++ b/src/features/artists/ArtistsWorkspace.tsx
@@ -6,6 +6,7 @@ import {
   textOrFallback,
 } from '../manualEntry/manualEntryUtils'
 import { FilterSelect } from '../catalog/FilterSelect'
+import type { ExternalMetadataArtistDetailDto } from '../catalog/catalogApi'
 import { uniqueValues } from '../catalog/catalogGraph'
 import type { RatingCriterion, RatingTargetType } from '../catalog/catalogApi'
 import { useCatalogSelection } from '../catalog/useCatalogSelection'
@@ -15,6 +16,10 @@ import type { ReleaseRecord } from '../releases/releasesData'
 import type { RelationRecord } from '../relations/relationsData'
 import type { TrackRecord } from '../tracks/tracksData'
 import { ArtistDetail, EmptyDetailPanel } from './ArtistDetail'
+import {
+  DiscogsArtistLookupPanel,
+  type DiscogsArtistApplyGroups,
+} from './DiscogsArtistLookupPanel'
 import type { ArtistRecord, ArtistType } from './artistsData'
 
 type ArtistsWorkspaceProps = {
@@ -64,6 +69,7 @@ export function ArtistsWorkspace({
   const [query, setQuery] = useState('')
   const [manualArtists, setManualArtists] = useState<ArtistRecord[]>([])
   const [editingArtistId, setEditingArtistId] = useState('')
+  const [discogsLookupArtistId, setDiscogsLookupArtistId] = useState('')
   const artists = useMemo(() => {
     return [...providedArtists, ...manualArtists]
   }, [manualArtists, providedArtists])
@@ -112,6 +118,7 @@ export function ArtistsWorkspace({
     setQuery('')
     selectArtist(artist.id)
     onManualEntryClose()
+    setDiscogsLookupArtistId('')
   }
 
   function handleUpdateArtist(artist: ArtistRecord) {
@@ -128,6 +135,7 @@ export function ArtistsWorkspace({
     setQuery('')
     selectArtist(artist.id)
     setEditingArtistId('')
+    setDiscogsLookupArtistId('')
   }
 
   function handleDeleteArtist(artistId: string) {
@@ -141,10 +149,12 @@ export function ArtistsWorkspace({
 
     setQuery('')
     setEditingArtistId('')
+    setDiscogsLookupArtistId('')
   }
 
   function handleCancelEdit() {
     setEditingArtistId('')
+    setDiscogsLookupArtistId('')
   }
 
   const editingArtist = artists.find((artist) => artist.id === editingArtistId)
@@ -205,6 +215,9 @@ export function ArtistsWorkspace({
           <ArtistEntryForm
             artists={artists}
             initialArtist={editingArtist}
+            initialShowDiscogsLookup={
+              editingArtist.id === discogsLookupArtistId
+            }
             key={editingArtist.id}
             onCancel={handleCancelEdit}
             onSubmit={handleUpdateArtist}
@@ -221,7 +234,14 @@ export function ArtistsWorkspace({
         <ArtistDetail
           artist={selectedArtist}
           catalogData={catalogData}
-          onEdit={() => setEditingArtistId(selectedArtist.id)}
+          onEdit={() => {
+            setEditingArtistId(selectedArtist.id)
+            setDiscogsLookupArtistId('')
+          }}
+          onUpdateViaDiscogs={() => {
+            setEditingArtistId(selectedArtist.id)
+            setDiscogsLookupArtistId(selectedArtist.id)
+          }}
           onDelete={() => handleDeleteArtist(selectedArtist.id)}
           ratingCriteria={ratingCriteria}
           onDeleteRating={onDeleteRating}
@@ -237,6 +257,7 @@ export function ArtistsWorkspace({
 export type ArtistEntryFormProps = {
   artists: ArtistRecord[]
   initialArtist?: ArtistRecord
+  initialShowDiscogsLookup?: boolean
   onCancel: () => void
   onSubmit: (artist: ArtistRecord) => void
 }
@@ -244,6 +265,7 @@ export type ArtistEntryFormProps = {
 export function ArtistEntryForm({
   artists,
   initialArtist,
+  initialShowDiscogsLookup,
   onCancel,
   onSubmit,
 }: ArtistEntryFormProps) {
@@ -253,6 +275,13 @@ export function ArtistEntryForm({
     initialArtist?.relationHint ?? '',
   )
   const [notes, setNotes] = useState(initialArtist?.summary ?? '')
+  const [externalSources, setExternalSources] = useState(
+    initialArtist?.externalSources,
+  )
+  const [discogsLookupOpenPreference, setDiscogsLookupOpenPreference] =
+    useState<boolean | null>(null)
+  const isDiscogsLookupOpen =
+    discogsLookupOpenPreference ?? Boolean(initialShowDiscogsLookup)
   const isValid = name.trim().length > 0
   const duplicateArtist = artists.find(
     (artist) =>
@@ -294,9 +323,28 @@ export function ArtistEntryForm({
       credits: isEditing ? (initialArtist?.credits ?? []) : [],
       tags: ['manual entry'],
       summary,
+      externalSources,
     })
   }
 
+  function handleApplyDiscogsDraft(
+    detail: ExternalMetadataArtistDetailDto,
+    groups: DiscogsArtistApplyGroups,
+  ) {
+    if (groups.core) {
+      setName(detail.draft.name)
+    }
+
+    if (groups.externalSource) {
+      setExternalSources(
+        detail.draft.externalSources.map((source) => ({
+          ...source,
+          appliedAt: new Date().toISOString(),
+        })),
+      )
+    }
+  }
+
   return (
     <ManualEntryPanel
       title={formTitle}
@@ -328,6 +376,18 @@ export function ArtistEntryForm({
           <option>Collective</option>
         </select>
       </label>
+      <DiscogsArtistLookupPanel
+        current={{
+          externalSourceCount: externalSources?.length ?? 0,
+          name,
+          type,
+        }}
+        isOpen={isDiscogsLookupOpen}
+        mode={initialArtist ? 'update' : 'create'}
+        searchSeed={name}
+        onApplyDraft={handleApplyDiscogsDraft}
+        onOpenChange={setDiscogsLookupOpenPreference}
+      />
       {duplicateArtist ? (
         <p className="manual-entry-warning manual-entry-wide" role="status">
           Likely duplicate artist: {duplicateArtist.name}. Submit is still
diff --git a/src/features/artists/DiscogsArtistLookupPanel.tsx b/src/features/artists/DiscogsArtistLookupPanel.tsx
new file mode 100644
index 0000000..8571940
--- /dev/null
+++ b/src/features/artists/DiscogsArtistLookupPanel.tsx
@@ -0,0 +1,342 @@
+import { Search } from 'lucide-react'
+import { useEffect, useRef, useState } from 'react'
+import {
+  CatalogApiError,
+  getDiscogsArtist,
+  searchDiscogsArtists,
+  type ExternalMetadataArtistCandidateDto,
+  type ExternalMetadataArtistDetailDto,
+} from '../catalog/catalogApi'
+
+export type DiscogsArtistApplyGroups = {
+  core: boolean
+  externalSource: boolean
+}
+
+export type DiscogsCurrentArtist = {
+  externalSourceCount: number
+  name: string
+  type: string
+}
+
+type DiscogsArtistLookupPanelProps = {
+  current: DiscogsCurrentArtist
+  isOpen: boolean
+  mode: 'create' | 'update'
+  searchSeed: string
+  onApplyDraft: (
+    detail: ExternalMetadataArtistDetailDto,
+    groups: DiscogsArtistApplyGroups,
+  ) => void
+  onOpenChange: (isOpen: boolean) => void
+}
+
+const emptyGroups: DiscogsArtistApplyGroups = {
+  core: false,
+  externalSource: false,
+}
+
+export function DiscogsArtistLookupPanel({
+  current,
+  isOpen,
+  mode,
+  searchSeed,
+  onApplyDraft,
+  onOpenChange,
+}: DiscogsArtistLookupPanelProps) {
+  const [query, setQuery] = useState(searchSeed)
+  const [status, setStatus] = useState('')
+  const [candidates, setCandidates] = useState<
+    ExternalMetadataArtistCandidateDto[]
+  >([])
+  const [selectedDetail, setSelectedDetail] =
+    useState<ExternalMetadataArtistDetailDto | null>(null)
+  const [applyGroups, setApplyGroups] = useState<DiscogsArtistApplyGroups>(() =>
+    defaultGroups(mode),
+  )
+  const wasOpen = useRef(false)
+
+  useEffect(() => {
+    if (isOpen && !wasOpen.current) {
+      setQuery(searchSeed)
+    }
+
+    wasOpen.current = isOpen
+  }, [isOpen, searchSeed])
+
+  async function handleSearch() {
+    setStatus('Searching Discogs artist candidates.')
+    setSelectedDetail(null)
+
+    try {
+      const result = await searchDiscogsArtists({ query, limit: 25 })
+      setCandidates(result.items)
+      setStatus(
+        result.items.length > 0
+          ? `${result.total} candidate${result.total === 1 ? '' : 's'} found.`
+          : 'No Discogs artist candidates found.',
+      )
+    } catch (error) {
+      setCandidates([])
+      setStatus(externalMetadataErrorMessage(error))
+    }
+  }
+
+  async function reviewCandidate(
+    candidate: ExternalMetadataArtistCandidateDto,
+  ) {
+    setStatus(`Loading Discogs detail for ${candidate.name}.`)
+
+    try {
+      const detail = await getDiscogsArtist(candidate.source.externalId)
+      setSelectedDetail(detail)
+      setApplyGroups(defaultGroups(mode))
+      setStatus(`Review loaded for ${detail.name}.`)
+    } catch (error) {
+      setSelectedDetail(null)
+      setStatus(externalMetadataErrorMessage(error))
+    }
+  }
+
+  function updateApplyGroup(
+    group: keyof DiscogsArtistApplyGroups,
+    checked: boolean,
+  ) {
+    setApplyGroups((groups) => ({ ...groups, [group]: checked }))
+  }
+
+  const hasSelectedGroup = Object.values(applyGroups).some(Boolean)
+
+  return (
+    <section
+      className="manual-entry-wide release-form-section discogs-release-lookup"
+      aria-label="Discogs artist lookup"
+      role="region"
+    >
+      <div className="release-form-section-header">
+        <div>
+          <h3>Discogs</h3>
+          <p>Search artist candidates and review fields before applying.</p>
+        </div>
+        <button
+          className="button button-secondary button-compact"
+          type="button"
+          onClick={() => onOpenChange(!isOpen)}
+        >
+          <Search size={14} aria-hidden="true" />
+          {isOpen ? 'Hide Discogs' : 'Search Discogs'}
+        </button>
+      </div>
+
+      {isOpen ? (
+        <>
+          <div className="discogs-search-form">
+            <label>
+              <span>Discogs query</span>
+              <input
+                aria-label="Discogs artist query"
+                value={query}
+                onChange={(event) => setQuery(event.target.value)}
+              />
+            </label>
+            <button
+              className="button button-secondary button-compact"
+              type="button"
+              onClick={() => {
+                void handleSearch()
+              }}
+            >
+              <Search size={14} aria-hidden="true" />
+              <span>Search Discogs artists</span>
+            </button>
+          </div>
+
+          {status ? (
+            <p className="discogs-lookup-status" role="status">
+              {status}
+            </p>
+          ) : null}
+
+          {candidates.length > 0 ? (
+            <div className="discogs-candidate-list">
+              {candidates.map((candidate) => (
+                <article
+                  className="discogs-candidate"
+                  key={candidate.source.externalId}
+                >
+                  <div>
+                    <strong>{candidate.name}</strong>
+                    {candidate.profile ? <p>{candidate.profile}</p> : null}
+                    {candidate.nameVariations.length > 0 ? (
+                      <p>Variations: {candidate.nameVariations.join(', ')}</p>
+                    ) : null}
+                    <p>{candidate.source.attribution}</p>
+                  </div>
+                  <div className="discogs-candidate-actions">
+                    <a
+                      className="detail-link"
+                      href={candidate.source.sourceUrl}
+                      target="_blank"
+                      rel="noreferrer"
+                    >
+                      Open candidate Discogs artist source
+                    </a>
+                    <button
+                      className="button button-secondary button-compact"
+                      type="button"
+                      onClick={() => {
+                        void reviewCandidate(candidate)
+                      }}
+                    >
+                      <span>Review {candidate.name}</span>
+                    </button>
+                  </div>
+                </article>
+              ))}
+            </div>
+          ) : null}
+
+          {selectedDetail ? (
+            <div className="discogs-review-panel">
+              <div className="release-form-section-header">
+                <div>
+                  <h3>Review Discogs artist</h3>
+                  <p>
+                    {selectedDetail.source.attribution}{' '}
+                    <a
+                      className="detail-link"
+                      href={selectedDetail.source.sourceUrl}
+                      target="_blank"
+                      rel="noreferrer"
+                    >
+                      Open Discogs artist source
+                    </a>
+                  </p>
+                </div>
+              </div>
+
+              <div className="discogs-review-grid">
+                <ReviewColumn
+                  title="Current local artist"
+                  rows={currentRows(current)}
+                />
+                <ReviewColumn
+                  title="Discogs draft"
+                  rows={discogsRows(selectedDetail)}
+                />
+              </div>
+
+              <fieldset className="discogs-apply-groups">
+                <legend>Apply groups</legend>
+                <ApplyGroup
+                  checked={applyGroups.core}
+                  label="Apply Core"
+                  onChange={(checked) => updateApplyGroup('core', checked)}
+                />
+                <ApplyGroup
+                  checked={applyGroups.externalSource}
+                  label="Apply External Source"
+                  onChange={(checked) =>
+                    updateApplyGroup('externalSource', checked)
+                  }
+                />
+              </fieldset>
+
+              <button
+                className="button button-primary button-compact"
+                type="button"
+                disabled={!hasSelectedGroup}
+                onClick={() => onApplyDraft(selectedDetail, applyGroups)}
+              >
+                Apply selected Discogs fields
+              </button>
+            </div>
+          ) : null}
+        </>
+      ) : (
+        <p className="release-section-note">
+          Discogs lookup is optional and never saves data until the artist form
+          is submitted.
+        </p>
+      )}
+    </section>
+  )
+}
+
+function defaultGroups(mode: 'create' | 'update'): DiscogsArtistApplyGroups {
+  return mode === 'create'
+    ? {
+        core: true,
+        externalSource: true,
+      }
+    : emptyGroups
+}
+
+function externalMetadataErrorMessage(error: unknown) {
+  if (error instanceof CatalogApiError) {
+    const retry =
+      error.retryAfter && error.status === 429
+        ? ` Retry after ${error.retryAfter} seconds.`
+        : ''
+
+    return `${error.message}${retry}`
+  }
+
+  return 'External metadata provider is unavailable.'
+}
+
+function currentRows(current: DiscogsCurrentArtist) {
+  return [
+    ['Name', current.name || 'Not recorded'],
+    ['Type', current.type || 'Not recorded'],
+    ['Sources', `${current.externalSourceCount} sources`],
+  ]
+}
+
+function discogsRows(detail: ExternalMetadataArtistDetailDto) {
+  return [
+    ['Name', detail.draft.name || 'Not recorded'],
+    ['Aliases', detail.aliases.join(', ') || 'Not recorded'],
+    ['Members', detail.members.join(', ') || 'Not recorded'],
+    ['Variations', detail.nameVariations.join(', ') || 'Not recorded'],
+    ['Profile', detail.profile ?? 'Not recorded'],
+    ['Sources', `${detail.draft.externalSources.length} sources`],
+  ]
+}
+
+function ReviewColumn({ title, rows }: { title: string; rows: string[][] }) {
+  return (
+    <div className="discogs-review-column">
+      <h4>{title}</h4>
+      <dl>
+        {rows.map(([label, value]) => (
+          <div key={label}>
+            <dt>{label}</dt>
+            <dd>{value}</dd>
+          </div>
+        ))}
+      </dl>
+    </div>
+  )
+}
+
+function ApplyGroup({
+  checked,
+  label,
+  onChange,
+}: {
+  checked: boolean
+  label: string
+  onChange: (checked: boolean) => void
+}) {
+  return (
+    <label className="compact-checkbox">
+      <input
+        type="checkbox"
+        checked={checked}
+        onChange={(event) => onChange(event.target.checked)}
+      />
+      <span>{label}</span>
+    </label>
+  )
+}
diff --git a/src/features/artists/artistsData.ts b/src/features/artists/artistsData.ts
index ef0d5ad..94e9083 100644
--- a/src/features/artists/artistsData.ts
+++ b/src/features/artists/artistsData.ts
@@ -1,4 +1,7 @@
-import type { EntityRating } from '../catalog/catalogApi'
+import type {
+  EntityRating,
+  ExternalSourceReference,
+} from '../catalog/catalogApi'
 
 export type ArtistType = 'Person' | 'Band' | 'Project' | 'Alias' | 'Collective'
 
@@ -27,6 +30,7 @@ export type ArtistRecord = {
   tags: string[]
   summary: string
   ratings?: EntityRating[]
+  externalSources?: ExternalSourceReference[]
 }
 
 export const artistRecords: ArtistRecord[] = [
diff --git a/src/features/catalog/api/artistLabelClient.ts b/src/features/catalog/api/artistLabelClient.ts
index 3fd958a..8aaf501 100644
--- a/src/features/catalog/api/artistLabelClient.ts
+++ b/src/features/catalog/api/artistLabelClient.ts
@@ -22,6 +22,9 @@ export async function createArtist(artist: ArtistRecord) {
   await sendJson('/api/artists', 'POST', {
     name: artist.name,
     type: toArtistTypeCode(artist.type),
+    ...(artist.externalSources === undefined
+      ? {}
+      : { externalSources: artist.externalSources }),
   })
 }
 
@@ -76,6 +79,9 @@ export async function updateArtist(artist: ArtistRecord) {
 
   await sendJson(`/api/artists/${artist.id}`, 'PUT', {
     name: artist.name,
+    ...(artist.externalSources === undefined
+      ? {}
+      : { externalSources: artist.externalSources }),
   })
 }
 
diff --git a/src/features/catalog/api/catalogEntityMappers.ts b/src/features/catalog/api/catalogEntityMappers.ts
index be00879..ea0ad3a 100644
--- a/src/features/catalog/api/catalogEntityMappers.ts
+++ b/src/features/catalog/api/catalogEntityMappers.ts
@@ -122,6 +122,7 @@ export function toArtistRecord(
     tags: [],
     summary: '',
     ratings: targetRatings(ratingsByTarget, 'artist', artist.id),
+    externalSources: artist.externalSources ?? [],
   }
 }
 
@@ -147,6 +148,10 @@ export function toReleaseRecord(
             artistsById.get(credit.contributorArtistId)?.name ??
             credit.contributorName,
           role: creditRoleLabel(credit.role, dictionaries),
+          roles: (credit.roles && credit.roles.length > 0
+            ? credit.roles
+            : [credit.role]
+          ).map((role) => creditRoleLabel(role, dictionaries)),
         }))
   const mainCredits = releaseCredits.filter((credit) =>
     isMainArtistRole(credit.role, dictionaries),
@@ -416,6 +421,7 @@ export function toTrackRecord(
       checksum: 'Not recorded',
     },
     ratings: targetRatings(ratingsByTarget, 'track', track.id),
+    externalSources: track.externalSources ?? [],
   }
 }
 
diff --git a/src/features/catalog/api/catalogRequestMappers.ts b/src/features/catalog/api/catalogRequestMappers.ts
index 96c59d1..b81f18a 100644
--- a/src/features/catalog/api/catalogRequestMappers.ts
+++ b/src/features/catalog/api/catalogRequestMappers.ts
@@ -22,18 +22,26 @@ export function toReleaseTypeCode(type: ReleaseType) {
 }
 
 export function toReleaseArtistCreditRequest(credit: ReleaseArtistCredit) {
+  const roles =
+    credit.roles && credit.roles.length > 0 ? credit.roles : [credit.role]
+
   return {
     artistId: credit.artistId,
     name: credit.artistId ? null : credit.artist,
-    role: toCreditRoleCode(credit.role),
+    role: toCreditRoleCode(roles[0]),
+    roles: roles.map((role) => toCreditRoleCode(role)),
   }
 }
 
 export function toTrackCreditRequest(credit: TrackCredit) {
+  const roles =
+    credit.roles && credit.roles.length > 0 ? credit.roles : [credit.role]
+
   return {
     artistId: credit.artistId,
     name: credit.artistId ? null : credit.artist,
-    role: toCreditRoleCode(credit.role),
+    role: toCreditRoleCode(roles[0]),
+    roles: roles.map((role) => toCreditRoleCode(role)),
   }
 }
 
@@ -73,6 +81,7 @@ export function toReleaseTracklistRequest(track: TrackRecord, index: number) {
         artistId: credit.artistId,
         artist: credit.artist,
         role: credit.role,
+        roles: credit.roles,
       }),
     ),
     versionNote,
diff --git a/src/features/catalog/api/catalogTypes.ts b/src/features/catalog/api/catalogTypes.ts
index f54119a..db1c7a5 100644
--- a/src/features/catalog/api/catalogTypes.ts
+++ b/src/features/catalog/api/catalogTypes.ts
@@ -316,6 +316,7 @@ export type ArtistDto = {
   id: string
   type: string
   name: string
+  externalSources?: ExternalSourceReference[] | null
 }
 
 export type LabelDto = {
@@ -353,6 +354,7 @@ export type ReleaseArtistCreditDto = {
   artistId: string
   artistName: string
   role: string
+  roles?: string[]
 }
 
 export type ReleaseLabelDto = {
@@ -377,6 +379,7 @@ export type TrackDto = {
   durationSeconds?: number | null
   genres: string[]
   tags: string[]
+  externalSources?: ExternalSourceReference[] | null
   credits?: TrackCreditDto[]
   releaseAppearances?: TrackReleaseAppearanceDto[]
 }
@@ -385,6 +388,7 @@ export type TrackCreditDto = {
   artistId: string
   artistName: string
   role: string
+  roles?: string[]
 }
 
 export type TrackReleaseAppearanceDto = {
@@ -449,6 +453,7 @@ export type CreditDto = {
   targetType: CatalogTargetType
   targetId: string
   role: string
+  roles?: string[]
   targetTitle?: string | null
 }
 
diff --git a/src/features/catalog/api/catalogValueMappers.ts b/src/features/catalog/api/catalogValueMappers.ts
index bef8e08..a1532ed 100644
--- a/src/features/catalog/api/catalogValueMappers.ts
+++ b/src/features/catalog/api/catalogValueMappers.ts
@@ -106,9 +106,12 @@ export function toTrackCredit(
   credit: CreditDto,
   dictionaries = activeDictionaries,
 ): TrackCredit {
+  const roles = creditRolesFromDto(credit, dictionaries)
+
   return {
     artistId: credit.contributorArtistId,
-    role: creditRoleLabel(credit.role, dictionaries),
+    role: roles[0] ?? creditRoleLabel(credit.role, dictionaries),
+    roles,
     artist: credit.contributorName,
     scope: 'Track credit.',
   }
@@ -118,9 +121,12 @@ export function toTrackCreditFromTrackCreditDto(
   credit: TrackCreditDto,
   dictionaries = activeDictionaries,
 ): TrackCredit {
+  const roles = creditRolesFromDto(credit, dictionaries)
+
   return {
     artistId: credit.artistId,
-    role: creditRoleLabel(credit.role, dictionaries),
+    role: roles[0] ?? creditRoleLabel(credit.role, dictionaries),
+    roles,
     artist: credit.artistName,
     scope: 'Track credit.',
   }
@@ -130,9 +136,12 @@ export function toTrackCreditFromReleaseCredit(
   credit: ReleaseArtistCreditDto,
   dictionaries = activeDictionaries,
 ): TrackCredit {
+  const roles = creditRolesFromDto(credit, dictionaries)
+
   return {
     artistId: credit.artistId,
-    role: creditRoleLabel(credit.role, dictionaries),
+    role: roles[0] ?? creditRoleLabel(credit.role, dictionaries),
+    roles,
     artist: credit.artistName,
     scope: 'Tracklist credit.',
   }
@@ -142,13 +151,27 @@ export function toReleaseArtistCredit(
   credit: ReleaseArtistCreditDto,
   dictionaries = activeDictionaries,
 ): ReleaseArtistCredit {
+  const roles = creditRolesFromDto(credit, dictionaries)
+
   return {
     artistId: credit.artistId,
     artist: credit.artistName,
-    role: creditRoleLabel(credit.role, dictionaries),
+    role: roles[0] ?? creditRoleLabel(credit.role, dictionaries),
+    roles,
   }
 }
 
+export function creditRolesFromDto(
+  credit: { role: string; roles?: string[] },
+  dictionaries = activeDictionaries,
+) {
+  const roleCodes =
+    credit.roles && credit.roles.length > 0 ? credit.roles : [credit.role]
+  return [
+    ...new Set(roleCodes.map((role) => creditRoleLabel(role, dictionaries))),
+  ]
+}
+
 export function toReleaseLabel(label: ReleaseLabelDto): ReleaseLabel {
   return {
     labelId: label.labelId ?? undefined,
@@ -164,8 +187,11 @@ export function releaseArtistDisplay(release: ReleaseDto) {
   }
 
   const credits = release.artistCredits ?? []
-  const mainCredits = credits.filter(
-    (credit) => credit.role === mainArtistRoleCode,
+  const mainCredits = credits.filter((credit) =>
+    (credit.roles && credit.roles.length > 0
+      ? credit.roles
+      : [credit.role]
+    ).includes(mainArtistRoleCode),
   )
   const visibleCredits = mainCredits.length > 0 ? mainCredits : credits
 
@@ -207,7 +233,14 @@ export function releaseArtistCreditsFromDisplay(
     return []
   }
 
-  return [{ artistId: release.artistId, artist, role: mainArtistRoleLabel() }]
+  return [
+    {
+      artistId: release.artistId,
+      artist,
+      role: mainArtistRoleLabel(),
+      roles: [mainArtistRoleLabel()],
+    },
+  ]
 }
 
 export function releaseLabelsFromDisplay(
diff --git a/src/features/catalog/api/externalMetadataClient.ts b/src/features/catalog/api/externalMetadataClient.ts
index d8dbd35..4382e47 100644
--- a/src/features/catalog/api/externalMetadataClient.ts
+++ b/src/features/catalog/api/externalMetadataClient.ts
@@ -26,12 +26,39 @@ export type DiscogsReleaseSearchParams = {
   limit?: number
 }
 
+export type DiscogsArtistSearchParams = {
+  query?: string
+  limit?: number
+}
+
+export type DiscogsTrackSearchParams = {
+  title?: string
+  artist?: string
+  releaseTitle?: string
+  year?: string
+  barcode?: string
+  catalogNumber?: string
+  limit?: number
+}
+
 export type DiscogsReleaseSearchResponse = {
   items: ExternalMetadataReleaseCandidateDto[]
   limit: number
   total: number
 }
 
+export type DiscogsArtistSearchResponse = {
+  items: ExternalMetadataArtistCandidateDto[]
+  limit: number
+  total: number
+}
+
+export type DiscogsTrackSearchResponse = {
+  items: ExternalMetadataTrackCandidateDto[]
+  limit: number
+  total: number
+}
+
 export type ExternalMetadataReleaseCandidateDto = {
   source: ExternalMetadataSourceDto
   title: string
@@ -51,6 +78,59 @@ export type ExternalMetadataReleaseDetailDto =
     draft: ExternalMetadataReleaseDraftDto
   }
 
+export type ExternalMetadataArtistCandidateDto = {
+  source: ExternalMetadataSourceDto
+  name: string
+  profile?: string | null
+  nameVariations: string[]
+}
+
+export type ExternalMetadataArtistDetailDto =
+  ExternalMetadataArtistCandidateDto & {
+    aliases: string[]
+    members: string[]
+    draft: ExternalMetadataArtistDraftDto
+  }
+
+export type ExternalMetadataArtistDraftDto = {
+  name: string
+  externalSources: ExternalSourceReference[]
+}
+
+export type ExternalMetadataTrackCandidateDto = {
+  source: ExternalMetadataSourceDto
+  title: string
+  position?: string | null
+  durationSeconds?: number | null
+  artists: string[]
+  release: ExternalMetadataTrackReleaseContextDto
+}
+
+export type ExternalMetadataTrackDetailDto =
+  ExternalMetadataTrackCandidateDto & {
+    credits: ExternalMetadataTrackCreditDto[]
+    draft: ExternalMetadataTrackDraftDto
+  }
+
+export type ExternalMetadataTrackReleaseContextDto = {
+  source: ExternalMetadataSourceDto
+  title: string
+  year?: number | null
+  artists: string[]
+}
+
+export type ExternalMetadataTrackCreditDto = {
+  name: string
+  role: string
+}
+
+export type ExternalMetadataTrackDraftDto = {
+  title: string
+  durationSeconds?: number | null
+  artistCredits: ExternalMetadataReleaseDraftArtistCreditDto[]
+  externalSources: ExternalSourceReference[]
+}
+
 export type ExternalMetadataReleaseTrackDto = {
   title: string
   position?: string | null
@@ -72,7 +152,10 @@ export type ExternalMetadataReleaseCreditDto = {
 
 export type ExternalMetadataReleaseDraftDto = {
   title: string
+  type?: string | null
+  genres: string[]
   year?: number | null
+  releaseDate?: string | null
   artistCredits: ExternalMetadataReleaseDraftArtistCreditDto[]
   labels: ExternalMetadataReleaseDraftLabelDto[]
   tracklist: ExternalMetadataReleaseDraftTrackDto[]
@@ -114,6 +197,31 @@ export async function searchDiscogsReleases(
   )
 }
 
+export async function searchDiscogsArtists(params: DiscogsArtistSearchParams) {
+  const query = new URLSearchParams()
+  appendTrimmed(query, 'query', params.query)
+  query.set('limit', String(params.limit ?? 25))
+
+  return getExternalMetadataJson<DiscogsArtistSearchResponse>(
+    `/api/external-metadata/discogs/artists?${query.toString()}`,
+  )
+}
+
+export async function searchDiscogsTracks(params: DiscogsTrackSearchParams) {
+  const query = new URLSearchParams()
+  appendTrimmed(query, 'title', params.title)
+  appendTrimmed(query, 'artist', params.artist)
+  appendTrimmed(query, 'releaseTitle', params.releaseTitle)
+  appendTrimmed(query, 'year', params.year)
+  appendTrimmed(query, 'barcode', params.barcode)
+  appendTrimmed(query, 'catalogNumber', params.catalogNumber)
+  query.set('limit', String(params.limit ?? 25))
+
+  return getExternalMetadataJson<DiscogsTrackSearchResponse>(
+    `/api/external-metadata/discogs/tracks?${query.toString()}`,
+  )
+}
+
 export async function getDiscogsRelease(externalId: string) {
   return getExternalMetadataJson<ExternalMetadataReleaseDetailDto>(
     `/api/external-metadata/discogs/releases/${encodeURIComponent(
@@ -122,6 +230,22 @@ export async function getDiscogsRelease(externalId: string) {
   )
 }
 
+export async function getDiscogsArtist(externalId: string) {
+  return getExternalMetadataJson<ExternalMetadataArtistDetailDto>(
+    `/api/external-metadata/discogs/artists/${encodeURIComponent(
+      externalId.trim(),
+    )}`,
+  )
+}
+
+export async function getDiscogsTrack(externalId: string) {
+  return getExternalMetadataJson<ExternalMetadataTrackDetailDto>(
+    `/api/external-metadata/discogs/tracks/${encodeURIComponent(
+      externalId.trim(),
+    )}`,
+  )
+}
+
 async function getExternalMetadataJson<T>(path: string): Promise<T> {
   const response = await fetch(path, {
     credentials: 'include',
diff --git a/src/features/catalog/api/trackClient.ts b/src/features/catalog/api/trackClient.ts
index 34d9d85..7fa2336 100644
--- a/src/features/catalog/api/trackClient.ts
+++ b/src/features/catalog/api/trackClient.ts
@@ -31,6 +31,9 @@ async function createTrackRecord(track: TrackRecord) {
     durationSeconds: parseDuration(track.duration),
     genres: track.tags.filter((tag) => genreSet.has(tag)),
     tags: track.tags.filter((tag) => !genreSet.has(tag)),
+    ...(track.externalSources === undefined
+      ? {}
+      : { externalSources: track.externalSources }),
     credits: track.credits.map(toTrackCreditRequest),
     releaseAppearances: track.releaseAppearances
       .filter((appearance) => appearance.releaseId)
@@ -75,6 +78,9 @@ export async function updateTrack(track: TrackRecord) {
     durationSeconds: parseDuration(track.duration),
     genres: track.tags.filter((tag) => genreSet.has(tag)),
     tags: track.tags.filter((tag) => !genreSet.has(tag)),
+    ...(track.externalSources === undefined
+      ? {}
+      : { externalSources: track.externalSources }),
     credits: track.credits.map(toTrackCreditRequest),
     releaseAppearances: track.releaseAppearances
       .filter((appearance) => appearance.releaseId)
diff --git a/src/features/catalog/catalogApi.mutations.test.ts b/src/features/catalog/catalogApi.mutations.test.ts
index e515ff1..4c45635 100644
--- a/src/features/catalog/catalogApi.mutations.test.ts
+++ b/src/features/catalog/catalogApi.mutations.test.ts
@@ -1,7 +1,9 @@
 import { describe, expect, it, vi } from 'vitest'
 import * as api from './catalogApi'
 import * as h from './catalogApiTestHarness'
+import type { ArtistRecord } from '../artists/artistsData'
 import type { ReleaseRecord } from '../releases/releasesData'
+import type { TrackRecord } from '../tracks/tracksData'
 
 h.setupCatalogApiAdapterTests()
 
@@ -59,6 +61,109 @@ describe('catalog API adapter mutations and covers', () => {
     })
   })
 
+  it('sends artist external sources on create and update', async () => {
+    const fetchMock = vi.fn<Window['fetch']>()
+    fetchMock
+      .mockResolvedValueOnce(h.jsonResponse({ id: 'artist-id' }, 201))
+      .mockResolvedValueOnce(h.jsonResponse({ id: 'artist-id' }))
+    vi.stubGlobal('fetch', fetchMock)
+    const artist: ArtistRecord = {
+      id: 'artist-id',
+      name: 'Discogs Artist',
+      type: 'Person',
+      aliases: [],
+      members: [],
+      relationHint: '',
+      creditHint: '',
+      relations: [],
+      credits: [],
+      tags: [],
+      summary: '',
+      externalSources: [
+        {
+          providerName: 'discogs',
+          resourceType: 'artist',
+          externalId: '5876',
+          sourceUrl: 'https://www.discogs.com/artist/5876',
+          appliedAt: '2026-05-31T19:00:00.000Z',
+        },
+      ],
+    }
+
+    await api.createArtist(artist)
+    await api.updateArtist(artist)
+
+    expect(
+      h.requestPayload<Record<string, unknown>>(fetchMock.mock.calls[0][1]),
+    ).toMatchObject({
+      externalSources: artist.externalSources,
+    })
+    expect(
+      h.requestPayload<Record<string, unknown>>(fetchMock.mock.calls[1][1]),
+    ).toMatchObject({
+      externalSources: artist.externalSources,
+    })
+  })
+
+  it('sends track external sources on create and update', async () => {
+    const fetchMock = vi.fn<Window['fetch']>()
+    fetchMock
+      .mockResolvedValueOnce(h.jsonResponse({ id: 'track-id' }, 201))
+      .mockResolvedValueOnce(h.jsonResponse({ id: 'track-id' }))
+    vi.stubGlobal('fetch', fetchMock)
+    const track: TrackRecord = {
+      id: 'track-id',
+      title: 'Discogs Track',
+      artist: 'Discogs Artist',
+      release: {
+        title: 'Discogs Release',
+        artist: 'Discogs Artist',
+        year: '2026',
+        label: 'Source Label',
+      },
+      trackNumber: '1',
+      duration: '04:29',
+      versionHint: '',
+      relationHint: '',
+      tags: [],
+      credits: [],
+      releaseAppearances: [],
+      relations: [],
+      fileMetadata: {
+        format: 'None recorded',
+        path: 'No file linked',
+        bitrate: 'Not recorded',
+        sampleRate: 'Not recorded',
+        channels: 'Not recorded',
+        importedAt: 'Manual entry',
+        checksum: 'Not recorded',
+      },
+      externalSources: [
+        {
+          providerName: 'discogs',
+          resourceType: 'track',
+          externalId: 'track-249504',
+          sourceUrl: 'https://www.discogs.com/release/249504',
+          appliedAt: '2026-05-31T19:00:00.000Z',
+        },
+      ],
+    }
+
+    await api.createTrack(track)
+    await api.updateTrack(track)
+
+    expect(
+      h.requestPayload<Record<string, unknown>>(fetchMock.mock.calls[0][1]),
+    ).toMatchObject({
+      externalSources: track.externalSources,
+    })
+    expect(
+      h.requestPayload<Record<string, unknown>>(fetchMock.mock.calls[1][1]),
+    ).toMatchObject({
+      externalSources: track.externalSources,
+    })
+  })
+
   it('rejects invalid rating values before sending a request', async () => {
     const fetchMock = vi.fn<Window['fetch']>()
     vi.stubGlobal('fetch', fetchMock)
diff --git a/src/features/catalog/externalMetadataClient.test.ts b/src/features/catalog/externalMetadataClient.test.ts
index 26909f1..cda5b26 100644
--- a/src/features/catalog/externalMetadataClient.test.ts
+++ b/src/features/catalog/externalMetadataClient.test.ts
@@ -1,7 +1,11 @@
 import { describe, expect, it, vi } from 'vitest'
 import {
+  getDiscogsArtist,
   getDiscogsRelease,
+  getDiscogsTrack,
+  searchDiscogsArtists,
   searchDiscogsReleases,
+  searchDiscogsTracks,
 } from './api/externalMetadataClient'
 import { CatalogApiError } from './api/httpClient'
 import * as h from './catalogApiTestHarness'
@@ -87,7 +91,10 @@ describe('external metadata API client', () => {
           credits: [{ name: 'New Order', role: 'Written-By' }],
           draft: {
             title: 'Blue Monday',
+            type: 'single',
+            genres: ['Electronic', 'Leftfield'],
             year: 1983,
+            releaseDate: '1983-03-07',
             artistCredits: [{ name: 'New Order', role: 'mainArtist' }],
             labels: [
               {
@@ -132,6 +139,9 @@ describe('external metadata API client', () => {
       position: 1,
       durationSeconds: 449,
     })
+    expect(detail.draft.releaseDate).toBe('1983-03-07')
+    expect(detail.draft.type).toBe('single')
+    expect(detail.draft.genres).toEqual(['Electronic', 'Leftfield'])
     expect(detail.draft.externalSources[0]).toMatchObject({
       providerName: 'discogs',
       resourceType: 'release',
@@ -168,6 +178,149 @@ describe('external metadata API client', () => {
       retryAfter: '60',
     } satisfies Partial<CatalogApiError>)
   })
+
+  it('searches Discogs artists with trimmed query params and parses detail drafts', async () => {
+    const fetchMock = vi.fn<Window['fetch']>()
+    fetchMock
+      .mockResolvedValueOnce(
+        h.jsonResponse({
+          items: [
+            {
+              source: source('artist', '5876'),
+              name: 'Arthur Baker',
+              profile: 'Producer and remixer.',
+              nameVariations: ['A. Baker'],
+            },
+          ],
+          limit: 25,
+          total: 1,
+        }),
+      )
+      .mockResolvedValueOnce(
+        h.jsonResponse({
+          source: source('artist', '5876'),
+          name: 'Arthur Baker',
+          profile: 'Producer and remixer.',
+          aliases: ['Arthur Baker III'],
+          members: ['Rockers Revenge'],
+          nameVariations: ['A. Baker'],
+          draft: {
+            name: 'Arthur Baker',
+            externalSources: [
+              {
+                providerName: 'discogs',
+                resourceType: 'artist',
+                externalId: '5876',
+                sourceUrl: 'https://www.discogs.com/artist/5876',
+              },
+            ],
+          },
+        }),
+      )
+    vi.stubGlobal('fetch', fetchMock)
+
+    const result = await searchDiscogsArtists({
+      query: ' Arthur Baker ',
+      limit: 25,
+    })
+    const detail = await getDiscogsArtist('5876')
+
+    const searchUrl = requestUrl(fetchMock.mock.calls[0][0])
+    expect(searchUrl.pathname).toBe('/api/external-metadata/discogs/artists')
+    expect(searchUrl.searchParams.get('query')).toBe('Arthur Baker')
+    expect(searchUrl.searchParams.get('limit')).toBe('25')
+    expect(result.items[0]).toMatchObject({
+      name: 'Arthur Baker',
+      source: { attribution: 'Data provided by Discogs.' },
+    })
+    expect(fetchMock.mock.calls[1][0]).toBe(
+      '/api/external-metadata/discogs/artists/5876',
+    )
+    expect(detail.draft.externalSources[0]).toMatchObject({
+      providerName: 'discogs',
+      resourceType: 'artist',
+      externalId: '5876',
+    })
+  })
+
+  it('searches Discogs tracks with release context and parses selected track detail', async () => {
+    const fetchMock = vi.fn<Window['fetch']>()
+    fetchMock
+      .mockResolvedValueOnce(
+        h.jsonResponse({
+          items: [
+            {
+              source: source('track', 'track-249504'),
+              title: 'Blue Monday',
+              position: 'A',
+              durationSeconds: 449,
+              artists: ['New Order'],
+              release: {
+                source: source('release', '249504'),
+                title: 'Blue Monday',
+                year: 1983,
+                artists: ['New Order'],
+              },
+            },
+          ],
+          limit: 25,
+          total: 1,
+        }),
+      )
+      .mockResolvedValueOnce(
+        h.jsonResponse({
+          source: source('track', 'track-249504'),
+          title: 'Blue Monday',
+          position: 'A',
+          durationSeconds: 449,
+          artists: ['New Order'],
+          credits: [{ name: 'Remixer Name', role: 'Remix' }],
+          release: {
+            source: source('release', '249504'),
+            title: 'Blue Monday',
+            year: 1983,
+            artists: ['New Order'],
+          },
+          draft: {
+            title: 'Blue Monday',
+            durationSeconds: 449,
+            artistCredits: [{ name: 'New Order', role: 'mainArtist' }],
+            externalSources: [
+              {
+                providerName: 'discogs',
+                resourceType: 'track',
+                externalId: 'track-249504',
+                sourceUrl: 'https://www.discogs.com/release/249504',
+              },
+            ],
+          },
+        }),
+      )
+    vi.stubGlobal('fetch', fetchMock)
+
+    const result = await searchDiscogsTracks({
+      title: ' Blue Monday ',
+      artist: ' New Order ',
+      releaseTitle: ' Blue Monday ',
+      year: ' 1983 ',
+      barcode: ' 5016839200371 ',
+      catalogNumber: ' FAC 73 ',
+      limit: 25,
+    })
+    const detail = await getDiscogsTrack('track-249504')
+
+    const searchUrl = requestUrl(fetchMock.mock.calls[0][0])
+    expect(searchUrl.pathname).toBe('/api/external-metadata/discogs/tracks')
+    expect(searchUrl.searchParams.get('title')).toBe('Blue Monday')
+    expect(searchUrl.searchParams.get('artist')).toBe('New Order')
+    expect(searchUrl.searchParams.get('releaseTitle')).toBe('Blue Monday')
+    expect(searchUrl.searchParams.get('catalogNumber')).toBe('FAC 73')
+    expect(result.items[0].release.title).toBe('Blue Monday')
+    expect(fetchMock.mock.calls[1][0]).toBe(
+      '/api/external-metadata/discogs/tracks/track-249504',
+    )
+    expect(detail.draft.externalSources[0].resourceType).toBe('track')
+  })
 })
 
 function source(resourceType: string, externalId: string) {
diff --git a/src/features/manualEntry/manual-entry.css b/src/features/manualEntry/manual-entry.css
index e654c99..ac9802f 100644
--- a/src/features/manualEntry/manual-entry.css
+++ b/src/features/manualEntry/manual-entry.css
@@ -109,6 +109,18 @@
   grid-column: 1 / -1;
 }
 
+@media (max-width: 700px) {
+  .manual-entry-header,
+  .manual-entry-actions {
+    align-items: stretch;
+    flex-direction: column;
+  }
+
+  .manual-entry-grid {
+    grid-template-columns: minmax(0, 1fr);
+  }
+}
+
 .catalog-add-entry-panel {
   display: grid;
 }
diff --git a/src/features/releases/CreditRolePicker.tsx b/src/features/releases/CreditRolePicker.tsx
new file mode 100644
index 0000000..99d464e
--- /dev/null
+++ b/src/features/releases/CreditRolePicker.tsx
@@ -0,0 +1,44 @@
+type CreditRolePickerProps = {
+  addLabel: string
+  ariaLabel: string
+  options: string[]
+  onSelect: (role: string) => void
+}
+
+export function CreditRolePicker({
+  addLabel,
+  ariaLabel,
+  options,
+  onSelect,
+}: CreditRolePickerProps) {
+  const hasOptions = options.length > 0
+
+  return (
+    <details
+      className={
+        hasOptions
+          ? 'release-artist-add-role'
+          : 'release-artist-add-role release-artist-add-role-disabled'
+      }
+    >
+      <summary aria-label={ariaLabel}>{addLabel}</summary>
+      {hasOptions ? (
+        <div className="release-artist-role-menu" role="menu">
+          {options.map((role) => (
+            <button
+              key={role}
+              type="button"
+              role="menuitem"
+              onClick={(event) => {
+                onSelect(role)
+                event.currentTarget.closest('details')?.removeAttribute('open')
+              }}
+            >
+              {role}
+            </button>
+          ))}
+        </div>
+      ) : null}
+    </details>
+  )
+}
diff --git a/src/features/releases/DiscogsReleaseLookupPanel.tsx b/src/features/releases/DiscogsReleaseLookupPanel.tsx
index 7fb8cac..0e2ba46 100644
--- a/src/features/releases/DiscogsReleaseLookupPanel.tsx
+++ b/src/features/releases/DiscogsReleaseLookupPanel.tsx
@@ -1,19 +1,24 @@
 import { Search } from 'lucide-react'
+import type { ReactNode } from 'react'
 import { useEffect, useRef, useState } from 'react'
 import {
   CatalogApiError,
   getDiscogsRelease,
   searchDiscogsReleases,
+  type CatalogDictionaries,
   type ExternalMetadataReleaseCandidateDto,
   type ExternalMetadataReleaseDetailDto,
+  type ExternalMetadataReleaseDraftArtistCreditDto,
+  type ExternalMetadataReleaseDraftTrackDto,
 } from '../catalog/catalogApi'
+import { discogsDraftTrackRows } from './discogsReleaseTrackRows'
 
 export type DiscogsApplyGroups = {
   core: boolean
   artists: boolean
+  classification: boolean
   labels: boolean
   tracklist: boolean
-  externalSource: boolean
 }
 
 export type DiscogsSearchSeed = {
@@ -26,7 +31,9 @@ export type DiscogsSearchSeed = {
 export type DiscogsCurrentRelease = {
   artists: string
   externalSourceCount: number
+  genres: string
   labels: string
+  releaseDate: string
   title: string
   trackCount: number
   year: string
@@ -34,6 +41,7 @@ export type DiscogsCurrentRelease = {
 
 type DiscogsReleaseLookupPanelProps = {
   current: DiscogsCurrentRelease
+  dictionaries: CatalogDictionaries
   isOpen: boolean
   mode: 'create' | 'update'
   searchSeed: DiscogsSearchSeed
@@ -47,13 +55,14 @@ type DiscogsReleaseLookupPanelProps = {
 const emptyGroups: DiscogsApplyGroups = {
   core: false,
   artists: false,
+  classification: false,
   labels: false,
   tracklist: false,
-  externalSource: false,
 }
 
 export function DiscogsReleaseLookupPanel({
   current,
+  dictionaries,
   isOpen,
   mode,
   searchSeed,
@@ -64,9 +73,9 @@ export function DiscogsReleaseLookupPanel({
   const [artist, setArtist] = useState(searchSeed.artist)
   const [title, setTitle] = useState(searchSeed.title)
   const [year, setYear] = useState(searchSeed.year)
-  const [barcode, setBarcode] = useState('')
   const [catalogNumber, setCatalogNumber] = useState(searchSeed.catalogNumber)
   const [status, setStatus] = useState('')
+  const [appliedStatus, setAppliedStatus] = useState('')
   const [candidates, setCandidates] = useState<
     ExternalMetadataReleaseCandidateDto[]
   >([])
@@ -90,6 +99,7 @@ export function DiscogsReleaseLookupPanel({
 
   async function handleSearch() {
     setStatus('Searching Discogs release candidates.')
+    setAppliedStatus('')
     setSelectedDetail(null)
 
     try {
@@ -98,7 +108,6 @@ export function DiscogsReleaseLookupPanel({
         artist,
         title,
         year,
-        barcode,
         catalogNumber,
         limit: 25,
       })
@@ -119,6 +128,7 @@ export function DiscogsReleaseLookupPanel({
     candidate: ExternalMetadataReleaseCandidateDto,
   ) {
     setStatus(`Loading Discogs detail for ${candidate.title}.`)
+    setAppliedStatus('')
 
     try {
       const detail = await getDiscogsRelease(candidate.source.externalId)
@@ -135,7 +145,21 @@ export function DiscogsReleaseLookupPanel({
     setApplyGroups((groups) => ({ ...groups, [group]: checked }))
   }
 
+  function handleApplyDraft(
+    detail: ExternalMetadataReleaseDetailDto,
+    groups: DiscogsApplyGroups,
+  ) {
+    onApplyDraft(detail, groups)
+    setAppliedStatus(
+      `Applied Discogs ${appliedGroupLabel(groups)} to the form. Save record to persist changes.`,
+    )
+    setCandidates([])
+    setSelectedDetail(null)
+    onOpenChange(false)
+  }
+
   const hasSelectedGroup = Object.values(applyGroups).some(Boolean)
+  const selectedExternalId = selectedDetail?.source.externalId ?? ''
 
   return (
     <section
@@ -194,14 +218,6 @@ export function DiscogsReleaseLookupPanel({
                 onChange={(event) => setYear(event.target.value)}
               />
             </label>
-            <label>
-              <span>Discogs barcode</span>
-              <input
-                aria-label="Discogs barcode"
-                value={barcode}
-                onChange={(event) => setBarcode(event.target.value)}
-              />
-            </label>
             <label>
               <span>Discogs catalog number</span>
               <input
@@ -218,7 +234,7 @@ export function DiscogsReleaseLookupPanel({
               }}
             >
               <Search size={14} aria-hidden="true" />
-              Search Discogs releases
+              <span>Search Discogs releases</span>
             </button>
           </div>
 
@@ -232,140 +248,227 @@ export function DiscogsReleaseLookupPanel({
             <div className="discogs-candidate-list">
               {candidates.map((candidate) => (
                 <article
-                  className="discogs-candidate"
+                  className={
+                    candidate.source.externalId === selectedExternalId
+                      ? 'discogs-candidate is-selected'
+                      : 'discogs-candidate'
+                  }
                   key={candidate.source.externalId}
                 >
-                  <div>
-                    <strong>{candidate.title}</strong>
-                    <p>
-                      {candidate.artists.join(', ') || 'Unknown artist'} ·{' '}
-                      {candidate.year ?? 'Unknown year'} ·{' '}
-                      {candidate.labels.join(', ') || 'Unknown label'}
-                    </p>
-                    <p>
-                      {[...candidate.formats, candidate.catalogNumber]
-                        .filter(Boolean)
-                        .join(' · ')}
-                    </p>
-                    {candidate.barcodes.length > 0 ? (
-                      <p>Barcodes: {candidate.barcodes.join(', ')}</p>
-                    ) : null}
-                    <p>{candidate.source.attribution}</p>
-                  </div>
-                  <div className="discogs-candidate-actions">
-                    <a
-                      className="detail-link"
-                      href={candidate.source.sourceUrl}
-                      target="_blank"
-                      rel="noreferrer"
-                    >
-                      Open candidate Discogs source
-                    </a>
-                    <button
-                      className="button button-secondary button-compact"
-                      type="button"
-                      onClick={() => {
-                        void reviewCandidate(candidate)
-                      }}
-                    >
-                      Review {candidate.title}
-                    </button>
+                  <div className="discogs-candidate-summary">
+                    <div>
+                      <strong>{candidate.title}</strong>
+                      <p>
+                        {candidate.artists.join(', ') || 'Unknown artist'} ·{' '}
+                        {candidate.year ?? 'Unknown year'}
+                      </p>
+                      <p>
+                        {[...candidate.formats, candidate.catalogNumber]
+                          .filter(Boolean)
+                          .join(' · ')}
+                      </p>
+                      <p>{candidate.source.attribution}</p>
+                    </div>
+                    <div className="discogs-candidate-actions">
+                      <a
+                        className="detail-link"
+                        href={candidate.source.sourceUrl}
+                        target="_blank"
+                        rel="noreferrer"
+                      >
+                        Open candidate Discogs source
+                      </a>
+                      <button
+                        className="button button-secondary button-compact"
+                        type="button"
+                        onClick={() => {
+                          void reviewCandidate(candidate)
+                        }}
+                      >
+                        <span>Review {candidate.title}</span>
+                      </button>
+                    </div>
                   </div>
+                  {selectedDetail?.source.externalId ===
+                  candidate.source.externalId ? (
+                    <DiscogsCandidateReview
+                      applyGroups={applyGroups}
+                      current={current}
+                      detail={selectedDetail}
+                      dictionaries={dictionaries}
+                      hasSelectedGroup={hasSelectedGroup}
+                      onApplyDraft={handleApplyDraft}
+                      onUpdateApplyGroup={updateApplyGroup}
+                    />
+                  ) : null}
                 </article>
               ))}
             </div>
           ) : null}
-
-          {selectedDetail ? (
-            <div className="discogs-review-panel">
-              <div className="release-form-section-header">
-                <div>
-                  <h3>Review Discogs candidate</h3>
-                  <p>
-                    {selectedDetail.source.attribution}{' '}
-                    <a
-                      className="detail-link"
-                      href={selectedDetail.source.sourceUrl}
-                      target="_blank"
-                      rel="noreferrer"
-                    >
-                      Open Discogs source
-                    </a>
-                  </p>
-                </div>
-              </div>
-
-              <div className="discogs-review-grid">
-                <ReviewColumn
-                  title="Current local release"
-                  rows={currentRows(current)}
-                />
-                <ReviewColumn
-                  title="Discogs draft"
-                  rows={discogsRows(selectedDetail)}
-                />
-              </div>
-
-              <fieldset className="discogs-apply-groups">
-                <legend>Apply groups</legend>
-                <ApplyGroup
-                  checked={applyGroups.core}
-                  label="Apply Core"
-                  onChange={(checked) => updateApplyGroup('core', checked)}
-                />
-                <ApplyGroup
-                  checked={applyGroups.artists}
-                  label="Apply Artists"
-                  onChange={(checked) => updateApplyGroup('artists', checked)}
-                />
-                <ApplyGroup
-                  checked={applyGroups.labels}
-                  label="Apply Labels"
-                  onChange={(checked) => updateApplyGroup('labels', checked)}
-                />
-                <ApplyGroup
-                  checked={applyGroups.tracklist}
-                  label="Apply Tracklist"
-                  onChange={(checked) => updateApplyGroup('tracklist', checked)}
-                />
-                <ApplyGroup
-                  checked={applyGroups.externalSource}
-                  label="Apply External Source"
-                  onChange={(checked) =>
-                    updateApplyGroup('externalSource', checked)
-                  }
-                />
-              </fieldset>
-
-              <button
-                className="button button-primary button-compact"
-                type="button"
-                disabled={!hasSelectedGroup}
-                onClick={() => onApplyDraft(selectedDetail, applyGroups)}
-              >
-                Apply selected Discogs fields
-              </button>
-            </div>
-          ) : null}
         </>
       ) : (
-        <p className="release-section-note">
-          Discogs lookup is optional and never saves data until the release form
-          is submitted.
+        <p
+          className={
+            appliedStatus ? 'discogs-apply-status' : 'release-section-note'
+          }
+          role={appliedStatus ? 'status' : undefined}
+        >
+          {appliedStatus ||
+            'Discogs lookup is optional and never saves data until the release form is submitted.'}
         </p>
       )}
     </section>
   )
 }
 
+function appliedGroupLabel(groups: DiscogsApplyGroups) {
+  const labels = [
+    groups.core ? 'core' : '',
+    groups.artists ? 'artists' : '',
+    groups.labels ? 'labels' : '',
+    groups.classification ? 'classification' : '',
+    groups.tracklist ? 'tracklist' : '',
+  ].filter(Boolean)
+
+  if (labels.length === 0) {
+    return 'fields'
+  }
+
+  return labels.length === 1
+    ? labels[0]
+    : `${labels.slice(0, -1).join(', ')} and ${labels.at(-1)}`
+}
+
+function DiscogsCandidateReview({
+  applyGroups,
+  current,
+  detail,
+  dictionaries,
+  hasSelectedGroup,
+  onApplyDraft,
+  onUpdateApplyGroup,
+}: {
+  applyGroups: DiscogsApplyGroups
+  current: DiscogsCurrentRelease
+  detail: ExternalMetadataReleaseDetailDto
+  dictionaries: CatalogDictionaries
+  hasSelectedGroup: boolean
+  onApplyDraft: (
+    detail: ExternalMetadataReleaseDetailDto,
+    groups: DiscogsApplyGroups,
+  ) => void
+  onUpdateApplyGroup: (
+    group: keyof DiscogsApplyGroups,
+    checked: boolean,
+  ) => void
+}) {
+  const compilationDetected = hasCompilationTrackArtists(detail)
+  const reviewTracks = discogsDraftTrackRows(detail.draft.tracklist)
+  const draftGenres = detail.draft.genres ?? []
+
+  return (
+    <div className="discogs-review-panel">
+      <div className="release-form-section-header">
+        <div>
+          <h3>Review Discogs candidate</h3>
+          <p>
+            {detail.source.attribution}{' '}
+            <a
+              className="detail-link"
+              href={detail.source.sourceUrl}
+              target="_blank"
+              rel="noreferrer"
+            >
+              Open Discogs source
+            </a>
+          </p>
+        </div>
+      </div>
+
+      <div className="discogs-impact-list">
+        <ImpactRow
+          checked={applyGroups.core}
+          currentValue={[
+            current.title || 'Not recorded',
+            current.releaseDate || current.year,
+          ]
+            .filter(Boolean)
+            .join(' · ')}
+          group="Core"
+          nextValue={[
+            detail.draft.title,
+            detail.draft.releaseDate || detail.draft.year?.toString(),
+          ]
+            .filter(Boolean)
+            .join(' · ')}
+          onChange={(checked) => onUpdateApplyGroup('core', checked)}
+        />
+        <ImpactRow
+          checked={applyGroups.artists}
+          currentValue={current.artists || 'Not recorded'}
+          group="Artists"
+          nextValue={`${detail.draft.artistCredits.length} Discogs credits`}
+          onChange={(checked) => onUpdateApplyGroup('artists', checked)}
+        >
+          <ArtistImpactList
+            credits={detail.draft.artistCredits}
+            dictionaries={dictionaries}
+          />
+        </ImpactRow>
+        <ImpactRow
+          checked={applyGroups.labels}
+          currentValue={current.labels || 'Not recorded'}
+          group="Labels"
+          nextValue={releaseLabelSummary(detail) || 'Not recorded'}
+          onChange={(checked) => onUpdateApplyGroup('labels', checked)}
+        />
+        <ImpactRow
+          checked={applyGroups.classification}
+          currentValue={current.genres || 'Not recorded'}
+          group="Classification"
+          nextValue={
+            draftGenres.length > 0 ? draftGenres.join(', ') : 'Not recorded'
+          }
+          onChange={(checked) => onUpdateApplyGroup('classification', checked)}
+        />
+        <ImpactRow
+          checked={applyGroups.tracklist}
+          currentValue={`${current.trackCount} rows`}
+          group="Tracklist"
+          nextValue={`${reviewTracks.length} Discogs rows`}
+          onChange={(checked) => onUpdateApplyGroup('tracklist', checked)}
+        >
+          {compilationDetected ? (
+            <p className="discogs-impact-warning">
+              Compilation detected: track-specific artists differ from release
+              artists. Applying Tracklist will mark the release as Various
+              Artists and write track-level artist credits.
+            </p>
+          ) : null}
+          <TrackImpactList dictionaries={dictionaries} tracks={reviewTracks} />
+        </ImpactRow>
+      </div>
+
+      <button
+        className="button button-primary button-compact"
+        type="button"
+        disabled={!hasSelectedGroup}
+        onClick={() => onApplyDraft(detail, applyGroups)}
+      >
+        Apply selected Discogs fields
+      </button>
+    </div>
+  )
+}
+
 function defaultGroups(mode: 'create' | 'update'): DiscogsApplyGroups {
   return mode === 'create'
     ? {
         core: true,
         artists: true,
+        classification: true,
         labels: true,
         tracklist: true,
-        externalSource: true,
       }
     : emptyGroups
 }
@@ -383,69 +486,222 @@ function externalMetadataErrorMessage(error: unknown) {
   return 'External metadata provider is unavailable.'
 }
 
-function currentRows(current: DiscogsCurrentRelease) {
-  return [
-    ['Title', current.title || 'Not recorded'],
-    ['Artist', current.artists || 'Not recorded'],
-    ['Year', current.year || 'Not recorded'],
-    ['Labels', current.labels || 'Not recorded'],
-    ['Tracklist', `${current.trackCount} rows`],
-    ['Sources', `${current.externalSourceCount} sources`],
-  ]
+function ImpactRow({
+  checked,
+  children,
+  currentValue,
+  group,
+  nextValue,
+  onChange,
+}: {
+  checked: boolean
+  children?: ReactNode
+  currentValue: string
+  group: string
+  nextValue: string
+  onChange: (checked: boolean) => void
+}) {
+  return (
+    <div className="discogs-impact-row">
+      <ApplyGroup
+        checked={checked}
+        label={`Apply ${group}`}
+        onChange={onChange}
+      />
+      <div className="discogs-impact-group">{group}</div>
+      <div className="discogs-impact-value">
+        <span>Current</span>
+        <strong>{currentValue}</strong>
+      </div>
+      <div className="discogs-impact-value">
+        <span>Discogs</span>
+        <strong>{nextValue}</strong>
+        {children ? (
+          <div className="discogs-impact-detail">{children}</div>
+        ) : null}
+      </div>
+    </div>
+  )
 }
 
-function discogsRows(detail: ExternalMetadataReleaseDetailDto) {
-  return [
-    ['Title', detail.draft.title || 'Not recorded'],
-    [
-      'Artist',
-      detail.draft.artistCredits.map((credit) => credit.name).join(', ') ||
-        'Not recorded',
-    ],
-    ['Year', detail.draft.year?.toString() ?? 'Not recorded'],
-    [
-      'Labels',
-      detail.draft.labels
-        .map((label) =>
-          [label.name, label.catalogNumber].filter(Boolean).join(' '),
-        )
-        .join(', ') || 'Not recorded',
-    ],
-    ['Tracklist', `${detail.draft.tracklist.length} rows`],
-    ['Formats', detail.formats.join(', ') || 'Not recorded'],
-    ['Barcodes', detail.barcodes.join(', ') || 'Not recorded'],
-    [
-      'Identifiers',
-      detail.identifiers
-        .map((identifier) => `${identifier.type}: ${identifier.value}`)
-        .join(', ') || 'Not recorded',
-    ],
-    [
-      'Credits',
-      detail.credits
-        .map((credit) => [credit.name, credit.role].filter(Boolean).join(' - '))
-        .join(', ') || 'Not recorded',
-    ],
-    ['Sources', `${detail.draft.externalSources.length} sources`],
-  ]
+function ArtistImpactList({
+  credits,
+  dictionaries,
+}: {
+  credits: ExternalMetadataReleaseDraftArtistCreditDto[]
+  dictionaries: CatalogDictionaries
+}) {
+  if (credits.length === 0) {
+    return <p className="discogs-impact-empty">No Discogs artist credits.</p>
+  }
+
+  return (
+    <div className="discogs-credit-impact-list">
+      {groupDiscogsReviewCredits(credits).map((credit) => (
+        <CreditImpactRow
+          credit={credit}
+          dictionaries={dictionaries}
+          key={credit.name}
+        />
+      ))}
+    </div>
+  )
 }
 
-function ReviewColumn({ title, rows }: { title: string; rows: string[][] }) {
+function TrackImpactList({
+  dictionaries,
+  tracks,
+}: {
+  dictionaries: CatalogDictionaries
+  tracks: ExternalMetadataReleaseDraftTrackDto[]
+}) {
+  const [showAllTracks, setShowAllTracks] = useState(false)
+  const previewTracks = showAllTracks ? tracks : tracks.slice(0, 4)
+  const hiddenCount = tracks.length - previewTracks.length
+
+  if (tracks.length === 0) {
+    return <p className="discogs-impact-empty">No Discogs track rows.</p>
+  }
+
   return (
-    <div className="discogs-review-column">
-      <h4>{title}</h4>
-      <dl>
-        {rows.map(([label, value]) => (
-          <div key={label}>
-            <dt>{label}</dt>
-            <dd>{value}</dd>
+    <div className="discogs-track-impact-list">
+      {previewTracks.map((track) => (
+        <div className="discogs-track-impact-row" key={track.position}>
+          <span className="discogs-track-impact-position">
+            {track.position}
+          </span>
+          <div>
+            <strong>{track.title}</strong>
+            <p>
+              {track.durationSeconds
+                ? formatDurationSeconds(track.durationSeconds)
+                : 'No duration'}{' '}
+              · create track
+            </p>
+            {track.artistCredits.length > 0 ? (
+              <div className="discogs-credit-impact-list">
+                {groupDiscogsReviewCredits(track.artistCredits).map(
+                  (credit) => (
+                    <CreditImpactRow
+                      credit={credit}
+                      dictionaries={dictionaries}
+                      key={`${track.position}-${credit.name}`}
+                    />
+                  ),
+                )}
+              </div>
+            ) : (
+              <p className="discogs-impact-empty">Inherits release artists.</p>
+            )}
           </div>
+        </div>
+      ))}
+      {hiddenCount > 0 ? (
+        <button
+          className="button button-secondary button-compact discogs-track-toggle"
+          type="button"
+          aria-expanded={showAllTracks}
+          onClick={() => setShowAllTracks(true)}
+        >
+          Show {hiddenCount} more Discogs track row
+          {hiddenCount === 1 ? '' : 's'}
+        </button>
+      ) : showAllTracks && tracks.length > 4 ? (
+        <button
+          className="button button-secondary button-compact discogs-track-toggle"
+          type="button"
+          aria-expanded={showAllTracks}
+          onClick={() => setShowAllTracks(false)}
+        >
+          Show fewer Discogs track rows
+        </button>
+      ) : null}
+    </div>
+  )
+}
+
+function CreditImpactRow({
+  credit,
+  dictionaries,
+}: {
+  credit: GroupedDiscogsReviewCredit
+  dictionaries: CatalogDictionaries
+}) {
+  return (
+    <div className="discogs-credit-impact-row">
+      <strong>{credit.name}</strong>
+      <span className="discogs-credit-role-list">
+        {credit.roles.map((role) => (
+          <span className="badge badge-credit" key={role}>
+            {roleLabelFromCode(role, dictionaries)}
+          </span>
         ))}
-      </dl>
+      </span>
     </div>
   )
 }
 
+type GroupedDiscogsReviewCredit = {
+  name: string
+  roles: string[]
+}
+
+function groupDiscogsReviewCredits(
+  credits: ExternalMetadataReleaseDraftArtistCreditDto[],
+) {
+  const grouped = new Map<string, GroupedDiscogsReviewCredit>()
+
+  credits.forEach((credit) => {
+    const name = credit.name.trim()
+    if (!name) {
+      return
+    }
+
+    const key = name.toLowerCase()
+    const existing = grouped.get(key)
+    const roles = splitRoleLabels(credit.role)
+
+    if (existing) {
+      existing.roles = [...new Set([...existing.roles, ...roles])]
+    } else {
+      grouped.set(key, { name, roles })
+    }
+  })
+
+  return [...grouped.values()]
+}
+
+function splitRoleLabels(role: string) {
+  const roles: string[] = []
+  let depth = 0
+  let current = ''
+
+  for (const character of role) {
+    if (character === '[' || character === '(') {
+      depth += 1
+    } else if ((character === ']' || character === ')') && depth > 0) {
+      depth -= 1
+    }
+
+    if (character === ',' && depth === 0) {
+      const trimmed = current.trim()
+      if (trimmed) {
+        roles.push(trimmed)
+      }
+      current = ''
+    } else {
+      current += character
+    }
+  }
+
+  const trimmed = current.trim()
+  if (trimmed) {
+    roles.push(trimmed)
+  }
+
+  return roles
+}
+
 function ApplyGroup({
   checked,
   label,
@@ -466,3 +722,74 @@ function ApplyGroup({
     </label>
   )
 }
+
+function releaseLabelSummary(detail: ExternalMetadataReleaseDetailDto) {
+  return detail.draft.labels
+    .map((label) => [label.name, label.catalogNumber].filter(Boolean).join(' '))
+    .join(', ')
+}
+
+function roleLabelFromCode(role: string, dictionaries: CatalogDictionaries) {
+  const trimmedRole = role.trim()
+
+  return (
+    dictionaries.creditRole.find(
+      (entry) => entry.code === trimmedRole || entry.name === trimmedRole,
+    )?.name ?? trimmedRole
+  )
+}
+
+function hasCompilationTrackArtists(detail: ExternalMetadataReleaseDetailDto) {
+  const releaseMainArtists = normalizedSet(
+    detail.draft.artistCredits
+      .filter((credit) => normalizeText(credit.role) === 'mainartist')
+      .map((credit) => credit.name),
+  )
+  const releaseArtists =
+    releaseMainArtists.size > 0
+      ? releaseMainArtists
+      : normalizedSet(detail.draft.artistCredits.map((credit) => credit.name))
+
+  return detail.draft.tracklist.some((track) => {
+    const trackMainArtists = normalizedSet(
+      track.artistCredits
+        .filter((credit) => normalizeText(credit.role) === 'mainartist')
+        .map((credit) => credit.name),
+    )
+
+    if (trackMainArtists.size === 0) {
+      return false
+    }
+
+    return !setsEqual(releaseArtists, trackMainArtists)
+  })
+}
+
+function normalizedSet(values: string[]) {
+  return new Set(values.map(normalizeText).filter(Boolean))
+}
+
+function normalizeText(value: string) {
+  return value.trim().toLowerCase()
+}
+
+function setsEqual(left: Set<string>, right: Set<string>) {
+  if (left.size !== right.size) {
+    return false
+  }
+
+  for (const value of left) {
+    if (!right.has(value)) {
+      return false
+    }
+  }
+
+  return true
+}
+
+function formatDurationSeconds(durationSeconds: number) {
+  const minutes = Math.floor(durationSeconds / 60)
+  const seconds = durationSeconds % 60
+
+  return `${minutes}:${String(seconds).padStart(2, '0')}`
+}
diff --git a/src/features/releases/ReleaseArtistCreditsSection.tsx b/src/features/releases/ReleaseArtistCreditsSection.tsx
index b1b205c..7c4aad0 100644
--- a/src/features/releases/ReleaseArtistCreditsSection.tsx
+++ b/src/features/releases/ReleaseArtistCreditsSection.tsx
@@ -1,5 +1,6 @@
 import type { Dispatch, SetStateAction } from 'react'
 import type { ArtistRecord } from '../artists/artistsData'
+import { CreditRolePicker } from './CreditRolePicker'
 import type { EditableArtistCredit } from './ReleaseEntryFormTypes'
 import { artistCreditName } from './releaseFormHelpers'
 
@@ -99,44 +100,34 @@ export function ReleaseArtistCreditsSection({
                     <span className="release-artist-chip-name">
                       {artistName || 'Unnamed artist'}
                     </span>
-                    <label className="release-artist-chip-role">
-                      <span className="visually-hidden">
-                        Role for {artistName || 'artist'}
-                      </span>
-                      <span
-                        className={
-                          credit.role
-                            ? 'release-artist-chip-role-face'
-                            : 'release-artist-chip-role-face release-artist-chip-role-face-unset'
+                    <span className="release-artist-chip-roles">
+                      {credit.roles.map((role) => (
+                        <span className="release-artist-role-pill" key={role}>
+                          <span>{role}</span>
+                          <button
+                            type="button"
+                            aria-label={`Remove ${role} from ${artistName || 'artist'}`}
+                            onClick={() =>
+                              removeCreditRole(credit, role, setArtistCredits)
+                            }
+                          >
+                            ×
+                          </button>
+                        </span>
+                      ))}
+                      <CreditRolePicker
+                        addLabel={
+                          credit.roles.length > 0 ? 'Add role' : 'Set role'
                         }
-                        aria-hidden="true"
-                      >
-                        <span>{credit.role || 'Set role'}</span>
-                        <span className="release-artist-chip-role-caret" />
-                      </span>
-                      <select
-                        className="release-artist-chip-role-select"
-                        aria-label={`Role for ${artistName || 'artist'}`}
-                        value={credit.role}
-                        onChange={(event) =>
-                          setArtistCredits((credits) =>
-                            credits.map((currentCredit) =>
-                              currentCredit.id === credit.id
-                                ? {
-                                    ...currentCredit,
-                                    role: event.target.value,
-                                  }
-                                : currentCredit,
-                            ),
-                          )
+                        ariaLabel={`Role for ${artistName || 'artist'}`}
+                        options={creditRoleOptions.filter(
+                          (role) => !credit.roles.includes(role),
+                        )}
+                        onSelect={(role) =>
+                          addCreditRole(credit, role, setArtistCredits)
                         }
-                      >
-                        <option value="">Set role</option>
-                        {creditRoleOptions.map((role) => (
-                          <option key={role}>{role}</option>
-                        ))}
-                      </select>
-                    </label>
+                      />
+                    </span>
                     <button
                       className="release-artist-chip-remove"
                       type="button"
@@ -166,3 +157,45 @@ export function ReleaseArtistCreditsSection({
     </section>
   )
 }
+
+function addCreditRole(
+  credit: EditableArtistCredit,
+  role: string,
+  setArtistCredits: Dispatch<SetStateAction<EditableArtistCredit[]>>,
+) {
+  if (!role || credit.roles.includes(role)) {
+    return
+  }
+
+  setArtistCredits((credits) =>
+    credits.map((currentCredit) =>
+      currentCredit.id === credit.id
+        ? {
+            ...currentCredit,
+            role: currentCredit.role || role,
+            roles: [...currentCredit.roles, role],
+          }
+        : currentCredit,
+    ),
+  )
+}
+
+function removeCreditRole(
+  credit: EditableArtistCredit,
+  role: string,
+  setArtistCredits: Dispatch<SetStateAction<EditableArtistCredit[]>>,
+) {
+  const nextRoles = credit.roles.filter((currentRole) => currentRole !== role)
+
+  setArtistCredits((credits) =>
+    credits.map((currentCredit) =>
+      currentCredit.id === credit.id
+        ? {
+            ...currentCredit,
+            role: nextRoles[0] ?? '',
+            roles: nextRoles,
+          }
+        : currentCredit,
+    ),
+  )
+}
diff --git a/src/features/releases/ReleaseCoreSection.tsx b/src/features/releases/ReleaseCoreSection.tsx
index 1a81c9c..d1148e5 100644
--- a/src/features/releases/ReleaseCoreSection.tsx
+++ b/src/features/releases/ReleaseCoreSection.tsx
@@ -4,7 +4,9 @@ import { releaseYearOptions } from './ReleaseEntryFormTypes'
 
 type ReleaseCoreSectionProps = {
   duplicateRelease?: ReleaseRecord
+  releaseDate: string
   releaseTypeOptions: string[]
+  setReleaseDate: Dispatch<SetStateAction<string>>
   setTitle: Dispatch<SetStateAction<string>>
   setType: Dispatch<SetStateAction<ReleaseType>>
   setYear: Dispatch<SetStateAction<string>>
@@ -15,7 +17,9 @@ type ReleaseCoreSectionProps = {
 
 export function ReleaseCoreSection({
   duplicateRelease,
+  releaseDate,
   releaseTypeOptions,
+  setReleaseDate,
   setTitle,
   setType,
   setYear,
@@ -54,6 +58,15 @@ export function ReleaseCoreSection({
               ))}
             </select>
           </label>
+          <label className="release-core-date-field">
+            <span>Release date</span>
+            <input
+              aria-label="Release date"
+              type="date"
+              value={releaseDate}
+              onChange={(event) => setReleaseDate(event.target.value)}
+            />
+          </label>
           <label className="release-core-type-field">
             <span>Type</span>
             <select
diff --git a/src/features/releases/ReleaseDetail.tsx b/src/features/releases/ReleaseDetail.tsx
index 445b13c..2bea626 100644
--- a/src/features/releases/ReleaseDetail.tsx
+++ b/src/features/releases/ReleaseDetail.tsx
@@ -175,7 +175,14 @@ export function ReleaseDetail({
             <article
               key={`${credit.artistId ?? credit.artist}-${credit.role}-${index}`}
             >
-              <span className="badge badge-credit">{credit.role}</span>
+              {(credit.roles && credit.roles.length > 0
+                ? credit.roles
+                : [credit.role]
+              ).map((role) => (
+                <span className="badge badge-credit" key={role}>
+                  {role}
+                </span>
+              ))}
               {credit.artistId ? (
                 <a
                   className="detail-link"
@@ -485,6 +492,7 @@ function releaseArtistCredits(release: ReleaseRecord): ReleaseArtistCredit[] {
       artistId: release.artistId,
       artist: release.artist,
       role: 'Main artist',
+      roles: ['Main artist'],
     },
   ]
 }
diff --git a/src/features/releases/ReleaseEntryForm.tsx b/src/features/releases/ReleaseEntryForm.tsx
index e965807..0c13ed3 100644
--- a/src/features/releases/ReleaseEntryForm.tsx
+++ b/src/features/releases/ReleaseEntryForm.tsx
@@ -21,6 +21,7 @@ import {
   DiscogsReleaseLookupPanel,
   type DiscogsApplyGroups,
 } from './DiscogsReleaseLookupPanel'
+import { discogsDraftTrackRows } from './discogsReleaseTrackRows'
 import { ReleaseArtistCreditsSection } from './ReleaseArtistCreditsSection'
 import { ReleaseClassificationSection } from './ReleaseClassificationSection'
 import { ReleaseCoreSection } from './ReleaseCoreSection'
@@ -59,6 +60,10 @@ export function ReleaseEntryForm({
           artistId: credit.artistId ?? '',
           artist: credit.artistId ? '' : credit.artist,
           role: credit.role,
+          roles:
+            credit.roles && credit.roles.length > 0
+              ? credit.roles
+              : [credit.role],
         }))
       }
 
@@ -69,6 +74,7 @@ export function ReleaseEntryForm({
             artistId: initialRelease.artistId ?? '',
             artist: initialRelease.artistId ? '' : initialRelease.artist,
             role: 'Main artist',
+            roles: ['Main artist'],
           },
         ]
       }
@@ -79,6 +85,9 @@ export function ReleaseEntryForm({
   const [draftArtist, setDraftArtist] = useState('')
   const [draftArtistId, setDraftArtistId] = useState('')
   const [year, setYear] = useState(initialRelease?.year ?? '')
+  const [releaseDate, setReleaseDate] = useState(
+    initialRelease?.releaseDate ?? '',
+  )
   const [notOnLabel, setNotOnLabel] = useState(
     Boolean(initialRelease?.notOnLabel),
   )
@@ -117,6 +126,13 @@ export function ReleaseEntryForm({
   const [type, setType] = useState<ReleaseType>(
     initialRelease?.type ?? releaseTypeOptions[0] ?? 'Unknown',
   )
+  const effectiveReleaseTypeOptions = releaseTypeOptions.includes(type)
+    ? releaseTypeOptions
+    : [...releaseTypeOptions, type]
+  const effectiveGenreOptions = [
+    ...genreOptions,
+    ...genres.filter((genre) => !genreOptions.includes(genre)),
+  ]
   const [includeOwnedCopy, setIncludeOwnedCopy] = useState(Boolean(firstCopy))
   const [medium, setMedium] = useState(firstCopy?.medium ?? '')
   const [status, setStatus] = useState<OwnedCopy['status'] | ''>(
@@ -146,9 +162,7 @@ export function ReleaseEntryForm({
     : labels
   const releaseMainArtistCredits = effectiveArtistCredits
     .map((credit) => releaseArtistCreditFromEditableCredit(credit, artists))
-    .filter(
-      (credit) => credit.role === 'Main artist' && credit.artist.length > 0,
-    )
+    .filter((credit) => hasMainArtistRole(credit) && credit.artist.length > 0)
   const {
     addDraftTrack,
     addTrackArtist,
@@ -198,8 +212,7 @@ export function ReleaseEntryForm({
     draftTracks.some(isDraftTrackIncluded)
   const hasUnsetReleaseArtistRole = artistCredits.some(
     (credit) =>
-      artistCreditName(credit, artists).length > 0 &&
-      credit.role.trim().length === 0,
+      artistCreditName(credit, artists).length > 0 && credit.roles.length === 0,
   )
   const hasUnsetTrackArtistRole = draftTracks.some(
     (track) =>
@@ -208,7 +221,7 @@ export function ReleaseEntryForm({
       track.artistCredits.some(
         (credit) =>
           artistCreditName(credit, artists).length > 0 &&
-          credit.role.trim().length === 0,
+          credit.roles.length === 0,
       ),
   )
   const hasInvalidVariousArtistTrack = draftTracks.some(
@@ -283,6 +296,7 @@ export function ReleaseEntryForm({
         artistId: draftArtistId,
         artist: draftArtistId ? '' : artistName,
         role: '',
+        roles: [],
       },
     ])
     setDraftArtist('')
@@ -334,6 +348,7 @@ export function ReleaseEntryForm({
       medium,
       notOnLabel,
       releaseNotes,
+      releaseDate,
       status,
       tags,
       title,
@@ -353,16 +368,18 @@ export function ReleaseEntryForm({
 
     if (groups.core) {
       setTitle(draft.title)
+      if (draft.type) {
+        setType(releaseTypeValueFromCode(draft.type))
+      }
       setYear(draft.year?.toString() ?? '')
+      if (draft.releaseDate) {
+        setReleaseDate(draft.releaseDate)
+      }
     }
 
     if (groups.artists) {
       setIsVariousArtists(false)
-      setArtistCredits(
-        draft.artistCredits.map((credit, index) =>
-          editableCreditFromDiscogsCredit(credit.name, credit.role, index),
-        ),
-      )
+      setArtistCredits(groupDiscogsCredits(draft.artistCredits, 'release'))
       setDraftArtist('')
       setDraftArtistId('')
     }
@@ -382,9 +399,19 @@ export function ReleaseEntryForm({
       )
     }
 
+    if (groups.classification) {
+      setGenres(draft.genres ?? [])
+    }
+
     if (groups.tracklist) {
+      const discogsTracks = discogsDraftTrackRows(draft.tracklist)
+
+      if (discogsTracklistNeedsVariousArtists(discogsTracks, draft)) {
+        setIsVariousArtists(true)
+      }
+
       replaceDraftTracks(
-        draft.tracklist.map(
+        discogsTracks.map(
           (track, index): DraftTrackRow => ({
             id: createManualRecordId(
               'draft-track',
@@ -397,13 +424,9 @@ export function ReleaseEntryForm({
               ? durationSecondsToParts(track.durationSeconds)
               : { ...emptyDurationParts },
             inheritReleaseArtistCredits: track.artistCredits.length === 0,
-            artistCredits: track.artistCredits.map((credit, creditIndex) =>
-              editableCreditFromDiscogsCredit(
-                credit.name,
-                credit.role,
-                creditIndex,
-                `track-${index + 1}`,
-              ),
+            artistCredits: groupDiscogsCredits(
+              track.artistCredits,
+              `track-${index + 1}`,
             ),
             draftArtist: '',
             draftArtistId: '',
@@ -413,14 +436,51 @@ export function ReleaseEntryForm({
       )
     }
 
-    if (groups.externalSource) {
-      setExternalSources(
-        draft.externalSources.map((source) => ({
-          ...source,
-          appliedAt: new Date().toISOString(),
-        })),
+    setExternalSources(
+      draft.externalSources.map((source) => ({
+        ...source,
+        appliedAt: new Date().toISOString(),
+      })),
+    )
+  }
+
+  function groupDiscogsCredits(
+    credits: ReadonlyArray<{ name: string; role: string }>,
+    prefix: string,
+  ): EditableArtistCredit[] {
+    const grouped = new Map<string, EditableArtistCredit>()
+
+    credits.forEach((credit, index) => {
+      const editableCredit = editableCreditFromDiscogsCredit(
+        credit.name,
+        credit.role,
+        index,
+        prefix,
       )
-    }
+      const key =
+        editableCredit.artistId ||
+        editableCredit.artist.trim().toLowerCase() ||
+        editableCredit.id
+      const existing = grouped.get(key)
+
+      if (existing) {
+        existing.roles = [
+          ...new Set([...existing.roles, ...editableCredit.roles]),
+        ]
+        existing.role = existing.roles[0] ?? ''
+      } else {
+        grouped.set(key, editableCredit)
+      }
+    })
+
+    return [...grouped.values()]
+  }
+
+  function releaseTypeValueFromCode(code: string) {
+    return (
+      dictionaries?.releaseType.find((entry) => entry.code === code)?.name ??
+      code
+    )
   }
 
   function editableCreditFromDiscogsCredit(
@@ -434,6 +494,8 @@ export function ReleaseEntryForm({
       (artist) => artist.name.toLowerCase() === trimmedName.toLowerCase(),
     )
 
+    const roles = roleLabelsFromCode(role)
+
     return {
       id: createManualRecordId(
         `${prefix}-artist-credit`,
@@ -441,14 +503,25 @@ export function ReleaseEntryForm({
       ),
       artistId: existingArtist?.id ?? '',
       artist: existingArtist ? '' : trimmedName,
-      role: creditRoleLabelFromCode(role),
+      role: roles[0] ?? '',
+      roles,
     }
   }
 
-  function creditRoleLabelFromCode(role: string) {
-    return (
-      dictionaries.creditRole.find((entry) => entry.code === role)?.name ?? role
-    )
+  function roleLabelsFromCode(role: string) {
+    return [
+      ...new Set(
+        role
+          .split(',')
+          .map((part) => part.trim())
+          .filter(Boolean)
+          .map(
+            (part) =>
+              dictionaries.creditRole.find((entry) => entry.code === part)
+                ?.name ?? part,
+          ),
+      ),
+    ]
   }
 
   return (
@@ -462,7 +535,9 @@ export function ReleaseEntryForm({
     >
       <ReleaseCoreSection
         duplicateRelease={duplicateRelease}
-        releaseTypeOptions={releaseTypeOptions}
+        releaseDate={releaseDate}
+        releaseTypeOptions={effectiveReleaseTypeOptions}
+        setReleaseDate={setReleaseDate}
         setTitle={setTitle}
         setType={setType}
         setYear={setYear}
@@ -474,15 +549,18 @@ export function ReleaseEntryForm({
         current={{
           artists: releaseArtist,
           externalSourceCount: externalSources?.length ?? 0,
+          genres: genres.join(', '),
           labels: effectiveLabels
             .map((label) =>
               [label.label, label.catalogNumber].filter(Boolean).join(' '),
             )
             .join(', '),
+          releaseDate,
           title,
           trackCount: draftTracks.filter(isDraftTrackIncluded).length,
           year,
         }}
+        dictionaries={dictionaries}
         isOpen={isDiscogsLookupOpen}
         mode={initialRelease ? 'update' : 'create'}
         searchSeed={{
@@ -522,7 +600,7 @@ export function ReleaseEntryForm({
         setNotOnLabel={setNotOnLabel}
       />
       <ReleaseClassificationSection
-        genreOptions={genreOptions}
+        genreOptions={effectiveGenreOptions}
         genres={genres}
         setGenres={setGenres}
         setTags={setTags}
@@ -568,3 +646,60 @@ export function ReleaseEntryForm({
     </ManualEntryPanel>
   )
 }
+
+function discogsTracklistNeedsVariousArtists(
+  tracklist: ExternalMetadataReleaseDetailDto['draft']['tracklist'],
+  draft: ExternalMetadataReleaseDetailDto['draft'],
+) {
+  const releaseMainArtists = normalizedSet(
+    draft.artistCredits
+      .filter((credit) => normalizeText(credit.role) === 'mainartist')
+      .map((credit) => credit.name),
+  )
+  const releaseArtists =
+    releaseMainArtists.size > 0
+      ? releaseMainArtists
+      : normalizedSet(draft.artistCredits.map((credit) => credit.name))
+
+  return tracklist.some((track) => {
+    const trackMainArtists = normalizedSet(
+      track.artistCredits
+        .filter((credit) => normalizeText(credit.role) === 'mainartist')
+        .map((credit) => credit.name),
+    )
+
+    if (trackMainArtists.size === 0) {
+      return false
+    }
+
+    return !setsEqual(releaseArtists, trackMainArtists)
+  })
+}
+
+function normalizedSet(values: string[]) {
+  return new Set(values.map(normalizeText).filter(Boolean))
+}
+
+function normalizeText(value: string) {
+  return value.trim().toLowerCase()
+}
+
+function setsEqual(left: Set<string>, right: Set<string>) {
+  if (left.size !== right.size) {
+    return false
+  }
+
+  for (const value of left) {
+    if (!right.has(value)) {
+      return false
+    }
+  }
+
+  return true
+}
+
+function hasMainArtistRole(credit: { role: string; roles?: string[] }) {
+  return (
+    credit.roles && credit.roles.length > 0 ? credit.roles : [credit.role]
+  ).includes('Main artist')
+}
diff --git a/src/features/releases/ReleaseEntryFormTypes.ts b/src/features/releases/ReleaseEntryFormTypes.ts
index 5cf3c8d..7945eb8 100644
--- a/src/features/releases/ReleaseEntryFormTypes.ts
+++ b/src/features/releases/ReleaseEntryFormTypes.ts
@@ -34,6 +34,7 @@ export type EditableArtistCredit = {
   artistId: string
   artist: string
   role: string
+  roles: string[]
 }
 
 export type EditableReleaseLabel = {
diff --git a/src/features/releases/ReleaseTrackArtistCreditChip.tsx b/src/features/releases/ReleaseTrackArtistCreditChip.tsx
index 1a64a1f..1c5427d 100644
--- a/src/features/releases/ReleaseTrackArtistCreditChip.tsx
+++ b/src/features/releases/ReleaseTrackArtistCreditChip.tsx
@@ -1,4 +1,5 @@
 import type { ArtistRecord } from '../artists/artistsData'
+import { CreditRolePicker } from './CreditRolePicker'
 import type { EditableArtistCredit } from './ReleaseEntryFormTypes'
 import { artistCreditName } from './releaseFormHelpers'
 
@@ -10,7 +11,7 @@ type ReleaseTrackArtistCreditChipProps = {
     trackId: string,
     creditId: string,
     field: keyof Omit<EditableArtistCredit, 'id'>,
-    value: string,
+    value: string | string[],
   ) => void
   removeTrackArtist: (trackId: string, creditId: string) => void
   trackId: string
@@ -31,40 +32,52 @@ export function ReleaseTrackArtistCreditChip({
       <span className="release-artist-chip-name">
         {artistName || 'Unnamed artist'}
       </span>
-      <label className="release-artist-chip-role">
-        <span className="visually-hidden">
-          Track role for {artistName || 'artist'}
-        </span>
-        <span
-          className={
-            credit.role
-              ? 'release-artist-chip-role-face'
-              : 'release-artist-chip-role-face release-artist-chip-role-face-unset'
-          }
-          aria-hidden="true"
-        >
-          <span>{credit.role || 'Set role'}</span>
-          <span className="release-artist-chip-role-caret" />
-        </span>
-        <select
-          className="release-artist-chip-role-select"
-          aria-label={`Track role for ${artistName || 'artist'}`}
-          value={credit.role}
-          onChange={(event) =>
+      <span className="release-artist-chip-roles">
+        {credit.roles.map((role) => (
+          <span className="release-artist-role-pill" key={role}>
+            <span>{role}</span>
+            <button
+              type="button"
+              aria-label={`Remove ${role} from ${artistName || 'artist'}`}
+              onClick={() => {
+                const roles = credit.roles.filter(
+                  (currentRole) => currentRole !== role,
+                )
+                handleTrackArtistChange(trackId, credit.id, 'roles', roles)
+                handleTrackArtistChange(
+                  trackId,
+                  credit.id,
+                  'role',
+                  roles[0] ?? '',
+                )
+              }}
+            >
+              ×
+            </button>
+          </span>
+        ))}
+        <CreditRolePicker
+          addLabel={credit.roles.length > 0 ? 'Add role' : 'Set role'}
+          ariaLabel={`Track role for ${artistName || 'artist'}`}
+          options={creditRoleOptions.filter(
+            (role) => !credit.roles.includes(role),
+          )}
+          onSelect={(role) => {
+            if (!role || credit.roles.includes(role)) {
+              return
+            }
+
+            const roles = [...credit.roles, role]
+            handleTrackArtistChange(trackId, credit.id, 'roles', roles)
             handleTrackArtistChange(
               trackId,
               credit.id,
               'role',
-              event.target.value,
+              credit.role || role,
             )
-          }
-        >
-          <option value="">Set role</option>
-          {creditRoleOptions.map((role) => (
-            <option key={role}>{role}</option>
-          ))}
-        </select>
-      </label>
+          }}
+        />
+      </span>
       <button
         className="release-artist-chip-remove"
         type="button"
diff --git a/src/features/releases/ReleaseTrackDetail.tsx b/src/features/releases/ReleaseTrackDetail.tsx
index 0ec2faf..388a0c9 100644
--- a/src/features/releases/ReleaseTrackDetail.tsx
+++ b/src/features/releases/ReleaseTrackDetail.tsx
@@ -30,7 +30,7 @@ export type ReleaseTrackDetailProps = {
     trackId: string,
     creditId: string,
     field: keyof Omit<EditableArtistCredit, 'id'>,
-    value: string,
+    value: string | string[],
   ) => void
   handleTrackDraftArtistChange: (trackId: string, nextName: string) => void
   isVariousArtists: boolean
diff --git a/src/features/releases/ReleaseTracklistSection.tsx b/src/features/releases/ReleaseTracklistSection.tsx
index c9fd266..868dc04 100644
--- a/src/features/releases/ReleaseTracklistSection.tsx
+++ b/src/features/releases/ReleaseTracklistSection.tsx
@@ -33,7 +33,7 @@ type ReleaseTracklistSectionProps = {
     trackId: string,
     creditId: string,
     field: keyof Omit<EditableArtistCredit, 'id'>,
-    value: string,
+    value: string | string[],
   ) => void
   handleTrackDraftArtistChange: (trackId: string, nextName: string) => void
   isVariousArtists: boolean
diff --git a/src/features/releases/discogsReleaseTrackRows.test.ts b/src/features/releases/discogsReleaseTrackRows.test.ts
new file mode 100644
index 0000000..41a9ea8
--- /dev/null
+++ b/src/features/releases/discogsReleaseTrackRows.test.ts
@@ -0,0 +1,32 @@
+import { describe, expect, it } from 'vitest'
+import { discogsDraftTrackRows } from './discogsReleaseTrackRows'
+
+describe('discogs release track rows', () => {
+  it('drops Discogs heading rows and renumbers remaining tracks for DiscWeave', () => {
+    expect(
+      discogsDraftTrackRows([
+        {
+          title: 'Orbit Compact Disc',
+          position: 1,
+          durationSeconds: null,
+          artistCredits: [],
+        },
+        {
+          title: 'Little Fluffy Clouds',
+          position: 2,
+          durationSeconds: 269,
+          artistCredits: [],
+        },
+        {
+          title: 'Earth (Gaia)',
+          position: 3,
+          durationSeconds: 580,
+          artistCredits: [],
+        },
+      ]),
+    ).toMatchObject([
+      { title: 'Little Fluffy Clouds', position: 1 },
+      { title: 'Earth (Gaia)', position: 2 },
+    ])
+  })
+})
diff --git a/src/features/releases/discogsReleaseTrackRows.ts b/src/features/releases/discogsReleaseTrackRows.ts
new file mode 100644
index 0000000..508c0af
--- /dev/null
+++ b/src/features/releases/discogsReleaseTrackRows.ts
@@ -0,0 +1,26 @@
+import type { ExternalMetadataReleaseDraftTrackDto } from '../catalog/catalogApi'
+
+export function discogsDraftTrackRows(
+  tracks: ExternalMetadataReleaseDraftTrackDto[],
+) {
+  return tracks
+    .filter((track) => !isDiscogsNonTrackHeadingRow(track))
+    .map((track, index) => ({
+      ...track,
+      position: index + 1,
+    }))
+}
+
+function isDiscogsNonTrackHeadingRow(
+  track: ExternalMetadataReleaseDraftTrackDto,
+) {
+  const title = normalizeText(track.title)
+  return (
+    /^(disc|disk|cd|side|part)\s*[a-z0-9]*$/.test(title) ||
+    /(?:compact\s+disc|bonus\s+disc|disc\s+\d|cd\s+\d)$/.test(title)
+  )
+}
+
+function normalizeText(value: string) {
+  return value.trim().toLowerCase()
+}
diff --git a/src/features/releases/release-form.css b/src/features/releases/release-form.css
index cec6192..4b1cff2 100644
--- a/src/features/releases/release-form.css
+++ b/src/features/releases/release-form.css
@@ -38,17 +38,38 @@
 }
 
 .discogs-release-lookup {
+  max-width: 100%;
+  min-width: 0;
   border: 1px solid var(--color-border);
   border-radius: var(--radius-sm);
   background: #fbfcfa;
   padding: 12px;
 }
 
+.discogs-release-lookup * {
+  min-width: 0;
+}
+
+.discogs-release-lookup .button {
+  max-width: 100%;
+  flex-wrap: wrap;
+  height: auto;
+  overflow-wrap: anywhere;
+  text-align: center;
+}
+
+.discogs-release-lookup .button span {
+  min-width: 0;
+  overflow-wrap: anywhere;
+  white-space: normal;
+}
+
 .discogs-search-form {
   display: grid;
-  grid-template-columns: repeat(3, minmax(0, 1fr)) auto;
+  grid-template-columns: repeat(5, minmax(0, 1fr)) auto;
   gap: 8px;
   align-items: end;
+  min-width: 0;
 }
 
 .discogs-search-form label {
@@ -62,6 +83,17 @@
   font-weight: 650;
 }
 
+.discogs-apply-status {
+  margin: 0;
+  border: 1px solid #c8d4c4;
+  border-radius: var(--radius-sm);
+  background: #eef3eb;
+  color: #405f42;
+  font-size: 12px;
+  font-weight: 700;
+  padding: 8px 10px;
+}
+
 .discogs-candidate-list,
 .discogs-review-panel {
   display: grid;
@@ -71,17 +103,29 @@
 
 .discogs-candidate {
   display: grid;
-  grid-template-columns: minmax(0, 1fr) auto;
   gap: 12px;
-  align-items: start;
+  min-width: 0;
   border: 1px solid var(--color-border);
   border-radius: var(--radius-sm);
   background: var(--color-surface);
   padding: 10px;
 }
 
+.discogs-candidate.is-selected {
+  border-color: #aeb6ad;
+  box-shadow: 0 0 0 1px rgba(81, 111, 82, 0.12);
+}
+
+.discogs-candidate-summary {
+  display: grid;
+  grid-template-columns: minmax(0, 1fr) auto;
+  gap: 12px;
+  align-items: start;
+  min-width: 0;
+}
+
 .discogs-candidate strong,
-.discogs-review-column h4 {
+.discogs-impact-row strong {
   color: var(--color-heading);
   font-size: 13px;
 }
@@ -96,6 +140,7 @@
   display: grid;
   justify-items: end;
   gap: 8px;
+  min-width: 0;
 }
 
 .discogs-candidate-actions .detail-link {
@@ -104,42 +149,35 @@
 }
 
 .discogs-review-panel {
-  border-top: 1px solid var(--color-border);
-  padding-top: 10px;
-}
-
-.discogs-review-grid {
   display: grid;
-  grid-template-columns: repeat(2, minmax(0, 1fr));
   gap: 10px;
+  border-top: 1px dashed var(--color-border);
+  padding-top: 10px;
 }
 
-.discogs-review-column {
+.discogs-impact-list {
   display: grid;
-  gap: 7px;
-  min-width: 0;
-  border: 1px solid var(--color-border);
-  border-radius: var(--radius-sm);
-  background: var(--color-surface);
-  padding: 10px;
+  gap: 0;
 }
 
-.discogs-review-column h4 {
-  margin: 0;
-}
-
-.discogs-review-column dl {
+.discogs-impact-row {
   display: grid;
-  gap: 7px;
-  margin: 0;
+  grid-template-columns:
+    minmax(120px, 150px) minmax(84px, 110px) minmax(0, 1fr)
+    minmax(0, 1.6fr);
+  gap: 12px;
+  align-items: start;
+  min-width: 0;
+  border-bottom: 1px solid var(--color-border);
+  padding: 9px 0;
 }
 
-.discogs-review-column dl div {
-  display: grid;
-  gap: 2px;
+.discogs-impact-row:last-child {
+  border-bottom: 0;
 }
 
-.discogs-review-column dt {
+.discogs-impact-group,
+.discogs-impact-value > span {
   color: var(--color-soft);
   font-size: 10px;
   font-weight: 780;
@@ -147,14 +185,109 @@
   text-transform: uppercase;
 }
 
-.discogs-review-column dd {
+.discogs-impact-value {
+  display: grid;
+  gap: 2px;
   min-width: 0;
-  margin: 0;
-  overflow-wrap: anywhere;
-  color: var(--color-heading);
+}
+
+.discogs-impact-value strong {
+  min-width: 0;
+  overflow-wrap: break-word;
   font-size: 12px;
 }
 
+.discogs-impact-value strong {
+  color: var(--color-heading);
+  font-weight: 650;
+}
+
+.discogs-impact-detail {
+  display: grid;
+  gap: 8px;
+  margin-top: 8px;
+  min-width: 0;
+}
+
+.discogs-credit-impact-list,
+.discogs-track-impact-list {
+  display: grid;
+  gap: 6px;
+}
+
+.discogs-credit-impact-row {
+  display: grid;
+  grid-template-columns: minmax(130px, 1fr) auto;
+  gap: 8px;
+  align-items: center;
+  min-width: 0;
+  border-top: 1px solid var(--color-border);
+  padding-top: 6px;
+}
+
+.discogs-credit-impact-row:first-child {
+  border-top: 0;
+  padding-top: 0;
+}
+
+.discogs-credit-impact-row .badge {
+  justify-self: start;
+}
+
+.discogs-credit-role-list {
+  display: flex;
+  flex-wrap: wrap;
+  justify-content: flex-end;
+  gap: 4px;
+}
+
+.discogs-track-impact-row {
+  display: grid;
+  grid-template-columns: 34px minmax(0, 1fr);
+  gap: 8px;
+  min-width: 0;
+  border-top: 1px solid var(--color-border);
+  padding-top: 7px;
+}
+
+.discogs-track-impact-row:first-child {
+  border-top: 0;
+  padding-top: 0;
+}
+
+.discogs-track-impact-position {
+  display: inline-grid;
+  width: 28px;
+  height: 24px;
+  place-items: center;
+  border: 1px solid var(--color-border);
+  border-radius: var(--radius-sm);
+  background: #f8faf6;
+  color: var(--color-muted);
+  font-size: 11px;
+  font-weight: 760;
+}
+
+.discogs-track-impact-row p,
+.discogs-impact-empty,
+.discogs-impact-warning {
+  margin: 2px 0 0;
+  color: var(--color-muted);
+  font-size: 11px;
+}
+
+.discogs-impact-warning {
+  border: 1px solid #ead19a;
+  border-radius: var(--radius-sm);
+  background: #fbf4df;
+  color: #7a5618;
+  padding: 7px 8px;
+}
+
+.discogs-track-toggle {
+  justify-self: start;
+}
+
 .discogs-apply-groups {
   display: flex;
   flex-wrap: wrap;
@@ -190,6 +323,10 @@
   grid-column: 1 / -1;
 }
 
+.release-core-type-field {
+  grid-column: 1 / -1;
+}
+
 .release-owned-copy-grid {
   grid-template-columns: repeat(2, minmax(160px, 1fr));
 }
@@ -239,45 +376,48 @@
 .release-artist-chip-list {
   display: flex;
   flex-wrap: wrap;
-  gap: 6px;
+  gap: 8px;
   min-width: 0;
 }
 
 .release-artist-chip {
-  display: inline-flex;
-  align-items: center;
-  gap: 8px;
-  max-width: 100%;
+  display: flex;
+  align-items: flex-start;
+  gap: 12px;
+  width: min(100%, 560px);
   min-width: 0;
   border: 1px solid #c8d4c4;
-  border-radius: 999px;
+  border-radius: var(--radius-md);
   background: #eef3eb;
-  padding: 5px 6px 5px 14px;
+  padding: 8px 8px 8px 12px;
 }
 
 .release-artist-chip-name {
+  flex: 0 0 160px;
   min-width: 0;
   overflow: hidden;
   color: var(--color-heading);
   font-size: 13px;
   font-weight: 700;
+  line-height: 1.35;
+  padding-top: 5px;
   text-overflow: ellipsis;
   white-space: nowrap;
 }
 
-.release-artist-chip-role {
-  position: relative;
-  display: inline-grid;
-  min-height: 28px;
-  flex: 0 0 auto;
-  align-items: center;
+.release-artist-chip-roles {
+  display: flex;
+  flex: 1 1 auto;
+  flex-wrap: wrap;
+  gap: 6px;
+  min-width: 0;
 }
 
-.release-artist-chip-role-face {
+.release-artist-role-pill {
   display: inline-flex;
-  min-height: 26px;
   align-items: center;
-  gap: 7px;
+  gap: 6px;
+  min-height: 26px;
   border: 1px solid #bdc9b9;
   border-radius: 999px;
   background-color: #f8faf6;
@@ -285,11 +425,11 @@
   font-size: 12px;
   font-weight: 700;
   line-height: 1;
-  padding: 0 9px 0 10px;
+  padding: 0 4px 0 10px;
   white-space: nowrap;
 }
 
-.manual-entry-grid .release-artist-chip-role-face span {
+.release-artist-role-pill span {
   color: inherit;
   font-size: inherit;
   font-weight: inherit;
@@ -297,32 +437,117 @@
   text-transform: none;
 }
 
-.release-artist-chip-role-face-unset {
-  border-color: #9da996;
+.release-artist-role-pill button {
+  display: grid;
+  width: 18px;
+  height: 18px;
+  place-items: center;
+  border: 0;
+  border-radius: 999px;
+  background: transparent;
   color: var(--color-muted);
+  cursor: pointer;
+  font-size: 14px;
+  line-height: 1;
+}
+
+.release-artist-role-pill button:hover {
+  background: #dfe8dc;
+  color: var(--color-heading);
+}
+
+.release-artist-add-role {
+  position: relative;
+  display: inline-flex;
+  align-items: center;
+  min-height: 26px;
+  border: 1px dashed #9da996;
+  border-radius: 999px;
+  background: #f8faf6;
+  color: var(--color-muted);
+  font-size: 12px;
+  font-weight: 700;
+  line-height: 1;
+  padding: 0 10px;
+  white-space: nowrap;
 }
 
-.release-artist-chip-role-caret {
-  width: 6px;
-  height: 6px;
-  border-right: 1.5px solid var(--color-muted);
-  border-bottom: 1.5px solid var(--color-muted);
-  transform: translateY(-1px) rotate(45deg);
+.release-artist-add-role[open] {
+  border-style: solid;
+  color: var(--color-heading);
+  z-index: 10;
 }
 
-.release-artist-chip-role-select {
+.release-artist-add-role summary {
+  display: inline-flex;
+  align-items: center;
+  min-height: 24px;
+  cursor: pointer;
+  list-style: none;
+}
+
+.release-artist-add-role summary::-webkit-details-marker {
+  display: none;
+}
+
+.release-artist-add-role-empty,
+.release-artist-add-role-disabled {
+  border-style: solid;
+}
+
+.release-artist-add-role-disabled {
+  cursor: default;
+  opacity: 0.65;
+}
+
+.release-artist-role-menu {
   position: absolute;
-  inset: 0;
+  top: calc(100% + 6px);
+  left: 0;
+  z-index: 30;
+  display: grid;
+  width: max-content;
+  min-width: 190px;
+  max-width: min(320px, calc(100vw - 48px));
+  max-height: 240px;
+  overflow-y: auto;
+  overscroll-behavior: contain;
+  border: 1px solid #4f594d;
+  border-radius: var(--radius-md);
+  background: #f8faf6;
+  box-shadow: 0 12px 28px rgba(23, 28, 22, 0.22);
+  padding: 6px;
+}
+
+.release-artist-role-menu button {
+  display: block;
   width: 100%;
-  height: 100%;
-  min-height: 0;
-  appearance: none;
   border: 0;
-  opacity: 0;
+  border-radius: var(--radius-sm);
+  background: transparent;
+  color: var(--color-heading);
   cursor: pointer;
+  font-size: 13px;
+  font-weight: 700;
+  line-height: 1.25;
+  padding: 8px 10px;
+  text-align: left;
+  white-space: normal;
+}
+
+.release-artist-role-menu button:hover,
+.release-artist-role-menu button:focus-visible {
+  background: #dfe8dc;
+  outline: none;
+}
+
+.release-artist-add-role:hover {
+  border-style: solid;
+  color: var(--color-heading);
 }
 
-.release-artist-chip-role:focus-within .release-artist-chip-role-face {
+.release-artist-add-role summary:focus-visible,
+.release-artist-role-pill button:focus-visible {
   outline: 3px solid rgba(81, 111, 82, 0.18);
   outline-offset: 2px;
 }
@@ -492,8 +717,9 @@
     justify-self: start;
   }
 
-  .discogs-candidate,
-  .discogs-review-grid {
+  .discogs-candidate-summary,
+  .discogs-impact-row,
+  .discogs-credit-impact-row {
     grid-template-columns: 1fr;
   }
 
@@ -511,6 +737,18 @@
     grid-template-columns: 1fr;
   }
 
+  .discogs-search-form > .button,
+  .discogs-candidate-actions .button {
+    width: 100%;
+    min-width: 0;
+    white-space: normal;
+  }
+
+  .discogs-candidate-actions {
+    justify-items: stretch;
+    width: 100%;
+  }
+
   .release-form-section-header,
   .release-section-actions {
     align-items: stretch;
diff --git a/src/features/releases/releaseFormHelpers.ts b/src/features/releases/releaseFormHelpers.ts
index 3e21597..132eb9a 100644
--- a/src/features/releases/releaseFormHelpers.ts
+++ b/src/features/releases/releaseFormHelpers.ts
@@ -74,6 +74,10 @@ export function draftTracksFromRelease(
           artistId: credit.artistId ?? '',
           artist: credit.artistId ? '' : credit.artist,
           role: credit.role,
+          roles:
+            credit.roles && credit.roles.length > 0
+              ? credit.roles
+              : [credit.role],
         })),
         draftArtist: '',
         draftArtistId: '',
@@ -223,6 +227,8 @@ export function editableArtistCreditFromReleaseCredit(
     artistId: credit.artistId ?? '',
     artist: credit.artistId ? '' : credit.artist,
     role: credit.role,
+    roles:
+      credit.roles && credit.roles.length > 0 ? credit.roles : [credit.role],
   }
 }
 
@@ -232,10 +238,13 @@ export function releaseArtistCreditFromEditableCredit(
 ): ReleaseArtistCredit {
   const existingArtist = artists.find((artist) => artist.id === credit.artistId)
 
+  const roles = credit.roles.length > 0 ? credit.roles : [credit.role]
+
   return {
     artistId: existingArtist?.id,
     artist: existingArtist?.name ?? credit.artist.trim(),
-    role: toCreditRole(credit.role),
+    role: toCreditRole(roles[0]),
+    roles: roles.map(toCreditRole),
   }
 }
 
diff --git a/src/features/releases/releaseSubmit.ts b/src/features/releases/releaseSubmit.ts
index 7528b33..0db65dc 100644
--- a/src/features/releases/releaseSubmit.ts
+++ b/src/features/releases/releaseSubmit.ts
@@ -41,6 +41,7 @@ type BuildReleaseSubmissionInput = {
   medium: string
   notOnLabel: boolean
   releaseNotes: string
+  releaseDate: string
   status: OwnedCopy['status'] | ''
   tags: string
   title: string
@@ -63,6 +64,7 @@ export function buildReleaseSubmission({
   medium,
   notOnLabel,
   releaseNotes,
+  releaseDate,
   status,
   tags,
   title,
@@ -90,16 +92,14 @@ export function buildReleaseSubmission({
   const displayArtist = isVariousArtists
     ? 'Various Artists'
     : resolvedArtistCredits
-        .filter((credit) => credit.role === 'Main artist')
+        .filter(hasMainArtistRole)
         .map((credit) => credit.artist)
         .join(', ') ||
       resolvedArtistCredits.map((credit) => credit.artist).join(', ')
   const displayLabel = notOnLabel
     ? 'Not On Label'
     : resolvedLabels.map(releaseLabelDisplay).join(', ') || 'Unknown label'
-  const firstMainArtist = resolvedArtistCredits.find(
-    (credit) => credit.role === 'Main artist',
-  )
+  const firstMainArtist = resolvedArtistCredits.find(hasMainArtistRole)
   const copyMedium = medium.trim()
   const copyStatus = status
   const releaseId =
@@ -128,6 +128,7 @@ export function buildReleaseSubmission({
     artistCredits: resolvedArtistCredits,
     type,
     year: textOrFallback(year, 'Unknown year'),
+    releaseDate: releaseDate.trim() || undefined,
     label: displayLabel,
     labels: resolvedLabels,
     isVariousArtists,
@@ -183,20 +184,20 @@ export function buildReleaseSubmission({
           const existingArtist = artists.find(
             (artist) => artist.id === credit.artistId,
           )
+          const roles = credit.roles.length > 0 ? credit.roles : [credit.role]
 
           return {
             artistId: existingArtist?.id,
             artist: existingArtist?.name ?? credit.artist.trim(),
-            role: toCreditRole(credit.role),
+            role: toCreditRole(roles[0]),
+            roles: roles.map(toCreditRole),
           }
         })
         .filter((credit) => credit.artist.length > 0)
       const effectiveTrackCredits =
         !track.inheritReleaseArtistCredits && resolvedTrackCredits.length > 0
           ? resolvedTrackCredits
-          : resolvedArtistCredits.filter(
-              (credit) => credit.role === 'Main artist',
-            )
+          : resolvedArtistCredits.filter(hasMainArtistRole)
       const trackArtist =
         effectiveTrackCredits.map((credit) => credit.artist).join(', ') ||
         displayArtist
@@ -226,6 +227,7 @@ export function buildReleaseSubmission({
         credits: effectiveTrackCredits.map((credit) => ({
           artistId: credit.artistId,
           role: credit.role,
+          roles: credit.roles,
           artist: credit.artist,
           scope: '',
         })),
@@ -266,3 +268,9 @@ export function buildReleaseSubmission({
 
   return { release, submittedTracks }
 }
+
+function hasMainArtistRole(credit: ReleaseArtistCredit) {
+  return (
+    credit.roles && credit.roles.length > 0 ? credit.roles : [credit.role]
+  ).includes('Main artist')
+}
diff --git a/src/features/releases/releasesData.ts b/src/features/releases/releasesData.ts
index 6ec999c..0f58ca4 100644
--- a/src/features/releases/releasesData.ts
+++ b/src/features/releases/releasesData.ts
@@ -19,6 +19,7 @@ export type ReleaseArtistCredit = {
   artistId?: string
   artist: string
   role: CreditRole
+  roles?: CreditRole[]
 }
 
 export type ReleaseLabel = {
diff --git a/src/features/releases/useReleaseTrackDrafts.ts b/src/features/releases/useReleaseTrackDrafts.ts
index a1dabd1..47fa099 100644
--- a/src/features/releases/useReleaseTrackDrafts.ts
+++ b/src/features/releases/useReleaseTrackDrafts.ts
@@ -135,6 +135,10 @@ export function useReleaseTrackDrafts({
                 artistId: credit.artistId ?? '',
                 artist: credit.artistId ? '' : credit.artist,
                 role: credit.role,
+                roles:
+                  credit.roles && credit.roles.length > 0
+                    ? credit.roles
+                    : [credit.role],
               })),
               draftArtist: '',
               draftArtistId: '',
@@ -188,7 +192,7 @@ export function useReleaseTrackDrafts({
     trackId: string,
     creditId: string,
     field: keyof Omit<EditableArtistCredit, 'id'>,
-    value: string,
+    value: string | string[],
   ) {
     setDraftTracks((currentTracks) =>
       currentTracks.map((track) =>
@@ -196,7 +200,12 @@ export function useReleaseTrackDrafts({
           ? {
               ...track,
               artistCredits: track.artistCredits.map((credit) =>
-                credit.id === creditId ? { ...credit, [field]: value } : credit,
+                credit.id === creditId
+                  ? {
+                      ...credit,
+                      [field]: value,
+                    }
+                  : credit,
               ),
             }
           : track,
@@ -247,6 +256,7 @@ export function useReleaseTrackDrafts({
               artistId: track.draftArtistId,
               artist: track.draftArtistId ? '' : artistName,
               role: '',
+              roles: [],
             },
           ],
         }
diff --git a/src/features/tracks/DiscogsTrackLookupPanel.tsx b/src/features/tracks/DiscogsTrackLookupPanel.tsx
new file mode 100644
index 0000000..ea4197b
--- /dev/null
+++ b/src/features/tracks/DiscogsTrackLookupPanel.tsx
@@ -0,0 +1,594 @@
+import { Search } from 'lucide-react'
+import { type ReactNode, useEffect, useRef, useState } from 'react'
+import {
+  CatalogApiError,
+  getDiscogsTrack,
+  searchDiscogsTracks,
+  type CatalogDictionaries,
+  type ExternalMetadataReleaseDraftArtistCreditDto,
+  type ExternalMetadataTrackCandidateDto,
+  type ExternalMetadataTrackDetailDto,
+} from '../catalog/catalogApi'
+import { formatDurationSeconds } from '../catalog/durationFormat'
+
+export type DiscogsTrackApplyGroups = {
+  core: boolean
+  credits: boolean
+}
+
+export type DiscogsTrackSearchSeed = {
+  artist: string
+  catalogNumber: string
+  releaseTitle: string
+  title: string
+  year: string
+}
+
+export type DiscogsCurrentTrack = {
+  artists: string
+  duration: string
+  title: string
+}
+
+type DiscogsTrackLookupPanelProps = {
+  current: DiscogsCurrentTrack
+  dictionaries: CatalogDictionaries
+  isOpen: boolean
+  mode: 'create' | 'update'
+  searchSeed: DiscogsTrackSearchSeed
+  onApplyDraft: (
+    detail: ExternalMetadataTrackDetailDto,
+    groups: DiscogsTrackApplyGroups,
+  ) => void
+  onOpenChange: (isOpen: boolean) => void
+}
+
+const emptyGroups: DiscogsTrackApplyGroups = {
+  core: false,
+  credits: false,
+}
+
+export function DiscogsTrackLookupPanel({
+  current,
+  dictionaries,
+  isOpen,
+  mode,
+  searchSeed,
+  onApplyDraft,
+  onOpenChange,
+}: DiscogsTrackLookupPanelProps) {
+  const [title, setTitle] = useState(searchSeed.title)
+  const [artist, setArtist] = useState(searchSeed.artist)
+  const [releaseTitle, setReleaseTitle] = useState(searchSeed.releaseTitle)
+  const [year, setYear] = useState(searchSeed.year)
+  const [catalogNumber, setCatalogNumber] = useState(searchSeed.catalogNumber)
+  const [status, setStatus] = useState('')
+  const [appliedStatus, setAppliedStatus] = useState('')
+  const [candidates, setCandidates] = useState<
+    ExternalMetadataTrackCandidateDto[]
+  >([])
+  const [selectedDetail, setSelectedDetail] =
+    useState<ExternalMetadataTrackDetailDto | null>(null)
+  const [applyGroups, setApplyGroups] = useState<DiscogsTrackApplyGroups>(() =>
+    defaultGroups(mode),
+  )
+  const wasOpen = useRef(false)
+
+  useEffect(() => {
+    if (isOpen && !wasOpen.current) {
+      setTitle(searchSeed.title)
+      setArtist(searchSeed.artist)
+      setReleaseTitle(searchSeed.releaseTitle)
+      setYear(searchSeed.year)
+      setCatalogNumber(searchSeed.catalogNumber)
+    }
+
+    wasOpen.current = isOpen
+  }, [isOpen, searchSeed])
+
+  async function handleSearch() {
+    setStatus('Searching Discogs track candidates.')
+    setAppliedStatus('')
+    setSelectedDetail(null)
+
+    try {
+      const result = await searchDiscogsTracks({
+        title,
+        artist,
+        releaseTitle,
+        year,
+        catalogNumber,
+        limit: 25,
+      })
+
+      setCandidates(result.items)
+      setStatus(
+        result.items.length > 0
+          ? `${result.total} candidate${result.total === 1 ? '' : 's'} found.`
+          : 'No Discogs track candidates found.',
+      )
+    } catch (error) {
+      setCandidates([])
+      setStatus(externalMetadataErrorMessage(error))
+    }
+  }
+
+  async function reviewCandidate(candidate: ExternalMetadataTrackCandidateDto) {
+    setStatus(`Loading Discogs detail for ${candidate.title}.`)
+    setAppliedStatus('')
+
+    try {
+      const detail = await getDiscogsTrack(candidate.source.externalId)
+      setSelectedDetail(detail)
+      setApplyGroups(defaultGroups(mode))
+      setStatus(`Review loaded for ${detail.title}.`)
+    } catch (error) {
+      setSelectedDetail(null)
+      setStatus(externalMetadataErrorMessage(error))
+    }
+  }
+
+  function updateApplyGroup(
+    group: keyof DiscogsTrackApplyGroups,
+    checked: boolean,
+  ) {
+    setApplyGroups((groups) => ({ ...groups, [group]: checked }))
+  }
+
+  function handleApplyDraft(
+    detail: ExternalMetadataTrackDetailDto,
+    groups: DiscogsTrackApplyGroups,
+  ) {
+    onApplyDraft(detail, groups)
+    setAppliedStatus(
+      `Applied Discogs ${appliedGroupLabel(groups)} to the form. Save record to persist changes.`,
+    )
+    setCandidates([])
+    setSelectedDetail(null)
+    onOpenChange(false)
+  }
+
+  const hasSelectedGroup = Object.values(applyGroups).some(Boolean)
+
+  return (
+    <section
+      className="manual-entry-wide release-form-section discogs-release-lookup discogs-track-lookup"
+      aria-label="Discogs track lookup"
+      role="region"
+    >
+      <div className="release-form-section-header">
+        <div>
+          <h3>Discogs</h3>
+          <p>Search track candidates and review fields before applying.</p>
+        </div>
+        <button
+          className="button button-secondary button-compact"
+          type="button"
+          onClick={() => onOpenChange(!isOpen)}
+        >
+          <Search size={14} aria-hidden="true" />
+          {isOpen ? 'Hide Discogs' : 'Search Discogs'}
+        </button>
+      </div>
+
+      {isOpen ? (
+        <>
+          <div className="discogs-search-form">
+            <LookupInput
+              label="Discogs track title"
+              value={title}
+              onChange={setTitle}
+            />
+            <LookupInput
+              label="Discogs artist"
+              value={artist}
+              onChange={setArtist}
+            />
+            <LookupInput
+              label="Discogs release title"
+              value={releaseTitle}
+              onChange={setReleaseTitle}
+            />
+            <LookupInput label="Discogs year" value={year} onChange={setYear} />
+            <LookupInput
+              label="Discogs catalog number"
+              value={catalogNumber}
+              onChange={setCatalogNumber}
+            />
+            <button
+              className="button button-secondary button-compact"
+              type="button"
+              onClick={() => {
+                void handleSearch()
+              }}
+            >
+              <Search size={14} aria-hidden="true" />
+              <span>Search Discogs tracks</span>
+            </button>
+          </div>
+
+          {status ? (
+            <p className="discogs-lookup-status" role="status">
+              {status}
+            </p>
+          ) : null}
+
+          {candidates.length > 0 ? (
+            <div className="discogs-candidate-list">
+              {candidates.map((candidate) => {
+                const isSelected =
+                  selectedDetail?.source.externalId ===
+                  candidate.source.externalId
+
+                return (
+                  <CandidateCard
+                    applyGroups={applyGroups}
+                    candidate={candidate}
+                    current={current}
+                    detail={isSelected ? selectedDetail : null}
+                    dictionaries={dictionaries}
+                    hasSelectedGroup={hasSelectedGroup}
+                    isSelected={isSelected}
+                    key={candidate.source.externalId}
+                    onApplyDraft={handleApplyDraft}
+                    onReview={() => {
+                      void reviewCandidate(candidate)
+                    }}
+                    onUpdateApplyGroup={updateApplyGroup}
+                  />
+                )
+              })}
+            </div>
+          ) : null}
+        </>
+      ) : (
+        <p
+          className={
+            appliedStatus ? 'discogs-apply-status' : 'release-section-note'
+          }
+          role={appliedStatus ? 'status' : undefined}
+        >
+          {appliedStatus ||
+            'Discogs lookup is optional and never saves data until the track form is submitted.'}
+        </p>
+      )}
+    </section>
+  )
+}
+
+function CandidateCard({
+  applyGroups,
+  candidate,
+  current,
+  detail,
+  dictionaries,
+  hasSelectedGroup,
+  isSelected,
+  onApplyDraft,
+  onReview,
+  onUpdateApplyGroup,
+}: {
+  applyGroups: DiscogsTrackApplyGroups
+  candidate: ExternalMetadataTrackCandidateDto
+  current: DiscogsCurrentTrack
+  detail: ExternalMetadataTrackDetailDto | null
+  dictionaries: CatalogDictionaries
+  hasSelectedGroup: boolean
+  isSelected: boolean
+  onApplyDraft: (
+    detail: ExternalMetadataTrackDetailDto,
+    groups: DiscogsTrackApplyGroups,
+  ) => void
+  onReview: () => void
+  onUpdateApplyGroup: (
+    group: keyof DiscogsTrackApplyGroups,
+    checked: boolean,
+  ) => void
+}) {
+  return (
+    <article className={`discogs-candidate${isSelected ? ' is-selected' : ''}`}>
+      <div className="discogs-candidate-summary">
+        <div>
+          <strong>{candidate.title}</strong>
+          <p>
+            {candidate.position ?? 'Unnumbered'} ·{' '}
+            {formatDurationSeconds(candidate.durationSeconds)}
+          </p>
+          <p>{joinOrEmpty(candidate.artists)}</p>
+          <p>
+            {candidate.release.title} ·{' '}
+            {candidate.release.year ?? 'Unknown year'} ·{' '}
+            {joinOrEmpty(candidate.release.artists)}
+          </p>
+          <p>{candidate.source.attribution}</p>
+        </div>
+        <div className="discogs-candidate-actions">
+          <a
+            className="detail-link"
+            href={candidate.source.sourceUrl}
+            target="_blank"
+            rel="noreferrer"
+          >
+            Open candidate Discogs track source
+          </a>
+          <button
+            className="button button-secondary button-compact"
+            type="button"
+            onClick={onReview}
+          >
+            <span>Review {candidate.title}</span>
+          </button>
+        </div>
+      </div>
+
+      {detail ? (
+        <DiscogsTrackCandidateReview
+          applyGroups={applyGroups}
+          current={current}
+          detail={detail}
+          dictionaries={dictionaries}
+          hasSelectedGroup={hasSelectedGroup}
+          onApplyDraft={onApplyDraft}
+          onUpdateApplyGroup={onUpdateApplyGroup}
+        />
+      ) : null}
+    </article>
+  )
+}
+
+function DiscogsTrackCandidateReview({
+  applyGroups,
+  current,
+  detail,
+  dictionaries,
+  hasSelectedGroup,
+  onApplyDraft,
+  onUpdateApplyGroup,
+}: {
+  applyGroups: DiscogsTrackApplyGroups
+  current: DiscogsCurrentTrack
+  detail: ExternalMetadataTrackDetailDto
+  dictionaries: CatalogDictionaries
+  hasSelectedGroup: boolean
+  onApplyDraft: (
+    detail: ExternalMetadataTrackDetailDto,
+    groups: DiscogsTrackApplyGroups,
+  ) => void
+  onUpdateApplyGroup: (
+    group: keyof DiscogsTrackApplyGroups,
+    checked: boolean,
+  ) => void
+}) {
+  return (
+    <div className="discogs-review-panel">
+      <div className="release-form-section-header">
+        <div>
+          <h3>Review Discogs track</h3>
+          <p>
+            {detail.source.attribution}{' '}
+            <a
+              className="detail-link"
+              href={detail.source.sourceUrl}
+              target="_blank"
+              rel="noreferrer"
+            >
+              Open Discogs track source
+            </a>
+          </p>
+        </div>
+      </div>
+
+      <div className="discogs-impact-list">
+        <ImpactRow
+          checked={applyGroups.core}
+          currentValue={trackCoreLabel(current.title, current.duration)}
+          group="Core"
+          nextValue={trackCoreLabel(
+            detail.draft.title,
+            formatDurationSeconds(detail.draft.durationSeconds),
+          )}
+          onChange={(checked) => onUpdateApplyGroup('core', checked)}
+        />
+        <ImpactRow
+          checked={applyGroups.credits}
+          currentValue={current.artists || 'Not recorded'}
+          group="Credits"
+          nextValue={`${detail.draft.artistCredits.length} Discogs credits`}
+          onChange={(checked) => onUpdateApplyGroup('credits', checked)}
+        >
+          <CreditImpactList
+            credits={detail.draft.artistCredits}
+            dictionaries={dictionaries}
+          />
+        </ImpactRow>
+      </div>
+
+      <button
+        className="button button-primary button-compact"
+        type="button"
+        disabled={!hasSelectedGroup}
+        onClick={() => onApplyDraft(detail, applyGroups)}
+      >
+        Apply selected Discogs fields
+      </button>
+    </div>
+  )
+}
+
+function ImpactRow({
+  checked,
+  children,
+  currentValue,
+  group,
+  nextValue,
+  onChange,
+}: {
+  checked: boolean
+  children?: ReactNode
+  currentValue: string
+  group: string
+  nextValue: string
+  onChange: (checked: boolean) => void
+}) {
+  return (
+    <div className="discogs-impact-row">
+      <ApplyGroup
+        checked={checked}
+        label={`Apply ${group}`}
+        onChange={onChange}
+      />
+      <div className="discogs-impact-group">{group}</div>
+      <div className="discogs-impact-value">
+        <span>Current</span>
+        <strong>{currentValue}</strong>
+      </div>
+      <div className="discogs-impact-value">
+        <span>Discogs</span>
+        <strong>{nextValue}</strong>
+        {children ? (
+          <div className="discogs-impact-detail">{children}</div>
+        ) : null}
+      </div>
+    </div>
+  )
+}
+
+function CreditImpactList({
+  credits,
+  dictionaries,
+}: {
+  credits: ExternalMetadataReleaseDraftArtistCreditDto[]
+  dictionaries: CatalogDictionaries
+}) {
+  if (credits.length === 0) {
+    return <p className="discogs-impact-empty">No Discogs artist credits.</p>
+  }
+
+  return (
+    <div className="discogs-credit-impact-list">
+      {credits.map((credit, index) => (
+        <CreditImpactRow
+          credit={credit}
+          dictionaries={dictionaries}
+          key={`${credit.name}-${credit.role}-${index}`}
+        />
+      ))}
+    </div>
+  )
+}
+
+function CreditImpactRow({
+  credit,
+  dictionaries,
+}: {
+  credit: ExternalMetadataReleaseDraftArtistCreditDto
+  dictionaries: CatalogDictionaries
+}) {
+  const role = roleLabelFromCode(credit.role, dictionaries)
+
+  return (
+    <div className="discogs-credit-impact-row">
+      <strong>{credit.name}</strong>
+      <span className="badge badge-credit">{role}</span>
+    </div>
+  )
+}
+
+function ApplyGroup({
+  checked,
+  label,
+  onChange,
+}: {
+  checked: boolean
+  label: string
+  onChange: (checked: boolean) => void
+}) {
+  return (
+    <label className="compact-checkbox">
+      <input
+        type="checkbox"
+        checked={checked}
+        onChange={(event) => onChange(event.target.checked)}
+      />
+      <span>{label}</span>
+    </label>
+  )
+}
+
+function defaultGroups(mode: 'create' | 'update'): DiscogsTrackApplyGroups {
+  return mode === 'create'
+    ? {
+        core: true,
+        credits: true,
+      }
+    : emptyGroups
+}
+
+function appliedGroupLabel(groups: DiscogsTrackApplyGroups) {
+  const labels = [
+    groups.core ? 'core' : '',
+    groups.credits ? 'credits' : '',
+  ].filter(Boolean)
+
+  if (labels.length === 0) {
+    return 'fields'
+  }
+
+  return labels.length === 1
+    ? labels[0]
+    : `${labels.slice(0, -1).join(', ')} and ${labels.at(-1)}`
+}
+
+function externalMetadataErrorMessage(error: unknown) {
+  if (error instanceof CatalogApiError) {
+    const retry =
+      error.retryAfter && error.status === 429
+        ? ` Retry after ${error.retryAfter} seconds.`
+        : ''
+
+    return `${error.message}${retry}`
+  }
+
+  return 'External metadata provider is unavailable.'
+}
+
+function trackCoreLabel(title: string, duration: string) {
+  return [title || 'Not recorded', duration || 'Unknown duration']
+    .filter(Boolean)
+    .join(' · ')
+}
+
+function joinOrEmpty(values: string[]) {
+  return values.length > 0 ? values.join(', ') : 'Not recorded'
+}
+
+function roleLabelFromCode(role: string, dictionaries: CatalogDictionaries) {
+  const trimmedRole = role.trim()
+
+  return (
+    dictionaries.creditRole.find(
+      (entry) => entry.code === trimmedRole || entry.name === trimmedRole,
+    )?.name ?? trimmedRole
+  )
+}
+
+function LookupInput({
+  label,
+  value,
+  onChange,
+}: {
+  label: string
+  value: string
+  onChange: (value: string) => void
+}) {
+  return (
+    <label>
+      <span>{label}</span>
+      <input
+        aria-label={label}
+        value={value}
+        onChange={(event) => onChange(event.target.value)}
+      />
+    </label>
+  )
+}
diff --git a/src/features/tracks/TrackDetail.tsx b/src/features/tracks/TrackDetail.tsx
index b1b0aa5..fdd7b50 100644
--- a/src/features/tracks/TrackDetail.tsx
+++ b/src/features/tracks/TrackDetail.tsx
@@ -26,6 +26,7 @@ type TrackDetailProps = {
   onDelete?: () => void
   onEdit?: () => void
   onEditLocalFile?: (track: TrackRecord) => void
+  onUpdateViaDiscogs?: () => void
   playlists: PlaylistRecord[]
   ratingCriteria: RatingCriterion[]
   relations: RelationRecord[]
@@ -48,6 +49,7 @@ export function TrackDetail({
   onDelete,
   onEdit,
   onEditLocalFile,
+  onUpdateViaDiscogs,
   onDeleteRating,
   onRateTarget,
   playlists,
@@ -93,6 +95,15 @@ export function TrackDetail({
             >
               Edit record
             </button>
+            {onUpdateViaDiscogs ? (
+              <button
+                className="button button-secondary"
+                type="button"
+                onClick={onUpdateViaDiscogs}
+              >
+                Update via Discogs
+              </button>
+            ) : null}
             {onDelete ? (
               <DeleteSessionRecordButton
                 confirmationMessage="Delete this track and remove its release links and credits?"
@@ -266,7 +277,14 @@ type CreditCardProps = {
 function CreditCard({ credit }: CreditCardProps) {
   return (
     <article>
-      <span className="badge badge-credit">{credit.role}</span>
+      {(credit.roles && credit.roles.length > 0
+        ? credit.roles
+        : [credit.role]
+      ).map((role) => (
+        <span className="badge badge-credit" key={role}>
+          {role}
+        </span>
+      ))}
       {credit.artistId ? (
         <a
           className="detail-link"
diff --git a/src/features/tracks/TrackEntryForm.tsx b/src/features/tracks/TrackEntryForm.tsx
index 1f77e99..64c1dca 100644
--- a/src/features/tracks/TrackEntryForm.tsx
+++ b/src/features/tracks/TrackEntryForm.tsx
@@ -12,6 +12,7 @@ import {
 } from '../catalog/catalogApi'
 import { toCreditRole } from '../catalog/creditRoles'
 import {
+  durationSecondsToParts,
   durationPartsToText,
   durationTextToParts,
   normalizeDurationPart,
@@ -19,6 +20,12 @@ import {
 } from '../catalog/durationFormat'
 import type { ArtistRecord } from '../artists/artistsData'
 import type { ReleaseRecord } from '../releases/releasesData'
+import type { ExternalMetadataTrackDetailDto } from '../catalog/catalogApi'
+import {
+  DiscogsTrackLookupPanel,
+  type DiscogsTrackApplyGroups,
+} from './DiscogsTrackLookupPanel'
+import { CreditRolePicker } from '../releases/CreditRolePicker'
 import {
   emptyVersionNote,
   trackArtistDisplay,
@@ -31,6 +38,7 @@ export type TrackEntryFormProps = {
   artists: ArtistRecord[]
   dictionaries: CatalogDictionaries
   initialTrack?: TrackRecord
+  initialShowDiscogsLookup?: boolean
   onCancel: () => void
   releases: ReleaseRecord[]
   tracks: TrackRecord[]
@@ -41,6 +49,7 @@ export function TrackEntryForm({
   artists,
   dictionaries,
   initialTrack,
+  initialShowDiscogsLookup,
   onCancel,
   tracks,
   onSubmit,
@@ -58,12 +67,21 @@ export function TrackEntryForm({
   const [credits, setCredits] = useState(() =>
     (initialTrack?.credits ?? []).map((credit, index) => ({
       ...credit,
+      roles:
+        credit.roles && credit.roles.length > 0 ? credit.roles : [credit.role],
       id: createManualRecordId(
         'track-credit',
         `${initialTrack?.id ?? 'new'}-${index}`,
       ),
     })),
   )
+  const [externalSources, setExternalSources] = useState(
+    initialTrack?.externalSources,
+  )
+  const [discogsLookupOpenPreference, setDiscogsLookupOpenPreference] =
+    useState<boolean | null>(null)
+  const isDiscogsLookupOpen =
+    discogsLookupOpenPreference ?? Boolean(initialShowDiscogsLookup)
   const appearances = useMemo(
     () => (initialTrack ? trackReleaseAppearances(initialTrack) : []),
     [initialTrack],
@@ -76,10 +94,10 @@ export function TrackEntryForm({
       .filter((tag) => !trackGenreOptions.includes(tag))
       .join(', ') ?? '',
   )
-  const hasInvalidCredit = credits.some((credit) => credit.role.length === 0)
+  const hasInvalidCredit = credits.some((credit) => credit.roles.length === 0)
   const isValid = title.trim().length > 0 && !hasInvalidCredit
   const candidateArtist = (
-    credits.find((credit) => credit.role === 'Main artist')?.artist ??
+    credits.find(hasMainArtistRole)?.artist ??
     credits[0]?.artist ??
     ''
   ).toLowerCase()
@@ -128,6 +146,7 @@ export function TrackEntryForm({
         artistId: existingArtist?.id,
         artist: existingArtist?.name ?? artistName,
         role: 'Main artist',
+        roles: ['Main artist'],
         scope: 'Track-level credit.',
       },
     ])
@@ -151,8 +170,7 @@ export function TrackEntryForm({
       versionNote: appearance.versionNote,
     }))
     const primaryAppearance = normalizedAppearances[0]
-    const primaryCredit =
-      credits.find((credit) => credit.role === 'Main artist') ?? credits[0]
+    const primaryCredit = credits.find(hasMainArtistRole) ?? credits[0]
     const existingFileMetadata = initialTrack?.fileMetadata
     const note = primaryAppearance?.versionNote.trim() || ''
     const tags = uniqueValues([
@@ -191,10 +209,11 @@ export function TrackEntryForm({
           'Manual track draft with incomplete metadata.',
       ),
       tags: tags.length > 0 ? tags : ['manual entry'],
-      credits: credits.map(({ artistId, artist, role, scope }) => ({
+      credits: credits.map(({ artistId, artist, role, roles, scope }) => ({
         artistId,
         artist,
-        role: toCreditRole(role),
+        role: toCreditRole(roles[0] ?? role),
+        roles: roles.map(toCreditRole),
         scope,
       })),
       releaseAppearances: normalizedAppearances,
@@ -217,7 +236,104 @@ export function TrackEntryForm({
         importedAt: existingFileMetadata?.importedAt ?? 'Manual entry',
         checksum: existingFileMetadata?.checksum ?? 'Not recorded',
       },
+      externalSources,
+    })
+  }
+
+  function handleApplyDiscogsDraft(
+    detail: ExternalMetadataTrackDetailDto,
+    groups: DiscogsTrackApplyGroups,
+  ) {
+    if (groups.core) {
+      setTitle(detail.draft.title)
+      setDurationParts(
+        detail.draft.durationSeconds
+          ? durationSecondsToParts(detail.draft.durationSeconds)
+          : durationTextToParts(''),
+      )
+    }
+
+    if (groups.credits) {
+      setCredits(groupDiscogsCredits(detail.draft.artistCredits))
+    }
+
+    setExternalSources(
+      detail.draft.externalSources.map((source) => ({
+        ...source,
+        appliedAt: new Date().toISOString(),
+      })),
+    )
+  }
+
+  function groupDiscogsCredits(
+    artistCredits: ReadonlyArray<{ name: string; role: string }>,
+  ) {
+    const grouped = new Map<
+      string,
+      ReturnType<typeof editableCreditFromDiscogsCredit>
+    >()
+
+    artistCredits.forEach((credit, index) => {
+      const editableCredit = editableCreditFromDiscogsCredit(
+        credit.name,
+        credit.role,
+        index,
+      )
+      const key =
+        editableCredit.artistId ||
+        editableCredit.artist.trim().toLowerCase() ||
+        editableCredit.id
+      const existing = grouped.get(key)
+
+      if (existing) {
+        existing.roles = [
+          ...new Set([...existing.roles, ...editableCredit.roles]),
+        ]
+        existing.role = existing.roles[0] ?? ''
+      } else {
+        grouped.set(key, editableCredit)
+      }
     })
+
+    return [...grouped.values()]
+  }
+
+  function editableCreditFromDiscogsCredit(
+    artistName: string,
+    role: string,
+    index: number,
+  ) {
+    const normalizedArtistName = artistName.trim()
+    const existingArtist = artists.find(
+      (record) =>
+        record.name.toLowerCase() === normalizedArtistName.toLowerCase(),
+    )
+
+    const roles = roleLabelsFromCode(role)
+
+    return {
+      id: createManualRecordId(
+        'track-credit',
+        `${normalizedArtistName}-${role}-${index}`,
+      ),
+      artistId: existingArtist?.id,
+      artist: existingArtist?.name ?? normalizedArtistName,
+      role: roles[0] ?? '',
+      roles,
+      scope: 'Suggested by Discogs track detail.',
+    }
+  }
+
+  function roleLabelsFromCode(role: string) {
+    return [
+      ...new Set(
+        role
+          .split(',')
+          .map((part) => part.trim())
+          .filter(Boolean)
+          .map((part) => toCreditRole(part)),
+      ),
+    ]
   }
 
   return (
@@ -323,6 +439,31 @@ export function TrackEntryForm({
               this session.
             </p>
           ) : null}
+          <DiscogsTrackLookupPanel
+            current={{
+              artists: credits.map((credit) => credit.artist).join(', '),
+              duration: durationPartsToText(durationParts),
+              title,
+            }}
+            dictionaries={dictionaries}
+            isOpen={isDiscogsLookupOpen}
+            mode={initialTrack ? 'update' : 'create'}
+            searchSeed={{
+              artist:
+                credits.find(hasMainArtistRole)?.artist ??
+                credits[0]?.artist ??
+                '',
+              catalogNumber: initialTrack?.release.catalogNumber ?? '',
+              releaseTitle:
+                appearances[0]?.releaseTitle ??
+                initialTrack?.release.title ??
+                '',
+              title,
+              year: appearances[0]?.year ?? initialTrack?.release.year ?? '',
+            }}
+            onApplyDraft={handleApplyDiscogsDraft}
+            onOpenChange={setDiscogsLookupOpenPreference}
+          />
           <section className="release-form-section">
             <div className="release-form-section-header">
               <div>
@@ -358,35 +499,63 @@ export function TrackEntryForm({
                     <span className="release-artist-chip-name">
                       {credit.artist}
                     </span>
-                    <label className="release-artist-chip-role">
-                      <span className="release-artist-chip-role-face">
-                        <span>{credit.role}</span>
-                        <span className="release-artist-chip-role-caret" />
-                      </span>
-                      <select
-                        aria-label={`Role for ${credit.artist}`}
-                        className="release-artist-chip-role-select"
-                        value={credit.role}
-                        onChange={(event) =>
+                    <span className="release-artist-chip-roles">
+                      {credit.roles.map((role) => (
+                        <span className="release-artist-role-pill" key={role}>
+                          <span>{role}</span>
+                          <button
+                            type="button"
+                            aria-label={`Remove ${role} from ${credit.artist}`}
+                            onClick={() =>
+                              setCredits((currentCredits) =>
+                                currentCredits.map((currentCredit) => {
+                                  if (currentCredit.id !== credit.id) {
+                                    return currentCredit
+                                  }
+
+                                  const roles = currentCredit.roles.filter(
+                                    (currentRole) => currentRole !== role,
+                                  )
+                                  return {
+                                    ...currentCredit,
+                                    role: roles[0] ?? '',
+                                    roles,
+                                  }
+                                }),
+                              )
+                            }
+                          >
+                            ×
+                          </button>
+                        </span>
+                      ))}
+                      <CreditRolePicker
+                        addLabel={
+                          credit.roles.length > 0 ? 'Add role' : 'Set role'
+                        }
+                        ariaLabel={`Role for ${credit.artist}`}
+                        options={trackCreditRoleOptions.filter(
+                          (role) => !credit.roles.includes(role),
+                        )}
+                        onSelect={(role) => {
+                          if (!role || credit.roles.includes(role)) {
+                            return
+                          }
+
                           setCredits((currentCredits) =>
                             currentCredits.map((currentCredit) =>
                               currentCredit.id === credit.id
                                 ? {
                                     ...currentCredit,
-                                    role: toCreditRole(event.target.value),
+                                    role: currentCredit.role || role,
+                                    roles: [...currentCredit.roles, role],
                                   }
                                 : currentCredit,
                             ),
                           )
-                        }
-                      >
-                        {trackCreditRoleOptions.map((role) => (
-                          <option key={role} value={role}>
-                            {role}
-                          </option>
-                        ))}
-                      </select>
-                    </label>
+                        }}
+                      />
+                    </span>
                     <button
                       aria-label={`Remove ${credit.artist}`}
                       className="release-artist-chip-remove"
@@ -483,3 +652,9 @@ export function TrackEntryForm({
     </ManualEntryPanel>
   )
 }
+
+function hasMainArtistRole(credit: { role: string; roles?: string[] }) {
+  return (
+    credit.roles && credit.roles.length > 0 ? credit.roles : [credit.role]
+  ).includes('Main artist')
+}
diff --git a/src/features/tracks/TracksWorkspace.tsx b/src/features/tracks/TracksWorkspace.tsx
index f8bad9c..a6a63f0 100644
--- a/src/features/tracks/TracksWorkspace.tsx
+++ b/src/features/tracks/TracksWorkspace.tsx
@@ -89,6 +89,7 @@ export function TracksWorkspace({
   })
   const [manualTracks, setManualTracks] = useState<TrackRecord[]>([])
   const [editingTrackId, setEditingTrackId] = useState('')
+  const [discogsLookupTrackId, setDiscogsLookupTrackId] = useState('')
   const [localEditFiles, setLocalEditFiles] = useState<LocalEditableFile[]>([])
   const [ratingColumnIds, setRatingColumnIds] = useState(() =>
     readRatingColumnIds('discweave.trackRatingColumns'),
@@ -110,7 +111,12 @@ export function TracksWorkspace({
         terms.every((term) => trackSearchText(track).includes(term)) &&
         (!filters.format || track.fileMetadata.format === filters.format) &&
         (!filters.creditRole ||
-          track.credits.some((credit) => credit.role === filters.creditRole)) &&
+          track.credits.some((credit) =>
+            (credit.roles && credit.roles.length > 0
+              ? credit.roles
+              : [credit.role]
+            ).includes(filters.creditRole),
+          )) &&
         (!filters.relationType ||
           track.versionHint === filters.relationType ||
           track.relations.some(
@@ -145,6 +151,7 @@ export function TracksWorkspace({
     setQuery('')
     selectTrack(track.id)
     onManualEntryClose()
+    setDiscogsLookupTrackId('')
   }
 
   function handleUpdateTrack(track: TrackRecord) {
@@ -161,6 +168,7 @@ export function TracksWorkspace({
     setQuery('')
     selectTrack(track.id)
     setEditingTrackId('')
+    setDiscogsLookupTrackId('')
   }
 
   function handleDeleteTrack(trackId: string) {
@@ -174,6 +182,7 @@ export function TracksWorkspace({
 
     setQuery('')
     setEditingTrackId('')
+    setDiscogsLookupTrackId('')
   }
 
   async function handleEditLocalFile(track: TrackRecord) {
@@ -228,7 +237,11 @@ export function TracksWorkspace({
             value={filters.creditRole}
             values={uniqueValues(
               tracks.flatMap((track) =>
-                track.credits.map((credit) => credit.role),
+                track.credits.flatMap((credit) =>
+                  credit.roles && credit.roles.length > 0
+                    ? credit.roles
+                    : [credit.role],
+                ),
               ),
             )}
             onChange={(creditRole) =>
@@ -279,8 +292,12 @@ export function TracksWorkspace({
             artists={artists}
             dictionaries={dictionaries}
             initialTrack={editingTrack}
+            initialShowDiscogsLookup={editingTrack.id === discogsLookupTrackId}
             key={editingTrack.id}
-            onCancel={() => setEditingTrackId('')}
+            onCancel={() => {
+              setEditingTrackId('')
+              setDiscogsLookupTrackId('')
+            }}
             releases={releases}
             tracks={tracks}
             onSubmit={handleUpdateTrack}
@@ -306,7 +323,14 @@ export function TracksWorkspace({
 
       {selectedTrack ? (
         <TrackDetail
-          onEdit={() => setEditingTrackId(selectedTrack.id)}
+          onEdit={() => {
+            setEditingTrackId(selectedTrack.id)
+            setDiscogsLookupTrackId('')
+          }}
+          onUpdateViaDiscogs={() => {
+            setEditingTrackId(selectedTrack.id)
+            setDiscogsLookupTrackId(selectedTrack.id)
+          }}
           onDelete={() => handleDeleteTrack(selectedTrack.id)}
           playlists={playlists}
           relations={relations}
diff --git a/src/features/tracks/trackDisplayHelpers.ts b/src/features/tracks/trackDisplayHelpers.ts
index 4eb2abd..e799b9b 100644
--- a/src/features/tracks/trackDisplayHelpers.ts
+++ b/src/features/tracks/trackDisplayHelpers.ts
@@ -31,7 +31,12 @@ export function trackReleaseAppearances(
 export function trackArtistDisplay(track: TrackRecord) {
   const mainArtists = uniqueValues(
     track.credits
-      .filter((credit) => credit.role === 'Main artist')
+      .filter((credit) =>
+        (credit.roles && credit.roles.length > 0
+          ? credit.roles
+          : [credit.role]
+        ).includes('Main artist'),
+      )
       .map((credit) => credit.artist),
   )
   const creditArtists = uniqueValues(
@@ -112,7 +117,9 @@ export function trackSearchText(track: TrackRecord) {
       : []),
     ...track.tags,
     ...track.credits.flatMap((credit) => [
-      credit.role,
+      ...(credit.roles && credit.roles.length > 0
+        ? credit.roles
+        : [credit.role]),
       credit.artist,
       credit.scope,
     ]),
diff --git a/src/features/tracks/tracks.css b/src/features/tracks/tracks.css
index f4c2009..07e37be 100644
--- a/src/features/tracks/tracks.css
+++ b/src/features/tracks/tracks.css
@@ -42,6 +42,28 @@
   align-self: end;
 }
 
+.discogs-track-lookup .discogs-search-form {
+  grid-template-columns: repeat(3, minmax(0, 1fr));
+}
+
+.discogs-track-lookup .discogs-search-form > .button {
+  justify-self: start;
+}
+
+.discogs-track-lookup .discogs-candidate-summary,
+.discogs-track-lookup .discogs-impact-row,
+.discogs-track-lookup .discogs-credit-impact-row {
+  grid-template-columns: minmax(0, 1fr);
+}
+
+.discogs-track-lookup .discogs-candidate-actions {
+  justify-items: start;
+}
+
+.discogs-track-lookup .discogs-candidate-actions .detail-link {
+  text-align: left;
+}
+
 .track-appearance-list {
   display: grid;
   gap: 8px;
@@ -131,3 +153,24 @@
   letter-spacing: 0.06em;
   text-transform: uppercase;
 }
+
+@media (max-width: 700px) {
+  .track-entry-layout,
+  .track-core-grid,
+  .track-credit-composer,
+  .draft-track-row {
+    grid-template-columns: minmax(0, 1fr);
+  }
+
+  .track-entry-side {
+    border-top: 1px solid var(--color-border);
+    border-left: 0;
+    padding-top: 12px;
+    padding-left: 0;
+  }
+
+  .draft-track-header {
+    align-items: stretch;
+    flex-direction: column;
+  }
+}
diff --git a/src/features/tracks/tracksData.ts b/src/features/tracks/tracksData.ts
index e82472b..270fccb 100644
--- a/src/features/tracks/tracksData.ts
+++ b/src/features/tracks/tracksData.ts
@@ -1,10 +1,14 @@
 import type { CreditRole } from '../catalog/creditRoles'
-import type { EntityRating } from '../catalog/catalogApi'
+import type {
+  EntityRating,
+  ExternalSourceReference,
+} from '../catalog/catalogApi'
 import type { ReleaseCoverImage, ReleaseLabel } from '../releases/releasesData'
 
 export type TrackCredit = {
   artistId?: string
   role: CreditRole
+  roles?: CreditRole[]
   artist: string
   scope: string
 }
@@ -67,6 +71,7 @@ export type TrackRecord = {
   relations: TrackRelation[]
   fileMetadata: LocalFileMetadata
   ratings?: EntityRating[]
+  externalSources?: ExternalSourceReference[]
 }
 
 export const trackRecords: TrackRecord[] = [
diff --git a/vitest.config.ts b/vitest.config.ts
index b2cd25d..a837bfc 100644
--- a/vitest.config.ts
+++ b/vitest.config.ts
@@ -3,7 +3,9 @@ import { defineConfig } from 'vitest/config'
 export default defineConfig({
   test: {
     environment: 'jsdom',
+    fileParallelism: false,
     globals: true,
     setupFiles: './src/test/setup.ts',
+    testTimeout: 10_000,
   },
 })

From 12d932f8fdc584d58f8d923eaea0bd214aee58b5 Mon Sep 17 00:00:00 2001
From: "r.osipin" <r.osipin@whyhappen.ru>
Date: Thu, 4 Jun 2026 11:27:13 +0300
Subject: [PATCH 3/3] Address Discogs UI PR feedback

---
 .superdesign/design-system.md                 |   2 +-
 src/App.catalog-actions.cases.ts              |  97 ++++
 src/App.catalog-actions.test.tsx              |  83 +---
 src/App.release-entry-basics.test.tsx         |   6 +-
 src/App.release-entry-tracklist.test.tsx      |   6 +-
 src/app/AuthenticatedApp.tsx                  |  12 +-
 .../artists/DiscogsArtistLookupPanel.tsx      |  13 +-
 .../catalog/api/catalogEntityMappers.ts       |   6 +-
 src/features/catalog/api/catalogTypes.ts      |   3 +-
 .../catalog/api/catalogValueMappers.ts        |  16 +-
 .../releases/DiscogsCandidateReview.tsx       | 331 +++++++++++++
 .../releases/DiscogsReleaseLookupPanel.tsx    | 435 +-----------------
 .../releases/ReleaseArtistCreditsSection.tsx  |  57 ++-
 src/features/releases/ReleaseDetail.tsx       |   1 +
 src/features/releases/ReleaseEntryForm.tsx    | 137 +-----
 .../releases/discogs-release-lookup.css       | 307 ++++++++++++
 src/features/releases/discogsReleaseApply.ts  |  64 +++
 src/features/releases/discogsRoleUtils.ts     | 146 ++++++
 src/features/releases/release-form.css        | 308 -------------
 src/features/releases/releases.css            |   1 +
 src/features/tracks/TrackEntryForm.tsx        |  87 +---
 src/features/tracks/discogsTrackApply.ts      |  74 +++
 src/features/tracks/tracks.css                |   8 +
 src/test/appTestHarness.ts                    |   8 +-
 24 files changed, 1133 insertions(+), 1075 deletions(-)
 create mode 100644 src/App.catalog-actions.cases.ts
 create mode 100644 src/features/releases/DiscogsCandidateReview.tsx
 create mode 100644 src/features/releases/discogs-release-lookup.css
 create mode 100644 src/features/releases/discogsReleaseApply.ts
 create mode 100644 src/features/releases/discogsRoleUtils.ts
 create mode 100644 src/features/tracks/discogsTrackApply.ts

diff --git a/.superdesign/design-system.md b/.superdesign/design-system.md
index 0374de6..a714e59 100644
--- a/.superdesign/design-system.md
+++ b/.superdesign/design-system.md
@@ -29,7 +29,7 @@ DiscWeave is a dense personal music archive for collectors. The UI should stay c
 - Do not show barcode search fields, barcode values, or raw identifier lists in release lookup/review UI unless a future product task makes them first-class fields.
 - Candidate rows should prioritize title, artists, year, labels, formats, catalog number, source link, and Discogs attribution.
 - Selecting a candidate must reveal the review immediately near the selected candidate or in a clearly visible review rail; users should not need to discover it by scrolling.
-- Review must make apply consequences explicit for Core, Artists, Labels, Tracklist, and External Source.
+- Review must make apply consequences explicit for Core, Artists, Labels, and Tracklist. External source provenance is applied with the selected Discogs draft after the user applies fields and saves.
 - Artist role suggestions that are not already in local dictionaries should be presented as roles that will be added/accepted with the release update, not as unexplained raw Discogs strings.
 - Multiple Discogs artist credits must be shown as separate rows grouped under Artists, with each artist name, one or more roles, and a clear existing-role/new-role status. Do not collapse mixed artist roles into a single comma-separated sentence.
 - Tracklist review must clearly state whether tracks will be created, replaced, preserved, or updated before the user applies a group.
diff --git a/src/App.catalog-actions.cases.ts b/src/App.catalog-actions.cases.ts
new file mode 100644
index 0000000..72c5ba3
--- /dev/null
+++ b/src/App.catalog-actions.cases.ts
@@ -0,0 +1,97 @@
+import type { AppRoutePath } from './app/routes'
+
+export type ManualEntryCase = {
+  action: string
+  detailName: string
+  form: string
+  heading: string
+  path: AppRoutePath
+  requiredLabel: string
+  rowName: RegExp
+  searchLabel: string
+  secondaryRequiredLabel?: string
+  secondaryValue?: string
+  value: string
+}
+
+export const manualEntryCases: ManualEntryCase[] = [
+  {
+    path: '/artists',
+    heading: 'Artists',
+    action: 'Add artist',
+    form: 'Add artist',
+    requiredLabel: 'Name',
+    value: 'Coil Archive Test Artist',
+    searchLabel: 'Search artists',
+    rowName: /coil archive test artist/i,
+    detailName: 'Coil Archive Test Artist',
+  },
+  {
+    path: '/releases',
+    heading: 'Releases',
+    action: 'Add release',
+    form: 'Add release',
+    requiredLabel: 'Title',
+    value: 'Silent Dub Test Pressing',
+    searchLabel: 'Search releases',
+    rowName: /silent dub test pressing/i,
+    detailName: 'Silent Dub Test Pressing',
+  },
+  {
+    path: '/tracks',
+    heading: 'Tracks',
+    action: 'Add track',
+    form: 'Add track',
+    requiredLabel: 'Title',
+    value: 'Unlabeled Field Recording',
+    searchLabel: 'Search tracks',
+    rowName: /unlabeled field recording/i,
+    detailName: 'Unlabeled Field Recording',
+  },
+  {
+    path: '/labels',
+    heading: 'Labels',
+    action: 'Add label',
+    form: 'Add label',
+    requiredLabel: 'Name',
+    value: 'Basement White Label',
+    searchLabel: 'Search labels',
+    rowName: /basement white label/i,
+    detailName: 'Basement White Label',
+  },
+  {
+    path: '/owned-items',
+    heading: 'Owned Items',
+    action: 'Add owned item',
+    form: 'Add owned item',
+    requiredLabel: 'Item name',
+    value: 'Basement Tape Reference Copy',
+    searchLabel: 'Search owned items',
+    rowName: /basement tape reference copy/i,
+    detailName: 'Basement Tape Reference Copy',
+  },
+  {
+    path: '/relations',
+    heading: 'Relations',
+    action: 'Add relation',
+    form: 'Add relation',
+    requiredLabel: 'Source',
+    secondaryRequiredLabel: 'Target',
+    value: 'Archive Source Person',
+    secondaryValue: 'Archive Target Project',
+    searchLabel: 'Search relations',
+    rowName: /archive source person archive target project/i,
+    detailName: 'Archive Source Person to Archive Target Project',
+  },
+  {
+    path: '/playlists',
+    heading: 'Playlists',
+    action: 'Add playlist',
+    form: 'Add playlist',
+    requiredLabel: 'Name',
+    value: 'Listening Desk Checks',
+    searchLabel: 'Search playlists',
+    rowName: /listening desk checks/i,
+    detailName: 'Listening Desk Checks',
+  },
+]
diff --git a/src/App.catalog-actions.test.tsx b/src/App.catalog-actions.test.tsx
index fe8e1e2..78559b1 100644
--- a/src/App.catalog-actions.test.tsx
+++ b/src/App.catalog-actions.test.tsx
@@ -1,5 +1,6 @@
 import { describe, expect, it } from 'vitest'
 import * as h from './test/appTestHarness'
+import { manualEntryCases } from './App.catalog-actions.cases'
 
 h.setupAppTestHooks()
 
@@ -456,87 +457,7 @@ describe('App catalog actions', () => {
     })
   })
 
-  it.each([
-    {
-      path: '/artists',
-      heading: 'Artists',
-      action: 'Add artist',
-      form: 'Add artist',
-      requiredLabel: 'Name',
-      value: 'Coil Archive Test Artist',
-      searchLabel: 'Search artists',
-      rowName: /coil archive test artist/i,
-      detailName: 'Coil Archive Test Artist',
-    },
-    {
-      path: '/releases',
-      heading: 'Releases',
-      action: 'Add release',
-      form: 'Add release',
-      requiredLabel: 'Title',
-      value: 'Silent Dub Test Pressing',
-      searchLabel: 'Search releases',
-      rowName: /silent dub test pressing/i,
-      detailName: 'Silent Dub Test Pressing',
-    },
-    {
-      path: '/tracks',
-      heading: 'Tracks',
-      action: 'Add track',
-      form: 'Add track',
-      requiredLabel: 'Title',
-      value: 'Unlabeled Field Recording',
-      searchLabel: 'Search tracks',
-      rowName: /unlabeled field recording/i,
-      detailName: 'Unlabeled Field Recording',
-    },
-    {
-      path: '/labels',
-      heading: 'Labels',
-      action: 'Add label',
-      form: 'Add label',
-      requiredLabel: 'Name',
-      value: 'Basement White Label',
-      searchLabel: 'Search labels',
-      rowName: /basement white label/i,
-      detailName: 'Basement White Label',
-    },
-    {
-      path: '/owned-items',
-      heading: 'Owned Items',
-      action: 'Add owned item',
-      form: 'Add owned item',
-      requiredLabel: 'Item name',
-      value: 'Basement Tape Reference Copy',
-      searchLabel: 'Search owned items',
-      rowName: /basement tape reference copy/i,
-      detailName: 'Basement Tape Reference Copy',
-    },
-    {
-      path: '/relations',
-      heading: 'Relations',
-      action: 'Add relation',
-      form: 'Add relation',
-      requiredLabel: 'Source',
-      secondaryRequiredLabel: 'Target',
-      value: 'Archive Source Person',
-      secondaryValue: 'Archive Target Project',
-      searchLabel: 'Search relations',
-      rowName: /archive source person archive target project/i,
-      detailName: 'Archive Source Person to Archive Target Project',
-    },
-    {
-      path: '/playlists',
-      heading: 'Playlists',
-      action: 'Add playlist',
-      form: 'Add playlist',
-      requiredLabel: 'Name',
-      value: 'Listening Desk Checks',
-      searchLabel: 'Search playlists',
-      rowName: /listening desk checks/i,
-      detailName: 'Listening Desk Checks',
-    },
-  ])(
+  it.each(manualEntryCases)(
     'supports required-only manual entry from the header in $heading',
     async ({
       path,
diff --git a/src/App.release-entry-basics.test.tsx b/src/App.release-entry-basics.test.tsx
index 6259524..f99f00e 100644
--- a/src/App.release-entry-basics.test.tsx
+++ b/src/App.release-entry-basics.test.tsx
@@ -60,9 +60,11 @@ describe('App release entry basics', () => {
       h.within(form).getByRole('button', { name: 'Add record' }),
     ).toBeDisabled()
 
-    await user.selectOptions(
+    await user.click(
       h.within(form).getByLabelText('Role for Unset Role Artist'),
-      'Main artist',
+    )
+    await user.click(
+      h.within(form).getByRole('menuitem', { name: 'Main artist' }),
     )
 
     expect(
diff --git a/src/App.release-entry-tracklist.test.tsx b/src/App.release-entry-tracklist.test.tsx
index 28c5c0c..3f4e482 100644
--- a/src/App.release-entry-tracklist.test.tsx
+++ b/src/App.release-entry-tracklist.test.tsx
@@ -389,9 +389,11 @@ describe('App release entry tracklists', () => {
       'Set a role for each track artist.',
     )
 
-    await user.selectOptions(
+    await user.click(
       h.within(form).getByLabelText('Track role for Track Artist'),
-      'Main artist',
+    )
+    await user.click(
+      h.within(form).getByRole('menuitem', { name: 'Main artist' }),
     )
 
     expect(h.screen.getByRole('button', { name: 'Add record' })).toBeEnabled()
diff --git a/src/app/AuthenticatedApp.tsx b/src/app/AuthenticatedApp.tsx
index 6e5c8b2..7dc1fb9 100644
--- a/src/app/AuthenticatedApp.tsx
+++ b/src/app/AuthenticatedApp.tsx
@@ -591,16 +591,6 @@ export function AuthenticatedApp({
   )
 }
 
-const fullCatalogRoutes = new Set<AppRoutePath>([
-  '/artists',
-  '/labels',
-  '/owned-items',
-  '/playlists',
-  '/relations',
-  '/releases',
-  '/tracks',
-])
-
 function routeRequiresFullCatalog(path: AppRoutePath) {
-  return fullCatalogRoutes.has(path)
+  return manualEntryRoutes.has(path)
 }
diff --git a/src/features/artists/DiscogsArtistLookupPanel.tsx b/src/features/artists/DiscogsArtistLookupPanel.tsx
index 8571940..e44b941 100644
--- a/src/features/artists/DiscogsArtistLookupPanel.tsx
+++ b/src/features/artists/DiscogsArtistLookupPanel.tsx
@@ -65,11 +65,22 @@ export function DiscogsArtistLookupPanel({
   }, [isOpen, searchSeed])
 
   async function handleSearch() {
+    const trimmedQuery = query.trim()
+    if (!trimmedQuery) {
+      setCandidates([])
+      setSelectedDetail(null)
+      setStatus('Enter an artist name to search.')
+      return
+    }
+
     setStatus('Searching Discogs artist candidates.')
     setSelectedDetail(null)
 
     try {
-      const result = await searchDiscogsArtists({ query, limit: 25 })
+      const result = await searchDiscogsArtists({
+        query: trimmedQuery,
+        limit: 25,
+      })
       setCandidates(result.items)
       setStatus(
         result.items.length > 0
diff --git a/src/features/catalog/api/catalogEntityMappers.ts b/src/features/catalog/api/catalogEntityMappers.ts
index ea0ad3a..d56e480 100644
--- a/src/features/catalog/api/catalogEntityMappers.ts
+++ b/src/features/catalog/api/catalogEntityMappers.ts
@@ -9,6 +9,7 @@ import type { RelationRecord } from '../../relations/relationsData'
 import type { TrackRecord } from '../../tracks/tracksData'
 import {
   conditionLabel,
+  creditRolesFromDto,
   creditRoleLabel,
   formatDuration,
   isDigitalFileMedium,
@@ -148,10 +149,7 @@ export function toReleaseRecord(
             artistsById.get(credit.contributorArtistId)?.name ??
             credit.contributorName,
           role: creditRoleLabel(credit.role, dictionaries),
-          roles: (credit.roles && credit.roles.length > 0
-            ? credit.roles
-            : [credit.role]
-          ).map((role) => creditRoleLabel(role, dictionaries)),
+          roles: creditRolesFromDto(credit, dictionaries),
         }))
   const mainCredits = releaseCredits.filter((credit) =>
     isMainArtistRole(credit.role, dictionaries),
diff --git a/src/features/catalog/api/catalogTypes.ts b/src/features/catalog/api/catalogTypes.ts
index db1c7a5..cb64f65 100644
--- a/src/features/catalog/api/catalogTypes.ts
+++ b/src/features/catalog/api/catalogTypes.ts
@@ -353,7 +353,8 @@ export type ReleaseCoverImageDto = {
 export type ReleaseArtistCreditDto = {
   artistId: string
   artistName: string
-  role: string
+  primaryRole?: string
+  role?: string
   roles?: string[]
 }
 
diff --git a/src/features/catalog/api/catalogValueMappers.ts b/src/features/catalog/api/catalogValueMappers.ts
index a1532ed..8e60e51 100644
--- a/src/features/catalog/api/catalogValueMappers.ts
+++ b/src/features/catalog/api/catalogValueMappers.ts
@@ -140,7 +140,7 @@ export function toTrackCreditFromReleaseCredit(
 
   return {
     artistId: credit.artistId,
-    role: roles[0] ?? creditRoleLabel(credit.role, dictionaries),
+    role: roles[0] ?? creditRoleLabel(primaryCreditRole(credit), dictionaries),
     roles,
     artist: credit.artistName,
     scope: 'Tracklist credit.',
@@ -156,22 +156,28 @@ export function toReleaseArtistCredit(
   return {
     artistId: credit.artistId,
     artist: credit.artistName,
-    role: roles[0] ?? creditRoleLabel(credit.role, dictionaries),
+    role: roles[0] ?? creditRoleLabel(primaryCreditRole(credit), dictionaries),
     roles,
   }
 }
 
 export function creditRolesFromDto(
-  credit: { role: string; roles?: string[] },
+  credit: { primaryRole?: string; role?: string; roles?: string[] },
   dictionaries = activeDictionaries,
 ) {
   const roleCodes =
-    credit.roles && credit.roles.length > 0 ? credit.roles : [credit.role]
+    credit.roles && credit.roles.length > 0
+      ? credit.roles
+      : [primaryCreditRole(credit)]
   return [
     ...new Set(roleCodes.map((role) => creditRoleLabel(role, dictionaries))),
   ]
 }
 
+function primaryCreditRole(credit: { primaryRole?: string; role?: string }) {
+  return credit.primaryRole ?? credit.role ?? ''
+}
+
 export function toReleaseLabel(label: ReleaseLabelDto): ReleaseLabel {
   return {
     labelId: label.labelId ?? undefined,
@@ -190,7 +196,7 @@ export function releaseArtistDisplay(release: ReleaseDto) {
   const mainCredits = credits.filter((credit) =>
     (credit.roles && credit.roles.length > 0
       ? credit.roles
-      : [credit.role]
+      : [primaryCreditRole(credit)]
     ).includes(mainArtistRoleCode),
   )
   const visibleCredits = mainCredits.length > 0 ? mainCredits : credits
diff --git a/src/features/releases/DiscogsCandidateReview.tsx b/src/features/releases/DiscogsCandidateReview.tsx
new file mode 100644
index 0000000..9f449f6
--- /dev/null
+++ b/src/features/releases/DiscogsCandidateReview.tsx
@@ -0,0 +1,331 @@
+import type { ReactNode } from 'react'
+import { useState } from 'react'
+import type {
+  CatalogDictionaries,
+  ExternalMetadataReleaseDetailDto,
+  ExternalMetadataReleaseDraftTrackDto,
+} from '../catalog/catalogApi'
+import { discogsDraftTrackRows } from './discogsReleaseTrackRows'
+import type {
+  DiscogsApplyGroups,
+  DiscogsCurrentRelease,
+} from './DiscogsReleaseLookupPanel'
+import {
+  discogsRoleLabelFromCode,
+  groupDiscogsReviewCredits,
+  hasCompilationTrackArtists,
+  type GroupedDiscogsReviewCredit,
+} from './discogsRoleUtils'
+
+type DiscogsCandidateReviewProps = {
+  applyGroups: DiscogsApplyGroups
+  current: DiscogsCurrentRelease
+  detail: ExternalMetadataReleaseDetailDto
+  dictionaries: CatalogDictionaries
+  hasSelectedGroup: boolean
+  onApplyDraft: (
+    detail: ExternalMetadataReleaseDetailDto,
+    groups: DiscogsApplyGroups,
+  ) => void
+  onUpdateApplyGroup: (
+    group: keyof DiscogsApplyGroups,
+    checked: boolean,
+  ) => void
+}
+
+export function DiscogsCandidateReview({
+  applyGroups,
+  current,
+  detail,
+  dictionaries,
+  hasSelectedGroup,
+  onApplyDraft,
+  onUpdateApplyGroup,
+}: DiscogsCandidateReviewProps) {
+  const compilationDetected = hasCompilationTrackArtists(detail)
+  const reviewTracks = discogsDraftTrackRows(detail.draft.tracklist)
+  const draftGenres = detail.draft.genres ?? []
+
+  return (
+    <div className="discogs-review-panel">
+      <div className="release-form-section-header">
+        <div>
+          <h3>Review Discogs candidate</h3>
+          <p>
+            {detail.source.attribution}{' '}
+            <a
+              className="detail-link"
+              href={detail.source.sourceUrl}
+              target="_blank"
+              rel="noreferrer"
+            >
+              Open Discogs source
+            </a>
+          </p>
+        </div>
+      </div>
+
+      <div className="discogs-impact-list">
+        <ImpactRow
+          checked={applyGroups.core}
+          currentValue={[
+            current.title || 'Not recorded',
+            current.releaseDate || current.year,
+          ]
+            .filter(Boolean)
+            .join(' · ')}
+          group="Core"
+          nextValue={[
+            detail.draft.title,
+            detail.draft.releaseDate || detail.draft.year?.toString(),
+          ]
+            .filter(Boolean)
+            .join(' · ')}
+          onChange={(checked) => onUpdateApplyGroup('core', checked)}
+        />
+        <ImpactRow
+          checked={applyGroups.artists}
+          currentValue={current.artists || 'Not recorded'}
+          group="Artists"
+          nextValue={`${detail.draft.artistCredits.length} Discogs credits`}
+          onChange={(checked) => onUpdateApplyGroup('artists', checked)}
+        >
+          <ArtistImpactList
+            credits={detail.draft.artistCredits}
+            dictionaries={dictionaries}
+          />
+        </ImpactRow>
+        <ImpactRow
+          checked={applyGroups.labels}
+          currentValue={current.labels || 'Not recorded'}
+          group="Labels"
+          nextValue={releaseLabelSummary(detail) || 'Not recorded'}
+          onChange={(checked) => onUpdateApplyGroup('labels', checked)}
+        />
+        <ImpactRow
+          checked={applyGroups.classification}
+          currentValue={current.genres || 'Not recorded'}
+          group="Classification"
+          nextValue={
+            draftGenres.length > 0 ? draftGenres.join(', ') : 'Not recorded'
+          }
+          onChange={(checked) => onUpdateApplyGroup('classification', checked)}
+        />
+        <ImpactRow
+          checked={applyGroups.tracklist}
+          currentValue={`${current.trackCount} rows`}
+          group="Tracklist"
+          nextValue={`${reviewTracks.length} Discogs rows`}
+          onChange={(checked) => onUpdateApplyGroup('tracklist', checked)}
+        >
+          {compilationDetected ? (
+            <p className="discogs-impact-warning">
+              Compilation detected: track-specific artists differ from release
+              artists. Applying Tracklist will mark the release as Various
+              Artists and write track-level artist credits.
+            </p>
+          ) : null}
+          <TrackImpactList dictionaries={dictionaries} tracks={reviewTracks} />
+        </ImpactRow>
+      </div>
+
+      <button
+        className="button button-primary button-compact"
+        type="button"
+        disabled={!hasSelectedGroup}
+        onClick={() => onApplyDraft(detail, applyGroups)}
+      >
+        Apply selected Discogs fields
+      </button>
+    </div>
+  )
+}
+
+function ImpactRow({
+  checked,
+  children,
+  currentValue,
+  group,
+  nextValue,
+  onChange,
+}: {
+  checked: boolean
+  children?: ReactNode
+  currentValue: string
+  group: string
+  nextValue: string
+  onChange: (checked: boolean) => void
+}) {
+  return (
+    <div className="discogs-impact-row">
+      <ApplyGroup
+        checked={checked}
+        label={`Apply ${group}`}
+        onChange={onChange}
+      />
+      <div className="discogs-impact-group">{group}</div>
+      <div className="discogs-impact-value">
+        <span>Current</span>
+        <strong>{currentValue}</strong>
+      </div>
+      <div className="discogs-impact-value">
+        <span>Discogs</span>
+        <strong>{nextValue}</strong>
+        {children ? (
+          <div className="discogs-impact-detail">{children}</div>
+        ) : null}
+      </div>
+    </div>
+  )
+}
+
+function ArtistImpactList({
+  credits,
+  dictionaries,
+}: {
+  credits: ExternalMetadataReleaseDetailDto['draft']['artistCredits']
+  dictionaries: CatalogDictionaries
+}) {
+  if (credits.length === 0) {
+    return <p className="discogs-impact-empty">No Discogs artist credits.</p>
+  }
+
+  return (
+    <div className="discogs-credit-impact-list">
+      {groupDiscogsReviewCredits(credits).map((credit) => (
+        <CreditImpactRow
+          credit={credit}
+          dictionaries={dictionaries}
+          key={credit.name}
+        />
+      ))}
+    </div>
+  )
+}
+
+function TrackImpactList({
+  dictionaries,
+  tracks,
+}: {
+  dictionaries: CatalogDictionaries
+  tracks: ExternalMetadataReleaseDraftTrackDto[]
+}) {
+  const [showAllTracks, setShowAllTracks] = useState(false)
+  const previewTracks = showAllTracks ? tracks : tracks.slice(0, 4)
+  const hiddenCount = tracks.length - previewTracks.length
+
+  if (tracks.length === 0) {
+    return <p className="discogs-impact-empty">No Discogs track rows.</p>
+  }
+
+  return (
+    <div className="discogs-track-impact-list">
+      {previewTracks.map((track) => (
+        <div className="discogs-track-impact-row" key={track.position}>
+          <span className="discogs-track-impact-position">
+            {track.position}
+          </span>
+          <div>
+            <strong>{track.title}</strong>
+            <p>
+              {track.durationSeconds
+                ? formatDurationSeconds(track.durationSeconds)
+                : 'No duration'}{' '}
+              · create track
+            </p>
+            {track.artistCredits.length > 0 ? (
+              <div className="discogs-credit-impact-list">
+                {groupDiscogsReviewCredits(track.artistCredits).map(
+                  (credit) => (
+                    <CreditImpactRow
+                      credit={credit}
+                      dictionaries={dictionaries}
+                      key={`${track.position}-${credit.name}`}
+                    />
+                  ),
+                )}
+              </div>
+            ) : (
+              <p className="discogs-impact-empty">Inherits release artists.</p>
+            )}
+          </div>
+        </div>
+      ))}
+      {hiddenCount > 0 ? (
+        <button
+          className="button button-secondary button-compact discogs-track-toggle"
+          type="button"
+          aria-expanded={showAllTracks}
+          onClick={() => setShowAllTracks(true)}
+        >
+          Show {hiddenCount} more Discogs track row
+          {hiddenCount === 1 ? '' : 's'}
+        </button>
+      ) : showAllTracks && tracks.length > 4 ? (
+        <button
+          className="button button-secondary button-compact discogs-track-toggle"
+          type="button"
+          aria-expanded={showAllTracks}
+          onClick={() => setShowAllTracks(false)}
+        >
+          Show fewer Discogs track rows
+        </button>
+      ) : null}
+    </div>
+  )
+}
+
+function CreditImpactRow({
+  credit,
+  dictionaries,
+}: {
+  credit: GroupedDiscogsReviewCredit
+  dictionaries: CatalogDictionaries
+}) {
+  return (
+    <div className="discogs-credit-impact-row">
+      <strong>{credit.name}</strong>
+      <span className="discogs-credit-role-list">
+        {credit.roles.map((role) => (
+          <span className="badge badge-credit" key={role}>
+            {discogsRoleLabelFromCode(role, dictionaries)}
+          </span>
+        ))}
+      </span>
+    </div>
+  )
+}
+
+function ApplyGroup({
+  checked,
+  label,
+  onChange,
+}: {
+  checked: boolean
+  label: string
+  onChange: (checked: boolean) => void
+}) {
+  return (
+    <label className="compact-checkbox">
+      <input
+        type="checkbox"
+        checked={checked}
+        onChange={(event) => onChange(event.target.checked)}
+      />
+      <span>{label}</span>
+    </label>
+  )
+}
+
+function releaseLabelSummary(detail: ExternalMetadataReleaseDetailDto) {
+  return detail.draft.labels
+    .map((label) => [label.name, label.catalogNumber].filter(Boolean).join(' '))
+    .join(', ')
+}
+
+function formatDurationSeconds(durationSeconds: number) {
+  const minutes = Math.floor(durationSeconds / 60)
+  const seconds = durationSeconds % 60
+
+  return `${minutes}:${String(seconds).padStart(2, '0')}`
+}
diff --git a/src/features/releases/DiscogsReleaseLookupPanel.tsx b/src/features/releases/DiscogsReleaseLookupPanel.tsx
index 0e2ba46..7cd0102 100644
--- a/src/features/releases/DiscogsReleaseLookupPanel.tsx
+++ b/src/features/releases/DiscogsReleaseLookupPanel.tsx
@@ -1,5 +1,4 @@
 import { Search } from 'lucide-react'
-import type { ReactNode } from 'react'
 import { useEffect, useRef, useState } from 'react'
 import {
   CatalogApiError,
@@ -8,10 +7,8 @@ import {
   type CatalogDictionaries,
   type ExternalMetadataReleaseCandidateDto,
   type ExternalMetadataReleaseDetailDto,
-  type ExternalMetadataReleaseDraftArtistCreditDto,
-  type ExternalMetadataReleaseDraftTrackDto,
 } from '../catalog/catalogApi'
-import { discogsDraftTrackRows } from './discogsReleaseTrackRows'
+import { DiscogsCandidateReview } from './DiscogsCandidateReview'
 
 export type DiscogsApplyGroups = {
   core: boolean
@@ -339,128 +336,6 @@ function appliedGroupLabel(groups: DiscogsApplyGroups) {
     : `${labels.slice(0, -1).join(', ')} and ${labels.at(-1)}`
 }
 
-function DiscogsCandidateReview({
-  applyGroups,
-  current,
-  detail,
-  dictionaries,
-  hasSelectedGroup,
-  onApplyDraft,
-  onUpdateApplyGroup,
-}: {
-  applyGroups: DiscogsApplyGroups
-  current: DiscogsCurrentRelease
-  detail: ExternalMetadataReleaseDetailDto
-  dictionaries: CatalogDictionaries
-  hasSelectedGroup: boolean
-  onApplyDraft: (
-    detail: ExternalMetadataReleaseDetailDto,
-    groups: DiscogsApplyGroups,
-  ) => void
-  onUpdateApplyGroup: (
-    group: keyof DiscogsApplyGroups,
-    checked: boolean,
-  ) => void
-}) {
-  const compilationDetected = hasCompilationTrackArtists(detail)
-  const reviewTracks = discogsDraftTrackRows(detail.draft.tracklist)
-  const draftGenres = detail.draft.genres ?? []
-
-  return (
-    <div className="discogs-review-panel">
-      <div className="release-form-section-header">
-        <div>
-          <h3>Review Discogs candidate</h3>
-          <p>
-            {detail.source.attribution}{' '}
-            <a
-              className="detail-link"
-              href={detail.source.sourceUrl}
-              target="_blank"
-              rel="noreferrer"
-            >
-              Open Discogs source
-            </a>
-          </p>
-        </div>
-      </div>
-
-      <div className="discogs-impact-list">
-        <ImpactRow
-          checked={applyGroups.core}
-          currentValue={[
-            current.title || 'Not recorded',
-            current.releaseDate || current.year,
-          ]
-            .filter(Boolean)
-            .join(' · ')}
-          group="Core"
-          nextValue={[
-            detail.draft.title,
-            detail.draft.releaseDate || detail.draft.year?.toString(),
-          ]
-            .filter(Boolean)
-            .join(' · ')}
-          onChange={(checked) => onUpdateApplyGroup('core', checked)}
-        />
-        <ImpactRow
-          checked={applyGroups.artists}
-          currentValue={current.artists || 'Not recorded'}
-          group="Artists"
-          nextValue={`${detail.draft.artistCredits.length} Discogs credits`}
-          onChange={(checked) => onUpdateApplyGroup('artists', checked)}
-        >
-          <ArtistImpactList
-            credits={detail.draft.artistCredits}
-            dictionaries={dictionaries}
-          />
-        </ImpactRow>
-        <ImpactRow
-          checked={applyGroups.labels}
-          currentValue={current.labels || 'Not recorded'}
-          group="Labels"
-          nextValue={releaseLabelSummary(detail) || 'Not recorded'}
-          onChange={(checked) => onUpdateApplyGroup('labels', checked)}
-        />
-        <ImpactRow
-          checked={applyGroups.classification}
-          currentValue={current.genres || 'Not recorded'}
-          group="Classification"
-          nextValue={
-            draftGenres.length > 0 ? draftGenres.join(', ') : 'Not recorded'
-          }
-          onChange={(checked) => onUpdateApplyGroup('classification', checked)}
-        />
-        <ImpactRow
-          checked={applyGroups.tracklist}
-          currentValue={`${current.trackCount} rows`}
-          group="Tracklist"
-          nextValue={`${reviewTracks.length} Discogs rows`}
-          onChange={(checked) => onUpdateApplyGroup('tracklist', checked)}
-        >
-          {compilationDetected ? (
-            <p className="discogs-impact-warning">
-              Compilation detected: track-specific artists differ from release
-              artists. Applying Tracklist will mark the release as Various
-              Artists and write track-level artist credits.
-            </p>
-          ) : null}
-          <TrackImpactList dictionaries={dictionaries} tracks={reviewTracks} />
-        </ImpactRow>
-      </div>
-
-      <button
-        className="button button-primary button-compact"
-        type="button"
-        disabled={!hasSelectedGroup}
-        onClick={() => onApplyDraft(detail, applyGroups)}
-      >
-        Apply selected Discogs fields
-      </button>
-    </div>
-  )
-}
-
 function defaultGroups(mode: 'create' | 'update'): DiscogsApplyGroups {
   return mode === 'create'
     ? {
@@ -485,311 +360,3 @@ function externalMetadataErrorMessage(error: unknown) {
 
   return 'External metadata provider is unavailable.'
 }
-
-function ImpactRow({
-  checked,
-  children,
-  currentValue,
-  group,
-  nextValue,
-  onChange,
-}: {
-  checked: boolean
-  children?: ReactNode
-  currentValue: string
-  group: string
-  nextValue: string
-  onChange: (checked: boolean) => void
-}) {
-  return (
-    <div className="discogs-impact-row">
-      <ApplyGroup
-        checked={checked}
-        label={`Apply ${group}`}
-        onChange={onChange}
-      />
-      <div className="discogs-impact-group">{group}</div>
-      <div className="discogs-impact-value">
-        <span>Current</span>
-        <strong>{currentValue}</strong>
-      </div>
-      <div className="discogs-impact-value">
-        <span>Discogs</span>
-        <strong>{nextValue}</strong>
-        {children ? (
-          <div className="discogs-impact-detail">{children}</div>
-        ) : null}
-      </div>
-    </div>
-  )
-}
-
-function ArtistImpactList({
-  credits,
-  dictionaries,
-}: {
-  credits: ExternalMetadataReleaseDraftArtistCreditDto[]
-  dictionaries: CatalogDictionaries
-}) {
-  if (credits.length === 0) {
-    return <p className="discogs-impact-empty">No Discogs artist credits.</p>
-  }
-
-  return (
-    <div className="discogs-credit-impact-list">
-      {groupDiscogsReviewCredits(credits).map((credit) => (
-        <CreditImpactRow
-          credit={credit}
-          dictionaries={dictionaries}
-          key={credit.name}
-        />
-      ))}
-    </div>
-  )
-}
-
-function TrackImpactList({
-  dictionaries,
-  tracks,
-}: {
-  dictionaries: CatalogDictionaries
-  tracks: ExternalMetadataReleaseDraftTrackDto[]
-}) {
-  const [showAllTracks, setShowAllTracks] = useState(false)
-  const previewTracks = showAllTracks ? tracks : tracks.slice(0, 4)
-  const hiddenCount = tracks.length - previewTracks.length
-
-  if (tracks.length === 0) {
-    return <p className="discogs-impact-empty">No Discogs track rows.</p>
-  }
-
-  return (
-    <div className="discogs-track-impact-list">
-      {previewTracks.map((track) => (
-        <div className="discogs-track-impact-row" key={track.position}>
-          <span className="discogs-track-impact-position">
-            {track.position}
-          </span>
-          <div>
-            <strong>{track.title}</strong>
-            <p>
-              {track.durationSeconds
-                ? formatDurationSeconds(track.durationSeconds)
-                : 'No duration'}{' '}
-              · create track
-            </p>
-            {track.artistCredits.length > 0 ? (
-              <div className="discogs-credit-impact-list">
-                {groupDiscogsReviewCredits(track.artistCredits).map(
-                  (credit) => (
-                    <CreditImpactRow
-                      credit={credit}
-                      dictionaries={dictionaries}
-                      key={`${track.position}-${credit.name}`}
-                    />
-                  ),
-                )}
-              </div>
-            ) : (
-              <p className="discogs-impact-empty">Inherits release artists.</p>
-            )}
-          </div>
-        </div>
-      ))}
-      {hiddenCount > 0 ? (
-        <button
-          className="button button-secondary button-compact discogs-track-toggle"
-          type="button"
-          aria-expanded={showAllTracks}
-          onClick={() => setShowAllTracks(true)}
-        >
-          Show {hiddenCount} more Discogs track row
-          {hiddenCount === 1 ? '' : 's'}
-        </button>
-      ) : showAllTracks && tracks.length > 4 ? (
-        <button
-          className="button button-secondary button-compact discogs-track-toggle"
-          type="button"
-          aria-expanded={showAllTracks}
-          onClick={() => setShowAllTracks(false)}
-        >
-          Show fewer Discogs track rows
-        </button>
-      ) : null}
-    </div>
-  )
-}
-
-function CreditImpactRow({
-  credit,
-  dictionaries,
-}: {
-  credit: GroupedDiscogsReviewCredit
-  dictionaries: CatalogDictionaries
-}) {
-  return (
-    <div className="discogs-credit-impact-row">
-      <strong>{credit.name}</strong>
-      <span className="discogs-credit-role-list">
-        {credit.roles.map((role) => (
-          <span className="badge badge-credit" key={role}>
-            {roleLabelFromCode(role, dictionaries)}
-          </span>
-        ))}
-      </span>
-    </div>
-  )
-}
-
-type GroupedDiscogsReviewCredit = {
-  name: string
-  roles: string[]
-}
-
-function groupDiscogsReviewCredits(
-  credits: ExternalMetadataReleaseDraftArtistCreditDto[],
-) {
-  const grouped = new Map<string, GroupedDiscogsReviewCredit>()
-
-  credits.forEach((credit) => {
-    const name = credit.name.trim()
-    if (!name) {
-      return
-    }
-
-    const key = name.toLowerCase()
-    const existing = grouped.get(key)
-    const roles = splitRoleLabels(credit.role)
-
-    if (existing) {
-      existing.roles = [...new Set([...existing.roles, ...roles])]
-    } else {
-      grouped.set(key, { name, roles })
-    }
-  })
-
-  return [...grouped.values()]
-}
-
-function splitRoleLabels(role: string) {
-  const roles: string[] = []
-  let depth = 0
-  let current = ''
-
-  for (const character of role) {
-    if (character === '[' || character === '(') {
-      depth += 1
-    } else if ((character === ']' || character === ')') && depth > 0) {
-      depth -= 1
-    }
-
-    if (character === ',' && depth === 0) {
-      const trimmed = current.trim()
-      if (trimmed) {
-        roles.push(trimmed)
-      }
-      current = ''
-    } else {
-      current += character
-    }
-  }
-
-  const trimmed = current.trim()
-  if (trimmed) {
-    roles.push(trimmed)
-  }
-
-  return roles
-}
-
-function ApplyGroup({
-  checked,
-  label,
-  onChange,
-}: {
-  checked: boolean
-  label: string
-  onChange: (checked: boolean) => void
-}) {
-  return (
-    <label className="compact-checkbox">
-      <input
-        type="checkbox"
-        checked={checked}
-        onChange={(event) => onChange(event.target.checked)}
-      />
-      <span>{label}</span>
-    </label>
-  )
-}
-
-function releaseLabelSummary(detail: ExternalMetadataReleaseDetailDto) {
-  return detail.draft.labels
-    .map((label) => [label.name, label.catalogNumber].filter(Boolean).join(' '))
-    .join(', ')
-}
-
-function roleLabelFromCode(role: string, dictionaries: CatalogDictionaries) {
-  const trimmedRole = role.trim()
-
-  return (
-    dictionaries.creditRole.find(
-      (entry) => entry.code === trimmedRole || entry.name === trimmedRole,
-    )?.name ?? trimmedRole
-  )
-}
-
-function hasCompilationTrackArtists(detail: ExternalMetadataReleaseDetailDto) {
-  const releaseMainArtists = normalizedSet(
-    detail.draft.artistCredits
-      .filter((credit) => normalizeText(credit.role) === 'mainartist')
-      .map((credit) => credit.name),
-  )
-  const releaseArtists =
-    releaseMainArtists.size > 0
-      ? releaseMainArtists
-      : normalizedSet(detail.draft.artistCredits.map((credit) => credit.name))
-
-  return detail.draft.tracklist.some((track) => {
-    const trackMainArtists = normalizedSet(
-      track.artistCredits
-        .filter((credit) => normalizeText(credit.role) === 'mainartist')
-        .map((credit) => credit.name),
-    )
-
-    if (trackMainArtists.size === 0) {
-      return false
-    }
-
-    return !setsEqual(releaseArtists, trackMainArtists)
-  })
-}
-
-function normalizedSet(values: string[]) {
-  return new Set(values.map(normalizeText).filter(Boolean))
-}
-
-function normalizeText(value: string) {
-  return value.trim().toLowerCase()
-}
-
-function setsEqual(left: Set<string>, right: Set<string>) {
-  if (left.size !== right.size) {
-    return false
-  }
-
-  for (const value of left) {
-    if (!right.has(value)) {
-      return false
-    }
-  }
-
-  return true
-}
-
-function formatDurationSeconds(durationSeconds: number) {
-  const minutes = Math.floor(durationSeconds / 60)
-  const seconds = durationSeconds % 60
-
-  return `${minutes}:${String(seconds).padStart(2, '0')}`
-}
diff --git a/src/features/releases/ReleaseArtistCreditsSection.tsx b/src/features/releases/ReleaseArtistCreditsSection.tsx
index 7c4aad0..2335b6b 100644
--- a/src/features/releases/ReleaseArtistCreditsSection.tsx
+++ b/src/features/releases/ReleaseArtistCreditsSection.tsx
@@ -101,8 +101,11 @@ export function ReleaseArtistCreditsSection({
                       {artistName || 'Unnamed artist'}
                     </span>
                     <span className="release-artist-chip-roles">
-                      {credit.roles.map((role) => (
-                        <span className="release-artist-role-pill" key={role}>
+                      {credit.roles.map((role, index) => (
+                        <span
+                          className="release-artist-role-pill"
+                          key={`${credit.id}-${role}-${index}`}
+                        >
                           <span>{role}</span>
                           <button
                             type="button"
@@ -163,20 +166,25 @@ function addCreditRole(
   role: string,
   setArtistCredits: Dispatch<SetStateAction<EditableArtistCredit[]>>,
 ) {
-  if (!role || credit.roles.includes(role)) {
+  if (!role) {
     return
   }
 
   setArtistCredits((credits) =>
-    credits.map((currentCredit) =>
-      currentCredit.id === credit.id
-        ? {
-            ...currentCredit,
-            role: currentCredit.role || role,
-            roles: [...currentCredit.roles, role],
-          }
-        : currentCredit,
-    ),
+    credits.map((currentCredit) => {
+      if (
+        currentCredit.id !== credit.id ||
+        currentCredit.roles.includes(role)
+      ) {
+        return currentCredit
+      }
+
+      return {
+        ...currentCredit,
+        role: currentCredit.role || role,
+        roles: [...currentCredit.roles, role],
+      }
+    }),
   )
 }
 
@@ -185,17 +193,20 @@ function removeCreditRole(
   role: string,
   setArtistCredits: Dispatch<SetStateAction<EditableArtistCredit[]>>,
 ) {
-  const nextRoles = credit.roles.filter((currentRole) => currentRole !== role)
-
   setArtistCredits((credits) =>
-    credits.map((currentCredit) =>
-      currentCredit.id === credit.id
-        ? {
-            ...currentCredit,
-            role: nextRoles[0] ?? '',
-            roles: nextRoles,
-          }
-        : currentCredit,
-    ),
+    credits.map((currentCredit) => {
+      if (currentCredit.id !== credit.id) {
+        return currentCredit
+      }
+
+      const nextRoles = currentCredit.roles.filter(
+        (currentRole) => currentRole !== role,
+      )
+      return {
+        ...currentCredit,
+        role: nextRoles[0] ?? '',
+        roles: nextRoles,
+      }
+    }),
   )
 }
diff --git a/src/features/releases/ReleaseDetail.tsx b/src/features/releases/ReleaseDetail.tsx
index 2bea626..14e7ba9 100644
--- a/src/features/releases/ReleaseDetail.tsx
+++ b/src/features/releases/ReleaseDetail.tsx
@@ -109,6 +109,7 @@ export function ReleaseDetail({
         <p>{release.artist}</p>
         {onEdit ||
         onUpdateViaDiscogs ||
+        onDelete ||
         (onEditLocalFiles && localTracks.length > 0) ? (
           <div className="detail-actions">
             {onEdit ? (
diff --git a/src/features/releases/ReleaseEntryForm.tsx b/src/features/releases/ReleaseEntryForm.tsx
index 0c13ed3..5c7b6a0 100644
--- a/src/features/releases/ReleaseEntryForm.tsx
+++ b/src/features/releases/ReleaseEntryForm.tsx
@@ -22,6 +22,8 @@ import {
   type DiscogsApplyGroups,
 } from './DiscogsReleaseLookupPanel'
 import { discogsDraftTrackRows } from './discogsReleaseTrackRows'
+import { groupDiscogsCredits } from './discogsReleaseApply'
+import { discogsTracklistNeedsVariousArtists } from './discogsRoleUtils'
 import { ReleaseArtistCreditsSection } from './ReleaseArtistCreditsSection'
 import { ReleaseClassificationSection } from './ReleaseClassificationSection'
 import { ReleaseCoreSection } from './ReleaseCoreSection'
@@ -379,7 +381,14 @@ export function ReleaseEntryForm({
 
     if (groups.artists) {
       setIsVariousArtists(false)
-      setArtistCredits(groupDiscogsCredits(draft.artistCredits, 'release'))
+      setArtistCredits(
+        groupDiscogsCredits(
+          draft.artistCredits,
+          'release',
+          artists,
+          dictionaries,
+        ),
+      )
       setDraftArtist('')
       setDraftArtistId('')
     }
@@ -427,6 +436,8 @@ export function ReleaseEntryForm({
             artistCredits: groupDiscogsCredits(
               track.artistCredits,
               `track-${index + 1}`,
+              artists,
+              dictionaries,
             ),
             draftArtist: '',
             draftArtistId: '',
@@ -444,38 +455,6 @@ export function ReleaseEntryForm({
     )
   }
 
-  function groupDiscogsCredits(
-    credits: ReadonlyArray<{ name: string; role: string }>,
-    prefix: string,
-  ): EditableArtistCredit[] {
-    const grouped = new Map<string, EditableArtistCredit>()
-
-    credits.forEach((credit, index) => {
-      const editableCredit = editableCreditFromDiscogsCredit(
-        credit.name,
-        credit.role,
-        index,
-        prefix,
-      )
-      const key =
-        editableCredit.artistId ||
-        editableCredit.artist.trim().toLowerCase() ||
-        editableCredit.id
-      const existing = grouped.get(key)
-
-      if (existing) {
-        existing.roles = [
-          ...new Set([...existing.roles, ...editableCredit.roles]),
-        ]
-        existing.role = existing.roles[0] ?? ''
-      } else {
-        grouped.set(key, editableCredit)
-      }
-    })
-
-    return [...grouped.values()]
-  }
-
   function releaseTypeValueFromCode(code: string) {
     return (
       dictionaries?.releaseType.find((entry) => entry.code === code)?.name ??
@@ -483,47 +462,6 @@ export function ReleaseEntryForm({
     )
   }
 
-  function editableCreditFromDiscogsCredit(
-    name: string,
-    role: string,
-    index: number,
-    prefix = 'release',
-  ): EditableArtistCredit {
-    const trimmedName = name.trim()
-    const existingArtist = artists.find(
-      (artist) => artist.name.toLowerCase() === trimmedName.toLowerCase(),
-    )
-
-    const roles = roleLabelsFromCode(role)
-
-    return {
-      id: createManualRecordId(
-        `${prefix}-artist-credit`,
-        `discogs-${index + 1}`,
-      ),
-      artistId: existingArtist?.id ?? '',
-      artist: existingArtist ? '' : trimmedName,
-      role: roles[0] ?? '',
-      roles,
-    }
-  }
-
-  function roleLabelsFromCode(role: string) {
-    return [
-      ...new Set(
-        role
-          .split(',')
-          .map((part) => part.trim())
-          .filter(Boolean)
-          .map(
-            (part) =>
-              dictionaries.creditRole.find((entry) => entry.code === part)
-                ?.name ?? part,
-          ),
-      ),
-    ]
-  }
-
   return (
     <ManualEntryPanel
       title={formTitle}
@@ -647,57 +585,6 @@ export function ReleaseEntryForm({
   )
 }
 
-function discogsTracklistNeedsVariousArtists(
-  tracklist: ExternalMetadataReleaseDetailDto['draft']['tracklist'],
-  draft: ExternalMetadataReleaseDetailDto['draft'],
-) {
-  const releaseMainArtists = normalizedSet(
-    draft.artistCredits
-      .filter((credit) => normalizeText(credit.role) === 'mainartist')
-      .map((credit) => credit.name),
-  )
-  const releaseArtists =
-    releaseMainArtists.size > 0
-      ? releaseMainArtists
-      : normalizedSet(draft.artistCredits.map((credit) => credit.name))
-
-  return tracklist.some((track) => {
-    const trackMainArtists = normalizedSet(
-      track.artistCredits
-        .filter((credit) => normalizeText(credit.role) === 'mainartist')
-        .map((credit) => credit.name),
-    )
-
-    if (trackMainArtists.size === 0) {
-      return false
-    }
-
-    return !setsEqual(releaseArtists, trackMainArtists)
-  })
-}
-
-function normalizedSet(values: string[]) {
-  return new Set(values.map(normalizeText).filter(Boolean))
-}
-
-function normalizeText(value: string) {
-  return value.trim().toLowerCase()
-}
-
-function setsEqual(left: Set<string>, right: Set<string>) {
-  if (left.size !== right.size) {
-    return false
-  }
-
-  for (const value of left) {
-    if (!right.has(value)) {
-      return false
-    }
-  }
-
-  return true
-}
-
 function hasMainArtistRole(credit: { role: string; roles?: string[] }) {
   return (
     credit.roles && credit.roles.length > 0 ? credit.roles : [credit.role]
diff --git a/src/features/releases/discogs-release-lookup.css b/src/features/releases/discogs-release-lookup.css
new file mode 100644
index 0000000..bfab10d
--- /dev/null
+++ b/src/features/releases/discogs-release-lookup.css
@@ -0,0 +1,307 @@
+.discogs-release-lookup {
+  max-width: 100%;
+  min-width: 0;
+  border: 1px solid var(--color-border);
+  border-radius: var(--radius-sm);
+  background: #fbfcfa;
+  padding: 12px;
+}
+
+.discogs-release-lookup * {
+  min-width: 0;
+}
+
+.discogs-release-lookup .button {
+  max-width: 100%;
+  flex-wrap: wrap;
+  height: auto;
+  overflow-wrap: anywhere;
+  text-align: center;
+}
+
+.discogs-release-lookup .button span {
+  min-width: 0;
+  overflow-wrap: anywhere;
+  white-space: normal;
+}
+
+.discogs-search-form {
+  display: grid;
+  grid-template-columns: repeat(5, minmax(0, 1fr)) auto;
+  gap: 8px;
+  align-items: end;
+  min-width: 0;
+}
+
+.discogs-search-form label {
+  min-width: 0;
+}
+
+.discogs-lookup-status {
+  margin: 0;
+  color: var(--color-muted);
+  font-size: 12px;
+  font-weight: 650;
+}
+
+.discogs-apply-status {
+  margin: 0;
+  border: 1px solid #c8d4c4;
+  border-radius: var(--radius-sm);
+  background: #eef3eb;
+  color: #405f42;
+  font-size: 12px;
+  font-weight: 700;
+  padding: 8px 10px;
+}
+
+.discogs-candidate-list,
+.discogs-review-panel {
+  display: grid;
+  gap: 8px;
+  min-width: 0;
+}
+
+.discogs-candidate {
+  display: grid;
+  gap: 12px;
+  min-width: 0;
+  border: 1px solid var(--color-border);
+  border-radius: var(--radius-sm);
+  background: var(--color-surface);
+  padding: 10px;
+}
+
+.discogs-candidate.is-selected {
+  border-color: #aeb6ad;
+  box-shadow: 0 0 0 1px rgba(81, 111, 82, 0.12);
+}
+
+.discogs-candidate-summary {
+  display: grid;
+  grid-template-columns: minmax(0, 1fr) auto;
+  gap: 12px;
+  align-items: start;
+  min-width: 0;
+}
+
+.discogs-candidate strong,
+.discogs-impact-row strong {
+  color: var(--color-heading);
+  font-size: 13px;
+}
+
+.discogs-candidate p {
+  margin: 2px 0 0;
+  color: var(--color-muted);
+  font-size: 12px;
+}
+
+.discogs-candidate-actions {
+  display: grid;
+  justify-items: end;
+  gap: 8px;
+  min-width: 0;
+}
+
+.discogs-candidate-actions .detail-link {
+  overflow-wrap: anywhere;
+  text-align: right;
+}
+
+.discogs-review-panel {
+  gap: 10px;
+  border-top: 1px dashed var(--color-border);
+  padding-top: 10px;
+}
+
+.discogs-impact-list {
+  display: grid;
+  gap: 0;
+}
+
+.discogs-impact-row {
+  display: grid;
+  grid-template-columns:
+    minmax(120px, 150px) minmax(84px, 110px) minmax(0, 1fr)
+    minmax(0, 1.6fr);
+  gap: 12px;
+  align-items: start;
+  min-width: 0;
+  border-bottom: 1px solid var(--color-border);
+  padding: 9px 0;
+}
+
+.discogs-impact-row:last-child {
+  border-bottom: 0;
+}
+
+.discogs-impact-group,
+.discogs-impact-value > span {
+  color: var(--color-soft);
+  font-size: 10px;
+  font-weight: 780;
+  letter-spacing: 0.06em;
+  text-transform: uppercase;
+}
+
+.discogs-impact-value {
+  display: grid;
+  gap: 2px;
+  min-width: 0;
+}
+
+.discogs-impact-value strong {
+  min-width: 0;
+  overflow-wrap: break-word;
+  color: var(--color-heading);
+  font-size: 12px;
+  font-weight: 650;
+}
+
+.discogs-impact-detail {
+  display: grid;
+  gap: 8px;
+  margin-top: 8px;
+  min-width: 0;
+}
+
+.discogs-credit-impact-list,
+.discogs-track-impact-list {
+  display: grid;
+  gap: 6px;
+}
+
+.discogs-credit-impact-row {
+  display: grid;
+  grid-template-columns: minmax(130px, 1fr) auto;
+  gap: 8px;
+  align-items: center;
+  min-width: 0;
+  border-top: 1px solid var(--color-border);
+  padding-top: 6px;
+}
+
+.discogs-credit-impact-row:first-child {
+  border-top: 0;
+  padding-top: 0;
+}
+
+.discogs-credit-impact-row .badge {
+  justify-self: start;
+}
+
+.discogs-credit-role-list {
+  display: flex;
+  flex-wrap: wrap;
+  justify-content: flex-end;
+  gap: 4px;
+}
+
+.discogs-track-impact-row {
+  display: grid;
+  grid-template-columns: 34px minmax(0, 1fr);
+  gap: 8px;
+  min-width: 0;
+  border-top: 1px solid var(--color-border);
+  padding-top: 7px;
+}
+
+.discogs-track-impact-row:first-child {
+  border-top: 0;
+  padding-top: 0;
+}
+
+.discogs-track-impact-position {
+  display: inline-grid;
+  width: 28px;
+  height: 24px;
+  place-items: center;
+  border: 1px solid var(--color-border);
+  border-radius: var(--radius-sm);
+  background: #f8faf6;
+  color: var(--color-muted);
+  font-size: 11px;
+  font-weight: 760;
+}
+
+.discogs-track-impact-row p,
+.discogs-impact-empty,
+.discogs-impact-warning {
+  margin: 2px 0 0;
+  color: var(--color-muted);
+  font-size: 11px;
+}
+
+.discogs-impact-warning {
+  border: 1px solid #ead19a;
+  border-radius: var(--radius-sm);
+  background: #fbf4df;
+  color: #7a5618;
+  padding: 7px 8px;
+}
+
+.discogs-track-toggle {
+  justify-self: start;
+}
+
+.discogs-apply-groups {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 8px 12px;
+  min-width: 0;
+  border: 0;
+  margin: 0;
+  padding: 0;
+}
+
+.discogs-apply-groups legend {
+  width: 100%;
+  color: var(--color-soft);
+  font-size: 11px;
+  font-weight: 780;
+  letter-spacing: 0.06em;
+  text-transform: uppercase;
+}
+
+@media (max-width: 860px) {
+  .discogs-search-form {
+    grid-template-columns: repeat(2, minmax(0, 1fr));
+  }
+
+  .discogs-search-form > .button {
+    justify-self: start;
+  }
+
+  .discogs-candidate-summary,
+  .discogs-impact-row,
+  .discogs-credit-impact-row {
+    grid-template-columns: 1fr;
+  }
+
+  .discogs-candidate-actions {
+    justify-items: start;
+  }
+
+  .discogs-candidate-actions .detail-link {
+    text-align: left;
+  }
+}
+
+@media (max-width: 560px) {
+  .discogs-search-form {
+    grid-template-columns: 1fr;
+  }
+
+  .discogs-search-form > .button,
+  .discogs-candidate-actions .button {
+    width: 100%;
+    min-width: 0;
+    white-space: normal;
+  }
+
+  .discogs-candidate-actions {
+    justify-items: stretch;
+    width: 100%;
+  }
+}
diff --git a/src/features/releases/discogsReleaseApply.ts b/src/features/releases/discogsReleaseApply.ts
new file mode 100644
index 0000000..9fa0943
--- /dev/null
+++ b/src/features/releases/discogsReleaseApply.ts
@@ -0,0 +1,64 @@
+import type { ArtistRecord } from '../artists/artistsData'
+import type { CatalogDictionaries } from '../catalog/catalogApi'
+import { createManualRecordId } from '../manualEntry/manualEntryUtils'
+import type { EditableArtistCredit } from './ReleaseEntryFormTypes'
+import { discogsRoleLabels } from './discogsRoleUtils'
+
+export function groupDiscogsCredits(
+  credits: ReadonlyArray<{ name: string; role: string }>,
+  prefix: string,
+  artists: ArtistRecord[],
+  dictionaries: CatalogDictionaries,
+): EditableArtistCredit[] {
+  const grouped = new Map<string, EditableArtistCredit>()
+
+  credits.forEach((credit, index) => {
+    const editableCredit = editableCreditFromDiscogsCredit(
+      credit.name,
+      credit.role,
+      index,
+      prefix,
+      artists,
+      dictionaries,
+    )
+    const key =
+      editableCredit.artistId ||
+      editableCredit.artist.trim().toLowerCase() ||
+      editableCredit.id
+    const existing = grouped.get(key)
+
+    if (existing) {
+      existing.roles = [
+        ...new Set([...existing.roles, ...editableCredit.roles]),
+      ]
+      existing.role = existing.roles[0] ?? ''
+    } else {
+      grouped.set(key, editableCredit)
+    }
+  })
+
+  return [...grouped.values()]
+}
+
+function editableCreditFromDiscogsCredit(
+  name: string,
+  role: string,
+  index: number,
+  prefix: string,
+  artists: ArtistRecord[],
+  dictionaries: CatalogDictionaries,
+): EditableArtistCredit {
+  const trimmedName = name.trim()
+  const existingArtist = artists.find(
+    (artist) => artist.name.toLowerCase() === trimmedName.toLowerCase(),
+  )
+  const roles = discogsRoleLabels(role, dictionaries)
+
+  return {
+    id: createManualRecordId(`${prefix}-artist-credit`, `discogs-${index + 1}`),
+    artistId: existingArtist?.id ?? '',
+    artist: existingArtist ? '' : trimmedName,
+    role: roles[0] ?? '',
+    roles,
+  }
+}
diff --git a/src/features/releases/discogsRoleUtils.ts b/src/features/releases/discogsRoleUtils.ts
new file mode 100644
index 0000000..af2693e
--- /dev/null
+++ b/src/features/releases/discogsRoleUtils.ts
@@ -0,0 +1,146 @@
+import type {
+  CatalogDictionaries,
+  ExternalMetadataReleaseDetailDto,
+  ExternalMetadataReleaseDraftArtistCreditDto,
+} from '../catalog/catalogApi'
+
+export type GroupedDiscogsReviewCredit = {
+  name: string
+  roles: string[]
+}
+
+export function discogsRoleLabels(
+  role: string,
+  dictionaries: CatalogDictionaries,
+) {
+  return splitDiscogsRoleLabels(role).map((part) =>
+    discogsRoleLabelFromCode(part, dictionaries),
+  )
+}
+
+export function discogsRoleLabelFromCode(
+  role: string,
+  dictionaries: CatalogDictionaries,
+) {
+  const trimmedRole = role.trim()
+
+  return (
+    dictionaries.creditRole.find(
+      (entry) => entry.code === trimmedRole || entry.name === trimmedRole,
+    )?.name ?? trimmedRole
+  )
+}
+
+export function groupDiscogsReviewCredits(
+  credits: ExternalMetadataReleaseDraftArtistCreditDto[],
+) {
+  const grouped = new Map<string, GroupedDiscogsReviewCredit>()
+
+  credits.forEach((credit) => {
+    const name = credit.name.trim()
+    if (!name) {
+      return
+    }
+
+    const key = name.toLowerCase()
+    const existing = grouped.get(key)
+    const roles = splitDiscogsRoleLabels(credit.role)
+
+    if (existing) {
+      existing.roles = [...new Set([...existing.roles, ...roles])]
+    } else {
+      grouped.set(key, { name, roles })
+    }
+  })
+
+  return [...grouped.values()]
+}
+
+export function splitDiscogsRoleLabels(role: string) {
+  const roles: string[] = []
+  let depth = 0
+  let current = ''
+
+  for (const character of role) {
+    if (character === '[' || character === '(') {
+      depth += 1
+    } else if ((character === ']' || character === ')') && depth > 0) {
+      depth -= 1
+    }
+
+    if (character === ',' && depth === 0) {
+      pushRole(current, roles)
+      current = ''
+    } else {
+      current += character
+    }
+  }
+
+  pushRole(current, roles)
+  return roles
+}
+
+export function hasCompilationTrackArtists(
+  detail: ExternalMetadataReleaseDetailDto,
+) {
+  return discogsTracklistNeedsVariousArtists(
+    detail.draft.tracklist,
+    detail.draft,
+  )
+}
+
+export function discogsTracklistNeedsVariousArtists(
+  tracklist: ExternalMetadataReleaseDetailDto['draft']['tracklist'],
+  draft: ExternalMetadataReleaseDetailDto['draft'],
+) {
+  const releaseMainArtists = normalizedSet(
+    draft.artistCredits
+      .filter((credit) => normalizeText(credit.role) === 'mainartist')
+      .map((credit) => credit.name),
+  )
+  const releaseArtists =
+    releaseMainArtists.size > 0
+      ? releaseMainArtists
+      : normalizedSet(draft.artistCredits.map((credit) => credit.name))
+
+  return tracklist.some((track) => {
+    const trackMainArtists = normalizedSet(
+      track.artistCredits
+        .filter((credit) => normalizeText(credit.role) === 'mainartist')
+        .map((credit) => credit.name),
+    )
+
+    return (
+      trackMainArtists.size > 0 && !setsEqual(releaseArtists, trackMainArtists)
+    )
+  })
+}
+
+function pushRole(value: string, roles: string[]) {
+  const trimmed = value.trim()
+  if (trimmed) {
+    roles.push(trimmed)
+  }
+}
+
+function normalizedSet(values: string[]) {
+  return new Set(values.map(normalizeText).filter(Boolean))
+}
+
+function normalizeText(value: string) {
+  return value.trim().toLowerCase()
+}
+
+function setsEqual(left: Set<string>, right: Set<string>) {
+  if (left.size !== right.size) {
+    return false
+  }
+
+  for (const value of left) {
+    if (!right.has(value)) {
+      return false
+    }
+  }
+
+  return true
+}
diff --git a/src/features/releases/release-form.css b/src/features/releases/release-form.css
index 4b1cff2..9320e9d 100644
--- a/src/features/releases/release-form.css
+++ b/src/features/releases/release-form.css
@@ -37,276 +37,6 @@
   gap: 8px;
 }
 
-.discogs-release-lookup {
-  max-width: 100%;
-  min-width: 0;
-  border: 1px solid var(--color-border);
-  border-radius: var(--radius-sm);
-  background: #fbfcfa;
-  padding: 12px;
-}
-
-.discogs-release-lookup * {
-  min-width: 0;
-}
-
-.discogs-release-lookup .button {
-  max-width: 100%;
-  flex-wrap: wrap;
-  height: auto;
-  overflow-wrap: anywhere;
-  text-align: center;
-}
-
-.discogs-release-lookup .button span {
-  min-width: 0;
-  overflow-wrap: anywhere;
-  white-space: normal;
-}
-
-.discogs-search-form {
-  display: grid;
-  grid-template-columns: repeat(5, minmax(0, 1fr)) auto;
-  gap: 8px;
-  align-items: end;
-  min-width: 0;
-}
-
-.discogs-search-form label {
-  min-width: 0;
-}
-
-.discogs-lookup-status {
-  margin: 0;
-  color: var(--color-muted);
-  font-size: 12px;
-  font-weight: 650;
-}
-
-.discogs-apply-status {
-  margin: 0;
-  border: 1px solid #c8d4c4;
-  border-radius: var(--radius-sm);
-  background: #eef3eb;
-  color: #405f42;
-  font-size: 12px;
-  font-weight: 700;
-  padding: 8px 10px;
-}
-
-.discogs-candidate-list,
-.discogs-review-panel {
-  display: grid;
-  gap: 8px;
-  min-width: 0;
-}
-
-.discogs-candidate {
-  display: grid;
-  gap: 12px;
-  min-width: 0;
-  border: 1px solid var(--color-border);
-  border-radius: var(--radius-sm);
-  background: var(--color-surface);
-  padding: 10px;
-}
-
-.discogs-candidate.is-selected {
-  border-color: #aeb6ad;
-  box-shadow: 0 0 0 1px rgba(81, 111, 82, 0.12);
-}
-
-.discogs-candidate-summary {
-  display: grid;
-  grid-template-columns: minmax(0, 1fr) auto;
-  gap: 12px;
-  align-items: start;
-  min-width: 0;
-}
-
-.discogs-candidate strong,
-.discogs-impact-row strong {
-  color: var(--color-heading);
-  font-size: 13px;
-}
-
-.discogs-candidate p {
-  margin: 2px 0 0;
-  color: var(--color-muted);
-  font-size: 12px;
-}
-
-.discogs-candidate-actions {
-  display: grid;
-  justify-items: end;
-  gap: 8px;
-  min-width: 0;
-}
-
-.discogs-candidate-actions .detail-link {
-  overflow-wrap: anywhere;
-  text-align: right;
-}
-
-.discogs-review-panel {
-  display: grid;
-  gap: 10px;
-  border-top: 1px dashed var(--color-border);
-  padding-top: 10px;
-}
-
-.discogs-impact-list {
-  display: grid;
-  gap: 0;
-}
-
-.discogs-impact-row {
-  display: grid;
-  grid-template-columns:
-    minmax(120px, 150px) minmax(84px, 110px) minmax(0, 1fr)
-    minmax(0, 1.6fr);
-  gap: 12px;
-  align-items: start;
-  min-width: 0;
-  border-bottom: 1px solid var(--color-border);
-  padding: 9px 0;
-}
-
-.discogs-impact-row:last-child {
-  border-bottom: 0;
-}
-
-.discogs-impact-group,
-.discogs-impact-value > span {
-  color: var(--color-soft);
-  font-size: 10px;
-  font-weight: 780;
-  letter-spacing: 0.06em;
-  text-transform: uppercase;
-}
-
-.discogs-impact-value {
-  display: grid;
-  gap: 2px;
-  min-width: 0;
-}
-
-.discogs-impact-value strong {
-  min-width: 0;
-  overflow-wrap: break-word;
-  font-size: 12px;
-}
-
-.discogs-impact-value strong {
-  color: var(--color-heading);
-  font-weight: 650;
-}
-
-.discogs-impact-detail {
-  display: grid;
-  gap: 8px;
-  margin-top: 8px;
-  min-width: 0;
-}
-
-.discogs-credit-impact-list,
-.discogs-track-impact-list {
-  display: grid;
-  gap: 6px;
-}
-
-.discogs-credit-impact-row {
-  display: grid;
-  grid-template-columns: minmax(130px, 1fr) auto;
-  gap: 8px;
-  align-items: center;
-  min-width: 0;
-  border-top: 1px solid var(--color-border);
-  padding-top: 6px;
-}
-
-.discogs-credit-impact-row:first-child {
-  border-top: 0;
-  padding-top: 0;
-}
-
-.discogs-credit-impact-row .badge {
-  justify-self: start;
-}
-
-.discogs-credit-role-list {
-  display: flex;
-  flex-wrap: wrap;
-  justify-content: flex-end;
-  gap: 4px;
-}
-
-.discogs-track-impact-row {
-  display: grid;
-  grid-template-columns: 34px minmax(0, 1fr);
-  gap: 8px;
-  min-width: 0;
-  border-top: 1px solid var(--color-border);
-  padding-top: 7px;
-}
-
-.discogs-track-impact-row:first-child {
-  border-top: 0;
-  padding-top: 0;
-}
-
-.discogs-track-impact-position {
-  display: inline-grid;
-  width: 28px;
-  height: 24px;
-  place-items: center;
-  border: 1px solid var(--color-border);
-  border-radius: var(--radius-sm);
-  background: #f8faf6;
-  color: var(--color-muted);
-  font-size: 11px;
-  font-weight: 760;
-}
-
-.discogs-track-impact-row p,
-.discogs-impact-empty,
-.discogs-impact-warning {
-  margin: 2px 0 0;
-  color: var(--color-muted);
-  font-size: 11px;
-}
-
-.discogs-impact-warning {
-  border: 1px solid #ead19a;
-  border-radius: var(--radius-sm);
-  background: #fbf4df;
-  color: #7a5618;
-  padding: 7px 8px;
-}
-
-.discogs-track-toggle {
-  justify-self: start;
-}
-
-.discogs-apply-groups {
-  display: flex;
-  flex-wrap: wrap;
-  gap: 8px 12px;
-  min-width: 0;
-  border: 0;
-  margin: 0;
-  padding: 0;
-}
-
-.discogs-apply-groups legend {
-  width: 100%;
-  color: var(--color-soft);
-  font-size: 11px;
-  font-weight: 780;
-  letter-spacing: 0.06em;
-  text-transform: uppercase;
-}
-
 .button-compact {
   min-height: 30px;
   padding: 0 10px;
@@ -708,47 +438,9 @@
   .release-row-checkbox {
     padding-top: 0;
   }
-
-  .discogs-search-form {
-    grid-template-columns: repeat(2, minmax(0, 1fr));
-  }
-
-  .discogs-search-form > .button {
-    justify-self: start;
-  }
-
-  .discogs-candidate-summary,
-  .discogs-impact-row,
-  .discogs-credit-impact-row {
-    grid-template-columns: 1fr;
-  }
-
-  .discogs-candidate-actions {
-    justify-items: start;
-  }
-
-  .discogs-candidate-actions .detail-link {
-    text-align: left;
-  }
 }
 
 @media (max-width: 560px) {
-  .discogs-search-form {
-    grid-template-columns: 1fr;
-  }
-
-  .discogs-search-form > .button,
-  .discogs-candidate-actions .button {
-    width: 100%;
-    min-width: 0;
-    white-space: normal;
-  }
-
-  .discogs-candidate-actions {
-    justify-items: stretch;
-    width: 100%;
-  }
-
   .release-form-section-header,
   .release-section-actions {
     align-items: stretch;
diff --git a/src/features/releases/releases.css b/src/features/releases/releases.css
index 41308e2..0526ee4 100644
--- a/src/features/releases/releases.css
+++ b/src/features/releases/releases.css
@@ -1,4 +1,5 @@
 @import './release-form.css';
+@import './discogs-release-lookup.css';
 @import './release-tracklist.css';
 @import './release-track-artists.css';
 @import './release-detail.css';
diff --git a/src/features/tracks/TrackEntryForm.tsx b/src/features/tracks/TrackEntryForm.tsx
index 64c1dca..ec1b259 100644
--- a/src/features/tracks/TrackEntryForm.tsx
+++ b/src/features/tracks/TrackEntryForm.tsx
@@ -32,6 +32,7 @@ import {
   trackReleaseAppearances,
   trackReleaseDisplay,
 } from './trackDisplayHelpers'
+import { groupDiscogsTrackCredits } from './discogsTrackApply'
 import type { TrackRecord } from './tracksData'
 
 export type TrackEntryFormProps = {
@@ -254,7 +255,13 @@ export function TrackEntryForm({
     }
 
     if (groups.credits) {
-      setCredits(groupDiscogsCredits(detail.draft.artistCredits))
+      setCredits(
+        groupDiscogsTrackCredits(
+          detail.draft.artistCredits,
+          artists,
+          dictionaries,
+        ),
+      )
     }
 
     setExternalSources(
@@ -265,77 +272,6 @@ export function TrackEntryForm({
     )
   }
 
-  function groupDiscogsCredits(
-    artistCredits: ReadonlyArray<{ name: string; role: string }>,
-  ) {
-    const grouped = new Map<
-      string,
-      ReturnType<typeof editableCreditFromDiscogsCredit>
-    >()
-
-    artistCredits.forEach((credit, index) => {
-      const editableCredit = editableCreditFromDiscogsCredit(
-        credit.name,
-        credit.role,
-        index,
-      )
-      const key =
-        editableCredit.artistId ||
-        editableCredit.artist.trim().toLowerCase() ||
-        editableCredit.id
-      const existing = grouped.get(key)
-
-      if (existing) {
-        existing.roles = [
-          ...new Set([...existing.roles, ...editableCredit.roles]),
-        ]
-        existing.role = existing.roles[0] ?? ''
-      } else {
-        grouped.set(key, editableCredit)
-      }
-    })
-
-    return [...grouped.values()]
-  }
-
-  function editableCreditFromDiscogsCredit(
-    artistName: string,
-    role: string,
-    index: number,
-  ) {
-    const normalizedArtistName = artistName.trim()
-    const existingArtist = artists.find(
-      (record) =>
-        record.name.toLowerCase() === normalizedArtistName.toLowerCase(),
-    )
-
-    const roles = roleLabelsFromCode(role)
-
-    return {
-      id: createManualRecordId(
-        'track-credit',
-        `${normalizedArtistName}-${role}-${index}`,
-      ),
-      artistId: existingArtist?.id,
-      artist: existingArtist?.name ?? normalizedArtistName,
-      role: roles[0] ?? '',
-      roles,
-      scope: 'Suggested by Discogs track detail.',
-    }
-  }
-
-  function roleLabelsFromCode(role: string) {
-    return [
-      ...new Set(
-        role
-          .split(',')
-          .map((part) => part.trim())
-          .filter(Boolean)
-          .map((part) => toCreditRole(part)),
-      ),
-    ]
-  }
-
   return (
     <ManualEntryPanel
       title={formTitle}
@@ -500,8 +436,11 @@ export function TrackEntryForm({
                       {credit.artist}
                     </span>
                     <span className="release-artist-chip-roles">
-                      {credit.roles.map((role) => (
-                        <span className="release-artist-role-pill" key={role}>
+                      {credit.roles.map((role, index) => (
+                        <span
+                          className="release-artist-role-pill"
+                          key={`${credit.id}-${role}-${index}`}
+                        >
                           <span>{role}</span>
                           <button
                             type="button"
diff --git a/src/features/tracks/discogsTrackApply.ts b/src/features/tracks/discogsTrackApply.ts
new file mode 100644
index 0000000..0df3ed3
--- /dev/null
+++ b/src/features/tracks/discogsTrackApply.ts
@@ -0,0 +1,74 @@
+import type { ArtistRecord } from '../artists/artistsData'
+import type { CatalogDictionaries } from '../catalog/catalogApi'
+import { createManualRecordId } from '../manualEntry/manualEntryUtils'
+import { discogsRoleLabels } from '../releases/discogsRoleUtils'
+
+export type EditableTrackCredit = {
+  artist: string
+  artistId?: string
+  id: string
+  role: string
+  roles: string[]
+  scope: string
+}
+
+export function groupDiscogsTrackCredits(
+  artistCredits: ReadonlyArray<{ name: string; role: string }>,
+  artists: ArtistRecord[],
+  dictionaries: CatalogDictionaries,
+) {
+  const grouped = new Map<string, EditableTrackCredit>()
+
+  artistCredits.forEach((credit, index) => {
+    const editableCredit = editableCreditFromDiscogsCredit(
+      credit.name,
+      credit.role,
+      index,
+      artists,
+      dictionaries,
+    )
+    const key =
+      editableCredit.artistId ||
+      editableCredit.artist.trim().toLowerCase() ||
+      editableCredit.id
+    const existing = grouped.get(key)
+
+    if (existing) {
+      existing.roles = [
+        ...new Set([...existing.roles, ...editableCredit.roles]),
+      ]
+      existing.role = existing.roles[0] ?? ''
+    } else {
+      grouped.set(key, editableCredit)
+    }
+  })
+
+  return [...grouped.values()]
+}
+
+function editableCreditFromDiscogsCredit(
+  artistName: string,
+  role: string,
+  index: number,
+  artists: ArtistRecord[],
+  dictionaries: CatalogDictionaries,
+): EditableTrackCredit {
+  const normalizedArtistName = artistName.trim()
+  const existingArtist = artists.find(
+    (record) =>
+      record.name.toLowerCase() === normalizedArtistName.toLowerCase(),
+  )
+  const roles = discogsRoleLabels(role, dictionaries)
+
+  return {
+    id: createManualRecordId(
+      'track-credit',
+      `${normalizedArtistName}-${role}-${index}`,
+    ),
+    artistId: existingArtist?.id,
+    artist: existingArtist?.name ?? normalizedArtistName,
+    role: roles[0] ?? '',
+    roles,
+    scope: 'Suggested by Discogs track detail.',
+  }
+}
diff --git a/src/features/tracks/tracks.css b/src/features/tracks/tracks.css
index 07e37be..7ba989c 100644
--- a/src/features/tracks/tracks.css
+++ b/src/features/tracks/tracks.css
@@ -155,6 +155,14 @@
 }
 
 @media (max-width: 700px) {
+  .discogs-track-lookup .discogs-search-form {
+    grid-template-columns: minmax(0, 1fr);
+  }
+
+  .discogs-track-lookup .discogs-search-form > .button {
+    justify-self: stretch;
+  }
+
   .track-entry-layout,
   .track-core-grid,
   .track-credit-composer,
diff --git a/src/test/appTestHarness.ts b/src/test/appTestHarness.ts
index 87540e8..44b165b 100644
--- a/src/test/appTestHarness.ts
+++ b/src/test/appTestHarness.ts
@@ -486,9 +486,11 @@ export async function addReleaseArtist(
 ) {
   await user.type(within(form).getByLabelText('Release artist'), name)
   await user.click(within(form).getByRole('button', { name: 'Add artist' }))
-  await user.selectOptions(
-    within(form).getByLabelText(`Role for ${name}`),
-    role,
+  await user.click(within(form).getByLabelText(`Role for ${name}`))
+  await user.click(
+    within(form).getByRole('menuitem', {
+      name: role,
+    }),
   )
 }