diff --git a/client/src/components/AppHeader.vue b/client/src/components/AppHeader.vue
index de1b98e4a..7bec7bdf5 100644
--- a/client/src/components/AppHeader.vue
+++ b/client/src/components/AppHeader.vue
@@ -430,7 +430,7 @@ function formatBadgeStyle(fmt: string, result?: GlobalSearchResult) {
                 <BookCoverImage
                   :book-id="row.result.id"
                   type="thumbnail"
-                  :version="row.result.updatedAt"
+                  :version="row.result.coverVersion"
                   class="h-16 w-12 object-cover rounded shrink-0 bg-muted"
                   :alt="row.result.title ?? ''"
                 />
@@ -559,7 +559,7 @@ function formatBadgeStyle(fmt: string, result?: GlobalSearchResult) {
                 <BookCoverImage
                   :book-id="row.result.id"
                   type="thumbnail"
-                  :version="row.result.updatedAt"
+                  :version="row.result.coverVersion"
                   class="h-16 w-12 object-cover rounded shrink-0 bg-muted"
                   :alt="row.result.title ?? ''"
                 />
diff --git a/client/src/components/__tests__/AppHeader.spec.ts b/client/src/components/__tests__/AppHeader.spec.ts
index c2b8eddb0..ae8ee8905 100644
--- a/client/src/components/__tests__/AppHeader.spec.ts
+++ b/client/src/components/__tests__/AppHeader.spec.ts
@@ -155,6 +155,7 @@ function makeResult(id: number, title = 'Prey'): GlobalSearchResult {
     readStatus: null,
     addedAt: '2026-01-01T00:00:00.000Z',
     updatedAt: null,
+    coverVersion: 'legacy:2026-01-01T00:00:00.000Z',
     metadataScore: null,
     hasCover: false,
     hasMetadataLocks: false,
diff --git a/client/src/features/book-dock/components/BookDockFileSheet.vue b/client/src/features/book-dock/components/BookDockFileSheet.vue
index 655c01290..d9bed296d 100644
--- a/client/src/features/book-dock/components/BookDockFileSheet.vue
+++ b/client/src/features/book-dock/components/BookDockFileSheet.vue
@@ -4,8 +4,10 @@ import { useI18n } from 'vue-i18n'
 import { formatDateTime } from '@/i18n/formatters'
 import { X, BookOpen, Check, Trash2, Sparkles, ArrowLeft, Wand2, AlertCircle } from '@lucide/vue'
 import {
+  getBookMediaKind,
   resolveBookDockSearchTitle,
   type BookDockFile,
+  type CoverMedium,
   type BookDockMetadata,
   type MetadataCandidate,
   type MetadataSource,
@@ -20,7 +22,7 @@ import MetadataDiffPanel from '@/features/book/components/detail/tabs/MetadataDi
 import { useBookDockDetail } from '../composables/useBookDockDetail'
 import { useLibraries } from '@/features/library/composables/useLibraries'
 import { useMetadataSearch } from '@/features/book/composables/useMetadataSearch'
-import type { MetadataPatch } from '@/features/book/composables/useMetadataDiff'
+import type { MetadataDiffApply } from '@/features/book/composables/useMetadataDiff'
 import { formatBytes } from '@/lib/formatting'
 import { toDisplayCoverUrl } from '@/features/book/lib/metadata-fetch'
 
@@ -277,8 +279,13 @@ function openSearch() {
   loadProviders()
 }
 
+// A dock file has one medium, so its search asks only the providers for it, and audio files get square art.
+const fileMediaKind = computed(() => getBookMediaKind(props.file.format))
+const fileCoverMedium = computed<CoverMedium>(() => (fileMediaKind.value === 'audiobook' ? 'audio' : 'ebook'))
+
 function handleSearchSubmit(params: { title: string; author: string; isbn: string }) {
-  search(params)
+  const mediaKind = fileMediaKind.value
+  search(mediaKind === 'unknown' ? params : { ...params, mediaKind })
 }
 
 function selectCandidate(candidate: MetadataCandidate) {
@@ -296,7 +303,7 @@ function backFromDiff() {
   selectedCandidate.value = null
 }
 
-async function handleApply(patch: { formPatch: MetadataPatch; coverUrl?: string }) {
+async function handleApply(patch: MetadataDiffApply) {
   const p = patch.formPatch
   const bookDockPatch = { ...p }
   delete bookDockPatch.customMetadata
@@ -315,9 +322,10 @@ async function handleApply(patch: { formPatch: MetadataPatch; coverUrl?: string
   if ('authors' in p) form.authors = (p.authors ?? []).join(', ')
   if ('genres' in p) form.genres = (p.genres ?? []).join(', ')
 
-  if (patch.coverUrl !== undefined) {
-    selectedCoverUrl.value = patch.coverUrl
-    passthroughMetadata.value.coverUrl = patch.coverUrl
+  const coverUrl = patch.coverUrl ?? patch.audioCoverUrl
+  if (coverUrl !== undefined) {
+    selectedCoverUrl.value = coverUrl
+    passthroughMetadata.value.coverUrl = coverUrl
   }
 
   if (debounceTimer) {
@@ -681,6 +689,7 @@ onMounted(() => {
             :providers="providers"
             :back-label="diffSource === 'fetched' ? t('common.back') : t('bookDock.sheet.results')"
             :current-cover-url="currentBookDockCoverUrl"
+            :cover-medium="fileCoverMedium"
             :provider-ids="providerIds"
             @back="backFromDiff"
             @apply="handleApply"
diff --git a/client/src/features/book-dock/components/__tests__/BookDockFileSheet.spec.ts b/client/src/features/book-dock/components/__tests__/BookDockFileSheet.spec.ts
index d6fe26899..c4e0a5ef3 100644
--- a/client/src/features/book-dock/components/__tests__/BookDockFileSheet.spec.ts
+++ b/client/src/features/book-dock/components/__tests__/BookDockFileSheet.spec.ts
@@ -53,11 +53,13 @@ const MetadataSearchPanelStub = defineComponent({
       required: true,
     },
   },
+  emits: ['search', 'select'],
   template: '<div data-test="metadata-search-panel" />',
 })
 
 const MetadataDiffPanelStub = defineComponent({
   name: 'MetadataDiffPanel',
+  props: { coverMedium: { type: String, default: undefined } },
   emits: ['apply'],
   template: '<div data-test="metadata-diff-panel" />',
 })
@@ -249,6 +251,27 @@ describe('BookDockFileSheet metadata search defaults', () => {
     )
   })
 
+  it('searches a docked audio file as an audiobook and stages the audiobook cover it picks', async () => {
+    const candidate: MetadataCandidate = { provider: 'audible', providerId: 'B0DUNE', title: 'Dune' }
+    mocks.filteredResults.push(candidate)
+    const wrapper = mountSheet(makeFile({ fileName: 'Dune.m4b', format: 'm4b' }))
+    const searchButton = wrapper.findAll('button').find((button) => button.text().trim() === 'Search')
+    await searchButton!.trigger('click')
+
+    wrapper.getComponent(MetadataSearchPanelStub).vm.$emit('search', { title: 'Dune', author: 'Frank Herbert', isbn: '' })
+    expect(mocks.search).toHaveBeenLastCalledWith({ title: 'Dune', author: 'Frank Herbert', isbn: '', mediaKind: 'audiobook' })
+
+    wrapper.getComponent(MetadataSearchPanelStub).vm.$emit('select', candidate)
+    await wrapper.vm.$nextTick()
+    const diff = wrapper.getComponent(MetadataDiffPanelStub)
+    expect(diff.props('coverMedium')).toBe('audio')
+
+    diff.vm.$emit('apply', { formPatch: {}, audioCoverUrl: 'https://covers.example/dune-audio.jpg' })
+    await wrapper.vm.$nextTick()
+
+    expect(mocks.saveMetadata).toHaveBeenCalledWith(1, expect.objectContaining({ coverUrl: 'https://covers.example/dune-audio.jpg' }))
+  })
+
   it('requests confirmation before discarding the file', async () => {
     const dockFile = makeFile()
     const wrapper = mountSheet(dockFile)
diff --git a/client/src/features/book-requests/__tests__/RequestSearchPanel.spec.ts b/client/src/features/book-requests/__tests__/RequestSearchPanel.spec.ts
index 86f7f0b4e..e0dd2e9ab 100644
--- a/client/src/features/book-requests/__tests__/RequestSearchPanel.spec.ts
+++ b/client/src/features/book-requests/__tests__/RequestSearchPanel.spec.ts
@@ -36,6 +36,7 @@ const state = vi.hoisted(
       routeQuery: Record<string, string>
       toastError: ReturnType<typeof vi.fn>
       lastFailure: Ref<{ code: string | null; meta: Record<string, unknown> | null; message: string | null } | null>
+      coverOrder: Ref<readonly string[]> | null
     },
 )
 
@@ -72,7 +73,8 @@ vi.mock('@/features/book/composables/useMetadataSearch', async () => {
   return {
     useMetadataSearch: () => ({
       filteredResults: ref([]),
-      coverProviderOrder: ref([]),
+      coverProviderOrder: ref(['amazon', 'itunes']),
+      audioCoverProviderOrder: ref(['audible', 'itunes']),
       resultProviderOrder: ref([]),
       interruptedProviders: ref([]),
       isStreaming: ref(false),
@@ -108,7 +110,12 @@ vi.mock('../composables/useRequestSubmission', async (importOriginal) => {
 vi.mock('../composables/useCandidateGroups', async () => {
   const { ref } = await import('vue')
   state.groups = ref([])
-  return { useCandidateGroups: () => ({ groups: state.groups }) }
+  return {
+    useCandidateGroups: (_results: unknown, _mediaKind: unknown, _availability: unknown, coverOrder: Ref<readonly string[]>) => {
+      state.coverOrder = coverOrder
+      return { groups: state.groups }
+    },
+  }
 })
 
 vi.mock('../composables/useRequestDestinationDefault', async (importOriginal) => {
@@ -795,4 +802,12 @@ describe('RequestSearchPanel free-text fallback', () => {
 
     expect(state.push).not.toHaveBeenCalled()
   })
+
+  it('orders an audiobook request’s cover art by the Audiobook cover rule', async () => {
+    await render()
+
+    expect(state.coverOrder?.value).toEqual(['amazon', 'itunes'])
+    state.mediaKind.value = 'audiobook'
+    expect(state.coverOrder?.value).toEqual(['audible', 'itunes'])
+  })
 })
diff --git a/client/src/features/book-requests/components/RequestSearchPanel.vue b/client/src/features/book-requests/components/RequestSearchPanel.vue
index ec912de78..a6c6b6068 100644
--- a/client/src/features/book-requests/components/RequestSearchPanel.vue
+++ b/client/src/features/book-requests/components/RequestSearchPanel.vue
@@ -61,8 +61,18 @@ import RequestCover from './RequestCover.vue'
 const emit = defineEmits<{ submitted: [] }>()
 
 const { t, locale } = useI18n()
-const { filteredResults, coverProviderOrder, resultProviderOrder, interruptedProviders, isStreaming, hasSearched, providers, loadProviders, search } =
-  useMetadataSearch()
+const {
+  filteredResults,
+  coverProviderOrder,
+  audioCoverProviderOrder,
+  resultProviderOrder,
+  interruptedProviders,
+  isStreaming,
+  hasSearched,
+  providers,
+  loadProviders,
+  search,
+} = useMetadataSearch()
 const { libraries, fetchLibraries } = useLibraries()
 const { hasPermission } = usePermissions()
 const { user } = useAuth()
@@ -106,7 +116,9 @@ const targetFolderId = ref<number | null>(null)
 const activeCoverUrls = ref<Record<string, string | null>>({})
 const failedProviderIcons = ref(new Set<MetadataProviderKey>())
 const expandedMetadataGroups = ref(new Set<string>())
-const { groups } = useCandidateGroups(filteredResults, mediaKind, getAvailability, coverProviderOrder, language, resultProviderOrder)
+// An audiobook request shows audiobook art, so its covers follow the Audiobook cover rule.
+const requestCoverProviderOrder = computed(() => (mediaKind.value === 'audiobook' ? audioCoverProviderOrder.value : coverProviderOrder.value))
+const { groups } = useCandidateGroups(filteredResults, mediaKind, getAvailability, requestCoverProviderOrder, language, resultProviderOrder)
 
 // Nobody approves these requests afterwards, so this is the only chance to say where the book goes.
 const autoApproves = computed(() => hasPermission(Permission.BookRequestAutoApprove))
diff --git a/client/src/features/book/components/BookCoverCard.test.ts b/client/src/features/book/components/BookCoverCard.test.ts
index 57544b822..c8be39860 100644
--- a/client/src/features/book/components/BookCoverCard.test.ts
+++ b/client/src/features/book/components/BookCoverCard.test.ts
@@ -6,6 +6,9 @@ import BookCoverCard from './BookCoverCard.vue'
 
 // -- module mocks (must precede imports) -------------------------------------
 
+const mockToastError = vi.hoisted(() => vi.fn<(message: string) => void>())
+vi.mock('vue-sonner', () => ({ toast: { error: mockToastError, success: vi.fn<(message: string) => void>() } }))
+
 const mockRouterPush = vi.fn<() => void>()
 vi.mock('vue-router', () => ({
   useRoute: () => ({ fullPath: '/' }),
@@ -153,6 +156,7 @@ function makeBook(overrides: Partial<BookCard> = {}): BookCard {
     readStatus: null,
     addedAt: '2024-01-01T00:00:00Z',
     updatedAt: null,
+    coverVersion: 'legacy:2024-01-01T00:00:00Z',
     metadataScore: 90,
     hasCover: false,
     hasMetadataLocks: false,
@@ -467,7 +471,7 @@ describe('BookCoverCard', () => {
     it('uses coverUrl composable for the image src', () => {
       const book = makeBook({ id: 42, hasCover: true })
       mountCard({ book })
-      expect(mockCoverUrl).toHaveBeenCalledWith(42, 'thumbnail', book.addedAt)
+      expect(mockCoverUrl).toHaveBeenCalledWith(42, 'thumbnail', book.coverVersion)
     })
 
     it('constrains overlays to the natural fitted cover frame after image load', async () => {
@@ -637,6 +641,34 @@ describe('BookCoverCard', () => {
       expect(mockDownloadFile).toHaveBeenCalledWith(22)
       expect(mockExportBooks).not.toHaveBeenCalled()
     })
+
+    it('reports a failed cover regeneration and keeps the cached cover', async () => {
+      const fetchMock = vi.fn<() => Promise<{ ok: boolean }>>().mockResolvedValue({ ok: false })
+      vi.stubGlobal('fetch', fetchMock)
+      const wrapper = mountCard({ book: makeBook({ id: 42 }) })
+      const regenerate = wrapper.findAll('[data-testid="dropdown-item"]').find((item) => item.text().trim() === 'Regenerate Cover')
+
+      await regenerate!.trigger('click')
+      await flushPromises()
+
+      expect(fetchMock).toHaveBeenCalledWith('/api/v1/books/42/re-extract-cover', { method: 'POST' })
+      expect(mockToastError).toHaveBeenCalledWith('Could not regenerate the cover')
+      expect(mockBumpVersion).not.toHaveBeenCalled()
+      vi.unstubAllGlobals()
+    })
+
+    it('refreshes the cover after a successful regeneration', async () => {
+      vi.stubGlobal('fetch', vi.fn<() => Promise<{ ok: boolean }>>().mockResolvedValue({ ok: true }))
+      const wrapper = mountCard({ book: makeBook({ id: 42 }) })
+      const regenerate = wrapper.findAll('[data-testid="dropdown-item"]').find((item) => item.text().trim() === 'Regenerate Cover')
+
+      await regenerate!.trigger('click')
+      await flushPromises()
+
+      expect(mockBumpVersion).toHaveBeenCalledWith(42)
+      expect(mockToastError).not.toHaveBeenCalled()
+      vi.unstubAllGlobals()
+    })
   })
 
   // ── cover aspect ratio ────────────────────────────────────────────────────
diff --git a/client/src/features/book/components/BookCoverCard.vue b/client/src/features/book/components/BookCoverCard.vue
index b9da119d6..c8d295879 100644
--- a/client/src/features/book/components/BookCoverCard.vue
+++ b/client/src/features/book/components/BookCoverCard.vue
@@ -53,6 +53,7 @@ import BookCoverArtwork from './BookCoverArtwork.vue'
 import BookCoverSurface from './BookCoverSurface.vue'
 import { fetchAuthors } from '@/features/author/api/author'
 import { useI18n } from 'vue-i18n'
+import { toast } from 'vue-sonner'
 import { hasReadAlong, READ_ALONG_FORMAT_COLOR, READ_ALONG_FORMAT_TITLE } from '@/features/book/lib/file-capabilities'
 
 const { t } = useI18n()
@@ -104,7 +105,7 @@ const openableFiles = computed(() => {
 })
 
 const { coverUrl, bumpVersion } = useCoverVersions()
-const coverSrc = computed(() => coverUrl(props.book.id, 'thumbnail', props.book.updatedAt ?? props.book.addedAt))
+const coverSrc = computed(() => coverUrl(props.book.id, 'thumbnail', props.book.coverVersion))
 
 const { refreshing, refreshWithFeedback } = useRefreshMetadata()
 const { isRefreshing } = useRefreshingBooks()
@@ -115,8 +116,14 @@ async function reExtractCover() {
   if (reExtractingCover.value) return
   reExtractingCover.value = true
   try {
-    await fetch(`/api/v1/books/${props.book.id}/re-extract-cover`, { method: 'POST' })
+    const res = await fetch(`/api/v1/books/${props.book.id}/re-extract-cover`, { method: 'POST' })
+    if (!res.ok) {
+      toast.error(t('book.coverRegeneration.failed'))
+      return
+    }
     bumpVersion(props.book.id)
+  } catch {
+    toast.error(t('book.coverRegeneration.failed'))
   } finally {
     reExtractingCover.value = false
   }
@@ -703,7 +710,7 @@ const secondaryLabelText = computed(() => resolveBookLabel(gridCardSecondaryLabe
                         <RefreshCw v-else class="size-4 mr-2" />
                         {{ t('book.actions.refreshMetadata') }}
                       </DropdownMenuItem>
-                      <DropdownMenuItem :disabled="reExtractingCover" @click="reExtractCover()">
+                      <DropdownMenuItem :disabled="reExtractingCover" @click="reExtractCover">
                         <Loader2 v-if="reExtractingCover" class="size-4 mr-2 animate-spin" />
                         <Image v-else class="size-4 mr-2" />
                         {{ t('book.actions.regenerateCover') }}
@@ -845,7 +852,7 @@ const secondaryLabelText = computed(() => resolveBookLabel(gridCardSecondaryLabe
                   <RefreshCw v-else class="size-4 mr-2" />
                   {{ t('book.actions.refreshMetadata') }}
                 </DropdownMenuItem>
-                <DropdownMenuItem :disabled="reExtractingCover" @click="reExtractCover()">
+                <DropdownMenuItem :disabled="reExtractingCover" @click="reExtractCover">
                   <Loader2 v-if="reExtractingCover" class="size-4 mr-2 animate-spin" />
                   <Image v-else class="size-4 mr-2" />
                   {{ t('book.actions.regenerateCover') }}
diff --git a/client/src/features/book/components/BookCoverLightbox.vue b/client/src/features/book/components/BookCoverLightbox.vue
new file mode 100644
index 000000000..fd66fb888
--- /dev/null
+++ b/client/src/features/book/components/BookCoverLightbox.vue
@@ -0,0 +1,92 @@
+<script setup lang="ts">
+import { computed, inject, ref, watch } from 'vue'
+import { useI18n } from 'vue-i18n'
+import { X } from '@lucide/vue'
+import { DialogClose, DialogContent, DialogDescription, DialogOverlay, DialogPortal, DialogRoot, DialogTitle } from 'reka-ui'
+import type { BookDetail, CoverMedium } from '@bookorbit/types'
+import { useCoverVersions } from '../composables/useCoverVersions'
+import { COVER_ASPECT_RATIO_KEY, DEFAULT_COVER_ASPECT_RATIO } from '../lib/cover-aspect-ratio'
+import { faceMedium } from '../lib/cover-slots'
+import CoverMediumSwitch from './CoverMediumSwitch.vue'
+
+const props = defineProps<{
+  open: boolean
+  book: Pick<BookDetail, 'id' | 'title' | 'covers' | 'coverVersion'>
+  /** The slot to open on. Without one the lightbox opens on the face, as the page shows it. */
+  medium?: CoverMedium | null
+  /** Unsaved editor images, shown in place of the saved slot they would replace. */
+  previews?: Partial<Record<CoverMedium, string | null>>
+}>()
+const emit = defineEmits<{ 'update:open': [open: boolean] }>()
+
+const { t } = useI18n()
+const { coverUrl } = useCoverVersions()
+const coverAspectRatio = inject(COVER_ASPECT_RATIO_KEY, ref(DEFAULT_COVER_ASPECT_RATIO))
+
+function hasImage(medium: CoverMedium): boolean {
+  return Boolean(props.previews?.[medium]) || props.book.covers[medium] !== null
+}
+
+const canSwitch = computed(() => hasImage('ebook') && hasImage('audio'))
+const selected = ref<CoverMedium | null>(null)
+
+watch(
+  () => props.open,
+  (open) => {
+    if (!open) return
+    selected.value = props.medium ?? (canSwitch.value ? faceMedium(props.book, coverAspectRatio.value) : null)
+  },
+  { immediate: true },
+)
+
+const src = computed(() => {
+  const medium = selected.value
+  if (!medium) return coverUrl(props.book.id, 'cover', props.book.coverVersion)
+  const preview = props.previews?.[medium]
+  if (preview) return preview
+  const slot = props.book.covers[medium]
+  return slot ? coverUrl(props.book.id, 'cover', slot.updatedAt, medium) : coverUrl(props.book.id, 'cover', props.book.coverVersion)
+})
+
+const switchValue = computed<CoverMedium>({
+  get: () => selected.value ?? faceMedium(props.book, coverAspectRatio.value),
+  set: (medium) => {
+    selected.value = medium
+  },
+})
+
+function handleOpenChange(open: boolean) {
+  emit('update:open', open)
+}
+</script>
+
+<template>
+  <DialogRoot :open="props.open" @update:open="handleOpenChange">
+    <DialogPortal>
+      <DialogOverlay
+        class="fixed inset-0 z-50 bg-black/80 data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 motion-reduce:animate-none"
+      />
+      <DialogContent
+        class="fixed left-1/2 top-1/2 z-50 flex max-h-[90vh] max-w-[90vw] -translate-x-1/2 -translate-y-1/2 flex-col items-center gap-3 outline-none data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 motion-reduce:animate-none"
+      >
+        <DialogTitle class="sr-only">{{ t('book.detail.coverLightbox.title') }}</DialogTitle>
+        <DialogDescription class="sr-only">{{ t('book.detail.coverLightbox.description') }}</DialogDescription>
+        <CoverMediumSwitch v-if="canSwitch" v-model="switchValue" :label="t('book.detail.coverLightbox.switchLabel')" />
+        <div class="relative min-h-0">
+          <img
+            :src="src"
+            :alt="props.book.title ?? ''"
+            class="rounded-md object-contain shadow-2xl"
+            :class="canSwitch ? 'max-h-[calc(90vh-3rem)] max-w-[90vw]' : 'max-h-[90vh] max-w-[90vw]'"
+          />
+          <DialogClose
+            class="absolute -top-3 -right-3 rounded-full border border-border bg-background p-1 text-muted-foreground transition-colors hover:text-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-primary"
+            :aria-label="t('common.close')"
+          >
+            <X class="size-4" aria-hidden="true" />
+          </DialogClose>
+        </div>
+      </DialogContent>
+    </DialogPortal>
+  </DialogRoot>
+</template>
diff --git a/client/src/features/book/components/BookListRow.vue b/client/src/features/book/components/BookListRow.vue
index 27d285571..8f3d5cc91 100644
--- a/client/src/features/book/components/BookListRow.vue
+++ b/client/src/features/book/components/BookListRow.vue
@@ -146,7 +146,7 @@ async function setRating(star: number) {
 }
 
 const { coverUrl } = useCoverVersions()
-const coverSrc = computed(() => coverUrl(props.book.id, 'thumbnail', props.book.updatedAt ?? props.book.addedAt))
+const coverSrc = computed(() => coverUrl(props.book.id, 'thumbnail', props.book.coverVersion))
 
 const { refreshing, refreshWithFeedback } = useRefreshMetadata()
 const injectedCoverAspectRatio = inject(COVER_ASPECT_RATIO_KEY, ref(DEFAULT_COVER_ASPECT_RATIO))
@@ -197,7 +197,7 @@ function openSeriesDetails() {
 }
 
 function collapsedCoverVersion(bookId: number): string | null | undefined {
-  if (bookId === props.book.id) return props.book.updatedAt ?? props.book.addedAt
+  if (bookId === props.book.id) return props.book.coverVersion
   return collapsedSeries.value?.coverUpdatedAtByBookId?.[bookId]
 }
 
diff --git a/client/src/features/book/components/BookQuickView.vue b/client/src/features/book/components/BookQuickView.vue
index bc7b19e81..6ca7d5b57 100644
--- a/client/src/features/book/components/BookQuickView.vue
+++ b/client/src/features/book/components/BookQuickView.vue
@@ -60,7 +60,7 @@ watch(
 )
 
 const { coverUrl } = useCoverVersions()
-const coverSrc = computed(() => (detail.value ? coverUrl(detail.value.id, 'cover', detail.value.updatedAt ?? detail.value.addedAt) : null))
+const coverSrc = computed(() => (detail.value ? coverUrl(detail.value.id, 'cover', detail.value.coverVersion) : null))
 
 const coverSeed = computed(() => (detail.value ? (detail.value.title ?? detail.value.folderPath.split('/').pop() ?? String(detail.value.id)) : ''))
 const coverPlaceholderTitle = computed(() => (detail.value ? (detail.value.title ?? detail.value.folderPath.split('/').pop() ?? null) : null))
diff --git a/client/src/features/book/components/CollapsedSeriesCard.vue b/client/src/features/book/components/CollapsedSeriesCard.vue
index 21131c46a..f93b82589 100644
--- a/client/src/features/book/components/CollapsedSeriesCard.vue
+++ b/client/src/features/book/components/CollapsedSeriesCard.vue
@@ -107,7 +107,7 @@ function handleSingleCoverError() {
 }
 
 function coverVersionFor(bookId: number): string | null | undefined {
-  if (bookId === props.book.id) return props.book.updatedAt ?? props.book.addedAt
+  if (bookId === props.book.id) return props.book.coverVersion
   return collapsed.value.coverUpdatedAtByBookId?.[bookId]
 }
 
diff --git a/client/src/features/book/components/CoverFill.vue b/client/src/features/book/components/CoverFill.vue
new file mode 100644
index 000000000..4eb4cbf3a
--- /dev/null
+++ b/client/src/features/book/components/CoverFill.vue
@@ -0,0 +1,27 @@
+<script setup lang="ts">
+withDefaults(
+  defineProps<{
+    src: string
+    alt?: string
+    loading?: 'lazy' | 'eager'
+  }>(),
+  {
+    alt: '',
+    loading: 'lazy',
+  },
+)
+</script>
+
+<template>
+  <span class="relative isolate block h-full w-full overflow-hidden rounded-[inherit] bg-muted">
+    <img
+      :src="src"
+      alt=""
+      aria-hidden="true"
+      class="absolute inset-0 h-full w-full scale-125 object-cover blur-xl brightness-75 motion-reduce:transition-none"
+      :loading="loading"
+      decoding="async"
+    />
+    <img :src="src" :alt="alt" class="relative z-10 h-full w-full object-contain motion-reduce:transition-none" :loading="loading" decoding="async" />
+  </span>
+</template>
diff --git a/client/src/features/book/components/CoverMediumSwitch.vue b/client/src/features/book/components/CoverMediumSwitch.vue
new file mode 100644
index 000000000..b4d8bb24d
--- /dev/null
+++ b/client/src/features/book/components/CoverMediumSwitch.vue
@@ -0,0 +1,61 @@
+<script setup lang="ts">
+import { computed, nextTick, ref } from 'vue'
+import { useI18n } from 'vue-i18n'
+import type { CoverMedium } from '@bookorbit/types'
+import { nextRovingIndex } from '@/lib/roving-index'
+
+const props = defineProps<{ modelValue: CoverMedium; label: string }>()
+const emit = defineEmits<{ 'update:modelValue': [value: CoverMedium] }>()
+
+const { t } = useI18n()
+
+const options = computed(() => [
+  { value: 'ebook' as const, label: t('book.detail.coverLightbox.ebook') },
+  { value: 'audio' as const, label: t('book.detail.coverLightbox.audio') },
+])
+
+const group = ref<HTMLElement | null>(null)
+
+function select(value: CoverMedium) {
+  emit('update:modelValue', value)
+}
+
+function handleKeydown(event: KeyboardEvent) {
+  const index = options.value.findIndex((option) => option.value === props.modelValue)
+  const next = nextRovingIndex(event.key, index, options.value.length)
+  if (next === null) return
+  event.preventDefault()
+  const value = options.value[next]!.value
+  select(value)
+  void nextTick(() => group.value?.querySelector<HTMLButtonElement>(`[data-medium="${value}"]`)?.focus())
+}
+</script>
+
+<template>
+  <div
+    ref="group"
+    role="radiogroup"
+    :aria-label="props.label"
+    class="inline-flex gap-0.5 rounded-md border border-border bg-muted p-0.5"
+    @keydown="handleKeydown"
+  >
+    <button
+      v-for="option in options"
+      :key="option.value"
+      :data-medium="option.value"
+      type="button"
+      role="radio"
+      :aria-checked="props.modelValue === option.value"
+      :tabindex="props.modelValue === option.value ? 0 : -1"
+      class="inline-flex h-7 items-center rounded px-3 text-xs transition-colors focus-visible:outline-2 focus-visible:outline-offset-1 focus-visible:outline-primary"
+      :class="
+        props.modelValue === option.value
+          ? 'bg-background font-semibold text-foreground shadow-xs'
+          : 'font-medium text-muted-foreground hover:text-foreground'
+      "
+      @click="select(option.value)"
+    >
+      {{ option.label }}
+    </button>
+  </div>
+</template>
diff --git a/client/src/features/book/components/VirtualBookGrid.spec.ts b/client/src/features/book/components/VirtualBookGrid.spec.ts
index e02ae5c62..7e0551ef5 100644
--- a/client/src/features/book/components/VirtualBookGrid.spec.ts
+++ b/client/src/features/book/components/VirtualBookGrid.spec.ts
@@ -74,6 +74,7 @@ function makeBook(id: number, overrides: Partial<BookCard> = {}): BookCard {
     readStatus: null,
     addedAt: '2026-01-01T00:00:00.000Z',
     updatedAt: null,
+    coverVersion: 'legacy:2026-01-01T00:00:00.000Z',
     metadataScore: null,
     hasCover: false,
     hasMetadataLocks: false,
diff --git a/client/src/features/book/components/__tests__/BookCoverCard.spec.ts b/client/src/features/book/components/__tests__/BookCoverCard.spec.ts
index ef6dc27c8..dcd01cf33 100644
--- a/client/src/features/book/components/__tests__/BookCoverCard.spec.ts
+++ b/client/src/features/book/components/__tests__/BookCoverCard.spec.ts
@@ -102,6 +102,7 @@ const missingBook: BookCard = {
   readStatus: null,
   addedAt: '2026-01-01T00:00:00.000Z',
   updatedAt: null,
+  coverVersion: 'legacy:2026-01-01T00:00:00.000Z',
   metadataScore: null,
   hasCover: false,
   hasMetadataLocks: false,
@@ -133,6 +134,7 @@ const presentBook: BookCard = {
   readStatus: null,
   addedAt: '2026-01-01T00:00:00.000Z',
   updatedAt: null,
+  coverVersion: 'legacy:2026-01-01T00:00:00.000Z',
   metadataScore: null,
   hasCover: false,
   hasMetadataLocks: false,
diff --git a/client/src/features/book/components/__tests__/BookCoverLightbox.spec.ts b/client/src/features/book/components/__tests__/BookCoverLightbox.spec.ts
new file mode 100644
index 000000000..686396967
--- /dev/null
+++ b/client/src/features/book/components/__tests__/BookCoverLightbox.spec.ts
@@ -0,0 +1,117 @@
+import { flushPromises, mount } from '@vue/test-utils'
+import { ref } from 'vue'
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import type { BookCoverSlot, BookDetail } from '@bookorbit/types'
+import { COVER_ASPECT_RATIO_KEY } from '../../lib/cover-aspect-ratio'
+import BookCoverLightbox from '../BookCoverLightbox.vue'
+
+vi.mock('vue-i18n', () => ({
+  useI18n: () => ({ t: (key: string) => key }),
+}))
+
+vi.mock('../../composables/useCoverVersions', () => ({
+  useCoverVersions: () => ({
+    coverUrl: (bookId: number, type: string, version?: string, medium?: string) =>
+      `/api/v1/books/${bookId}/${type}?t=${version}&medium=${medium ?? ''}`,
+  }),
+}))
+
+type LightboxBook = Pick<BookDetail, 'id' | 'title' | 'covers' | 'coverVersion'>
+
+function slot(updatedAt: string): BookCoverSlot {
+  return { source: 'extracted', updatedAt, width: null, height: null }
+}
+
+const bothSlots: LightboxBook = { id: 3, title: 'Dune', covers: { ebook: slot('e1'), audio: slot('a1') }, coverVersion: 'face' }
+
+function mountLightbox(
+  props: { book?: LightboxBook; medium?: 'ebook' | 'audio' | null; previews?: Record<string, string | null> } = {},
+  aspectRatio = '2/3',
+) {
+  return mount(BookCoverLightbox, {
+    props: { open: true, book: props.book ?? bothSlots, medium: props.medium, previews: props.previews },
+    attachTo: document.body,
+    global: { provide: { [COVER_ASPECT_RATIO_KEY as symbol]: ref(aspectRatio) } },
+  })
+}
+
+function image(): HTMLImageElement {
+  return document.body.querySelector('img')!
+}
+
+function radios(): HTMLButtonElement[] {
+  return [...document.body.querySelectorAll<HTMLButtonElement>('[role="radio"]')]
+}
+
+describe('BookCoverLightbox', () => {
+  afterEach(() => {
+    document.body.innerHTML = ''
+  })
+
+  it('is a titled dialog with a labelled close button', async () => {
+    mountLightbox()
+    await flushPromises()
+
+    const dialog = document.body.querySelector('[role="dialog"]')!
+    const titleId = dialog.getAttribute('aria-labelledby')!
+    expect(document.getElementById(titleId)?.textContent).toBe('book.detail.coverLightbox.title')
+    expect(document.body.querySelector('[aria-label="common.close"]')).not.toBeNull()
+  })
+
+  it('opens on the face and switches between the two slots', async () => {
+    mountLightbox({}, '1/1')
+    await flushPromises()
+
+    expect(image().getAttribute('src')).toBe('/api/v1/books/3/cover?t=a1&medium=audio')
+    expect(radios().map((radio) => radio.getAttribute('aria-checked'))).toEqual(['false', 'true'])
+
+    radios()[0]!.click()
+    await flushPromises()
+
+    expect(image().getAttribute('src')).toBe('/api/v1/books/3/cover?t=e1&medium=ebook')
+  })
+
+  it('moves between the slots with the arrow keys', async () => {
+    mountLightbox()
+    await flushPromises()
+
+    radios()[0]!.dispatchEvent(new KeyboardEvent('keydown', { key: 'ArrowRight', bubbles: true }))
+    await flushPromises()
+
+    expect(radios()[1]!.getAttribute('aria-checked')).toBe('true')
+    expect(document.activeElement).toBe(radios()[1])
+  })
+
+  it('opens on the slot it is given', async () => {
+    mountLightbox({ medium: 'audio' })
+    await flushPromises()
+
+    expect(image().getAttribute('src')).toBe('/api/v1/books/3/cover?t=a1&medium=audio')
+  })
+
+  it('shows no switch and the bare face when only one slot has an image', async () => {
+    mountLightbox({ book: { ...bothSlots, covers: { ebook: slot('e1'), audio: null } } })
+    await flushPromises()
+
+    expect(radios()).toHaveLength(0)
+    expect(image().getAttribute('src')).toBe('/api/v1/books/3/cover?t=face&medium=')
+  })
+
+  it('shows an unsaved editor image in place of its slot', async () => {
+    mountLightbox({ book: { ...bothSlots, covers: { ebook: slot('e1'), audio: null } }, medium: 'audio', previews: { audio: 'blob:square' } })
+    await flushPromises()
+
+    expect(radios()).toHaveLength(2)
+    expect(image().getAttribute('src')).toBe('blob:square')
+  })
+
+  it('asks its parent to close on Escape', async () => {
+    const wrapper = mountLightbox()
+    await flushPromises()
+
+    document.body.querySelector('[role="dialog"]')!.dispatchEvent(new KeyboardEvent('keydown', { key: 'Escape', bubbles: true }))
+    await flushPromises()
+
+    expect(wrapper.emitted('update:open')).toEqual([[false]])
+  })
+})
diff --git a/client/src/features/book/components/__tests__/BookFilterBuilder.spec.ts b/client/src/features/book/components/__tests__/BookFilterBuilder.spec.ts
index 2247ef892..e7c6a5a2f 100644
--- a/client/src/features/book/components/__tests__/BookFilterBuilder.spec.ts
+++ b/client/src/features/book/components/__tests__/BookFilterBuilder.spec.ts
@@ -155,6 +155,22 @@ describe('BookFilterBuilder', () => {
     expect(wrapper.find('input').exists()).toBe(false)
   })
 
+  it('offers Audiobook Cover as a missing or present rule with no value input', async () => {
+    const wrapper = mount(BookFilterBuilder, {
+      props: {
+        modelValue: { type: 'group', join: 'AND', rules: [{ type: 'rule', field: 'title', operator: 'contains', value: 'Dune' }] },
+      },
+    })
+
+    const [fieldSelect] = wrapper.findAll('select')
+    expect(fieldSelect!.findAll('option').map((opt) => opt.text())).toEqual(expect.arrayContaining(['Cover', 'Audiobook Cover']))
+    await fieldSelect!.setValue('audioCover')
+
+    const operatorSelect = wrapper.findAll('select')[1]
+    expect(operatorSelect!.findAll('option').map((opt) => opt.text())).toEqual(['is missing', 'is present'])
+    expect(wrapper.find('input').exists()).toBe(false)
+  })
+
   it('includes Series Status in field options', () => {
     const wrapper = mount(BookFilterBuilder, {
       props: {
diff --git a/client/src/features/book/components/__tests__/BookListRow.spec.ts b/client/src/features/book/components/__tests__/BookListRow.spec.ts
index ab3de7fb1..54b68fad2 100644
--- a/client/src/features/book/components/__tests__/BookListRow.spec.ts
+++ b/client/src/features/book/components/__tests__/BookListRow.spec.ts
@@ -68,6 +68,7 @@ const missingBook: BookCard = {
   readStatus: null,
   addedAt: '2026-01-01T00:00:00.000Z',
   updatedAt: null,
+  coverVersion: 'legacy:2026-01-01T00:00:00.000Z',
   metadataScore: null,
   hasCover: false,
   hasMetadataLocks: false,
@@ -99,6 +100,7 @@ const presentBook: BookCard = {
   readStatus: null,
   addedAt: '2026-01-01T00:00:00.000Z',
   updatedAt: null,
+  coverVersion: 'legacy:2026-01-01T00:00:00.000Z',
   metadataScore: null,
   hasCover: false,
   hasMetadataLocks: false,
diff --git a/client/src/features/book/components/__tests__/BookListRowMoveAction.spec.ts b/client/src/features/book/components/__tests__/BookListRowMoveAction.spec.ts
index 4a6ae337e..f1824e9c2 100644
--- a/client/src/features/book/components/__tests__/BookListRowMoveAction.spec.ts
+++ b/client/src/features/book/components/__tests__/BookListRowMoveAction.spec.ts
@@ -29,6 +29,7 @@ const book: BookCard = {
   readStatus: null,
   addedAt: '2026-01-01T00:00:00.000Z',
   updatedAt: null,
+  coverVersion: 'legacy:2026-01-01T00:00:00.000Z',
   metadataScore: null,
   hasCover: false,
   hasMetadataLocks: false,
diff --git a/client/src/features/book/components/__tests__/BookQuickView.spec.ts b/client/src/features/book/components/__tests__/BookQuickView.spec.ts
index bf40f9836..0334cd667 100644
--- a/client/src/features/book/components/__tests__/BookQuickView.spec.ts
+++ b/client/src/features/book/components/__tests__/BookQuickView.spec.ts
@@ -87,6 +87,9 @@ function makeDetail(overrides: Partial<BookDetail> = {}): BookDetail {
     personalNoteUpdatedAt: null,
     communityRatings: [],
     coverSource: null,
+    coverMedia: [],
+    covers: { ebook: null, audio: null },
+    coverVersion: 'legacy:2026-01-01T00:00:00.000Z',
     hardcoverEditionId: null,
     providerIds: {},
     authors: [],
diff --git a/client/src/features/book/components/__tests__/BookTableCells.spec.ts b/client/src/features/book/components/__tests__/BookTableCells.spec.ts
index da2aef602..7f26dc4b2 100644
--- a/client/src/features/book/components/__tests__/BookTableCells.spec.ts
+++ b/client/src/features/book/components/__tests__/BookTableCells.spec.ts
@@ -244,6 +244,7 @@ describe('BookTableReadButtonCell', () => {
       readStatus: null,
       addedAt: '2026-01-01T00:00:00.000Z',
       updatedAt: null,
+      coverVersion: 'legacy:2026-01-01T00:00:00.000Z',
       metadataScore: null,
       hasCover: false,
       hasMetadataLocks: false,
diff --git a/client/src/features/book/components/__tests__/CollapsedSeriesCard.spec.ts b/client/src/features/book/components/__tests__/CollapsedSeriesCard.spec.ts
index 4209fe18e..4a7ada892 100644
--- a/client/src/features/book/components/__tests__/CollapsedSeriesCard.spec.ts
+++ b/client/src/features/book/components/__tests__/CollapsedSeriesCard.spec.ts
@@ -68,6 +68,7 @@ function makeBook(overrides?: Partial<BookCard>): BookCard {
     readStatus: null,
     addedAt: '2024-01-01T00:00:00.000Z',
     updatedAt: null,
+    coverVersion: 'legacy:2024-01-01T00:00:00.000Z',
     metadataScore: null,
     hasCover: false,
     hasMetadataLocks: false,
diff --git a/client/src/features/book/components/__tests__/CoverFill.spec.ts b/client/src/features/book/components/__tests__/CoverFill.spec.ts
new file mode 100644
index 000000000..c75cfdc59
--- /dev/null
+++ b/client/src/features/book/components/__tests__/CoverFill.spec.ts
@@ -0,0 +1,23 @@
+import { mount } from '@vue/test-utils'
+import { describe, expect, it } from 'vitest'
+
+import CoverFill from '../CoverFill.vue'
+
+describe('CoverFill', () => {
+  it('renders a blurred backdrop behind the complete cover', () => {
+    const wrapper = mount(CoverFill, {
+      props: {
+        src: '/api/v1/books/42/cover?t=version',
+        alt: 'A portrait cover',
+        loading: 'eager',
+      },
+    })
+
+    const images = wrapper.findAll('img')
+    expect(images).toHaveLength(2)
+    expect(images[0]?.attributes()).toMatchObject({ 'aria-hidden': 'true', alt: '', loading: 'eager' })
+    expect(images[0]?.classes()).toEqual(expect.arrayContaining(['object-cover', 'blur-xl', 'scale-125']))
+    expect(images[1]?.attributes()).toMatchObject({ alt: 'A portrait cover', loading: 'eager' })
+    expect(images[1]?.classes()).toContain('object-contain')
+  })
+})
diff --git a/client/src/features/book/components/__tests__/DetailsTab.spec.ts b/client/src/features/book/components/__tests__/DetailsTab.spec.ts
index 83e1b2d61..54f5e3beb 100644
--- a/client/src/features/book/components/__tests__/DetailsTab.spec.ts
+++ b/client/src/features/book/components/__tests__/DetailsTab.spec.ts
@@ -69,6 +69,7 @@ const globalStubs = {
     DialogOverlay: { template: '<div />' },
     DialogContent: { template: '<div><slot /></div>' },
     DialogClose: { template: '<button><slot /></button>' },
+    BookCoverLightbox: true,
     AddToCollectionSheet: true,
     MoveToLibrarySheet: true,
     DeleteBookDialog: true,
@@ -101,6 +102,9 @@ function makeBook(overrides: Partial<BookDetail> = {}): BookDetail {
     personalNoteUpdatedAt: null,
     communityRatings: [],
     coverSource: null,
+    coverMedia: [],
+    covers: { ebook: null, audio: null },
+    coverVersion: 'legacy:2024-01-01T00:00:00.000Z',
     hardcoverEditionId: null,
     providerIds: {},
     authors: [],
@@ -167,6 +171,29 @@ describe('DetailsTab - missing state', () => {
 })
 
 describe('DetailsTab - present state', () => {
+  it('hands the shared cover lightbox the book, opening on the face', async () => {
+    const book = makeBook({
+      coverSource: 'extracted',
+      coverMedia: ['ebook', 'audio'],
+      covers: {
+        ebook: { source: 'extracted', updatedAt: '2026-09-01T00:00:00.000Z', width: 600, height: 900 },
+        audio: { source: 'custom', updatedAt: '2026-09-02T00:00:00.000Z', width: 800, height: 800 },
+      },
+    })
+    const wrapper = mount(DetailsTab, { props: { book }, global: globalStubs })
+    // Only a cover that has loaded can be opened, so the button appears with it.
+    expect(wrapper.find('button[aria-label="View larger cover"]').exists()).toBe(false)
+    wrapper.getComponent({ name: 'BookCoverArtwork' }).vm.$emit('load', 2 / 3)
+    await wrapper.vm.$nextTick()
+
+    await wrapper.get('button[aria-label="View larger cover"]').trigger('click')
+
+    const lightbox = wrapper.getComponent({ name: 'BookCoverLightbox' })
+    expect(lightbox.props('open')).toBe(true)
+    expect(lightbox.props('book')).toStrictEqual(book)
+    expect(lightbox.props('medium')).toBeUndefined()
+  })
+
   it('does not render the warning banner', () => {
     const wrapper = mount(DetailsTab, {
       props: { book: makeBook({ status: 'present' }) },
diff --git a/client/src/features/book/components/__tests__/VirtualBookTable.collapsedSeries.spec.ts b/client/src/features/book/components/__tests__/VirtualBookTable.collapsedSeries.spec.ts
index ce55f43a0..fd59cc806 100644
--- a/client/src/features/book/components/__tests__/VirtualBookTable.collapsedSeries.spec.ts
+++ b/client/src/features/book/components/__tests__/VirtualBookTable.collapsedSeries.spec.ts
@@ -50,6 +50,7 @@ function makeBook(id: number, overrides: Partial<BookCard> = {}): BookCard {
     readStatus: null,
     addedAt: '2026-01-01T00:00:00.000Z',
     updatedAt: null,
+    coverVersion: 'legacy:2026-01-01T00:00:00.000Z',
     metadataScore: null,
     hasCover: false,
     hasMetadataLocks: false,
diff --git a/client/src/features/book/components/detail/files/FilesHeroBar.vue b/client/src/features/book/components/detail/files/FilesHeroBar.vue
index 60878fa91..72755c9df 100644
--- a/client/src/features/book/components/detail/files/FilesHeroBar.vue
+++ b/client/src/features/book/components/detail/files/FilesHeroBar.vue
@@ -28,7 +28,7 @@ const { t } = useI18n()
 const { coverUrl } = useCoverVersions()
 
 const hasCover = computed(() => props.book.coverSource !== null)
-const coverSrc = computed(() => coverUrl(props.book.id, 'thumbnail', props.book.updatedAt ?? props.book.addedAt))
+const coverSrc = computed(() => coverUrl(props.book.id, 'thumbnail', props.book.coverVersion))
 const isMissing = computed(() => props.book.status === 'missing')
 
 /**
diff --git a/client/src/features/book/components/detail/tabs/CoverEditorPanel.spec.ts b/client/src/features/book/components/detail/tabs/CoverEditorPanel.spec.ts
index 71467b7d9..cb4035b4b 100644
--- a/client/src/features/book/components/detail/tabs/CoverEditorPanel.spec.ts
+++ b/client/src/features/book/components/detail/tabs/CoverEditorPanel.spec.ts
@@ -1,7 +1,7 @@
 import { mount } from '@vue/test-utils'
 import { ref } from 'vue'
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
-import type { BookDetail } from '@bookorbit/types'
+import type { BookCoverSlot, BookDetail, BookMetadataLockField, CoverMedium } from '@bookorbit/types'
 import { useCoverEditor } from '../../../composables/useCoverEditor'
 import CoverEditorPanel from './CoverEditorPanel.vue'
 
@@ -15,7 +15,8 @@ vi.mock('../../../composables/useCoverEditor', () => ({
 
 vi.mock('../../../composables/useCoverVersions', () => ({
   useCoverVersions: () => ({
-    coverUrl: vi.fn<() => string>().mockReturnValue('/cover.jpg'),
+    coverUrl: (bookId: number, type: string, version?: string, medium?: string) =>
+      `/api/v1/books/${bookId}/${type}?t=${version}&medium=${medium ?? ''}`,
     bumpVersion: vi.fn<() => void>(),
   }),
 }))
@@ -24,127 +25,403 @@ vi.mock('@/features/auth/composables/usePermissions', () => ({
   usePermissions: () => ({ hasPermission: vi.fn<() => boolean>().mockReturnValue(true) }),
 }))
 
-const book = {
-  id: 1,
-  title: 'Test Book',
-  folderPath: '/books/Test Book',
-  authors: [],
-  files: [],
-  coverSource: null,
-  addedAt: '2026-07-22T00:00:00.000Z',
-  updatedAt: '2026-07-22T00:00:00.000Z',
-} as unknown as BookDetail
+function slot(source: BookCoverSlot['source'] = 'extracted', updatedAt = '2026-09-01T00:00:00.000Z'): BookCoverSlot {
+  return { source, updatedAt, width: null, height: null }
+}
 
-function setupEditor() {
+function makeBook(overrides: Partial<BookDetail> = {}): BookDetail {
+  return {
+    id: 1,
+    title: 'Test Book',
+    folderPath: '/books/Test Book',
+    authors: [],
+    files: [],
+    coverSource: null,
+    coverMedia: ['ebook'],
+    covers: { ebook: null, audio: null },
+    coverVersion: 'ebook:-:-',
+    lockedFields: [],
+    addedAt: '2026-07-22T00:00:00.000Z',
+    updatedAt: '2026-07-22T00:00:00.000Z',
+    ...overrides,
+  } as unknown as BookDetail
+}
+
+const mixedBook = makeBook({
+  coverSource: 'custom',
+  coverMedia: ['ebook', 'audio'],
+  covers: { ebook: slot('extracted', '2026-09-01T00:00:00.000Z'), audio: slot('custom', '2026-09-02T00:00:00.000Z') },
+})
+
+type FakeEditor = ReturnType<typeof fakeEditor>
+
+function fakeEditor() {
   const uploading = ref(false)
+  const regenerating = ref(false)
+  const error = ref<string | null>(null)
+  const previewSrc = ref<string | null>(null)
   const pendingFile = ref<File | null>(null)
   const pendingUrl = ref<string | null>(null)
-  const setUrl = vi.fn<(url: string) => void>((url) => {
-    pendingUrl.value = url || null
-  })
-  const confirm = vi.fn<() => Promise<boolean>>().mockResolvedValue(true)
-  vi.mocked(useCoverEditor).mockReturnValue({
+  return {
     uploading,
-    error: ref<string | null>(null),
-    previewSrc: ref<string | null>(null),
+    regenerating,
+    error,
+    previewSrc,
     pendingFile,
     pendingUrl,
     selectFile: vi.fn<(file: File) => void>(),
-    setUrl,
-    clearPending: vi.fn<() => void>(),
-    confirm,
-    revert: vi.fn<() => Promise<'extracted' | null | false>>(),
-  })
-  return { uploading, pendingUrl, setUrl, confirm }
+    setUrl: vi.fn<(url: string) => void>((url) => {
+      pendingUrl.value = url || null
+      previewSrc.value = url || null
+    }),
+    clearPending: vi.fn<() => void>(() => {
+      pendingUrl.value = null
+      pendingFile.value = null
+      previewSrc.value = null
+    }),
+    confirm: vi.fn<() => Promise<boolean>>(async () => {
+      pendingUrl.value = null
+      previewSrc.value = null
+      return true
+    }),
+    revert: vi.fn<() => Promise<'extracted' | null | false>>().mockResolvedValue('extracted'),
+    regenerate: vi.fn<() => Promise<boolean>>().mockResolvedValue(true),
+  }
 }
 
-function mountPanel(disabled = false) {
+let editors: Record<CoverMedium | 'none', FakeEditor>
+
+function mountPanel(options: { book?: BookDetail; disabled?: boolean; lockedFields?: BookMetadataLockField[] } = {}) {
   return mount(CoverEditorPanel, {
-    props: { book, disabled },
+    props: { book: options.book ?? makeBook(), disabled: options.disabled ?? false, lockedFields: options.lockedFields ?? [] },
+    attachTo: document.body,
     global: {
       stubs: {
-        BookCoverPlaceholder: true,
-        CoverSearchDrawer: true,
-        Teleport: true,
+        BookCoverPlaceholder: { template: '<div data-test="placeholder" />' },
+        BookCoverLightbox: true,
+        CoverSearchDrawer: { props: ['open', 'isAudiobook'], template: '<div data-test="search" :data-audiobook="String(isAudiobook)" />' },
       },
     },
   })
 }
 
+type ExposedPanel = {
+  confirm: (media?: (CoverMedium | null)[]) => Promise<boolean>
+  setUrl: (url: string) => void
+  hasPending: boolean
+  pendingMedia: (CoverMedium | null)[]
+  reset: () => void
+}
+
+function radios(wrapper: ReturnType<typeof mountPanel>) {
+  return wrapper.findAll('[role="radio"]')
+}
+
 describe('CoverEditorPanel', () => {
   beforeEach(() => {
     vi.useFakeTimers()
-    setupEditor()
+    editors = { ebook: fakeEditor(), audio: fakeEditor(), none: fakeEditor() }
+    vi.mocked(useCoverEditor).mockImplementation((_bookId, medium) => editors[medium ?? 'none'] as never)
   })
 
   afterEach(() => {
     vi.useRealTimers()
+    document.body.innerHTML = ''
   })
 
-  it('sizes its layout from its own column instead of the viewport', () => {
-    const wrapper = mountPanel()
-    const container = wrapper.get('.\\@container\\/cover-editor')
-    const layout = container.get(':scope > div')
+  describe('one medium', () => {
+    it('sizes its layout from its own column instead of the viewport', () => {
+      const wrapper = mountPanel()
+      const container = wrapper.get('.\\@container\\/cover-editor')
+      const layout = container.get(':scope > div')
 
-    expect(layout.classes()).toContain('@min-[21rem]/cover-editor:flex-row')
-    expect(layout.classes()).not.toContain('lg:flex-col')
-    expect(layout.get(':scope > div').classes()).toContain('@min-[21rem]/cover-editor:w-36')
-  })
-
-  it('disables every visible cover mutation control when the parent is disabled', () => {
-    const { pendingUrl } = setupEditor()
-    pendingUrl.value = 'https://example.com/cover.jpg'
-    const wrapper = mountPanel(true)
-
-    const buttons = wrapper.findAll('button')
-    expect(buttons.length).toBeGreaterThan(0)
-    expect(buttons.every((button) => button.attributes('disabled') !== undefined)).toBe(true)
-    expect(wrapper.get('input[type="file"]').attributes('disabled')).toBeDefined()
-  })
-
-  it('does not apply a debounced URL after saving disables the panel', async () => {
-    const { setUrl } = setupEditor()
-    const wrapper = mountPanel()
-    const urlModeButton = wrapper.findAll('button').find((button) => button.text().includes('urlTab'))
-    expect(urlModeButton).toBeDefined()
-    await urlModeButton!.trigger('click')
-    await wrapper.get('input').setValue('https://example.com/cover.jpg')
-
-    await wrapper.setProps({ disabled: true })
-    await vi.advanceTimersByTimeAsync(400)
-
-    expect(setUrl).not.toHaveBeenCalled()
-  })
-
-  it('rejects overlapping exposed confirmations while an upload is active', async () => {
-    const { uploading, confirm } = setupEditor()
-    let resolveUpload!: (result: boolean) => void
-    confirm.mockImplementation(() => {
-      uploading.value = true
-      return new Promise<boolean>((resolve) => {
-        resolveUpload = (result) => {
-          uploading.value = false
-          resolve(result)
-        }
-      })
+      expect(layout.classes()).toContain('@min-[21rem]/cover-editor:flex-row')
+      expect(layout.classes()).not.toContain('lg:flex-col')
+      expect(layout.get(':scope > div').classes()).toContain('@min-[21rem]/cover-editor:w-36')
     })
-    const wrapper = mountPanel()
-    const exposed = wrapper.vm as unknown as { confirm: () => Promise<boolean> }
 
-    const firstConfirmation = exposed.confirm()
-    await expect(exposed.confirm()).resolves.toBe(false)
-    resolveUpload(true)
+    it('shows a single cover with no tile choice', () => {
+      const wrapper = mountPanel({ book: makeBook({ coverSource: 'extracted', covers: { ebook: slot(), audio: null } }) })
 
-    await expect(firstConfirmation).resolves.toBe(true)
-    expect(confirm).toHaveBeenCalledTimes(1)
+      expect(wrapper.find('[role="radiogroup"]').exists()).toBe(false)
+      expect(wrapper.get('img').attributes('src')).toContain('medium=ebook')
+    })
+
+    it('uses the audio lock key for a book that only has an audiobook', async () => {
+      const wrapper = mountPanel({ book: makeBook({ coverMedia: ['audio'] }), lockedFields: ['audioCover'] })
+
+      const lock = wrapper.get('[aria-label="book.detail.coverEditor.unlockCover"]')
+      await lock.trigger('click')
+
+      expect(wrapper.emitted('toggleLock')).toEqual([['audioCover']])
+      expect(wrapper.get('input[type="file"]').attributes('disabled')).toBeDefined()
+    })
+
+    it('shows a legacy cover that no slot holds yet', () => {
+      const wrapper = mountPanel({ book: makeBook({ coverSource: 'custom', coverVersion: 'legacy:1' }) })
+
+      expect(wrapper.find('[data-test="placeholder"]').exists()).toBe(false)
+      expect(wrapper.get('img').attributes('src')).toContain('t=legacy:1')
+      expect(wrapper.text()).toContain('book.detail.coverEditor.revertToOriginal')
+    })
+
+    it('disables every visible cover control when the parent is disabled', () => {
+      editors.ebook.pendingUrl.value = 'https://example.com/cover.jpg'
+      const wrapper = mountPanel({ disabled: true })
+
+      const buttons = wrapper.findAll('button')
+      expect(buttons.length).toBeGreaterThan(0)
+      expect(buttons.every((button) => button.attributes('disabled') !== undefined)).toBe(true)
+      expect(wrapper.get('input[type="file"]').attributes('disabled')).toBeDefined()
+    })
+
+    it('does not apply a debounced URL after saving disables the panel', async () => {
+      const wrapper = mountPanel()
+      await wrapper.get('[aria-pressed="false"]').trigger('click')
+      await wrapper.get('input[aria-label="book.detail.coverEditor.urlLabel"]').setValue('https://example.com/cover.jpg')
+
+      await wrapper.setProps({ disabled: true })
+      await vi.advanceTimersByTimeAsync(400)
+
+      expect(editors.ebook.setUrl).not.toHaveBeenCalled()
+    })
+
+    it('rejects overlapping exposed confirmations while an upload is active', async () => {
+      editors.ebook.pendingUrl.value = 'https://example.com/cover.jpg'
+      let resolveUpload!: (result: boolean) => void
+      editors.ebook.confirm.mockImplementation(() => {
+        editors.ebook.uploading.value = true
+        return new Promise<boolean>((resolve) => {
+          resolveUpload = (result) => {
+            editors.ebook.uploading.value = false
+            resolve(result)
+          }
+        })
+      })
+      const wrapper = mountPanel()
+      const exposed = wrapper.vm as unknown as ExposedPanel
+
+      const firstConfirmation = exposed.confirm()
+      await expect(exposed.confirm()).resolves.toBe(false)
+      resolveUpload(true)
+
+      await expect(firstConfirmation).resolves.toBe(true)
+      expect(editors.ebook.confirm).toHaveBeenCalledTimes(1)
+    })
+
+    it('does not invoke an exposed confirmation while disabled', async () => {
+      editors.ebook.pendingUrl.value = 'https://example.com/cover.jpg'
+      const wrapper = mountPanel({ disabled: true })
+      const exposed = wrapper.vm as unknown as ExposedPanel
+
+      await expect(exposed.confirm()).resolves.toBe(false)
+      expect(editors.ebook.confirm).not.toHaveBeenCalled()
+    })
   })
 
-  it('does not invoke an exposed confirmation while disabled', async () => {
-    const { confirm } = setupEditor()
-    const wrapper = mountPanel(true)
-    const exposed = wrapper.vm as unknown as { confirm: () => Promise<boolean> }
+  describe('two media', () => {
+    it('offers a Book and an Audiobook tile as a radio group, with the book selected first', () => {
+      const wrapper = mountPanel({ book: mixedBook })
 
-    await expect(exposed.confirm()).resolves.toBe(false)
-    expect(confirm).not.toHaveBeenCalled()
+      const group = wrapper.get('[role="radiogroup"]')
+      expect(group.attributes('aria-label')).toBe('book.detail.coverEditor.slotsLabel')
+      expect(radios(wrapper).map((radio) => radio.attributes('aria-label'))).toEqual([
+        'book.detail.coverEditor.slotEbookName',
+        'book.detail.coverEditor.slotAudioName',
+      ])
+      expect(radios(wrapper).map((radio) => radio.attributes('aria-checked'))).toEqual(['true', 'false'])
+      expect(radios(wrapper).map((radio) => radio.attributes('tabindex'))).toEqual(['0', '-1'])
+      expect(wrapper.text()).toContain('book.detail.coverEditor.editingEbook')
+    })
+
+    it('loads each tile from its own slot', () => {
+      const wrapper = mountPanel({ book: mixedBook })
+
+      const sources = wrapper.findAll('[role="radio"] img').map((img) => img.attributes('src'))
+      expect(sources).toEqual([
+        '/api/v1/books/1/cover?t=2026-09-01T00:00:00.000Z&medium=ebook',
+        '/api/v1/books/1/cover?t=2026-09-02T00:00:00.000Z&medium=audio',
+      ])
+    })
+
+    it('shows the placeholder for an empty slot instead of requesting it', () => {
+      const wrapper = mountPanel({
+        book: makeBook({ coverSource: 'extracted', coverMedia: ['ebook', 'audio'], covers: { ebook: slot(), audio: null } }),
+      })
+
+      expect(wrapper.findAll('[role="radio"] img')).toHaveLength(1)
+      expect(wrapper.findAll('[role="radio"] [data-test="placeholder"]')).toHaveLength(1)
+    })
+
+    it('selects a tile on click and points the shared controls at it', async () => {
+      const wrapper = mountPanel({ book: mixedBook })
+
+      await radios(wrapper)[1]!.trigger('click')
+
+      expect(radios(wrapper).map((radio) => radio.attributes('aria-checked'))).toEqual(['false', 'true'])
+      expect(wrapper.text()).toContain('book.detail.coverEditor.editingAudio')
+      expect(wrapper.get('[data-test="search"]').attributes('data-audiobook')).toBe('true')
+      const controls = wrapper.get('[role="group"][aria-labelledby]')
+      expect(wrapper.get(`#${controls.attributes('aria-labelledby')}`).text()).toBe('book.detail.coverEditor.editingAudio')
+    })
+
+    it('moves the selection and focus with the arrow keys', async () => {
+      const wrapper = mountPanel({ book: mixedBook })
+
+      await radios(wrapper)[0]!.trigger('keydown', { key: 'ArrowRight' })
+      await wrapper.vm.$nextTick()
+
+      expect(radios(wrapper)[1]!.attributes('aria-checked')).toBe('true')
+      expect(document.activeElement).toBe(radios(wrapper)[1]!.element)
+    })
+
+    it('keeps each lock outside its radio and toggles that slot', async () => {
+      const wrapper = mountPanel({ book: mixedBook, lockedFields: ['audioCover'] })
+
+      expect(wrapper.find('[role="radio"] button').exists()).toBe(false)
+      await wrapper.get('[aria-label="book.detail.coverEditor.lockEbookCover"]').trigger('click')
+      await wrapper.get('[aria-label="book.detail.coverEditor.unlockAudioCover"]').trigger('click')
+
+      expect(wrapper.emitted('toggleLock')).toEqual([['cover'], ['audioCover']])
+    })
+
+    it('disables the controls only while the selected tile is locked', async () => {
+      const wrapper = mountPanel({ book: mixedBook, lockedFields: ['audioCover'] })
+      expect(wrapper.get('input[type="file"]').attributes('disabled')).toBeUndefined()
+
+      await radios(wrapper)[1]!.trigger('click')
+
+      expect(wrapper.get('input[type="file"]').attributes('disabled')).toBeDefined()
+    })
+
+    it('opens the lightbox on the tile whose View larger was pressed', async () => {
+      const wrapper = mountPanel({ book: mixedBook })
+
+      await wrapper.get('[aria-label="book.detail.coverEditor.viewLargerAudio"]').trigger('click')
+
+      const lightbox = wrapper.getComponent({ name: 'BookCoverLightbox' })
+      expect(lightbox.props('open')).toBe(true)
+      expect(lightbox.props('medium')).toBe('audio')
+      expect(radios(wrapper)[0]!.attributes('aria-checked')).toBe('true')
+    })
+
+    it('keeps a pending image per tile and applies URL input to the selected one', async () => {
+      const wrapper = mountPanel({ book: mixedBook })
+      await radios(wrapper)[1]!.trigger('click')
+      await wrapper.get('[aria-pressed="false"]').trigger('click')
+      await wrapper.get('input[aria-label="book.detail.coverEditor.urlLabel"]').setValue('https://example.com/square.jpg')
+      await vi.advanceTimersByTimeAsync(400)
+
+      expect(editors.audio.setUrl).toHaveBeenCalledWith('https://example.com/square.jpg')
+      expect(editors.ebook.setUrl).not.toHaveBeenCalled()
+
+      await radios(wrapper)[0]!.trigger('click')
+      expect(wrapper.find('input[aria-label="book.detail.coverEditor.urlLabel"]').exists()).toBe(false)
+      expect((wrapper.vm as unknown as ExposedPanel).pendingMedia).toEqual(['audio'])
+    })
+
+    it('shows Revert only for the selected tile when its slot is custom', async () => {
+      const wrapper = mountPanel({ book: mixedBook })
+      expect(wrapper.text()).not.toContain('book.detail.coverEditor.revertToOriginal')
+
+      await radios(wrapper)[1]!.trigger('click')
+      const revert = wrapper.findAll('button').find((button) => button.text().includes('book.detail.coverEditor.revertToOriginal'))
+      await revert!.trigger('click')
+      await vi.runAllTimersAsync()
+
+      expect(editors.audio.revert).toHaveBeenCalledTimes(1)
+      expect(wrapper.emitted('coverChanged')).toEqual([['audio']])
+    })
+
+    it('regenerates the selected slot and reports its medium', async () => {
+      const wrapper = mountPanel({ book: mixedBook })
+      await radios(wrapper)[1]!.trigger('click')
+
+      const regenerate = wrapper.findAll('button').find((button) => button.text().includes('book.detail.coverEditor.regenerateCover'))
+      await regenerate!.trigger('click')
+      await vi.runAllTimersAsync()
+
+      expect(editors.audio.regenerate).toHaveBeenCalledTimes(1)
+      expect(editors.ebook.regenerate).not.toHaveBeenCalled()
+      expect(wrapper.emitted('coverChanged')).toEqual([['audio']])
+    })
+
+    it('saves every pending tile and reports each medium', async () => {
+      editors.ebook.pendingUrl.value = 'https://example.com/portrait.jpg'
+      editors.audio.pendingUrl.value = 'https://example.com/square.jpg'
+      const wrapper = mountPanel({ book: mixedBook })
+      const exposed = wrapper.vm as unknown as ExposedPanel
+
+      expect(exposed.hasPending).toBe(true)
+      await expect(exposed.confirm()).resolves.toBe(true)
+
+      expect(editors.ebook.confirm).toHaveBeenCalledTimes(1)
+      expect(editors.audio.confirm).toHaveBeenCalledTimes(1)
+      expect(wrapper.emitted('coverChanged')).toEqual([['ebook'], ['audio']])
+    })
+
+    it('saves only the tiles it is asked for', async () => {
+      editors.ebook.pendingUrl.value = 'https://example.com/portrait.jpg'
+      editors.audio.pendingUrl.value = 'https://example.com/square.jpg'
+      const wrapper = mountPanel({ book: mixedBook })
+
+      await expect((wrapper.vm as unknown as ExposedPanel).confirm(['audio'])).resolves.toBe(true)
+
+      expect(editors.ebook.confirm).not.toHaveBeenCalled()
+      expect(editors.audio.confirm).toHaveBeenCalledTimes(1)
+    })
+
+    it('stops at the first failed tile and selects it', async () => {
+      editors.ebook.pendingUrl.value = 'https://example.com/portrait.jpg'
+      editors.audio.pendingUrl.value = 'https://example.com/square.jpg'
+      editors.ebook.confirm.mockResolvedValue(false)
+      const wrapper = mountPanel({ book: mixedBook })
+      await radios(wrapper)[1]!.trigger('click')
+
+      await expect((wrapper.vm as unknown as ExposedPanel).confirm()).resolves.toBe(false)
+      await wrapper.vm.$nextTick()
+
+      expect(editors.audio.confirm).not.toHaveBeenCalled()
+      expect(radios(wrapper)[0]!.attributes('aria-checked')).toBe('true')
+      expect(wrapper.emitted('coverChanged')).toBeUndefined()
+    })
+
+    it('routes a metadata result cover to the book tile and selects it', async () => {
+      const wrapper = mountPanel({ book: mixedBook })
+      await radios(wrapper)[1]!.trigger('click')
+
+      ;(wrapper.vm as unknown as ExposedPanel).setUrl('https://example.com/result.jpg')
+      await wrapper.vm.$nextTick()
+
+      expect(editors.ebook.setUrl).toHaveBeenCalledWith('https://example.com/result.jpg')
+      expect(radios(wrapper)[0]!.attributes('aria-checked')).toBe('true')
+    })
+
+    it('clears every tile on reset', async () => {
+      editors.ebook.pendingUrl.value = 'https://example.com/portrait.jpg'
+      editors.audio.pendingUrl.value = 'https://example.com/square.jpg'
+      const wrapper = mountPanel({ book: mixedBook })
+
+      ;(wrapper.vm as unknown as ExposedPanel).reset()
+
+      expect(editors.ebook.clearPending).toHaveBeenCalled()
+      expect(editors.audio.clearPending).toHaveBeenCalled()
+      expect((wrapper.vm as unknown as ExposedPanel).hasPending).toBe(false)
+    })
+  })
+
+  describe('accessibility of the shared controls', () => {
+    it('keeps the file input reachable by keyboard and labels the URL input', async () => {
+      const wrapper = mountPanel()
+
+      const fileInput = wrapper.get('input[type="file"]')
+      expect(fileInput.classes()).toContain('sr-only')
+      expect(fileInput.classes()).not.toContain('hidden')
+
+      const modes = wrapper.findAll('[aria-pressed]')
+      expect(modes.map((mode) => mode.attributes('aria-pressed'))).toEqual(['true', 'false'])
+      await modes[1]!.trigger('click')
+      expect(wrapper.find('input[aria-label="book.detail.coverEditor.urlLabel"]').exists()).toBe(true)
+    })
   })
 })
diff --git a/client/src/features/book/components/detail/tabs/CoverEditorPanel.vue b/client/src/features/book/components/detail/tabs/CoverEditorPanel.vue
index f15acbb00..bc806823f 100644
--- a/client/src/features/book/components/detail/tabs/CoverEditorPanel.vue
+++ b/client/src/features/book/components/detail/tabs/CoverEditorPanel.vue
@@ -1,85 +1,193 @@
 <script setup lang="ts">
-import { computed, inject, ref, onUnmounted } from 'vue'
+import { computed, inject, nextTick, onUnmounted, reactive, ref, useId, watch } from 'vue'
 import { useI18n } from 'vue-i18n'
-import { Image, ImagePlus, Link, Lock, LockOpen, Loader2, RotateCcw, Search, Upload, X } from '@lucide/vue'
-import type { BookDetail } from '@bookorbit/types'
-import { FORMAT_TO_GROUP } from '@bookorbit/types'
+import { Image, ImagePlus, Link, Loader2, Lock, LockOpen, Maximize2, RotateCcw, Search, Upload } from '@lucide/vue'
+import type { BookDetail, BookMetadataLockField, CoverMedium } from '@bookorbit/types'
 import { hideOnError } from '../../../lib/metadata-fetch'
 import { useCoverEditor } from '../../../composables/useCoverEditor'
 import { useCoverVersions } from '../../../composables/useCoverVersions'
 import { usePermissions } from '@/features/auth/composables/usePermissions'
 import { COVER_ASPECT_RATIO_KEY, DEFAULT_COVER_ASPECT_RATIO } from '../../../lib/cover-aspect-ratio'
+import { coverFieldMedium, coverLockField, coverTileState, editorTiles } from '../../../lib/cover-slots'
+import { nextRovingIndex } from '@/lib/roving-index'
+import BookCoverLightbox from '@/features/book/components/BookCoverLightbox.vue'
 import BookCoverPlaceholder from '@/features/book/components/BookCoverPlaceholder.vue'
 import CoverSearchDrawer from './CoverSearchDrawer.vue'
 
-const props = defineProps<{ book: BookDetail; locked?: boolean; disabled?: boolean }>()
-const emit = defineEmits<{ coverChanged: ['extracted' | 'custom' | null]; toggleLock: [] }>()
+type TileKey = CoverMedium | 'none'
+type CoverLockField = ReturnType<typeof coverLockField>
+
+const props = defineProps<{ book: BookDetail; lockedFields: readonly BookMetadataLockField[]; disabled?: boolean }>()
+const emit = defineEmits<{ coverChanged: [medium: CoverMedium | null]; toggleLock: [field: CoverLockField] }>()
 
 const { t } = useI18n()
+const { coverUrl } = useCoverVersions()
+const { hasPermission } = usePermissions()
+const coverAspectRatio = inject(COVER_ASPECT_RATIO_KEY, ref(DEFAULT_COVER_ASPECT_RATIO))
 
 const bookIdRef = computed(() => props.book.id)
-const { uploading, error, previewSrc, pendingFile, pendingUrl, selectFile, setUrl, clearPending, confirm, revert } = useCoverEditor(bookIdRef)
+// One editor per slot, so a pending image on one tile survives selecting the other.
+const editors = {
+  ebook: reactive(useCoverEditor(bookIdRef, 'ebook')),
+  audio: reactive(useCoverEditor(bookIdRef, 'audio')),
+  none: reactive(useCoverEditor(bookIdRef, null)),
+}
+const tileUi = reactive<Record<TileKey, { mode: 'file' | 'url'; urlInput: string }>>({
+  ebook: { mode: 'file', urlInput: '' },
+  audio: { mode: 'file', urlInput: '' },
+  none: { mode: 'file', urlInput: '' },
+})
 
-const { coverUrl, bumpVersion } = useCoverVersions()
-const { hasPermission } = usePermissions()
+function tileKey(medium: CoverMedium | null): TileKey {
+  return medium ?? 'none'
+}
 
-const reExtractingCover = ref(false)
+function mediumOf(key: TileKey): CoverMedium | null {
+  return key === 'none' ? null : key
+}
 
-async function reExtractCover() {
-  if (controlsDisabled.value || reExtractingCover.value) return
-  reExtractingCover.value = true
-  try {
-    await fetch(`/api/v1/books/${props.book.id}/re-extract-cover`, { method: 'POST' })
-    bumpVersion(props.book.id)
-    emit('coverChanged', 'extracted')
-  } finally {
-    reExtractingCover.value = false
+const tileKeys = computed<TileKey[]>(() => editorTiles(props.book).map(tileKey))
+const isMultiSlot = computed(() => tileKeys.value.length > 1)
+const selectedKey = ref<TileKey>(tileKeys.value[0] ?? 'none')
+
+watch(tileKeys, (keys) => {
+  if (!keys.includes(selectedKey.value)) selectedKey.value = keys[0] ?? 'none'
+})
+
+function clearAllPending() {
+  clearTimeout(debounceTimer)
+  for (const key of Object.keys(editors) as TileKey[]) {
+    editors[key].clearPending()
+    tileUi[key] = { mode: 'file', urlInput: '' }
   }
 }
 
-const mode = ref<'file' | 'url'>('file')
-const urlInput = ref('')
-const isSearchOpen = ref(false)
+watch(
+  () => props.book.id,
+  () => {
+    clearAllPending()
+    selectedKey.value = tileKeys.value[0] ?? 'none'
+  },
+)
 
-let debounceTimer: ReturnType<typeof setTimeout>
-
-const activeSrc = computed(() => previewSrc.value ?? coverUrl(props.book.id, 'cover', props.book.updatedAt ?? props.book.addedAt))
-const hasPending = computed(() => !!pendingFile.value || !!pendingUrl.value)
-const controlsDisabled = computed(() => Boolean(props.locked || props.disabled))
-const primaryFile = computed(() => props.book.files.find((f) => f.role === 'primary') ?? props.book.files[0] ?? null)
-const isPrimaryAudio = computed(() => primaryFile.value?.format != null && FORMAT_TO_GROUP[primaryFile.value.format] === 'audio')
-const hasCover = computed(() => !!props.book.coverSource || !!previewSrc.value)
 const coverSeed = computed(() => props.book.title ?? props.book.folderPath.split('/').pop() ?? String(props.book.id))
-const coverAspectRatio = inject(COVER_ASPECT_RATIO_KEY, ref(DEFAULT_COVER_ASPECT_RATIO))
+const authorLine = computed(() => props.book.authors.map((a) => a.name).join(', ') || null)
 
-function cancelPending() {
-  clearPending()
-  urlInput.value = ''
+const tiles = computed(() =>
+  tileKeys.value.map((key) => {
+    const medium = mediumOf(key)
+    const editor = editors[key]
+    const state = coverTileState(props.book, medium, coverAspectRatio.value)
+    const lockField = coverLockField(medium)
+    const locked = props.lockedFields.includes(lockField)
+    return {
+      key,
+      medium,
+      lockField,
+      locked,
+      hasImage: state.hasImage || Boolean(editor.previewSrc),
+      src: editor.previewSrc ?? coverUrl(props.book.id, 'cover', state.version, medium ?? undefined),
+      source: state.source,
+      label: medium === 'audio' ? t('book.detail.coverEditor.slotAudio') : t('book.detail.coverEditor.slotEbook'),
+      name: medium === 'audio' ? t('book.detail.coverEditor.slotAudioName') : t('book.detail.coverEditor.slotEbookName'),
+      lockLabel: lockLabel(medium, locked),
+      viewLargerLabel: viewLargerLabel(medium),
+    }
+  }),
+)
+
+function lockLabel(medium: CoverMedium | null, locked: boolean): string {
+  if (!isMultiSlot.value) return locked ? t('book.detail.coverEditor.unlockCover') : t('book.detail.coverEditor.lockCover')
+  if (medium === 'audio') return locked ? t('book.detail.coverEditor.unlockAudioCover') : t('book.detail.coverEditor.lockAudioCover')
+  return locked ? t('book.detail.coverEditor.unlockEbookCover') : t('book.detail.coverEditor.lockEbookCover')
 }
 
-function onFileChange(e: Event) {
-  if (controlsDisabled.value) return
-  const file = (e.target as HTMLInputElement).files?.[0]
-  if (file) selectFile(file)
+function viewLargerLabel(medium: CoverMedium | null): string {
+  if (!isMultiSlot.value) return t('book.detail.coverEditor.viewLarger')
+  return medium === 'audio' ? t('book.detail.coverEditor.viewLargerAudio') : t('book.detail.coverEditor.viewLargerEbook')
+}
+
+const selectedTile = computed(() => tiles.value.find((tile) => tile.key === selectedKey.value) ?? tiles.value[0]!)
+const activeEditor = computed(() => editors[selectedTile.value.key])
+const activeUi = computed(() => tileUi[selectedTile.value.key])
+const controlsDisabled = computed(() => Boolean(props.disabled || selectedTile.value.locked))
+const hasActivePending = computed(() => Boolean(activeEditor.value.pendingFile || activeEditor.value.pendingUrl))
+const editingCaption = computed(() =>
+  selectedTile.value.medium === 'audio' ? t('book.detail.coverEditor.editingAudio') : t('book.detail.coverEditor.editingEbook'),
+)
+const captionId = `cover-editor-caption-${useId()}`
+
+const pendingKeys = computed(() => tileKeys.value.filter((key) => Boolean(editors[key].pendingFile || editors[key].pendingUrl)))
+const hasPending = computed(() => pendingKeys.value.length > 0)
+const pendingMedia = computed(() => pendingKeys.value.map(mediumOf))
+const busy = computed(() => tileKeys.value.some((key) => editors[key].uploading || editors[key].regenerating))
+
+const tileGroup = ref<HTMLElement | null>(null)
+
+function selectTile(key: TileKey) {
+  selectedKey.value = key
+}
+
+function handleTileKeydown(event: KeyboardEvent) {
+  const index = tileKeys.value.indexOf(selectedKey.value)
+  const next = nextRovingIndex(event.key, index, tileKeys.value.length)
+  if (next === null) return
+  event.preventDefault()
+  const key = tileKeys.value[next]!
+  selectedKey.value = key
+  void nextTick(() => tileGroup.value?.querySelector<HTMLButtonElement>(`[data-cover-tile="${key}"]`)?.focus())
+}
+
+function handleToggleLock(field: CoverLockField) {
+  if (props.disabled) return
+  emit('toggleLock', field)
+}
+
+const lightboxOpen = ref(false)
+const lightboxMedium = ref<CoverMedium | null>(null)
+const lightboxPreviews = computed(() => ({ ebook: editors.ebook.previewSrc, audio: editors.audio.previewSrc }))
+
+function openLightbox(key: TileKey) {
+  lightboxMedium.value = mediumOf(key)
+  lightboxOpen.value = true
+}
+
+function handleLightboxOpenChange(open: boolean) {
+  lightboxOpen.value = open
+}
+
+let debounceTimer: ReturnType<typeof setTimeout> | undefined
+
+function cancelPending() {
+  activeEditor.value.clearPending()
+  activeUi.value.urlInput = ''
+}
+
+function onFileChange(event: Event) {
+  const input = event.target as HTMLInputElement
+  const file = input.files?.[0]
+  input.value = ''
+  if (controlsDisabled.value || !file) return
+  activeEditor.value.selectFile(file)
+}
+
+function applyPendingUrl(key: TileKey) {
+  if (props.disabled || tiles.value.find((tile) => tile.key === key)?.locked) return
+  editors[key].setUrl(tileUi[key].urlInput.trim())
 }
 
 function onUrlInput() {
   if (controlsDisabled.value) return
   clearTimeout(debounceTimer)
-  debounceTimer = setTimeout(applyPendingUrl, 400)
+  const key = selectedKey.value
+  debounceTimer = setTimeout(() => applyPendingUrl(key), 400)
 }
 
-function applyPendingUrl() {
+function switchMode(mode: 'file' | 'url') {
   if (controlsDisabled.value) return
-  setUrl(urlInput.value.trim())
-}
-
-function switchMode(modeValue: 'file' | 'url') {
-  if (controlsDisabled.value) return
-  mode.value = modeValue
   clearTimeout(debounceTimer)
-  clearPending()
-  urlInput.value = ''
+  activeUi.value.mode = mode
+  cancelPending()
 }
 
 function handleSelectFileMode() {
@@ -90,42 +198,7 @@ function handleSelectUrlMode() {
   switchMode('url')
 }
 
-function handleSearchSelect(url: string) {
-  if (controlsDisabled.value) return
-  urlInput.value = url
-  setUrl(url)
-}
-
-async function confirmPending() {
-  if (controlsDisabled.value || uploading.value) return false
-  return confirm()
-}
-
-async function handleConfirm() {
-  const ok = await confirmPending()
-  if (ok) emit('coverChanged', 'custom')
-}
-
-async function handleRevert() {
-  if (controlsDisabled.value) return
-  const result = await revert()
-  if (result !== false) emit('coverChanged', result)
-}
-
-const lightboxOpen = ref(false)
-
-function handleCoverClick() {
-  if (hasCover.value) lightboxOpen.value = true
-}
-
-function handleCloseLightbox() {
-  lightboxOpen.value = false
-}
-
-function handleToggleLock() {
-  if (props.disabled) return
-  emit('toggleLock')
-}
+const isSearchOpen = ref(false)
 
 function handleOpenSearch() {
   if (controlsDisabled.value) return
@@ -136,172 +209,297 @@ function handleSearchOpenChange(open: boolean) {
   isSearchOpen.value = open && !controlsDisabled.value
 }
 
-function setPendingUrl(url: string) {
+function handleSearchSelect(url: string) {
   if (controlsDisabled.value) return
-  setUrl(url)
+  activeUi.value.urlInput = url
+  activeEditor.value.setUrl(url)
 }
 
-defineExpose({ setUrl: setPendingUrl, hasPending, busy: uploading, confirm: confirmPending })
+async function confirmTile(key: TileKey): Promise<boolean> {
+  const ok = await editors[key].confirm()
+  if (ok) {
+    tileUi[key].urlInput = ''
+    emit('coverChanged', mediumOf(key))
+  }
+  return ok
+}
+
+async function handleConfirm() {
+  if (controlsDisabled.value || activeEditor.value.uploading) return
+  await confirmTile(selectedKey.value)
+}
+
+async function handleRevert() {
+  if (controlsDisabled.value) return
+  const key = selectedKey.value
+  const result = await editors[key].revert()
+  if (result !== false) emit('coverChanged', mediumOf(key))
+}
+
+async function handleRegenerate() {
+  if (controlsDisabled.value || activeEditor.value.regenerating) return
+  const key = selectedKey.value
+  if (await editors[key].regenerate()) emit('coverChanged', mediumOf(key))
+}
+
+/**
+ * Saves the pending tiles, all of them by default. It stops at the first failure and selects that
+ * tile, so its error is the one on screen.
+ */
+async function confirmPending(media: readonly (CoverMedium | null)[] = pendingMedia.value): Promise<boolean> {
+  if (props.disabled) return false
+  const keys = media.map(tileKey).filter((key) => pendingKeys.value.includes(key))
+  if (keys.some((key) => editors[key].uploading)) return false
+  for (const key of keys) {
+    if (!(await confirmTile(key))) {
+      selectedKey.value = key
+      return false
+    }
+  }
+  return true
+}
+
+/**
+ * Stages a fetched cover on a tile. A medium the book has picks its tile; otherwise the cover goes to
+ * the ebook slot, or the only slot a book without an ebook has.
+ */
+function setPendingUrl(url: string, medium?: CoverMedium) {
+  const key = tileKey(medium && props.book.coverMedia.includes(medium) ? medium : coverFieldMedium(props.book))
+  const tile = tiles.value.find((candidate) => candidate.key === key)
+  if (props.disabled || !tile || tile.locked) return
+  selectedKey.value = key
+  editors[key].setUrl(url)
+}
+
+defineExpose({ setUrl: setPendingUrl, hasPending, pendingMedia, busy, confirm: confirmPending, reset: clearAllPending })
 
 onUnmounted(() => clearTimeout(debounceTimer))
 </script>
 
 <template>
   <div class="@container/cover-editor">
-    <div class="flex min-w-0 flex-col gap-3 @min-[21rem]/cover-editor:flex-row @min-[21rem]/cover-editor:gap-5">
-      <!-- Cover image -->
+    <div class="flex min-w-0 flex-col gap-3" :class="isMultiSlot ? '' : '@min-[21rem]/cover-editor:flex-row @min-[21rem]/cover-editor:gap-5'">
+      <!-- Two slots: a radio group of tiles. Each tile's lock and zoom sit beside its radio, not inside it. -->
       <div
-        class="relative w-full shrink-0 overflow-hidden rounded-lg bg-muted shadow-md @min-[21rem]/cover-editor:w-36"
-        :class="hasCover ? 'cursor-zoom-in' : ''"
-        :style="{ aspectRatio: coverAspectRatio }"
-        @click="handleCoverClick"
+        v-if="isMultiSlot"
+        ref="tileGroup"
+        role="radiogroup"
+        :aria-label="t('book.detail.coverEditor.slotsLabel')"
+        class="flex flex-wrap items-end justify-center gap-3"
       >
-        <img v-if="hasCover" :src="activeSrc" :alt="book.title ?? ''" class="h-full w-full object-contain" @error="hideOnError" />
-        <BookCoverPlaceholder
-          v-else
-          :title="book.title"
-          :author-line="book.authors.map((a) => a.name).join(', ') || null"
-          :is-audio="isPrimaryAudio"
-          :seed="coverSeed"
-        />
-        <button
-          type="button"
-          class="absolute right-2 bottom-2 flex size-7 items-center justify-center rounded-md border shadow-sm backdrop-blur-sm transition-colors"
-          :class="
-            props.locked
-              ? 'border-primary/40 bg-primary/25 text-primary hover:bg-primary/35'
-              : 'border-input bg-background/90 text-muted-foreground hover:bg-muted hover:text-foreground'
-          "
-          :title="props.locked ? t('book.detail.coverEditor.unlockCover') : t('book.detail.coverEditor.lockCover')"
-          :disabled="props.disabled"
-          @click.stop="handleToggleLock"
-        >
-          <Lock v-if="props.locked" class="size-4" />
-          <LockOpen v-else class="size-4" />
-        </button>
+        <div v-for="tile in tiles" :key="tile.key" class="flex flex-col items-center gap-1.5">
+          <div
+            class="relative h-36 overflow-hidden rounded-lg bg-muted shadow-md ring-2 ring-offset-2 ring-offset-background transition-shadow"
+            :class="[tile.medium === 'audio' ? 'aspect-square' : 'aspect-[2/3]', tile.key === selectedKey ? 'ring-primary' : 'ring-transparent']"
+          >
+            <button
+              type="button"
+              role="radio"
+              :data-cover-tile="tile.key"
+              :aria-checked="tile.key === selectedKey"
+              :tabindex="tile.key === selectedKey ? 0 : -1"
+              :aria-label="tile.name"
+              :disabled="props.disabled"
+              class="relative block h-full w-full focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-inset"
+              @click="selectTile(tile.key)"
+              @keydown="handleTileKeydown"
+            >
+              <img v-if="tile.hasImage" :src="tile.src" alt="" class="h-full w-full object-contain" @error="hideOnError" />
+              <BookCoverPlaceholder v-else :title="book.title" :author-line="authorLine" :is-audio="tile.medium === 'audio'" :seed="coverSeed" />
+            </button>
+            <button
+              v-if="tile.hasImage"
+              type="button"
+              class="absolute bottom-2 left-2 flex size-7 items-center justify-center rounded-md border border-input bg-background/90 text-foreground shadow-sm backdrop-blur-sm transition-colors hover:bg-muted focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring"
+              :title="tile.viewLargerLabel"
+              :aria-label="tile.viewLargerLabel"
+              :disabled="props.disabled"
+              @click="openLightbox(tile.key)"
+            >
+              <Maximize2 class="size-3.5" aria-hidden="true" />
+            </button>
+            <button
+              type="button"
+              class="absolute right-2 bottom-2 flex size-7 items-center justify-center rounded-md border shadow-sm backdrop-blur-sm transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring"
+              :class="
+                tile.locked
+                  ? 'border-primary/40 bg-primary/25 text-primary hover:bg-primary/35'
+                  : 'border-input bg-background/90 text-muted-foreground hover:bg-muted hover:text-foreground focus-visible:text-foreground'
+              "
+              :title="tile.lockLabel"
+              :aria-label="tile.lockLabel"
+              :disabled="props.disabled"
+              @click="handleToggleLock(tile.lockField)"
+            >
+              <Lock v-if="tile.locked" class="size-4" aria-hidden="true" />
+              <LockOpen v-else class="size-4" aria-hidden="true" />
+            </button>
+          </div>
+          <span class="text-xs" :class="tile.key === selectedKey ? 'font-semibold text-primary' : 'text-muted-foreground'" aria-hidden="true">
+            {{ tile.label }}
+          </span>
+        </div>
       </div>
 
-      <!-- Lightbox -->
-      <Teleport to="body">
+      <!-- One slot: the cover itself, which opens the lightbox. -->
+      <template v-else>
         <div
-          v-if="lightboxOpen && hasCover"
-          class="fixed inset-0 z-50 flex items-center justify-center bg-black/80 backdrop-blur-sm"
-          @click="handleCloseLightbox"
+          v-for="tile in tiles"
+          :key="tile.key"
+          class="relative w-full shrink-0 overflow-hidden rounded-lg bg-muted shadow-md @min-[21rem]/cover-editor:w-36"
+          :style="{ aspectRatio: coverAspectRatio }"
         >
           <button
-            class="absolute top-4 right-4 p-2 rounded-full bg-white/10 hover:bg-white/20 text-white transition-colors"
-            @click="handleCloseLightbox"
+            v-if="tile.hasImage"
+            type="button"
+            class="block h-full w-full cursor-zoom-in focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-inset"
+            :aria-label="tile.viewLargerLabel"
+            :disabled="props.disabled"
+            @click="openLightbox(tile.key)"
           >
-            <X class="size-5" />
+            <img :src="tile.src" :alt="book.title ?? ''" class="h-full w-full object-contain" @error="hideOnError" />
           </button>
-          <img :src="activeSrc" :alt="book.title ?? ''" class="max-h-[90vh] max-w-[90vw] rounded-lg shadow-2xl object-contain" @click.stop />
-        </div>
-      </Teleport>
-
-      <!-- Controls follow the space assigned by the parent layout, not the viewport width. -->
-      <div class="flex min-w-0 flex-1 flex-col gap-3">
-        <!-- Mode toggle -->
-        <div class="flex gap-1 p-0.5 rounded-lg bg-muted">
+          <BookCoverPlaceholder v-else :title="book.title" :author-line="authorLine" :is-audio="tile.medium === 'audio'" :seed="coverSeed" />
           <button
-            class="flex flex-1 items-center justify-center gap-1.5 py-1.5 rounded-md text-xs font-medium transition-colors disabled:opacity-50 disabled:cursor-not-allowed"
-            :class="mode === 'file' ? 'bg-background shadow-sm text-foreground' : 'text-muted-foreground hover:text-foreground'"
+            type="button"
+            class="absolute right-2 bottom-2 flex size-7 items-center justify-center rounded-md border shadow-sm backdrop-blur-sm transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring"
+            :class="
+              tile.locked
+                ? 'border-primary/40 bg-primary/25 text-primary hover:bg-primary/35'
+                : 'border-input bg-background/90 text-muted-foreground hover:bg-muted hover:text-foreground focus-visible:text-foreground'
+            "
+            :title="tile.lockLabel"
+            :aria-label="tile.lockLabel"
+            :disabled="props.disabled"
+            @click="handleToggleLock(tile.lockField)"
+          >
+            <Lock v-if="tile.locked" class="size-4" aria-hidden="true" />
+            <LockOpen v-else class="size-4" aria-hidden="true" />
+          </button>
+        </div>
+      </template>
+
+      <BookCoverLightbox
+        :open="lightboxOpen"
+        :book="book"
+        :medium="lightboxMedium"
+        :previews="lightboxPreviews"
+        @update:open="handleLightboxOpenChange"
+      />
+
+      <!-- Controls act on the selected tile, and the caption names it for everyone. -->
+      <div
+        class="flex min-w-0 flex-1 flex-col gap-3"
+        :role="isMultiSlot ? 'group' : undefined"
+        :aria-labelledby="isMultiSlot ? captionId : undefined"
+      >
+        <p v-if="isMultiSlot" :id="captionId" class="text-xs font-medium text-muted-foreground">{{ editingCaption }}</p>
+
+        <div class="flex gap-1 p-0.5 rounded-lg bg-muted" role="group" :aria-label="t('book.detail.coverEditor.sourceMode')">
+          <button
+            type="button"
+            class="flex flex-1 items-center justify-center gap-1.5 py-1.5 rounded-md text-xs font-medium transition-colors disabled:opacity-50 disabled:cursor-not-allowed focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring"
+            :class="activeUi.mode === 'file' ? 'bg-background shadow-sm text-foreground' : 'text-muted-foreground hover:text-foreground'"
+            :aria-pressed="activeUi.mode === 'file'"
             :disabled="controlsDisabled"
             @click="handleSelectFileMode"
           >
-            <ImagePlus class="size-3.5" />
+            <ImagePlus class="size-3.5" aria-hidden="true" />
             {{ t('book.detail.coverEditor.fileTab') }}
           </button>
           <button
-            class="flex flex-1 items-center justify-center gap-1.5 py-1.5 rounded-md text-xs font-medium transition-colors disabled:opacity-50 disabled:cursor-not-allowed"
-            :class="mode === 'url' ? 'bg-background shadow-sm text-foreground' : 'text-muted-foreground hover:text-foreground'"
+            type="button"
+            class="flex flex-1 items-center justify-center gap-1.5 py-1.5 rounded-md text-xs font-medium transition-colors disabled:opacity-50 disabled:cursor-not-allowed focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring"
+            :class="activeUi.mode === 'url' ? 'bg-background shadow-sm text-foreground' : 'text-muted-foreground hover:text-foreground'"
+            :aria-pressed="activeUi.mode === 'url'"
             :disabled="controlsDisabled"
             @click="handleSelectUrlMode"
           >
-            <Link class="size-3.5" />
+            <Link class="size-3.5" aria-hidden="true" />
             {{ t('book.detail.coverEditor.urlTab') }}
           </button>
         </div>
 
-        <!-- File input -->
-        <div v-if="mode === 'file'">
-          <label
-            class="flex items-center gap-2 h-9 px-3 rounded-lg border border-dashed border-input bg-background text-xs text-muted-foreground hover:text-foreground hover:border-foreground/40 transition-colors"
-            :class="controlsDisabled ? 'cursor-not-allowed opacity-60' : 'cursor-pointer'"
-          >
-            <Upload class="size-3.5 shrink-0" />
-            <span class="truncate">{{ pendingFile ? pendingFile.name : t('book.detail.coverEditor.chooseImage') }}</span>
-            <input type="file" accept="image/*" class="hidden" :disabled="controlsDisabled" @change="onFileChange" />
-          </label>
-        </div>
+        <!-- The input stays in the tab order; only its box is hidden, so the label is what shows focus. -->
+        <label
+          v-if="activeUi.mode === 'file'"
+          class="relative flex items-center gap-2 h-9 px-3 rounded-lg border border-dashed border-input bg-background text-xs text-muted-foreground hover:text-foreground hover:border-foreground/40 transition-colors focus-within:ring-2 focus-within:ring-ring"
+          :class="controlsDisabled ? 'cursor-not-allowed opacity-60' : 'cursor-pointer'"
+        >
+          <Upload class="size-3.5 shrink-0" aria-hidden="true" />
+          <span class="truncate">{{ activeEditor.pendingFile ? activeEditor.pendingFile.name : t('book.detail.coverEditor.chooseImage') }}</span>
+          <input type="file" accept="image/*" class="sr-only" :disabled="controlsDisabled" @change="onFileChange" />
+        </label>
 
-        <!-- URL input -->
-        <div v-else class="flex flex-col gap-2">
-          <input
-            v-model="urlInput"
-            class="w-full h-9 rounded-lg border border-input bg-background px-3 text-xs outline-none focus:ring-1 focus:ring-ring transition-shadow"
-            :disabled="controlsDisabled"
-            @input="onUrlInput"
-          />
-        </div>
+        <input
+          v-else
+          v-model="activeUi.urlInput"
+          inputmode="url"
+          :aria-label="t('book.detail.coverEditor.urlLabel')"
+          class="w-full h-9 rounded-lg border border-input bg-background px-3 text-xs outline-none focus:ring-1 focus:ring-ring transition-shadow"
+          :disabled="controlsDisabled"
+          @input="onUrlInput"
+        />
 
-        <!-- Search Button -->
         <button
+          type="button"
           class="flex items-center justify-center gap-2 w-full h-9 rounded-lg border border-input bg-background text-xs font-medium hover:bg-muted transition-colors disabled:opacity-50 disabled:cursor-not-allowed"
           :disabled="controlsDisabled"
           @click="handleOpenSearch"
         >
-          <Search class="size-3.5" />
+          <Search class="size-3.5" aria-hidden="true" />
           {{ t('book.detail.coverEditor.findCoverOnline') }}
         </button>
 
-        <!-- Cover Search Drawer -->
         <CoverSearchDrawer
           :open="isSearchOpen"
           :initial-title="book.title ?? ''"
           :initial-author="book.authors?.[0]?.name ?? ''"
-          :is-audiobook="isPrimaryAudio"
+          :is-audiobook="selectedTile.medium === 'audio'"
           @update:open="handleSearchOpenChange"
           @select="handleSearchSelect"
         />
 
-        <!-- Error -->
-        <p v-if="error" class="text-xs text-destructive">{{ error }}</p>
+        <p v-if="activeEditor.error" role="alert" class="text-xs text-destructive">{{ activeEditor.error }}</p>
 
-        <!-- Actions -->
         <div class="flex flex-col gap-1.5">
           <button
-            v-if="hasPending"
+            v-if="hasActivePending"
+            type="button"
             class="w-full h-8 rounded-lg bg-primary text-primary-foreground text-xs font-medium hover:bg-primary/90 transition-colors disabled:opacity-50"
-            :disabled="uploading || controlsDisabled"
+            :disabled="activeEditor.uploading || controlsDisabled"
             @click="handleConfirm"
           >
-            {{ uploading ? t('book.detail.coverEditor.saving') : t('book.detail.coverEditor.saveCover') }}
+            {{ activeEditor.uploading ? t('book.detail.coverEditor.saving') : t('book.detail.coverEditor.saveCover') }}
           </button>
           <button
-            v-if="hasPending"
+            v-if="hasActivePending"
+            type="button"
             class="w-full h-8 rounded-lg border border-input bg-background text-xs hover:bg-muted transition-colors disabled:opacity-50"
-            :disabled="uploading || controlsDisabled"
+            :disabled="activeEditor.uploading || controlsDisabled"
             @click="cancelPending"
           >
             {{ t('common.cancel') }}
           </button>
           <button
-            v-if="book.coverSource === 'custom'"
-            class="flex items-center justify-center gap-1.5 w-full h-8 rounded-lg border border-input bg-background text-xs text-muted-foreground hover:text-foreground hover:bg-muted transition-colors disabled:opacity-50"
-            :disabled="uploading || controlsDisabled"
+            v-if="selectedTile.source === 'custom'"
+            type="button"
+            class="flex items-center justify-center gap-1.5 w-full h-8 rounded-lg border border-input bg-background text-xs text-muted-foreground hover:text-foreground focus-visible:text-foreground hover:bg-muted transition-colors disabled:opacity-50"
+            :disabled="activeEditor.uploading || controlsDisabled"
             @click="handleRevert"
           >
-            <RotateCcw class="size-3" />
+            <RotateCcw class="size-3" aria-hidden="true" />
             {{ t('book.detail.coverEditor.revertToOriginal') }}
           </button>
           <button
             v-if="hasPermission('library_edit_metadata')"
-            class="flex items-center justify-center gap-1.5 w-full h-8 rounded-lg border border-input bg-background text-xs text-muted-foreground hover:text-foreground hover:bg-muted transition-colors disabled:opacity-50"
-            :disabled="reExtractingCover || controlsDisabled"
-            @click="reExtractCover"
+            type="button"
+            class="flex items-center justify-center gap-1.5 w-full h-8 rounded-lg border border-input bg-background text-xs text-muted-foreground hover:text-foreground focus-visible:text-foreground hover:bg-muted transition-colors disabled:opacity-50"
+            :disabled="activeEditor.regenerating || controlsDisabled"
+            @click="handleRegenerate"
           >
-            <Loader2 v-if="reExtractingCover" class="size-3 animate-spin" />
-            <Image v-else class="size-3" />
+            <Loader2 v-if="activeEditor.regenerating" class="size-3 animate-spin" aria-hidden="true" />
+            <Image v-else class="size-3" aria-hidden="true" />
             {{ t('book.detail.coverEditor.regenerateCover') }}
           </button>
         </div>
diff --git a/client/src/features/book/components/detail/tabs/DetailsTab.vue b/client/src/features/book/components/detail/tabs/DetailsTab.vue
index 49ec62680..2f3d9441e 100644
--- a/client/src/features/book/components/detail/tabs/DetailsTab.vue
+++ b/client/src/features/book/components/detail/tabs/DetailsTab.vue
@@ -23,10 +23,10 @@ import {
   TriangleAlert,
   X,
 } from '@lucide/vue'
-import { DialogClose, DialogContent, DialogOverlay, DialogPortal, DialogRoot } from 'reka-ui'
 import { getFormatColor } from '@/features/book/lib/format-colors'
 import { providerIconPathSafe } from '@/features/book/lib/provider-icons'
 import { createBookProviderLinks } from '@/features/book/lib/provider-links'
+import { faceMedium } from '@/features/book/lib/cover-slots'
 import { readingDateToDateKey } from '@/features/book/lib/reading-date'
 import { getProviderColor, PROVIDER_SHORT_LABELS } from '@/lib/provider-colors'
 import { useCoverVersions } from '@/features/book/composables/useCoverVersions'
@@ -37,6 +37,7 @@ import { STATUS_OPTIONS, STATUS_ICONS, STATUS_COLORS, useBookStatus } from '@/fe
 import BookDownloadButton from '@/features/book/components/BookDownloadButton.vue'
 import DiscoverRow from '@/features/book/components/detail/DiscoverRow.vue'
 import BookCoverArtwork from '@/features/book/components/BookCoverArtwork.vue'
+import BookCoverLightbox from '@/features/book/components/BookCoverLightbox.vue'
 import { Tooltip, TooltipContent, TooltipTrigger } from '@/components/ui/tooltip'
 import { Popover, PopoverContent, PopoverTrigger } from '@/components/ui/popover'
 import { DropdownMenu, DropdownMenuContent, DropdownMenuItem, DropdownMenuTrigger } from '@/components/ui/dropdown-menu'
@@ -276,7 +277,7 @@ const coverSeed = computed(() => props.book.title ?? props.book.folderPath.split
 const coverPlaceholderTitle = computed(() => props.book.title ?? props.book.folderPath.split('/').pop() ?? null)
 const hasCover = computed(() => props.book.coverSource !== null)
 const { coverUrl } = useCoverVersions()
-const coverSrc = computed(() => coverUrl(props.book.id, 'cover', props.book.updatedAt ?? props.book.addedAt))
+const coverSrc = computed(() => coverUrl(props.book.id, 'cover', props.book.coverVersion))
 
 watch(coverSrc, () => {
   coverLoaded.value = false
@@ -352,6 +353,11 @@ const primaryFile = computed(() => props.book.files.find((f) => f.role === 'prim
 const readAlongFile = computed(() => props.book.files.find((file) => hasReadAlong(file)) ?? null)
 const hasAudioFile = computed(() => props.book.files.some((file) => file.format != null && FORMAT_TO_GROUP[file.format] === 'audio'))
 const isPrimaryAudio = computed(() => primaryFile.value?.format != null && FORMAT_TO_GROUP[primaryFile.value.format] === 'audio')
+// The hero shows the face, whose shape follows the library rather than the primary file once slots exist.
+const isFaceAudio = computed(() => {
+  if (!props.book.covers.ebook && !props.book.covers.audio) return isPrimaryAudio.value
+  return faceMedium(props.book, coverAspectRatio.value) === 'audio'
+})
 const isPrimaryComic = computed(() => primaryFile.value?.format != null && FORMAT_TO_GROUP[primaryFile.value.format] === 'cbx')
 const readableFiles = computed(() => props.book.files.filter((f) => f.format && READER_OPENABLE_FORMATS.has(f.format)))
 
@@ -1124,10 +1130,14 @@ function handleCoverError() {
   coverImageRatio.value = null
 }
 
+const canOpenCoverLightbox = computed(() => hasCover.value && coverLoaded.value && !coverFailed.value)
+
 function handleCoverClick() {
-  if (hasCover.value && coverLoaded.value && !coverFailed.value) {
-    coverLightboxOpen.value = true
-  }
+  if (canOpenCoverLightbox.value) coverLightboxOpen.value = true
+}
+
+function handleCoverLightboxOpenChange(open: boolean) {
+  coverLightboxOpen.value = open
 }
 
 function openEditCover() {
@@ -1335,19 +1345,26 @@ watch(
           >
             <BookCoverSurface
               class="book-cover-surface--spine-fitted group relative w-full overflow-hidden rounded-lg shadow-lg shadow-black/40"
-              :disable-spine="isPrimaryAudio"
+              :disable-spine="isFaceAudio"
               :is-comic="isPrimaryComic"
               :class="hasCover && coverLoaded && !coverFailed ? 'cursor-zoom-in' : ''"
               :style="{ aspectRatio: detailCoverAspectRatio }"
-              @click="handleCoverClick"
             >
+              <button
+                v-if="canOpenCoverLightbox"
+                type="button"
+                class="absolute inset-0 z-[4] cursor-zoom-in rounded-lg focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-primary"
+                :aria-label="t('book.detail.details.viewCover')"
+                @click="handleCoverClick"
+              />
               <Tooltip>
                 <TooltipTrigger as-child>
                   <button
-                    class="absolute top-1.5 right-1.5 z-10 p-1 rounded bg-black/50 text-white opacity-0 group-hover:opacity-100 transition-opacity"
+                    class="absolute top-1.5 right-1.5 z-10 p-1 rounded bg-black/50 text-white opacity-0 group-hover:opacity-100 focus-visible:opacity-100 transition-opacity"
+                    :aria-label="t('book.detail.details.editCover')"
                     @click.stop="openEditCover"
                   >
-                    <Pencil class="size-3" />
+                    <Pencil class="size-3" aria-hidden="true" />
                   </button>
                 </TooltipTrigger>
                 <TooltipContent>{{ t('book.detail.details.editCover') }}</TooltipContent>
@@ -1357,13 +1374,13 @@ watch(
                 :has-cover="hasCover"
                 :title="coverPlaceholderTitle"
                 :author-line="book.authors.map((a) => a.name).join(', ') || null"
-                :is-audio="isPrimaryAudio"
+                :is-audio="isFaceAudio"
                 :seed="coverSeed"
                 :alt="book.title ?? ''"
                 :frame-aspect-ratio="detailCoverAspectRatio"
                 loading="eager"
                 backdrop-class="blur-lg brightness-50"
-                :spine="!isPrimaryAudio"
+                :spine="!isFaceAudio"
                 :is-comic="isPrimaryComic"
                 @load="handleCoverLoad"
                 @error="handleCoverError"
@@ -2328,24 +2345,7 @@ watch(
     @confirm="handleResetReadingState"
   />
 
-  <!-- Cover lightbox -->
-  <DialogRoot :open="coverLightboxOpen" @update:open="coverLightboxOpen = $event">
-    <DialogPortal>
-      <DialogOverlay
-        class="fixed inset-0 z-50 bg-black/80 data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0"
-      />
-      <DialogContent
-        class="fixed left-1/2 top-1/2 z-50 -translate-x-1/2 -translate-y-1/2 max-w-[90vw] max-h-[90vh] outline-none data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95"
-      >
-        <img :src="coverSrc" :alt="book.title ?? ''" class="max-w-[90vw] max-h-[90vh] rounded-md shadow-2xl object-contain" />
-        <DialogClose
-          class="absolute -top-3 -right-3 p-1 rounded-full bg-background border border-border text-muted-foreground hover:text-foreground transition-colors"
-        >
-          <X class="size-4" />
-        </DialogClose>
-      </DialogContent>
-    </DialogPortal>
-  </DialogRoot>
+  <BookCoverLightbox :open="coverLightboxOpen" :book="book" @update:open="handleCoverLightboxOpenChange" />
 </template>
 
 <style scoped>
diff --git a/client/src/features/book/components/detail/tabs/EditMetadataTab.vue b/client/src/features/book/components/detail/tabs/EditMetadataTab.vue
index c39a52ed0..030a757f1 100644
--- a/client/src/features/book/components/detail/tabs/EditMetadataTab.vue
+++ b/client/src/features/book/components/detail/tabs/EditMetadataTab.vue
@@ -1,5 +1,5 @@
 <script setup lang="ts">
-import { computed, onBeforeUnmount, ref, watch } from 'vue'
+import { computed, nextTick, onBeforeUnmount, ref, watch } from 'vue'
 import { useI18n } from 'vue-i18n'
 import {
   Check,
@@ -20,6 +20,7 @@ import type {
   BookCommunityRating,
   BookDetail,
   BookMetadataLockField,
+  CoverMedium,
   CustomMetadataPrimitiveValue,
   MetadataProviderInfo,
   WriteResult,
@@ -35,7 +36,7 @@ import MetadataFieldLabel from './MetadataFieldLabel.vue'
 import RichDescriptionEditor from './RichDescriptionEditor.vue'
 import SeriesMembershipEditor from './SeriesMembershipEditor.vue'
 import WriteAndRenameResultPanel from '../WriteAndRenameResultPanel.vue'
-import type { MetadataPatch } from '../../../composables/useMetadataDiff'
+import type { MetadataDiffApply, MetadataPatch } from '../../../composables/useMetadataDiff'
 import { type EditableSeriesMembership, normalizeSeriesMemberships, useMetadataEditor } from '../../../composables/useMetadataEditor'
 import { type MetadataRefreshPreview, useRefreshMetadata } from '../../../composables/useRefreshMetadata'
 import { type FileMetadata, useFileMetadata } from '../../../composables/useFileMetadata'
@@ -51,6 +52,7 @@ import { buildFileMetadataPatch } from '@/features/book/lib/file-metadata-patch'
 import { metadataRefreshAppliedMessage, metadataRefreshEmptyMessage } from '@/features/book/lib/metadata-refresh-feedback'
 import { filterProviderIdFields, isProviderIdFieldAvailable, isProviderIdFormField } from '@/features/book/lib/provider-id-fields'
 import { formatCommunityRatingLine } from '@/features/book/lib/community-rating'
+import { coverFieldMedium, coverLockField } from '@/features/book/lib/cover-slots'
 import { formatList } from '@/i18n/formatters'
 import MetadataSourceCard from './MetadataSourceCard.vue'
 
@@ -60,7 +62,7 @@ const props = defineProps<{ book: BookDetail }>()
 const emit = defineEmits<{
   saved: [BookDetail]
   locksChanged: [BookMetadataLockField[]]
-  coverChanged: ['extracted' | 'custom' | null]
+  coverChanged: [medium: CoverMedium | null]
   fileRenamed: []
 }>()
 
@@ -339,7 +341,7 @@ const comicWideFields = computed(
 )
 
 const hasLockedFields = computed(() => lockedFields.value.length > 0)
-const hasPendingChanges = computed(() => isDirty.value || locksDirty.value)
+const hasPendingChanges = computed(() => isDirty.value || locksDirty.value || Boolean(coverPanel.value?.hasPending))
 const hasInvalidSeriesIndex = computed(() =>
   form.seriesMemberships.some((membership) => membership.seriesIndex !== null && !isValidSeriesIndex(membership.seriesIndex)),
 )
@@ -348,25 +350,36 @@ const communityRatingLines = computed(() =>
   form.communityRatings.map((rating) => formatCommunityRatingLine(rating, availableMetadataProviders.value ?? [])),
 )
 
+/**
+ * Locks here save with the form, so a pending cover whose slot is locked on the server can only be
+ * written after the form has unlocked it. Every other pending cover is written first, and a failure
+ * there stops the form save.
+ */
 async function submit() {
   if (submitDisabled.value) return
-  if (coverPanel.value?.hasPending) {
-    const ok = await coverPanel.value.confirm()
-    if (ok) emit('coverChanged', 'custom')
-  }
+  const panel = coverPanel.value
+  const pendingMedia = panel?.pendingMedia ?? []
+  const lockedOnServer = (medium: CoverMedium | null) => props.book.lockedFields.includes(coverLockField(medium))
+  if (panel && !(await panel.confirm(pendingMedia.filter((medium) => !lockedOnServer(medium))))) return
+
   const locksChanged = locksDirty.value
   const result = await save(props.book.id, lockedFields.value)
-  if (result) {
-    markLocksPersisted(result.book.lockedFields)
-    emit('saved', result.book)
-    if (locksChanged) emit('locksChanged', result.book.lockedFields)
-    showSaveResultToast(result.write, result.libraryAutoWriteEnabled)
-  }
+  if (!result) return
+  markLocksPersisted(result.book.lockedFields)
+  emit('saved', result.book)
+  if (locksChanged) emit('locksChanged', result.book.lockedFields)
+  showSaveResultToast(result.write, result.libraryAutoWriteEnabled)
+
+  const unlockedBySave = pendingMedia.filter((medium) => lockedOnServer(medium) && !result.book.lockedFields.includes(coverLockField(medium)))
+  if (!panel || unlockedBySave.length === 0) return
+  await nextTick()
+  await panel.confirm(unlockedBySave)
 }
 
 function handleReset() {
   reset()
   resetLocks()
+  coverPanel.value?.reset()
 }
 
 const hoverRating = ref<number | null>(null)
@@ -589,7 +602,9 @@ function applyCustomMetadataPatch(formPatch: MetadataPatch): number {
   return updated
 }
 
-function applyPatchToForm(formPatch: MetadataPatch, coverUrl: string | undefined): { skippedFields: BookMetadataLockField[]; updatedCount: number } {
+type FetchedCovers = Partial<Record<CoverMedium, string>>
+
+function applyPatchToForm(formPatch: MetadataPatch, covers: FetchedCovers): { skippedFields: BookMetadataLockField[]; updatedCount: number } {
   const skippedFields: BookMetadataLockField[] = []
   let updatedCount = 0
   const hasSeriesMembershipPatch = formPatch.seriesMemberships !== undefined
@@ -604,11 +619,14 @@ function applyPatchToForm(formPatch: MetadataPatch, coverUrl: string | undefined
   updatedCount += applyAudioPatch(formPatch, skippedFields)
   updatedCount += applyCustomMetadataPatch(formPatch)
 
-  if (coverUrl) {
-    if (isLocked('cover')) {
-      trackLockedField('cover', skippedFields)
+  for (const [medium, url] of Object.entries(covers) as [CoverMedium, string | undefined][]) {
+    if (!url) continue
+    const target = props.book.coverMedia.includes(medium) ? medium : coverFieldMedium(props.book)
+    const coverField = coverLockField(target)
+    if (isLocked(coverField)) {
+      trackLockedField(coverField, skippedFields)
     } else {
-      coverPanel.value?.setUrl(coverUrl)
+      coverPanel.value?.setUrl(url, target ?? undefined)
       updatedCount++
     }
   }
@@ -623,9 +641,9 @@ function showApplyResult(skippedFields: BookMetadataLockField[], updatedCount: n
   toast.info(t('book.detail.editMetadata.applyResult', { skipped: skippedPart, updated: updatedPart }))
 }
 
-function handleApply({ formPatch, coverUrl }: { formPatch: MetadataPatch; coverUrl?: string }) {
+function handleApply({ formPatch, coverUrl, audioCoverUrl }: MetadataDiffApply) {
   if (formDisabled.value) return
-  const { skippedFields, updatedCount } = applyPatchToForm(formPatch, coverUrl)
+  const { skippedFields, updatedCount } = applyPatchToForm(formPatch, { ebook: coverUrl, audio: audioCoverUrl })
   showApplyResult(skippedFields, updatedCount)
 }
 
@@ -735,7 +753,7 @@ async function autoFill() {
   const result = await previewRefresh(props.book.id)
   if (formDisabled.value) return
   if (!result) {
-    toast.error('Auto-fill failed')
+    toast.error(t('book.detail.editMetadata.autoFillFailed'))
     return
   }
 
@@ -749,7 +767,7 @@ async function autoFill() {
     return
   }
 
-  const { skippedFields, updatedCount } = applyPatchToForm(buildPreviewPatch(preview), preview.coverUrl)
+  const { skippedFields, updatedCount } = applyPatchToForm(buildPreviewPatch(preview), { ebook: preview.coverUrl, audio: preview.audioCoverUrl })
   if (skippedFields.length > 0) {
     showApplyResult(skippedFields, updatedCount)
     return
@@ -761,7 +779,7 @@ async function autoFill() {
 }
 
 function applyFileMetadataToForm(meta: FileMetadata): number {
-  const { updatedCount } = applyPatchToForm(buildFileMetadataPatch(meta), undefined)
+  const { updatedCount } = applyPatchToForm(buildFileMetadataPatch(meta), {})
   return updatedCount
 }
 
@@ -817,8 +835,8 @@ async function handleSeriesLockToggle() {
   await replaceLocks(props.book.id, next, 'seriesName')
 }
 
-function handleCoverLockToggle() {
-  handleLockToggle('cover')
+function handleCoverLockToggle(field: 'cover' | 'audioCover') {
+  void handleLockToggle(field)
 }
 
 async function handleLockAll() {
@@ -831,8 +849,8 @@ async function handleUnlockAll() {
   await unlockAll(props.book.id)
 }
 
-function handleCoverChanged(source: 'extracted' | 'custom' | null) {
-  emit('coverChanged', source)
+function handleCoverChanged(medium: CoverMedium | null) {
+  emit('coverChanged', medium)
 }
 </script>
 
@@ -1027,7 +1045,7 @@ function handleCoverChanged(source: 'extracted' | 'custom' | null) {
             <CoverEditorPanel
               ref="coverPanel"
               :book="props.book"
-              :locked="isLocked('cover')"
+              :locked-fields="lockedFields"
               :disabled="formDisabled"
               @cover-changed="handleCoverChanged"
               @toggle-lock="handleCoverLockToggle"
diff --git a/client/src/features/book/components/detail/tabs/MetadataDiffCoverResults.vue b/client/src/features/book/components/detail/tabs/MetadataDiffCoverResults.vue
new file mode 100644
index 000000000..7807c22c3
--- /dev/null
+++ b/client/src/features/book/components/detail/tabs/MetadataDiffCoverResults.vue
@@ -0,0 +1,88 @@
+<script setup lang="ts">
+import { computed } from 'vue'
+import { useI18n } from 'vue-i18n'
+import { Check, Loader2 } from '@lucide/vue'
+import type { CoverMedium, MetadataCandidate, MetadataProviderInfo } from '@bookorbit/types'
+import { getProviderLabel, hideOnError, providerBadgeStyle, toDisplayCoverUrl } from '../../../lib/metadata-fetch'
+
+const props = defineProps<{
+  medium: CoverMedium
+  choices: MetadataCandidate[]
+  active: MetadataCandidate | null
+  picked: MetadataCandidate | null
+  providers: MetadataProviderInfo[]
+  searching: boolean
+}>()
+
+const emit = defineEmits<{ select: [candidate: MetadataCandidate] }>()
+
+const { t } = useI18n()
+
+const aspectRatio = computed(() => (props.medium === 'audio' ? '1/1' : '2/3'))
+const copy = computed(() =>
+  props.medium === 'audio'
+    ? {
+        group: t('book.detail.editMetadata.diffPanel.secondCover.audioResults'),
+        searching: t('book.detail.editMetadata.diffPanel.secondCover.searchingAudio'),
+        none: t('book.detail.editMetadata.diffPanel.secondCover.noAudio'),
+      }
+    : {
+        group: t('book.detail.editMetadata.diffPanel.secondCover.bookResults'),
+        searching: t('book.detail.editMetadata.diffPanel.secondCover.searchingBook'),
+        none: t('book.detail.editMetadata.diffPanel.secondCover.noBook'),
+      },
+)
+
+function providerLabel(candidate: MetadataCandidate): string {
+  return getProviderLabel(candidate.provider, props.providers)
+}
+
+function selectChoice(candidate: MetadataCandidate) {
+  emit('select', candidate)
+}
+</script>
+
+<template>
+  <div class="mt-2.5">
+    <div v-if="choices.length" role="group" :aria-label="copy.group" class="flex items-center gap-1.5 overflow-x-auto p-0.5">
+      <button
+        v-for="(candidate, index) in choices"
+        :key="`${candidate.provider}:${candidate.providerId}:${index}`"
+        type="button"
+        class="relative w-12 shrink-0 overflow-hidden rounded-md bg-muted ring-1 transition-all focus-visible:outline-2 focus-visible:outline-offset-2 focus-visible:outline-primary"
+        :class="candidate === active ? 'ring-2 ring-primary' : 'ring-border hover:ring-foreground/40'"
+        :style="{ aspectRatio }"
+        :aria-pressed="candidate === active"
+        :aria-label="
+          t('book.detail.editMetadata.diffPanel.secondCover.showCover', {
+            provider: providerLabel(candidate),
+            index: index + 1,
+            total: choices.length,
+          })
+        "
+        @click="selectChoice(candidate)"
+      >
+        <img :src="toDisplayCoverUrl(candidate.coverUrl)" alt="" class="h-full w-full object-contain" @error="hideOnError" />
+        <span
+          class="absolute inset-x-0.5 bottom-0.5 truncate rounded px-0.5 text-center text-[8px] font-bold"
+          :style="providerBadgeStyle(candidate.provider)"
+          aria-hidden="true"
+        >
+          {{ providerLabel(candidate) }}
+        </span>
+        <span
+          v-if="candidate === picked"
+          class="absolute end-0.5 top-0.5 flex size-3.5 items-center justify-center rounded-full bg-primary text-primary-foreground"
+          aria-hidden="true"
+        >
+          <Check class="size-2.5" />
+        </span>
+      </button>
+    </div>
+    <p v-if="searching" role="status" class="mt-1.5 inline-flex items-center gap-1.5 text-[11px] text-muted-foreground">
+      <Loader2 class="size-3 animate-spin motion-reduce:animate-none" aria-hidden="true" />
+      {{ copy.searching }}
+    </p>
+    <p v-else-if="!choices.length" class="mt-1.5 text-[11px] text-muted-foreground">{{ copy.none }}</p>
+  </div>
+</template>
diff --git a/client/src/features/book/components/detail/tabs/MetadataDiffPanel.vue b/client/src/features/book/components/detail/tabs/MetadataDiffPanel.vue
index d4b8f14a2..8d24e9ee9 100644
--- a/client/src/features/book/components/detail/tabs/MetadataDiffPanel.vue
+++ b/client/src/features/book/components/detail/tabs/MetadataDiffPanel.vue
@@ -4,13 +4,17 @@ import { useI18n } from 'vue-i18n'
 import { ArrowLeft, CopyCheck, Copy, CheckCheck, Eye, EyeOff, Info } from '@lucide/vue'
 import type {
   BookMetadataLockField,
+  CoverMedium,
   MetadataCandidate,
   MetadataProviderInfo,
   MetadataProviderKey,
   MetadataSource,
   ProviderIds,
 } from '@bookorbit/types'
-import { useMetadataDiff, type DiffFieldKey, type MetadataPatch } from '../../../composables/useMetadataDiff'
+import { useMetadataDiff, type DiffField, type DiffFieldKey, type MetadataDiffApply } from '../../../composables/useMetadataDiff'
+import { useSecondCoverRow, type SecondCoverInput } from '../../../composables/useSecondCoverRow'
+import { useCoverShapes } from '../../../composables/useCoverShapes'
+import { coverLockField } from '../../../lib/cover-slots'
 import {
   getProviderColor,
   getProviderLabel,
@@ -20,6 +24,7 @@ import {
   toDisplayCoverUrl,
 } from '../../../lib/metadata-fetch'
 import MetadataDiffRow from './MetadataDiffRow.vue'
+import MetadataDiffCoverResults from './MetadataDiffCoverResults.vue'
 import { COVER_ASPECT_RATIO_KEY, DEFAULT_COVER_ASPECT_RATIO } from '../../../lib/cover-aspect-ratio'
 
 const props = defineProps<{
@@ -32,15 +37,25 @@ const props = defineProps<{
   currentCoverUrl?: string
   providerIds?: ProviderIds
   lockedFields?: BookMetadataLockField[]
+  /** The slot the main cover row fills. Defaults to the ebook slot. */
+  coverMedium?: CoverMedium
+  /** The other medium's cover row, for a book that has both media; fed by its own search. */
+  secondCover?: SecondCoverInput | null
 }>()
 
 const emit = defineEmits<{
   back: []
-  apply: [{ formPatch: MetadataPatch; coverUrl?: string }]
+  apply: [MetadataDiffApply]
 }>()
 
 const { t } = useI18n()
-const coverAspectRatio = inject(COVER_ASPECT_RATIO_KEY, ref(DEFAULT_COVER_ASPECT_RATIO))
+const libraryAspectRatio = inject(COVER_ASPECT_RATIO_KEY, ref(DEFAULT_COVER_ASPECT_RATIO))
+const mainMedium = computed<CoverMedium>(() => props.coverMedium ?? 'ebook')
+/** Result thumbnails take the main cover row's slot shape, or the library's when the panel has no slot. */
+const coverAspectRatio = computed(() => {
+  if (!props.coverMedium) return libraryAspectRatio.value
+  return props.coverMedium === 'audio' ? '1/1' : '2/3'
+})
 
 const activeProvider = ref<MetadataProviderKey>(props.initialCandidate.provider)
 const showUnchanged = ref(false)
@@ -94,6 +109,8 @@ const activeCandidate = computed(
     props.initialCandidate,
 )
 
+const { shapeOf: coverShapeOf } = useCoverShapes(() => [...representativeCandidates.value, ...(props.secondCover?.candidates ?? [])])
+
 const {
   fields,
   picksPerProvider,
@@ -111,9 +128,38 @@ const {
   representativeCandidates,
   activeProvider,
   computed(() => props.providers),
-  props.currentCoverUrl,
+  () => props.currentCoverUrl,
   computed(() => props.providerIds),
   computed(() => props.lockedFields ?? []),
+  {
+    coverMedium: mainMedium,
+    coverLabelKey: () =>
+      props.secondCover ? `book.detail.editMetadata.diff.fields.${mainMedium.value === 'audio' ? 'audioCover' : 'bookCover'}` : undefined,
+    coverShapeOf,
+  },
+)
+
+const secondCoverLocked = computed(() => Boolean(props.secondCover && (props.lockedFields ?? []).includes(coverLockField(props.secondCover.medium))))
+const {
+  choices: secondCoverChoices,
+  active: secondCoverActive,
+  row: secondCoverRow,
+  picked: secondCoverPicked,
+  pickedCoverUrl: secondCoverPickedUrl,
+  select: selectSecondCover,
+  togglePick: toggleSecondCoverPick,
+} = useSecondCoverRow(
+  () =>
+    props.secondCover
+      ? {
+          medium: props.secondCover.medium,
+          candidates: props.secondCover.candidates,
+          priority: props.secondCover.priority,
+          currentUrl: props.secondCover.currentUrl,
+          locked: secondCoverLocked.value,
+        }
+      : null,
+  coverShapeOf,
 )
 
 const activeProviderLabel = computed(() => getProviderLabel(activeProvider.value, props.providers))
@@ -125,12 +171,13 @@ const candidateSeed = computed(() => activeCandidate.value.title ?? t('book.deta
 const candidateAuthorLine = computed(() => activeCandidate.value.authors?.join(', ') || null)
 
 const selectedFieldCount = computed(() => {
-  let total = 0
+  let total = secondCoverPicked.value ? 1 : 0
   for (const count of picksPerProvider.value.values()) {
     total += count
   }
   return total
 })
+const hasSelection = computed(() => hasCopied.value || secondCoverPicked.value !== null)
 
 const selectedCountLabel = computed(() => {
   if (!selectedFieldCount.value) return t('book.detail.editMetadata.diffPanel.noFieldsSelected')
@@ -161,6 +208,16 @@ const activeResultMeta = computed(
 
 const visibleFields = computed(() => fields.value.filter((field) => showUnchanged.value || field.hasDiff || !field.bookValue))
 
+/** The second cover row always shows, right after the main cover row, since its results arrive on their own. */
+const displayRows = computed<{ field: DiffField; second: boolean }[]>(() => {
+  const rows = visibleFields.value.map((field) => ({ field, second: false }))
+  const second = secondCoverRow.value
+  if (!second) return rows
+  const coverIndex = rows.findIndex((row) => row.field.key === 'coverUrl')
+  rows.splice(coverIndex + 1, 0, { field: second, second: true })
+  return rows
+})
+
 function isSameCandidate(a: MetadataCandidate, b: MetadataCandidate): boolean {
   if (a.provider !== b.provider) return false
   if (a.providerId && b.providerId) return a.providerId === b.providerId
@@ -214,6 +271,14 @@ function handlePickFromProvider(key: DiffFieldKey, provider: MetadataProviderKey
   pickFieldFromProvider(key, provider)
 }
 
+function handleSecondCoverToggle() {
+  toggleSecondCoverPick()
+}
+
+function handleSecondCoverSelect(candidate: MetadataCandidate) {
+  selectSecondCover(candidate)
+}
+
 function candidateCoverUrl(candidate: MetadataCandidate): string {
   return toDisplayCoverUrl(candidate.coverUrl)
 }
@@ -235,7 +300,16 @@ function goBack() {
 }
 
 function apply() {
-  emit('apply', buildPatch())
+  const { formPatch, coverUrl } = buildPatch()
+  const covers: Partial<Record<CoverMedium, string>> = {}
+  if (coverUrl) covers[mainMedium.value] = coverUrl
+  const secondUrl = secondCoverPickedUrl.value
+  if (props.secondCover && secondUrl && !secondCoverLocked.value) covers[props.secondCover.medium] = secondUrl
+  emit('apply', {
+    formPatch,
+    ...(covers.ebook ? { coverUrl: covers.ebook } : {}),
+    ...(covers.audio ? { audioCoverUrl: covers.audio } : {}),
+  })
 }
 
 onBeforeUnmount(() => {
@@ -311,7 +385,8 @@ onBeforeUnmount(() => {
             <span class="min-w-0 flex-1">
               <span class="block text-xs font-medium text-foreground line-clamp-1">{{ resolveCandidateDisplayTitle(candidate) }}</span>
               <span class="block text-[10px] text-muted-foreground line-clamp-1">
-                {{ candidate.publishedDate ?? candidate.publishedYear ?? 'Date unknown' }} - {{ index + 1 }} of {{ resultsForActiveProvider.length }}
+                {{ candidate.publishedDate ?? candidate.publishedYear ?? t('book.detail.editMetadata.diffPanel.yearUnknown') }} -
+                {{ t('book.detail.editMetadata.diffPanel.indexOf', { index: index + 1, total: resultsForActiveProvider.length }) }}
               </span>
             </span>
           </button>
@@ -329,7 +404,7 @@ onBeforeUnmount(() => {
       <div class="sticky top-0 z-10 -mx-4 px-4 py-2.5 border-b border-border bg-background/95 backdrop-blur-sm">
         <div class="flex items-center gap-1.5 pb-1">
           <div class="min-w-0 flex items-center gap-1.5 overflow-x-auto whitespace-nowrap pr-2">
-            <p v-if="hasCopied" class="shrink-0 text-xs text-muted-foreground inline-flex items-center gap-1.5">
+            <p v-if="hasSelection" class="shrink-0 text-xs text-muted-foreground inline-flex items-center gap-1.5">
               <CheckCheck class="size-3.5 text-primary" />
               {{ selectedCountLabel }}
             </p>
@@ -375,22 +450,47 @@ onBeforeUnmount(() => {
         </div>
       </div>
 
-      <MetadataDiffRow
-        v-for="field in visibleFields"
-        :key="field.key"
-        :field="field"
-        :active-provider="activeProvider"
-        :providers="providers"
-        :book-seed="bookSeed"
-        :book-author-line="bookAuthorLine"
-        :candidate-seed="candidateSeed"
-        :candidate-author-line="candidateAuthorLine"
-        :genre-write-mode="genreWriteMode"
-        @toggle="toggleField"
-        @pick-from-provider="handlePickFromProvider"
-        @update:genre-write-mode="setGenreWriteMode"
-      />
-      <p v-if="visibleFields.length === 0" class="py-8 text-center text-sm text-muted-foreground">
+      <template v-for="row in displayRows" :key="row.field.key">
+        <MetadataDiffRow
+          v-if="row.second"
+          :field="row.field"
+          :active-provider="secondCoverActive?.provider ?? activeProvider"
+          :providers="providers"
+          :book-seed="bookSeed"
+          :book-author-line="bookAuthorLine"
+          :candidate-seed="candidateSeed"
+          :candidate-author-line="candidateAuthorLine"
+          @toggle="handleSecondCoverToggle"
+        >
+          <template #coverResults>
+            <MetadataDiffCoverResults
+              v-if="secondCover"
+              :medium="secondCover.medium"
+              :choices="secondCoverChoices"
+              :active="secondCoverActive"
+              :picked="secondCoverPicked"
+              :providers="providers"
+              :searching="secondCover.searching"
+              @select="handleSecondCoverSelect"
+            />
+          </template>
+        </MetadataDiffRow>
+        <MetadataDiffRow
+          v-else
+          :field="row.field"
+          :active-provider="activeProvider"
+          :providers="providers"
+          :book-seed="bookSeed"
+          :book-author-line="bookAuthorLine"
+          :candidate-seed="candidateSeed"
+          :candidate-author-line="candidateAuthorLine"
+          :genre-write-mode="genreWriteMode"
+          @toggle="toggleField"
+          @pick-from-provider="handlePickFromProvider"
+          @update:genre-write-mode="setGenreWriteMode"
+        />
+      </template>
+      <p v-if="displayRows.length === 0" class="py-8 text-center text-sm text-muted-foreground">
         {{ showUnchanged ? t('book.detail.editMetadata.diffPanel.noMetadata') : t('book.detail.editMetadata.diffPanel.noChangedFields') }}
       </p>
     </div>
@@ -403,7 +503,7 @@ onBeforeUnmount(() => {
         </button>
         <button
           class="relative h-8 px-4 rounded-lg bg-primary text-primary-foreground text-sm font-medium transition-all disabled:opacity-40 hover:opacity-90 active:scale-95 overflow-hidden group"
-          :disabled="!hasCopied"
+          :disabled="!hasSelection"
           @click="apply"
         >
           <span class="absolute inset-0 bg-white/10 opacity-0 group-hover:opacity-100 transition-opacity" />
diff --git a/client/src/features/book/components/detail/tabs/MetadataDiffRow.vue b/client/src/features/book/components/detail/tabs/MetadataDiffRow.vue
index 482151bb2..cf0137f25 100644
--- a/client/src/features/book/components/detail/tabs/MetadataDiffRow.vue
+++ b/client/src/features/book/components/detail/tabs/MetadataDiffRow.vue
@@ -1,10 +1,11 @@
 <script setup lang="ts">
-import { computed, inject, ref, watch } from 'vue'
+import { computed, inject, ref, useId, watch } from 'vue'
 import { useI18n } from 'vue-i18n'
 import { ArrowLeft, RotateCcw, CheckCircle2, X, ZoomIn, Layers } from '@lucide/vue'
 import type { MetadataProviderInfo, MetadataProviderKey } from '@bookorbit/types'
 import type { DiffField, DiffFieldKey, GenreWriteMode } from '../../../composables/useMetadataDiff'
 import { hideOnError, providerBadgeStyle } from '../../../lib/metadata-fetch'
+import { DialogClose, DialogContent, DialogOverlay, DialogPortal, DialogRoot, DialogTitle } from 'reka-ui'
 import { Popover, PopoverContent, PopoverTrigger } from '@/components/ui/popover'
 import { COVER_ASPECT_RATIO_KEY, DEFAULT_COVER_ASPECT_RATIO } from '../../../lib/cover-aspect-ratio'
 import BookCoverPlaceholder from '@/features/book/components/BookCoverPlaceholder.vue'
@@ -27,9 +28,37 @@ const emit = defineEmits<{
 }>()
 
 const { t } = useI18n()
-const coverAspectRatio = inject(COVER_ASPECT_RATIO_KEY, ref(DEFAULT_COVER_ASPECT_RATIO))
+const libraryAspectRatio = inject(COVER_ASPECT_RATIO_KEY, ref(DEFAULT_COVER_ASPECT_RATIO))
+/** A cover row's frames take its slot's shape; without a slot they follow the library. */
+const coverAspectRatio = computed(() => {
+  if (props.field.coverMedium === 'audio') return '1/1'
+  if (props.field.coverMedium === 'ebook') return '2/3'
+  return libraryAspectRatio.value
+})
+const isAudioCover = computed(() => props.field.coverMedium === 'audio')
+const coverShapeHintId = `cover-shape-hint-${useId()}`
+/** Art of the other shape for this slot: offered, but named, since a letterboxed cover is a downgrade from a fitting one. */
+const coverShapeHint = computed(() => {
+  if (props.field.candidateCoverFit !== 'mismatch' || !props.field.candidateDisplay) return ''
+  return isAudioCover.value
+    ? t('book.detail.editMetadata.diff.coverShapeHint.portraitForAudio')
+    : t('book.detail.editMetadata.diff.coverShapeHint.squareForBook')
+})
 
 const lightboxSrc = ref<string | null>(null)
+
+function openCurrentCoverPreview() {
+  if (props.field.isPicked) lightboxSrc.value = props.field.pickedDisplay || props.field.candidateDisplay
+  else if (props.field.bookValue) lightboxSrc.value = props.field.bookValue
+}
+
+function openCandidateCoverPreview() {
+  if (props.field.candidateDisplay) lightboxSrc.value = props.field.candidateDisplay
+}
+
+function handleCoverPreviewOpenChange(open: boolean) {
+  if (!open) lightboxSrc.value = null
+}
 const isCurrentExpanded = ref(false)
 const isCandidateExpanded = ref(false)
 
@@ -56,6 +85,12 @@ const CLAMPABLE_TEXT_FIELDS = new Set<DiffFieldKey>([
   'comicStoryArcs',
 ])
 
+const toggleLabel = computed(() =>
+  props.field.isPicked
+    ? t('book.detail.editMetadata.diff.keepCurrent', { field: t(props.field.labelKey) })
+    : t('book.detail.editMetadata.diff.useNew', { field: t(props.field.labelKey) }),
+)
+
 const canClampCurrent = computed(
   () => CLAMPABLE_TEXT_FIELDS.has(props.field.key) && props.field.currentDisplay.length > 160 && props.field.key !== 'sourceUrl',
 )
@@ -102,7 +137,7 @@ watch(
   <!-- Cover row -->
   <div v-if="field.isCover" class="py-3.5 border-b border-border/40">
     <div class="mb-2.5 flex items-center gap-2">
-      <p class="text-[10px] font-semibold uppercase tracking-widest text-muted-foreground">{{ field.label }}</p>
+      <p class="text-[10px] font-semibold uppercase tracking-widest text-muted-foreground">{{ t(field.labelKey) }}</p>
       <span v-if="field.isLocked" class="inline-flex items-center rounded-full bg-primary/10 px-2 py-0.5 text-[9px] font-medium text-primary">
         {{ t('book.detail.editMetadata.diff.locked') }}
       </span>
@@ -113,9 +148,7 @@ watch(
         class="w-16 rounded-lg overflow-hidden bg-muted transition-all duration-300 shadow-sm ring-1 relative group"
         :class="field.isPicked ? 'ring-primary ring-2' : field.bookValue ? 'ring-border cursor-zoom-in' : 'ring-border opacity-50'"
         :style="{ aspectRatio: coverAspectRatio }"
-        @click="
-          field.isPicked ? (lightboxSrc = field.pickedDisplay || field.candidateDisplay) : field.bookValue ? (lightboxSrc = field.bookValue) : null
-        "
+        @click="openCurrentCoverPreview"
       >
         <template v-if="field.isPicked && field.pickedDisplay">
           <img
@@ -141,7 +174,7 @@ watch(
           />
         </template>
         <div v-else class="absolute inset-0">
-          <BookCoverPlaceholder :title="bookSeed ?? null" :author-line="bookAuthorLine ?? null" :is-audio="false" :seed="bookSeed ?? 'book'" />
+          <BookCoverPlaceholder :title="bookSeed ?? null" :author-line="bookAuthorLine ?? null" :is-audio="isAudioCover" :seed="bookSeed ?? 'book'" />
         </div>
         <div
           v-if="field.isPicked || field.bookValue"
@@ -171,6 +204,9 @@ watch(
               : 'bg-card border border-border text-muted-foreground hover:border-primary/40 hover:text-primary hover:bg-primary/5'
           "
           :disabled="field.isLocked"
+          :aria-label="toggleLabel"
+          :aria-pressed="field.isPicked"
+          :aria-describedby="coverShapeHint ? coverShapeHintId : undefined"
           @click="handleToggle"
         >
           <RotateCcw v-if="field.isPicked && field.pickedFromActive" class="size-3.5" />
@@ -225,7 +261,7 @@ watch(
             : 'ring-border opacity-50'
         "
         :style="{ aspectRatio: coverAspectRatio }"
-        @click="field.candidateDisplay ? (lightboxSrc = field.candidateDisplay) : null"
+        @click="openCandidateCoverPreview"
       >
         <template v-if="field.candidateDisplay">
           <img
@@ -245,7 +281,7 @@ watch(
           <BookCoverPlaceholder
             :title="candidateSeed ?? null"
             :author-line="candidateAuthorLine ?? null"
-            :is-audio="false"
+            :is-audio="isAudioCover"
             :seed="candidateSeed ?? 'candidate'"
           />
         </div>
@@ -257,12 +293,20 @@ watch(
         </div>
       </div>
     </div>
+    <div v-if="coverShapeHint" class="grid grid-cols-[1fr_auto_1fr] gap-2">
+      <p :id="coverShapeHintId" class="col-start-3 mt-1.5 min-w-0 text-[11px] leading-snug text-muted-foreground">{{ coverShapeHint }}</p>
+    </div>
+    <div v-if="$slots.coverResults" class="grid grid-cols-[1fr_auto_1fr] gap-2">
+      <div class="col-start-3 min-w-0">
+        <slot name="coverResults" />
+      </div>
+    </div>
   </div>
 
   <!-- Text row -->
   <div v-else class="py-2.5 border-b border-border/40">
     <div class="mb-1.5 flex items-center gap-2">
-      <p class="text-[10px] font-semibold uppercase tracking-widest text-muted-foreground">{{ field.label }}</p>
+      <p class="text-[10px] font-semibold uppercase tracking-widest text-muted-foreground">{{ t(field.labelKey) }}</p>
       <span v-if="field.isLocked" class="inline-flex items-center rounded-full bg-primary/10 px-2 py-0.5 text-[9px] font-medium text-primary">
         {{ t('book.detail.editMetadata.diff.locked') }}
       </span>
@@ -303,7 +347,7 @@ watch(
         class="min-w-0 rounded-lg px-3 py-2 transition-all duration-200"
         :class="!field.hasDiff ? 'bg-muted/30 opacity-50' : field.isPicked ? 'bg-muted/30 opacity-40' : 'bg-background ring-1 ring-border'"
       >
-        <p class="text-[10px] font-medium text-muted-foreground mb-0.5 sm:hidden">Current</p>
+        <p class="text-[10px] font-medium text-muted-foreground mb-0.5 sm:hidden">{{ t('book.detail.editMetadata.diffPanel.current') }}</p>
         <p
           class="wrap-break-word leading-snug text-sm w-full"
           :class="[!field.currentDisplay ? 'text-muted-foreground italic' : 'text-foreground', currentTextClass]"
@@ -334,6 +378,8 @@ watch(
               : 'bg-card border border-border text-muted-foreground hover:border-primary/40 hover:text-primary hover:bg-primary/5'
           "
           :disabled="field.isLocked"
+          :aria-label="toggleLabel"
+          :aria-pressed="field.isPicked"
           @click="handleToggle"
         >
           <RotateCcw v-if="field.isPicked && field.pickedFromActive" class="size-3.5" />
@@ -386,7 +432,7 @@ watch(
           !field.hasDiff ? 'bg-muted/30 opacity-50' : field.isPicked && field.pickedFromActive ? 'bg-primary/8 ring-1 ring-primary/20' : 'bg-muted/40'
         "
       >
-        <p class="text-[10px] font-medium text-muted-foreground mb-0.5 sm:hidden">New</p>
+        <p class="text-[10px] font-medium text-muted-foreground mb-0.5 sm:hidden">{{ t('book.detail.editMetadata.diffPanel.new') }}</p>
         <a
           v-if="field.key === 'sourceUrl' && field.candidateDisplay"
           :href="field.candidateDisplay"
@@ -414,22 +460,31 @@ watch(
     </div>
   </div>
 
-  <!-- Lightbox -->
-  <Teleport to="body">
-    <div v-if="lightboxSrc" class="fixed inset-0 z-[60] flex items-center justify-center bg-black/80 backdrop-blur-sm" @click="lightboxSrc = null">
-      <button
-        class="absolute top-4 right-4 size-9 rounded-full bg-white/10 hover:bg-white/20 text-white flex items-center justify-center transition-colors"
-        @click="lightboxSrc = null"
-      >
-        <X class="size-5" />
-      </button>
-      <img
-        :src="lightboxSrc"
-        :alt="t('book.detail.editMetadata.diff.coverPreviewAlt')"
-        class="max-h-[85vh] max-w-[85vw] rounded-lg shadow-2xl object-contain"
-        @click.stop
-        @error="hideOnError"
+  <!-- A nested dialog, so a drawer or sheet around the diff treats it as its own child layer. -->
+  <DialogRoot :open="lightboxSrc !== null" @update:open="handleCoverPreviewOpenChange">
+    <DialogPortal>
+      <DialogOverlay
+        class="fixed inset-0 z-[60] bg-black/80 backdrop-blur-sm data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 motion-reduce:animate-none"
       />
-    </div>
-  </Teleport>
+      <DialogContent
+        :aria-describedby="undefined"
+        class="fixed left-1/2 top-1/2 z-[60] -translate-x-1/2 -translate-y-1/2 outline-none data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 motion-reduce:animate-none"
+      >
+        <DialogTitle class="sr-only">{{ t('book.detail.coverLightbox.title') }}</DialogTitle>
+        <img
+          v-if="lightboxSrc"
+          :src="lightboxSrc"
+          :alt="t('book.detail.editMetadata.diff.coverPreviewAlt')"
+          class="max-h-[85vh] max-w-[85vw] rounded-lg shadow-2xl object-contain"
+          @error="hideOnError"
+        />
+        <DialogClose
+          class="absolute -top-3 -right-3 rounded-full border border-border bg-background p-1 text-muted-foreground transition-colors hover:text-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-primary"
+          :aria-label="t('common.close')"
+        >
+          <X class="size-4" aria-hidden="true" />
+        </DialogClose>
+      </DialogContent>
+    </DialogPortal>
+  </DialogRoot>
 </template>
diff --git a/client/src/features/book/components/detail/tabs/MetadataSearchDrawer.test.ts b/client/src/features/book/components/detail/tabs/MetadataSearchDrawer.test.ts
index cf795b136..9ad726d7c 100644
--- a/client/src/features/book/components/detail/tabs/MetadataSearchDrawer.test.ts
+++ b/client/src/features/book/components/detail/tabs/MetadataSearchDrawer.test.ts
@@ -4,9 +4,13 @@ import { defineComponent, h } from 'vue'
 import { MetadataProviderKey, type BookDetail } from '@bookorbit/types'
 import MetadataSearchDrawer from './MetadataSearchDrawer.vue'
 
+type SearchCall = { title?: string; author?: string; isbn?: string; bookId?: number; isAudiobook?: boolean; mediaKind?: string; providers?: string[] }
+
 const metadataSearchMocks = vi.hoisted(() => ({
+  instances: 0,
   loadProviders: vi.fn<(bookId?: number) => void>(),
-  search: vi.fn<(params: { title?: string; author?: string; isbn?: string; bookId?: number; isAudiobook?: boolean }) => void>(),
+  search: vi.fn<(params: SearchCall) => void>(),
+  secondSearch: vi.fn<(params: SearchCall) => void>(),
   toggleProvider: vi.fn<(provider: string) => void>(),
   selectFieldRuleProviders: vi.fn<() => void>(),
   clearProviderFilter: vi.fn<() => void>(),
@@ -14,7 +18,7 @@ const metadataSearchMocks = vi.hoisted(() => ({
 
 vi.mock('../../../composables/useCoverVersions', () => ({
   useCoverVersions: () => ({
-    coverUrl: () => '/covers/42',
+    coverUrl: (bookId: number, _type: string, _version: string, medium?: string) => `/covers/${bookId}${medium ? `?medium=${medium}` : ''}`,
   }),
 }))
 
@@ -22,19 +26,26 @@ vi.mock('../../../composables/useMetadataSearch', async () => {
   const vue = await vi.importActual<typeof import('vue')>('vue')
 
   return {
-    useMetadataSearch: () => ({
-      filteredResults: vue.ref([]),
-      providerCounts: vue.reactive({}),
-      isStreaming: vue.ref(false),
-      hasSearched: vue.ref(true),
-      providers: vue.ref([{ key: 'google', label: 'Google Books', identifiable: true }]),
-      selectedProviders: vue.ref([]),
-      loadProviders: metadataSearchMocks.loadProviders,
-      search: metadataSearchMocks.search,
-      toggleProvider: metadataSearchMocks.toggleProvider,
-      selectFieldRuleProviders: metadataSearchMocks.selectFieldRuleProviders,
-      clearProviderFilter: metadataSearchMocks.clearProviderFilter,
-    }),
+    // The drawer makes two searches: the book's own, then one as its other medium.
+    useMetadataSearch: () => {
+      const first = metadataSearchMocks.instances++ % 2 === 0
+      return {
+        results: vue.ref([]),
+        filteredResults: vue.ref([]),
+        providerCounts: vue.reactive({}),
+        isStreaming: vue.ref(false),
+        hasSearched: vue.ref(true),
+        providers: vue.ref([{ key: 'google', label: 'Google Books', identifiable: true }]),
+        selectedProviders: vue.ref([]),
+        coverProviderOrder: vue.ref(['amazon', 'itunes']),
+        audioCoverProviderOrder: vue.ref(['audible', 'itunes']),
+        loadProviders: metadataSearchMocks.loadProviders,
+        search: first ? metadataSearchMocks.search : metadataSearchMocks.secondSearch,
+        toggleProvider: metadataSearchMocks.toggleProvider,
+        selectFieldRuleProviders: metadataSearchMocks.selectFieldRuleProviders,
+        clearProviderFilter: metadataSearchMocks.clearProviderFilter,
+      }
+    },
   }
 })
 
@@ -72,12 +83,21 @@ const MetadataSearchPanelStub = defineComponent({
   },
 })
 
-function makeBook(files: BookDetail['files'] = []): BookDetail {
+function makeBook(files: BookDetail['files'] = [], overrides: Partial<BookDetail> = {}): BookDetail {
+  const coverMedia = [
+    ...(files.some((file) => file.format !== 'm4b') ? (['ebook'] as const) : []),
+    ...(files.some((file) => file.format === 'm4b') ? (['audio'] as const) : []),
+  ]
   return {
     id: 42,
     title: 'Dune',
     authors: [{ id: 1, name: 'Frank Herbert' }],
     files,
+    coverMedia,
+    covers: { ebook: null, audio: null },
+    coverSource: null,
+    coverVersion: 'v1',
+    ...overrides,
     genres: [],
     communityRatings: [],
     providerIds: {},
@@ -90,15 +110,16 @@ function makeFile(format: string, role: string): BookDetail['files'][number] {
   return { id: 1, format, role } as unknown as BookDetail['files'][number]
 }
 
-function mountDrawer(files: BookDetail['files'] = []) {
+function mountDrawer(files: BookDetail['files'] = [], overrides: Partial<BookDetail> = {}) {
   return mount(MetadataSearchDrawer, {
     props: {
-      book: makeBook(files),
+      book: makeBook(files, overrides),
       lockedFields: [],
     },
     global: {
       stubs: {
-        Teleport: true,
+        // The sheet portals its content to <body>; render it in place so the panel can be found.
+        DialogPortal: { template: '<div><slot /></div>' },
         MetadataSearchPanel: MetadataSearchPanelStub,
         MetadataDiffPanel: true,
       },
@@ -109,6 +130,16 @@ function mountDrawer(files: BookDetail['files'] = []) {
 describe('MetadataSearchDrawer', () => {
   beforeEach(() => {
     vi.clearAllMocks()
+    metadataSearchMocks.instances = 0
+  })
+
+  it('is a labelled dialog whose labelled close button closes it', async () => {
+    const wrapper = mountDrawer()
+    expect(wrapper.get('[role="dialog"]').attributes('aria-labelledby')).toBeTruthy()
+
+    await wrapper.get('button[aria-label="Close"]').trigger('click')
+
+    expect(wrapper.emitted('close')).toHaveLength(1)
   })
 
   it('filters provider tabs without re-running the last metadata search', async () => {
@@ -147,4 +178,34 @@ describe('MetadataSearchDrawer', () => {
 
     expect(metadataSearchMocks.search).toHaveBeenLastCalledWith(expect.objectContaining({ isAudiobook: true }))
   })
+
+  it('searches the other medium too for a book with both, without the ISBN and with its cover rule providers', async () => {
+    const wrapper = mountDrawer([makeFile('epub', 'primary'), makeFile('m4b', 'content')])
+
+    await wrapper.find('[data-testid="search"]').trigger('click')
+
+    expect(metadataSearchMocks.secondSearch).toHaveBeenCalledWith({
+      title: 'Dune',
+      author: 'Frank Herbert',
+      bookId: 42,
+      mediaKind: 'audiobook',
+      providers: ['audible', 'itunes'],
+    })
+  })
+
+  it('searches the book edition as the other medium for an audiobook-first book', async () => {
+    const wrapper = mountDrawer([makeFile('m4b', 'primary'), makeFile('epub', 'content')])
+
+    await wrapper.find('[data-testid="search"]').trigger('click')
+
+    expect(metadataSearchMocks.secondSearch).toHaveBeenCalledWith(expect.objectContaining({ mediaKind: 'ebook', providers: ['amazon', 'itunes'] }))
+  })
+
+  it('makes no second search for a book with one medium', async () => {
+    const wrapper = mountDrawer([makeFile('epub', 'primary')])
+
+    await wrapper.find('[data-testid="search"]').trigger('click')
+
+    expect(metadataSearchMocks.secondSearch).not.toHaveBeenCalled()
+  })
 })
diff --git a/client/src/features/book/components/detail/tabs/MetadataSearchDrawer.vue b/client/src/features/book/components/detail/tabs/MetadataSearchDrawer.vue
index 0e3bc1474..c2c566008 100644
--- a/client/src/features/book/components/detail/tabs/MetadataSearchDrawer.vue
+++ b/client/src/features/book/components/detail/tabs/MetadataSearchDrawer.vue
@@ -1,25 +1,47 @@
 <script setup lang="ts">
-import { computed, onMounted, ref } from 'vue'
+import { computed, inject, onMounted, ref } from 'vue'
 import { useI18n } from 'vue-i18n'
 import { X, Sparkles } from '@lucide/vue'
+import { Sheet, SheetClose, SheetContent, SheetDescription, SheetTitle } from '@/components/ui/sheet'
 import { getBookMediaProfile } from '@bookorbit/types'
-import type { BookDetail, BookMetadataLockField, MetadataCandidate, MetadataProviderKey, MetadataSource } from '@bookorbit/types'
+import type { BookDetail, BookMetadataLockField, CoverMedium, MetadataCandidate, MetadataProviderKey, MetadataSource } from '@bookorbit/types'
 import { useMetadataSearch } from '../../../composables/useMetadataSearch'
 import { useCoverVersions } from '../../../composables/useCoverVersions'
-import type { MetadataPatch } from '../../../composables/useMetadataDiff'
+import type { MetadataDiffApply } from '../../../composables/useMetadataDiff'
+import type { SecondCoverInput } from '../../../composables/useSecondCoverRow'
+import { COVER_ASPECT_RATIO_KEY, DEFAULT_COVER_ASPECT_RATIO } from '../../../lib/cover-aspect-ratio'
+import { coverFieldMedium, coverTileState, otherMedium } from '../../../lib/cover-slots'
 import MetadataSearchPanel from './MetadataSearchPanel.vue'
 import MetadataDiffPanel from './MetadataDiffPanel.vue'
 
 const props = defineProps<{ book: BookDetail; lockedFields: BookMetadataLockField[] }>()
 const emit = defineEmits<{
   close: []
-  apply: [{ formPatch: MetadataPatch; coverUrl?: string }]
+  apply: [MetadataDiffApply]
 }>()
 
 const { t } = useI18n()
 const { coverUrl } = useCoverVersions()
-const bookCoverUrl = computed(() => coverUrl(props.book.id, 'cover', props.book.updatedAt ?? props.book.addedAt))
+const libraryAspectRatio = inject(COVER_ASPECT_RATIO_KEY, ref(DEFAULT_COVER_ASPECT_RATIO))
 const isAudiobookSearch = computed(() => getBookMediaProfile(props.book.files).primaryMediaKind === 'audiobook')
+
+/** The slot the main results fill: the medium the book is searched as, if the book has it. */
+const mainCoverMedium = computed<CoverMedium>(() => {
+  const searched: CoverMedium = isAudiobookSearch.value ? 'audio' : 'ebook'
+  return props.book.coverMedia.includes(searched) ? searched : (coverFieldMedium(props.book) ?? searched)
+})
+/** A book with both media also gets the other medium's cover row, from a search run as that medium. */
+const secondCoverMedium = computed<CoverMedium | null>(() => {
+  const other = otherMedium(mainCoverMedium.value)
+  return props.book.coverMedia.includes(other) ? other : null
+})
+
+/** An empty slot has no current cover, rather than the other slot's image the server would fall back to. */
+function slotCoverUrl(medium: CoverMedium): string {
+  const state = coverTileState(props.book, medium, libraryAspectRatio.value)
+  return state.hasImage ? coverUrl(props.book.id, 'cover', state.version, medium) : ''
+}
+const mainCoverUrl = computed(() => slotCoverUrl(mainCoverMedium.value))
 const searchDefaults = computed(() => ({
   title: props.book.title ?? undefined,
   author: props.book.authors[0]?.name ?? undefined,
@@ -61,7 +83,24 @@ const {
   toggleProvider,
   selectFieldRuleProviders,
   clearProviderFilter,
+  coverProviderOrder,
+  audioCoverProviderOrder,
 } = useMetadataSearch()
+const secondSearch = useMetadataSearch()
+const { results: secondResults, isStreaming: secondSearching } = secondSearch
+
+const secondCover = computed<SecondCoverInput | null>(() => {
+  const medium = secondCoverMedium.value
+  if (!medium) return null
+  return {
+    medium,
+    candidates: secondResults.value,
+    priority: secondCoverPriority.value,
+    currentUrl: slotCoverUrl(medium),
+    searching: secondSearching.value,
+  }
+})
+const secondCoverPriority = computed(() => (secondCoverMedium.value === 'audio' ? audioCoverProviderOrder.value : coverProviderOrder.value))
 
 const view = ref<'search' | 'diff'>('search')
 const selectedCandidate = ref<MetadataCandidate | null>(null)
@@ -76,12 +115,22 @@ onMounted(() => {
   loadProviders(props.book.id)
 })
 
-function handleClose() {
-  emit('close')
+function handleOpenChange(open: boolean) {
+  if (!open) emit('close')
 }
 
 function runMetadataSearch(params: { title: string; author: string; isbn: string }) {
   search({ ...params, bookId: props.book.id, isAudiobook: isAudiobookSearch.value })
+  const medium = secondCoverMedium.value
+  if (!medium) return
+  // The ISBN names the main medium's edition; Hardcover would pin it and iTunes would answer with it.
+  void secondSearch.search({
+    title: params.title,
+    author: params.author,
+    bookId: props.book.id,
+    mediaKind: medium === 'audio' ? 'audiobook' : 'ebook',
+    ...(secondCoverPriority.value.length ? { providers: secondCoverPriority.value } : {}),
+  })
 }
 
 function handleSearch(params: { title: string; author: string; isbn: string }) {
@@ -111,86 +160,81 @@ function backToSearch() {
   view.value = 'search'
 }
 
-function handleApply(patch: { formPatch: MetadataPatch; coverUrl?: string }) {
+function handleApply(patch: MetadataDiffApply) {
   emit('apply', patch)
   emit('close')
 }
 </script>
 
 <template>
-  <Teleport to="body">
-    <div class="fixed inset-0 z-50 flex">
-      <!-- Backdrop -->
-      <div class="hidden sm:block flex-1 bg-black/50 backdrop-blur-sm" @click="handleClose" />
+  <Sheet :open="true" @update:open="handleOpenChange">
+    <SheetContent side="right" hide-close class="w-full gap-0 overflow-hidden border-border p-0 shadow-2xl sm:w-3/4 sm:max-w-5xl">
+      <!-- Gradient accent strip -->
+      <div class="h-px w-full bg-linear-to-r from-transparent via-primary to-transparent shrink-0 opacity-60" />
 
-      <!-- Drawer panel -->
-      <div class="relative flex flex-col w-full sm:w-3/4 sm:max-w-5xl h-full bg-background sm:border-l border-border shadow-2xl overflow-hidden">
-        <!-- Gradient accent strip -->
-        <div class="h-px w-full bg-linear-to-r from-transparent via-primary to-transparent shrink-0 opacity-60" />
+      <!-- Ambient glow -->
+      <div class="absolute top-0 right-0 w-64 h-32 bg-primary/5 rounded-full blur-3xl pointer-events-none" />
 
-        <!-- Ambient glow -->
-        <div class="absolute top-0 right-0 w-64 h-32 bg-primary/5 rounded-full blur-3xl pointer-events-none" />
+      <SheetClose
+        class="absolute top-3 right-3 z-10 size-7 rounded-full flex items-center justify-center text-muted-foreground hover:text-foreground hover:bg-muted transition-all hover:scale-110 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring"
+        :aria-label="t('common.close')"
+      >
+        <X class="size-4" aria-hidden="true" />
+      </SheetClose>
 
-        <!-- Close button -->
-        <button
-          class="absolute top-3 right-3 z-10 size-7 rounded-full flex items-center justify-center text-muted-foreground hover:text-foreground hover:bg-muted transition-all hover:scale-110"
-          @click="handleClose"
-        >
-          <X class="size-4" />
-        </button>
-
-        <!-- Title bar -->
-        <div class="flex items-center gap-2.5 px-4 py-3 border-b border-border shrink-0 pr-12">
-          <div class="size-7 rounded-lg bg-primary/10 flex items-center justify-center ring-1 ring-primary/20 shrink-0">
-            <Sparkles class="size-3.5 text-primary" />
-          </div>
-          <div class="min-w-0">
-            <p class="text-sm font-semibold">{{ drawerTitle }}</p>
-            <p class="text-xs text-muted-foreground line-clamp-1">{{ drawerSubtitle }}</p>
-          </div>
-
-          <!-- Step indicator -->
-          <div class="ml-auto flex items-center gap-1 shrink-0">
-            <div class="h-1.5 w-6 rounded-full transition-all duration-300" :class="view === 'search' ? 'bg-primary' : 'bg-border'" />
-            <div class="h-1.5 w-6 rounded-full transition-all duration-300" :class="view === 'diff' ? 'bg-primary' : 'bg-border'" />
-          </div>
+      <!-- Title bar -->
+      <div class="flex items-center gap-2.5 px-4 py-3 border-b border-border shrink-0 pr-12">
+        <div class="size-7 rounded-lg bg-primary/10 flex items-center justify-center ring-1 ring-primary/20 shrink-0">
+          <Sparkles class="size-3.5 text-primary" aria-hidden="true" />
+        </div>
+        <div class="min-w-0">
+          <SheetTitle class="text-sm font-semibold">{{ drawerTitle }}</SheetTitle>
+          <SheetDescription class="text-xs text-muted-foreground line-clamp-1">{{ drawerSubtitle }}</SheetDescription>
         </div>
 
-        <!-- Content -->
-        <div class="flex-1 min-h-0 relative">
-          <MetadataSearchPanel
-            v-if="view === 'search'"
-            :search-defaults="searchDefaults"
-            :providers="providers"
-            :filtered-results="filteredResults"
-            :provider-counts="providerCounts"
-            :selected-providers="selectedProviders"
-            :is-streaming="isStreaming"
-            :has-searched="hasSearched"
-            :interrupted-providers="interruptedProviders"
-            @search="handleSearch"
-            @toggle-provider="handleToggleProvider"
-            @clear-filter="handleClearProviderFilter"
-            @select-field-rules="handleSelectFieldRules"
-            @select="handleSelect"
-          />
-
-          <MetadataDiffPanel
-            v-else-if="view === 'diff' && selectedCandidate"
-            :current="currentSource"
-            :candidates="filteredResults"
-            :initial-candidate="selectedCandidate"
-            :providers="providers"
-            :current-cover-url="bookCoverUrl"
-            :provider-ids="book.providerIds"
-            :locked-fields="props.lockedFields"
-            :filtered-results="filteredResults"
-            :back-label="t('book.detail.editMetadata.diffPanel.results')"
-            @back="backToSearch"
-            @apply="handleApply"
-          />
+        <!-- Step indicator -->
+        <div class="ml-auto flex items-center gap-1 shrink-0">
+          <div class="h-1.5 w-6 rounded-full transition-all duration-300" :class="view === 'search' ? 'bg-primary' : 'bg-border'" />
+          <div class="h-1.5 w-6 rounded-full transition-all duration-300" :class="view === 'diff' ? 'bg-primary' : 'bg-border'" />
         </div>
       </div>
-    </div>
-  </Teleport>
+
+      <!-- Content -->
+      <div class="flex-1 min-h-0 relative">
+        <MetadataSearchPanel
+          v-if="view === 'search'"
+          :search-defaults="searchDefaults"
+          :providers="providers"
+          :filtered-results="filteredResults"
+          :provider-counts="providerCounts"
+          :selected-providers="selectedProviders"
+          :is-streaming="isStreaming"
+          :has-searched="hasSearched"
+          :interrupted-providers="interruptedProviders"
+          @search="handleSearch"
+          @toggle-provider="handleToggleProvider"
+          @clear-filter="handleClearProviderFilter"
+          @select-field-rules="handleSelectFieldRules"
+          @select="handleSelect"
+        />
+
+        <MetadataDiffPanel
+          v-else-if="view === 'diff' && selectedCandidate"
+          :current="currentSource"
+          :candidates="filteredResults"
+          :initial-candidate="selectedCandidate"
+          :providers="providers"
+          :current-cover-url="mainCoverUrl"
+          :cover-medium="mainCoverMedium"
+          :second-cover="secondCover"
+          :provider-ids="book.providerIds"
+          :locked-fields="props.lockedFields"
+          :filtered-results="filteredResults"
+          :back-label="t('book.detail.editMetadata.diffPanel.results')"
+          @back="backToSearch"
+          @apply="handleApply"
+        />
+      </div>
+    </SheetContent>
+  </Sheet>
 </template>
diff --git a/client/src/features/book/components/detail/tabs/__tests__/DetailsTab.spec.ts b/client/src/features/book/components/detail/tabs/__tests__/DetailsTab.spec.ts
index 223f90ea8..247003206 100644
--- a/client/src/features/book/components/detail/tabs/__tests__/DetailsTab.spec.ts
+++ b/client/src/features/book/components/detail/tabs/__tests__/DetailsTab.spec.ts
@@ -60,6 +60,9 @@ function makeBook(overrides: Partial<BookDetail> = {}): BookDetail {
     personalNoteUpdatedAt: null,
     communityRatings: [],
     coverSource: 'extracted',
+    coverMedia: ['ebook'],
+    covers: { ebook: null, audio: null },
+    coverVersion: 'legacy:2024-01-01T00:00:00.000Z',
     hardcoverEditionId: null,
     providerIds: {},
     authors: [{ id: 1, name: 'Author One', sortName: null }],
diff --git a/client/src/features/book/components/detail/tabs/__tests__/DetailsTabActions.spec.ts b/client/src/features/book/components/detail/tabs/__tests__/DetailsTabActions.spec.ts
index c97ec1649..3dbfe50fb 100644
--- a/client/src/features/book/components/detail/tabs/__tests__/DetailsTabActions.spec.ts
+++ b/client/src/features/book/components/detail/tabs/__tests__/DetailsTabActions.spec.ts
@@ -59,6 +59,9 @@ function makeBook(overrides: Partial<BookDetail> = {}): BookDetail {
     personalNoteUpdatedAt: null,
     communityRatings: [],
     coverSource: 'extracted',
+    coverMedia: ['ebook'],
+    covers: { ebook: null, audio: null },
+    coverVersion: 'legacy:2024-01-01T00:00:00.000Z',
     hardcoverEditionId: null,
     providerIds: {},
     authors: [{ id: 1, name: 'Author One', sortName: null }],
diff --git a/client/src/features/book/components/detail/tabs/__tests__/EditMetadataTab.spec.ts b/client/src/features/book/components/detail/tabs/__tests__/EditMetadataTab.spec.ts
new file mode 100644
index 000000000..6d95963de
--- /dev/null
+++ b/client/src/features/book/components/detail/tabs/__tests__/EditMetadataTab.spec.ts
@@ -0,0 +1,278 @@
+import { flushPromises, mount } from '@vue/test-utils'
+import { defineComponent, ref } from 'vue'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import type { BookDetail, CoverMedium } from '@bookorbit/types'
+import { api } from '@/lib/api'
+import EditMetadataTab from '../EditMetadataTab.vue'
+
+vi.mock('vue-i18n', () => ({
+  useI18n: () => ({ t: (key: string) => key, locale: ref('en') }),
+}))
+
+vi.mock('vue-sonner', () => ({
+  toast: { success: vi.fn<() => void>(), info: vi.fn<() => void>(), warning: vi.fn<() => void>(), error: vi.fn<() => void>() },
+}))
+
+vi.mock('@/lib/api', () => ({
+  api: vi.fn<(url: string, init?: RequestInit) => Promise<Response>>(),
+  setOnAuthFailure: vi.fn<(callback: () => void) => void>(),
+}))
+
+vi.mock('@/features/auth/composables/usePermissions', () => ({
+  usePermissions: () => ({ hasPermission: () => true }),
+}))
+
+const panel = {
+  hasPending: ref(false),
+  pendingMedia: ref<(CoverMedium | null)[]>([]),
+  busy: ref(false),
+  confirm: vi.fn<(media?: (CoverMedium | null)[]) => Promise<boolean>>(),
+  setUrl: vi.fn<(url: string) => void>(),
+  reset: vi.fn<() => void>(),
+}
+
+const CoverEditorPanelStub = defineComponent({
+  name: 'CoverEditorPanel',
+  props: ['book', 'lockedFields', 'disabled'],
+  emits: ['coverChanged', 'toggleLock'],
+  setup(_props, { expose }) {
+    expose(panel)
+    return {}
+  },
+  template: '<div data-test="cover-panel" />',
+})
+
+const MetadataSearchDrawerStub = defineComponent({
+  name: 'MetadataSearchDrawer',
+  props: ['book', 'lockedFields'],
+  emits: ['close', 'apply'],
+  template: '<div data-test="search-drawer" />',
+})
+
+function makeBook(overrides: Partial<BookDetail> = {}): BookDetail {
+  return {
+    id: 7,
+    libraryId: 1,
+    libraryName: 'Library',
+    addedAt: '2024-01-01T00:00:00.000Z',
+    updatedAt: null,
+    status: 'present',
+    title: 'Dune',
+    subtitle: null,
+    description: null,
+    isbn10: null,
+    isbn13: null,
+    publisher: null,
+    publishedDate: null,
+    publishedYear: null,
+    language: null,
+    pageCount: null,
+    seriesName: null,
+    seriesIndex: null,
+    seriesMemberships: [],
+    rating: null,
+    personalNote: null,
+    personalNoteUpdatedAt: null,
+    communityRatings: [],
+    coverSource: 'extracted',
+    coverMedia: ['ebook', 'audio'],
+    covers: { ebook: null, audio: null },
+    coverVersion: 'v',
+    hardcoverEditionId: null,
+    providerIds: {},
+    authors: [],
+    narrators: [],
+    genres: [],
+    tags: [],
+    files: [],
+    folderPath: '/books/Dune',
+    lastWrittenAt: null,
+    metadataScore: null,
+    readStatus: null,
+    audioMetadata: null,
+    formatPriority: [],
+    comicMetadata: null,
+    customMetadata: [],
+    lockedFields: [],
+    collections: [],
+    ...overrides,
+  } as unknown as BookDetail
+}
+
+function json(body: unknown, ok = true): Response {
+  return { ok, status: ok ? 200 : 500, json: async () => body } as Response
+}
+
+function patchCalls() {
+  return vi.mocked(api).mock.calls.filter(([, init]) => init?.method === 'PATCH')
+}
+
+function mountTab(book: BookDetail) {
+  return mount(EditMetadataTab, {
+    props: { book },
+    global: {
+      stubs: {
+        CoverEditorPanel: CoverEditorPanelStub,
+        MetadataSearchDrawer: MetadataSearchDrawerStub,
+        MetadataSourceCard: true,
+        MetadataFieldLabel: true,
+        RichDescriptionEditor: true,
+        SeriesMembershipEditor: true,
+        ChipInput: true,
+        InputWithSuggestions: true,
+        WriteAndRenameResultPanel: true,
+        Tooltip: { template: '<div><slot /></div>' },
+        TooltipTrigger: { template: '<div><slot /></div>' },
+        TooltipContent: { template: '<div><slot /></div>' },
+      },
+    },
+  })
+}
+
+function saveButton(wrapper: ReturnType<typeof mountTab>) {
+  return wrapper.findAll('button').find((button) => button.text().includes('common.save'))!
+}
+
+describe('EditMetadataTab cover tiles', () => {
+  let savedBook: BookDetail
+
+  beforeEach(() => {
+    panel.hasPending.value = false
+    panel.pendingMedia.value = []
+    panel.busy.value = false
+    panel.confirm.mockReset()
+    panel.confirm.mockResolvedValue(true)
+    panel.setUrl.mockReset()
+    panel.reset.mockReset()
+    savedBook = makeBook()
+    vi.mocked(api).mockReset()
+    vi.mocked(api).mockImplementation(async (url, init) => {
+      if (init?.method === 'PATCH') return json({ book: savedBook, write: null, libraryAutoWriteEnabled: false })
+      if (String(url).includes('/metadata-fetch/providers')) return json([])
+      return json({})
+    })
+  })
+
+  it('enables Save when the only change is an unsaved cover', async () => {
+    const wrapper = mountTab(makeBook())
+    await flushPromises()
+    expect(saveButton(wrapper).attributes('disabled')).toBeDefined()
+
+    panel.hasPending.value = true
+    panel.pendingMedia.value = ['audio']
+    await flushPromises()
+
+    expect(saveButton(wrapper).attributes('disabled')).toBeUndefined()
+  })
+
+  it('does not save the form when a cover fails to save', async () => {
+    const wrapper = mountTab(makeBook())
+    await flushPromises()
+    panel.hasPending.value = true
+    panel.pendingMedia.value = ['ebook', 'audio']
+    panel.confirm.mockResolvedValue(false)
+    await flushPromises()
+
+    await saveButton(wrapper).trigger('click')
+    await flushPromises()
+
+    expect(panel.confirm).toHaveBeenCalledWith(['ebook', 'audio'])
+    expect(patchCalls()).toHaveLength(0)
+  })
+
+  it('writes a cover whose slot the form unlocks only after the form save', async () => {
+    const wrapper = mountTab(makeBook({ lockedFields: ['audioCover'] }))
+    await flushPromises()
+    wrapper.getComponent(CoverEditorPanelStub).vm.$emit('toggleLock', 'audioCover')
+    panel.hasPending.value = true
+    panel.pendingMedia.value = ['ebook', 'audio']
+    savedBook = makeBook({ lockedFields: [] })
+    await flushPromises()
+
+    const order: string[] = []
+    panel.confirm.mockImplementation(async (media) => {
+      order.push(`covers:${(media ?? []).join(',')}`)
+      return true
+    })
+    vi.mocked(api).mockImplementation(async (url, init) => {
+      if (init?.method === 'PATCH') {
+        order.push('form')
+        return json({ book: savedBook, write: null, libraryAutoWriteEnabled: false })
+      }
+      return json([])
+    })
+
+    await saveButton(wrapper).trigger('click')
+    await flushPromises()
+
+    expect(order).toEqual(['covers:ebook', 'form', 'covers:audio'])
+    expect(JSON.parse(String(patchCalls()[0]![1]!.body)).lockedFields).toEqual([])
+  })
+
+  it('clears the unsaved covers with the rest of the form', async () => {
+    const wrapper = mountTab(makeBook())
+    await flushPromises()
+    panel.hasPending.value = true
+    await flushPromises()
+
+    await wrapper.get('[aria-label="common.cancel"]').trigger('click')
+
+    expect(panel.reset).toHaveBeenCalledTimes(1)
+  })
+
+  it('passes each tile lock from the form, and toggles the one a tile asks for', async () => {
+    const wrapper = mountTab(makeBook({ lockedFields: ['cover'] }))
+    await flushPromises()
+
+    expect(wrapper.getComponent(CoverEditorPanelStub).props('lockedFields')).toEqual(['cover'])
+    wrapper.getComponent(CoverEditorPanelStub).vm.$emit('toggleLock', 'audioCover')
+    await flushPromises()
+
+    expect(wrapper.getComponent(CoverEditorPanelStub).props('lockedFields')).toEqual(['cover', 'audioCover'])
+  })
+
+  it('checks the audiobook cover lock before applying a searched cover to a book without an ebook', async () => {
+    const wrapper = mountTab(makeBook({ coverMedia: ['audio'], lockedFields: ['audioCover'] }))
+    await flushPromises()
+    await wrapper.get('[aria-label="common.search"]').trigger('click')
+
+    wrapper.getComponent(MetadataSearchDrawerStub).vm.$emit('apply', { formPatch: {}, coverUrl: 'https://example.com/square.jpg' })
+    await flushPromises()
+
+    expect(panel.setUrl).not.toHaveBeenCalled()
+  })
+
+  it('applies a searched cover to the panel when its slot is unlocked', async () => {
+    const wrapper = mountTab(makeBook({ lockedFields: ['audioCover'] }))
+    await flushPromises()
+    await wrapper.get('[aria-label="common.search"]').trigger('click')
+
+    wrapper.getComponent(MetadataSearchDrawerStub).vm.$emit('apply', { formPatch: {}, coverUrl: 'https://example.com/portrait.jpg' })
+    await flushPromises()
+
+    expect(panel.setUrl).toHaveBeenCalledWith('https://example.com/portrait.jpg', 'ebook')
+  })
+
+  it('stages each searched cover on its own tile, skipping a locked one', async () => {
+    const wrapper = mountTab(makeBook({ coverMedia: ['ebook', 'audio'], lockedFields: ['cover'] }))
+    await flushPromises()
+    await wrapper.get('[aria-label="common.search"]').trigger('click')
+
+    wrapper
+      .getComponent(MetadataSearchDrawerStub)
+      .vm.$emit('apply', { formPatch: {}, coverUrl: 'https://example.com/portrait.jpg', audioCoverUrl: 'https://example.com/square.jpg' })
+    await flushPromises()
+
+    expect(panel.setUrl).toHaveBeenCalledTimes(1)
+    expect(panel.setUrl).toHaveBeenCalledWith('https://example.com/square.jpg', 'audio')
+  })
+
+  it('reports a cover change with its medium', async () => {
+    const wrapper = mountTab(makeBook())
+    await flushPromises()
+
+    wrapper.getComponent(CoverEditorPanelStub).vm.$emit('coverChanged', 'audio')
+
+    expect(wrapper.emitted('coverChanged')).toEqual([['audio']])
+  })
+})
diff --git a/client/src/features/book/components/detail/tabs/__tests__/MetadataDiffPanel.spec.ts b/client/src/features/book/components/detail/tabs/__tests__/MetadataDiffPanel.spec.ts
new file mode 100644
index 000000000..bc1777c39
--- /dev/null
+++ b/client/src/features/book/components/detail/tabs/__tests__/MetadataDiffPanel.spec.ts
@@ -0,0 +1,159 @@
+import { describe, expect, it } from 'vitest'
+import { mount, type VueWrapper } from '@vue/test-utils'
+import type { MetadataCandidate, MetadataProviderInfo, MetadataSource } from '@bookorbit/types'
+import MetadataDiffPanel from '../MetadataDiffPanel.vue'
+import type { SecondCoverInput } from '../../../../composables/useSecondCoverRow'
+
+const current: MetadataSource = {
+  title: 'Dune',
+  subtitle: null,
+  description: null,
+  publisher: null,
+  publishedDate: null,
+  publishedYear: null,
+  language: null,
+  pageCount: null,
+  seriesName: null,
+  seriesIndex: null,
+  isbn10: null,
+  isbn13: null,
+  authors: ['Frank Herbert'],
+  genres: [],
+  narrators: [],
+  durationSeconds: null,
+  abridged: null,
+  hardcoverEditionId: null,
+  communityRatings: [],
+}
+
+const providers: MetadataProviderInfo[] = [
+  { key: 'google', label: 'Google Books', identifiable: true },
+  { key: 'audible', label: 'Audible', identifiable: true },
+  { key: 'itunes', label: 'iTunes', identifiable: true },
+]
+
+const google: MetadataCandidate = { provider: 'google', providerId: 'g1', title: 'Dune', coverUrl: '/covers/google.jpg', coverShape: 'portrait' }
+const audible: MetadataCandidate = { provider: 'audible', providerId: 'a1', title: 'Dune', coverUrl: '/covers/audible.jpg', coverShape: 'square' }
+const itunes: MetadataCandidate = { provider: 'itunes', providerId: 'i1', title: 'Dune', coverUrl: '/covers/itunes.jpg', coverShape: 'square' }
+
+function secondCover(overrides: Partial<SecondCoverInput> = {}): SecondCoverInput {
+  return { medium: 'audio', candidates: [itunes, audible], priority: ['audible', 'itunes'], currentUrl: '', searching: false, ...overrides }
+}
+
+function mountPanel(props: Record<string, unknown> = {}) {
+  return mount(MetadataDiffPanel, {
+    props: {
+      current,
+      candidates: [google],
+      initialCandidate: google,
+      providers,
+      filteredResults: [google],
+      currentCoverUrl: '',
+      coverMedium: 'ebook',
+      secondCover: secondCover(),
+      ...props,
+    },
+  })
+}
+
+async function click(wrapper: VueWrapper, label: string) {
+  await wrapper.get(`button[aria-label="${label}"]`).trigger('click')
+}
+
+async function clickText(wrapper: VueWrapper, text: string) {
+  const button = wrapper.findAll('button').find((candidate) => candidate.text() === text)
+  if (!button) throw new Error(`No button reads "${text}"`)
+  await button.trigger('click')
+}
+
+function applied(wrapper: VueWrapper) {
+  return wrapper.emitted('apply')?.[0]?.[0] as { coverUrl?: string; audioCoverUrl?: string } | undefined
+}
+
+describe('MetadataDiffPanel', () => {
+  it('shows one cover row per medium for a book that has both', () => {
+    const wrapper = mountPanel()
+
+    expect(wrapper.text()).toContain('Book cover')
+    expect(wrapper.text()).toContain('Audiobook cover')
+  })
+
+  it('applies the audiobook cover the Audiobook cover rule ranks first, to the audio slot only', async () => {
+    const wrapper = mountPanel()
+
+    await click(wrapper, 'Use the new Audiobook cover')
+    await clickText(wrapper, 'Apply to form')
+
+    const payload = applied(wrapper)
+    expect(payload?.audioCoverUrl).toBe('/covers/audible.jpg')
+    expect(payload?.coverUrl).toBeUndefined()
+  })
+
+  it('lets the audiobook cover come from another result of its own search', async () => {
+    const wrapper = mountPanel()
+
+    await click(wrapper, 'Show the iTunes cover, 2 of 2')
+    await click(wrapper, 'Use the new Audiobook cover')
+    await clickText(wrapper, 'Apply to form')
+
+    expect(applied(wrapper)?.audioCoverUrl).toBe('/covers/itunes.jpg')
+  })
+
+  it('leaves the audiobook cover out of Copy All', async () => {
+    const wrapper = mountPanel()
+
+    await clickText(wrapper, 'Copy All')
+    await clickText(wrapper, 'Apply to form')
+
+    const payload = applied(wrapper)
+    expect(payload?.coverUrl).toBe('/covers/google.jpg')
+    expect(payload?.audioCoverUrl).toBeUndefined()
+  })
+
+  it('does not apply a pick for a locked audiobook cover', async () => {
+    const wrapper = mountPanel({ lockedFields: ['audioCover'] })
+
+    expect(wrapper.get('button[aria-label="Use the new Audiobook cover"]').attributes('disabled')).toBeDefined()
+  })
+
+  it('sends the one cover of a book that is only an audiobook to the audio slot', async () => {
+    const wrapper = mountPanel({
+      coverMedium: 'audio',
+      secondCover: null,
+      candidates: [audible],
+      initialCandidate: audible,
+      filteredResults: [audible],
+    })
+
+    expect(wrapper.text()).not.toContain('Audiobook cover')
+    await click(wrapper, 'Use the new Cover')
+    await clickText(wrapper, 'Apply to form')
+
+    expect(applied(wrapper)).toMatchObject({ audioCoverUrl: '/covers/audible.jpg' })
+    expect(applied(wrapper)?.coverUrl).toBeUndefined()
+  })
+
+  it('names portrait art offered for a filled audiobook slot, and keeps it out of Copy All', async () => {
+    const wrapper = mountPanel({
+      coverMedium: 'audio',
+      secondCover: null,
+      currentCoverUrl: '/api/v1/books/1/cover?medium=audio',
+    })
+
+    const hint = wrapper.findAll('p').find((paragraph) => paragraph.text() === 'Portrait image. Audiobook covers are square.')
+    expect(hint).toBeDefined()
+    expect(wrapper.get('button[aria-label="Use the new Cover"]').attributes('aria-describedby')).toBe(hint?.attributes('id'))
+
+    await clickText(wrapper, 'Copy All')
+    await clickText(wrapper, 'Apply to form')
+    expect(applied(wrapper)?.audioCoverUrl).toBeUndefined()
+  })
+
+  it('says when the other medium is still being searched, or found nothing', async () => {
+    const searching = mountPanel({ secondCover: secondCover({ candidates: [], searching: true }) })
+    expect(searching.get('[role="status"]').text()).toBe('Searching audiobook editions...')
+
+    const empty = mountPanel({ secondCover: secondCover({ candidates: [] }) })
+    expect(empty.text()).toContain('No audiobook covers found.')
+  })
+})
diff --git a/client/src/features/book/components/detail/tabs/__tests__/ReadingLogTab.spec.ts b/client/src/features/book/components/detail/tabs/__tests__/ReadingLogTab.spec.ts
index 49fb15ead..42e7351f8 100644
--- a/client/src/features/book/components/detail/tabs/__tests__/ReadingLogTab.spec.ts
+++ b/client/src/features/book/components/detail/tabs/__tests__/ReadingLogTab.spec.ts
@@ -57,6 +57,9 @@ function makeBook(overrides: Partial<BookDetail> = {}): BookDetail {
     personalNoteUpdatedAt: null,
     communityRatings: [],
     coverSource: null,
+    coverMedia: [],
+    covers: { ebook: null, audio: null },
+    coverVersion: 'legacy:2024-01-01T00:00:00.000Z',
     hardcoverEditionId: null,
     providerIds: {},
     authors: [],
diff --git a/client/src/features/book/components/table/BookCoverDialog.vue b/client/src/features/book/components/table/BookCoverDialog.vue
index 64db2c57a..05a770570 100644
--- a/client/src/features/book/components/table/BookCoverDialog.vue
+++ b/client/src/features/book/components/table/BookCoverDialog.vue
@@ -27,21 +27,21 @@ const { md } = useBreakpoints(breakpointsTailwind)
 const isEditEnabled = computed(() => !props.readOnly && md.value)
 
 const mode = ref<'view' | 'edit'>('view')
-const savedCover = ref(false)
 
 const { detail, loading, fetch } = useBookDetail()
-const { isLocked, toggle, load: loadLocks } = useMetadataLocks()
+const { lockedFields, toggle, load: loadLocks } = useMetadataLocks()
 const { coverUrl } = useCoverVersions()
 const coverAspectRatio = inject(COVER_ASPECT_RATIO_KEY, ref(DEFAULT_COVER_ASPECT_RATIO))
+const editor = ref<InstanceType<typeof CoverEditorPanel> | null>(null)
 
-const hasCoverResolved = computed(() => savedCover.value || (props.book?.hasCover ?? false))
-const coverVersion = computed(() => detail.value?.updatedAt ?? props.book?.updatedAt ?? props.book?.addedAt ?? null)
+const currentDetail = computed(() => (detail.value && detail.value.id === props.book?.id ? detail.value : null))
+const hasCoverResolved = computed(() => (currentDetail.value ? currentDetail.value.coverSource !== null : (props.book?.hasCover ?? false)))
+const coverVersion = computed(() => currentDetail.value?.coverVersion ?? props.book?.coverVersion ?? null)
 
 watch(
   () => props.book?.id,
   () => {
     mode.value = 'view'
-    savedCover.value = false
     detail.value = null
   },
 )
@@ -61,19 +61,23 @@ function switchToView() {
   mode.value = 'view'
 }
 
-function handleCoverChanged() {
-  savedCover.value = true
-  if (props.book) emit('update:book', props.book.id, true)
-  mode.value = 'view'
+// The other tile may still hold an unsaved image, so the editor stays open until nothing is pending.
+async function handleCoverChanged() {
+  const bookId = props.book?.id
+  if (bookId === undefined) return
+  await fetch(bookId)
+  if (!currentDetail.value || currentDetail.value.id !== bookId) return
+  emit('update:book', bookId, currentDetail.value.coverSource !== null)
+  if (!editor.value?.hasPending) mode.value = 'view'
 }
 
 function handleOpenChange(open: boolean) {
   if (!open) emit('close')
 }
 
-async function handleToggleCoverLock() {
-  if (!detail.value) return
-  await toggle(detail.value.id, 'cover')
+async function handleToggleCoverLock(field: 'cover' | 'audioCover') {
+  if (!currentDetail.value) return
+  await toggle(currentDetail.value.id, field)
 }
 </script>
 
@@ -144,16 +148,18 @@ async function handleToggleCoverLock() {
 
           <!-- Edit mode -->
           <template v-else>
-            <div v-if="loading" class="flex items-center justify-center py-12">
-              <Loader2 class="size-5 animate-spin text-muted-foreground" />
-            </div>
+            <!-- A refetch after a save keeps the editor mounted, or the other tile's pending image is lost. -->
             <CoverEditorPanel
-              v-else-if="detail"
-              :book="detail"
-              :locked="isLocked('cover')"
+              v-if="currentDetail"
+              ref="editor"
+              :book="currentDetail"
+              :locked-fields="lockedFields"
               @cover-changed="handleCoverChanged"
               @toggle-lock="handleToggleCoverLock"
             />
+            <div v-else-if="loading" class="flex items-center justify-center py-12">
+              <Loader2 class="size-5 animate-spin text-muted-foreground" />
+            </div>
           </template>
         </div>
       </DialogContent>
diff --git a/client/src/features/book/components/table/BookTableCellDispatcher.vue b/client/src/features/book/components/table/BookTableCellDispatcher.vue
index 26026b014..5708d4396 100644
--- a/client/src/features/book/components/table/BookTableCellDispatcher.vue
+++ b/client/src/features/book/components/table/BookTableCellDispatcher.vue
@@ -121,7 +121,7 @@ const isComic = computed(() => primaryFile.value?.format != null && FORMAT_TO_GR
     v-else-if="cellType === 'cover'"
     :book-id="book.id"
     :title="book.title"
-    :version="book.updatedAt ?? book.addedAt"
+    :version="book.coverVersion"
     :has-cover="book.hasCover"
     :is-audio="isAudiobook"
     :is-comic="isComic"
diff --git a/client/src/features/book/components/table/BookTableCollapsedSeriesCell.vue b/client/src/features/book/components/table/BookTableCollapsedSeriesCell.vue
index c6624898e..f0791197d 100644
--- a/client/src/features/book/components/table/BookTableCollapsedSeriesCell.vue
+++ b/client/src/features/book/components/table/BookTableCollapsedSeriesCell.vue
@@ -29,7 +29,7 @@ const isComic = computed(() => primaryFile.value?.format != null && FORMAT_TO_GR
 const { coverUrl } = useCoverVersions()
 
 function thumbnailUrl(bookId: number): string {
-  const version = bookId === props.book.id ? (props.book.updatedAt ?? props.book.addedAt) : collapsed.value.coverUpdatedAtByBookId?.[bookId]
+  const version = bookId === props.book.id ? props.book.coverVersion : collapsed.value.coverUpdatedAtByBookId?.[bookId]
   return coverUrl(bookId, 'thumbnail', version)
 }
 
diff --git a/client/src/features/book/components/table/__tests__/BookCoverDialog.spec.ts b/client/src/features/book/components/table/__tests__/BookCoverDialog.spec.ts
new file mode 100644
index 000000000..ac71a118d
--- /dev/null
+++ b/client/src/features/book/components/table/__tests__/BookCoverDialog.spec.ts
@@ -0,0 +1,187 @@
+import { flushPromises, mount } from '@vue/test-utils'
+import { defineComponent, ref } from 'vue'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import type { BookCard, BookDetail, BookMetadataLockField } from '@bookorbit/types'
+import BookCoverDialog from '../BookCoverDialog.vue'
+
+const detail = ref<BookDetail | null>(null)
+const loading = ref(false)
+const fetchDetail = vi.fn<(bookId: number) => Promise<void>>()
+const lockedFields = ref<BookMetadataLockField[]>([])
+const toggle = vi.fn<(bookId: number, field: BookMetadataLockField) => Promise<void>>()
+const editorPending = ref(false)
+
+vi.mock('vue-i18n', () => ({
+  useI18n: () => ({ t: (key: string) => key }),
+}))
+
+vi.mock('@vueuse/core', async (importOriginal) => ({
+  ...(await importOriginal<typeof import('@vueuse/core')>()),
+  useBreakpoints: () => ({ md: ref(true) }),
+}))
+
+vi.mock('../../../composables/useBookDetail', () => ({
+  useBookDetail: () => ({ detail, loading, fetch: fetchDetail }),
+}))
+
+vi.mock('../../../composables/useMetadataLocks', () => ({
+  useMetadataLocks: () => ({ lockedFields, toggle, load: vi.fn<() => void>() }),
+}))
+
+vi.mock('../../../composables/useCoverVersions', () => ({
+  useCoverVersions: () => ({ coverUrl: (bookId: number, _type: string, version?: string) => `/cover/${bookId}?t=${version}` }),
+}))
+
+const CoverEditorPanelStub = defineComponent({
+  name: 'CoverEditorPanel',
+  props: ['book', 'lockedFields'],
+  emits: ['coverChanged', 'toggleLock'],
+  setup(_props, { expose }) {
+    expose({ hasPending: editorPending })
+    return {}
+  },
+  template: '<div data-test="editor" />',
+})
+
+const card = { id: 5, title: 'Dune', hasCover: false, coverVersion: 'card-version' } as unknown as BookCard
+
+function makeDetail(overrides: Partial<BookDetail> = {}): BookDetail {
+  return {
+    id: 5,
+    title: 'Dune',
+    coverSource: null,
+    coverMedia: ['ebook', 'audio'],
+    covers: { ebook: null, audio: null },
+    coverVersion: 'detail-version',
+    lockedFields: [],
+    ...overrides,
+  } as unknown as BookDetail
+}
+
+function mountDialog() {
+  return mount(BookCoverDialog, {
+    props: { book: card, readOnly: false },
+    global: {
+      stubs: {
+        DialogRoot: { template: '<div><slot /></div>' },
+        DialogPortal: { template: '<div><slot /></div>' },
+        DialogOverlay: { template: '<div />' },
+        DialogContent: { template: '<div><slot /></div>' },
+        DialogTitle: { template: '<div><slot /></div>' },
+        DialogDescription: { template: '<div><slot /></div>' },
+        DialogClose: { template: '<button><slot /></button>' },
+        BookCoverPlaceholder: true,
+        CoverEditorPanel: CoverEditorPanelStub,
+      },
+    },
+  })
+}
+
+async function openEditor(wrapper: ReturnType<typeof mountDialog>) {
+  const edit = wrapper.findAll('button').find((button) => button.text().includes('book.table.cover.editCover'))!
+  await edit.trigger('click')
+  await flushPromises()
+}
+
+describe('BookCoverDialog', () => {
+  beforeEach(() => {
+    detail.value = null
+    loading.value = false
+    editorPending.value = false
+    lockedFields.value = []
+    fetchDetail.mockReset()
+    fetchDetail.mockImplementation(async () => {
+      detail.value = makeDetail()
+    })
+    toggle.mockReset()
+  })
+
+  it('loads the detail and passes its locks to the editor', async () => {
+    lockedFields.value = ['audioCover']
+    const wrapper = mountDialog()
+
+    await openEditor(wrapper)
+
+    expect(fetchDetail).toHaveBeenCalledWith(5)
+    expect(wrapper.getComponent(CoverEditorPanelStub).props('lockedFields')).toEqual(['audioCover'])
+  })
+
+  it('toggles the lock of the tile that asked', async () => {
+    const wrapper = mountDialog()
+    await openEditor(wrapper)
+
+    wrapper.getComponent(CoverEditorPanelStub).vm.$emit('toggleLock', 'audioCover')
+    await flushPromises()
+
+    expect(toggle).toHaveBeenCalledWith(5, 'audioCover')
+  })
+
+  it('refetches after a save and reports whether the book now has a cover', async () => {
+    const wrapper = mountDialog()
+    await openEditor(wrapper)
+    fetchDetail.mockImplementation(async () => {
+      detail.value = makeDetail({ coverSource: 'custom', coverVersion: 'after-save' })
+    })
+
+    wrapper.getComponent(CoverEditorPanelStub).vm.$emit('coverChanged', 'audio')
+    await flushPromises()
+
+    expect(fetchDetail).toHaveBeenCalledTimes(2)
+    expect(wrapper.emitted('update:book')).toEqual([[5, true]])
+    expect(wrapper.find('[data-test="editor"]').exists()).toBe(false)
+    expect(wrapper.get('img').attributes('src')).toBe('/cover/5?t=after-save')
+  })
+
+  it('reports a cleared cover as no cover', async () => {
+    const wrapper = mountDialog()
+    await openEditor(wrapper)
+    fetchDetail.mockImplementation(async () => {
+      detail.value = makeDetail({ coverSource: null })
+    })
+
+    wrapper.getComponent(CoverEditorPanelStub).vm.$emit('coverChanged', 'ebook')
+    await flushPromises()
+
+    expect(wrapper.emitted('update:book')).toEqual([[5, false]])
+  })
+
+  it('keeps the editor open while the other tile still has an unsaved image', async () => {
+    const wrapper = mountDialog()
+    await openEditor(wrapper)
+    editorPending.value = true
+    fetchDetail.mockImplementation(async () => {
+      loading.value = true
+      await Promise.resolve()
+      detail.value = makeDetail({ coverSource: 'custom' })
+      loading.value = false
+    })
+
+    wrapper.getComponent(CoverEditorPanelStub).vm.$emit('coverChanged', 'ebook')
+    await flushPromises()
+
+    expect(wrapper.find('[data-test="editor"]').exists()).toBe(true)
+  })
+
+  it('does not unmount the editor while it refetches', async () => {
+    const wrapper = mountDialog()
+    await openEditor(wrapper)
+    editorPending.value = true
+    let finishFetch!: () => void
+    fetchDetail.mockImplementation(() => {
+      loading.value = true
+      return new Promise<void>((resolve) => {
+        finishFetch = () => {
+          loading.value = false
+          resolve()
+        }
+      })
+    })
+
+    wrapper.getComponent(CoverEditorPanelStub).vm.$emit('coverChanged', 'ebook')
+    await flushPromises()
+
+    expect(wrapper.find('[data-test="editor"]').exists()).toBe(true)
+    finishFetch()
+    await flushPromises()
+  })
+})
diff --git a/client/src/features/book/components/table/__tests__/BookTableCellDispatcher.spec.ts b/client/src/features/book/components/table/__tests__/BookTableCellDispatcher.spec.ts
index 990d6c443..f783d6042 100644
--- a/client/src/features/book/components/table/__tests__/BookTableCellDispatcher.spec.ts
+++ b/client/src/features/book/components/table/__tests__/BookTableCellDispatcher.spec.ts
@@ -24,6 +24,7 @@ function makeBook(overrides: Partial<BookCard> = {}): BookCard {
     readStatus: null,
     addedAt: '2026-01-01T00:00:00.000Z',
     updatedAt: null,
+    coverVersion: 'legacy:2026-01-01T00:00:00.000Z',
     metadataScore: null,
     hasCover: false,
     hasMetadataLocks: false,
diff --git a/client/src/features/book/components/table/__tests__/BookTableCollapsedSeriesCell.spec.ts b/client/src/features/book/components/table/__tests__/BookTableCollapsedSeriesCell.spec.ts
index a379bddbc..f70e6ffbe 100644
--- a/client/src/features/book/components/table/__tests__/BookTableCollapsedSeriesCell.spec.ts
+++ b/client/src/features/book/components/table/__tests__/BookTableCollapsedSeriesCell.spec.ts
@@ -32,6 +32,7 @@ function makeBook(format: string | null): BookCard {
     readStatus: null,
     addedAt: '2026-01-01T00:00:00.000Z',
     updatedAt: null,
+    coverVersion: 'legacy:2026-01-01T00:00:00.000Z',
     metadataScore: null,
     hasCover: false,
     hasMetadataLocks: false,
diff --git a/client/src/features/book/composables/__tests__/tableColumnSchema.spec.ts b/client/src/features/book/composables/__tests__/tableColumnSchema.spec.ts
index c0c9b5959..0e875bcd7 100644
--- a/client/src/features/book/composables/__tests__/tableColumnSchema.spec.ts
+++ b/client/src/features/book/composables/__tests__/tableColumnSchema.spec.ts
@@ -49,6 +49,7 @@ function makeBook(overrides: Partial<BookCard> = {}): BookCard {
     readStatus: null,
     addedAt: '2025-01-01T00:00:00Z',
     updatedAt: null,
+    coverVersion: 'legacy:2025-01-01T00:00:00Z',
     metadataScore: null,
     hasCover: false,
     hasMetadataLocks: false,
@@ -126,6 +127,7 @@ describe('tableColumnSchema', () => {
       readStatus: null,
       addedAt: '2025-01-01T00:00:00.000Z',
       updatedAt: null,
+      coverVersion: 'legacy:2025-01-01T00:00:00.000Z',
       metadataScore: null,
       hasCover: false,
       hasMetadataLocks: false,
diff --git a/client/src/features/book/composables/__tests__/useBookBulkActions.spec.ts b/client/src/features/book/composables/__tests__/useBookBulkActions.spec.ts
index 136b9136d..dc27820b6 100644
--- a/client/src/features/book/composables/__tests__/useBookBulkActions.spec.ts
+++ b/client/src/features/book/composables/__tests__/useBookBulkActions.spec.ts
@@ -2,6 +2,8 @@ import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 import { ref } from 'vue'
 import { BOOK_METADATA_LOCK_FIELDS, type BookCard, type UserBookStatus } from '@bookorbit/types'
 
+import { i18n } from '@/i18n'
+
 const mocks = vi.hoisted(() => ({
   api: vi.fn<(input: RequestInfo | URL, init?: RequestInit) => Promise<{ ok: boolean }>>(),
   toastSuccess: vi.fn<(message: string) => void>(),
@@ -94,6 +96,7 @@ function makeBook(overrides: Partial<BookCard> = {}): BookCard {
     readStatus: null,
     addedAt: '2026-01-01T00:00:00.000Z',
     updatedAt: null,
+    coverVersion: 'legacy:2026-01-01T00:00:00.000Z',
     metadataScore: null,
     hasCover: false,
     hasMetadataLocks: false,
@@ -242,6 +245,7 @@ describe('useBookBulkActions', () => {
     expect(books.value[0]?.lockedFields).toEqual([...BOOK_METADATA_LOCK_FIELDS])
     expect(books.value[1]?.lockedFields).toEqual([])
     expect(books.value[2]?.lockedFields).toEqual([...BOOK_METADATA_LOCK_FIELDS])
+    expect(books.value[0]?.lockedFields).toEqual(expect.arrayContaining(['cover', 'audioCover']))
   })
 
   it('skips local field updates for selected books where that field is locked', async () => {
@@ -520,6 +524,26 @@ describe('useBookBulkActions', () => {
     expect(mocks.bumpVersion.mock.calls.filter((c) => c[0] === 40).length).toBe(1)
   })
 
+  it('reports the bulk re-extract outcome through the English source catalog', async () => {
+    i18n.global.locale.value = 'en'
+    mocks.api.mockResolvedValue(makeSseStream([`data: ${JSON.stringify({ done: true, processed: 2, updated: 1 })}`]))
+
+    const { handleBulkReExtractCover } = useBookBulkActions(ref(new Set([30, 40])), vi.fn())
+    await handleBulkReExtractCover()
+
+    expect(mocks.toastSuccess).toHaveBeenCalledWith('Re-extracted 1 of 2 covers')
+  })
+
+  it('reports a failed bulk re-extract request', async () => {
+    i18n.global.locale.value = 'en'
+    mocks.api.mockResolvedValue({ ok: false })
+
+    const { handleBulkReExtractCover } = useBookBulkActions(ref(new Set([30])), vi.fn())
+    await handleBulkReExtractCover()
+
+    expect(mocks.toastError).toHaveBeenCalledWith('Could not re-extract covers')
+  })
+
   it('bumps all re-extract IDs in finally when stream delivers no events', async () => {
     mocks.api.mockResolvedValue(makeSseStream([]))
     mocks.bumpVersion.mockReset()
diff --git a/client/src/features/book/composables/__tests__/useBookNavigation.spec.ts b/client/src/features/book/composables/__tests__/useBookNavigation.spec.ts
index aba627421..58684b47b 100644
--- a/client/src/features/book/composables/__tests__/useBookNavigation.spec.ts
+++ b/client/src/features/book/composables/__tests__/useBookNavigation.spec.ts
@@ -24,6 +24,7 @@ function makeBook(id: number): BookCard {
     readStatus: null,
     addedAt: '2024-01-01T00:00:00Z',
     updatedAt: null,
+    coverVersion: 'legacy:2024-01-01T00:00:00Z',
     metadataScore: null,
     hasCover: false,
     hasMetadataLocks: false,
diff --git a/client/src/features/book/composables/__tests__/useBookTableShell.spec.ts b/client/src/features/book/composables/__tests__/useBookTableShell.spec.ts
index 767fe86a0..1589be131 100644
--- a/client/src/features/book/composables/__tests__/useBookTableShell.spec.ts
+++ b/client/src/features/book/composables/__tests__/useBookTableShell.spec.ts
@@ -95,6 +95,7 @@ function makeBook(overrides: Partial<BookCard> = {}): BookCard {
     readStatus: null,
     addedAt: '2026-01-01T00:00:00.000Z',
     updatedAt: null,
+    coverVersion: 'legacy:2026-01-01T00:00:00.000Z',
     metadataScore: null,
     hasCover: false,
     hasMetadataLocks: false,
diff --git a/client/src/features/book/composables/__tests__/useBookViewContext.spec.ts b/client/src/features/book/composables/__tests__/useBookViewContext.spec.ts
index 3cfe6fdca..6c74816fb 100644
--- a/client/src/features/book/composables/__tests__/useBookViewContext.spec.ts
+++ b/client/src/features/book/composables/__tests__/useBookViewContext.spec.ts
@@ -30,6 +30,7 @@ function makeBook(id: number): BookCard {
     readStatus: null,
     addedAt: '2024-01-01T00:00:00Z',
     updatedAt: null,
+    coverVersion: 'legacy:2024-01-01T00:00:00Z',
     metadataScore: null,
     hasCover: false,
     hasMetadataLocks: false,
diff --git a/client/src/features/book/composables/__tests__/useBookViewWindow.spec.ts b/client/src/features/book/composables/__tests__/useBookViewWindow.spec.ts
index c9a505060..2397b8082 100644
--- a/client/src/features/book/composables/__tests__/useBookViewWindow.spec.ts
+++ b/client/src/features/book/composables/__tests__/useBookViewWindow.spec.ts
@@ -46,6 +46,7 @@ function makeBook(id: number): BookCard {
     readStatus: null,
     addedAt: '2024-01-01T00:00:00Z',
     updatedAt: null,
+    coverVersion: 'legacy:2024-01-01T00:00:00Z',
     metadataScore: null,
     hasCover: false,
     hasMetadataLocks: false,
diff --git a/client/src/features/book/composables/__tests__/useBulkEditMetadata.test.ts b/client/src/features/book/composables/__tests__/useBulkEditMetadata.test.ts
index c7a5b3fb7..20ffc2301 100644
--- a/client/src/features/book/composables/__tests__/useBulkEditMetadata.test.ts
+++ b/client/src/features/book/composables/__tests__/useBulkEditMetadata.test.ts
@@ -42,6 +42,7 @@ function makeBook(overrides: Partial<BookCard> = {}): BookCard {
     readStatus: null,
     addedAt: '2026-01-01T00:00:00.000Z',
     updatedAt: null,
+    coverVersion: 'legacy:2026-01-01T00:00:00.000Z',
     metadataScore: null,
     hasCover: false,
     hasMetadataLocks: false,
diff --git a/client/src/features/book/composables/__tests__/useCoverEditor.spec.ts b/client/src/features/book/composables/__tests__/useCoverEditor.spec.ts
new file mode 100644
index 000000000..cfb1569e2
--- /dev/null
+++ b/client/src/features/book/composables/__tests__/useCoverEditor.spec.ts
@@ -0,0 +1,136 @@
+// @vitest-environment node
+import { ref } from 'vue'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { api } from '@/lib/api'
+import { useCoverEditor } from '../useCoverEditor'
+
+const bumpVersion = vi.fn<(bookId: number) => void>()
+
+vi.mock('vue', async (importOriginal) => ({
+  ...(await importOriginal<typeof import('vue')>()),
+  onUnmounted: vi.fn<() => void>(),
+}))
+
+vi.mock('vue-i18n', () => ({
+  useI18n: () => ({ t: (key: string) => key }),
+}))
+
+vi.mock('@/lib/api', () => ({
+  api: vi.fn<(url: string, init?: RequestInit) => Promise<Response>>(),
+}))
+
+vi.mock('../useCoverVersions', () => ({
+  useCoverVersions: () => ({ bumpVersion }),
+}))
+
+function response(ok: boolean, body: unknown = {}): Response {
+  return { ok, status: ok ? 200 : 423, json: async () => body } as Response
+}
+
+describe('useCoverEditor', () => {
+  beforeEach(() => {
+    vi.mocked(api).mockReset()
+    bumpVersion.mockReset()
+  })
+
+  it('writes an uploaded file to its own slot', async () => {
+    vi.mocked(api).mockResolvedValue(response(true))
+    const editor = useCoverEditor(ref(7), 'audio')
+    editor.selectFile(new File(['x'], 'square.jpg', { type: 'image/jpeg' }))
+
+    await expect(editor.confirm()).resolves.toBe(true)
+
+    expect(vi.mocked(api).mock.calls[0]![0]).toBe('/api/v1/books/7/cover?medium=audio')
+    expect(vi.mocked(api).mock.calls[0]![1]).toMatchObject({ method: 'POST' })
+    expect(bumpVersion).toHaveBeenCalledWith(7)
+    expect(editor.pendingFile.value).toBeNull()
+  })
+
+  it('saves a URL to its own slot', async () => {
+    vi.mocked(api).mockResolvedValue(response(true))
+    const editor = useCoverEditor(ref(7), 'ebook')
+    editor.setUrl(' https://example.com/cover.jpg ')
+
+    await expect(editor.confirm()).resolves.toBe(true)
+
+    expect(vi.mocked(api)).toHaveBeenCalledWith('/api/v1/books/7/cover/from-url?medium=ebook', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ url: 'https://example.com/cover.jpg' }),
+    })
+  })
+
+  it('leaves the medium off for a book with no content files, so the server routes it', async () => {
+    vi.mocked(api).mockResolvedValue(response(true, { coverSource: null }))
+    const editor = useCoverEditor(ref(7), null)
+
+    await editor.revert()
+
+    expect(vi.mocked(api)).toHaveBeenCalledWith('/api/v1/books/7/cover', { method: 'DELETE' })
+  })
+
+  it('keeps the pending image and shows a translated error when the save fails', async () => {
+    vi.mocked(api).mockResolvedValue(response(false))
+    const editor = useCoverEditor(ref(7), 'audio')
+    editor.setUrl('https://example.com/cover.jpg')
+
+    await expect(editor.confirm()).resolves.toBe(false)
+
+    expect(editor.error.value).toBe('book.detail.coverEditor.saveFailed')
+    expect(editor.pendingUrl.value).toBe('https://example.com/cover.jpg')
+    expect(editor.uploading.value).toBe(false)
+    expect(bumpVersion).not.toHaveBeenCalled()
+  })
+
+  it('does nothing without a pending image', async () => {
+    const editor = useCoverEditor(ref(7), 'ebook')
+
+    await expect(editor.confirm()).resolves.toBe(false)
+
+    expect(api).not.toHaveBeenCalled()
+  })
+
+  it('reverts its slot and returns what the slot falls back to', async () => {
+    vi.mocked(api).mockResolvedValue(response(true, { coverSource: 'extracted' }))
+    const editor = useCoverEditor(ref(7), 'audio')
+
+    await expect(editor.revert()).resolves.toBe('extracted')
+
+    expect(vi.mocked(api)).toHaveBeenCalledWith('/api/v1/books/7/cover?medium=audio', { method: 'DELETE' })
+    expect(bumpVersion).toHaveBeenCalledWith(7)
+  })
+
+  it('reports a failed revert', async () => {
+    vi.mocked(api).mockResolvedValue(response(false))
+    const editor = useCoverEditor(ref(7), 'audio')
+
+    await expect(editor.revert()).resolves.toBe(false)
+
+    expect(editor.error.value).toBe('book.detail.coverEditor.revertFailed')
+  })
+
+  it('regenerates its slot and checks the response', async () => {
+    vi.mocked(api).mockResolvedValueOnce(response(true)).mockResolvedValueOnce(response(false))
+    const editor = useCoverEditor(ref(7), 'ebook')
+
+    await expect(editor.regenerate()).resolves.toBe(true)
+    expect(vi.mocked(api)).toHaveBeenCalledWith('/api/v1/books/7/re-extract-cover?medium=ebook', { method: 'POST' })
+    expect(bumpVersion).toHaveBeenCalledTimes(1)
+
+    await expect(editor.regenerate()).resolves.toBe(false)
+    expect(editor.error.value).toBe('book.coverRegeneration.failed')
+    expect(editor.regenerating.value).toBe(false)
+    expect(bumpVersion).toHaveBeenCalledTimes(1)
+  })
+
+  it('follows the current book id', async () => {
+    vi.mocked(api).mockResolvedValue(response(true))
+    const bookId = ref(7)
+    const editor = useCoverEditor(bookId, 'ebook')
+    bookId.value = 9
+
+    await editor.regenerate()
+
+    expect(vi.mocked(api)).toHaveBeenCalledWith('/api/v1/books/9/re-extract-cover?medium=ebook', { method: 'POST' })
+  })
+})
diff --git a/client/src/features/book/composables/__tests__/useCoverShapes.spec.ts b/client/src/features/book/composables/__tests__/useCoverShapes.spec.ts
new file mode 100644
index 000000000..7ba08e8be
--- /dev/null
+++ b/client/src/features/book/composables/__tests__/useCoverShapes.spec.ts
@@ -0,0 +1,65 @@
+// @vitest-environment node
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { nextTick, ref } from 'vue'
+import type { MetadataCandidate } from '@bookorbit/types'
+import { useCoverShapes } from '../useCoverShapes'
+
+class FakeImage {
+  static loads: FakeImage[] = []
+  naturalWidth = 0
+  naturalHeight = 0
+  onload: (() => void) | null = null
+  onerror: (() => void) | null = null
+  src = ''
+
+  constructor() {
+    FakeImage.loads.push(this)
+  }
+
+  finish(width: number, height: number) {
+    this.naturalWidth = width
+    this.naturalHeight = height
+    this.onload?.()
+  }
+}
+
+function candidate(id: string, data: Partial<MetadataCandidate> = {}): MetadataCandidate {
+  return { provider: 'hardcover', providerId: id, title: 'The Silver Chair', coverUrl: `/covers/${id}.jpg`, ...data }
+}
+
+describe('useCoverShapes', () => {
+  beforeEach(() => {
+    FakeImage.loads = []
+    vi.stubGlobal('Image', FakeImage)
+  })
+
+  afterEach(() => {
+    vi.unstubAllGlobals()
+  })
+
+  it('measures only covers whose provider states no shape, once per image', async () => {
+    const unsized = candidate('unsized')
+    const stated = candidate('stated', { coverShape: 'square' })
+    const list = ref<MetadataCandidate[]>([unsized, stated])
+    const { shapeOf } = useCoverShapes(list)
+
+    expect(FakeImage.loads.map((image) => image.src)).toEqual(['/covers/unsized.jpg'])
+    expect(shapeOf(unsized)).toBe('unknown')
+
+    FakeImage.loads[0]!.finish(336, 500)
+    expect(shapeOf(unsized)).toBe('portrait')
+    expect(shapeOf(stated)).toBe('square')
+
+    list.value = [...list.value, candidate('unsized')]
+    await nextTick()
+    expect(FakeImage.loads).toHaveLength(1)
+  })
+
+  it('leaves a cover that fails to load as unknown', () => {
+    const broken = candidate('broken')
+    const { shapeOf } = useCoverShapes([broken])
+
+    FakeImage.loads[0]!.onerror?.()
+    expect(shapeOf(broken)).toBe('unknown')
+  })
+})
diff --git a/client/src/features/book/composables/__tests__/useCoverVersions.test.ts b/client/src/features/book/composables/__tests__/useCoverVersions.test.ts
index db562a4b9..2a086332c 100644
--- a/client/src/features/book/composables/__tests__/useCoverVersions.test.ts
+++ b/client/src/features/book/composables/__tests__/useCoverVersions.test.ts
@@ -46,6 +46,17 @@ describe('useCoverVersions', () => {
     expect(coverUrl(42, 'thumbnail', '2026-05-01T12:00:00.000Z')).toBe('/api/v1/books/42/thumbnail?t=1777636800000')
   })
 
+  it('preserves opaque server cover versions in the URL', async () => {
+    const { coverUrl } = await load()
+    expect(coverUrl(42, 'cover', 'ebook:2026-09-23T12:34:56.000Z:-')).toBe('/api/v1/books/42/cover?t=ebook%3A2026-09-23T12%3A34%3A56.000Z%3A-')
+  })
+
+  it('requests an explicit cover medium without losing the version', async () => {
+    const { coverUrl } = await load()
+    expect(coverUrl(42, 'cover', 'slot-version', 'audio')).toBe('/api/v1/books/42/cover?t=slot-version&medium=audio')
+    expect(coverUrl(42, 'thumbnail', undefined, 'audio')).toBe('/api/v1/books/42/thumbnail?medium=audio')
+  })
+
   it('combines local and server versions when both are present', async () => {
     const { coverUrl, bumpVersion } = await load()
     bumpVersion(42)
@@ -95,19 +106,25 @@ describe('useCoverVersions', () => {
   it('persists bumped version to localStorage', async () => {
     const { bumpVersion } = await load()
     bumpVersion(11)
-    const stored = JSON.parse(localStorage.getItem('cover-versions') ?? '[]') as [number, number][]
+    const stored = JSON.parse(localStorage.getItem('cover-versions-v2') ?? '[]') as [number, number][]
     expect(stored).toContainEqual([11, Date.now()])
   })
 
   it('loads pre-existing versions from localStorage on init', async () => {
     const ts = Date.now()
-    localStorage.setItem('cover-versions', JSON.stringify([[20, ts]]))
+    localStorage.setItem('cover-versions-v2', JSON.stringify([[20, ts]]))
     const { coverUrl } = await load()
     expect(coverUrl(20)).toBe(`/api/v1/books/20/thumbnail?t=${ts}`)
   })
 
+  it('does not reuse cover bumps from the pre-slot storage key', async () => {
+    localStorage.setItem('cover-versions', JSON.stringify([[20, Date.now()]]))
+    const { coverUrl } = await load()
+    expect(coverUrl(20)).toBe('/api/v1/books/20/thumbnail')
+  })
+
   it('returns empty map when localStorage contains corrupt data', async () => {
-    localStorage.setItem('cover-versions', 'not-json')
+    localStorage.setItem('cover-versions-v2', 'not-json')
     const { coverUrl } = await load()
     expect(coverUrl(1)).toBe('/api/v1/books/1/thumbnail')
   })
diff --git a/client/src/features/book/composables/__tests__/useMetadataDiff.spec.ts b/client/src/features/book/composables/__tests__/useMetadataDiff.spec.ts
index af9b47aaa..9b1ddfde5 100644
--- a/client/src/features/book/composables/__tests__/useMetadataDiff.spec.ts
+++ b/client/src/features/book/composables/__tests__/useMetadataDiff.spec.ts
@@ -161,7 +161,7 @@ describe('useMetadataDiff', () => {
     ])
 
     expect(fields.value.find((field) => field.key === 'librofmId')).toMatchObject({
-      label: 'Libro.fm ISBN',
+      labelKey: 'book.detail.editMetadata.diff.providerIds.librofm',
       candidateDisplay: '9781234567890',
     })
 
@@ -189,7 +189,7 @@ describe('useMetadataDiff', () => {
     )
 
     expect(fields.value.find((field) => field.key === 'audibleId')).toMatchObject({
-      label: 'Audible ID',
+      labelKey: 'book.detail.editMetadata.diff.providerIds.audible',
       bookValue: 'B0OLD12345',
       candidateDisplay: 'B0TEST12345',
     })
@@ -538,4 +538,84 @@ describe('useMetadataDiff', () => {
     const coverField = fields.value.find((f) => f.key === 'coverUrl')
     expect(coverField?.candidateDisplay).toBe(sameOriginCover)
   })
+
+  it('gives the cover row the lock, label and frame of the slot it fills, and reads the current cover live', () => {
+    const candidates = ref([mockCandidate1])
+    const activeProvider = ref<MetadataProviderKey>('google')
+    const currentCover = ref('')
+    const { fields, toggleField, buildPatch } = useMetadataDiff(
+      mockCurrent,
+      candidates,
+      activeProvider,
+      providers,
+      () => currentCover.value,
+      undefined,
+      ['audioCover'],
+      { coverMedium: 'audio', coverLabelKey: 'book.detail.editMetadata.diff.fields.audioCover' },
+    )
+
+    expect(fields.value.find((f) => f.key === 'coverUrl')).toMatchObject({
+      labelKey: 'book.detail.editMetadata.diff.fields.audioCover',
+      coverMedium: 'audio',
+      isLocked: true,
+      bookValue: '',
+    })
+    toggleField('coverUrl')
+    expect(buildPatch().coverUrl).toBeUndefined()
+
+    currentCover.value = '/api/v1/books/1/cover?medium=audio'
+    expect(fields.value.find((f) => f.key === 'coverUrl')?.bookValue).toBe('/api/v1/books/1/cover?medium=audio')
+  })
+
+  describe('cover shape', () => {
+    const hardcover: MetadataCandidate = { provider: 'hardcover', providerId: 'h1', title: 'The Silver Chair', coverUrl: '/covers/hardcover.jpg' }
+    const audible: MetadataCandidate = {
+      provider: 'audible',
+      providerId: 'a1',
+      title: 'The Silver Chair',
+      coverUrl: '/covers/audible.jpg',
+      coverShape: 'square',
+    }
+    const google: MetadataCandidate = {
+      provider: 'google',
+      providerId: 'g1',
+      title: 'The Silver Chair',
+      coverUrl: '/covers/google.jpg',
+      coverShape: 'portrait',
+    }
+    const measuredPortrait = (candidate: MetadataCandidate) => (candidate === hardcover ? 'portrait' : (candidate.coverShape ?? 'unknown'))
+
+    function audioDiff(currentCover: string) {
+      return useMetadataDiff(mockCurrent, [hardcover, google, audible], 'hardcover', communityRatingProviders, () => currentCover, undefined, [], {
+        coverMedium: 'audio',
+        coverShapeOf: measuredPortrait,
+      })
+    }
+
+    it('names the fit of the offered cover and lists square alternatives first for the audio slot', () => {
+      const { fields } = audioDiff('/api/v1/books/1/cover?medium=audio')
+      const cover = fields.value.find((f) => f.key === 'coverUrl')
+
+      expect(cover?.candidateCoverFit).toBe('mismatch')
+      expect(cover?.providerValues.map((value) => value.provider)).toEqual(['audible', 'hardcover', 'google'])
+    })
+
+    it('keeps Copy All from swapping a cover for art of the other shape, but the arrow still can', () => {
+      const { copyAll, buildPatch, toggleField } = audioDiff('/api/v1/books/1/cover?medium=audio')
+
+      copyAll()
+      expect(buildPatch().coverUrl).toBeUndefined()
+      expect(buildPatch().formPatch.title).toBe('The Silver Chair')
+
+      toggleField('coverUrl')
+      expect(buildPatch().coverUrl).toBe('/covers/hardcover.jpg')
+    })
+
+    it('lets Copy All fill an empty slot with art of the other shape', () => {
+      const { copyAll, buildPatch } = audioDiff('')
+
+      copyAll()
+      expect(buildPatch().coverUrl).toBe('/covers/hardcover.jpg')
+    })
+  })
 })
diff --git a/client/src/features/book/composables/__tests__/useMetadataEditor.spec.ts b/client/src/features/book/composables/__tests__/useMetadataEditor.spec.ts
index f43bdc3a4..ee8e75f36 100644
--- a/client/src/features/book/composables/__tests__/useMetadataEditor.spec.ts
+++ b/client/src/features/book/composables/__tests__/useMetadataEditor.spec.ts
@@ -34,6 +34,9 @@ function makeBook(overrides: Partial<BookDetail> = {}): BookDetail {
     personalNoteUpdatedAt: null,
     communityRatings: [],
     coverSource: null,
+    coverMedia: [],
+    covers: { ebook: null, audio: null },
+    coverVersion: 'legacy:2024-01-01T00:00:00.000Z',
     hardcoverEditionId: null,
     providerIds: {},
     authors: [],
diff --git a/client/src/features/book/composables/__tests__/useMetadataLocks.spec.ts b/client/src/features/book/composables/__tests__/useMetadataLocks.spec.ts
index 9b9c18f42..5f3b98dc8 100644
--- a/client/src/features/book/composables/__tests__/useMetadataLocks.spec.ts
+++ b/client/src/features/book/composables/__tests__/useMetadataLocks.spec.ts
@@ -1,5 +1,5 @@
 import { beforeEach, describe, expect, it, vi } from 'vitest'
-import type { BookDetail } from '@bookorbit/types'
+import { BOOK_METADATA_LOCK_FIELDS, type BookDetail } from '@bookorbit/types'
 
 import { useMetadataLocks } from '../useMetadataLocks'
 
@@ -9,6 +9,8 @@ vi.mock('@/lib/api', () => ({
   api: apiMock,
 }))
 
+const BOOK_FIELDS_WITHOUT_AUDIO_COVER = BOOK_METADATA_LOCK_FIELDS.filter((field) => field !== 'audioCover')
+
 function makeBook(overrides: Partial<BookDetail> = {}): BookDetail {
   return {
     id: 1,
@@ -35,6 +37,9 @@ function makeBook(overrides: Partial<BookDetail> = {}): BookDetail {
     personalNoteUpdatedAt: null,
     communityRatings: [],
     coverSource: null,
+    coverMedia: [],
+    covers: { ebook: null, audio: null },
+    coverVersion: 'legacy:2024-01-01T00:00:00.000Z',
     hardcoverEditionId: null,
     providerIds: {},
     authors: [],
@@ -94,7 +99,6 @@ describe('useMetadataLocks', () => {
   })
 
   it('lockAll sends every lockable field', async () => {
-    const { BOOK_METADATA_LOCK_FIELDS } = await import('@bookorbit/types')
     const allLocked = makeBook({ lockedFields: [...BOOK_METADATA_LOCK_FIELDS] })
     apiMock.mockResolvedValue({ ok: true, json: async () => allLocked })
 
@@ -103,6 +107,15 @@ describe('useMetadataLocks', () => {
 
     expect(result?.lockedFields).toHaveLength(BOOK_METADATA_LOCK_FIELDS.length)
     expect(areAllLocked.value).toBe(true)
+    const [, req] = apiMock.mock.calls[0] as [string, RequestInit]
+    expect(JSON.parse(String(req.body)).lockedFields).toEqual(expect.arrayContaining(['cover', 'audioCover']))
+  })
+
+  it('does not count a book as fully locked while its audiobook cover is unlocked', () => {
+    const { load, areAllLocked } = useMetadataLocks()
+    load(makeBook({ lockedFields: BOOK_FIELDS_WITHOUT_AUDIO_COVER }))
+
+    expect(areAllLocked.value).toBe(false)
   })
 
   it('unlockAll sends an empty lock set', async () => {
diff --git a/client/src/features/book/composables/__tests__/usePersonalNote.spec.ts b/client/src/features/book/composables/__tests__/usePersonalNote.spec.ts
index 578beae66..a99db0a26 100644
--- a/client/src/features/book/composables/__tests__/usePersonalNote.spec.ts
+++ b/client/src/features/book/composables/__tests__/usePersonalNote.spec.ts
@@ -36,6 +36,9 @@ function makeBook(overrides: Partial<BookDetail> = {}): BookDetail {
     personalNoteUpdatedAt: null,
     communityRatings: [],
     coverSource: null,
+    coverMedia: [],
+    covers: { ebook: null, audio: null },
+    coverVersion: 'legacy:2024-01-01T00:00:00.000Z',
     hardcoverEditionId: null,
     providerIds: {},
     authors: [],
diff --git a/client/src/features/book/composables/__tests__/useSecondCoverRow.spec.ts b/client/src/features/book/composables/__tests__/useSecondCoverRow.spec.ts
new file mode 100644
index 000000000..93680289f
--- /dev/null
+++ b/client/src/features/book/composables/__tests__/useSecondCoverRow.spec.ts
@@ -0,0 +1,89 @@
+// @vitest-environment node
+import { describe, expect, it } from 'vitest'
+import { ref } from 'vue'
+import type { MetadataCandidate, MetadataProviderKey } from '@bookorbit/types'
+import { useSecondCoverRow, type SecondCoverRowSource } from '../useSecondCoverRow'
+
+function candidate(provider: MetadataProviderKey, id: string, data: Partial<MetadataCandidate> = {}): MetadataCandidate {
+  return { provider, providerId: id, title: 'Dune', coverUrl: `/covers/${id}.jpg`, ...data }
+}
+
+function source(overrides: Partial<SecondCoverRowSource> = {}): SecondCoverRowSource {
+  return {
+    medium: 'audio',
+    candidates: [],
+    priority: ['audible', 'itunes', 'amazon'],
+    currentUrl: '',
+    locked: false,
+    ...overrides,
+  }
+}
+
+describe('useSecondCoverRow', () => {
+  it('offers the slot-shaped art of the highest-ranked provider first', () => {
+    const amazon = candidate('amazon', 'amazon-1', { coverShape: 'portrait' })
+    const itunes = candidate('itunes', 'itunes-1', { coverShape: 'square' })
+    const audible = candidate('audible', 'audible-1', { coverShape: 'square' })
+    const unknown = candidate('goodreads', 'goodreads-1')
+    const noCover = candidate('google', 'google-1', { coverUrl: undefined })
+    const { choices, active } = useSecondCoverRow(source({ candidates: [amazon, unknown, itunes, noCover, audible] }))
+
+    expect(choices.value).toEqual([audible, itunes, unknown, amazon])
+    expect(active.value).toBe(audible)
+  })
+
+  it('ranks art measured as the other shape last, and names its fit', () => {
+    const hardcover = candidate('hardcover', 'hardcover-1')
+    const goodreads = candidate('goodreads', 'goodreads-1')
+    const measured = (entry: MetadataCandidate) => (entry === hardcover ? 'portrait' : (entry.coverShape ?? 'unknown'))
+    const { choices, active, row, select } = useSecondCoverRow(
+      source({ priority: ['hardcover', 'goodreads'], candidates: [hardcover, goodreads] }),
+      measured,
+    )
+
+    expect(choices.value).toEqual([goodreads, hardcover])
+    expect(active.value).toBe(goodreads)
+    expect(row.value?.candidateCoverFit).toBe('unknown')
+
+    select(hardcover)
+    expect(row.value?.candidateCoverFit).toBe('mismatch')
+  })
+
+  it('keeps its pick apart from the selection, and a locked slot cannot be picked', () => {
+    const audible = candidate('audible', 'audible-1', { coverShape: 'square' })
+    const itunes = candidate('itunes', 'itunes-1', { coverShape: 'square' })
+    const locked = ref(false)
+    const row = useSecondCoverRow(() =>
+      source({ candidates: [audible, itunes], currentUrl: '/api/v1/books/1/cover?medium=audio', locked: locked.value }),
+    )
+
+    row.togglePick()
+    row.select(itunes)
+
+    expect(row.pickedCoverUrl.value).toBe('/covers/audible-1.jpg')
+    expect(row.row.value).toMatchObject({
+      key: 'secondCoverUrl',
+      labelKey: 'book.detail.editMetadata.diff.fields.audioCover',
+      coverMedium: 'audio',
+      isPicked: true,
+      pickedFromActive: false,
+      pickedProvider: 'audible',
+      bookValue: '/api/v1/books/1/cover?medium=audio',
+    })
+
+    row.togglePick()
+    expect(row.picked.value).toBe(itunes)
+
+    locked.value = true
+    row.togglePick()
+    expect(row.picked.value).toBe(itunes)
+    expect(row.row.value?.isLocked).toBe(true)
+  })
+
+  it('has no row without a second medium', () => {
+    const { row, choices } = useSecondCoverRow(null)
+
+    expect(row.value).toBeNull()
+    expect(choices.value).toEqual([])
+  })
+})
diff --git a/client/src/features/book/composables/__tests__/useTableCellEditor.spec.ts b/client/src/features/book/composables/__tests__/useTableCellEditor.spec.ts
index 1c00d7e64..2ca3110fc 100644
--- a/client/src/features/book/composables/__tests__/useTableCellEditor.spec.ts
+++ b/client/src/features/book/composables/__tests__/useTableCellEditor.spec.ts
@@ -36,6 +36,7 @@ function makeBook(overrides: Partial<BookCard> = {}): BookCard {
     readStatus: null,
     addedAt: '2024-01-01T00:00:00Z',
     updatedAt: null,
+    coverVersion: 'legacy:2024-01-01T00:00:00Z',
     metadataScore: null,
     hasCover: false,
     hasMetadataLocks: false,
diff --git a/client/src/features/book/composables/__tests__/useTableCellHelpers.spec.ts b/client/src/features/book/composables/__tests__/useTableCellHelpers.spec.ts
index 5e2b63994..d24427cef 100644
--- a/client/src/features/book/composables/__tests__/useTableCellHelpers.spec.ts
+++ b/client/src/features/book/composables/__tests__/useTableCellHelpers.spec.ts
@@ -35,6 +35,7 @@ function makeBook(overrides: Partial<BookCard> = {}): BookCard {
     readStatus: null,
     addedAt: '2025-01-01T00:00:00.000Z',
     updatedAt: null,
+    coverVersion: 'legacy:2025-01-01T00:00:00.000Z',
     metadataScore: null,
     hasCover: false,
     hasMetadataLocks: false,
diff --git a/client/src/features/book/composables/__tests__/useTableCoverDialog.spec.ts b/client/src/features/book/composables/__tests__/useTableCoverDialog.spec.ts
index 8d48a1df7..7557ee400 100644
--- a/client/src/features/book/composables/__tests__/useTableCoverDialog.spec.ts
+++ b/client/src/features/book/composables/__tests__/useTableCoverDialog.spec.ts
@@ -21,6 +21,7 @@ function makeBook(overrides: Partial<BookCard> = {}): BookCard {
     readStatus: null,
     addedAt: '2025-01-01T00:00:00.000Z',
     updatedAt: null,
+    coverVersion: 'legacy:2025-01-01T00:00:00.000Z',
     metadataScore: null,
     hasCover: false,
     hasMetadataLocks: false,
diff --git a/client/src/features/book/composables/__tests__/useTableQuickFilters.spec.ts b/client/src/features/book/composables/__tests__/useTableQuickFilters.spec.ts
index 5a57863fe..62ddc7d8a 100644
--- a/client/src/features/book/composables/__tests__/useTableQuickFilters.spec.ts
+++ b/client/src/features/book/composables/__tests__/useTableQuickFilters.spec.ts
@@ -1,6 +1,11 @@
-import { describe, it, expect } from 'vitest'
+import { beforeAll, describe, it, expect } from 'vitest'
+import { activateI18nLocale } from '@/i18n'
 import { useTableQuickFilters } from '../useTableQuickFilters'
 
+beforeAll(() => {
+  activateI18nLocale('en')
+})
+
 describe('useTableQuickFilters', () => {
   describe('getQuickFilterOptions', () => {
     it('returns empty array for non-library view types', () => {
@@ -22,11 +27,13 @@ describe('useTableQuickFilters', () => {
       expect(options[1]!.key).toBe('missing')
     })
 
-    it('returns cover presence options for cover column in library view', () => {
+    it('returns cover presence options, plus a missing audiobook cover option, for the cover column', () => {
       const { getQuickFilterOptions } = useTableQuickFilters('library')
-      const options = getQuickFilterOptions('cover')
-      expect(options).toHaveLength(2)
-      expect(options[0]!.label).toContain('cover')
+      expect(getQuickFilterOptions('cover')).toEqual([
+        { key: 'present', label: 'Filter to books with covers' },
+        { key: 'missing', label: 'Filter to books missing covers' },
+        { key: 'missingAudio', label: 'Filter to books missing audiobook covers' },
+      ])
     })
 
     it('returns present/missing options for title column', () => {
@@ -82,6 +89,11 @@ describe('useTableQuickFilters', () => {
       expect(rule).toEqual({ type: 'rule', field: 'cover', operator: 'isPresent' })
     })
 
+    it('returns audioCover isMissing rule for cover+missingAudio', () => {
+      const rule = buildQuickFilterRule('cover', 'missingAudio')
+      expect(rule).toEqual({ type: 'rule', field: 'audioCover', operator: 'isMissing' })
+    })
+
     it('returns title isEmpty rule for title+missing', () => {
       const rule = buildQuickFilterRule('title', 'missing')
       expect(rule).toEqual({ type: 'rule', field: 'title', operator: 'isEmpty' })
diff --git a/client/src/features/book/composables/useBookBulkActions.ts b/client/src/features/book/composables/useBookBulkActions.ts
index b7eb630db..0b16e251d 100644
--- a/client/src/features/book/composables/useBookBulkActions.ts
+++ b/client/src/features/book/composables/useBookBulkActions.ts
@@ -10,6 +10,8 @@ import {
   type ReadStatus,
   type UserBookStatus,
 } from '@bookorbit/types'
+import { i18n } from '@/i18n'
+import { formatNumber } from '@/i18n/formatters'
 import { api } from '@/lib/api'
 import { toast } from 'vue-sonner'
 import { useCoverVersions } from './useCoverVersions'
@@ -208,7 +210,7 @@ export function useBookBulkActions(
     const ids = querySelection?.value ? [] : [...selectedIds.value]
     const total = querySelection?.value ? querySelection.value.total : ids.length
     markRefreshing(ids)
-    inFlight.value = { label: 'Re-extracting covers', processed: 0, total }
+    inFlight.value = { label: i18n.global.t('book.coverRegeneration.bulkInProgress'), processed: 0, total }
     const res = await api('/api/v1/books/bulk-re-extract-cover', {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
@@ -217,7 +219,7 @@ export function useBookBulkActions(
     if (!res.ok) {
       clearRefreshing(ids)
       inFlight.value = null
-      toast.error('Failed to re-extract covers')
+      toast.error(i18n.global.t('book.coverRegeneration.bulkFailed'))
       return
     }
     const reader = res.body!.getReader()
@@ -237,7 +239,7 @@ export function useBookBulkActions(
               bumpedIds.add(data.bookId)
               bumpVersion(data.bookId)
               clearRefreshing([data.bookId])
-              inFlight.value = { label: 'Re-extracting covers', processed: inFlight.value!.processed + 1, total }
+              inFlight.value = { label: i18n.global.t('book.coverRegeneration.bulkInProgress'), processed: inFlight.value!.processed + 1, total }
             }
             if (data.done) {
               processed = data.processed
@@ -255,7 +257,7 @@ export function useBookBulkActions(
       clearRefreshing(ids)
       inFlight.value = null
     }
-    toast.success(`Re-extracted ${updated} of ${processed} cover${processed === 1 ? '' : 's'}`)
+    toast.success(i18n.global.t('book.coverRegeneration.bulkCompleted', { updated: formatNumber(updated), processed }))
   }
 
   async function handleDownloadFiles(scope: ExportScope) {
diff --git a/client/src/features/book/composables/useCoverEditor.ts b/client/src/features/book/composables/useCoverEditor.ts
index 6937f4842..56d3ce9e1 100644
--- a/client/src/features/book/composables/useCoverEditor.ts
+++ b/client/src/features/book/composables/useCoverEditor.ts
@@ -1,17 +1,30 @@
 import { onUnmounted, ref, type Ref } from 'vue'
+import { useI18n } from 'vue-i18n'
+import type { CoverMedium } from '@bookorbit/types'
 import { api } from '@/lib/api'
 import { useCoverVersions } from './useCoverVersions'
 import { toDisplayCoverUrl } from '../lib/metadata-fetch'
 
-export function useCoverEditor(bookId: Ref<number>) {
+/**
+ * One cover slot's pending image and writes. A book with both media gets one instance per slot;
+ * `medium` is null only for a book with no content files, whose writes the server routes itself.
+ */
+export function useCoverEditor(bookId: Ref<number>, medium: CoverMedium | null = null) {
   const uploading = ref(false)
+  const regenerating = ref(false)
   const error = ref<string | null>(null)
   const previewSrc = ref<string | null>(null)
   const pendingFile = ref<File | null>(null)
   const pendingUrl = ref<string | null>(null)
 
+  const { t } = useI18n()
   const { bumpVersion } = useCoverVersions()
 
+  function route(path: string): string {
+    const base = `/api/v1/books/${bookId.value}/${path}`
+    return medium ? `${base}?medium=${medium}` : base
+  }
+
   function selectFile(file: File) {
     clearPending()
     pendingFile.value = file
@@ -43,10 +56,10 @@ export function useCoverEditor(bookId: Ref<number>) {
       if (pendingFile.value) {
         const form = new FormData()
         form.append('file', pendingFile.value)
-        const res = await api(`/api/v1/books/${bookId.value}/cover`, { method: 'POST', body: form })
+        const res = await api(route('cover'), { method: 'POST', body: form })
         if (!res.ok) throw new Error(`HTTP ${res.status}`)
       } else {
-        const res = await api(`/api/v1/books/${bookId.value}/cover/from-url`, {
+        const res = await api(route('cover/from-url'), {
           method: 'POST',
           headers: { 'Content-Type': 'application/json' },
           body: JSON.stringify({ url: pendingUrl.value }),
@@ -56,8 +69,8 @@ export function useCoverEditor(bookId: Ref<number>) {
       bumpVersion(bookId.value)
       clearPending()
       return true
-    } catch (e) {
-      error.value = e instanceof Error ? e.message : 'Upload failed'
+    } catch {
+      error.value = t('book.detail.coverEditor.saveFailed')
       return false
     } finally {
       uploading.value = false
@@ -68,22 +81,38 @@ export function useCoverEditor(bookId: Ref<number>) {
     uploading.value = true
     error.value = null
     try {
-      const res = await api(`/api/v1/books/${bookId.value}/cover`, { method: 'DELETE' })
+      const res = await api(route('cover'), { method: 'DELETE' })
       if (!res.ok) throw new Error(`HTTP ${res.status}`)
       const data = await res.json()
       bumpVersion(bookId.value)
       return data.coverSource as 'extracted' | null
-    } catch (e) {
-      error.value = e instanceof Error ? e.message : 'Revert failed'
+    } catch {
+      error.value = t('book.detail.coverEditor.revertFailed')
       return false
     } finally {
       uploading.value = false
     }
   }
 
+  async function regenerate(): Promise<boolean> {
+    regenerating.value = true
+    error.value = null
+    try {
+      const res = await api(route('re-extract-cover'), { method: 'POST' })
+      if (!res.ok) throw new Error(`HTTP ${res.status}`)
+      bumpVersion(bookId.value)
+      return true
+    } catch {
+      error.value = t('book.coverRegeneration.failed')
+      return false
+    } finally {
+      regenerating.value = false
+    }
+  }
+
   onUnmounted(() => {
     if (previewSrc.value?.startsWith('blob:')) URL.revokeObjectURL(previewSrc.value)
   })
 
-  return { uploading, error, previewSrc, pendingFile, pendingUrl, selectFile, setUrl, clearPending, confirm, revert }
+  return { uploading, regenerating, error, previewSrc, pendingFile, pendingUrl, selectFile, setUrl, clearPending, confirm, revert, regenerate }
 }
diff --git a/client/src/features/book/composables/useCoverShapes.ts b/client/src/features/book/composables/useCoverShapes.ts
new file mode 100644
index 000000000..821f77d13
--- /dev/null
+++ b/client/src/features/book/composables/useCoverShapes.ts
@@ -0,0 +1,49 @@
+import { shallowReactive, toValue, watch, type MaybeRefOrGetter } from 'vue'
+import { coverShapeFromSize, type MetadataCandidate, type MetadataCoverShape } from '@bookorbit/types'
+import { toDisplayCoverUrl } from '../lib/metadata-fetch'
+import { statedCoverShape } from '../lib/cover-slots'
+
+/**
+ * Each candidate cover's shape: the provider's, or when it states none, the size of the image once
+ * the browser has loaded it. Hardcover leaves the size off some editions, and an audiobook edition's
+ * image is as often the print jacket as square art, so a stated-unknown cover can still be portrait.
+ */
+export function useCoverShapes(candidates: MaybeRefOrGetter<readonly MetadataCandidate[]>) {
+  const measured = shallowReactive(new Map<string, MetadataCoverShape>())
+  const pending = new Set<string>()
+
+  function measure(url: string) {
+    pending.add(url)
+    const image = new Image()
+    image.onload = () => {
+      pending.delete(url)
+      measured.set(url, coverShapeFromSize(image.naturalWidth, image.naturalHeight))
+    }
+    image.onerror = () => {
+      pending.delete(url)
+      measured.set(url, 'unknown')
+    }
+    image.src = url
+  }
+
+  watch(
+    () =>
+      toValue(candidates)
+        .filter((candidate) => statedCoverShape(candidate) === 'unknown')
+        .map((candidate) => toDisplayCoverUrl(candidate.coverUrl)),
+    (urls) => {
+      for (const url of urls) {
+        if (url && !measured.has(url) && !pending.has(url)) measure(url)
+      }
+    },
+    { immediate: true },
+  )
+
+  function shapeOf(candidate: MetadataCandidate): MetadataCoverShape {
+    const stated = statedCoverShape(candidate)
+    if (stated !== 'unknown') return stated
+    return measured.get(toDisplayCoverUrl(candidate.coverUrl)) ?? 'unknown'
+  }
+
+  return { shapeOf }
+}
diff --git a/client/src/features/book/composables/useCoverVersions.ts b/client/src/features/book/composables/useCoverVersions.ts
index 9f9903e56..044e243dd 100644
--- a/client/src/features/book/composables/useCoverVersions.ts
+++ b/client/src/features/book/composables/useCoverVersions.ts
@@ -1,6 +1,7 @@
+import type { CoverMedium } from '@bookorbit/types'
 import { ref } from 'vue'
 
-const STORAGE_KEY = 'cover-versions'
+const STORAGE_KEY = 'cover-versions-v2'
 type CoverVersionInput = number | string | Date | null | undefined
 
 function load(): Map<number, number> {
@@ -23,23 +24,24 @@ function persist(map: Map<number, number>) {
 
 const versions = ref<Map<number, number>>(load())
 
-function normalizeVersion(value: CoverVersionInput): number | undefined {
-  if (typeof value === 'number') return Number.isFinite(value) && value > 0 ? Math.trunc(value) : undefined
+function normalizeVersion(value: CoverVersionInput): string | undefined {
+  if (typeof value === 'number') return Number.isFinite(value) && value > 0 ? String(Math.trunc(value)) : undefined
   if (value instanceof Date) {
     const time = value.getTime()
-    return Number.isFinite(time) && time > 0 ? time : undefined
+    return Number.isFinite(time) && time > 0 ? String(time) : undefined
   }
   if (typeof value !== 'string') return undefined
 
   const trimmed = value.trim()
   if (!trimmed) return undefined
   const numeric = Number(trimmed)
-  if (Number.isFinite(numeric) && numeric > 0) return Math.trunc(numeric)
+  if (Number.isFinite(numeric) && numeric > 0) return String(Math.trunc(numeric))
   const parsed = Date.parse(trimmed)
-  return Number.isFinite(parsed) && parsed > 0 ? parsed : undefined
+  if (Number.isFinite(parsed) && parsed > 0) return String(parsed)
+  return trimmed
 }
 
-function versionToken(localVersion: number | undefined, serverVersion: number | undefined): string | undefined {
+function versionToken(localVersion: number | undefined, serverVersion: string | undefined): string | undefined {
   if (serverVersion !== undefined && localVersion !== undefined) return `${serverVersion}-${localVersion}`
   if (serverVersion !== undefined) return String(serverVersion)
   if (localVersion !== undefined) return String(localVersion)
@@ -57,12 +59,16 @@ export function useCoverVersions() {
     return versions.value.get(bookId)
   }
 
-  function coverUrl(bookId: number, type: 'thumbnail' | 'cover' = 'thumbnail', sourceVersion?: CoverVersionInput): string {
+  function coverUrl(bookId: number, type: 'thumbnail' | 'cover' = 'thumbnail', sourceVersion?: CoverVersionInput, medium?: CoverMedium): string {
     const base = `/api/v1/books/${bookId}/${type}`
     const localVersion = versions.value.get(bookId)
     const serverVersion = normalizeVersion(sourceVersion)
     const token = versionToken(localVersion, serverVersion)
-    return token ? `${base}?t=${token}` : base
+    const params = new URLSearchParams()
+    if (token) params.set('t', token)
+    if (medium) params.set('medium', medium)
+    const query = params.toString()
+    return query ? `${base}?${query}` : base
   }
 
   return { getVersion, bumpVersion, coverUrl }
diff --git a/client/src/features/book/composables/useGlobalSearch.test.ts b/client/src/features/book/composables/useGlobalSearch.test.ts
index facaa460f..c0bbe9bcf 100644
--- a/client/src/features/book/composables/useGlobalSearch.test.ts
+++ b/client/src/features/book/composables/useGlobalSearch.test.ts
@@ -37,6 +37,7 @@ function makeBook(id: number): BookCard {
     readStatus: null,
     addedAt: '2026-01-01T00:00:00.000Z',
     updatedAt: null,
+    coverVersion: 'legacy:2026-01-01T00:00:00.000Z',
     metadataScore: null,
     hasCover: false,
     hasMetadataLocks: false,
diff --git a/client/src/features/book/composables/useMetadataDiff.ts b/client/src/features/book/composables/useMetadataDiff.ts
index d48e03ae3..0d8868d99 100644
--- a/client/src/features/book/composables/useMetadataDiff.ts
+++ b/client/src/features/book/composables/useMetadataDiff.ts
@@ -3,7 +3,9 @@ import type {
   BookCommunityRating,
   BookMetadataLockField,
   ComicMetadataFields,
+  CoverMedium,
   MetadataCandidate,
+  MetadataCoverShape,
   MetadataProviderInfo,
   MetadataProviderKey,
   MetadataSeriesMembership,
@@ -13,6 +15,7 @@ import type {
 } from '@bookorbit/types'
 import { getProviderLabel, toDisplayCoverUrl } from '../lib/metadata-fetch'
 import { formatCommunityRatingLine, formatCommunityRatingValue } from '../lib/community-rating'
+import { COVER_FIT_RANK, coverFit, coverLockField, statedCoverShape, type CoverFit } from '../lib/cover-slots'
 
 type ComicDiffFieldKey =
   | 'comicIssueNumber'
@@ -47,6 +50,8 @@ export type DiffFieldKey =
   | 'durationSeconds'
   | 'abridged'
   | 'coverUrl'
+  /** The cover of a book's other medium, when it has two. */
+  | 'secondCoverUrl'
   | 'hardcoverEditionId'
   | ProviderIdPatchField
   | 'sourceUrl'
@@ -61,7 +66,8 @@ export interface ProviderFieldValue {
 
 export interface DiffField {
   key: DiffFieldKey
-  label: string
+  /** An i18n key; the row translates it. */
+  labelKey: string
   bookValue: string
   currentDisplay: string
   candidateDisplay: string
@@ -71,6 +77,10 @@ export interface DiffField {
   pickedProvider: MetadataProviderKey | null
   pickedDisplay: string
   isCover: boolean
+  /** The slot a cover row fills, which also sets the shape its frames take. */
+  coverMedium?: CoverMedium
+  /** How the offered cover's shape fits its slot; set on a cover row that offers one. */
+  candidateCoverFit?: CoverFit
   isLocked: boolean
   isCopyable: boolean
   providerValues: ProviderFieldValue[]
@@ -114,6 +124,15 @@ export interface MetadataPatch {
   customMetadata?: CustomMetadataBookValueInput[]
 }
 
+/** What the diff hands back: the form fields, plus a cover for each slot that was picked. */
+export interface MetadataDiffApply {
+  formPatch: MetadataPatch
+  /** For the ebook slot. */
+  coverUrl?: string
+  /** For the audio slot. */
+  audioCoverUrl?: string
+}
+
 export type GenreWriteMode = 'merge' | 'replace'
 
 export function mergeGenreLists(existing: readonly string[], incoming: readonly string[]): string[] {
@@ -131,47 +150,53 @@ export function mergeGenreLists(existing: readonly string[], incoming: readonly
   return merged
 }
 
-export const FIELD_DEFS: { key: DiffFieldKey; label: string }[] = [
-  { key: 'coverUrl', label: 'Cover' },
-  { key: 'title', label: 'Title' },
-  { key: 'subtitle', label: 'Subtitle' },
-  { key: 'authors', label: 'Authors' },
-  { key: 'description', label: 'Description' },
-  { key: 'publisher', label: 'Publisher' },
-  { key: 'publishedDate', label: 'Published' },
-  { key: 'language', label: 'Language' },
-  { key: 'pageCount', label: 'Page Count' },
-  { key: 'communityRating', label: 'Community Rating' },
-  { key: 'seriesName', label: 'Series' },
-  { key: 'seriesIndex', label: 'Series Index' },
-  { key: 'isbn13', label: 'ISBN-13' },
-  { key: 'isbn10', label: 'ISBN-10' },
-  { key: 'genres', label: 'Genres' },
-  { key: 'narrators', label: 'Narrators' },
-  { key: 'durationSeconds', label: 'Duration (seconds)' },
-  { key: 'abridged', label: 'Abridged' },
-  { key: 'hardcoverEditionId', label: 'Hardcover Edition ID' },
-]
+const FIELD_LABEL_PREFIX = 'book.detail.editMetadata.diff.fields'
+
+export const FIELD_DEFS: { key: DiffFieldKey; labelKey: string }[] = (
+  [
+    'coverUrl',
+    'title',
+    'subtitle',
+    'authors',
+    'description',
+    'publisher',
+    'publishedDate',
+    'language',
+    'pageCount',
+    'communityRating',
+    'seriesName',
+    'seriesIndex',
+    'isbn13',
+    'isbn10',
+    'genres',
+    'narrators',
+    'durationSeconds',
+    'abridged',
+    'hardcoverEditionId',
+  ] as const
+).map((key) => ({ key, labelKey: `${FIELD_LABEL_PREFIX}.${key}` }))
 
 export interface ComicFieldDef {
   key: ComicDiffFieldKey
-  label: string
+  labelKey: string
   comicKey: keyof ComicMetadataFields
 }
 
-export const COMIC_FIELD_DEFS: ComicFieldDef[] = [
-  { key: 'comicIssueNumber', label: 'Issue Number', comicKey: 'issueNumber' },
-  { key: 'comicVolumeName', label: 'Volume', comicKey: 'volumeName' },
-  { key: 'comicPencillers', label: 'Pencillers', comicKey: 'pencillers' },
-  { key: 'comicInkers', label: 'Inkers', comicKey: 'inkers' },
-  { key: 'comicColorists', label: 'Colorists', comicKey: 'colorists' },
-  { key: 'comicLetterers', label: 'Letterers', comicKey: 'letterers' },
-  { key: 'comicCoverArtists', label: 'Cover Artists', comicKey: 'coverArtists' },
-  { key: 'comicCharacters', label: 'Characters', comicKey: 'characters' },
-  { key: 'comicTeams', label: 'Teams', comicKey: 'teams' },
-  { key: 'comicLocations', label: 'Locations', comicKey: 'locations' },
-  { key: 'comicStoryArcs', label: 'Story Arcs', comicKey: 'storyArcs' },
-]
+export const COMIC_FIELD_DEFS: ComicFieldDef[] = (
+  [
+    ['comicIssueNumber', 'issueNumber'],
+    ['comicVolumeName', 'volumeName'],
+    ['comicPencillers', 'pencillers'],
+    ['comicInkers', 'inkers'],
+    ['comicColorists', 'colorists'],
+    ['comicLetterers', 'letterers'],
+    ['comicCoverArtists', 'coverArtists'],
+    ['comicCharacters', 'characters'],
+    ['comicTeams', 'teams'],
+    ['comicLocations', 'locations'],
+    ['comicStoryArcs', 'storyArcs'],
+  ] as const
+).map(([key, comicKey]) => ({ key, labelKey: `${FIELD_LABEL_PREFIX}.${key}`, comicKey }))
 
 export const COMIC_KEY_MAP: Record<ComicDiffFieldKey, keyof ComicMetadataFields> = Object.fromEntries(
   COMIC_FIELD_DEFS.map((d) => [d.key, d.comicKey]),
@@ -219,21 +244,9 @@ export function isProviderIdPatchField(key: DiffFieldKey): key is ProviderIdPatc
   return PROVIDER_ID_PATCH_FIELDS.has(key)
 }
 
-export const PROVIDER_ID_LABEL: Record<MetadataProviderKey, string> = {
-  google: 'Google Books ID',
-  goodreads: 'Goodreads ID',
-  amazon: 'Amazon ID',
-  hardcover: 'Hardcover ID',
-  openLibrary: 'Open Library ID',
-  itunes: 'iTunes ID',
-  audible: 'Audible ID',
-  audnexus: 'Audible ID',
-  librofm: 'Libro.fm ISBN',
-  comicvine: 'ComicVine ID',
-  ranobedb: 'RanobeDB ID',
-  kobo: 'Kobo ID',
-  lubimyczytac: 'LubimyCzytac ID',
-  aladin: 'Aladin ID',
+/** The i18n key naming each provider's id row. AudNexus stores an Audible id. */
+export function providerIdLabelKey(provider: MetadataProviderKey): string {
+  return `book.detail.editMetadata.diff.providerIds.${provider === 'audnexus' ? 'audible' : provider}`
 }
 
 export function getCandidateValueFrom(candidate: MetadataCandidate, key: DiffFieldKey): string {
@@ -272,22 +285,39 @@ function normalizeSeriesMemberships(values: readonly MetadataSeriesMembership[]
   return out
 }
 
+export interface MetadataDiffOptions {
+  /** The slot the cover row fills. Defaults to the ebook slot. */
+  coverMedium?: MaybeRefOrGetter<CoverMedium | undefined>
+  /** Overrides the cover row's label, for a book that shows one cover row per medium. */
+  coverLabelKey?: MaybeRefOrGetter<string | undefined>
+  /** A candidate cover's shape. Defaults to the shape its provider states. */
+  coverShapeOf?: (candidate: MetadataCandidate) => MetadataCoverShape
+}
+
 export function useMetadataDiff(
   current: MetadataSource,
   candidates: MaybeRefOrGetter<MetadataCandidate[]>,
   activeProvider: MaybeRefOrGetter<MetadataProviderKey>,
   providerInfos: MaybeRefOrGetter<MetadataProviderInfo[]>,
-  currentCoverUrl?: string,
+  currentCoverUrl?: MaybeRefOrGetter<string | undefined>,
   providerIds?: MaybeRefOrGetter<ProviderIds | undefined>,
   lockedFields?: MaybeRefOrGetter<readonly BookMetadataLockField[] | undefined>,
+  options: MetadataDiffOptions = {},
 ) {
   const pickedSources = reactive(new Map<DiffFieldKey, MetadataProviderKey>())
   const pickedCommunityRatingProviders = reactive(new Set<MetadataProviderKey>())
   const genreWriteMode = ref<GenreWriteMode>('merge')
   const lockedFieldSet = computed(() => new Set(toValue(lockedFields) ?? []))
+  const coverMedium = computed<CoverMedium>(() => toValue(options.coverMedium) ?? 'ebook')
+  const coverShapeOf = options.coverShapeOf ?? statedCoverShape
+
+  function candidateCoverFit(candidate: MetadataCandidate): CoverFit {
+    return coverFit(coverShapeOf(candidate), coverMedium.value)
+  }
 
   function resolveLockField(key: DiffFieldKey): BookMetadataLockField | null {
-    if (key === 'coverUrl') return 'cover'
+    if (key === 'coverUrl') return coverLockField(coverMedium.value)
+    if (key === 'secondCoverUrl') return coverLockField(coverMedium.value === 'audio' ? 'ebook' : 'audio')
     if (key === 'sourceUrl') return null
     if (key === 'publishedDate') return 'publishedYear'
     return key
@@ -298,7 +328,7 @@ export function useMetadataDiff(
     if (key === 'authors') return current.authors.join(', ')
     if (key === 'genres') return current.genres.join(', ')
     if (key === 'narrators') return current.narrators?.join(', ') ?? ''
-    if (key === 'coverUrl') return currentCoverUrl ?? ''
+    if (key === 'coverUrl') return toValue(currentCoverUrl) ?? ''
     if (key === 'communityRating') {
       const ap = toValue(activeProvider)
       const existing = current.communityRatings?.find((r) => r.provider === ap)
@@ -312,7 +342,7 @@ export function useMetadataDiff(
   function buildProviderValues(key: DiffFieldKey): ProviderFieldValue[] {
     const allCandidates = toValue(candidates)
     const infos = toValue(providerInfos)
-    const result: ProviderFieldValue[] = []
+    const result: { value: ProviderFieldValue; fitRank: number }[] = []
     const seenProviders = new Set<MetadataProviderKey>()
 
     for (const c of allCandidates) {
@@ -321,17 +351,20 @@ export function useMetadataDiff(
       const display = getCandidateValueFrom(c, key)
       if (!display) continue
       result.push({
-        provider: c.provider,
-        label: getProviderLabel(c.provider, infos),
-        display,
-        isPicked: key === 'communityRating' ? pickedCommunityRatingProviders.has(c.provider) : pickedSources.get(key) === c.provider,
+        value: {
+          provider: c.provider,
+          label: getProviderLabel(c.provider, infos),
+          display,
+          isPicked: key === 'communityRating' ? pickedCommunityRatingProviders.has(c.provider) : pickedSources.get(key) === c.provider,
+        },
+        fitRank: key === 'coverUrl' ? COVER_FIT_RANK[candidateCoverFit(c)] : 0,
       })
     }
 
-    return result
+    return result.sort((a, b) => a.fitRank - b.fitRank).map(({ value }) => value)
   }
 
-  function makeRow(key: DiffFieldKey, label: string): DiffField | null {
+  function makeRow(key: DiffFieldKey, labelKey: string): DiffField | null {
     const allCandidates = toValue(candidates)
     const ap = toValue(activeProvider)
     const activeCandidate = allCandidates.find((c) => c.provider === ap)
@@ -380,7 +413,7 @@ export function useMetadataDiff(
 
     return {
       key,
-      label,
+      labelKey: key === 'coverUrl' ? (toValue(options.coverLabelKey) ?? labelKey) : labelKey,
       bookValue: bookVal,
       currentDisplay: isPicked ? pickedDisplay : bookVal,
       candidateDisplay: candidateVal,
@@ -390,6 +423,8 @@ export function useMetadataDiff(
       pickedProvider,
       pickedDisplay,
       isCover: key === 'coverUrl',
+      ...(key === 'coverUrl' ? { coverMedium: coverMedium.value } : {}),
+      ...(key === 'coverUrl' && activeCandidate && candidateVal ? { candidateCoverFit: candidateCoverFit(activeCandidate) } : {}),
       isLocked: lockField ? lockedFieldSet.value.has(lockField) : false,
       isCopyable: true,
       providerValues: buildProviderValues(key),
@@ -404,13 +439,13 @@ export function useMetadataDiff(
     const activeCandidate = allCandidates.find((c) => c.provider === ap)
 
     for (const def of FIELD_DEFS) {
-      const row = makeRow(def.key, def.label)
+      const row = makeRow(def.key, def.labelKey)
       if (row) rows.push(row)
     }
 
     if (activeCandidate?.comicMetadata) {
       for (const def of COMIC_FIELD_DEFS) {
-        const row = makeRow(def.key, def.label)
+        const row = makeRow(def.key, def.labelKey)
         if (row) rows.push(row)
       }
     }
@@ -427,7 +462,7 @@ export function useMetadataDiff(
 
       rows.push({
         key: providerIdKey,
-        label: PROVIDER_ID_LABEL[ap] ?? 'Provider ID',
+        labelKey: providerIdLabelKey(ap),
         bookValue: existingProviderId ?? '',
         currentDisplay: pickedFromActive ? pickedDisplay : (existingProviderId ?? ''),
         candidateDisplay: activeProviderIdVal,
@@ -446,7 +481,7 @@ export function useMetadataDiff(
     if (activeCandidate?.sourceUrl) {
       rows.push({
         key: 'sourceUrl',
-        label: 'Source URL',
+        labelKey: `${FIELD_LABEL_PREFIX}.sourceUrl`,
         bookValue: '',
         currentDisplay: '',
         candidateDisplay: activeCandidate.sourceUrl,
@@ -496,10 +531,12 @@ export function useMetadataDiff(
     }
   }
 
+  /** Like the automatic fetch, a bulk copy never swaps a cover for art of the other shape; the row's own arrow still can. */
   function copyAll() {
     const ap = toValue(activeProvider)
     for (const f of fields.value) {
       if (!f.isCopyable || f.isLocked) continue
+      if (f.isCover && f.bookValue && f.candidateCoverFit === 'mismatch') continue
       if (f.key === 'communityRating') pickedCommunityRatingProviders.add(ap)
       else pickedSources.set(f.key, ap)
     }
diff --git a/client/src/features/book/composables/useMetadataSearch.ts b/client/src/features/book/composables/useMetadataSearch.ts
index 569c2d715..9fdb529de 100644
--- a/client/src/features/book/composables/useMetadataSearch.ts
+++ b/client/src/features/book/composables/useMetadataSearch.ts
@@ -18,6 +18,8 @@ export interface SearchParams {
   isAudiobook?: boolean
   /** Narrows the search to the providers that serve one medium; the server derives isAudiobook from it. */
   mediaKind?: ConcreteBookMediaKind
+  /** Asks exactly these providers, whatever the provider filter holds. */
+  providers?: MetadataProviderKey[]
 }
 
 export function useMetadataSearch() {
@@ -67,7 +69,7 @@ export function useMetadataSearch() {
     if (params.isAudiobook != null) query.set('isAudiobook', String(params.isAudiobook))
     if (params.mediaKind) query.set('mediaKind', params.mediaKind)
     const onlyProvider = providers.value.length === 1 ? providers.value[0] : undefined
-    const requestedProviders = selectedProviders.value.length ? selectedProviders.value : onlyProvider ? [onlyProvider.key] : []
+    const requestedProviders = params.providers ?? (selectedProviders.value.length ? selectedProviders.value : onlyProvider ? [onlyProvider.key] : [])
     if (requestedProviders.length) query.set('providers', requestedProviders.join(','))
 
     try {
@@ -158,12 +160,15 @@ export function useMetadataSearch() {
     return sortResults(filtered)
   })
 
-  const coverProviderOrder = computed(() =>
-    providers.value
-      .filter((provider) => provider.coverPriority !== undefined)
-      .sort((a, b) => a.coverPriority! - b.coverPriority!)
-      .map((provider) => provider.key),
-  )
+  const coverProviderOrder = computed(() => providerOrderBy('coverPriority'))
+  const audioCoverProviderOrder = computed(() => providerOrderBy('audioCoverPriority'))
+
+  function providerOrderBy(priority: 'coverPriority' | 'audioCoverPriority'): MetadataProviderKey[] {
+    return providers.value
+      .filter((provider) => provider[priority] !== undefined)
+      .sort((a, b) => a[priority]! - b[priority]!)
+      .map((provider) => provider.key)
+  }
 
   const resultProviderOrder = computed(() => {
     const available = new Set(providers.value.map((provider) => provider.key))
@@ -202,8 +207,10 @@ export function useMetadataSearch() {
   )
 
   return {
+    results,
     filteredResults,
     coverProviderOrder,
+    audioCoverProviderOrder,
     resultProviderOrder,
     providerCounts,
     providerStatuses,
diff --git a/client/src/features/book/composables/useSecondCoverRow.ts b/client/src/features/book/composables/useSecondCoverRow.ts
new file mode 100644
index 000000000..f1b3edc19
--- /dev/null
+++ b/client/src/features/book/composables/useSecondCoverRow.ts
@@ -0,0 +1,102 @@
+import { computed, shallowRef, toValue, type MaybeRefOrGetter } from 'vue'
+import type { CoverMedium, MetadataCandidate, MetadataCoverShape, MetadataProviderKey } from '@bookorbit/types'
+import { toDisplayCoverUrl } from '../lib/metadata-fetch'
+import { COVER_FIT_RANK, coverFit, statedCoverShape } from '../lib/cover-slots'
+import type { DiffField } from './useMetadataDiff'
+
+/** What the diff panel is given for the other medium's cover row. */
+export interface SecondCoverInput {
+  medium: CoverMedium
+  candidates: MetadataCandidate[]
+  priority: MetadataProviderKey[]
+  currentUrl: string
+  searching: boolean
+}
+
+export interface SecondCoverRowSource {
+  medium: CoverMedium
+  /** Results of the search run as this medium, in arrival order. */
+  candidates: MetadataCandidate[]
+  /** Providers in the order the slot's field rule ranks them for covers. */
+  priority: MetadataProviderKey[]
+  /** The slot's current cover, or '' when the slot is empty. */
+  currentUrl: string
+  locked: boolean
+}
+
+/**
+ * The cover row for a book's other medium, fed by a search of its own. It keeps its own candidates,
+ * selection and pick apart from the main rows: iTunes, Hardcover and Amazon answer both searches,
+ * and a pick keyed by provider would let one list overwrite the other's.
+ */
+export function useSecondCoverRow(
+  source: MaybeRefOrGetter<SecondCoverRowSource | null>,
+  shapeOf: (candidate: MetadataCandidate) => MetadataCoverShape = statedCoverShape,
+) {
+  // Shallow, so a candidate is compared by identity with the list it came from, not with a proxy of it.
+  const chosen = shallowRef<MetadataCandidate | null>(null)
+  const picked = shallowRef<MetadataCandidate | null>(null)
+
+  /** Art of the slot's shape first, each group in the field rule's order, so the default is the rule's best fit. */
+  const choices = computed<MetadataCandidate[]>(() => {
+    const current = toValue(source)
+    if (!current) return []
+    const rank = new Map(current.priority.map((provider, index) => [provider, index]))
+    const fitRank = (candidate: MetadataCandidate) => COVER_FIT_RANK[coverFit(shapeOf(candidate), current.medium)]
+    return current.candidates
+      .map((candidate, index) => ({ candidate, index }))
+      .filter(({ candidate }) => toDisplayCoverUrl(candidate.coverUrl))
+      .sort(
+        (a, b) =>
+          fitRank(a.candidate) - fitRank(b.candidate) ||
+          (rank.get(a.candidate.provider) ?? Number.MAX_SAFE_INTEGER) - (rank.get(b.candidate.provider) ?? Number.MAX_SAFE_INTEGER) ||
+          a.index - b.index,
+      )
+      .map(({ candidate }) => candidate)
+  })
+
+  const active = computed<MetadataCandidate | null>(() => {
+    const selected = chosen.value
+    if (selected && choices.value.includes(selected)) return selected
+    return choices.value[0] ?? null
+  })
+
+  const row = computed<DiffField | null>(() => {
+    const current = toValue(source)
+    if (!current) return null
+    const candidateDisplay = toDisplayCoverUrl(active.value?.coverUrl)
+    const pickedDisplay = toDisplayCoverUrl(picked.value?.coverUrl)
+    const isPicked = picked.value !== null
+    return {
+      key: 'secondCoverUrl',
+      labelKey: `book.detail.editMetadata.diff.fields.${current.medium === 'audio' ? 'audioCover' : 'bookCover'}`,
+      bookValue: current.currentUrl,
+      currentDisplay: isPicked ? pickedDisplay : current.currentUrl,
+      candidateDisplay,
+      hasDiff: current.currentUrl !== candidateDisplay,
+      isPicked,
+      pickedFromActive: isPicked && picked.value === active.value,
+      pickedProvider: picked.value?.provider ?? null,
+      pickedDisplay,
+      isCover: true,
+      coverMedium: current.medium,
+      ...(active.value && candidateDisplay ? { candidateCoverFit: coverFit(shapeOf(active.value), current.medium) } : {}),
+      isLocked: current.locked,
+      isCopyable: true,
+      providerValues: [],
+    }
+  })
+
+  function select(candidate: MetadataCandidate) {
+    chosen.value = candidate
+  }
+
+  function togglePick() {
+    if (toValue(source)?.locked || !active.value) return
+    picked.value = picked.value === active.value ? null : active.value
+  }
+
+  const pickedCoverUrl = computed(() => picked.value?.coverUrl)
+
+  return { choices, active, row, picked, pickedCoverUrl, select, togglePick }
+}
diff --git a/client/src/features/book/composables/useTableQuickFilters.ts b/client/src/features/book/composables/useTableQuickFilters.ts
index 64f66e8c2..618406543 100644
--- a/client/src/features/book/composables/useTableQuickFilters.ts
+++ b/client/src/features/book/composables/useTableQuickFilters.ts
@@ -1,4 +1,9 @@
 import type { Rule, StaticRuleField, TableViewType } from '@bookorbit/types'
+import { i18n } from '@/i18n'
+
+// Resolved through the global composer because this runs outside a component setup; the template
+// that calls it still re-renders on a language change.
+const t = i18n.global.t
 
 type QuickFilterField = Exclude<StaticRuleField, 'communityRating' | 'communityRatingCount'>
 
@@ -29,15 +34,16 @@ export function useTableQuickFilters(viewType: TableViewType) {
 
     if (colId === 'format') {
       return [
-        { key: 'present', label: 'Filter to present files' },
-        { key: 'missing', label: 'Filter to missing files' },
+        { key: 'present', label: t('book.table.quickFilter.presentFiles') },
+        { key: 'missing', label: t('book.table.quickFilter.missingFiles') },
       ]
     }
 
     if (colId === 'cover') {
       return [
-        { key: 'present', label: 'Filter to books with covers' },
-        { key: 'missing', label: 'Filter to books missing covers' },
+        { key: 'present', label: t('book.table.quickFilter.withCovers') },
+        { key: 'missing', label: t('book.table.quickFilter.missingCovers') },
+        { key: 'missingAudio', label: t('book.table.quickFilter.missingAudioCovers') },
       ]
     }
 
@@ -61,8 +67,8 @@ export function useTableQuickFilters(viewType: TableViewType) {
       ].includes(colId)
     ) {
       return [
-        { key: 'present', label: 'Filter to rows with values' },
-        { key: 'missing', label: 'Filter to empty rows' },
+        { key: 'present', label: t('book.table.quickFilter.withValues') },
+        { key: 'missing', label: t('book.table.quickFilter.emptyRows') },
       ]
     }
 
@@ -71,6 +77,7 @@ export function useTableQuickFilters(viewType: TableViewType) {
 
   function buildQuickFilterRule(colId: string, key: string): Rule | null {
     if (colId === 'format') return { type: 'rule', field: 'fileAvailability', operator: key === 'missing' ? 'isMissing' : 'isPresent' }
+    if (colId === 'cover' && key === 'missingAudio') return { type: 'rule', field: 'audioCover', operator: 'isMissing' }
     if (colId === 'cover') return { type: 'rule', field: 'cover', operator: key === 'missing' ? 'isMissing' : 'isPresent' }
 
     const textField = TEXT_FIELD_MAP[colId]
diff --git a/client/src/features/book/lib/__tests__/cover-slots.spec.ts b/client/src/features/book/lib/__tests__/cover-slots.spec.ts
new file mode 100644
index 000000000..59faba414
--- /dev/null
+++ b/client/src/features/book/lib/__tests__/cover-slots.spec.ts
@@ -0,0 +1,84 @@
+// @vitest-environment node
+import { describe, expect, it } from 'vitest'
+import type { BookCoverSlot, BookDetail } from '@bookorbit/types'
+import { coverFieldMedium, coverFit, coverLockField, coverTileState, editorTiles, faceMedium, isLegacyCover, otherMedium } from '../cover-slots'
+
+type SlotBook = Pick<BookDetail, 'coverMedia' | 'covers' | 'coverSource' | 'coverVersion'>
+
+function slot(source: BookCoverSlot['source'], updatedAt: string): BookCoverSlot {
+  return { source, updatedAt, width: null, height: null }
+}
+
+function book(overrides: Partial<SlotBook> = {}): SlotBook {
+  return { coverMedia: ['ebook', 'audio'], covers: { ebook: null, audio: null }, coverSource: null, coverVersion: 'v', ...overrides }
+}
+
+describe('cover slots', () => {
+  it('names the other medium and each slot lock', () => {
+    expect(otherMedium('ebook')).toBe('audio')
+    expect(otherMedium('audio')).toBe('ebook')
+    expect(coverLockField('ebook')).toBe('cover')
+    expect(coverLockField('audio')).toBe('audioCover')
+    expect(coverLockField(null)).toBe('cover')
+  })
+
+  it('picks the face by library shape, falling back to the filled slot', () => {
+    const both = book({ covers: { ebook: slot('extracted', 'a'), audio: slot('extracted', 'b') } })
+    expect(faceMedium(both, '2/3')).toBe('ebook')
+    expect(faceMedium(both, '1/1')).toBe('audio')
+
+    const audioOnly = book({ covers: { ebook: null, audio: slot('extracted', 'b') } })
+    expect(faceMedium(audioOnly, '2/3')).toBe('audio')
+
+    expect(faceMedium(book(), '1/1')).toBe('audio')
+  })
+
+  it('gives one tile per medium, and one unnamed tile for a book with no content files', () => {
+    expect(editorTiles(book({ coverMedia: ['audio', 'ebook'] }))).toEqual(['ebook', 'audio'])
+    expect(editorTiles(book({ coverMedia: ['audio'] }))).toEqual(['audio'])
+    expect(editorTiles(book({ coverMedia: [] }))).toEqual([null])
+  })
+
+  it('sends a metadata cover to the ebook slot unless the book has no ebook', () => {
+    expect(coverFieldMedium(book())).toBe('ebook')
+    expect(coverFieldMedium(book({ coverMedia: ['audio'] }))).toBe('audio')
+    expect(coverFieldMedium(book({ coverMedia: [] }))).toBeNull()
+  })
+
+  it('recognises a cover the upgrade has not moved into a slot', () => {
+    expect(isLegacyCover(book({ coverSource: 'custom' }))).toBe(true)
+    expect(isLegacyCover(book({ coverSource: 'custom', covers: { ebook: slot('custom', 'a'), audio: null } }))).toBe(false)
+    expect(isLegacyCover(book())).toBe(false)
+  })
+
+  it('describes a filled slot from the slot itself', () => {
+    const state = coverTileState(book({ coverSource: 'custom', covers: { ebook: null, audio: slot('custom', 'b') } }), 'audio', '2/3')
+    expect(state).toEqual({ hasImage: true, source: 'custom', version: 'b' })
+  })
+
+  it('shows an empty slot as empty', () => {
+    const state = coverTileState(book({ coverSource: 'extracted', covers: { ebook: slot('extracted', 'a'), audio: null } }), 'audio', '2/3')
+    expect(state).toEqual({ hasImage: false, source: null, version: 'v' })
+  })
+
+  it('puts a legacy cover on the face tile of a two-slot book, and on the only tile otherwise', () => {
+    const legacy = book({ coverSource: 'custom', coverVersion: 'legacy:1' })
+    expect(coverTileState(legacy, 'ebook', '2/3').hasImage).toBe(true)
+    expect(coverTileState(legacy, 'audio', '2/3').hasImage).toBe(false)
+    expect(coverTileState(legacy, 'audio', '1/1')).toEqual({ hasImage: true, source: 'custom', version: 'legacy:1' })
+
+    const audioOnly = book({ coverMedia: ['audio'], coverSource: 'extracted', coverVersion: 'legacy:1' })
+    expect(coverTileState(audioOnly, 'audio', '2/3').hasImage).toBe(true)
+
+    const noFiles = book({ coverMedia: [], coverSource: 'extracted' })
+    expect(coverTileState(noFiles, null, '2/3').hasImage).toBe(true)
+  })
+
+  it('fits square art to the audio slot and portrait art to the ebook slot', () => {
+    expect(coverFit('square', 'audio')).toBe('match')
+    expect(coverFit('portrait', 'audio')).toBe('mismatch')
+    expect(coverFit('portrait', 'ebook')).toBe('match')
+    expect(coverFit('square', 'ebook')).toBe('mismatch')
+    expect(coverFit('unknown', 'audio')).toBe('unknown')
+  })
+})
diff --git a/client/src/features/book/lib/__tests__/metadata-refresh-feedback.spec.ts b/client/src/features/book/lib/__tests__/metadata-refresh-feedback.spec.ts
index 1a3e21ed5..353c584ee 100644
--- a/client/src/features/book/lib/__tests__/metadata-refresh-feedback.spec.ts
+++ b/client/src/features/book/lib/__tests__/metadata-refresh-feedback.spec.ts
@@ -28,6 +28,9 @@ function makeBook(overrides: Partial<BookDetail> = {}): BookDetail {
     personalNoteUpdatedAt: null,
     communityRatings: [],
     coverSource: null,
+    coverMedia: [],
+    covers: { ebook: null, audio: null },
+    coverVersion: 'legacy:2024-01-01T00:00:00.000Z',
     hardcoverEditionId: null,
     providerIds: {},
     authors: [{ id: 1, name: 'Hanya Yanagihara', sortName: null }],
diff --git a/client/src/features/book/lib/__tests__/write-back-fields.spec.ts b/client/src/features/book/lib/__tests__/write-back-fields.spec.ts
new file mode 100644
index 000000000..1ff490a3f
--- /dev/null
+++ b/client/src/features/book/lib/__tests__/write-back-fields.spec.ts
@@ -0,0 +1,51 @@
+// @vitest-environment node
+import { describe, expect, it } from 'vitest'
+import type { BookCoverSlot, BookDetail } from '@bookorbit/types'
+
+import { resolveWriteBackFields } from '../write-back-fields'
+
+function slot(source: BookCoverSlot['source']): BookCoverSlot {
+  return { source, updatedAt: '2026-01-01T00:00:00.000Z', width: 400, height: 600 }
+}
+
+function book(overrides: Partial<BookDetail>): BookDetail {
+  return {
+    coverSource: null,
+    covers: { ebook: null, audio: null },
+    files: [],
+    ...overrides,
+  } as BookDetail
+}
+
+function coverValue(detail: BookDetail): string | null {
+  return resolveWriteBackFields(detail, ['coverBytes'])[0]!.value
+}
+
+describe('write-back cover preview', () => {
+  it('shows the book cover for an EPUB write, not the summary of both slots', () => {
+    const detail = book({
+      coverSource: 'custom',
+      covers: { ebook: slot('extracted'), audio: slot('custom') },
+      files: [
+        { format: 'epub', role: 'primary' },
+        { format: 'm4b', role: 'content' },
+      ] as BookDetail['files'],
+    })
+
+    expect(coverValue(detail)).toBe('extracted')
+  })
+
+  it('shows the audiobook cover for an audio write, and nothing when that slot is empty', () => {
+    const files = [
+      { format: 'm4b', role: 'primary' },
+      { format: 'epub', role: 'content' },
+    ] as BookDetail['files']
+
+    expect(coverValue(book({ covers: { ebook: slot('extracted'), audio: slot('custom') }, files }))).toBe('custom')
+    expect(coverValue(book({ coverSource: 'extracted', covers: { ebook: slot('extracted'), audio: null }, files }))).toBeNull()
+  })
+
+  it('falls back to the single legacy cover of a book the upgrade has not reached', () => {
+    expect(coverValue(book({ coverSource: 'custom', files: [{ format: 'epub', role: 'primary' }] as BookDetail['files'] }))).toBe('custom')
+  })
+})
diff --git a/client/src/features/book/lib/book-card-mapper.ts b/client/src/features/book/lib/book-card-mapper.ts
index c67460d45..f375fdac2 100644
--- a/client/src/features/book/lib/book-card-mapper.ts
+++ b/client/src/features/book/lib/book-card-mapper.ts
@@ -35,6 +35,7 @@ export function mergeBookCardWithDetail(book: BookCard, detail: BookDetail): Boo
     readStatus: detail.readStatus,
     metadataScore: detail.metadataScore,
     hasCover: detail.coverSource !== null,
+    coverVersion: detail.coverVersion,
     hasMetadataLocks: detail.lockedFields.length > 0,
     lockedFields: detail.lockedFields,
     narrators: detail.audioMetadata?.narrators.map((narrator) => narrator.name) ?? [],
@@ -94,7 +95,7 @@ export function detectChangedColumns(previous: BookCard, next: BookCard): Column
   if (previous.updatedAt !== next.updatedAt) changed.add('updatedAt')
   if (previous.addedAt !== next.addedAt) changed.add('addedAt')
   if (previous.status !== next.status) changed.add('read')
-  if (previous.hasCover !== next.hasCover || !sameFiles(previous.files, next.files)) {
+  if (previous.hasCover !== next.hasCover || previous.coverVersion !== next.coverVersion || !sameFiles(previous.files, next.files)) {
     changed.add('cover')
     changed.add('format')
     changed.add('fileSize')
diff --git a/client/src/features/book/lib/cover-fill-artwork.spec.ts b/client/src/features/book/lib/cover-fill-artwork.spec.ts
new file mode 100644
index 000000000..5e52f4877
--- /dev/null
+++ b/client/src/features/book/lib/cover-fill-artwork.spec.ts
@@ -0,0 +1,58 @@
+import { afterEach, describe, expect, it, vi } from 'vitest'
+
+import { createCoverFillArtworkUrl } from './cover-fill-artwork'
+
+describe('createCoverFillArtworkUrl', () => {
+  afterEach(() => {
+    vi.unstubAllGlobals()
+    vi.restoreAllMocks()
+  })
+
+  it('draws a blurred fill and a contained foreground into a square blob', async () => {
+    class LoadedImage {
+      decoding = ''
+      naturalWidth = 200
+      naturalHeight = 400
+      onload: (() => void) | null = null
+      onerror: (() => void) | null = null
+
+      set src(_value: string) {
+        queueMicrotask(() => this.onload?.())
+      }
+    }
+
+    const drawImage = vi.fn<(image: CanvasImageSource, ...coordinates: number[]) => void>()
+    const context = {
+      drawImage,
+      fillRect: vi.fn<(x: number, y: number, width: number, height: number) => void>(),
+      restore: vi.fn<() => void>(),
+      save: vi.fn<() => void>(),
+      fillStyle: '',
+      filter: '',
+    }
+    const canvas = {
+      width: 0,
+      height: 0,
+      getContext: vi.fn<() => typeof context>().mockReturnValue(context),
+      toBlob: vi.fn<(callback: BlobCallback) => void>().mockImplementation((callback) => callback(new Blob(['artwork'], { type: 'image/jpeg' }))),
+    }
+    const createElement = document.createElement.bind(document)
+
+    vi.stubGlobal('Image', LoadedImage)
+    vi.spyOn(document, 'createElement').mockImplementation((tagName: string, options?: ElementCreationOptions) => {
+      if (tagName === 'canvas') return canvas as unknown as HTMLCanvasElement
+      return createElement(tagName, options)
+    })
+    vi.stubGlobal('URL', {
+      ...URL,
+      createObjectURL: vi.fn<(object: Blob | MediaSource) => string>().mockReturnValue('blob:cover-artwork'),
+      revokeObjectURL: vi.fn<(url: string) => void>(),
+    })
+
+    await expect(createCoverFillArtworkUrl('/api/v1/books/42/cover', 512)).resolves.toBe('blob:cover-artwork')
+    expect(canvas).toMatchObject({ width: 512, height: 512 })
+    expect(drawImage).toHaveBeenCalledTimes(2)
+    expect(drawImage.mock.calls[0]?.[1]).toBeLessThan(0)
+    expect(drawImage.mock.calls[1]?.slice(1)).toEqual([128, 0, 256, 512])
+  })
+})
diff --git a/client/src/features/book/lib/cover-fill-artwork.ts b/client/src/features/book/lib/cover-fill-artwork.ts
new file mode 100644
index 000000000..8f8c1e165
--- /dev/null
+++ b/client/src/features/book/lib/cover-fill-artwork.ts
@@ -0,0 +1,54 @@
+const DEFAULT_ARTWORK_SIZE = 512
+
+function loadImage(src: string): Promise<HTMLImageElement> {
+  return new Promise((resolve, reject) => {
+    const image = new Image()
+    image.decoding = 'async'
+    image.onload = () => resolve(image)
+    image.onerror = () => reject(new Error('Unable to load cover artwork'))
+    image.src = src
+  })
+}
+
+function drawCover(ctx: CanvasRenderingContext2D, image: HTMLImageElement, size: number, mode: 'fill' | 'fit', overscan = 1) {
+  const scale =
+    (mode === 'fill'
+      ? Math.max(size / image.naturalWidth, size / image.naturalHeight)
+      : Math.min(size / image.naturalWidth, size / image.naturalHeight)) * overscan
+  const width = image.naturalWidth * scale
+  const height = image.naturalHeight * scale
+  ctx.drawImage(image, (size - width) / 2, (size - height) / 2, width, height)
+}
+
+function canvasBlob(canvas: HTMLCanvasElement): Promise<Blob | null> {
+  return new Promise((resolve) => canvas.toBlob(resolve, 'image/jpeg', 0.9))
+}
+
+export async function createCoverFillArtworkUrl(src: string, size = DEFAULT_ARTWORK_SIZE): Promise<string | null> {
+  if (typeof document === 'undefined' || typeof Image === 'undefined' || size <= 0) return null
+
+  try {
+    const image = await loadImage(src)
+    if (image.naturalWidth <= 0 || image.naturalHeight <= 0) return null
+
+    const canvas = document.createElement('canvas')
+    canvas.width = size
+    canvas.height = size
+    const ctx = canvas.getContext('2d')
+    if (!ctx) return null
+
+    ctx.save()
+    ctx.filter = `blur(${Math.max(12, Math.round(size * 0.06))}px) brightness(0.75)`
+    drawCover(ctx, image, size, 'fill', 1.15)
+    ctx.restore()
+
+    ctx.fillStyle = 'rgba(0, 0, 0, 0.15)'
+    ctx.fillRect(0, 0, size, size)
+    drawCover(ctx, image, size, 'fit')
+
+    const blob = await canvasBlob(canvas)
+    return blob ? URL.createObjectURL(blob) : null
+  } catch {
+    return null
+  }
+}
diff --git a/client/src/features/book/lib/cover-slots.ts b/client/src/features/book/lib/cover-slots.ts
new file mode 100644
index 000000000..a90e54d94
--- /dev/null
+++ b/client/src/features/book/lib/cover-slots.ts
@@ -0,0 +1,76 @@
+import type { BookDetail, BookMetadataLockField, CoverAspectRatio, CoverMedium, MetadataCandidate, MetadataCoverShape } from '@bookorbit/types'
+
+type SlotBook = Pick<BookDetail, 'coverMedia' | 'covers' | 'coverSource' | 'coverVersion'>
+
+export function otherMedium(medium: CoverMedium): CoverMedium {
+  return medium === 'ebook' ? 'audio' : 'ebook'
+}
+
+export type CoverFit = 'match' | 'unknown' | 'mismatch'
+
+const SLOT_SHAPE: Record<CoverMedium, Exclude<MetadataCoverShape, 'unknown'>> = { ebook: 'portrait', audio: 'square' }
+
+/** Slot-shaped art ranks first and art of the other shape last, as in the server's cover choices. */
+export const COVER_FIT_RANK: Record<CoverFit, number> = { match: 0, unknown: 1, mismatch: 2 }
+
+export function coverFit(shape: MetadataCoverShape, medium: CoverMedium): CoverFit {
+  if (shape === 'unknown') return 'unknown'
+  return shape === SLOT_SHAPE[medium] ? 'match' : 'mismatch'
+}
+
+export function statedCoverShape(candidate: MetadataCandidate): MetadataCoverShape {
+  return candidate.coverShape ?? 'unknown'
+}
+
+export function coverLockField(medium: CoverMedium | null): Extract<BookMetadataLockField, 'cover' | 'audioCover'> {
+  return medium === 'audio' ? 'audioCover' : 'cover'
+}
+
+/** Mirrors the server's face rule: a square library shows the audio slot, any other shape the ebook slot. */
+export function faceMedium(book: Pick<SlotBook, 'covers'>, aspectRatio: CoverAspectRatio | string): CoverMedium {
+  const preferred: CoverMedium = aspectRatio === '1/1' ? 'audio' : 'ebook'
+  if (book.covers[preferred]) return preferred
+  const alternate = otherMedium(preferred)
+  return book.covers[alternate] ? alternate : preferred
+}
+
+/**
+ * The media the editor shows one tile each for. A book with no content files still gets one tile,
+ * with no medium, so its writes fall through to the server's own routing.
+ */
+export function editorTiles(book: Pick<SlotBook, 'coverMedia'>): (CoverMedium | null)[] {
+  const tiles = (['ebook', 'audio'] as const).filter((medium) => book.coverMedia.includes(medium))
+  return tiles.length > 0 ? tiles : [null]
+}
+
+/** The slot a metadata result's `cover` field fills: the ebook slot, unless the book has no ebook. */
+export function coverFieldMedium(book: Pick<SlotBook, 'coverMedia'>): CoverMedium | null {
+  if (book.coverMedia.includes('ebook')) return 'ebook'
+  if (book.coverMedia.includes('audio')) return 'audio'
+  return null
+}
+
+/** A cover the upgrade has not moved into a slot yet: the summary says there is one, but no slot holds it. */
+export function isLegacyCover(book: Pick<SlotBook, 'covers' | 'coverSource'>): boolean {
+  return book.coverSource !== null && book.covers.ebook === null && book.covers.audio === null
+}
+
+export type CoverTileState = {
+  hasImage: boolean
+  source: 'extracted' | 'custom' | null
+  version: string
+}
+
+/**
+ * What a tile shows. Until the upgrade converts a legacy cover, it has no slot, so the tile the face
+ * would resolve to shows it rather than an empty placeholder.
+ */
+export function coverTileState(book: SlotBook, medium: CoverMedium | null, aspectRatio: CoverAspectRatio | string): CoverTileState {
+  const slot = medium ? book.covers[medium] : null
+  if (slot) return { hasImage: true, source: slot.source, version: slot.updatedAt }
+  if (!isLegacyCover(book)) return { hasImage: false, source: null, version: book.coverVersion }
+  const tiles = editorTiles(book)
+  const legacyTile = tiles.length === 1 ? tiles[0] : faceMedium(book, aspectRatio)
+  if (medium !== legacyTile) return { hasImage: false, source: null, version: book.coverVersion }
+  return { hasImage: true, source: book.coverSource, version: book.coverVersion }
+}
diff --git a/client/src/features/book/lib/table-row-state-sync.spec.ts b/client/src/features/book/lib/table-row-state-sync.spec.ts
index 711db71c1..0273435b1 100644
--- a/client/src/features/book/lib/table-row-state-sync.spec.ts
+++ b/client/src/features/book/lib/table-row-state-sync.spec.ts
@@ -22,6 +22,7 @@ function makeBook(overrides: Partial<BookCard> = {}): BookCard {
     readStatus: null,
     addedAt: '2024-01-01T00:00:00Z',
     updatedAt: null,
+    coverVersion: 'legacy:2024-01-01T00:00:00Z',
     metadataScore: null,
     hasCover: false,
     hasMetadataLocks: false,
diff --git a/client/src/features/book/lib/write-back-fields.ts b/client/src/features/book/lib/write-back-fields.ts
index 238c424f3..f7920d743 100644
--- a/client/src/features/book/lib/write-back-fields.ts
+++ b/client/src/features/book/lib/write-back-fields.ts
@@ -1,4 +1,11 @@
-import { BOOK_FILE_WRITE_FIELD_LABELS, type BookDetail, type BookFileWriteField } from '@bookorbit/types'
+import {
+  BOOK_FILE_WRITE_FIELD_LABELS,
+  getPrimaryBookFile,
+  isAudioFormat,
+  type BookDetail,
+  type BookFileWriteField,
+  type CoverMedium,
+} from '@bookorbit/types'
 
 export type WriteBackField = {
   field: BookFileWriteField
@@ -54,7 +61,7 @@ function resolveValue(book: BookDetail, field: BookFileWriteField): string | nul
     case 'description':
       return plainText(book.description)
     case 'coverBytes':
-      return book.coverSource
+      return writtenCoverSource(book)
     case 'seriesIndex':
       return book.seriesIndex != null ? String(book.seriesIndex) : null
     case 'seriesName':
@@ -78,3 +85,15 @@ function resolveValue(book: BookDetail, field: BookFileWriteField): string | nul
     }
   }
 }
+
+/**
+ * Write-back embeds only the written file's own medium: the EPUB gets the book cover and the audio
+ * tracks the audiobook cover. A book with no slots yet still serves its one legacy cover.
+ */
+function writtenCoverSource(book: BookDetail): string | null {
+  const covers = book.covers ?? { ebook: null, audio: null }
+  if (!covers.ebook && !covers.audio) return book.coverSource
+  const format = getPrimaryBookFile(book.files ?? [])?.format?.toLowerCase()
+  const medium: CoverMedium = format && isAudioFormat(format) ? 'audio' : 'ebook'
+  return covers[medium]?.source ?? null
+}
diff --git a/client/src/features/dashboard/components/DashboardScroller.spec.ts b/client/src/features/dashboard/components/DashboardScroller.spec.ts
index 35c0fdd9d..3543865c2 100644
--- a/client/src/features/dashboard/components/DashboardScroller.spec.ts
+++ b/client/src/features/dashboard/components/DashboardScroller.spec.ts
@@ -111,6 +111,7 @@ function makeBook(id: number, format: string, coverAspectRatio: BookCard['coverA
     readStatus: null,
     addedAt: '2026-01-01T00:00:00.000Z',
     updatedAt: null,
+    coverVersion: 'legacy:2026-01-01T00:00:00.000Z',
     metadataScore: null,
     hasCover: false,
     hasMetadataLocks: false,
diff --git a/client/src/features/library/components/LibraryCreatorDetails.vue b/client/src/features/library/components/LibraryCreatorDetails.vue
index 826a072b5..2961c43eb 100644
--- a/client/src/features/library/components/LibraryCreatorDetails.vue
+++ b/client/src/features/library/components/LibraryCreatorDetails.vue
@@ -133,7 +133,7 @@ function updateCoverAspectRatio(event: Event) {
         </label>
       </div>
       <p id="cover-style-description" class="mt-2 text-xs text-muted-foreground">
-        {{ t('library.creator.details.coverStyle.hint') }}
+        {{ t('library.creator.details.coverStyle.hintSlots') }}
       </p>
     </fieldset>
   </div>
diff --git a/client/src/features/reader/ReaderView.vue b/client/src/features/reader/ReaderView.vue
index 1674b3f9c..2ef44c1d3 100644
--- a/client/src/features/reader/ReaderView.vue
+++ b/client/src/features/reader/ReaderView.vue
@@ -54,12 +54,14 @@ import { findMatchingCfiRange } from './epub/utils'
 import { getFormatGroup } from '@bookorbit/types'
 import { resolveReaderResumeTarget } from '@/lib/reading-checkpoint'
 import { api } from '@/lib/api'
+import { useCoverVersions } from '@/features/book/composables/useCoverVersions'
 
 const PdfV4ReaderView = defineAsyncComponent(() => import('./pdf-v4/PdfV4ReaderView.vue'))
 
 const { t } = useI18n()
 const route = useRoute()
 const router = useRouter()
+const { coverUrl } = useCoverVersions()
 const bookId = Number(route.params.bookId)
 const fileId = Number(route.params.fileId)
 const fileFormat = (route.query.format as string) || 'epub'
@@ -457,7 +459,7 @@ async function buildTtsBook(): Promise<{
     bookFileId: fileId,
     title: bookMeta.value.title ?? chapterTitle.value ?? 'Book',
     author: bookMeta.value.authors?.[0]?.name ?? null,
-    coverUrl: bookMeta.value.coverSource ? `/api/v1/books/${bookId}/cover` : null,
+    coverUrl: bookMeta.value.coverSource ? coverUrl(bookId, 'cover', bookMeta.value.coverVersion, 'audio') : null,
     totalChapters: totalSections.value,
   }
 }
diff --git a/client/src/features/reader/audiobook/AudiobookReaderView.vue b/client/src/features/reader/audiobook/AudiobookReaderView.vue
index 80337201f..7b11948c8 100644
--- a/client/src/features/reader/audiobook/AudiobookReaderView.vue
+++ b/client/src/features/reader/audiobook/AudiobookReaderView.vue
@@ -28,8 +28,11 @@ import {
 } from '@lucide/vue'
 import type { AudiobookManifest, AudiobookManifestAsset, AudiobookManifestChapter, BookDetail } from '@bookorbit/types'
 import { api } from '@/lib/api'
+import CoverFill from '@/features/book/components/CoverFill.vue'
 import BookCoverPlaceholder from '@/features/book/components/BookCoverPlaceholder.vue'
+import { useCoverVersions } from '@/features/book/composables/useCoverVersions'
 import { bookCoverPalette } from '@/features/book/lib/book-cover'
+import { createCoverFillArtworkUrl } from '@/features/book/lib/cover-fill-artwork'
 import { useAudioProgress } from './composables/useAudioProgress'
 import { useAudioQueue } from './composables/useAudioQueue'
 import { useAudioSettings } from './composables/useAudioSettings'
@@ -42,6 +45,7 @@ const { t } = useI18n()
 const props = defineProps<{ bookId: number; fileId: number; peekMode?: boolean }>()
 const route = useRoute()
 const router = useRouter()
+const { coverUrl } = useCoverVersions()
 const trackingEnabled = computed(() => !props.peekMode)
 
 const detail = ref<BookDetail | null>(null)
@@ -212,9 +216,19 @@ watch(isPlaying, (val) => {
 })
 
 let mounted = true
+let mediaSessionArtworkUrl: string | null = null
+let mediaSessionArtworkRevision = 0
+
+function releaseMediaSessionArtwork() {
+  mediaSessionArtworkRevision++
+  if (!mediaSessionArtworkUrl) return
+  URL.revokeObjectURL(mediaSessionArtworkUrl)
+  mediaSessionArtworkUrl = null
+}
 
 onUnmounted(() => {
   mounted = false
+  releaseMediaSessionArtwork()
   stopQueuePlayingWatch?.()
   stopQueuePlayingWatch = null
   queue?.destroy()
@@ -241,6 +255,7 @@ const displayTitle = computed(() => {
 
 const coverSeed = computed(() => detail.value?.title ?? detail.value?.folderPath.split('/').pop() ?? String(props.bookId))
 const coverPalette = computed(() => bookCoverPalette(coverSeed.value))
+const coverSrc = computed(() => (detail.value?.coverSource ? coverUrl(props.bookId, 'cover', detail.value.coverVersion, 'audio') : null))
 
 // ── Media Session ─────────────────────────────────────────────────────────────
 
@@ -256,6 +271,32 @@ function updateMediaPlaybackState() {
   }
 }
 
+function updateMediaSessionMetadata(book: BookDetail) {
+  if (!('mediaSession' in navigator)) return
+  releaseMediaSessionArtwork()
+  const revision = mediaSessionArtworkRevision
+  const src = book.coverSource ? coverUrl(props.bookId, 'cover', book.coverVersion, 'audio') : null
+  const metadata = (artwork: MediaImage[] = []) =>
+    new MediaMetadata({
+      title: displayTitle.value,
+      artist: book.authors.map((author) => author.name).join(', '),
+      artwork,
+    })
+
+  navigator.mediaSession.metadata = metadata()
+  if (!src) return
+
+  void createCoverFillArtworkUrl(src).then((artworkUrl) => {
+    if (!artworkUrl) return
+    if (!mounted || revision !== mediaSessionArtworkRevision) {
+      URL.revokeObjectURL(artworkUrl)
+      return
+    }
+    mediaSessionArtworkUrl = artworkUrl
+    navigator.mediaSession.metadata = metadata([{ src: artworkUrl, sizes: '512x512', type: 'image/jpeg' }])
+  })
+}
+
 // ── Controls ──────────────────────────────────────────────────────────────────
 
 function togglePlay() {
@@ -711,11 +752,7 @@ onMounted(async () => {
     manifest.value = manifestRes
 
     if ('mediaSession' in navigator) {
-      navigator.mediaSession.metadata = new MediaMetadata({
-        title: displayTitle.value,
-        artist: detailRes.authors.map((a: { name: string }) => a.name).join(', '),
-        artwork: detailRes.coverSource ? [{ src: `/api/v1/books/${props.bookId}/cover`, sizes: '512x512', type: 'image/jpeg' }] : [],
-      })
+      updateMediaSessionMetadata(detailRes)
       navigator.mediaSession.setActionHandler('play', togglePlay)
       navigator.mediaSession.setActionHandler('pause', togglePlay)
       navigator.mediaSession.setActionHandler('seekbackward', skipBack)
@@ -761,9 +798,9 @@ onMounted(async () => {
     <!-- Blurred cover backdrop -->
     <div class="absolute inset-0">
       <div
-        v-if="detail?.coverSource"
+        v-if="coverSrc"
         class="absolute inset-0 scale-110"
-        :style="{ backgroundImage: `url(/api/v1/books/${props.bookId}/cover)`, backgroundSize: 'cover', backgroundPosition: 'center' }"
+        :style="{ backgroundImage: `url(${coverSrc})`, backgroundSize: 'cover', backgroundPosition: 'center' }"
       />
       <div v-else class="absolute inset-0" :style="{ background: coverPalette.gradient }" />
       <div class="absolute inset-0 backdrop-blur-3xl bg-black/60" />
@@ -838,14 +875,14 @@ onMounted(async () => {
               class="absolute -inset-4 rounded-2xl blur-3xl pointer-events-none transition-opacity duration-700"
               :class="isPlaying ? 'opacity-50' : 'opacity-15'"
               :style="
-                detail.coverSource
-                  ? { backgroundImage: `url(/api/v1/books/${props.bookId}/cover)`, backgroundSize: 'cover', backgroundPosition: 'center' }
+                coverSrc
+                  ? { backgroundImage: `url(${coverSrc})`, backgroundSize: 'cover', backgroundPosition: 'center' }
                   : { background: coverPalette.gradient }
               "
             />
             <!-- Cover -->
             <div class="absolute inset-0 rounded-2xl overflow-hidden ring-1 ring-white/10 shadow-2xl">
-              <img v-if="detail.coverSource" :src="`/api/v1/books/${props.bookId}/cover`" class="w-full h-full object-cover" :alt="displayTitle" />
+              <CoverFill v-if="coverSrc" :src="coverSrc" :alt="displayTitle" loading="eager" />
               <BookCoverPlaceholder
                 v-else
                 :title="detail.title"
diff --git a/client/src/features/reader/audiobook/__tests__/AudiobookReaderView.spec.ts b/client/src/features/reader/audiobook/__tests__/AudiobookReaderView.spec.ts
new file mode 100644
index 000000000..0fbd9a920
--- /dev/null
+++ b/client/src/features/reader/audiobook/__tests__/AudiobookReaderView.spec.ts
@@ -0,0 +1,324 @@
+import { ref } from 'vue'
+import { flushPromises, mount, type VueWrapper } from '@vue/test-utils'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import type { AudiobookManifest, BookDetail } from '@bookorbit/types'
+import type { useCoverVersions } from '@/features/book/composables/useCoverVersions'
+
+import AudiobookReaderView from '../AudiobookReaderView.vue'
+import BookCoverPlaceholder from '@/features/book/components/BookCoverPlaceholder.vue'
+import CoverFill from '@/features/book/components/CoverFill.vue'
+
+type CoverUrl = ReturnType<typeof useCoverVersions>['coverUrl']
+
+const BOOK_ID = 7
+const FILE_ID = 71
+const COVER_VERSION = 'ebook:2026-09-20T10:00:00.000Z:2026-09-21T12:30:00.000Z'
+const ARTWORK_URL = 'blob:audio-artwork'
+
+const mocks = vi.hoisted(() => ({
+  api: vi.fn<(input: string) => Promise<{ ok: boolean; json: () => Promise<unknown> }>>(),
+  coverUrl: vi.fn<CoverUrl>(),
+  createCoverFillArtworkUrl: vi.fn<(src: string, size?: number) => Promise<string | null>>(),
+  revokeObjectURL: vi.fn<(url: string) => void>(),
+}))
+
+vi.mock('vue-i18n', () => ({ useI18n: () => ({ t: (key: string) => key }) }))
+
+vi.mock('vue-router', () => ({
+  useRoute: () => ({ params: { bookId: '7', fileId: '71' }, query: {} }),
+  useRouter: () => ({ back: vi.fn<() => void>(), replace: vi.fn<() => Promise<void>>().mockResolvedValue(undefined) }),
+}))
+
+vi.mock('@/lib/api', () => ({ api: mocks.api }))
+
+vi.mock('@/features/book/composables/useCoverVersions', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('@/features/book/composables/useCoverVersions')>()
+  return {
+    useCoverVersions: () => {
+      const real = actual.useCoverVersions()
+      mocks.coverUrl.mockImplementation(real.coverUrl)
+      return { ...real, coverUrl: mocks.coverUrl }
+    },
+  }
+})
+
+vi.mock('@/features/book/lib/cover-fill-artwork', () => ({ createCoverFillArtworkUrl: mocks.createCoverFillArtworkUrl }))
+
+vi.mock('../composables/useAudioProgress', () => ({
+  useAudioProgress: () => ({
+    resumeAssetId: ref<string | null>(null),
+    resumePosition: ref(0),
+    revision: ref(0),
+    loaded: ref(true),
+    load: vi.fn<() => Promise<void>>().mockResolvedValue(undefined),
+    update: vi.fn<(assetId: string, positionSeconds: number) => void>(),
+    flush: vi.fn<() => void>(),
+  }),
+}))
+
+vi.mock('../composables/useAudioQueue', () => ({
+  useAudioQueue: () => ({
+    currentIndex: ref(0),
+    isPlaying: ref(false),
+    loadError: ref<string | null>(null),
+    activateIndex: vi.fn<(index: number, positionSeconds: number) => void>(),
+    play: vi.fn<() => void>(),
+    pause: vi.fn<() => void>(),
+    seek: vi.fn<(positionSeconds: number) => void>(),
+    position: vi.fn<() => number>().mockReturnValue(0),
+    setSpeed: vi.fn<(rate: number) => void>(),
+    setVolume: vi.fn<(volume: number) => void>(),
+    goToAsset: vi.fn<(assetId: string, positionSeconds: number) => void>(),
+    nextFile: vi.fn<() => void>(),
+    prevFile: vi.fn<() => void>(),
+    destroy: vi.fn<() => void>(),
+  }),
+}))
+
+vi.mock('../composables/useAudioSettings', () => ({
+  useAudioSettings: () => ({
+    playbackSpeed: ref(1),
+    volume: ref(1),
+    skipBackSeconds: ref(15),
+    skipForwardSeconds: ref(30),
+    init: vi.fn<() => Promise<void>>().mockResolvedValue(undefined),
+    setPlaybackSpeed: vi.fn<(rate: number) => void>(),
+    setVolume: vi.fn<(volume: number) => void>(),
+    setSkipBackSeconds: vi.fn<(seconds: number) => void>(),
+    setSkipForwardSeconds: vi.fn<(seconds: number) => void>(),
+  }),
+}))
+
+vi.mock('../composables/useAudioBookmarks', () => ({
+  useAudioBookmarks: () => ({
+    bookmarks: ref([]),
+    load: vi.fn<() => Promise<void>>().mockResolvedValue(undefined),
+    add: vi.fn<(positionSeconds: number, title: string, chapterId?: string) => Promise<null>>().mockResolvedValue(null),
+    remove: vi.fn<(bookmarkId: string) => Promise<void>>().mockResolvedValue(undefined),
+  }),
+}))
+
+vi.mock('../../shared/composables/useReadingSession', () => ({
+  useReadingSession: () => ({ onActivity: vi.fn<() => void>() }),
+}))
+
+vi.mock('../../shared/composables/useFullscreen', () => ({
+  useFullscreen: () => ({ isFullscreen: ref(false), toggleFullscreen: vi.fn<() => void>() }),
+}))
+
+function bookDetail(overrides: Partial<BookDetail> = {}): BookDetail {
+  return {
+    id: BOOK_ID,
+    libraryId: 1,
+    libraryName: 'Library',
+    status: 'present',
+    folderPath: '/path/to/library/The Long Orbit',
+    addedAt: '2026-09-01T00:00:00.000Z',
+    updatedAt: null,
+    title: 'The Long Orbit',
+    subtitle: null,
+    description: null,
+    isbn10: null,
+    isbn13: null,
+    publisher: null,
+    publishedDate: null,
+    publishedYear: null,
+    language: null,
+    pageCount: null,
+    seriesName: null,
+    seriesIndex: null,
+    rating: null,
+    personalNote: null,
+    personalNoteUpdatedAt: null,
+    communityRatings: [],
+    coverSource: 'extracted',
+    coverMedia: ['ebook', 'audio'],
+    covers: {
+      ebook: { source: 'extracted', updatedAt: '2026-09-20T10:00:00.000Z', width: 600, height: 900 },
+      audio: { source: 'custom', updatedAt: '2026-09-21T12:30:00.000Z', width: 1000, height: 1000 },
+    },
+    coverVersion: COVER_VERSION,
+    hardcoverEditionId: null,
+    providerIds: {},
+    authors: [{ id: 1, name: 'Ada Vance', sortName: 'Vance, Ada' }],
+    genres: [],
+    tags: [],
+    files: [
+      {
+        id: 70,
+        role: 'primary',
+        format: 'epub',
+        filename: 'the-long-orbit.epub',
+        sizeBytes: 1024,
+        absolutePath: '/path/to/library/The Long Orbit/the-long-orbit.epub',
+        createdAt: '2026-09-01T00:00:00.000Z',
+        durationSeconds: null,
+      },
+      {
+        id: FILE_ID,
+        role: 'content',
+        format: 'm4b',
+        filename: 'the-long-orbit.m4b',
+        sizeBytes: 4096,
+        absolutePath: '/path/to/library/The Long Orbit/the-long-orbit.m4b',
+        createdAt: '2026-09-01T00:00:00.000Z',
+        durationSeconds: 3600,
+      },
+    ],
+    lastWrittenAt: null,
+    metadataScore: null,
+    readStatus: null,
+    audioMetadata: null,
+    readAloudSync: {
+      mode: 'auto',
+      state: 'unavailable',
+      unavailableReason: 'no_media_overlay_epub',
+      overlayFileId: null,
+      audioDurationSeconds: null,
+      overlayDurationSeconds: null,
+      durationDifferenceSeconds: null,
+      durationDifferenceRatio: null,
+      koreaderDownloadAvailable: false,
+    },
+    formatPriority: [],
+    comicMetadata: null,
+    customMetadata: [],
+    lockedFields: [],
+    collections: [],
+    ...overrides,
+  }
+}
+
+function audiobookManifest(): AudiobookManifest {
+  return {
+    schema: 'bookorbit.audiobook-manifest',
+    schemaVersion: 2,
+    revision: 'manifest-rev-1',
+    book: { id: BOOK_ID, title: 'The Long Orbit', authors: ['Ada Vance'], narrators: ['Sam Reed'], hasCover: true },
+    assets: [{ assetId: 'asset-1', sequence: 0, format: 'm4b', durationMs: 3_600_000, sizeBytes: 4096, etag: 'etag-1' }],
+    chapters: [{ id: 'chapter-1', title: 'Launch', assetId: 'asset-1', sequence: 0, startMs: 0, endMs: 3_600_000, assetOffsetMs: 0 }],
+    totalDurationMs: 3_600_000,
+  }
+}
+
+function serve(detail: BookDetail) {
+  mocks.api.mockImplementation(async (input) => {
+    if (input === `/api/v1/books/${BOOK_ID}`) return { ok: true, json: async () => detail }
+    if (input === `/api/v1/audiobooks/${BOOK_ID}/manifest`) return { ok: true, json: async () => audiobookManifest() }
+    throw new Error(`Unexpected request: ${input}`)
+  })
+}
+
+function stubMediaSession() {
+  const session: { metadata: MediaMetadataInit | null; playbackState: MediaSessionPlaybackState } = { metadata: null, playbackState: 'none' }
+  vi.stubGlobal(
+    'MediaMetadata',
+    class {
+      constructor(init: MediaMetadataInit) {
+        Object.assign(this, init)
+      }
+    },
+  )
+  Object.defineProperty(navigator, 'mediaSession', {
+    configurable: true,
+    value: Object.assign(session, {
+      setActionHandler: vi.fn<(action: MediaSessionAction, handler: MediaSessionActionHandler | null) => void>(),
+    }),
+  })
+  return session
+}
+
+function coverRequest(url: string) {
+  const parsed = new URL(url, 'http://localhost')
+  return { path: parsed.pathname, medium: parsed.searchParams.get('medium'), version: parsed.searchParams.get('t') }
+}
+
+function backgroundImageUrls(wrapper: VueWrapper): string[] {
+  return wrapper
+    .findAll('div')
+    .map((div) => /^url\("?(.*?)"?\)$/.exec((div.element as HTMLElement).style.backgroundImage)?.[1])
+    .filter((url): url is string => url !== undefined)
+}
+
+let wrapper: VueWrapper | null = null
+
+async function mountView() {
+  wrapper = mount(AudiobookReaderView, {
+    props: { bookId: BOOK_ID, fileId: FILE_ID },
+    global: { stubs: { BookCoverPlaceholder: true } },
+  })
+  await flushPromises()
+  return wrapper
+}
+
+describe('AudiobookReaderView', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    mocks.createCoverFillArtworkUrl.mockResolvedValue(ARTWORK_URL)
+    vi.stubGlobal(
+      'URL',
+      class extends URL {
+        static revokeObjectURL = mocks.revokeObjectURL
+      },
+    )
+  })
+
+  afterEach(() => {
+    wrapper?.unmount()
+    wrapper = null
+    vi.unstubAllGlobals()
+    Reflect.deleteProperty(navigator, 'mediaSession')
+  })
+
+  it('draws the cover and backdrop from the audio slot, versioned by coverVersion', async () => {
+    serve(bookDetail())
+    const view = await mountView()
+
+    const coverFill = view.findComponent(CoverFill)
+    expect(coverFill.exists()).toBe(true)
+    const src = coverFill.props('src')
+    expect(coverRequest(src)).toEqual({ path: `/api/v1/books/${BOOK_ID}/cover`, medium: 'audio', version: COVER_VERSION })
+    expect(coverFill.props()).toMatchObject({ alt: 'The Long Orbit', loading: 'eager' })
+
+    const backdrops = backgroundImageUrls(view)
+    expect(backdrops.length).toBeGreaterThan(0)
+    expect(new Set(backdrops)).toEqual(new Set([src]))
+
+    const requestedCovers = mocks.coverUrl.mock.calls
+    expect(requestedCovers.length).toBeGreaterThan(0)
+    expect(requestedCovers).toEqual(requestedCovers.map(() => [BOOK_ID, 'cover', COVER_VERSION, 'audio']))
+    expect(view.findComponent(BookCoverPlaceholder).exists()).toBe(false)
+  })
+
+  it('builds the media session artwork from the audio-slot cover', async () => {
+    const session = stubMediaSession()
+    serve(bookDetail())
+    const view = await mountView()
+
+    const src = view.findComponent(CoverFill).props('src')
+    expect(coverRequest(src).medium).toBe('audio')
+    expect(mocks.createCoverFillArtworkUrl).toHaveBeenCalledExactlyOnceWith(src)
+    expect(session.metadata).toMatchObject({
+      title: 'The Long Orbit',
+      artist: 'Ada Vance',
+      artwork: [{ src: ARTWORK_URL, sizes: '512x512', type: 'image/jpeg' }],
+    })
+  })
+
+  it('shows the placeholder and requests no cover when the book has none', async () => {
+    const session = stubMediaSession()
+    serve(bookDetail({ coverSource: null, coverMedia: [], covers: { ebook: null, audio: null }, coverVersion: 'legacy:2026-09-01T00:00:00.000Z' }))
+    const view = await mountView()
+
+    expect(mocks.coverUrl).not.toHaveBeenCalled()
+    expect(mocks.createCoverFillArtworkUrl).not.toHaveBeenCalled()
+    expect(view.findComponent(CoverFill).exists()).toBe(false)
+    expect(view.find('img').exists()).toBe(false)
+    expect(backgroundImageUrls(view)).toEqual([])
+
+    const placeholder = view.findComponent(BookCoverPlaceholder)
+    expect(placeholder.exists()).toBe(true)
+    expect(placeholder.props()).toMatchObject({ title: 'The Long Orbit', authorLine: 'Ada Vance', isAudio: true })
+    expect(session.metadata).toMatchObject({ title: 'The Long Orbit', artist: 'Ada Vance', artwork: [] })
+  })
+})
diff --git a/client/src/features/reader/media-overlay/components/MediaOverlayMiniPlayer.vue b/client/src/features/reader/media-overlay/components/MediaOverlayMiniPlayer.vue
index 732f14173..ad9fc241e 100644
--- a/client/src/features/reader/media-overlay/components/MediaOverlayMiniPlayer.vue
+++ b/client/src/features/reader/media-overlay/components/MediaOverlayMiniPlayer.vue
@@ -6,6 +6,7 @@ import { useMediaOverlay } from '../composables/useMediaOverlay'
 import { useTtsMiniPlayerUi } from '@/features/tts/composables/useTtsMiniPlayerUi'
 import TtsSpeedControl from '@/features/tts/components/TtsSpeedControl.vue'
 import TtsSleepTimerPicker from '@/features/tts/components/TtsSleepTimerPicker.vue'
+import CoverFill from '@/features/book/components/CoverFill.vue'
 
 const { t } = useI18n()
 const { isActive, isPlaying, rate, currentBook, error, sleepTimer, toggle, nextSentence, prevSentence, setRate, stop } = useMediaOverlay()
@@ -51,7 +52,7 @@ function handleStop() {
             :aria-expanded="showPanel"
             @click="togglePanel"
           >
-            <img v-if="currentBook?.coverUrl" :src="currentBook.coverUrl" alt="" class="w-full h-full object-cover" />
+            <CoverFill v-if="currentBook?.coverUrl" :src="currentBook.coverUrl" />
             <Headphones v-else class="w-4 h-4 text-muted-foreground" />
           </button>
 
diff --git a/client/src/features/scanner/composables/useScanProgress.ts b/client/src/features/scanner/composables/useScanProgress.ts
index 123164836..81aa22b71 100644
--- a/client/src/features/scanner/composables/useScanProgress.ts
+++ b/client/src/features/scanner/composables/useScanProgress.ts
@@ -40,7 +40,8 @@ function getSocket(): Socket {
     })
 
     socket.on('cover:refreshed', (event: CoverRefreshedEvent) => {
-      useCoverVersions().bumpVersion(event.bookId)
+      const coverVersions = useCoverVersions()
+      for (const bookId of event.bookIds) coverVersions.bumpVersion(bookId)
     })
 
     socket.on('disconnect', () => {
diff --git a/client/src/features/series/composables/useSeriesBookMediaGroups.test.ts b/client/src/features/series/composables/useSeriesBookMediaGroups.test.ts
index aaab71b31..22d3bf926 100644
--- a/client/src/features/series/composables/useSeriesBookMediaGroups.test.ts
+++ b/client/src/features/series/composables/useSeriesBookMediaGroups.test.ts
@@ -23,6 +23,7 @@ function makeBook(format: string | null | undefined, overrides: Partial<BookCard
     readStatus: null,
     addedAt: '2026-01-01T00:00:00.000Z',
     updatedAt: null,
+    coverVersion: 'legacy:2026-01-01T00:00:00.000Z',
     metadataScore: null,
     hasCover: false,
     hasMetadataLocks: false,
diff --git a/client/src/features/series/views/SeriesDetailView.spec.ts b/client/src/features/series/views/SeriesDetailView.spec.ts
index 8e63531db..c2c4b01ed 100644
--- a/client/src/features/series/views/SeriesDetailView.spec.ts
+++ b/client/src/features/series/views/SeriesDetailView.spec.ts
@@ -124,6 +124,7 @@ function makeBook(overrides: Partial<BookCard> = {}): BookCard {
     readStatus: null,
     addedAt: '2026-01-01T00:00:00.000Z',
     updatedAt: null,
+    coverVersion: 'legacy:2026-01-01T00:00:00.000Z',
     metadataScore: null,
     hasCover: false,
     hasMetadataLocks: false,
diff --git a/client/src/features/settings/metadata-preferences/MetadataFieldRulesSettings.vue b/client/src/features/settings/metadata-preferences/MetadataFieldRulesSettings.vue
index 5c2a3409a..286053a64 100644
--- a/client/src/features/settings/metadata-preferences/MetadataFieldRulesSettings.vue
+++ b/client/src/features/settings/metadata-preferences/MetadataFieldRulesSettings.vue
@@ -11,7 +11,7 @@ import FieldRulesToolbar from './components/FieldRulesToolbar.vue'
 import FieldRulesTable from './components/FieldRulesTable.vue'
 import FieldRulesSaveBar from './components/FieldRulesSaveBar.vue'
 import AdvancedFetchOptions from './components/AdvancedFetchOptions.vue'
-import { fieldsMatching, type ProviderBulkAction } from './lib/field-rules'
+import { fieldRuleLabelKey, fieldsMatching, type ProviderBulkAction } from './lib/field-rules'
 
 const { t } = useI18n()
 const { statuses, fetchConfig } = useProviderConfig()
@@ -36,7 +36,7 @@ watch(
   },
 )
 
-const fieldLabel = (field: MetadataField) => t(`settings.metadata.fields.${field}`)
+const fieldLabel = (field: MetadataField) => t(fieldRuleLabelKey(field))
 
 const visibleFields = computed(() => {
   const fields = scopes.activeFields.value
diff --git a/client/src/features/settings/metadata-preferences/components/FieldRuleRow.vue b/client/src/features/settings/metadata-preferences/components/FieldRuleRow.vue
index 55b722ab8..905137f2c 100644
--- a/client/src/features/settings/metadata-preferences/components/FieldRuleRow.vue
+++ b/client/src/features/settings/metadata-preferences/components/FieldRuleRow.vue
@@ -10,7 +10,7 @@ import ProviderChipList from './ProviderChipList.vue'
 import ProviderAddMenu from './ProviderAddMenu.vue'
 import MergeStrategySegmented from './MergeStrategySegmented.vue'
 import FieldRuleDetail from './FieldRuleDetail.vue'
-import { resolvedProviders, skippedProviders } from '../lib/field-rules'
+import { fieldRuleLabelKey, resolvedProviders, skippedProviders } from '../lib/field-rules'
 
 const { t } = useI18n()
 
@@ -32,7 +32,7 @@ const emit = defineEmits<{
   'update:expanded': [value: boolean]
 }>()
 
-const label = computed(() => t(`settings.metadata.fields.${props.field}`))
+const label = computed(() => t(fieldRuleLabelKey(props.field)))
 const resolved = computed(() => resolvedProviders(props.preference.providers, props.statuses))
 const skipped = computed(() => skippedProviders(props.preference.providers, props.statuses))
 const hasNoUsableProvider = computed(() => props.preference.enabled && resolved.value.length === 0)
diff --git a/client/src/features/settings/metadata-preferences/components/ProviderBulkMenu.vue b/client/src/features/settings/metadata-preferences/components/ProviderBulkMenu.vue
index c6759fc17..7d7a16b91 100644
--- a/client/src/features/settings/metadata-preferences/components/ProviderBulkMenu.vue
+++ b/client/src/features/settings/metadata-preferences/components/ProviderBulkMenu.vue
@@ -16,7 +16,7 @@ import {
   DropdownMenuTrigger,
 } from '@/components/ui/dropdown-menu'
 import { providerChipStyle, PROVIDER_SHORT_LABELS } from '@/lib/provider-colors'
-import { providerUsageCount, skipReasonFor, type ProviderBulkAction } from '../lib/field-rules'
+import { BULK_REORDER_EXEMPT_FIELDS, providerUsageCount, skipReasonFor, type ProviderBulkAction } from '../lib/field-rules'
 
 const { t } = useI18n()
 
@@ -45,6 +45,7 @@ const entries = computed(() =>
         short: PROVIDER_SHORT_LABELS[key] ?? key,
         usage: providerUsageCount(props.fields, key),
         skipReason: skipReasonFor(status),
+        keepsExemptOrder: [...BULK_REORDER_EXEMPT_FIELDS].some((field) => props.fields[field]?.providers.includes(key)),
       }
     })
     .sort((a, b) => b.usage - a.usage || a.label.localeCompare(b.label)),
@@ -120,6 +121,9 @@ function runBulk(provider: MetadataProviderKey, action: ProviderBulkAction) {
             <Trash2 :size="14" />
             {{ t('settings.metadata.fieldRules.toolbar.removeEverywhere') }}
           </DropdownMenuItem>
+          <p v-if="entry.keepsExemptOrder" class="px-2 pt-1 pb-1.5 text-xs text-muted-foreground">
+            {{ t('settings.metadata.fieldRules.toolbar.audioCoverOrderKept') }}
+          </p>
         </DropdownMenuSubContent>
       </DropdownMenuSub>
     </DropdownMenuContent>
diff --git a/client/src/features/settings/metadata-preferences/composables/__tests__/useFieldRuleScopes.spec.ts b/client/src/features/settings/metadata-preferences/composables/__tests__/useFieldRuleScopes.spec.ts
index 084e73a4f..18a5c4151 100644
--- a/client/src/features/settings/metadata-preferences/composables/__tests__/useFieldRuleScopes.spec.ts
+++ b/client/src/features/settings/metadata-preferences/composables/__tests__/useFieldRuleScopes.spec.ts
@@ -197,15 +197,25 @@ describe('useFieldRuleScopes', () => {
     expect(body.overrides).toEqual({})
   })
 
-  it('applies a provider action across every field in one edit', async () => {
+  it('applies a provider action across every field in one edit, leaving the Audiobook cover order alone', async () => {
     const { api } = await setup()
     api.applyProviderToAllFields(key('google'), 'first')
     await nextTick()
 
-    expect(api.unsavedFields.value.size).toBe(ALL_METADATA_FIELDS.length)
-    for (const field of ALL_METADATA_FIELDS) {
+    const reordered = ALL_METADATA_FIELDS.filter((field) => field !== 'audioCover')
+    expect([...api.unsavedFields.value].sort()).toEqual([...reordered].sort())
+    for (const field of reordered) {
       expect(api.activeFields.value?.[field].providers).toEqual(['google', 'goodreads'])
     }
+    expect(api.activeFields.value?.audioCover.providers).toEqual(['goodreads', 'google'])
+  })
+
+  it('still removes a provider from the Audiobook cover rule when removing it everywhere', async () => {
+    const { api } = await setup()
+    api.applyProviderToAllFields(key('google'), 'remove')
+    await nextTick()
+
+    expect(api.activeFields.value?.audioCover.providers).toEqual(['goodreads'])
   })
 
   it('removing a provider everywhere leaves the other providers in order', async () => {
diff --git a/client/src/features/settings/metadata-preferences/composables/useFieldRuleScopes.ts b/client/src/features/settings/metadata-preferences/composables/useFieldRuleScopes.ts
index d53695a4d..5defe52bb 100644
--- a/client/src/features/settings/metadata-preferences/composables/useFieldRuleScopes.ts
+++ b/client/src/features/settings/metadata-preferences/composables/useFieldRuleScopes.ts
@@ -4,7 +4,7 @@ import { ALL_METADATA_FIELDS } from '@bookorbit/types'
 import type { FieldPreference, FieldPreferenceOverrides, MetadataField, MetadataFetchPreferences, MetadataProviderKey } from '@bookorbit/types'
 import { useLibraries } from '@/features/library/composables/useLibraries'
 import { useMetadataPreferences } from './useMetadataPreferences'
-import { applyProviderAction, type ProviderBulkAction } from '../lib/field-rules'
+import { applyProviderAction, BULK_REORDER_EXEMPT_FIELDS, type ProviderBulkAction } from '../lib/field-rules'
 
 export const GLOBAL_SCOPE = 'global' as const
 export type FieldRuleScopeId = typeof GLOBAL_SCOPE | number
@@ -192,13 +192,13 @@ export function useFieldRuleScopes() {
     writeDraft(activeScopeId.value, { fields: { ...draft.fields, [field]: { ...globalPref, providers: [...globalPref.providers] } }, pending })
   }
 
-  function updateEveryField(update: (pref: FieldPreference) => FieldPreference) {
+  function updateEveryField(update: (pref: FieldPreference, field: MetadataField) => FieldPreference) {
     const draft = activeDraft.value
     if (!draft || saving.value) return
     const fields = { ...draft.fields }
     const pending = new Map(draft.pending)
     for (const field of ALL_METADATA_FIELDS) {
-      const next = update(fields[field])
+      const next = update(fields[field], field)
       if (next === fields[field]) continue
       fields[field] = next
       pending.set(field, next)
@@ -212,7 +212,8 @@ export function useFieldRuleScopes() {
 
   /** Moves or removes one provider across every field in the active scope. */
   function applyProviderToAllFields(provider: MetadataProviderKey, action: ProviderBulkAction) {
-    updateEveryField((pref) => {
+    updateEveryField((pref, field) => {
+      if (action !== 'remove' && BULK_REORDER_EXEMPT_FIELDS.has(field)) return pref
       const providers = applyProviderAction(pref.providers, provider, action)
       return providers.length === pref.providers.length && providers.every((key, index) => key === pref.providers[index])
         ? pref
diff --git a/client/src/features/settings/metadata-preferences/lib/__tests__/field-rules.spec.ts b/client/src/features/settings/metadata-preferences/lib/__tests__/field-rules.spec.ts
index c29f377fa..2dc76f26a 100644
--- a/client/src/features/settings/metadata-preferences/lib/__tests__/field-rules.spec.ts
+++ b/client/src/features/settings/metadata-preferences/lib/__tests__/field-rules.spec.ts
@@ -1,8 +1,11 @@
 import { describe, expect, it } from 'vitest'
 import { ALL_METADATA_FIELDS } from '@bookorbit/types'
 import type { FieldPreference, MetadataField, MetadataProviderKey, ProviderStatus } from '@bookorbit/types'
+import en from '@/locales/en.json'
 import {
   applyProviderAction,
+  FIELD_GROUPS,
+  fieldRuleLabelKey,
   fieldsMatching,
   isProviderUsable,
   providerRank,
@@ -156,3 +159,28 @@ describe('fieldsMatching', () => {
     expect([...result]).toEqual(['title'])
   })
 })
+
+function messageAt(path: string): unknown {
+  return path.split('.').reduce<unknown>((node, part) => (node as Record<string, unknown> | undefined)?.[part], en)
+}
+
+describe('metadata field labels and groups', () => {
+  // Label keys are built at runtime, so the locale check, which reads literal keys, cannot see them.
+  it('has an English label for every field, in the rule editor and everywhere else', () => {
+    const unlabelled = ALL_METADATA_FIELDS.filter(
+      (field) => typeof messageAt(`settings.metadata.fields.${field}`) !== 'string' || typeof messageAt(fieldRuleLabelKey(field)) !== 'string',
+    )
+    expect(unlabelled).toEqual([])
+  })
+
+  it('names the two cover rules apart in the rule editor only', () => {
+    expect(messageAt(fieldRuleLabelKey('cover'))).toBe('Book cover')
+    expect(messageAt(fieldRuleLabelKey('audioCover'))).toBe('Audiobook cover')
+    expect(messageAt('settings.metadata.fields.cover')).toBe('Cover')
+  })
+
+  it('puts every field in exactly one group, since a field in none is never shown', () => {
+    const grouped = FIELD_GROUPS.flatMap((group) => group.fields)
+    expect([...grouped].sort()).toEqual([...ALL_METADATA_FIELDS].sort())
+  })
+})
diff --git a/client/src/features/settings/metadata-preferences/lib/field-rules.ts b/client/src/features/settings/metadata-preferences/lib/field-rules.ts
index b278eb19a..6ee31e807 100644
--- a/client/src/features/settings/metadata-preferences/lib/field-rules.ts
+++ b/client/src/features/settings/metadata-preferences/lib/field-rules.ts
@@ -3,7 +3,7 @@ import type { FieldPreference, MetadataField, MetadataProviderKey, ProviderStatu
 
 /** Display grouping for the rule table. Every metadata field belongs to exactly one group. */
 export const FIELD_GROUPS: { id: string; fields: MetadataField[] }[] = [
-  { id: 'core', fields: ['title', 'subtitle', 'description', 'cover'] },
+  { id: 'core', fields: ['title', 'subtitle', 'description', 'cover', 'audioCover'] },
   { id: 'contributors', fields: ['authors'] },
   { id: 'publication', fields: ['publisher', 'publishedYear', 'language', 'pageCount', 'communityRating'] },
   { id: 'series', fields: ['seriesName', 'seriesIndex'] },
@@ -11,6 +11,20 @@ export const FIELD_GROUPS: { id: string; fields: MetadataField[] }[] = [
   { id: 'audiobook', fields: ['narrators', 'duration', 'abridged'] },
 ]
 
+/**
+ * Rules the bulk reorder leaves alone. The Audiobook cover rule puts audiobook sources first on
+ * purpose, and "make first everywhere" would quietly undo that.
+ */
+export const BULK_REORDER_EXEMPT_FIELDS: ReadonlySet<MetadataField> = new Set<MetadataField>(['audioCover'])
+
+/**
+ * The rule editor names the ebook cover rule "Book cover" to tell it from the Audiobook cover
+ * rule. Everywhere else, such as the auto-fetch picker and score weights, "Cover" means either.
+ */
+export function fieldRuleLabelKey(field: MetadataField): string {
+  return field === 'cover' ? 'settings.metadata.fieldRules.bookCover' : `settings.metadata.fields.${field}`
+}
+
 /** Why a provider that sits in a priority order will not be consulted. */
 export type ProviderSkipReason = 'disabled' | 'notConfigured'
 
diff --git a/client/src/features/tools/composables/__tests__/useMissingResources.spec.ts b/client/src/features/tools/composables/__tests__/useMissingResources.spec.ts
index b68ccd8c8..08d032b91 100644
--- a/client/src/features/tools/composables/__tests__/useMissingResources.spec.ts
+++ b/client/src/features/tools/composables/__tests__/useMissingResources.spec.ts
@@ -167,7 +167,7 @@ describe('useMissingResources', () => {
   it('never exposes rows from the previous category while the next page is loading', async () => {
     vi.mocked(api.getMissingResourcesSummary).mockResolvedValue(summary({ sweep: completedSweep }))
     vi.mocked(api.getOrphanedCoverDirs).mockResolvedValue({
-      items: [{ bookId: 1028, fileCount: 3, sizeBytes: 1024 }],
+      items: [{ bookId: 1028, fileCount: 3, sizeBytes: 1024, media: ['audio'] }],
       total: 283,
       page: 1,
       pageSize: 50,
diff --git a/client/src/features/tools/missing-resources/components/BrokenCoverRow.vue b/client/src/features/tools/missing-resources/components/BrokenCoverRow.vue
index 8fc8d271a..0270fdc57 100644
--- a/client/src/features/tools/missing-resources/components/BrokenCoverRow.vue
+++ b/client/src/features/tools/missing-resources/components/BrokenCoverRow.vue
@@ -1,7 +1,7 @@
 <script setup lang="ts">
 import { computed } from 'vue'
 import { useI18n } from 'vue-i18n'
-import type { BrokenCoverEntry } from '@bookorbit/types'
+import type { BrokenCoverEntry, BrokenCoverSlot } from '@bookorbit/types'
 
 import { formatList } from '@/i18n/formatters'
 
@@ -12,6 +12,18 @@ const { t } = useI18n()
 
 const title = computed(() => props.entry.title ?? t('tools.missingResources.untitled'))
 
+const SLOT_LABEL_KEYS: Record<BrokenCoverSlot['medium'], Record<BrokenCoverSlot['source'], string>> = {
+  ebook: { extracted: 'tools.missingResources.brokenSlot.ebookExtracted', custom: 'tools.missingResources.brokenSlot.ebookCustom' },
+  audio: { extracted: 'tools.missingResources.brokenSlot.audioExtracted', custom: 'tools.missingResources.brokenSlot.audioCustom' },
+}
+
+// A cover the upgrade has not moved into a slot yet has no slot to name, so it keeps the plain source.
+const badges = computed(() =>
+  props.entry.slots.length > 0
+    ? props.entry.slots.map((slot) => ({ key: slot.medium, label: t(SLOT_LABEL_KEYS[slot.medium][slot.source]) }))
+    : [{ key: 'cover', label: t(`tools.missingResources.coverSource.${props.entry.coverSource}`) }],
+)
+
 function handleToggle(): void {
   emit('toggle', props.entry.id)
 }
@@ -30,12 +42,12 @@ function handleToggle(): void {
     <div class="min-w-0 flex-1">
       <p class="truncate text-sm font-medium text-foreground">{{ title }}</p>
       <p v-if="entry.authors.length > 0" class="truncate text-xs text-muted-foreground">{{ formatList(entry.authors) }}</p>
+      <ul class="mt-1 flex flex-wrap gap-1">
+        <li v-for="badge in badges" :key="badge.key" class="rounded border border-border px-1.5 py-0.5 text-xs text-muted-foreground">
+          {{ badge.label }}
+        </li>
+      </ul>
     </div>
-    <div class="hidden shrink-0 items-center gap-2 sm:flex">
-      <span class="rounded border border-border px-1.5 py-0.5 text-xs text-muted-foreground">
-        {{ t(`tools.missingResources.coverSource.${entry.coverSource}`) }}
-      </span>
-      <span class="text-xs text-muted-foreground">{{ entry.libraryName }}</span>
-    </div>
+    <span class="hidden shrink-0 text-xs text-muted-foreground sm:block">{{ entry.libraryName }}</span>
   </li>
 </template>
diff --git a/client/src/features/tools/missing-resources/components/OrphanedCoverRow.vue b/client/src/features/tools/missing-resources/components/OrphanedCoverRow.vue
index d61654346..38f77cc72 100644
--- a/client/src/features/tools/missing-resources/components/OrphanedCoverRow.vue
+++ b/client/src/features/tools/missing-resources/components/OrphanedCoverRow.vue
@@ -12,6 +12,15 @@ const { t } = useI18n()
 
 const label = computed(() => t('tools.missingResources.table.coverFolder', { bookId: props.entry.bookId }))
 
+// A folder from before covers had slots holds its files at the top level and names no medium.
+const mediaLabel = computed(() => {
+  const media = props.entry.media
+  if (media.includes('ebook') && media.includes('audio')) return t('tools.missingResources.table.orphanMedia.both')
+  if (media.includes('audio')) return t('tools.missingResources.table.orphanMedia.audio')
+  if (media.includes('ebook')) return t('tools.missingResources.table.orphanMedia.ebook')
+  return null
+})
+
 function handleToggle(): void {
   emit('toggle', props.entry.bookId)
 }
@@ -29,8 +38,9 @@ function handleToggle(): void {
     />
     <div class="min-w-0 flex-1">
       <p class="truncate text-sm font-medium text-foreground">{{ label }}</p>
-      <p class="text-xs text-muted-foreground">
-        {{ t('tools.missingResources.table.fileCount', { count: entry.fileCount }) }}
+      <p class="flex flex-wrap items-center gap-x-2 text-xs text-muted-foreground">
+        <span>{{ t('tools.missingResources.table.fileCount', { count: entry.fileCount }) }}</span>
+        <span v-if="mediaLabel">{{ mediaLabel }}</span>
       </p>
     </div>
     <span class="shrink-0 text-xs text-muted-foreground tabular-nums">{{ formatBytes(entry.sizeBytes) }}</span>
diff --git a/client/src/features/tools/missing-resources/components/__tests__/CoverRows.spec.ts b/client/src/features/tools/missing-resources/components/__tests__/CoverRows.spec.ts
new file mode 100644
index 000000000..f9bfeb70a
--- /dev/null
+++ b/client/src/features/tools/missing-resources/components/__tests__/CoverRows.spec.ts
@@ -0,0 +1,68 @@
+import { mount } from '@vue/test-utils'
+import { describe, expect, it, vi } from 'vitest'
+import type { BrokenCoverEntry, OrphanedCoverDirEntry } from '@bookorbit/types'
+import BrokenCoverRow from '../BrokenCoverRow.vue'
+import OrphanedCoverRow from '../OrphanedCoverRow.vue'
+
+vi.mock('vue-i18n', () => ({
+  useI18n: () => ({ t: (key: string, params?: Record<string, unknown>) => (params ? `${key} ${JSON.stringify(params)}` : key) }),
+}))
+
+vi.mock('@/i18n/formatters', async (importOriginal) => ({
+  ...(await importOriginal<typeof import('@/i18n/formatters')>()),
+  formatList: (items: string[]) => items.join(', '),
+}))
+
+function brokenEntry(overrides: Partial<BrokenCoverEntry> = {}): BrokenCoverEntry {
+  return { id: 5, title: 'Dune', authors: ['Frank Herbert'], libraryId: 1, libraryName: 'Main', coverSource: 'custom', slots: [], ...overrides }
+}
+
+function orphanEntry(overrides: Partial<OrphanedCoverDirEntry> = {}): OrphanedCoverDirEntry {
+  return { bookId: 42, fileCount: 2, sizeBytes: 10, media: [], ...overrides }
+}
+
+describe('BrokenCoverRow', () => {
+  it('names each broken slot with its source', () => {
+    const wrapper = mount(BrokenCoverRow, {
+      props: {
+        entry: brokenEntry({
+          slots: [
+            { medium: 'ebook', source: 'extracted' },
+            { medium: 'audio', source: 'custom' },
+          ],
+        }),
+        selected: false,
+        disabled: false,
+      },
+    })
+
+    expect(wrapper.findAll('ul li').map((badge) => badge.text())).toEqual([
+      'tools.missingResources.brokenSlot.ebookExtracted',
+      'tools.missingResources.brokenSlot.audioCustom',
+    ])
+  })
+
+  it('keeps the plain cover source for a cover that has no slot yet', () => {
+    const wrapper = mount(BrokenCoverRow, { props: { entry: brokenEntry(), selected: false, disabled: false } })
+
+    expect(wrapper.findAll('ul li').map((badge) => badge.text())).toEqual(['tools.missingResources.coverSource.custom'])
+  })
+})
+
+describe('OrphanedCoverRow', () => {
+  it.each([
+    [['ebook', 'audio'], 'tools.missingResources.table.orphanMedia.both'],
+    [['audio'], 'tools.missingResources.table.orphanMedia.audio'],
+    [['ebook'], 'tools.missingResources.table.orphanMedia.ebook'],
+  ] as const)('names the slot folders %j it holds', (media, label) => {
+    const wrapper = mount(OrphanedCoverRow, { props: { entry: orphanEntry({ media: [...media] }), selected: false, disabled: false } })
+
+    expect(wrapper.text()).toContain(label)
+  })
+
+  it('names no slot for a folder from before covers had slots', () => {
+    const wrapper = mount(OrphanedCoverRow, { props: { entry: orphanEntry(), selected: false, disabled: false } })
+
+    expect(wrapper.text()).not.toContain('orphanMedia')
+  })
+})
diff --git a/client/src/features/tts/components/TtsMiniPlayer.vue b/client/src/features/tts/components/TtsMiniPlayer.vue
index a4c8232de..b98851047 100644
--- a/client/src/features/tts/components/TtsMiniPlayer.vue
+++ b/client/src/features/tts/components/TtsMiniPlayer.vue
@@ -7,6 +7,7 @@ import { useTtsMiniPlayerUi } from '../composables/useTtsMiniPlayerUi'
 import { useTtsVoices } from '../composables/useTtsVoices'
 import TtsMiniPlayerExpanded from './TtsMiniPlayerExpanded.vue'
 import { formatVoiceDisplayName } from '../lib/voice-display'
+import CoverFill from '@/features/book/components/CoverFill.vue'
 
 const { playbackState, currentBook, currentBlockIndex, currentChapterIndex, speed, currentProviderId, currentVoiceId, togglePlayPause } =
   useTtsPlayer()
@@ -209,12 +210,7 @@ onUnmounted(() => {
           :aria-label="playbackState === 'playing' ? t('tts.player.pause') : t('tts.player.play')"
           @click="togglePlayPause"
         >
-          <img
-            v-if="currentBook?.coverUrl"
-            :src="currentBook.coverUrl"
-            alt=""
-            class="absolute inset-0 w-full h-full object-cover rounded-full opacity-20"
-          />
+          <CoverFill v-if="currentBook?.coverUrl" :src="currentBook.coverUrl" class="absolute inset-0 rounded-full opacity-20" />
           <Pause v-if="playbackState === 'playing'" class="relative w-6 h-6" />
           <Play v-else class="relative w-6 h-6" />
         </button>
@@ -237,7 +233,7 @@ onUnmounted(() => {
             :aria-label="t('tts.player.openDetails')"
             @click="openExpanded"
           >
-            <img v-if="currentBook?.coverUrl" :src="currentBook.coverUrl" alt="" class="w-full h-full object-cover" />
+            <CoverFill v-if="currentBook?.coverUrl" :src="currentBook.coverUrl" />
             <Headphones v-else class="w-4 h-4 text-muted-foreground" />
           </button>
 
diff --git a/client/src/features/tts/components/TtsMiniPlayerExpanded.vue b/client/src/features/tts/components/TtsMiniPlayerExpanded.vue
index 6dc9915ff..63342dbec 100644
--- a/client/src/features/tts/components/TtsMiniPlayerExpanded.vue
+++ b/client/src/features/tts/components/TtsMiniPlayerExpanded.vue
@@ -10,6 +10,7 @@ import TtsSpeedControl from './TtsSpeedControl.vue'
 import TtsSleepTimerPicker from './TtsSleepTimerPicker.vue'
 import TtsVoicePicker from './TtsVoicePicker.vue'
 import { formatVoiceDisplayName, formatVoiceLocaleLabel } from '../lib/voice-display'
+import CoverFill from '@/features/book/components/CoverFill.vue'
 
 const emit = defineEmits<{ close: [] }>()
 
@@ -180,7 +181,7 @@ async function handleSaveDefaultVoice() {
   <div class="bg-card border border-border rounded-xl shadow-2xl p-4 space-y-4">
     <div class="flex items-start gap-3">
       <div class="flex-shrink-0 w-16 h-20 rounded-lg bg-muted overflow-hidden flex items-center justify-center">
-        <img v-if="currentBook?.coverUrl" :src="currentBook.coverUrl" alt="" class="w-full h-full object-cover" />
+        <CoverFill v-if="currentBook?.coverUrl" :src="currentBook.coverUrl" />
         <Headphones v-else class="w-8 h-8 text-muted-foreground" />
       </div>
       <div class="flex-1 min-w-0">
diff --git a/client/src/features/tts/composables/useTtsMediaSession.ts b/client/src/features/tts/composables/useTtsMediaSession.ts
index ddcd9377d..657a4b559 100644
--- a/client/src/features/tts/composables/useTtsMediaSession.ts
+++ b/client/src/features/tts/composables/useTtsMediaSession.ts
@@ -1,14 +1,40 @@
 import type { TtsCurrentBook } from '../lib/tts-state'
+import { createCoverFillArtworkUrl } from '@/features/book/lib/cover-fill-artwork'
 
 export function useTtsMediaSession() {
+  let artworkUrl: string | null = null
+  let metadataRevision = 0
+
+  function releaseArtwork() {
+    metadataRevision++
+    if (!artworkUrl) return
+    URL.revokeObjectURL(artworkUrl)
+    artworkUrl = null
+  }
+
   function setMetadata(book: TtsCurrentBook) {
     if (!('mediaSession' in navigator)) return
-    const artwork: MediaImage[] = book.coverUrl ? [{ src: book.coverUrl, sizes: '512x512', type: 'image/jpeg' }] : []
-    navigator.mediaSession.metadata = new MediaMetadata({
-      title: book.title,
-      artist: book.author ?? '',
-      album: 'BookOrbit',
-      artwork,
+    releaseArtwork()
+    const revision = metadataRevision
+    const metadata = (artwork: MediaImage[] = []) =>
+      new MediaMetadata({
+        title: book.title,
+        artist: book.author ?? '',
+        album: 'BookOrbit',
+        artwork,
+      })
+
+    navigator.mediaSession.metadata = metadata()
+    if (!book.coverUrl) return
+
+    void createCoverFillArtworkUrl(book.coverUrl).then((nextArtworkUrl) => {
+      if (!nextArtworkUrl) return
+      if (revision !== metadataRevision) {
+        URL.revokeObjectURL(nextArtworkUrl)
+        return
+      }
+      artworkUrl = nextArtworkUrl
+      navigator.mediaSession.metadata = metadata([{ src: nextArtworkUrl, sizes: '512x512', type: 'image/jpeg' }])
     })
   }
 
@@ -28,6 +54,7 @@ export function useTtsMediaSession() {
 
   function clearHandlers() {
     if (!('mediaSession' in navigator)) return
+    releaseArtwork()
     navigator.mediaSession.setActionHandler('play', null)
     navigator.mediaSession.setActionHandler('pause', null)
     navigator.mediaSession.setActionHandler('previoustrack', null)
diff --git a/client/src/lib/__tests__/roving-index.spec.ts b/client/src/lib/__tests__/roving-index.spec.ts
new file mode 100644
index 000000000..b7ec3b2fc
--- /dev/null
+++ b/client/src/lib/__tests__/roving-index.spec.ts
@@ -0,0 +1,26 @@
+// @vitest-environment node
+import { describe, expect, it } from 'vitest'
+import { nextRovingIndex } from '../roving-index'
+
+describe('nextRovingIndex', () => {
+  it('moves forward and back, wrapping at both ends', () => {
+    expect(nextRovingIndex('ArrowRight', 0, 2)).toBe(1)
+    expect(nextRovingIndex('ArrowDown', 1, 2)).toBe(0)
+    expect(nextRovingIndex('ArrowLeft', 0, 2)).toBe(1)
+    expect(nextRovingIndex('ArrowUp', 1, 3)).toBe(0)
+  })
+
+  it('jumps to the ends', () => {
+    expect(nextRovingIndex('Home', 2, 3)).toBe(0)
+    expect(nextRovingIndex('End', 0, 3)).toBe(2)
+  })
+
+  it('treats an unselected group as starting from the first item', () => {
+    expect(nextRovingIndex('ArrowRight', -1, 3)).toBe(1)
+  })
+
+  it('ignores other keys and empty groups', () => {
+    expect(nextRovingIndex('Enter', 0, 2)).toBeNull()
+    expect(nextRovingIndex('ArrowRight', 0, 0)).toBeNull()
+  })
+})
diff --git a/client/src/lib/roving-index.ts b/client/src/lib/roving-index.ts
new file mode 100644
index 000000000..cf8147a43
--- /dev/null
+++ b/client/src/lib/roving-index.ts
@@ -0,0 +1,22 @@
+/**
+ * The index a radio group's arrow, Home and End keys move to, wrapping at both ends, or null
+ * when the key is not one a radio group handles.
+ */
+export function nextRovingIndex(key: string, index: number, count: number): number | null {
+  if (count <= 0) return null
+  const current = index < 0 ? 0 : index
+  switch (key) {
+    case 'ArrowRight':
+    case 'ArrowDown':
+      return (current + 1) % count
+    case 'ArrowLeft':
+    case 'ArrowUp':
+      return (current - 1 + count) % count
+    case 'Home':
+      return 0
+    case 'End':
+      return count - 1
+    default:
+      return null
+  }
+}
diff --git a/client/src/locales/en.json b/client/src/locales/en.json
index 496516c86..177269b38 100644
--- a/client/src/locales/en.json
+++ b/client/src/locales/en.json
@@ -1504,6 +1504,7 @@
         "subtitle": "Subtitle",
         "description": "Description",
         "cover": "Cover",
+        "audioCover": "Audiobook cover",
         "authors": "Authors",
         "publisher": "Publisher",
         "publishedYear": "Published year",
@@ -1688,6 +1689,7 @@
         "clearAllProviders": "Clear All Providers",
         "clearAll": "Clear All",
         "resetToDefault": "Reset to Default",
+        "bookCover": "Book cover",
         "reset": "Reset",
         "dragProvidersHint": "Drag providers from here onto any field to add them",
         "dragProviderHere": "drag a provider here",
@@ -1822,6 +1824,7 @@
           "makeFirst": "Make first everywhere",
           "makeLast": "Make last everywhere",
           "removeEverywhere": "Remove from all fields",
+          "audioCoverOrderKept": "Reordering skips the Audiobook cover rule, which keeps audiobook sources first.",
           "allFields": "All fields",
           "overridesOnly": "Overrides only",
           "clearFilters": "Clear filters"
@@ -4805,6 +4808,12 @@
       "openAs": "Open as {format}",
       "openReadAlong": "Open read-along EPUB"
     },
+    "coverRegeneration": {
+      "failed": "Could not regenerate the cover",
+      "bulkInProgress": "Re-extracting covers",
+      "bulkFailed": "Could not re-extract covers",
+      "bulkCompleted": "Re-extracted {updated} of {processed, plural, one {# cover} other {# covers}}"
+    },
     "readStatus": {
       "unread": "Unread",
       "wantToRead": "Want to Read",
@@ -4897,6 +4906,7 @@
         "isbn": "ISBN",
         "metadataScore": "Metadata Score",
         "cover": "Cover",
+        "audioCover": "Audiobook Cover",
         "lockStatus": "Lock Status",
         "seriesStatus": "Series Status"
       },
@@ -5200,7 +5210,32 @@
         "saving": "Saving...",
         "saveCover": "Save cover",
         "revertToOriginal": "Revert to original",
-        "regenerateCover": "Regenerate Cover"
+        "regenerateCover": "Regenerate Cover",
+        "slotsLabel": "Cover to edit",
+        "slotEbook": "Book",
+        "slotAudio": "Audiobook",
+        "slotEbookName": "Book cover",
+        "slotAudioName": "Audiobook cover",
+        "editingEbook": "Editing the book cover",
+        "editingAudio": "Editing the audiobook cover",
+        "lockEbookCover": "Lock book cover",
+        "unlockEbookCover": "Unlock book cover",
+        "lockAudioCover": "Lock audiobook cover",
+        "unlockAudioCover": "Unlock audiobook cover",
+        "viewLarger": "View larger",
+        "viewLargerEbook": "View larger book cover",
+        "viewLargerAudio": "View larger audiobook cover",
+        "sourceMode": "Image source",
+        "urlLabel": "Image URL",
+        "saveFailed": "Could not save the cover",
+        "revertFailed": "Could not revert the cover"
+      },
+      "coverLightbox": {
+        "title": "Cover preview",
+        "description": "The full-size cover. Press Escape to close.",
+        "switchLabel": "Cover to show",
+        "ebook": "Book",
+        "audio": "Audiobook"
       },
       "coverSearch": {
         "title": "Online Search",
@@ -5241,6 +5276,7 @@
           "cancelEditAria": "Cancel personal review edit"
         },
         "editCover": "Edit cover",
+        "viewCover": "View larger cover",
         "finished": "Finished",
         "resetFileProgress": "Reset file progress",
         "resetting": "Resetting...",
@@ -5380,6 +5416,7 @@
         "loadFromFileTooltip": "Load metadata from the primary book file",
         "writeToFile": "Write to file",
         "autoFill": "Auto-fill",
+        "autoFillFailed": "Auto-fill failed",
         "fetchingMetadata": "Fetching metadata...",
         "noExistingProviderIds": "No metadata fetched: none of the active Field Rule providers has an ID stored on this book.",
         "allFieldsLocked": "All fields are locked",
@@ -5449,9 +5486,19 @@
           "hideUnchanged": "Hide unchanged",
           "showUnchanged": "Show unchanged",
           "current": "Current",
+          "new": "New",
           "noMetadata": "No metadata available from this source.",
           "noChangedFields": "No changed or missing fields. Use Show unchanged to inspect everything.",
-          "applyToForm": "Apply to form"
+          "applyToForm": "Apply to form",
+          "secondCover": {
+            "audioResults": "Audiobook cover results",
+            "bookResults": "Book cover results",
+            "showCover": "Show the {provider} cover, {index} of {total}",
+            "searchingAudio": "Searching audiobook editions...",
+            "searchingBook": "Searching book editions...",
+            "noAudio": "No audiobook covers found.",
+            "noBook": "No book covers found."
+          }
         },
         "diff": {
           "locked": "Locked",
@@ -5460,8 +5507,14 @@
           "newCoverAlt": "New cover",
           "pickCoverFromProvider": "Pick cover from another provider",
           "pickCoverSource": "Pick cover source",
+          "coverShapeHint": {
+            "portraitForAudio": "Portrait image. Audiobook covers are square.",
+            "squareForBook": "Square image. Book covers are portrait."
+          },
           "pickFromProvider": "Pick from another provider",
           "pickSource": "Pick source",
+          "useNew": "Use the new {field}",
+          "keepCurrent": "Keep the current {field}",
           "genreWriteMode": {
             "label": "How to apply genres",
             "merge": "Merge",
@@ -5470,7 +5523,57 @@
           "empty": "empty",
           "showLess": "Show less",
           "showMore": "Show more",
-          "coverPreviewAlt": "Cover preview"
+          "coverPreviewAlt": "Cover preview",
+          "fields": {
+            "coverUrl": "Cover",
+            "bookCover": "Book cover",
+            "audioCover": "Audiobook cover",
+            "title": "Title",
+            "subtitle": "Subtitle",
+            "authors": "Authors",
+            "description": "Description",
+            "publisher": "Publisher",
+            "publishedDate": "Published",
+            "language": "Language",
+            "pageCount": "Page count",
+            "communityRating": "Community rating",
+            "seriesName": "Series",
+            "seriesIndex": "Series index",
+            "isbn13": "ISBN-13",
+            "isbn10": "ISBN-10",
+            "genres": "Genres",
+            "narrators": "Narrators",
+            "durationSeconds": "Duration (seconds)",
+            "abridged": "Abridged",
+            "hardcoverEditionId": "Hardcover edition ID",
+            "comicIssueNumber": "Issue number",
+            "comicVolumeName": "Volume",
+            "comicPencillers": "Pencillers",
+            "comicInkers": "Inkers",
+            "comicColorists": "Colorists",
+            "comicLetterers": "Letterers",
+            "comicCoverArtists": "Cover artists",
+            "comicCharacters": "Characters",
+            "comicTeams": "Teams",
+            "comicLocations": "Locations",
+            "comicStoryArcs": "Story arcs",
+            "sourceUrl": "Source URL"
+          },
+          "providerIds": {
+            "google": "Google Books ID",
+            "goodreads": "Goodreads ID",
+            "amazon": "Amazon ID",
+            "hardcover": "Hardcover ID",
+            "openLibrary": "Open Library ID",
+            "itunes": "iTunes ID",
+            "audible": "Audible ID",
+            "librofm": "Libro.fm ISBN",
+            "comicvine": "ComicVine ID",
+            "ranobedb": "RanobeDB ID",
+            "kobo": "Kobo ID",
+            "lubimyczytac": "LubimyCzytac ID",
+            "aladin": "Aladin ID"
+          }
         },
         "searchDrawer": {
           "searchTitle": "Search Metadata",
@@ -6147,6 +6250,15 @@
       "chips": {
         "addPlaceholder": "Add..."
       },
+      "quickFilter": {
+        "presentFiles": "Filter to present files",
+        "missingFiles": "Filter to missing files",
+        "withCovers": "Filter to books with covers",
+        "missingCovers": "Filter to books missing covers",
+        "missingAudioCovers": "Filter to books missing audiobook covers",
+        "withValues": "Filter to rows with values",
+        "emptyRows": "Filter to empty rows"
+      },
       "cover": {
         "previewDescription": "Book cover preview",
         "editDescription": "Edit book cover",
@@ -8324,7 +8436,8 @@
           "title": "Cover style",
           "portrait": "Portrait",
           "square": "Square",
-          "hint": "Portrait for ebook or mixed libraries. Square for audiobook-only libraries."
+          "hint": "Portrait for ebook or mixed libraries. Square for audiobook-only libraries.",
+          "hintSlots": "Portrait for ebook or mixed libraries, square for audiobook-only libraries. A book with both an ebook and an audiobook shows its book cover in a portrait library and its audiobook cover in a square one."
         },
         "icon": {
           "label": "Icon",
@@ -10328,10 +10441,21 @@
         "extracted": "Extracted",
         "custom": "Custom"
       },
+      "brokenSlot": {
+        "ebookExtracted": "Book cover, extracted",
+        "ebookCustom": "Book cover, custom",
+        "audioExtracted": "Audiobook cover, extracted",
+        "audioCustom": "Audiobook cover, custom"
+      },
       "table": {
         "selectPage": "Select everything on this page",
         "coverFolder": "Cover folder for book #{bookId}",
-        "fileCount": "{count, plural, one {# file} other {# files}}"
+        "fileCount": "{count, plural, one {# file} other {# files}}",
+        "orphanMedia": {
+          "ebook": "Book cover",
+          "audio": "Audiobook cover",
+          "both": "Book and audiobook covers"
+        }
       },
       "confirm": {
         "title": "Clean missing resources?",
diff --git a/client/src/views/BookDetailView.vue b/client/src/views/BookDetailView.vue
index 3b8c69e9c..8e923f13d 100644
--- a/client/src/views/BookDetailView.vue
+++ b/client/src/views/BookDetailView.vue
@@ -63,7 +63,7 @@ const { bookDetailCoverTint } = useDisplaySettings()
 const tintSource = computed(() => {
   const book = detail.value
   if (bookDetailCoverTint.value === 'off' || tab.value !== 'details' || !book || book.coverSource === null) return null
-  return coverUrl(book.id, 'cover', book.updatedAt ?? book.addedAt)
+  return coverUrl(book.id, 'cover', book.coverVersion)
 })
 const { tint } = useCoverTint(tintSource)
 const coverTint = computed(() => {
@@ -126,8 +126,9 @@ function onLocksChanged(lockedFields: BookMetadataLockField[]) {
   if (detail.value) detail.value.lockedFields = lockedFields
 }
 
-function onCoverChanged(source: 'extracted' | 'custom' | null) {
-  if (detail.value) detail.value = { ...detail.value, coverSource: source }
+// A cover write can change either slot, the summary and the face version, so take the server's view.
+function onCoverChanged() {
+  void fetch(bookId.value)
 }
 </script>
 
diff --git a/client/src/views/BookEditMetadataView.vue b/client/src/views/BookEditMetadataView.vue
index 8fa450744..53abbbf6d 100644
--- a/client/src/views/BookEditMetadataView.vue
+++ b/client/src/views/BookEditMetadataView.vue
@@ -27,8 +27,9 @@ function onMetadataSaved(updated: BookDetail) {
   detail.value = updated
 }
 
-function onCoverChanged(source: 'extracted' | 'custom' | null) {
-  if (detail.value) detail.value = { ...detail.value, coverSource: source }
+// A cover write can change either slot, the summary and the face version, so take the server's view.
+function onCoverChanged() {
+  void fetch(bookId.value)
 }
 
 function onFileRenamed() {
diff --git a/client/src/views/__tests__/BookDetailView.spec.ts b/client/src/views/__tests__/BookDetailView.spec.ts
index a2422d8f3..734844ac0 100644
--- a/client/src/views/__tests__/BookDetailView.spec.ts
+++ b/client/src/views/__tests__/BookDetailView.spec.ts
@@ -85,6 +85,9 @@ function makeBook(overrides: Partial<BookDetail> = {}): BookDetail {
     personalNoteUpdatedAt: null,
     communityRatings: [],
     coverSource: null,
+    coverMedia: [],
+    covers: { ebook: null, audio: null },
+    coverVersion: 'legacy:2024-01-01T00:00:00.000Z',
     hardcoverEditionId: null,
     providerIds: {},
     authors: [],
diff --git a/client/vite.config.ts b/client/vite.config.ts
index 996af90f8..96d0f1727 100644
--- a/client/vite.config.ts
+++ b/client/vite.config.ts
@@ -94,7 +94,7 @@ export default defineConfig({
         navigateFallbackDenylist: [/^\/api\//],
         runtimeCaching: [
           {
-            urlPattern: /^.*\/api\/v1\/books\/\d+\/cover(\?.*)?$/,
+            urlPattern: /^.*\/api\/v1\/books\/\d+\/cover\?(?:[^#]*&)?t=[^#]*$/,
             handler: 'CacheFirst',
             options: {
               cacheName: 'book-covers',
@@ -108,7 +108,7 @@ export default defineConfig({
             },
           },
           {
-            urlPattern: /^.*\/api\/v1\/books\/\d+\/thumbnail(\?.*)?$/,
+            urlPattern: /^.*\/api\/v1\/books\/\d+\/thumbnail\?(?:[^#]*&)?t=[^#]*$/,
             handler: 'CacheFirst',
             options: {
               cacheName: 'book-thumbnails',
@@ -121,6 +121,34 @@ export default defineConfig({
               },
             },
           },
+          {
+            urlPattern: /^.*\/api\/v1\/books\/\d+\/cover(\?.*)?$/,
+            handler: 'StaleWhileRevalidate',
+            options: {
+              cacheName: 'book-covers',
+              expiration: {
+                maxEntries: 200,
+                maxAgeSeconds: 60 * 60 * 24 * 30,
+              },
+              cacheableResponse: {
+                statuses: [0, 200],
+              },
+            },
+          },
+          {
+            urlPattern: /^.*\/api\/v1\/books\/\d+\/thumbnail(\?.*)?$/,
+            handler: 'StaleWhileRevalidate',
+            options: {
+              cacheName: 'book-thumbnails',
+              expiration: {
+                maxEntries: 200,
+                maxAgeSeconds: 60 * 60 * 24 * 30,
+              },
+              cacheableResponse: {
+                statuses: [0, 200],
+              },
+            },
+          },
         ],
       },
       devOptions: {
diff --git a/packages/types/src/book.ts b/packages/types/src/book.ts
index c8ecba807..2b8a37e1d 100644
--- a/packages/types/src/book.ts
+++ b/packages/types/src/book.ts
@@ -103,6 +103,35 @@ export type BookMediaProfile = {
 
 type BookMediaFile = Pick<BookFileRef, "format" | "role">;
 
+export const COVER_MEDIA = ["ebook", "audio"] as const;
+export type CoverMedium = (typeof COVER_MEDIA)[number];
+
+type CoverMediaFile = BookMediaFile & {
+  mediaOverlay?: Pick<EpubMediaOverlayCapability, "available"> | null;
+  mediaOverlayAvailable?: boolean | null;
+};
+
+export type CoverMedia = {
+  hasEbook: boolean;
+  hasAudio: boolean;
+};
+
+export function getCoverMedia(files: readonly CoverMediaFile[]): CoverMedia {
+  let hasEbook = false;
+  let hasAudio = false;
+
+  for (const file of files) {
+    if (file.role !== "content" && file.role !== "primary") continue;
+    const format = file.format?.trim().toLowerCase();
+    if (!format) continue;
+    if (isAudioFormat(format)) hasAudio = true;
+    else hasEbook = true;
+    if (format === "epub" && (file.mediaOverlay?.available === true || file.mediaOverlayAvailable === true)) hasAudio = true;
+  }
+
+  return { hasEbook, hasAudio };
+}
+
 export function getPrimaryBookFile<T extends BookMediaFile>(files: readonly T[]): T | null {
   return files.find((file) => file.role === "primary") ?? files.find((file) => file.format != null) ?? files[0] ?? null;
 }
@@ -154,6 +183,7 @@ export type BookCard = {
   readStatus: UserBookStatus | null;
   addedAt: string;
   updatedAt: string | null;
+  coverVersion: string;
   metadataScore: number | null;
   hasCover: boolean;
   hasMetadataLocks: boolean;
@@ -195,11 +225,7 @@ export type ReadAloudProgressSyncMode = "auto" | "disabled";
 
 export type ReadAloudProgressSyncState = "enabled" | "disabled" | "unavailable";
 
-export type ReadAloudProgressSyncUnavailableReason =
-  | "no_media_overlay_epub"
-  | "no_audio_files"
-  | "missing_duration"
-  | "duration_mismatch";
+export type ReadAloudProgressSyncUnavailableReason = "no_media_overlay_epub" | "no_audio_files" | "missing_duration" | "duration_mismatch";
 
 export type ReadAloudProgressSync = {
   mode: ReadAloudProgressSyncMode;
@@ -250,6 +276,9 @@ export type BookDetail = {
   personalNoteUpdatedAt: string | null;
   communityRatings: BookCommunityRating[];
   coverSource: "extracted" | "custom" | null;
+  coverMedia: CoverMedium[];
+  covers: Record<CoverMedium, BookCoverSlot | null>;
+  coverVersion: string;
   hardcoverEditionId: string | null;
   providerIds: ProviderIds;
   authors: { id: number; name: string; sortName: string | null }[];
@@ -269,6 +298,13 @@ export type BookDetail = {
   fileWriteStatus?: BookFileWriteStatus;
 };
 
+export type BookCoverSlot = {
+  source: "extracted" | "custom";
+  updatedAt: string;
+  width: number | null;
+  height: number | null;
+};
+
 export type BookMetadataSaveResult = {
   book: BookDetail;
   write: WriteResult | null;
@@ -291,6 +327,7 @@ export type BookMetadataRefreshPreviewFields = {
   seriesMemberships?: MetadataSeriesMembership[] | null;
   communityRatings?: BookCommunityRating[];
   coverUrl?: string;
+  audioCoverUrl?: string;
   googleBooksId?: string | null;
   goodreadsId?: string | null;
   amazonId?: string | null;
diff --git a/packages/types/src/maintenance.ts b/packages/types/src/maintenance.ts
index 23d937500..6e91b49d5 100644
--- a/packages/types/src/maintenance.ts
+++ b/packages/types/src/maintenance.ts
@@ -1,3 +1,5 @@
+import type { CoverMedium } from "./book";
+
 export const MISSING_RESOURCE_CATEGORIES = ["missing_books", "broken_covers", "orphaned_cover_dirs"] as const;
 export type MissingResourceCategory = (typeof MISSING_RESOURCE_CATEGORIES)[number];
 
@@ -35,6 +37,11 @@ export type MissingBookEntry = {
   updatedAt: string | null;
 };
 
+export type BrokenCoverSlot = {
+  medium: CoverMedium;
+  source: "extracted" | "custom";
+};
+
 export type BrokenCoverEntry = {
   id: number;
   title: string | null;
@@ -42,12 +49,16 @@ export type BrokenCoverEntry = {
   libraryId: number;
   libraryName: string;
   coverSource: "extracted" | "custom";
+  /** The slots whose image is gone. Empty for a cover the upgrade has not moved into a slot yet. */
+  slots: BrokenCoverSlot[];
 };
 
 export type OrphanedCoverDirEntry = {
   bookId: number;
   fileCount: number;
   sizeBytes: number;
+  /** The slot folders it holds. Empty for a folder from before covers had slots. */
+  media: CoverMedium[];
 };
 
 export type MissingResourcePage<TEntry> = {
diff --git a/packages/types/src/metadata-fetch.ts b/packages/types/src/metadata-fetch.ts
index e43292c97..ac9b935bc 100644
--- a/packages/types/src/metadata-fetch.ts
+++ b/packages/types/src/metadata-fetch.ts
@@ -1,4 +1,5 @@
 import type { AudiobookChapter, NarratorRef } from "./audiobook";
+import type { CoverMedium } from "./book";
 import type { SeriesIndex } from "./series-index";
 
 export const MetadataProviderKey = {
@@ -59,6 +60,33 @@ export interface BookCommunityRating {
   updatedAt: string | null;
 }
 
+/**
+ * The shape of a candidate's cover as the provider knows it, without downloading the image. A
+ * provider that cannot tell (a book-level image that may belong to any edition) says `unknown`.
+ */
+export type MetadataCoverShape = "square" | "portrait" | "unknown";
+
+/**
+ * Width over height from this ratio through `SQUARE_COVER_MAX_RATIO` reads as square art. Measured
+ * on provider covers in September 2026: real audiobook art sat at 0.998-1.000, while portrait
+ * jackets padded to 0.93 and box-set photos came between 0.90 and 0.95, so the floor sits above them.
+ */
+export const SQUARE_COVER_MIN_RATIO = 0.95;
+export const SQUARE_COVER_MAX_RATIO = 1.1;
+/** Width over height at or below this reads as a portrait jacket; real ebook art reached 0.85. */
+export const PORTRAIT_COVER_MAX_RATIO = 0.85;
+/** Provider placeholders and search thumbnails are smaller than this on their short side; no real cover is. */
+export const MIN_COVER_SHORT_SIDE_PX = 150;
+
+/** The shape of a cover of this size, or `unknown` for a size that is neither square nor portrait. */
+export function coverShapeFromSize(width: number | null | undefined, height: number | null | undefined): MetadataCoverShape {
+  if (!width || !height || width <= 0 || height <= 0) return "unknown";
+  const ratio = width / height;
+  if (ratio >= SQUARE_COVER_MIN_RATIO && ratio <= SQUARE_COVER_MAX_RATIO) return "square";
+  if (ratio <= PORTRAIT_COVER_MAX_RATIO) return "portrait";
+  return "unknown";
+}
+
 export interface MetadataCandidate {
   provider: MetadataProviderKey;
   providerId: string;
@@ -83,6 +111,10 @@ export interface MetadataCandidate {
   seriesMemberships?: MetadataSeriesMembership[];
   genres?: string[];
   coverUrl?: string;
+  coverShape?: MetadataCoverShape;
+  /** Pixel size of the cover when the provider states it, so a shape can be checked without a download. */
+  coverWidth?: number;
+  coverHeight?: number;
   sourceUrl?: string;
   narrators?: string[];
   durationSeconds?: number;
@@ -101,6 +133,8 @@ export interface MetadataProviderInfo {
   selectedByFieldRules?: boolean;
   /** Zero-based priority for the effective Cover field rule. Absent when the provider is not used for covers. */
   coverPriority?: number;
+  /** Zero-based priority for the effective Audiobook cover field rule. Absent when the provider is not used for it. */
+  audioCoverPriority?: number;
 }
 
 /**
@@ -120,6 +154,12 @@ export interface MetadataProviderSearchStatus {
 export type MetadataFetchEmptyReason =
   "no_active_providers" | "no_existing_provider_ids" | "providers_throttled" | "no_candidates" | "no_resolved_fields";
 
+/** How a fetch settled one cover slot. `pass` 2 is the re-query for a book's other medium. */
+export interface MetadataFetchCoverSlotDiagnostics {
+  provider: MetadataProviderKey | null;
+  pass: 1 | 2 | null;
+}
+
 export interface MetadataFetchDiagnostics {
   reason: MetadataFetchEmptyReason | null;
   activeProviders: MetadataProviderKey[];
@@ -130,6 +170,8 @@ export interface MetadataFetchDiagnostics {
   candidateProviders: MetadataProviderKey[];
   candidateCount: number;
   resolvedFieldCount: number;
+  /** One entry per cover slot the fetch applied to; a slot outside the book's media is absent. */
+  coverSlots?: Partial<Record<CoverMedium, MetadataFetchCoverSlotDiagnostics>>;
 }
 
 export interface ProviderThrottleRuntimeState {
diff --git a/packages/types/src/metadata-lock.ts b/packages/types/src/metadata-lock.ts
index 71c8656ac..2a3124bd6 100644
--- a/packages/types/src/metadata-lock.ts
+++ b/packages/types/src/metadata-lock.ts
@@ -44,6 +44,7 @@ export const BOOK_METADATA_LOCK_FIELDS = [
   "comicTeams",
   "comicLocations",
   "cover",
+  "audioCover",
 ] as const;
 
 export type BookMetadataLockField = (typeof BOOK_METADATA_LOCK_FIELDS)[number];
diff --git a/packages/types/src/metadata-preferences.ts b/packages/types/src/metadata-preferences.ts
index 802f07a6e..a7f44824e 100644
--- a/packages/types/src/metadata-preferences.ts
+++ b/packages/types/src/metadata-preferences.ts
@@ -5,6 +5,7 @@ export type MetadataField =
   | "subtitle"
   | "description"
   | "cover"
+  | "audioCover"
   | "authors"
   | "publisher"
   | "publishedYear"
@@ -23,6 +24,7 @@ export const ALL_METADATA_FIELDS: MetadataField[] = [
   "subtitle",
   "description",
   "cover",
+  "audioCover",
   "authors",
   "publisher",
   "publishedYear",
diff --git a/packages/types/src/query.ts b/packages/types/src/query.ts
index 1229e62ab..92c666c4f 100644
--- a/packages/types/src/query.ts
+++ b/packages/types/src/query.ts
@@ -21,6 +21,8 @@ import type { CommunityRatingProviderKey } from "./metadata-fetch";
  * - `fileSize` - resolved via `book_files.size_bytes` (primary file; rule values are bytes)
  * - `isbn` - matches both `isbn10` and `isbn13` in `book_metadata`
  * - `publishedDate` - uses full dates when available and falls back to published year
+ * - `cover` - either cover slot filled (`book_metadata.cover_source` is the summary of both)
+ * - `audioCover` - books whose cover media include audio, by whether their audio cover slot is filled
  * - `lockStatus` - derived from `book_metadata.locked_fields` (non-empty array = locked)
  * - `seriesStatus` - computed per-user: "up next in series" (next unstarted book whose earlier series entries are all finished)
  *
@@ -55,6 +57,7 @@ export type StaticRuleField =
   | "isbn"
   | "metadataScore"
   | "cover"
+  | "audioCover"
   | "lockStatus"
   | "seriesStatus";
 
@@ -131,6 +134,7 @@ export const FIELD_OPERATORS: Record<StaticRuleField, RuleOperator[]> = {
   isbn: ["isEmpty", "isNotEmpty", "eq"],
   metadataScore: ["gt", "gte", "lt", "lte", "between", "isEmpty", "isNotEmpty"],
   cover: ["isMissing", "isPresent"],
+  audioCover: ["isMissing", "isPresent"],
   lockStatus: ["isLocked", "isUnlocked"],
   seriesStatus: ["isUpNext"],
 };
diff --git a/packages/types/src/scanner.ts b/packages/types/src/scanner.ts
index 1f33abebe..cb9d53da4 100644
--- a/packages/types/src/scanner.ts
+++ b/packages/types/src/scanner.ts
@@ -38,8 +38,8 @@ export interface CoverRefreshProgressEvent {
 }
 
 export interface CoverRefreshedEvent {
-  bookId: number;
-  libraryId: number;
+  bookIds: number[];
+  libraryId?: number;
 }
 
 export interface BookMissingEvent {
diff --git a/scripts/e2e/suite-registry.mjs b/scripts/e2e/suite-registry.mjs
index e0e1665eb..e3614e7dd 100644
--- a/scripts/e2e/suite-registry.mjs
+++ b/scripts/e2e/suite-registry.mjs
@@ -51,6 +51,8 @@ export const E2E_SUITES = Object.freeze({
     prepareDedicatedDatabase: true,
     useDedicatedDatabase: true,
     changedPaths: [
+      "server/src/modules/book-cover-store/**",
+      "server/src/modules/metadata/cover-slot-reconciler.service.ts",
       "server/src/modules/scanner/**",
       "server/test/scanner-scenarios.e2e-spec.ts",
       "server/test/e2e/scanner/**",
@@ -69,6 +71,8 @@ export const E2E_SUITES = Object.freeze({
     prepareDedicatedDatabase: true,
     useDedicatedDatabase: true,
     changedPaths: [
+      "server/src/modules/book-cover-store/**",
+      "server/src/modules/metadata/cover-slot-reconciler.service.ts",
       "server/src/modules/scanner/**",
       "server/test/scanner-file-operations.e2e-spec.ts",
       "server/test/e2e/scanner/**",
@@ -133,6 +137,7 @@ export const E2E_SUITES = Object.freeze({
     prepareDedicatedDatabase: true,
     useDedicatedDatabase: true,
     changedPaths: [
+      "server/src/modules/book-cover-store/**",
       "server/src/modules/book-dock/**",
       "server/src/modules/upload/**",
       "server/src/modules/metadata/**",
@@ -152,6 +157,7 @@ export const E2E_SUITES = Object.freeze({
     prepareDedicatedDatabase: true,
     useDedicatedDatabase: true,
     changedPaths: [
+      "server/src/modules/book-cover-store/**",
       "server/src/modules/book/**",
       "server/src/modules/library/**",
       "server/src/modules/file-write/**",
@@ -180,6 +186,7 @@ export const E2E_SUITES = Object.freeze({
       "server/src/modules/metadata-fetch/**",
       "server/src/modules/metadata-preferences/**",
       "server/src/modules/cover/**",
+      "server/src/modules/book-cover-store/**",
       "server/src/modules/scanner/**",
       "server/src/modules/library/**",
       "server/src/modules/auth/**",
@@ -203,6 +210,7 @@ export const E2E_SUITES = Object.freeze({
     useDedicatedDatabase: true,
     changedPaths: [
       "server/src/modules/migration/**",
+      "server/src/modules/book-cover-store/**",
       "server/test/migration-booklore.e2e-spec.ts",
       "server/test/e2e/migration-booklore/**",
       ".github/workflows/e2e-runner.yml",
@@ -259,7 +267,9 @@ export const E2E_SUITES = Object.freeze({
     useDedicatedDatabase: true,
     changedPaths: [
       "server/src/**",
+      "server/src/modules/book-cover-store/**",
       "server/test/authorization-matrix.e2e-spec.ts",
+      "server/test/e2e/slot-cover-artifacts.ts",
       "server/test/e2e/authorization-matrix/**",
       ".github/workflows/e2e-runner.yml",
       ...SHARED_TYPES_PATHS,
@@ -442,11 +452,13 @@ export const E2E_SUITES = Object.freeze({
     useDedicatedDatabase: true,
     changedPaths: [
       "server/src/modules/book/**",
+      "server/src/modules/book-cover-store/**",
       "server/src/modules/library/**",
       "server/src/modules/collection/**",
       "server/src/modules/auth/**",
       "server/src/modules/user/**",
       "server/test/book-api-contract.e2e-spec.ts",
+      "server/test/e2e/slot-cover-artifacts.ts",
       "server/test/e2e/book-api-contract/**",
       ...SHARED_TYPES_PATHS,
       ...SHARED_DB_AND_HELPER_PATHS,
@@ -504,15 +516,38 @@ export const E2E_SUITES = Object.freeze({
     useDedicatedDatabase: true,
     changedPaths: [
       "server/src/modules/library/**",
+      "server/src/modules/book-cover-store/**",
       "server/src/modules/auth/**",
       "server/src/modules/user/**",
       "server/src/modules/role/**",
       "server/test/library-admin-workflows.e2e-spec.ts",
+      "server/test/e2e/slot-cover-artifacts.ts",
       "server/test/e2e/library/**",
       ...SHARED_TYPES_PATHS,
       ...SHARED_DB_AND_HELPER_PATHS,
     ],
   },
+  "missing-resources": {
+    id: "missing-resources",
+    name: "Missing Resources",
+    timeout: 60,
+    lane: "full",
+    description: "Missing Resources cover sweep and cleanup suite",
+    vitestTarget: "test/missing-resources.e2e-spec.ts",
+    junitOutput: `${TEST_RESULTS_DIR}/missing-resources-e2e-junit.xml`,
+    prepareDedicatedDatabase: true,
+    useDedicatedDatabase: true,
+    changedPaths: [
+      "server/src/modules/maintenance/**",
+      "server/src/modules/book-cover-store/**",
+      "server/src/modules/book/**",
+      "server/src/modules/library/**",
+      "server/test/missing-resources.e2e-spec.ts",
+      "server/test/e2e/metadata-write/**",
+      ...SHARED_TYPES_PATHS,
+      ...SHARED_DB_AND_HELPER_PATHS,
+    ],
+  },
   "reader-format-delivery": {
     id: "reader-format-delivery",
     name: "Reader Format Delivery",
@@ -548,6 +583,7 @@ export const E2E_SUITES = Object.freeze({
     changedPaths: [
       "server/src/modules/opds/**",
       "server/src/modules/book/**",
+      "server/src/modules/book-cover-store/**",
       "server/src/modules/library/**",
       "server/src/modules/collection/**",
       "server/src/modules/lens/**",
@@ -578,6 +614,7 @@ export const E2E_SUITES = Object.freeze({
       "server/src/modules/library/**",
       "server/src/modules/auth/**",
       "server/src/modules/cover/**",
+      "server/src/modules/book-cover-store/**",
       "server/src/modules/scanner/**",
       "server/src/modules/seed/**",
       "server/test/email-lifecycle.e2e-spec.ts",
@@ -848,6 +885,7 @@ export const E2E_SUITES = Object.freeze({
     changedPaths: [
       "server/src/modules/kobo/**",
       "server/src/modules/cover/**",
+      "server/src/modules/book-cover-store/**",
       "server/src/modules/metadata/**",
       "server/test/kobo-cover-identity.e2e-spec.ts",
       "server/test/e2e/reader-state-isolation/**",
@@ -888,6 +926,8 @@ export const E2E_SUITES = Object.freeze({
     prepareDedicatedDatabase: true,
     useDedicatedDatabase: true,
     changedPaths: [
+      "server/src/modules/book-cover-store/**",
+      "server/src/modules/metadata/cover-slot-reconciler.service.ts",
       "server/src/modules/library/**",
       "server/src/modules/file-write/**",
       "server/src/modules/scanner/**",
diff --git a/server/.env.example b/server/.env.example
index 4aea18221..59b00e90c 100644
--- a/server/.env.example
+++ b/server/.env.example
@@ -24,6 +24,8 @@ SETUP_BOOTSTRAP_TOKEN=
 # This path resolves relative to server/ (where the process runs).
 # ../local/data points to <project-root>/local/data.
 APP_DATA_PATH=../local/data
+# Use sync for deterministic migration checks, or skip in isolated E2E fixtures.
+COVER_SLOTS_BACKFILL_MODE=background
 
 # Top of the library creation folder picker. Defaults to / when unset.
 # Set this to the server-visible folder where users should create libraries.
diff --git a/server/src/app.module.ts b/server/src/app.module.ts
index 465c3c7b1..00555564d 100644
--- a/server/src/app.module.ts
+++ b/server/src/app.module.ts
@@ -10,6 +10,7 @@ import {
   audiolessEpubConfig,
   authConfig,
   bookRequestConfig,
+  coverSlotsConfig,
   dbConfig,
   emailConfig,
   fileWriteConfig,
@@ -106,6 +107,7 @@ import { PodcastModule } from './modules/podcast/podcast.module';
         dbConfig,
         authConfig,
         storageConfig,
+        coverSlotsConfig,
         fileWriteConfig,
         emailConfig,
         migrationConfig,
diff --git a/server/src/common/book-cover-storage.test.ts b/server/src/common/book-cover-storage.test.ts
index 1fa9cd88d..c9189056e 100644
--- a/server/src/common/book-cover-storage.test.ts
+++ b/server/src/common/book-cover-storage.test.ts
@@ -2,16 +2,18 @@ import { join } from 'path';
 
 import {
   bookCoverDirPath,
-  bookThumbnailPath,
+  bookCoverSlotDirPath,
+  bookCoverSlotThumbnailPath,
   findPreferredBookCoverFileName,
   isCustomBookCoverFileName,
   isExtractedBookCoverFileName,
 } from './book-cover-storage';
 
 describe('book-cover-storage', () => {
-  it('builds cover and thumbnail paths under the book cover directory', () => {
+  it('builds slot cover and thumbnail paths under the book cover directory', () => {
     expect(bookCoverDirPath('/books', 42)).toBe(join('/books', 'covers', '42'));
-    expect(bookThumbnailPath('/books', 42)).toBe(join('/books', 'covers', '42', 'thumbnail.jpg'));
+    expect(bookCoverSlotDirPath('/books', 42, 'audio')).toBe(join('/books', 'covers', '42', 'audio'));
+    expect(bookCoverSlotThumbnailPath('/books', 42, 'ebook')).toBe(join('/books', 'covers', '42', 'ebook', 'thumbnail.jpg'));
   });
 
   it('detects custom and extracted cover file names', () => {
diff --git a/server/src/common/book-cover-storage.ts b/server/src/common/book-cover-storage.ts
index da70137c3..e8ef8563e 100644
--- a/server/src/common/book-cover-storage.ts
+++ b/server/src/common/book-cover-storage.ts
@@ -1,4 +1,5 @@
 import { join } from 'path';
+import type { CoverMedium } from '@bookorbit/types';
 
 export const COVER_CUSTOM_FILE_PREFIX = 'cover_custom.';
 export const COVER_EXTRACTED_FILE_PREFIX = 'cover_extracted.';
@@ -9,8 +10,12 @@ export function bookCoverDirPath(appDataPath: string, bookId: number): string {
   return join(appDataPath, 'covers', String(bookId));
 }
 
-export function bookThumbnailPath(appDataPath: string, bookId: number): string {
-  return join(bookCoverDirPath(appDataPath, bookId), COVER_THUMBNAIL_FILE_NAME);
+export function bookCoverSlotDirPath(appDataPath: string, bookId: number, medium: CoverMedium): string {
+  return join(bookCoverDirPath(appDataPath, bookId), medium);
+}
+
+export function bookCoverSlotThumbnailPath(appDataPath: string, bookId: number, medium: CoverMedium): string {
+  return join(bookCoverSlotDirPath(appDataPath, bookId, medium), COVER_THUMBNAIL_FILE_NAME);
 }
 
 export function isCustomBookCoverFileName(fileName: string): boolean {
diff --git a/server/src/common/utils/book-media.utils.ts b/server/src/common/utils/book-media.utils.ts
index 4bc7cabec..0c839ba68 100644
--- a/server/src/common/utils/book-media.utils.ts
+++ b/server/src/common/utils/book-media.utils.ts
@@ -1,7 +1,14 @@
-import { getBookMediaProfile } from '@bookorbit/types';
+import { getBookMediaProfile, type CoverMedia, type CoverMedium } from '@bookorbit/types';
 
 type BookMediaFileRow = { format: string | null; role: string };
 
+/** What a metadata fetch needs to know about a book's cover slots. */
+export type CoverFetchState = {
+  media: CoverMedia;
+  filled: Record<CoverMedium, boolean>;
+  locked: CoverMedium[];
+};
+
 type AudiobookMetadataSignals = {
   durationSeconds?: number | null;
   audibleId?: string | null;
@@ -17,3 +24,14 @@ export function resolveIsAudiobook(files: readonly BookMediaFileRow[] | undefine
   if (primaryMediaKind !== 'unknown') return primaryMediaKind === 'audiobook';
   return meta?.durationSeconds != null || !!meta?.audibleId || !!meta?.librofmId;
 }
+
+/** The pipeline's view of the slots: each is an existing field when filled, and locked slots are skipped. */
+export function coverFetchInputs(state: CoverFetchState): {
+  existing: { cover: true | null; audioCover: true | null };
+  options: { coverMedia: CoverMedia; lockedCoverSlots: CoverMedium[] };
+} {
+  return {
+    existing: { cover: state.filled.ebook ? true : null, audioCover: state.filled.audio ? true : null },
+    options: { coverMedia: state.media, lockedCoverSlots: state.locked },
+  };
+}
diff --git a/server/src/common/utils/placeholder-cover.utils.test.ts b/server/src/common/utils/placeholder-cover.utils.test.ts
new file mode 100644
index 000000000..84345f847
--- /dev/null
+++ b/server/src/common/utils/placeholder-cover.utils.test.ts
@@ -0,0 +1,14 @@
+import { createHash } from 'crypto';
+
+import { GOOGLE_BOOKS_PLACEHOLDER_HASHES, GOOGLE_BOOKS_PLACEHOLDER_LENGTHS, isKnownPlaceholderCover } from './placeholder-cover.utils';
+
+describe('isKnownPlaceholderCover', () => {
+  it('matches only bytes of the placeholder length and hash', () => {
+    const [length] = [...GOOGLE_BOOKS_PLACEHOLDER_LENGTHS];
+    const sameLength = Buffer.alloc(length!, 1);
+
+    expect(GOOGLE_BOOKS_PLACEHOLDER_HASHES.has(createHash('sha256').update(sameLength).digest('hex'))).toBe(false);
+    expect(isKnownPlaceholderCover(sameLength)).toBe(false);
+    expect(isKnownPlaceholderCover(Buffer.alloc(10))).toBe(false);
+  });
+});
diff --git a/server/src/common/utils/placeholder-cover.utils.ts b/server/src/common/utils/placeholder-cover.utils.ts
new file mode 100644
index 000000000..8c14d5d59
--- /dev/null
+++ b/server/src/common/utils/placeholder-cover.utils.ts
@@ -0,0 +1,13 @@
+import { createHash } from 'crypto';
+
+/**
+ * Fingerprints of the "no cover" image Google Books serves in place of art. It is a full-size
+ * portrait PNG, so neither a size floor nor a shape check can tell it from a real jacket.
+ */
+export const GOOGLE_BOOKS_PLACEHOLDER_LENGTHS: ReadonlySet<number> = new Set([9_103]);
+export const GOOGLE_BOOKS_PLACEHOLDER_HASHES: ReadonlySet<string> = new Set(['3efa8c43e5b4348f303a528c81adf435f0111ea752fe9f0f6241478b60987fa6']);
+
+export function isKnownPlaceholderCover(bytes: Buffer): boolean {
+  if (!GOOGLE_BOOKS_PLACEHOLDER_LENGTHS.has(bytes.length)) return false;
+  return GOOGLE_BOOKS_PLACEHOLDER_HASHES.has(createHash('sha256').update(bytes).digest('hex'));
+}
diff --git a/server/src/config/config.ts b/server/src/config/config.ts
index b7d8c9a45..ba47a5913 100644
--- a/server/src/config/config.ts
+++ b/server/src/config/config.ts
@@ -44,6 +44,10 @@ export const storageConfig = registerAs('storage', () => {
   };
 });
 
+export const coverSlotsConfig = registerAs('coverSlots', () => ({
+  backfillMode: process.env.COVER_SLOTS_BACKFILL_MODE?.trim().toLowerCase() || (process.env.NODE_ENV === 'test' ? 'skip' : 'background'),
+}));
+
 export const fileWriteConfig = registerAs('fileWrite', () => ({
   debounceMs: parsePositiveInteger(process.env.FILE_WRITE_DEBOUNCE_MS, 3_000),
   maxConcurrentWrites: parsePositiveInteger(process.env.FILE_WRITE_MAX_CONCURRENT_WRITES, 2),
diff --git a/server/src/config/env.validation.ts b/server/src/config/env.validation.ts
index 04891c0f1..16cec761d 100644
--- a/server/src/config/env.validation.ts
+++ b/server/src/config/env.validation.ts
@@ -68,6 +68,7 @@ const envSchema = z.object({
   SETUP_BOOTSTRAP_TOKEN: z.string().optional(),
   DISABLE_LOCAL_AUTH: booleanEnvFlag('DISABLE_LOCAL_AUTH'),
   APP_DATA_PATH: z.string().default('/data'),
+  COVER_SLOTS_BACKFILL_MODE: z.enum(['background', 'sync', 'skip']).optional(),
   BOOK_DOCK_PATH: z
     .string()
     .transform((val) => val.trim())
diff --git a/server/src/db/migrations/0097_add_book_covers.sql b/server/src/db/migrations/0097_add_book_covers.sql
new file mode 100644
index 000000000..7ce2a60b4
--- /dev/null
+++ b/server/src/db/migrations/0097_add_book_covers.sql
@@ -0,0 +1,18 @@
+CREATE TABLE "book_covers" (
+	"book_id" integer NOT NULL,
+	"medium" varchar(5) NOT NULL,
+	"source" varchar(9) NOT NULL,
+	"origin" varchar(12) NOT NULL,
+	"width" integer,
+	"height" integer,
+	"updated_at" timestamp with time zone DEFAULT now() NOT NULL,
+	"dormant_since" timestamp with time zone,
+	CONSTRAINT "book_covers_book_id_medium_pk" PRIMARY KEY("book_id","medium"),
+	CONSTRAINT "book_covers_medium_chk" CHECK ("book_covers"."medium" in ('ebook', 'audio')),
+	CONSTRAINT "book_covers_source_chk" CHECK ("book_covers"."source" in ('extracted', 'custom')),
+	CONSTRAINT "book_covers_origin_chk" CHECK ("book_covers"."origin" in ('embedded', 'folder_image', 'opf', 'provider', 'dock', 'upload', 'legacy')),
+	CONSTRAINT "book_covers_width_positive_chk" CHECK ("book_covers"."width" is null or "book_covers"."width" > 0),
+	CONSTRAINT "book_covers_height_positive_chk" CHECK ("book_covers"."height" is null or "book_covers"."height" > 0)
+);
+--> statement-breakpoint
+ALTER TABLE "book_covers" ADD CONSTRAINT "book_covers_book_id_books_id_fk" FOREIGN KEY ("book_id") REFERENCES "public"."books"("id") ON DELETE cascade ON UPDATE no action;
\ No newline at end of file
diff --git a/server/src/db/migrations/meta/0097_snapshot.json b/server/src/db/migrations/meta/0097_snapshot.json
new file mode 100644
index 000000000..2998af324
--- /dev/null
+++ b/server/src/db/migrations/meta/0097_snapshot.json
@@ -0,0 +1,22473 @@
+{
+  "id": "eb343249-d6a3-43a5-9515-a9a9a19b4ece",
+  "prevId": "ec7ea477-6e96-4a59-bab6-8f0ead7280bd",
+  "version": "7",
+  "dialect": "postgresql",
+  "tables": {
+    "public.audit_log": {
+      "name": "audit_log",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "bigserial",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "actor_username": {
+          "name": "actor_username",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "action": {
+          "name": "action",
+          "type": "varchar(100)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "resource": {
+          "name": "resource",
+          "type": "varchar(100)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "resource_id": {
+          "name": "resource_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "ip": {
+          "name": "ip",
+          "type": "varchar(45)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "meta": {
+          "name": "meta",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "idx_audit_user_id": {
+          "name": "idx_audit_user_id",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "idx_audit_actor_username": {
+          "name": "idx_audit_actor_username",
+          "columns": [
+            {
+              "expression": "actor_username",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "idx_audit_actor_username_trgm": {
+          "name": "idx_audit_actor_username_trgm",
+          "columns": [
+            {
+              "expression": "actor_username",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last",
+              "opclass": "gin_trgm_ops"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "gin",
+          "with": {}
+        },
+        "idx_audit_resource": {
+          "name": "idx_audit_resource",
+          "columns": [
+            {
+              "expression": "resource",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "resource_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "idx_audit_resource_id": {
+          "name": "idx_audit_resource_id",
+          "columns": [
+            {
+              "expression": "resource_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "idx_audit_resource_trgm": {
+          "name": "idx_audit_resource_trgm",
+          "columns": [
+            {
+              "expression": "resource",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last",
+              "opclass": "gin_trgm_ops"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "gin",
+          "with": {}
+        },
+        "idx_audit_action": {
+          "name": "idx_audit_action",
+          "columns": [
+            {
+              "expression": "action",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "idx_audit_action_trgm": {
+          "name": "idx_audit_action_trgm",
+          "columns": [
+            {
+              "expression": "action",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last",
+              "opclass": "gin_trgm_ops"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "gin",
+          "with": {}
+        },
+        "idx_audit_description_trgm": {
+          "name": "idx_audit_description_trgm",
+          "columns": [
+            {
+              "expression": "description",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last",
+              "opclass": "gin_trgm_ops"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "gin",
+          "with": {}
+        },
+        "idx_audit_meta_text_trgm": {
+          "name": "idx_audit_meta_text_trgm",
+          "columns": [
+            {
+              "expression": "(\"meta\"::text) gin_trgm_ops",
+              "asc": true,
+              "isExpression": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "gin",
+          "with": {}
+        },
+        "idx_audit_ip": {
+          "name": "idx_audit_ip",
+          "columns": [
+            {
+              "expression": "ip",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "idx_audit_created_at": {
+          "name": "idx_audit_created_at",
+          "columns": [
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "idx_audit_reading_insights_access": {
+          "name": "idx_audit_reading_insights_access",
+          "columns": [
+            {
+              "expression": "resource",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "resource_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "action",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "audit_log_user_id_users_id_fk": {
+          "name": "audit_log_user_id_users_id_fk",
+          "tableFrom": "audit_log",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.app_settings": {
+      "name": "app_settings",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "serial",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "key": {
+          "name": "key",
+          "type": "varchar(100)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "value": {
+          "name": "value",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "app_settings_key_unique": {
+          "name": "app_settings_key_unique",
+          "nullsNotDistinct": false,
+          "columns": ["key"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.auth_sessions": {
+      "name": "auth_sessions",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "serial",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "token_version": {
+          "name": "token_version",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "authentication_method": {
+          "name": "authentication_method",
+          "type": "varchar(20)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "client_kind": {
+          "name": "client_kind",
+          "type": "varchar(10)",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'web'"
+        },
+        "device_label": {
+          "name": "device_label",
+          "type": "varchar(100)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "expires_at": {
+          "name": "expires_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "revoked_at": {
+          "name": "revoked_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "auth_sessions_user_id_idx": {
+          "name": "auth_sessions_user_id_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "auth_sessions_expires_at_idx": {
+          "name": "auth_sessions_expires_at_idx",
+          "columns": [
+            {
+              "expression": "expires_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "auth_sessions_user_id_users_id_fk": {
+          "name": "auth_sessions_user_id_users_id_fk",
+          "tableFrom": "auth_sessions",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "auth_sessions_client_kind_chk": {
+          "name": "auth_sessions_client_kind_chk",
+          "value": "\"auth_sessions\".\"client_kind\" in ('web', 'native')"
+        },
+        "auth_sessions_authentication_method_chk": {
+          "name": "auth_sessions_authentication_method_chk",
+          "value": "\"auth_sessions\".\"authentication_method\" in ('password', 'oidc', 'magic_link', 'setup', 'legacy')"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.magic_access_tokens": {
+      "name": "magic_access_tokens",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "serial",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_by": {
+          "name": "created_by",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "label": {
+          "name": "label",
+          "type": "varchar(100)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "token_hash": {
+          "name": "token_hash",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "raw_token": {
+          "name": "raw_token",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "is_active": {
+          "name": "is_active",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": true
+        },
+        "expires_at": {
+          "name": "expires_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "last_used_at": {
+          "name": "last_used_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "use_count": {
+          "name": "use_count",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "revoked_at": {
+          "name": "revoked_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "magic_access_tokens_user_id_idx": {
+          "name": "magic_access_tokens_user_id_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "magic_access_tokens_user_id_users_id_fk": {
+          "name": "magic_access_tokens_user_id_users_id_fk",
+          "tableFrom": "magic_access_tokens",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "magic_access_tokens_created_by_users_id_fk": {
+          "name": "magic_access_tokens_created_by_users_id_fk",
+          "tableFrom": "magic_access_tokens",
+          "tableTo": "users",
+          "columnsFrom": ["created_by"],
+          "columnsTo": ["id"],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "magic_access_tokens_token_hash_unique": {
+          "name": "magic_access_tokens_token_hash_unique",
+          "nullsNotDistinct": false,
+          "columns": ["token_hash"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {
+        "magic_access_tokens_use_count_nonneg_chk": {
+          "name": "magic_access_tokens_use_count_nonneg_chk",
+          "value": "\"magic_access_tokens\".\"use_count\" >= 0"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.password_reset_tokens": {
+      "name": "password_reset_tokens",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "serial",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "token_hash": {
+          "name": "token_hash",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "expires_at": {
+          "name": "expires_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "used_at": {
+          "name": "used_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "password_reset_tokens_user_id_idx": {
+          "name": "password_reset_tokens_user_id_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "password_reset_tokens_expires_at_idx": {
+          "name": "password_reset_tokens_expires_at_idx",
+          "columns": [
+            {
+              "expression": "expires_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "password_reset_tokens_user_id_users_id_fk": {
+          "name": "password_reset_tokens_user_id_users_id_fk",
+          "tableFrom": "password_reset_tokens",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "password_reset_tokens_token_hash_unique": {
+          "name": "password_reset_tokens_token_hash_unique",
+          "nullsNotDistinct": false,
+          "columns": ["token_hash"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {
+        "password_reset_tokens_expires_after_created_chk": {
+          "name": "password_reset_tokens_expires_after_created_chk",
+          "value": "\"password_reset_tokens\".\"expires_at\" > \"password_reset_tokens\".\"created_at\""
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.refresh_tokens": {
+      "name": "refresh_tokens",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "serial",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "session_id": {
+          "name": "session_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "token_hash": {
+          "name": "token_hash",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "authentication_method": {
+          "name": "authentication_method",
+          "type": "varchar(20)",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'legacy'"
+        },
+        "expires_at": {
+          "name": "expires_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "revoked_at": {
+          "name": "revoked_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "rotated_at": {
+          "name": "rotated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "replaced_by_token_hash": {
+          "name": "replaced_by_token_hash",
+          "type": "varchar(64)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "refresh_tokens_user_id_idx": {
+          "name": "refresh_tokens_user_id_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "refresh_tokens_session_id_idx": {
+          "name": "refresh_tokens_session_id_idx",
+          "columns": [
+            {
+              "expression": "session_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "refresh_tokens_expires_at_idx": {
+          "name": "refresh_tokens_expires_at_idx",
+          "columns": [
+            {
+              "expression": "expires_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "refresh_tokens_user_id_users_id_fk": {
+          "name": "refresh_tokens_user_id_users_id_fk",
+          "tableFrom": "refresh_tokens",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "refresh_tokens_session_id_auth_sessions_id_fk": {
+          "name": "refresh_tokens_session_id_auth_sessions_id_fk",
+          "tableFrom": "refresh_tokens",
+          "tableTo": "auth_sessions",
+          "columnsFrom": ["session_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "refresh_tokens_token_hash_unique": {
+          "name": "refresh_tokens_token_hash_unique",
+          "nullsNotDistinct": false,
+          "columns": ["token_hash"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {
+        "refresh_tokens_expires_after_created_chk": {
+          "name": "refresh_tokens_expires_after_created_chk",
+          "value": "\"refresh_tokens\".\"expires_at\" > \"refresh_tokens\".\"created_at\""
+        },
+        "refresh_tokens_authentication_method_chk": {
+          "name": "refresh_tokens_authentication_method_chk",
+          "value": "\"refresh_tokens\".\"authentication_method\" in ('password', 'oidc', 'magic_link', 'setup', 'legacy')"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.user_content_filter_genres": {
+      "name": "user_content_filter_genres",
+      "schema": "",
+      "columns": {
+        "user_id": {
+          "name": "user_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "filter_type": {
+          "name": "filter_type",
+          "type": "content_filter_type",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "genre_id": {
+          "name": "genre_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {
+        "user_content_filter_genres_genre_id_idx": {
+          "name": "user_content_filter_genres_genre_id_idx",
+          "columns": [
+            {
+              "expression": "genre_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "user_content_filter_genres_user_id_users_id_fk": {
+          "name": "user_content_filter_genres_user_id_users_id_fk",
+          "tableFrom": "user_content_filter_genres",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "user_content_filter_genres_genre_id_genres_id_fk": {
+          "name": "user_content_filter_genres_genre_id_genres_id_fk",
+          "tableFrom": "user_content_filter_genres",
+          "tableTo": "genres",
+          "columnsFrom": ["genre_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "user_content_filter_genres_user_id_filter_type_genre_id_pk": {
+          "name": "user_content_filter_genres_user_id_filter_type_genre_id_pk",
+          "columns": ["user_id", "filter_type", "genre_id"]
+        }
+      },
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.user_content_filter_tags": {
+      "name": "user_content_filter_tags",
+      "schema": "",
+      "columns": {
+        "user_id": {
+          "name": "user_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "filter_type": {
+          "name": "filter_type",
+          "type": "content_filter_type",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "tag_id": {
+          "name": "tag_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {
+        "user_content_filter_tags_tag_id_idx": {
+          "name": "user_content_filter_tags_tag_id_idx",
+          "columns": [
+            {
+              "expression": "tag_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "user_content_filter_tags_user_id_users_id_fk": {
+          "name": "user_content_filter_tags_user_id_users_id_fk",
+          "tableFrom": "user_content_filter_tags",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "user_content_filter_tags_tag_id_tags_id_fk": {
+          "name": "user_content_filter_tags_tag_id_tags_id_fk",
+          "tableFrom": "user_content_filter_tags",
+          "tableTo": "tags",
+          "columnsFrom": ["tag_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "user_content_filter_tags_user_id_filter_type_tag_id_pk": {
+          "name": "user_content_filter_tags_user_id_filter_type_tag_id_pk",
+          "columns": ["user_id", "filter_type", "tag_id"]
+        }
+      },
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.user_library_access": {
+      "name": "user_library_access",
+      "schema": "",
+      "columns": {
+        "user_id": {
+          "name": "user_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "library_id": {
+          "name": "library_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "access_level": {
+          "name": "access_level",
+          "type": "library_access_level",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'viewer'"
+        }
+      },
+      "indexes": {
+        "user_library_access_library_user_idx": {
+          "name": "user_library_access_library_user_idx",
+          "columns": [
+            {
+              "expression": "library_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "user_library_access_user_id_users_id_fk": {
+          "name": "user_library_access_user_id_users_id_fk",
+          "tableFrom": "user_library_access",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "user_library_access_library_id_libraries_id_fk": {
+          "name": "user_library_access_library_id_libraries_id_fk",
+          "tableFrom": "user_library_access",
+          "tableTo": "libraries",
+          "columnsFrom": ["library_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "user_library_access_user_id_library_id_pk": {
+          "name": "user_library_access_user_id_library_id_pk",
+          "columns": ["user_id", "library_id"]
+        }
+      },
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.user_permissions": {
+      "name": "user_permissions",
+      "schema": "",
+      "columns": {
+        "user_id": {
+          "name": "user_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "permission_name": {
+          "name": "permission_name",
+          "type": "varchar(100)",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "user_permissions_user_id_users_id_fk": {
+          "name": "user_permissions_user_id_users_id_fk",
+          "tableFrom": "user_permissions",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "user_permissions_user_id_permission_name_pk": {
+          "name": "user_permissions_user_id_permission_name_pk",
+          "columns": ["user_id", "permission_name"]
+        }
+      },
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.users": {
+      "name": "users",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "serial",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "username": {
+          "name": "username",
+          "type": "varchar(100)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "name": {
+          "name": "name",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "email": {
+          "name": "email",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "password_hash": {
+          "name": "password_hash",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "active": {
+          "name": "active",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": true
+        },
+        "is_superuser": {
+          "name": "is_superuser",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "is_default_password": {
+          "name": "is_default_password",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "token_version": {
+          "name": "token_version",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 1
+        },
+        "failed_login_attempts": {
+          "name": "failed_login_attempts",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "locked_until": {
+          "name": "locked_until",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "settings": {
+          "name": "settings",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'{}'::jsonb"
+        },
+        "oidc_subject": {
+          "name": "oidc_subject",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "oidc_issuer": {
+          "name": "oidc_issuer",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "avatar_url": {
+          "name": "avatar_url",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "avatar_source": {
+          "name": "avatar_source",
+          "type": "user_avatar_source",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'none'"
+        },
+        "avatar_version": {
+          "name": "avatar_version",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "provisioning_method": {
+          "name": "provisioning_method",
+          "type": "varchar(20)",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'local'"
+        },
+        "last_login_at": {
+          "name": "last_login_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "last_authenticated_at": {
+          "name": "last_authenticated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "see_own_requested_books": {
+          "name": "see_own_requested_books",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "reading_insights_sharing_level": {
+          "name": "reading_insights_sharing_level",
+          "type": "reading_insights_sharing_level",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'private'"
+        },
+        "reading_insights_consented_at": {
+          "name": "reading_insights_consented_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "users_username_lower_uidx": {
+          "name": "users_username_lower_uidx",
+          "columns": [
+            {
+              "expression": "lower(\"username\")",
+              "asc": true,
+              "isExpression": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "users_email_lower_uidx": {
+          "name": "users_email_lower_uidx",
+          "columns": [
+            {
+              "expression": "lower(\"email\")",
+              "asc": true,
+              "isExpression": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "where": "\"users\".\"email\" is not null",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "users_oidc_subject_issuer_uidx": {
+          "name": "users_oidc_subject_issuer_uidx",
+          "columns": [
+            {
+              "expression": "oidc_subject",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "oidc_issuer",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "where": "\"users\".\"oidc_subject\" is not null and \"users\".\"oidc_issuer\" is not null",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "users_last_authenticated_at_idx": {
+          "name": "users_last_authenticated_at_idx",
+          "columns": [
+            {
+              "expression": "last_authenticated_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "users_username_unique": {
+          "name": "users_username_unique",
+          "nullsNotDistinct": false,
+          "columns": ["username"]
+        },
+        "users_email_unique": {
+          "name": "users_email_unique",
+          "nullsNotDistinct": false,
+          "columns": ["email"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {
+        "users_provisioning_method_chk": {
+          "name": "users_provisioning_method_chk",
+          "value": "\"users\".\"provisioning_method\" in ('local', 'manual', 'oidc', 'shared')"
+        },
+        "users_token_version_nonnegative_chk": {
+          "name": "users_token_version_nonnegative_chk",
+          "value": "\"users\".\"token_version\" >= 0"
+        },
+        "users_failed_login_attempts_nonnegative_chk": {
+          "name": "users_failed_login_attempts_nonnegative_chk",
+          "value": "\"users\".\"failed_login_attempts\" >= 0"
+        },
+        "users_avatar_version_nonnegative_chk": {
+          "name": "users_avatar_version_nonnegative_chk",
+          "value": "\"users\".\"avatar_version\" >= 0"
+        },
+        "users_reading_insights_consent_chk": {
+          "name": "users_reading_insights_consent_chk",
+          "value": "(\"users\".\"reading_insights_sharing_level\" = 'private' and \"users\".\"reading_insights_consented_at\" is null) or (\"users\".\"reading_insights_sharing_level\" <> 'private' and \"users\".\"reading_insights_consented_at\" is not null)"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.comic_metadata": {
+      "name": "comic_metadata",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "serial",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "book_id": {
+          "name": "book_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "issue_number": {
+          "name": "issue_number",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "volume_name": {
+          "name": "volume_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "pencillers": {
+          "name": "pencillers",
+          "type": "text[]",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "inkers": {
+          "name": "inkers",
+          "type": "text[]",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "colorists": {
+          "name": "colorists",
+          "type": "text[]",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "letterers": {
+          "name": "letterers",
+          "type": "text[]",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "cover_artists": {
+          "name": "cover_artists",
+          "type": "text[]",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "characters": {
+          "name": "characters",
+          "type": "text[]",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "teams": {
+          "name": "teams",
+          "type": "text[]",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "locations": {
+          "name": "locations",
+          "type": "text[]",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "story_arcs": {
+          "name": "story_arcs",
+          "type": "text[]",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "comic_metadata_book_id_books_id_fk": {
+          "name": "comic_metadata_book_id_books_id_fk",
+          "tableFrom": "comic_metadata",
+          "tableTo": "books",
+          "columnsFrom": ["book_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "comic_metadata_book_id_unique": {
+          "name": "comic_metadata_book_id_unique",
+          "nullsNotDistinct": false,
+          "columns": ["book_id"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.book_custom_metadata_values": {
+      "name": "book_custom_metadata_values",
+      "schema": "",
+      "columns": {
+        "book_id": {
+          "name": "book_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "field_id": {
+          "name": "field_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "value_text": {
+          "name": "value_text",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "value_number": {
+          "name": "value_number",
+          "type": "double precision",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "value_date": {
+          "name": "value_date",
+          "type": "date",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "value_boolean": {
+          "name": "value_boolean",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "book_custom_metadata_values_field_idx": {
+          "name": "book_custom_metadata_values_field_idx",
+          "columns": [
+            {
+              "expression": "field_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "book_custom_metadata_values_book_id_books_id_fk": {
+          "name": "book_custom_metadata_values_book_id_books_id_fk",
+          "tableFrom": "book_custom_metadata_values",
+          "tableTo": "books",
+          "columnsFrom": ["book_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "book_custom_metadata_values_field_id_custom_metadata_fields_id_fk": {
+          "name": "book_custom_metadata_values_field_id_custom_metadata_fields_id_fk",
+          "tableFrom": "book_custom_metadata_values",
+          "tableTo": "custom_metadata_fields",
+          "columnsFrom": ["field_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "book_custom_metadata_values_book_id_field_id_pk": {
+          "name": "book_custom_metadata_values_book_id_field_id_pk",
+          "columns": ["book_id", "field_id"]
+        }
+      },
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "book_custom_metadata_values_single_value_chk": {
+          "name": "book_custom_metadata_values_single_value_chk",
+          "value": "(\n        (\"book_custom_metadata_values\".\"value_text\" is not null)::int +\n        (\"book_custom_metadata_values\".\"value_number\" is not null)::int +\n        (\"book_custom_metadata_values\".\"value_date\" is not null)::int +\n        (\"book_custom_metadata_values\".\"value_boolean\" is not null)::int\n      ) <= 1"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.custom_metadata_fields": {
+      "name": "custom_metadata_fields",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "serial",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "key": {
+          "name": "key",
+          "type": "varchar(100)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "label": {
+          "name": "label",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "type": {
+          "name": "type",
+          "type": "varchar(20)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "display_order": {
+          "name": "display_order",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "archived_at": {
+          "name": "archived_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "custom_metadata_fields_key_uidx": {
+          "name": "custom_metadata_fields_key_uidx",
+          "columns": [
+            {
+              "expression": "key",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "custom_metadata_fields_active_order_idx": {
+          "name": "custom_metadata_fields_active_order_idx",
+          "columns": [
+            {
+              "expression": "archived_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "display_order",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "label",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "custom_metadata_fields_type_chk": {
+          "name": "custom_metadata_fields_type_chk",
+          "value": "\"custom_metadata_fields\".\"type\" in ('text', 'url', 'number', 'date', 'boolean')"
+        },
+        "custom_metadata_fields_key_format_chk": {
+          "name": "custom_metadata_fields_key_format_chk",
+          "value": "\"custom_metadata_fields\".\"key\" ~ '^[a-z0-9][a-z0-9_]{0,99}$'"
+        },
+        "custom_metadata_fields_label_not_blank_chk": {
+          "name": "custom_metadata_fields_label_not_blank_chk",
+          "value": "length(btrim(\"custom_metadata_fields\".\"label\")) > 0"
+        },
+        "custom_metadata_fields_display_order_nonnegative_chk": {
+          "name": "custom_metadata_fields_display_order_nonnegative_chk",
+          "value": "\"custom_metadata_fields\".\"display_order\" >= 0"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.custom_metadata_library_fields": {
+      "name": "custom_metadata_library_fields",
+      "schema": "",
+      "columns": {
+        "field_id": {
+          "name": "field_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "library_id": {
+          "name": "library_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "display_order": {
+          "name": "display_order",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "custom_metadata_library_fields_field_idx": {
+          "name": "custom_metadata_library_fields_field_idx",
+          "columns": [
+            {
+              "expression": "field_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "custom_metadata_library_fields_library_order_idx": {
+          "name": "custom_metadata_library_fields_library_order_idx",
+          "columns": [
+            {
+              "expression": "library_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "display_order",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "field_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "custom_metadata_library_fields_field_id_custom_metadata_fields_id_fk": {
+          "name": "custom_metadata_library_fields_field_id_custom_metadata_fields_id_fk",
+          "tableFrom": "custom_metadata_library_fields",
+          "tableTo": "custom_metadata_fields",
+          "columnsFrom": ["field_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "custom_metadata_library_fields_library_id_libraries_id_fk": {
+          "name": "custom_metadata_library_fields_library_id_libraries_id_fk",
+          "tableFrom": "custom_metadata_library_fields",
+          "tableTo": "libraries",
+          "columnsFrom": ["library_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "custom_metadata_library_fields_library_id_field_id_pk": {
+          "name": "custom_metadata_library_fields_library_id_field_id_pk",
+          "columns": ["library_id", "field_id"]
+        }
+      },
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "custom_metadata_library_fields_display_order_nonnegative_chk": {
+          "name": "custom_metadata_library_fields_display_order_nonnegative_chk",
+          "value": "\"custom_metadata_library_fields\".\"display_order\" >= 0"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.custom_icons": {
+      "name": "custom_icons",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "serial",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "slug": {
+          "name": "slug",
+          "type": "varchar(80)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "name": {
+          "name": "name",
+          "type": "varchar(120)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "original_file_name": {
+          "name": "original_file_name",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "stored_file_name": {
+          "name": "stored_file_name",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "file_size": {
+          "name": "file_size",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "file_hash": {
+          "name": "file_hash",
+          "type": "varchar(64)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "custom_icons_slug_uidx": {
+          "name": "custom_icons_slug_uidx",
+          "columns": [
+            {
+              "expression": "slug",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "custom_icons_slug_chk": {
+          "name": "custom_icons_slug_chk",
+          "value": "\"custom_icons\".\"slug\" ~ '^[a-z0-9][a-z0-9-]*[a-z0-9]$' or \"custom_icons\".\"slug\" ~ '^[a-z0-9]$'"
+        },
+        "custom_icons_file_size_positive_chk": {
+          "name": "custom_icons_file_size_positive_chk",
+          "value": "\"custom_icons\".\"file_size\" > 0"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.migration_plan_artifacts": {
+      "name": "migration_plan_artifacts",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "serial",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "source_id": {
+          "name": "source_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "profile_id": {
+          "name": "profile_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "source_snapshot_hash": {
+          "name": "source_snapshot_hash",
+          "type": "varchar(128)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "profile_hash": {
+          "name": "profile_hash",
+          "type": "varchar(128)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "plan_hash": {
+          "name": "plan_hash",
+          "type": "varchar(128)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "plan": {
+          "name": "plan",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "source_data": {
+          "name": "source_data",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "summary": {
+          "name": "summary",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_by_user_id": {
+          "name": "created_by_user_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "migration_plan_artifacts_plan_hash_uidx": {
+          "name": "migration_plan_artifacts_plan_hash_uidx",
+          "columns": [
+            {
+              "expression": "plan_hash",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "migration_plan_artifacts_source_id_idx": {
+          "name": "migration_plan_artifacts_source_id_idx",
+          "columns": [
+            {
+              "expression": "source_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "migration_plan_artifacts_profile_id_idx": {
+          "name": "migration_plan_artifacts_profile_id_idx",
+          "columns": [
+            {
+              "expression": "profile_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "migration_plan_artifacts_source_id_migration_sources_id_fk": {
+          "name": "migration_plan_artifacts_source_id_migration_sources_id_fk",
+          "tableFrom": "migration_plan_artifacts",
+          "tableTo": "migration_sources",
+          "columnsFrom": ["source_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "migration_plan_artifacts_profile_id_migration_profiles_id_fk": {
+          "name": "migration_plan_artifacts_profile_id_migration_profiles_id_fk",
+          "tableFrom": "migration_plan_artifacts",
+          "tableTo": "migration_profiles",
+          "columnsFrom": ["profile_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "migration_plan_artifacts_created_by_user_id_users_id_fk": {
+          "name": "migration_plan_artifacts_created_by_user_id_users_id_fk",
+          "tableFrom": "migration_plan_artifacts",
+          "tableTo": "users",
+          "columnsFrom": ["created_by_user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "migration_plan_artifacts_profile_source_fk": {
+          "name": "migration_plan_artifacts_profile_source_fk",
+          "tableFrom": "migration_plan_artifacts",
+          "tableTo": "migration_profiles",
+          "columnsFrom": ["profile_id", "source_id"],
+          "columnsTo": ["id", "source_id"],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "migration_plan_artifacts_id_source_profile_unique": {
+          "name": "migration_plan_artifacts_id_source_profile_unique",
+          "nullsNotDistinct": false,
+          "columns": ["id", "source_id", "profile_id"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.migration_profiles": {
+      "name": "migration_profiles",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "serial",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "source_id": {
+          "name": "source_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "name": {
+          "name": "name",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "version": {
+          "name": "version",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 1
+        },
+        "user_mappings": {
+          "name": "user_mappings",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "path_mappings": {
+          "name": "path_mappings",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'[]'::jsonb"
+        },
+        "scope": {
+          "name": "scope",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'{}'::jsonb"
+        },
+        "created_by_user_id": {
+          "name": "created_by_user_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "migration_profiles_source_name_version_uidx": {
+          "name": "migration_profiles_source_name_version_uidx",
+          "columns": [
+            {
+              "expression": "source_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "name",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "version",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "migration_profiles_source_id_idx": {
+          "name": "migration_profiles_source_id_idx",
+          "columns": [
+            {
+              "expression": "source_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "migration_profiles_source_id_migration_sources_id_fk": {
+          "name": "migration_profiles_source_id_migration_sources_id_fk",
+          "tableFrom": "migration_profiles",
+          "tableTo": "migration_sources",
+          "columnsFrom": ["source_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "migration_profiles_created_by_user_id_users_id_fk": {
+          "name": "migration_profiles_created_by_user_id_users_id_fk",
+          "tableFrom": "migration_profiles",
+          "tableTo": "users",
+          "columnsFrom": ["created_by_user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "migration_profiles_id_source_id_unique": {
+          "name": "migration_profiles_id_source_id_unique",
+          "nullsNotDistinct": false,
+          "columns": ["id", "source_id"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {
+        "migration_profiles_version_positive_chk": {
+          "name": "migration_profiles_version_positive_chk",
+          "value": "\"migration_profiles\".\"version\" >= 1"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.migration_run_metrics": {
+      "name": "migration_run_metrics",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "serial",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "run_id": {
+          "name": "run_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "stage": {
+          "name": "stage",
+          "type": "varchar(64)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "entity_type": {
+          "name": "entity_type",
+          "type": "varchar(64)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "processed": {
+          "name": "processed",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "imported": {
+          "name": "imported",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "skipped": {
+          "name": "skipped",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "unresolved": {
+          "name": "unresolved",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "failed": {
+          "name": "failed",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "migration_run_metrics_run_stage_entity_uidx": {
+          "name": "migration_run_metrics_run_stage_entity_uidx",
+          "columns": [
+            {
+              "expression": "run_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "stage",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "entity_type",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "migration_run_metrics_run_id_idx": {
+          "name": "migration_run_metrics_run_id_idx",
+          "columns": [
+            {
+              "expression": "run_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "migration_run_metrics_run_id_migration_runs_id_fk": {
+          "name": "migration_run_metrics_run_id_migration_runs_id_fk",
+          "tableFrom": "migration_run_metrics",
+          "tableTo": "migration_runs",
+          "columnsFrom": ["run_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "migration_run_metrics_processed_nonnegative_chk": {
+          "name": "migration_run_metrics_processed_nonnegative_chk",
+          "value": "\"migration_run_metrics\".\"processed\" >= 0"
+        },
+        "migration_run_metrics_imported_nonnegative_chk": {
+          "name": "migration_run_metrics_imported_nonnegative_chk",
+          "value": "\"migration_run_metrics\".\"imported\" >= 0"
+        },
+        "migration_run_metrics_skipped_nonnegative_chk": {
+          "name": "migration_run_metrics_skipped_nonnegative_chk",
+          "value": "\"migration_run_metrics\".\"skipped\" >= 0"
+        },
+        "migration_run_metrics_unresolved_nonnegative_chk": {
+          "name": "migration_run_metrics_unresolved_nonnegative_chk",
+          "value": "\"migration_run_metrics\".\"unresolved\" >= 0"
+        },
+        "migration_run_metrics_failed_nonnegative_chk": {
+          "name": "migration_run_metrics_failed_nonnegative_chk",
+          "value": "\"migration_run_metrics\".\"failed\" >= 0"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.migration_runs": {
+      "name": "migration_runs",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "serial",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "source_id": {
+          "name": "source_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "profile_id": {
+          "name": "profile_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "plan_artifact_id": {
+          "name": "plan_artifact_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "target_key": {
+          "name": "target_key",
+          "type": "varchar(100)",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'bookorbit'"
+        },
+        "state": {
+          "name": "state",
+          "type": "varchar(32)",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'draft'"
+        },
+        "current_stage": {
+          "name": "current_stage",
+          "type": "varchar(64)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "triggered_by_user_id": {
+          "name": "triggered_by_user_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "started_at": {
+          "name": "started_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "ended_at": {
+          "name": "ended_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "error_message": {
+          "name": "error_message",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "migration_runs_source_target_state_idx": {
+          "name": "migration_runs_source_target_state_idx",
+          "columns": [
+            {
+              "expression": "source_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "target_key",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "state",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "migration_runs_state_idx": {
+          "name": "migration_runs_state_idx",
+          "columns": [
+            {
+              "expression": "state",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "migration_runs_source_id_migration_sources_id_fk": {
+          "name": "migration_runs_source_id_migration_sources_id_fk",
+          "tableFrom": "migration_runs",
+          "tableTo": "migration_sources",
+          "columnsFrom": ["source_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "migration_runs_profile_id_migration_profiles_id_fk": {
+          "name": "migration_runs_profile_id_migration_profiles_id_fk",
+          "tableFrom": "migration_runs",
+          "tableTo": "migration_profiles",
+          "columnsFrom": ["profile_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "migration_runs_plan_artifact_id_migration_plan_artifacts_id_fk": {
+          "name": "migration_runs_plan_artifact_id_migration_plan_artifacts_id_fk",
+          "tableFrom": "migration_runs",
+          "tableTo": "migration_plan_artifacts",
+          "columnsFrom": ["plan_artifact_id"],
+          "columnsTo": ["id"],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "migration_runs_triggered_by_user_id_users_id_fk": {
+          "name": "migration_runs_triggered_by_user_id_users_id_fk",
+          "tableFrom": "migration_runs",
+          "tableTo": "users",
+          "columnsFrom": ["triggered_by_user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "migration_runs_profile_source_fk": {
+          "name": "migration_runs_profile_source_fk",
+          "tableFrom": "migration_runs",
+          "tableTo": "migration_profiles",
+          "columnsFrom": ["profile_id", "source_id"],
+          "columnsTo": ["id", "source_id"],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        },
+        "migration_runs_plan_artifact_source_profile_fk": {
+          "name": "migration_runs_plan_artifact_source_profile_fk",
+          "tableFrom": "migration_runs",
+          "tableTo": "migration_plan_artifacts",
+          "columnsFrom": ["plan_artifact_id", "source_id", "profile_id"],
+          "columnsTo": ["id", "source_id", "profile_id"],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "migration_runs_state_chk": {
+          "name": "migration_runs_state_chk",
+          "value": "\"state\" IN ('draft', 'preflight_failed', 'dry_run_ready', 'running', 'failed', 'completed')"
+        },
+        "migration_runs_started_before_ended_chk": {
+          "name": "migration_runs_started_before_ended_chk",
+          "value": "\"migration_runs\".\"ended_at\" is null or \"migration_runs\".\"started_at\" is null or \"migration_runs\".\"ended_at\" >= \"migration_runs\".\"started_at\""
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.migration_sources": {
+      "name": "migration_sources",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "serial",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "type": {
+          "name": "type",
+          "type": "varchar(50)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "name": {
+          "name": "name",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "connection_config": {
+          "name": "connection_config",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "capabilities": {
+          "name": "capabilities",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "last_validated_at": {
+          "name": "last_validated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_by_user_id": {
+          "name": "created_by_user_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "migration_sources_type_name_uidx": {
+          "name": "migration_sources_type_name_uidx",
+          "columns": [
+            {
+              "expression": "type",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "name",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "migration_sources_created_by_user_id_idx": {
+          "name": "migration_sources_created_by_user_id_idx",
+          "columns": [
+            {
+              "expression": "created_by_user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "migration_sources_created_by_user_id_users_id_fk": {
+          "name": "migration_sources_created_by_user_id_users_id_fk",
+          "tableFrom": "migration_sources",
+          "tableTo": "users",
+          "columnsFrom": ["created_by_user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.libraries": {
+      "name": "libraries",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "serial",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "type": {
+          "name": "type",
+          "type": "varchar(20)",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'books'"
+        },
+        "name": {
+          "name": "name",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "icon": {
+          "name": "icon",
+          "type": "varchar(100)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "display_order": {
+          "name": "display_order",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "cover_aspect_ratio": {
+          "name": "cover_aspect_ratio",
+          "type": "varchar(10)",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'2/3'"
+        },
+        "watch": {
+          "name": "watch",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "watch_local_folders": {
+          "name": "watch_local_folders",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": true
+        },
+        "auto_scan_cron_expression": {
+          "name": "auto_scan_cron_expression",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "metadata_precedence": {
+          "name": "metadata_precedence",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'[\"folderStructure\",\"embedded\",\"nfoFile\",\"opfFile\",\"sidecar\"]'::jsonb"
+        },
+        "format_priority": {
+          "name": "format_priority",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'[\"epub\",\"pdf\",\"cbz\",\"cbr\",\"cb7\",\"mobi\",\"azw3\",\"azw\",\"fb2\",\"m4b\",\"mp3\",\"m4a\",\"opus\",\"ogg\",\"flac\"]'::jsonb"
+        },
+        "allowed_formats": {
+          "name": "allowed_formats",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'[]'::jsonb"
+        },
+        "organization_mode": {
+          "name": "organization_mode",
+          "type": "varchar(20)",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'book_per_folder'"
+        },
+        "added_at_source": {
+          "name": "added_at_source",
+          "type": "varchar(20)",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'imported'"
+        },
+        "exclude_patterns": {
+          "name": "exclude_patterns",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'[]'::jsonb"
+        },
+        "reading_threshold": {
+          "name": "reading_threshold",
+          "type": "double precision",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0.25
+        },
+        "mark_as_finished_percent_complete": {
+          "name": "mark_as_finished_percent_complete",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 98
+        },
+        "file_write_enabled": {
+          "name": "file_write_enabled",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "file_write_write_cover": {
+          "name": "file_write_write_cover",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": true
+        },
+        "file_write_epub_enabled": {
+          "name": "file_write_epub_enabled",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": true
+        },
+        "file_write_epub_max_file_size_mb": {
+          "name": "file_write_epub_max_file_size_mb",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 100
+        },
+        "file_write_fb2_enabled": {
+          "name": "file_write_fb2_enabled",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "file_write_fb2_max_file_size_mb": {
+          "name": "file_write_fb2_max_file_size_mb",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 100
+        },
+        "file_write_pdf_enabled": {
+          "name": "file_write_pdf_enabled",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": true
+        },
+        "file_write_pdf_max_file_size_mb": {
+          "name": "file_write_pdf_max_file_size_mb",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 100
+        },
+        "file_write_cbx_enabled": {
+          "name": "file_write_cbx_enabled",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "file_write_cbx_max_file_size_mb": {
+          "name": "file_write_cbx_max_file_size_mb",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 500
+        },
+        "file_write_kindle_enabled": {
+          "name": "file_write_kindle_enabled",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "file_write_kindle_max_file_size_mb": {
+          "name": "file_write_kindle_max_file_size_mb",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 100
+        },
+        "file_write_audio_enabled": {
+          "name": "file_write_audio_enabled",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "file_write_audio_max_file_size_mb": {
+          "name": "file_write_audio_max_file_size_mb",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 500
+        },
+        "file_rename_enabled": {
+          "name": "file_rename_enabled",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "file_naming_pattern": {
+          "name": "file_naming_pattern",
+          "type": "varchar(500)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "metadata_fetch_preferences": {
+          "name": "metadata_fetch_preferences",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "book_metadata_fetch_config": {
+          "name": "book_metadata_fetch_config",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "book_metadata_fetch_last_run_at": {
+          "name": "book_metadata_fetch_last_run_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "book_metadata_fetch_last_queued_count": {
+          "name": "book_metadata_fetch_last_queued_count",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "scan_mode": {
+          "name": "scan_mode",
+          "type": "varchar(20)",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'auto'"
+        },
+        "poll_interval_seconds": {
+          "name": "poll_interval_seconds",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "default": 300
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "libraries_name_lower_uidx": {
+          "name": "libraries_name_lower_uidx",
+          "columns": [
+            {
+              "expression": "lower(\"name\")",
+              "asc": true,
+              "isExpression": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "libraries_display_order_nonnegative_chk": {
+          "name": "libraries_display_order_nonnegative_chk",
+          "value": "\"libraries\".\"display_order\" >= 0"
+        },
+        "libraries_type_chk": {
+          "name": "libraries_type_chk",
+          "value": "\"libraries\".\"type\" in ('books', 'podcasts')"
+        },
+        "libraries_organization_mode_chk": {
+          "name": "libraries_organization_mode_chk",
+          "value": "\"libraries\".\"organization_mode\" in ('book_per_folder', 'book_per_file')"
+        },
+        "libraries_added_at_source_chk": {
+          "name": "libraries_added_at_source_chk",
+          "value": "\"libraries\".\"added_at_source\" in ('imported', 'file_modified', 'file_created')"
+        },
+        "libraries_reading_threshold_range_chk": {
+          "name": "libraries_reading_threshold_range_chk",
+          "value": "\"libraries\".\"reading_threshold\" >= 0 and \"libraries\".\"reading_threshold\" <= 100"
+        },
+        "libraries_mark_finished_percent_range_chk": {
+          "name": "libraries_mark_finished_percent_range_chk",
+          "value": "\"libraries\".\"mark_as_finished_percent_complete\" >= 0 and \"libraries\".\"mark_as_finished_percent_complete\" <= 100"
+        },
+        "libraries_scan_mode_chk": {
+          "name": "libraries_scan_mode_chk",
+          "value": "\"libraries\".\"scan_mode\" in ('auto', 'manual')"
+        },
+        "libraries_poll_interval_nonnegative_chk": {
+          "name": "libraries_poll_interval_nonnegative_chk",
+          "value": "\"libraries\".\"poll_interval_seconds\" is null or \"libraries\".\"poll_interval_seconds\" >= 0"
+        },
+        "libraries_file_write_epub_max_size_chk": {
+          "name": "libraries_file_write_epub_max_size_chk",
+          "value": "\"libraries\".\"file_write_epub_max_file_size_mb\" >= 1"
+        },
+        "libraries_file_write_pdf_max_size_chk": {
+          "name": "libraries_file_write_pdf_max_size_chk",
+          "value": "\"libraries\".\"file_write_pdf_max_file_size_mb\" >= 1"
+        },
+        "libraries_file_write_cbx_max_size_chk": {
+          "name": "libraries_file_write_cbx_max_size_chk",
+          "value": "\"libraries\".\"file_write_cbx_max_file_size_mb\" >= 1"
+        },
+        "libraries_file_write_kindle_max_size_chk": {
+          "name": "libraries_file_write_kindle_max_size_chk",
+          "value": "\"libraries\".\"file_write_kindle_max_file_size_mb\" >= 1"
+        },
+        "libraries_file_write_audio_max_size_chk": {
+          "name": "libraries_file_write_audio_max_size_chk",
+          "value": "\"libraries\".\"file_write_audio_max_file_size_mb\" >= 1"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.library_folders": {
+      "name": "library_folders",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "serial",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "library_id": {
+          "name": "library_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "path": {
+          "name": "path",
+          "type": "varchar(4096)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "scan_state_version": {
+          "name": "scan_state_version",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "role": {
+          "name": "role",
+          "type": "varchar(20)",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'downloads'"
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "library_folders_library_id_idx": {
+          "name": "library_folders_library_id_idx",
+          "columns": [
+            {
+              "expression": "library_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "library_folders_library_path_uidx": {
+          "name": "library_folders_library_path_uidx",
+          "columns": [
+            {
+              "expression": "library_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "path",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "library_folders_library_id_libraries_id_fk": {
+          "name": "library_folders_library_id_libraries_id_fk",
+          "tableFrom": "library_folders",
+          "tableTo": "libraries",
+          "columnsFrom": ["library_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "library_folders_id_library_id_unique": {
+          "name": "library_folders_id_library_id_unique",
+          "nullsNotDistinct": false,
+          "columns": ["id", "library_id"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {
+        "library_folders_scan_state_version_nonnegative_chk": {
+          "name": "library_folders_scan_state_version_nonnegative_chk",
+          "value": "\"library_folders\".\"scan_state_version\" >= 0"
+        },
+        "library_folders_role_chk": {
+          "name": "library_folders_role_chk",
+          "value": "\"library_folders\".\"role\" in ('downloads', 'local')"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.book_files": {
+      "name": "book_files",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "serial",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "public_id": {
+          "name": "public_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "book_id": {
+          "name": "book_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "library_folder_id": {
+          "name": "library_folder_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "absolute_path": {
+          "name": "absolute_path",
+          "type": "varchar(4096)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "rel_path": {
+          "name": "rel_path",
+          "type": "varchar(4096)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "ino": {
+          "name": "ino",
+          "type": "numeric(20, 0)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "size_bytes": {
+          "name": "size_bytes",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "mtime": {
+          "name": "mtime",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "file_hash": {
+          "name": "file_hash",
+          "type": "varchar(32)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "format": {
+          "name": "format",
+          "type": "varchar(20)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "role": {
+          "name": "role",
+          "type": "varchar(20)",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'content'"
+        },
+        "sort_order": {
+          "name": "sort_order",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "duration_seconds": {
+          "name": "duration_seconds",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "is_fixed_layout": {
+          "name": "is_fixed_layout",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "media_overlay_available": {
+          "name": "media_overlay_available",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "media_overlay_duration_seconds": {
+          "name": "media_overlay_duration_seconds",
+          "type": "double precision",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "media_overlay_checked_at": {
+          "name": "media_overlay_checked_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "book_files_public_id_uidx": {
+          "name": "book_files_public_id_uidx",
+          "columns": [
+            {
+              "expression": "public_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "book_files_absolute_path_uidx": {
+          "name": "book_files_absolute_path_uidx",
+          "columns": [
+            {
+              "expression": "absolute_path",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "book_files_book_id_idx": {
+          "name": "book_files_book_id_idx",
+          "columns": [
+            {
+              "expression": "book_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "book_files_library_folder_id_idx": {
+          "name": "book_files_library_folder_id_idx",
+          "columns": [
+            {
+              "expression": "library_folder_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "book_files_file_hash_idx": {
+          "name": "book_files_file_hash_idx",
+          "columns": [
+            {
+              "expression": "file_hash",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "book_files_ino_idx": {
+          "name": "book_files_ino_idx",
+          "columns": [
+            {
+              "expression": "ino",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "book_files_format_idx": {
+          "name": "book_files_format_idx",
+          "columns": [
+            {
+              "expression": "format",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "book_files_media_overlay_available_idx": {
+          "name": "book_files_media_overlay_available_idx",
+          "columns": [
+            {
+              "expression": "media_overlay_available",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "where": "\"book_files\".\"media_overlay_available\" = true",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "book_files_library_folder_file_hash_idx": {
+          "name": "book_files_library_folder_file_hash_idx",
+          "columns": [
+            {
+              "expression": "library_folder_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "file_hash",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "book_files_library_folder_ino_idx": {
+          "name": "book_files_library_folder_ino_idx",
+          "columns": [
+            {
+              "expression": "library_folder_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "ino",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "book_files_book_id_books_id_fk": {
+          "name": "book_files_book_id_books_id_fk",
+          "tableFrom": "book_files",
+          "tableTo": "books",
+          "columnsFrom": ["book_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "book_files_library_folder_id_library_folders_id_fk": {
+          "name": "book_files_library_folder_id_library_folders_id_fk",
+          "tableFrom": "book_files",
+          "tableTo": "library_folders",
+          "columnsFrom": ["library_folder_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "book_files_book_folder_consistency_fk": {
+          "name": "book_files_book_folder_consistency_fk",
+          "tableFrom": "book_files",
+          "tableTo": "books",
+          "columnsFrom": ["book_id", "library_folder_id"],
+          "columnsTo": ["id", "library_folder_id"],
+          "onDelete": "cascade",
+          "onUpdate": "cascade"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "book_files_role_chk": {
+          "name": "book_files_role_chk",
+          "value": "\"book_files\".\"role\" in ('content', 'cover', 'metadata', 'supplement')"
+        },
+        "book_files_size_bytes_nonnegative_chk": {
+          "name": "book_files_size_bytes_nonnegative_chk",
+          "value": "\"book_files\".\"size_bytes\" is null or \"book_files\".\"size_bytes\" >= 0"
+        },
+        "book_files_duration_seconds_nonnegative_chk": {
+          "name": "book_files_duration_seconds_nonnegative_chk",
+          "value": "\"book_files\".\"duration_seconds\" is null or \"book_files\".\"duration_seconds\" >= 0"
+        },
+        "book_files_media_overlay_duration_seconds_nonnegative_chk": {
+          "name": "book_files_media_overlay_duration_seconds_nonnegative_chk",
+          "value": "\"book_files\".\"media_overlay_duration_seconds\" is null or \"book_files\".\"media_overlay_duration_seconds\" >= 0"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.books": {
+      "name": "books",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "serial",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "library_id": {
+          "name": "library_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "library_folder_id": {
+          "name": "library_folder_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "primary_file_id": {
+          "name": "primary_file_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "primary_author_sort_name": {
+          "name": "primary_author_sort_name",
+          "type": "varchar(500)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "folder_path": {
+          "name": "folder_path",
+          "type": "varchar(4096)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "status": {
+          "name": "status",
+          "type": "varchar(20)",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'present'"
+        },
+        "added_at": {
+          "name": "added_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "books_library_id_folder_path_idx": {
+          "name": "books_library_id_folder_path_idx",
+          "columns": [
+            {
+              "expression": "library_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "folder_path",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "books_primary_file_id_idx": {
+          "name": "books_primary_file_id_idx",
+          "columns": [
+            {
+              "expression": "primary_file_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "books_library_status_id_idx": {
+          "name": "books_library_status_id_idx",
+          "columns": [
+            {
+              "expression": "library_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "status",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "books_library_added_at_idx": {
+          "name": "books_library_added_at_idx",
+          "columns": [
+            {
+              "expression": "library_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "\"added_at\" desc",
+              "asc": true,
+              "isExpression": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "books_library_visible_added_id_idx": {
+          "name": "books_library_visible_added_id_idx",
+          "columns": [
+            {
+              "expression": "library_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "\"added_at\" desc",
+              "asc": true,
+              "isExpression": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "where": "\"books\".\"status\" <> 'processing'",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "books_library_author_sort_id_idx": {
+          "name": "books_library_author_sort_id_idx",
+          "columns": [
+            {
+              "expression": "library_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "\"primary_author_sort_name\" asc nulls last",
+              "asc": true,
+              "isExpression": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "where": "\"books\".\"status\" <> 'processing'",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "books_library_author_sort_desc_id_idx": {
+          "name": "books_library_author_sort_desc_id_idx",
+          "columns": [
+            {
+              "expression": "library_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "\"primary_author_sort_name\" desc nulls last",
+              "asc": true,
+              "isExpression": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "where": "\"books\".\"status\" <> 'processing'",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "books_library_id_libraries_id_fk": {
+          "name": "books_library_id_libraries_id_fk",
+          "tableFrom": "books",
+          "tableTo": "libraries",
+          "columnsFrom": ["library_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "books_library_folder_id_library_folders_id_fk": {
+          "name": "books_library_folder_id_library_folders_id_fk",
+          "tableFrom": "books",
+          "tableTo": "library_folders",
+          "columnsFrom": ["library_folder_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "books_primary_file_id_book_files_id_fk": {
+          "name": "books_primary_file_id_book_files_id_fk",
+          "tableFrom": "books",
+          "tableTo": "book_files",
+          "columnsFrom": ["primary_file_id"],
+          "columnsTo": ["id"],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "books_library_folder_library_fk": {
+          "name": "books_library_folder_library_fk",
+          "tableFrom": "books",
+          "tableTo": "library_folders",
+          "columnsFrom": ["library_folder_id", "library_id"],
+          "columnsTo": ["id", "library_id"],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "books_id_library_folder_id_unique": {
+          "name": "books_id_library_folder_id_unique",
+          "nullsNotDistinct": false,
+          "columns": ["id", "library_folder_id"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {
+        "books_status_chk": {
+          "name": "books_status_chk",
+          "value": "\"books\".\"status\" in ('present', 'missing', 'processing')"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.book_covers": {
+      "name": "book_covers",
+      "schema": "",
+      "columns": {
+        "book_id": {
+          "name": "book_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "medium": {
+          "name": "medium",
+          "type": "varchar(5)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "source": {
+          "name": "source",
+          "type": "varchar(9)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "origin": {
+          "name": "origin",
+          "type": "varchar(12)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "width": {
+          "name": "width",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "height": {
+          "name": "height",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "dormant_since": {
+          "name": "dormant_since",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "book_covers_book_id_books_id_fk": {
+          "name": "book_covers_book_id_books_id_fk",
+          "tableFrom": "book_covers",
+          "tableTo": "books",
+          "columnsFrom": ["book_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "book_covers_book_id_medium_pk": {
+          "name": "book_covers_book_id_medium_pk",
+          "columns": ["book_id", "medium"]
+        }
+      },
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "book_covers_medium_chk": {
+          "name": "book_covers_medium_chk",
+          "value": "\"book_covers\".\"medium\" in ('ebook', 'audio')"
+        },
+        "book_covers_source_chk": {
+          "name": "book_covers_source_chk",
+          "value": "\"book_covers\".\"source\" in ('extracted', 'custom')"
+        },
+        "book_covers_origin_chk": {
+          "name": "book_covers_origin_chk",
+          "value": "\"book_covers\".\"origin\" in ('embedded', 'folder_image', 'opf', 'provider', 'dock', 'upload', 'legacy')"
+        },
+        "book_covers_width_positive_chk": {
+          "name": "book_covers_width_positive_chk",
+          "value": "\"book_covers\".\"width\" is null or \"book_covers\".\"width\" > 0"
+        },
+        "book_covers_height_positive_chk": {
+          "name": "book_covers_height_positive_chk",
+          "value": "\"book_covers\".\"height\" is null or \"book_covers\".\"height\" > 0"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.book_duplicate_dismissals": {
+      "name": "book_duplicate_dismissals",
+      "schema": "",
+      "columns": {
+        "user_id": {
+          "name": "user_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "book_id_a": {
+          "name": "book_id_a",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "book_id_b": {
+          "name": "book_id_b",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "book_duplicate_dismissals_user_created_idx": {
+          "name": "book_duplicate_dismissals_user_created_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "\"created_at\" desc",
+              "asc": true,
+              "isExpression": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "book_duplicate_dismissals_user_id_users_id_fk": {
+          "name": "book_duplicate_dismissals_user_id_users_id_fk",
+          "tableFrom": "book_duplicate_dismissals",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "book_duplicate_dismissals_book_id_a_books_id_fk": {
+          "name": "book_duplicate_dismissals_book_id_a_books_id_fk",
+          "tableFrom": "book_duplicate_dismissals",
+          "tableTo": "books",
+          "columnsFrom": ["book_id_a"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "book_duplicate_dismissals_book_id_b_books_id_fk": {
+          "name": "book_duplicate_dismissals_book_id_b_books_id_fk",
+          "tableFrom": "book_duplicate_dismissals",
+          "tableTo": "books",
+          "columnsFrom": ["book_id_b"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "book_duplicate_dismissals_user_id_book_id_a_book_id_b_pk": {
+          "name": "book_duplicate_dismissals_user_id_book_id_a_book_id_b_pk",
+          "columns": ["user_id", "book_id_a", "book_id_b"]
+        }
+      },
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "book_duplicate_dismissals_order_chk": {
+          "name": "book_duplicate_dismissals_order_chk",
+          "value": "\"book_duplicate_dismissals\".\"book_id_a\" < \"book_duplicate_dismissals\".\"book_id_b\""
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.book_duplicate_group_members": {
+      "name": "book_duplicate_group_members",
+      "schema": "",
+      "columns": {
+        "group_id": {
+          "name": "group_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "scan_id": {
+          "name": "scan_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "book_id": {
+          "name": "book_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {
+        "book_duplicate_group_members_group_idx": {
+          "name": "book_duplicate_group_members_group_idx",
+          "columns": [
+            {
+              "expression": "group_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "book_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "book_duplicate_group_members_group_id_book_duplicate_groups_id_fk": {
+          "name": "book_duplicate_group_members_group_id_book_duplicate_groups_id_fk",
+          "tableFrom": "book_duplicate_group_members",
+          "tableTo": "book_duplicate_groups",
+          "columnsFrom": ["group_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "book_duplicate_group_members_scan_id_book_duplicate_scans_id_fk": {
+          "name": "book_duplicate_group_members_scan_id_book_duplicate_scans_id_fk",
+          "tableFrom": "book_duplicate_group_members",
+          "tableTo": "book_duplicate_scans",
+          "columnsFrom": ["scan_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "book_duplicate_group_members_book_id_books_id_fk": {
+          "name": "book_duplicate_group_members_book_id_books_id_fk",
+          "tableFrom": "book_duplicate_group_members",
+          "tableTo": "books",
+          "columnsFrom": ["book_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "book_duplicate_group_members_scan_id_book_id_pk": {
+          "name": "book_duplicate_group_members_scan_id_book_id_pk",
+          "columns": ["scan_id", "book_id"]
+        }
+      },
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.book_duplicate_groups": {
+      "name": "book_duplicate_groups",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "serial",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "scan_id": {
+          "name": "scan_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "root_book_id": {
+          "name": "root_book_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "reasons": {
+          "name": "reasons",
+          "type": "text[]",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "max_title_similarity": {
+          "name": "max_title_similarity",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "member_count": {
+          "name": "member_count",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "confidence": {
+          "name": "confidence",
+          "type": "smallint",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 1
+        },
+        "member_bytes_total": {
+          "name": "member_bytes_total",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "member_bytes_max": {
+          "name": "member_bytes_max",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        }
+      },
+      "indexes": {
+        "book_duplicate_groups_scan_root_uidx": {
+          "name": "book_duplicate_groups_scan_root_uidx",
+          "columns": [
+            {
+              "expression": "scan_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "root_book_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "book_duplicate_groups_scan_id_idx": {
+          "name": "book_duplicate_groups_scan_id_idx",
+          "columns": [
+            {
+              "expression": "scan_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "book_duplicate_groups_scan_member_count_idx": {
+          "name": "book_duplicate_groups_scan_member_count_idx",
+          "columns": [
+            {
+              "expression": "scan_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "member_count",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "book_duplicate_groups_scan_reclaimable_idx": {
+          "name": "book_duplicate_groups_scan_reclaimable_idx",
+          "columns": [
+            {
+              "expression": "scan_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "(\"member_bytes_total\" - \"member_bytes_max\") desc",
+              "asc": true,
+              "isExpression": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "book_duplicate_groups_scan_confidence_idx": {
+          "name": "book_duplicate_groups_scan_confidence_idx",
+          "columns": [
+            {
+              "expression": "scan_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "confidence",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "book_duplicate_groups_scan_id_book_duplicate_scans_id_fk": {
+          "name": "book_duplicate_groups_scan_id_book_duplicate_scans_id_fk",
+          "tableFrom": "book_duplicate_groups",
+          "tableTo": "book_duplicate_scans",
+          "columnsFrom": ["scan_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "book_duplicate_groups_root_book_id_books_id_fk": {
+          "name": "book_duplicate_groups_root_book_id_books_id_fk",
+          "tableFrom": "book_duplicate_groups",
+          "tableTo": "books",
+          "columnsFrom": ["root_book_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "book_duplicate_groups_confidence_chk": {
+          "name": "book_duplicate_groups_confidence_chk",
+          "value": "\"book_duplicate_groups\".\"confidence\" between 1 and 4"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.book_duplicate_pairs": {
+      "name": "book_duplicate_pairs",
+      "schema": "",
+      "columns": {
+        "scan_id": {
+          "name": "scan_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "group_id": {
+          "name": "group_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "book_id_a": {
+          "name": "book_id_a",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "book_id_b": {
+          "name": "book_id_b",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "reasons": {
+          "name": "reasons",
+          "type": "text[]",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "title_similarity": {
+          "name": "title_similarity",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "book_duplicate_pairs_group_idx": {
+          "name": "book_duplicate_pairs_group_idx",
+          "columns": [
+            {
+              "expression": "group_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "book_duplicate_pairs_scan_a_idx": {
+          "name": "book_duplicate_pairs_scan_a_idx",
+          "columns": [
+            {
+              "expression": "scan_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "book_id_a",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "book_duplicate_pairs_scan_b_idx": {
+          "name": "book_duplicate_pairs_scan_b_idx",
+          "columns": [
+            {
+              "expression": "scan_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "book_id_b",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "book_duplicate_pairs_scan_id_book_duplicate_scans_id_fk": {
+          "name": "book_duplicate_pairs_scan_id_book_duplicate_scans_id_fk",
+          "tableFrom": "book_duplicate_pairs",
+          "tableTo": "book_duplicate_scans",
+          "columnsFrom": ["scan_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "book_duplicate_pairs_group_id_book_duplicate_groups_id_fk": {
+          "name": "book_duplicate_pairs_group_id_book_duplicate_groups_id_fk",
+          "tableFrom": "book_duplicate_pairs",
+          "tableTo": "book_duplicate_groups",
+          "columnsFrom": ["group_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "book_duplicate_pairs_book_id_a_books_id_fk": {
+          "name": "book_duplicate_pairs_book_id_a_books_id_fk",
+          "tableFrom": "book_duplicate_pairs",
+          "tableTo": "books",
+          "columnsFrom": ["book_id_a"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "book_duplicate_pairs_book_id_b_books_id_fk": {
+          "name": "book_duplicate_pairs_book_id_b_books_id_fk",
+          "tableFrom": "book_duplicate_pairs",
+          "tableTo": "books",
+          "columnsFrom": ["book_id_b"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "book_duplicate_pairs_scan_id_book_id_a_book_id_b_pk": {
+          "name": "book_duplicate_pairs_scan_id_book_id_a_book_id_b_pk",
+          "columns": ["scan_id", "book_id_a", "book_id_b"]
+        }
+      },
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "book_duplicate_pairs_order_chk": {
+          "name": "book_duplicate_pairs_order_chk",
+          "value": "\"book_duplicate_pairs\".\"book_id_a\" < \"book_duplicate_pairs\".\"book_id_b\""
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.book_duplicate_scan_keys": {
+      "name": "book_duplicate_scan_keys",
+      "schema": "",
+      "columns": {
+        "scan_id": {
+          "name": "scan_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "book_id": {
+          "name": "book_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "kind": {
+          "name": "kind",
+          "type": "varchar(20)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "value": {
+          "name": "value",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {
+        "book_duplicate_scan_keys_lookup_idx": {
+          "name": "book_duplicate_scan_keys_lookup_idx",
+          "columns": [
+            {
+              "expression": "scan_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "kind",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "value",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "book_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "book_duplicate_scan_keys_scan_id_book_duplicate_scans_id_fk": {
+          "name": "book_duplicate_scan_keys_scan_id_book_duplicate_scans_id_fk",
+          "tableFrom": "book_duplicate_scan_keys",
+          "tableTo": "book_duplicate_scans",
+          "columnsFrom": ["scan_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "book_duplicate_scan_keys_book_id_books_id_fk": {
+          "name": "book_duplicate_scan_keys_book_id_books_id_fk",
+          "tableFrom": "book_duplicate_scan_keys",
+          "tableTo": "books",
+          "columnsFrom": ["book_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "book_duplicate_scan_keys_scan_id_book_id_kind_value_pk": {
+          "name": "book_duplicate_scan_keys_scan_id_book_id_kind_value_pk",
+          "columns": ["scan_id", "book_id", "kind", "value"]
+        }
+      },
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "book_duplicate_scan_keys_kind_chk": {
+          "name": "book_duplicate_scan_keys_kind_chk",
+          "value": "\"book_duplicate_scan_keys\".\"kind\" in ('file_hash', 'isbn', 'exact_metadata')"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.book_duplicate_scans": {
+      "name": "book_duplicate_scans",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "serial",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "library_ids": {
+          "name": "library_ids",
+          "type": "integer[]",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "requested_library_id": {
+          "name": "requested_library_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "similarity_percent": {
+          "name": "similarity_percent",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "status": {
+          "name": "status",
+          "type": "varchar(20)",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'queued'"
+        },
+        "processed_books": {
+          "name": "processed_books",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "total_books": {
+          "name": "total_books",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "total_groups": {
+          "name": "total_groups",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "total_extra_copies": {
+          "name": "total_extra_copies",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "total_reclaimable_bytes": {
+          "name": "total_reclaimable_bytes",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "error_code": {
+          "name": "error_code",
+          "type": "varchar(50)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "completed_at": {
+          "name": "completed_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "book_duplicate_scans_user_created_idx": {
+          "name": "book_duplicate_scans_user_created_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "\"created_at\" desc",
+              "asc": true,
+              "isExpression": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "book_duplicate_scans_status_idx": {
+          "name": "book_duplicate_scans_status_idx",
+          "columns": [
+            {
+              "expression": "status",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "book_duplicate_scans_user_id_users_id_fk": {
+          "name": "book_duplicate_scans_user_id_users_id_fk",
+          "tableFrom": "book_duplicate_scans",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "book_duplicate_scans_similarity_chk": {
+          "name": "book_duplicate_scans_similarity_chk",
+          "value": "\"book_duplicate_scans\".\"similarity_percent\" between 70 and 100"
+        },
+        "book_duplicate_scans_status_chk": {
+          "name": "book_duplicate_scans_status_chk",
+          "value": "\"book_duplicate_scans\".\"status\" in ('queued', 'running', 'completed', 'failed')"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.book_move_jobs": {
+      "name": "book_move_jobs",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "serial",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "started_by": {
+          "name": "started_by",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "target_library_id": {
+          "name": "target_library_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "target_folder_id": {
+          "name": "target_folder_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "source_library_ids": {
+          "name": "source_library_ids",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'[]'::jsonb"
+        },
+        "status": {
+          "name": "status",
+          "type": "varchar(20)",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'running'"
+        },
+        "total_books": {
+          "name": "total_books",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "succeeded": {
+          "name": "succeeded",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "merged": {
+          "name": "merged",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "failed": {
+          "name": "failed",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "skipped": {
+          "name": "skipped",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "error": {
+          "name": "error",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "started_at": {
+          "name": "started_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "finished_at": {
+          "name": "finished_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "book_move_jobs_status_idx": {
+          "name": "book_move_jobs_status_idx",
+          "columns": [
+            {
+              "expression": "status",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "book_move_jobs_started_at_idx": {
+          "name": "book_move_jobs_started_at_idx",
+          "columns": [
+            {
+              "expression": "\"started_at\" desc",
+              "asc": true,
+              "isExpression": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "book_move_jobs_started_by_users_id_fk": {
+          "name": "book_move_jobs_started_by_users_id_fk",
+          "tableFrom": "book_move_jobs",
+          "tableTo": "users",
+          "columnsFrom": ["started_by"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "book_move_jobs_target_library_id_libraries_id_fk": {
+          "name": "book_move_jobs_target_library_id_libraries_id_fk",
+          "tableFrom": "book_move_jobs",
+          "tableTo": "libraries",
+          "columnsFrom": ["target_library_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "book_move_jobs_target_folder_id_library_folders_id_fk": {
+          "name": "book_move_jobs_target_folder_id_library_folders_id_fk",
+          "tableFrom": "book_move_jobs",
+          "tableTo": "library_folders",
+          "columnsFrom": ["target_folder_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "book_move_jobs_status_chk": {
+          "name": "book_move_jobs_status_chk",
+          "value": "\"book_move_jobs\".\"status\" in ('running', 'completed', 'failed', 'interrupted')"
+        },
+        "book_move_jobs_counts_nonnegative_chk": {
+          "name": "book_move_jobs_counts_nonnegative_chk",
+          "value": "\"book_move_jobs\".\"total_books\" >= 0 and \"book_move_jobs\".\"succeeded\" >= 0 and \"book_move_jobs\".\"merged\" >= 0 and \"book_move_jobs\".\"failed\" >= 0 and \"book_move_jobs\".\"skipped\" >= 0"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.collection_books": {
+      "name": "collection_books",
+      "schema": "",
+      "columns": {
+        "collection_id": {
+          "name": "collection_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "book_id": {
+          "name": "book_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "added_at": {
+          "name": "added_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "position": {
+          "name": "position",
+          "type": "bigserial",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {
+        "collection_books_book_id_idx": {
+          "name": "collection_books_book_id_idx",
+          "columns": [
+            {
+              "expression": "book_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "collection_books_collection_position_idx": {
+          "name": "collection_books_collection_position_idx",
+          "columns": [
+            {
+              "expression": "collection_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "position",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "collection_books_collection_id_collections_id_fk": {
+          "name": "collection_books_collection_id_collections_id_fk",
+          "tableFrom": "collection_books",
+          "tableTo": "collections",
+          "columnsFrom": ["collection_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "collection_books_book_id_books_id_fk": {
+          "name": "collection_books_book_id_books_id_fk",
+          "tableFrom": "collection_books",
+          "tableTo": "books",
+          "columnsFrom": ["book_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "collection_books_collection_id_book_id_pk": {
+          "name": "collection_books_collection_id_book_id_pk",
+          "columns": ["collection_id", "book_id"]
+        }
+      },
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.collection_podcasts": {
+      "name": "collection_podcasts",
+      "schema": "",
+      "columns": {
+        "collection_id": {
+          "name": "collection_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "podcast_id": {
+          "name": "podcast_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "added_at": {
+          "name": "added_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "collection_podcasts_podcast_id_idx": {
+          "name": "collection_podcasts_podcast_id_idx",
+          "columns": [
+            {
+              "expression": "podcast_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "collection_podcasts_collection_id_collections_id_fk": {
+          "name": "collection_podcasts_collection_id_collections_id_fk",
+          "tableFrom": "collection_podcasts",
+          "tableTo": "collections",
+          "columnsFrom": ["collection_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "collection_podcasts_podcast_id_podcasts_id_fk": {
+          "name": "collection_podcasts_podcast_id_podcasts_id_fk",
+          "tableFrom": "collection_podcasts",
+          "tableTo": "podcasts",
+          "columnsFrom": ["podcast_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "collection_podcasts_collection_id_podcast_id_pk": {
+          "name": "collection_podcasts_collection_id_podcast_id_pk",
+          "columns": ["collection_id", "podcast_id"]
+        }
+      },
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.collections": {
+      "name": "collections",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "serial",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "media_type": {
+          "name": "media_type",
+          "type": "varchar(20)",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'books'"
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "icon": {
+          "name": "icon",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "is_public": {
+          "name": "is_public",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "sync_to_kobo": {
+          "name": "sync_to_kobo",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "display_order": {
+          "name": "display_order",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "collections_user_media_type_name_uidx": {
+          "name": "collections_user_media_type_name_uidx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "media_type",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "name",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "collections_user_display_name_idx": {
+          "name": "collections_user_display_name_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "display_order",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "name",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "collections_public_display_name_idx": {
+          "name": "collections_public_display_name_idx",
+          "columns": [
+            {
+              "expression": "is_public",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "display_order",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "name",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "collections_user_id_users_id_fk": {
+          "name": "collections_user_id_users_id_fk",
+          "tableFrom": "collections",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "collections_media_type_chk": {
+          "name": "collections_media_type_chk",
+          "value": "\"collections\".\"media_type\" in ('books', 'podcasts')"
+        },
+        "collections_kobo_books_only_chk": {
+          "name": "collections_kobo_books_only_chk",
+          "value": "\"collections\".\"sync_to_kobo\" = false or \"collections\".\"media_type\" = 'books'"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.smart_scope_kobo_subscriptions": {
+      "name": "smart_scope_kobo_subscriptions",
+      "schema": "",
+      "columns": {
+        "user_id": {
+          "name": "user_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "smart_scope_id": {
+          "name": "smart_scope_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "smart_scope_kobo_subscriptions_smart_scope_id_idx": {
+          "name": "smart_scope_kobo_subscriptions_smart_scope_id_idx",
+          "columns": [
+            {
+              "expression": "smart_scope_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "smart_scope_kobo_subscriptions_user_id_users_id_fk": {
+          "name": "smart_scope_kobo_subscriptions_user_id_users_id_fk",
+          "tableFrom": "smart_scope_kobo_subscriptions",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "smart_scope_kobo_subscriptions_smart_scope_id_smart_scopes_id_fk": {
+          "name": "smart_scope_kobo_subscriptions_smart_scope_id_smart_scopes_id_fk",
+          "tableFrom": "smart_scope_kobo_subscriptions",
+          "tableTo": "smart_scopes",
+          "columnsFrom": ["smart_scope_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "smart_scope_kobo_subscriptions_user_id_smart_scope_id_pk": {
+          "name": "smart_scope_kobo_subscriptions_user_id_smart_scope_id_pk",
+          "columns": ["user_id", "smart_scope_id"]
+        }
+      },
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.smart_scopes": {
+      "name": "smart_scopes",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "serial",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "media_type": {
+          "name": "media_type",
+          "type": "varchar(20)",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'books'"
+        },
+        "library_id": {
+          "name": "library_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "name": {
+          "name": "name",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "icon": {
+          "name": "icon",
+          "type": "varchar(100)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "filter": {
+          "name": "filter",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "default_sort": {
+          "name": "default_sort",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'[]'::jsonb"
+        },
+        "is_public": {
+          "name": "is_public",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "sync_to_kobo": {
+          "name": "sync_to_kobo",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "display_order": {
+          "name": "display_order",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "smart_scopes_user_media_type_idx": {
+          "name": "smart_scopes_user_media_type_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "media_type",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "smart_scopes_user_id_users_id_fk": {
+          "name": "smart_scopes_user_id_users_id_fk",
+          "tableFrom": "smart_scopes",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "smart_scopes_library_id_libraries_id_fk": {
+          "name": "smart_scopes_library_id_libraries_id_fk",
+          "tableFrom": "smart_scopes",
+          "tableTo": "libraries",
+          "columnsFrom": ["library_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "smart_scopes_user_id_media_type_name_unique": {
+          "name": "smart_scopes_user_id_media_type_name_unique",
+          "nullsNotDistinct": false,
+          "columns": ["user_id", "media_type", "name"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {
+        "smart_scopes_media_type_chk": {
+          "name": "smart_scopes_media_type_chk",
+          "value": "\"smart_scopes\".\"media_type\" in ('books', 'podcasts')"
+        },
+        "smart_scopes_library_scope_chk": {
+          "name": "smart_scopes_library_scope_chk",
+          "value": "(\"smart_scopes\".\"media_type\" = 'podcasts') = (\"smart_scopes\".\"library_id\" is not null)"
+        },
+        "smart_scopes_kobo_books_only_chk": {
+          "name": "smart_scopes_kobo_books_only_chk",
+          "value": "\"smart_scopes\".\"sync_to_kobo\" = false or \"smart_scopes\".\"media_type\" = 'books'"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.book_series": {
+      "name": "book_series",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "serial",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "name": {
+          "name": "name",
+          "type": "varchar(500)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "normalized_name": {
+          "name": "normalized_name",
+          "type": "varchar(500)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "expected_book_count": {
+          "name": "expected_book_count",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "expected_book_count_source": {
+          "name": "expected_book_count_source",
+          "type": "varchar(50)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "expected_book_count_updated_at": {
+          "name": "expected_book_count_updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "book_series_normalized_name_uidx": {
+          "name": "book_series_normalized_name_uidx",
+          "columns": [
+            {
+              "expression": "normalized_name",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "book_series_name_trgm_idx": {
+          "name": "book_series_name_trgm_idx",
+          "columns": [
+            {
+              "expression": "name",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last",
+              "opclass": "gin_trgm_ops"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "gin",
+          "with": {}
+        },
+        "book_series_name_unaccent_trgm_idx": {
+          "name": "book_series_name_unaccent_trgm_idx",
+          "columns": [
+            {
+              "expression": "public.bookorbit_unaccent(\"name\") gin_trgm_ops",
+              "asc": true,
+              "isExpression": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "gin",
+          "with": {}
+        },
+        "book_series_name_lower_idx": {
+          "name": "book_series_name_lower_idx",
+          "columns": [
+            {
+              "expression": "lower(\"name\")",
+              "asc": true,
+              "isExpression": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "book_series_expected_book_count_range_chk": {
+          "name": "book_series_expected_book_count_range_chk",
+          "value": "\"book_series\".\"expected_book_count\" IS NULL OR (\"book_series\".\"expected_book_count\" >= 1 AND \"book_series\".\"expected_book_count\" <= 10000)"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.book_series_memberships": {
+      "name": "book_series_memberships",
+      "schema": "",
+      "columns": {
+        "book_id": {
+          "name": "book_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "series_id": {
+          "name": "series_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "series_index": {
+          "name": "series_index",
+          "type": "varchar(20)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "display_order": {
+          "name": "display_order",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "book_series_memberships_book_display_uidx": {
+          "name": "book_series_memberships_book_display_uidx",
+          "columns": [
+            {
+              "expression": "book_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "display_order",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "book_series_memberships_series_index_book_idx": {
+          "name": "book_series_memberships_series_index_book_idx",
+          "columns": [
+            {
+              "expression": "series_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "(CASE WHEN \"series_index\" IS NULL THEN NULL ELSE ARRAY[split_part(\"series_index\", '.', 1)::numeric, CASE WHEN strpos(\"series_index\", '.') = 0 THEN -1::numeric ELSE split_part(\"series_index\", '.', 2)::numeric END] END)",
+              "asc": true,
+              "isExpression": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "\"series_index\" COLLATE \"C\"",
+              "asc": true,
+              "isExpression": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "book_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "book_series_memberships_book_display_idx": {
+          "name": "book_series_memberships_book_display_idx",
+          "columns": [
+            {
+              "expression": "book_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "display_order",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "book_series_memberships_book_id_books_id_fk": {
+          "name": "book_series_memberships_book_id_books_id_fk",
+          "tableFrom": "book_series_memberships",
+          "tableTo": "books",
+          "columnsFrom": ["book_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "book_series_memberships_series_id_book_series_id_fk": {
+          "name": "book_series_memberships_series_id_book_series_id_fk",
+          "tableFrom": "book_series_memberships",
+          "tableTo": "book_series",
+          "columnsFrom": ["series_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "book_series_memberships_book_id_series_id_pk": {
+          "name": "book_series_memberships_book_id_series_id_pk",
+          "columns": ["book_id", "series_id"]
+        }
+      },
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "book_series_memberships_display_order_nonnegative_chk": {
+          "name": "book_series_memberships_display_order_nonnegative_chk",
+          "value": "\"book_series_memberships\".\"display_order\" >= 0"
+        },
+        "book_series_memberships_series_index_format_chk": {
+          "name": "book_series_memberships_series_index_format_chk",
+          "value": "\"book_series_memberships\".\"series_index\" is null or \"book_series_memberships\".\"series_index\" ~ '^[0-9]+([.][0-9]+)?$'"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.author_enrichment_queue": {
+      "name": "author_enrichment_queue",
+      "schema": "",
+      "columns": {
+        "author_id": {
+          "name": "author_id",
+          "type": "integer",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "status": {
+          "name": "status",
+          "type": "varchar(20)",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'queued'"
+        },
+        "reason": {
+          "name": "reason",
+          "type": "varchar(50)",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'unknown'"
+        },
+        "attempt_count": {
+          "name": "attempt_count",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "next_attempt_at": {
+          "name": "next_attempt_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "last_attempt_at": {
+          "name": "last_attempt_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "last_success_at": {
+          "name": "last_success_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "last_error": {
+          "name": "last_error",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "last_http_status": {
+          "name": "last_http_status",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "author_enrichment_queue_status_next_attempt_idx": {
+          "name": "author_enrichment_queue_status_next_attempt_idx",
+          "columns": [
+            {
+              "expression": "status",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "next_attempt_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "author_enrichment_queue_next_attempt_idx": {
+          "name": "author_enrichment_queue_next_attempt_idx",
+          "columns": [
+            {
+              "expression": "next_attempt_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "author_enrichment_queue_single_processing_idx": {
+          "name": "author_enrichment_queue_single_processing_idx",
+          "columns": [
+            {
+              "expression": "status",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "where": "\"author_enrichment_queue\".\"status\" = 'processing'",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "author_enrichment_queue_author_id_authors_id_fk": {
+          "name": "author_enrichment_queue_author_id_authors_id_fk",
+          "tableFrom": "author_enrichment_queue",
+          "tableTo": "authors",
+          "columnsFrom": ["author_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "author_enrichment_queue_status_chk": {
+          "name": "author_enrichment_queue_status_chk",
+          "value": "\"author_enrichment_queue\".\"status\" in ('queued', 'processing', 'rate_limited', 'failed', 'done')"
+        },
+        "author_enrichment_queue_reason_chk": {
+          "name": "author_enrichment_queue_reason_chk",
+          "value": "\"author_enrichment_queue\".\"reason\" in ('unknown', 'metadata_replace', 'manual_backfill', 'manual_backfill_all', 'author_rename', 'author_merge_target')"
+        },
+        "author_enrichment_queue_attempt_count_nonnegative_chk": {
+          "name": "author_enrichment_queue_attempt_count_nonnegative_chk",
+          "value": "\"author_enrichment_queue\".\"attempt_count\" >= 0"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.authors": {
+      "name": "authors",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "serial",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "name": {
+          "name": "name",
+          "type": "varchar(500)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "sort_name": {
+          "name": "sort_name",
+          "type": "varchar(500)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "has_photo": {
+          "name": "has_photo",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "birth_date": {
+          "name": "birth_date",
+          "type": "date",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "birth_year": {
+          "name": "birth_year",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "death_date": {
+          "name": "death_date",
+          "type": "date",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "death_year": {
+          "name": "death_year",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "website": {
+          "name": "website",
+          "type": "varchar(2048)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "genres": {
+          "name": "genres",
+          "type": "text[]",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "influences": {
+          "name": "influences",
+          "type": "text[]",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "metadata_provider": {
+          "name": "metadata_provider",
+          "type": "varchar(50)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "metadata_provider_id": {
+          "name": "metadata_provider_id",
+          "type": "varchar(128)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "last_enriched_at": {
+          "name": "last_enriched_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "authors_name_trgm_idx": {
+          "name": "authors_name_trgm_idx",
+          "columns": [
+            {
+              "expression": "name",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last",
+              "opclass": "gin_trgm_ops"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "gin",
+          "with": {}
+        },
+        "authors_name_unaccent_trgm_idx": {
+          "name": "authors_name_unaccent_trgm_idx",
+          "columns": [
+            {
+              "expression": "public.bookorbit_unaccent(\"name\") gin_trgm_ops",
+              "asc": true,
+              "isExpression": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "gin",
+          "with": {}
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "authors_name_unique": {
+          "name": "authors_name_unique",
+          "nullsNotDistinct": false,
+          "columns": ["name"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.book_authors": {
+      "name": "book_authors",
+      "schema": "",
+      "columns": {
+        "book_id": {
+          "name": "book_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "author_id": {
+          "name": "author_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "display_order": {
+          "name": "display_order",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        }
+      },
+      "indexes": {
+        "book_authors_author_id_idx": {
+          "name": "book_authors_author_id_idx",
+          "columns": [
+            {
+              "expression": "author_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "book_authors_book_display_idx": {
+          "name": "book_authors_book_display_idx",
+          "columns": [
+            {
+              "expression": "book_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "display_order",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "book_authors_book_display_author_idx": {
+          "name": "book_authors_book_display_author_idx",
+          "columns": [
+            {
+              "expression": "book_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "display_order",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "author_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "book_authors_book_id_books_id_fk": {
+          "name": "book_authors_book_id_books_id_fk",
+          "tableFrom": "book_authors",
+          "tableTo": "books",
+          "columnsFrom": ["book_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "book_authors_author_id_authors_id_fk": {
+          "name": "book_authors_author_id_authors_id_fk",
+          "tableFrom": "book_authors",
+          "tableTo": "authors",
+          "columnsFrom": ["author_id"],
+          "columnsTo": ["id"],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "book_authors_book_id_author_id_pk": {
+          "name": "book_authors_book_id_author_id_pk",
+          "columns": ["book_id", "author_id"]
+        }
+      },
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.book_community_ratings": {
+      "name": "book_community_ratings",
+      "schema": "",
+      "columns": {
+        "book_id": {
+          "name": "book_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "provider": {
+          "name": "provider",
+          "type": "varchar(50)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "rating": {
+          "name": "rating",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "rating_count": {
+          "name": "rating_count",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "book_community_ratings_provider_idx": {
+          "name": "book_community_ratings_provider_idx",
+          "columns": [
+            {
+              "expression": "provider",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "book_community_ratings_rating_book_idx": {
+          "name": "book_community_ratings_rating_book_idx",
+          "columns": [
+            {
+              "expression": "rating",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "book_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "book_community_ratings_provider_rating_book_idx": {
+          "name": "book_community_ratings_provider_rating_book_idx",
+          "columns": [
+            {
+              "expression": "provider",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "rating",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "book_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "book_community_ratings_count_book_idx": {
+          "name": "book_community_ratings_count_book_idx",
+          "columns": [
+            {
+              "expression": "rating_count",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "book_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "book_community_ratings_provider_count_book_idx": {
+          "name": "book_community_ratings_provider_count_book_idx",
+          "columns": [
+            {
+              "expression": "provider",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "rating_count",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "book_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "book_community_ratings_book_id_books_id_fk": {
+          "name": "book_community_ratings_book_id_books_id_fk",
+          "tableFrom": "book_community_ratings",
+          "tableTo": "books",
+          "columnsFrom": ["book_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "book_community_ratings_book_id_provider_pk": {
+          "name": "book_community_ratings_book_id_provider_pk",
+          "columns": ["book_id", "provider"]
+        }
+      },
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "book_community_ratings_rating_range_chk": {
+          "name": "book_community_ratings_rating_range_chk",
+          "value": "\"book_community_ratings\".\"rating\" >= 0 and \"book_community_ratings\".\"rating\" <= 5"
+        },
+        "book_community_ratings_count_nonnegative_chk": {
+          "name": "book_community_ratings_count_nonnegative_chk",
+          "value": "\"book_community_ratings\".\"rating_count\" is null or \"book_community_ratings\".\"rating_count\" >= 0"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.book_genres": {
+      "name": "book_genres",
+      "schema": "",
+      "columns": {
+        "book_id": {
+          "name": "book_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "genre_id": {
+          "name": "genre_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {
+        "book_genres_genre_id_idx": {
+          "name": "book_genres_genre_id_idx",
+          "columns": [
+            {
+              "expression": "genre_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "book_genres_book_id_books_id_fk": {
+          "name": "book_genres_book_id_books_id_fk",
+          "tableFrom": "book_genres",
+          "tableTo": "books",
+          "columnsFrom": ["book_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "book_genres_genre_id_genres_id_fk": {
+          "name": "book_genres_genre_id_genres_id_fk",
+          "tableFrom": "book_genres",
+          "tableTo": "genres",
+          "columnsFrom": ["genre_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "book_genres_book_id_genre_id_pk": {
+          "name": "book_genres_book_id_genre_id_pk",
+          "columns": ["book_id", "genre_id"]
+        }
+      },
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.book_metadata": {
+      "name": "book_metadata",
+      "schema": "",
+      "columns": {
+        "book_id": {
+          "name": "book_id",
+          "type": "integer",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "title": {
+          "name": "title",
+          "type": "varchar(1000)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "subtitle": {
+          "name": "subtitle",
+          "type": "varchar(1000)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "isbn10": {
+          "name": "isbn10",
+          "type": "varchar(10)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "isbn13": {
+          "name": "isbn13",
+          "type": "varchar(13)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "publisher": {
+          "name": "publisher",
+          "type": "varchar(500)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "published_date": {
+          "name": "published_date",
+          "type": "date",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "published_year": {
+          "name": "published_year",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "language": {
+          "name": "language",
+          "type": "varchar(100)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "page_count": {
+          "name": "page_count",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "series_id": {
+          "name": "series_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "series_name": {
+          "name": "series_name",
+          "type": "varchar(500)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "series_index": {
+          "name": "series_index",
+          "type": "varchar(20)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "rating": {
+          "name": "rating",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "cover_source": {
+          "name": "cover_source",
+          "type": "varchar(9)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "google_books_id": {
+          "name": "google_books_id",
+          "type": "varchar(50)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "goodreads_id": {
+          "name": "goodreads_id",
+          "type": "varchar(50)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "amazon_id": {
+          "name": "amazon_id",
+          "type": "varchar(20)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "hardcover_id": {
+          "name": "hardcover_id",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "hardcover_edition_id": {
+          "name": "hardcover_edition_id",
+          "type": "varchar(50)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "open_library_id": {
+          "name": "open_library_id",
+          "type": "varchar(50)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "itunes_id": {
+          "name": "itunes_id",
+          "type": "varchar(50)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "kobo_id": {
+          "name": "kobo_id",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "metadata_score": {
+          "name": "metadata_score",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "last_metadata_fetch_at": {
+          "name": "last_metadata_fetch_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "embedding": {
+          "name": "embedding",
+          "type": "vector(256)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "last_written_at": {
+          "name": "last_written_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "duration_seconds": {
+          "name": "duration_seconds",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "abridged": {
+          "name": "abridged",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "audible_id": {
+          "name": "audible_id",
+          "type": "varchar(20)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "librofm_id": {
+          "name": "librofm_id",
+          "type": "varchar(50)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "comicvine_id": {
+          "name": "comicvine_id",
+          "type": "varchar(50)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "ranobedb_id": {
+          "name": "ranobedb_id",
+          "type": "varchar(50)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "lubimyczytac_id": {
+          "name": "lubimyczytac_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "aladin_id": {
+          "name": "aladin_id",
+          "type": "varchar(20)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "chapters": {
+          "name": "chapters",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "locked_fields": {
+          "name": "locked_fields",
+          "type": "text[]",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'{}'::text[]"
+        },
+        "cover_updated_at": {
+          "name": "cover_updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "bm_title_trgm_idx": {
+          "name": "bm_title_trgm_idx",
+          "columns": [
+            {
+              "expression": "title",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last",
+              "opclass": "gin_trgm_ops"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "gin",
+          "with": {}
+        },
+        "bm_title_unaccent_trgm_idx": {
+          "name": "bm_title_unaccent_trgm_idx",
+          "columns": [
+            {
+              "expression": "public.bookorbit_unaccent(\"title\") gin_trgm_ops",
+              "asc": true,
+              "isExpression": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "gin",
+          "with": {}
+        },
+        "bm_title_lower_idx": {
+          "name": "bm_title_lower_idx",
+          "columns": [
+            {
+              "expression": "lower(\"title\")",
+              "asc": true,
+              "isExpression": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "bm_title_book_id_idx": {
+          "name": "bm_title_book_id_idx",
+          "columns": [
+            {
+              "expression": "title",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "book_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "bm_series_trgm_idx": {
+          "name": "bm_series_trgm_idx",
+          "columns": [
+            {
+              "expression": "series_name",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last",
+              "opclass": "gin_trgm_ops"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "gin",
+          "with": {}
+        },
+        "bm_series_unaccent_trgm_idx": {
+          "name": "bm_series_unaccent_trgm_idx",
+          "columns": [
+            {
+              "expression": "public.bookorbit_unaccent(\"series_name\") gin_trgm_ops",
+              "asc": true,
+              "isExpression": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "gin",
+          "with": {}
+        },
+        "bm_series_id_idx": {
+          "name": "bm_series_id_idx",
+          "columns": [
+            {
+              "expression": "series_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "bm_series_id_index_book_id_idx": {
+          "name": "bm_series_id_index_book_id_idx",
+          "columns": [
+            {
+              "expression": "series_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "(CASE WHEN \"series_index\" IS NULL THEN NULL ELSE ARRAY[split_part(\"series_index\", '.', 1)::numeric, CASE WHEN strpos(\"series_index\", '.') = 0 THEN -1::numeric ELSE split_part(\"series_index\", '.', 2)::numeric END] END)",
+              "asc": true,
+              "isExpression": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "\"series_index\" COLLATE \"C\"",
+              "asc": true,
+              "isExpression": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "book_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "bm_series_index_sort_idx": {
+          "name": "bm_series_index_sort_idx",
+          "columns": [
+            {
+              "expression": "(CASE WHEN \"series_index\" IS NULL THEN NULL ELSE ARRAY[split_part(\"series_index\", '.', 1)::numeric, CASE WHEN strpos(\"series_index\", '.') = 0 THEN -1::numeric ELSE split_part(\"series_index\", '.', 2)::numeric END] END)",
+              "asc": true,
+              "isExpression": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "\"series_index\" COLLATE \"C\"",
+              "asc": true,
+              "isExpression": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "book_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "bm_series_name_lower_btrim_idx": {
+          "name": "bm_series_name_lower_btrim_idx",
+          "columns": [
+            {
+              "expression": "lower(btrim(\"series_name\"))",
+              "asc": true,
+              "isExpression": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "bm_publisher_trgm_idx": {
+          "name": "bm_publisher_trgm_idx",
+          "columns": [
+            {
+              "expression": "publisher",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last",
+              "opclass": "gin_trgm_ops"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "gin",
+          "with": {}
+        },
+        "bm_publisher_unaccent_trgm_idx": {
+          "name": "bm_publisher_unaccent_trgm_idx",
+          "columns": [
+            {
+              "expression": "public.bookorbit_unaccent(\"publisher\") gin_trgm_ops",
+              "asc": true,
+              "isExpression": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "gin",
+          "with": {}
+        },
+        "bm_language_idx": {
+          "name": "bm_language_idx",
+          "columns": [
+            {
+              "expression": "language",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "bm_language_trgm_idx": {
+          "name": "bm_language_trgm_idx",
+          "columns": [
+            {
+              "expression": "language",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last",
+              "opclass": "gin_trgm_ops"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "gin",
+          "with": {}
+        },
+        "bm_language_unaccent_trgm_idx": {
+          "name": "bm_language_unaccent_trgm_idx",
+          "columns": [
+            {
+              "expression": "public.bookorbit_unaccent(\"language\") gin_trgm_ops",
+              "asc": true,
+              "isExpression": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "gin",
+          "with": {}
+        },
+        "bm_published_date_idx": {
+          "name": "bm_published_date_idx",
+          "columns": [
+            {
+              "expression": "published_date",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "bm_published_year_idx": {
+          "name": "bm_published_year_idx",
+          "columns": [
+            {
+              "expression": "published_year",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "bm_published_date_sort_idx": {
+          "name": "bm_published_date_sort_idx",
+          "columns": [
+            {
+              "expression": "coalesce(\"published_date\", make_date(\"published_year\", 1, 1))",
+              "asc": true,
+              "isExpression": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "bm_series_name_index_idx": {
+          "name": "bm_series_name_index_idx",
+          "columns": [
+            {
+              "expression": "series_name",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "(CASE WHEN \"series_index\" IS NULL THEN NULL ELSE ARRAY[split_part(\"series_index\", '.', 1)::numeric, CASE WHEN strpos(\"series_index\", '.') = 0 THEN -1::numeric ELSE split_part(\"series_index\", '.', 2)::numeric END] END)",
+              "asc": true,
+              "isExpression": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "\"series_index\" COLLATE \"C\"",
+              "asc": true,
+              "isExpression": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "bm_isbn10_idx": {
+          "name": "bm_isbn10_idx",
+          "columns": [
+            {
+              "expression": "isbn10",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "bm_isbn13_idx": {
+          "name": "bm_isbn13_idx",
+          "columns": [
+            {
+              "expression": "isbn13",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "bm_embedding_hnsw_cosine_idx": {
+          "name": "bm_embedding_hnsw_cosine_idx",
+          "columns": [
+            {
+              "expression": "\"embedding\" vector_cosine_ops",
+              "asc": true,
+              "isExpression": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "hnsw",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "book_metadata_book_id_books_id_fk": {
+          "name": "book_metadata_book_id_books_id_fk",
+          "tableFrom": "book_metadata",
+          "tableTo": "books",
+          "columnsFrom": ["book_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "book_metadata_series_id_book_series_id_fk": {
+          "name": "book_metadata_series_id_book_series_id_fk",
+          "tableFrom": "book_metadata",
+          "tableTo": "book_series",
+          "columnsFrom": ["series_id"],
+          "columnsTo": ["id"],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "book_metadata_rating_range_chk": {
+          "name": "book_metadata_rating_range_chk",
+          "value": "\"book_metadata\".\"rating\" is null or (\"book_metadata\".\"rating\" >= 1 and \"book_metadata\".\"rating\" <= 10)"
+        },
+        "book_metadata_published_date_range_chk": {
+          "name": "book_metadata_published_date_range_chk",
+          "value": "\"book_metadata\".\"published_date\" is null or (extract(year from \"book_metadata\".\"published_date\") >= 1000 and extract(year from \"book_metadata\".\"published_date\") <= 2200)"
+        },
+        "book_metadata_published_year_range_chk": {
+          "name": "book_metadata_published_year_range_chk",
+          "value": "\"book_metadata\".\"published_year\" is null or (\"book_metadata\".\"published_year\" >= 1000 and \"book_metadata\".\"published_year\" <= 2200)"
+        },
+        "book_metadata_page_count_nonnegative_chk": {
+          "name": "book_metadata_page_count_nonnegative_chk",
+          "value": "\"book_metadata\".\"page_count\" is null or \"book_metadata\".\"page_count\" >= 0"
+        },
+        "book_metadata_series_index_format_chk": {
+          "name": "book_metadata_series_index_format_chk",
+          "value": "\"book_metadata\".\"series_index\" is null or \"book_metadata\".\"series_index\" ~ '^[0-9]+([.][0-9]+)?$'"
+        },
+        "book_metadata_duration_seconds_nonnegative_chk": {
+          "name": "book_metadata_duration_seconds_nonnegative_chk",
+          "value": "\"book_metadata\".\"duration_seconds\" is null or \"book_metadata\".\"duration_seconds\" >= 0"
+        },
+        "book_metadata_cover_source_chk": {
+          "name": "book_metadata_cover_source_chk",
+          "value": "\"book_metadata\".\"cover_source\" is null or \"book_metadata\".\"cover_source\" in ('extracted', 'custom')"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.book_metadata_fetch_queue": {
+      "name": "book_metadata_fetch_queue",
+      "schema": "",
+      "columns": {
+        "book_id": {
+          "name": "book_id",
+          "type": "integer",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "status": {
+          "name": "status",
+          "type": "varchar(20)",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'queued'"
+        },
+        "reason": {
+          "name": "reason",
+          "type": "varchar(50)",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'manual_trigger'"
+        },
+        "attempt_count": {
+          "name": "attempt_count",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "last_attempt_at": {
+          "name": "last_attempt_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "last_error": {
+          "name": "last_error",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "last_http_status": {
+          "name": "last_http_status",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "bmfq_status_idx": {
+          "name": "bmfq_status_idx",
+          "columns": [
+            {
+              "expression": "status",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "bmfq_created_at_idx": {
+          "name": "bmfq_created_at_idx",
+          "columns": [
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "bmfq_status_created_book_idx": {
+          "name": "bmfq_status_created_book_idx",
+          "columns": [
+            {
+              "expression": "status",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "book_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "book_metadata_fetch_queue_book_id_books_id_fk": {
+          "name": "book_metadata_fetch_queue_book_id_books_id_fk",
+          "tableFrom": "book_metadata_fetch_queue",
+          "tableTo": "books",
+          "columnsFrom": ["book_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "book_metadata_fetch_queue_status_chk": {
+          "name": "book_metadata_fetch_queue_status_chk",
+          "value": "\"book_metadata_fetch_queue\".\"status\" in ('queued', 'processing', 'failed')"
+        },
+        "book_metadata_fetch_queue_reason_chk": {
+          "name": "book_metadata_fetch_queue_reason_chk",
+          "value": "\"book_metadata_fetch_queue\".\"reason\" in ('event_import', 'manual_trigger', 'manual_retry')"
+        },
+        "book_metadata_fetch_queue_attempt_count_nonnegative_chk": {
+          "name": "book_metadata_fetch_queue_attempt_count_nonnegative_chk",
+          "value": "\"book_metadata_fetch_queue\".\"attempt_count\" >= 0"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.book_tags": {
+      "name": "book_tags",
+      "schema": "",
+      "columns": {
+        "book_id": {
+          "name": "book_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "tag_id": {
+          "name": "tag_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {
+        "book_tags_tag_id_idx": {
+          "name": "book_tags_tag_id_idx",
+          "columns": [
+            {
+              "expression": "tag_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "book_tags_book_id_books_id_fk": {
+          "name": "book_tags_book_id_books_id_fk",
+          "tableFrom": "book_tags",
+          "tableTo": "books",
+          "columnsFrom": ["book_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "book_tags_tag_id_tags_id_fk": {
+          "name": "book_tags_tag_id_tags_id_fk",
+          "tableFrom": "book_tags",
+          "tableTo": "tags",
+          "columnsFrom": ["tag_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "book_tags_book_id_tag_id_pk": {
+          "name": "book_tags_book_id_tag_id_pk",
+          "columns": ["book_id", "tag_id"]
+        }
+      },
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.genres": {
+      "name": "genres",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "serial",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "name": {
+          "name": "name",
+          "type": "varchar(200)",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {
+        "genres_name_trgm_idx": {
+          "name": "genres_name_trgm_idx",
+          "columns": [
+            {
+              "expression": "name",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last",
+              "opclass": "gin_trgm_ops"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "gin",
+          "with": {}
+        },
+        "genres_name_unaccent_trgm_idx": {
+          "name": "genres_name_unaccent_trgm_idx",
+          "columns": [
+            {
+              "expression": "public.bookorbit_unaccent(\"name\") gin_trgm_ops",
+              "asc": true,
+              "isExpression": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "gin",
+          "with": {}
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "genres_name_unique": {
+          "name": "genres_name_unique",
+          "nullsNotDistinct": false,
+          "columns": ["name"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.tags": {
+      "name": "tags",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "serial",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "name": {
+          "name": "name",
+          "type": "varchar(200)",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {
+        "tags_name_trgm_idx": {
+          "name": "tags_name_trgm_idx",
+          "columns": [
+            {
+              "expression": "name",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last",
+              "opclass": "gin_trgm_ops"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "gin",
+          "with": {}
+        },
+        "tags_name_unaccent_trgm_idx": {
+          "name": "tags_name_unaccent_trgm_idx",
+          "columns": [
+            {
+              "expression": "public.bookorbit_unaccent(\"name\") gin_trgm_ops",
+              "asc": true,
+              "isExpression": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "gin",
+          "with": {}
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "tags_name_unique": {
+          "name": "tags_name_unique",
+          "nullsNotDistinct": false,
+          "columns": ["name"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.book_narrators": {
+      "name": "book_narrators",
+      "schema": "",
+      "columns": {
+        "book_id": {
+          "name": "book_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "narrator_id": {
+          "name": "narrator_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "display_order": {
+          "name": "display_order",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        }
+      },
+      "indexes": {
+        "book_narrators_narrator_id_idx": {
+          "name": "book_narrators_narrator_id_idx",
+          "columns": [
+            {
+              "expression": "narrator_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "book_narrators_book_id_books_id_fk": {
+          "name": "book_narrators_book_id_books_id_fk",
+          "tableFrom": "book_narrators",
+          "tableTo": "books",
+          "columnsFrom": ["book_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "book_narrators_narrator_id_narrators_id_fk": {
+          "name": "book_narrators_narrator_id_narrators_id_fk",
+          "tableFrom": "book_narrators",
+          "tableTo": "narrators",
+          "columnsFrom": ["narrator_id"],
+          "columnsTo": ["id"],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "book_narrators_book_id_narrator_id_pk": {
+          "name": "book_narrators_book_id_narrator_id_pk",
+          "columns": ["book_id", "narrator_id"]
+        }
+      },
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.narrators": {
+      "name": "narrators",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "serial",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "name": {
+          "name": "name",
+          "type": "varchar(500)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "sort_name": {
+          "name": "sort_name",
+          "type": "varchar(500)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "narrators_name_trgm_idx": {
+          "name": "narrators_name_trgm_idx",
+          "columns": [
+            {
+              "expression": "name",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last",
+              "opclass": "gin_trgm_ops"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "gin",
+          "with": {}
+        },
+        "narrators_name_unaccent_trgm_idx": {
+          "name": "narrators_name_unaccent_trgm_idx",
+          "columns": [
+            {
+              "expression": "public.bookorbit_unaccent(\"name\") gin_trgm_ops",
+              "asc": true,
+              "isExpression": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "gin",
+          "with": {}
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "narrators_name_unique": {
+          "name": "narrators_name_unique",
+          "nullsNotDistinct": false,
+          "columns": ["name"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.library_dir_scan_state": {
+      "name": "library_dir_scan_state",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "serial",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "library_folder_id": {
+          "name": "library_folder_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "dir_path": {
+          "name": "dir_path",
+          "type": "varchar(4096)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "last_seen_mtime_ms": {
+          "name": "last_seen_mtime_ms",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {
+        "library_dir_scan_state_folder_dir_uidx": {
+          "name": "library_dir_scan_state_folder_dir_uidx",
+          "columns": [
+            {
+              "expression": "library_folder_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "dir_path",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "library_dir_scan_state_folder_idx": {
+          "name": "library_dir_scan_state_folder_idx",
+          "columns": [
+            {
+              "expression": "library_folder_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "library_dir_scan_state_library_folder_id_library_folders_id_fk": {
+          "name": "library_dir_scan_state_library_folder_id_library_folders_id_fk",
+          "tableFrom": "library_dir_scan_state",
+          "tableTo": "library_folders",
+          "columnsFrom": ["library_folder_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.scan_jobs": {
+      "name": "scan_jobs",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "serial",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "library_id": {
+          "name": "library_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "status": {
+          "name": "status",
+          "type": "varchar(20)",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'running'"
+        },
+        "triggered_by": {
+          "name": "triggered_by",
+          "type": "varchar(20)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "added_count": {
+          "name": "added_count",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "updated_count": {
+          "name": "updated_count",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "missing_count": {
+          "name": "missing_count",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "error_message": {
+          "name": "error_message",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "started_at": {
+          "name": "started_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "completed_at": {
+          "name": "completed_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "scan_jobs_library_status_idx": {
+          "name": "scan_jobs_library_status_idx",
+          "columns": [
+            {
+              "expression": "library_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "status",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "scan_jobs_library_started_at_idx": {
+          "name": "scan_jobs_library_started_at_idx",
+          "columns": [
+            {
+              "expression": "library_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "\"started_at\" desc",
+              "asc": true,
+              "isExpression": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "scan_jobs_library_id_libraries_id_fk": {
+          "name": "scan_jobs_library_id_libraries_id_fk",
+          "tableFrom": "scan_jobs",
+          "tableTo": "libraries",
+          "columnsFrom": ["library_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "scan_jobs_status_chk": {
+          "name": "scan_jobs_status_chk",
+          "value": "\"scan_jobs\".\"status\" in ('running', 'completed', 'failed')"
+        },
+        "scan_jobs_triggered_by_chk": {
+          "name": "scan_jobs_triggered_by_chk",
+          "value": "\"scan_jobs\".\"triggered_by\" in ('manual', 'watcher', 'schedule')"
+        },
+        "scan_jobs_added_count_nonnegative_chk": {
+          "name": "scan_jobs_added_count_nonnegative_chk",
+          "value": "\"scan_jobs\".\"added_count\" >= 0"
+        },
+        "scan_jobs_updated_count_nonnegative_chk": {
+          "name": "scan_jobs_updated_count_nonnegative_chk",
+          "value": "\"scan_jobs\".\"updated_count\" >= 0"
+        },
+        "scan_jobs_missing_count_nonnegative_chk": {
+          "name": "scan_jobs_missing_count_nonnegative_chk",
+          "value": "\"scan_jobs\".\"missing_count\" >= 0"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.annotation_positions": {
+      "name": "annotation_positions",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "serial",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "annotation_id": {
+          "name": "annotation_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "book_file_id": {
+          "name": "book_file_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "format": {
+          "name": "format",
+          "type": "varchar(12)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "pos0": {
+          "name": "pos0",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "pos1": {
+          "name": "pos1",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "status": {
+          "name": "status",
+          "type": "varchar(10)",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'exact'"
+        },
+        "converter_version": {
+          "name": "converter_version",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "extras": {
+          "name": "extras",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "annotation_positions_annotation_format_uidx": {
+          "name": "annotation_positions_annotation_format_uidx",
+          "columns": [
+            {
+              "expression": "annotation_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "format",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "annotation_positions_user_idx": {
+          "name": "annotation_positions_user_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "annotation_positions_book_file_id_idx": {
+          "name": "annotation_positions_book_file_id_idx",
+          "columns": [
+            {
+              "expression": "book_file_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "annotation_positions_format_status_idx": {
+          "name": "annotation_positions_format_status_idx",
+          "columns": [
+            {
+              "expression": "format",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "status",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "annotation_positions_annotation_id_annotations_id_fk": {
+          "name": "annotation_positions_annotation_id_annotations_id_fk",
+          "tableFrom": "annotation_positions",
+          "tableTo": "annotations",
+          "columnsFrom": ["annotation_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "annotation_positions_user_id_users_id_fk": {
+          "name": "annotation_positions_user_id_users_id_fk",
+          "tableFrom": "annotation_positions",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "annotation_positions_book_file_id_book_files_id_fk": {
+          "name": "annotation_positions_book_file_id_book_files_id_fk",
+          "tableFrom": "annotation_positions",
+          "tableTo": "book_files",
+          "columnsFrom": ["book_file_id"],
+          "columnsTo": ["id"],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "annotation_positions_format_chk": {
+          "name": "annotation_positions_format_chk",
+          "value": "\"annotation_positions\".\"format\" in ('cfi', 'xpointer', 'pdf', 'kobo_span')"
+        },
+        "annotation_positions_status_chk": {
+          "name": "annotation_positions_status_chk",
+          "value": "\"annotation_positions\".\"status\" in ('exact', 'repaired', 'failed', 'pending')"
+        },
+        "annotation_positions_pos0_chk": {
+          "name": "annotation_positions_pos0_chk",
+          "value": "\"annotation_positions\".\"status\" in ('failed', 'pending') or \"annotation_positions\".\"pos0\" is not null"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.annotation_sync_state": {
+      "name": "annotation_sync_state",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "serial",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "annotation_id": {
+          "name": "annotation_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "source": {
+          "name": "source",
+          "type": "varchar(10)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "device_id": {
+          "name": "device_id",
+          "type": "varchar(100)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "external_key": {
+          "name": "external_key",
+          "type": "varchar(64)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "external_created_at": {
+          "name": "external_created_at",
+          "type": "varchar(19)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "last_applied_version": {
+          "name": "last_applied_version",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "delete_acked_at": {
+          "name": "delete_acked_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "first_synced_at": {
+          "name": "first_synced_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "last_synced_at": {
+          "name": "last_synced_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "annotation_sync_state_annotation_source_device_uidx": {
+          "name": "annotation_sync_state_annotation_source_device_uidx",
+          "columns": [
+            {
+              "expression": "annotation_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "source",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "device_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "annotation_sync_state_user_source_device_key_idx": {
+          "name": "annotation_sync_state_user_source_device_key_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "source",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "device_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "external_key",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "annotation_sync_state_user_key_idx": {
+          "name": "annotation_sync_state_user_key_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "external_key",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "annotation_sync_state_annotation_id_idx": {
+          "name": "annotation_sync_state_annotation_id_idx",
+          "columns": [
+            {
+              "expression": "annotation_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "annotation_sync_state_annotation_id_annotations_id_fk": {
+          "name": "annotation_sync_state_annotation_id_annotations_id_fk",
+          "tableFrom": "annotation_sync_state",
+          "tableTo": "annotations",
+          "columnsFrom": ["annotation_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "annotation_sync_state_user_id_users_id_fk": {
+          "name": "annotation_sync_state_user_id_users_id_fk",
+          "tableFrom": "annotation_sync_state",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "annotation_sync_state_source_chk": {
+          "name": "annotation_sync_state_source_chk",
+          "value": "\"annotation_sync_state\".\"source\" in ('koreader', 'kobo')"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.annotations": {
+      "name": "annotations",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "serial",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "book_id": {
+          "name": "book_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "text": {
+          "name": "text",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "color": {
+          "name": "color",
+          "type": "varchar(20)",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'yellow'"
+        },
+        "style": {
+          "name": "style",
+          "type": "varchar(20)",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'highlight'"
+        },
+        "note": {
+          "name": "note",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "chapter_title": {
+          "name": "chapter_title",
+          "type": "varchar(500)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "origin": {
+          "name": "origin",
+          "type": "varchar(10)",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'web'"
+        },
+        "version": {
+          "name": "version",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 1
+        },
+        "deleted_at": {
+          "name": "deleted_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "device_created_at": {
+          "name": "device_created_at",
+          "type": "varchar(19)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "device_updated_at": {
+          "name": "device_updated_at",
+          "type": "varchar(19)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "source_created_at": {
+          "name": "source_created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "annotations_user_id_idx": {
+          "name": "annotations_user_id_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "annotations_user_id_id_idx": {
+          "name": "annotations_user_id_id_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "annotations_user_book_idx": {
+          "name": "annotations_user_book_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "book_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "annotations_book_id_idx": {
+          "name": "annotations_book_id_idx",
+          "columns": [
+            {
+              "expression": "book_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "annotations_user_book_active_idx": {
+          "name": "annotations_user_book_active_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "book_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "where": "\"annotations\".\"deleted_at\" is null",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "annotations_user_created_active_idx": {
+          "name": "annotations_user_created_active_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "coalesce(\"source_created_at\", \"created_at\") desc",
+              "asc": true,
+              "isExpression": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "id",
+              "isExpression": false,
+              "asc": false,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "where": "\"annotations\".\"deleted_at\" is null",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "annotations_user_book_created_active_idx": {
+          "name": "annotations_user_book_created_active_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "book_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "coalesce(\"source_created_at\", \"created_at\") desc",
+              "asc": true,
+              "isExpression": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "id",
+              "isExpression": false,
+              "asc": false,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "where": "\"annotations\".\"deleted_at\" is null",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "annotations_user_id_users_id_fk": {
+          "name": "annotations_user_id_users_id_fk",
+          "tableFrom": "annotations",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "annotations_book_id_books_id_fk": {
+          "name": "annotations_book_id_books_id_fk",
+          "tableFrom": "annotations",
+          "tableTo": "books",
+          "columnsFrom": ["book_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "annotations_style_chk": {
+          "name": "annotations_style_chk",
+          "value": "\"annotations\".\"style\" in ('highlight', 'underline', 'strikethrough', 'squiggly', 'invert')"
+        },
+        "annotations_origin_chk": {
+          "name": "annotations_origin_chk",
+          "value": "\"annotations\".\"origin\" in ('web', 'koreader', 'kobo')"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.audiobook_progress": {
+      "name": "audiobook_progress",
+      "schema": "",
+      "columns": {
+        "user_id": {
+          "name": "user_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "book_id": {
+          "name": "book_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "percentage": {
+          "name": "percentage",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "current_file_id": {
+          "name": "current_file_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "position_seconds": {
+          "name": "position_seconds",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "revision": {
+          "name": "revision",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 1
+        },
+        "captured_at": {
+          "name": "captured_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "operation_id": {
+          "name": "operation_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "manifest_revision": {
+          "name": "manifest_revision",
+          "type": "varchar(64)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "abp_user_id_idx": {
+          "name": "abp_user_id_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "audiobook_progress_book_id_idx": {
+          "name": "audiobook_progress_book_id_idx",
+          "columns": [
+            {
+              "expression": "book_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "audiobook_progress_current_file_id_idx": {
+          "name": "audiobook_progress_current_file_id_idx",
+          "columns": [
+            {
+              "expression": "current_file_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "audiobook_progress_user_id_users_id_fk": {
+          "name": "audiobook_progress_user_id_users_id_fk",
+          "tableFrom": "audiobook_progress",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "audiobook_progress_book_id_books_id_fk": {
+          "name": "audiobook_progress_book_id_books_id_fk",
+          "tableFrom": "audiobook_progress",
+          "tableTo": "books",
+          "columnsFrom": ["book_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "audiobook_progress_current_file_id_book_files_id_fk": {
+          "name": "audiobook_progress_current_file_id_book_files_id_fk",
+          "tableFrom": "audiobook_progress",
+          "tableTo": "book_files",
+          "columnsFrom": ["current_file_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "audiobook_progress_user_id_book_id_pk": {
+          "name": "audiobook_progress_user_id_book_id_pk",
+          "columns": ["user_id", "book_id"]
+        }
+      },
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "audiobook_progress_percentage_range_chk": {
+          "name": "audiobook_progress_percentage_range_chk",
+          "value": "\"audiobook_progress\".\"percentage\" >= 0 and \"audiobook_progress\".\"percentage\" <= 100"
+        },
+        "audiobook_progress_position_seconds_nonnegative_chk": {
+          "name": "audiobook_progress_position_seconds_nonnegative_chk",
+          "value": "\"audiobook_progress\".\"position_seconds\" >= 0"
+        },
+        "audiobook_progress_revision_positive_chk": {
+          "name": "audiobook_progress_revision_positive_chk",
+          "value": "\"audiobook_progress\".\"revision\" >= 1"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.bookmarks": {
+      "name": "bookmarks",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "serial",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "client_id": {
+          "name": "client_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "book_id": {
+          "name": "book_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "cfi": {
+          "name": "cfi",
+          "type": "varchar(2000)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "title": {
+          "name": "title",
+          "type": "varchar(500)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "note": {
+          "name": "note",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "chapter_id": {
+          "name": "chapter_id",
+          "type": "varchar(80)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "position_seconds": {
+          "name": "position_seconds",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "origin": {
+          "name": "origin",
+          "type": "varchar(10)",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'web'"
+        },
+        "device_pos": {
+          "name": "device_pos",
+          "type": "varchar(4000)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "pageno": {
+          "name": "pageno",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "deleted_at": {
+          "name": "deleted_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "bookmarks_user_book_client_id_uidx": {
+          "name": "bookmarks_user_book_client_id_uidx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "book_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "client_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "bookmarks_user_book_idx": {
+          "name": "bookmarks_user_book_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "book_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "bookmarks_book_id_idx": {
+          "name": "bookmarks_book_id_idx",
+          "columns": [
+            {
+              "expression": "book_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "bookmarks_deleted_at_idx": {
+          "name": "bookmarks_deleted_at_idx",
+          "columns": [
+            {
+              "expression": "deleted_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "where": "\"bookmarks\".\"deleted_at\" is not null",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "bookmarks_user_book_cfi_uidx": {
+          "name": "bookmarks_user_book_cfi_uidx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "book_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "cfi",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "where": "\"bookmarks\".\"cfi\" is not null",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "bookmarks_user_book_pos_uidx": {
+          "name": "bookmarks_user_book_pos_uidx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "book_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "position_seconds",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "where": "\"bookmarks\".\"position_seconds\" is not null and \"bookmarks\".\"cfi\" is null",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "bookmarks_user_id_users_id_fk": {
+          "name": "bookmarks_user_id_users_id_fk",
+          "tableFrom": "bookmarks",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "bookmarks_book_id_books_id_fk": {
+          "name": "bookmarks_book_id_books_id_fk",
+          "tableFrom": "bookmarks",
+          "tableTo": "books",
+          "columnsFrom": ["book_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "bookmarks_origin_chk": {
+          "name": "bookmarks_origin_chk",
+          "value": "\"bookmarks\".\"origin\" in ('web', 'koreader')"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.reader_default_preferences": {
+      "name": "reader_default_preferences",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "serial",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "format_group": {
+          "name": "format_group",
+          "type": "varchar(10)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "settings": {
+          "name": "settings",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "rdp_user_format_idx": {
+          "name": "rdp_user_format_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "format_group",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "reader_default_preferences_user_id_users_id_fk": {
+          "name": "reader_default_preferences_user_id_users_id_fk",
+          "tableFrom": "reader_default_preferences",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "reader_default_preferences_format_group_chk": {
+          "name": "reader_default_preferences_format_group_chk",
+          "value": "\"reader_default_preferences\".\"format_group\" in ('epub', 'pdf', 'cbx', 'audio')"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.reader_preferences": {
+      "name": "reader_preferences",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "serial",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "book_file_id": {
+          "name": "book_file_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "settings": {
+          "name": "settings",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "rp_user_file_idx": {
+          "name": "rp_user_file_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "book_file_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "reader_preferences_book_file_id_idx": {
+          "name": "reader_preferences_book_file_id_idx",
+          "columns": [
+            {
+              "expression": "book_file_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "reader_preferences_user_id_users_id_fk": {
+          "name": "reader_preferences_user_id_users_id_fk",
+          "tableFrom": "reader_preferences",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "reader_preferences_book_file_id_book_files_id_fk": {
+          "name": "reader_preferences_book_file_id_book_files_id_fk",
+          "tableFrom": "reader_preferences",
+          "tableTo": "book_files",
+          "columnsFrom": ["book_file_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.reading_attempts": {
+      "name": "reading_attempts",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "serial",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "book_id": {
+          "name": "book_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "started_on": {
+          "name": "started_on",
+          "type": "date",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "ended_on": {
+          "name": "ended_on",
+          "type": "date",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "outcome": {
+          "name": "outcome",
+          "type": "varchar(20)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "origin": {
+          "name": "origin",
+          "type": "varchar(20)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "external_provider": {
+          "name": "external_provider",
+          "type": "varchar(40)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "external_id": {
+          "name": "external_id",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "deleted_at": {
+          "name": "deleted_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "reading_attempts_user_book_idx": {
+          "name": "reading_attempts_user_book_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "book_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "reading_attempts_book_id_idx": {
+          "name": "reading_attempts_book_id_idx",
+          "columns": [
+            {
+              "expression": "book_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "reading_attempts_user_outcome_ended_idx": {
+          "name": "reading_attempts_user_outcome_ended_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "outcome",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "ended_on",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "reading_attempts_one_active_uidx": {
+          "name": "reading_attempts_one_active_uidx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "book_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "where": "\"reading_attempts\".\"outcome\" is null and \"reading_attempts\".\"deleted_at\" is null",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "reading_attempts_external_uidx": {
+          "name": "reading_attempts_external_uidx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "external_provider",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "external_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "where": "\"reading_attempts\".\"external_provider\" is not null and \"reading_attempts\".\"external_id\" is not null",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "reading_attempts_user_id_users_id_fk": {
+          "name": "reading_attempts_user_id_users_id_fk",
+          "tableFrom": "reading_attempts",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "reading_attempts_book_id_books_id_fk": {
+          "name": "reading_attempts_book_id_books_id_fk",
+          "tableFrom": "reading_attempts",
+          "tableTo": "books",
+          "columnsFrom": ["book_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "reading_attempts_outcome_chk": {
+          "name": "reading_attempts_outcome_chk",
+          "value": "\"reading_attempts\".\"outcome\" is null or \"reading_attempts\".\"outcome\" in ('completed', 'skimmed', 'abandoned')"
+        },
+        "reading_attempts_origin_chk": {
+          "name": "reading_attempts_origin_chk",
+          "value": "\"reading_attempts\".\"origin\" in ('manual', 'bookorbit', 'kobo', 'koreader', 'hardcover', 'migration')"
+        },
+        "reading_attempts_end_after_start_chk": {
+          "name": "reading_attempts_end_after_start_chk",
+          "value": "\"reading_attempts\".\"ended_on\" is null or \"reading_attempts\".\"started_on\" is null or \"reading_attempts\".\"ended_on\" >= \"reading_attempts\".\"started_on\""
+        },
+        "reading_attempts_closed_has_outcome_chk": {
+          "name": "reading_attempts_closed_has_outcome_chk",
+          "value": "\"reading_attempts\".\"ended_on\" is null or \"reading_attempts\".\"outcome\" is not null"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.reading_progress": {
+      "name": "reading_progress",
+      "schema": "",
+      "columns": {
+        "book_file_id": {
+          "name": "book_file_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "percentage": {
+          "name": "percentage",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "cfi": {
+          "name": "cfi",
+          "type": "varchar(2000)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "page_number": {
+          "name": "page_number",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "position_seconds": {
+          "name": "position_seconds",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "media_overlay_fragment": {
+          "name": "media_overlay_fragment",
+          "type": "varchar(4096)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "media_overlay_section_index": {
+          "name": "media_overlay_section_index",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "kobo_location_source": {
+          "name": "kobo_location_source",
+          "type": "varchar(4096)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "kobo_location_type": {
+          "name": "kobo_location_type",
+          "type": "varchar(64)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "kobo_location_value": {
+          "name": "kobo_location_value",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "kobo_content_source_progress_percent": {
+          "name": "kobo_content_source_progress_percent",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "koreader_progress": {
+          "name": "koreader_progress",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "narration_percentage": {
+          "name": "narration_percentage",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "narration_updated_at": {
+          "name": "narration_updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "text_updated_at": {
+          "name": "text_updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "last_read_at": {
+          "name": "last_read_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "reading_progress_user_id_idx": {
+          "name": "reading_progress_user_id_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "reading_progress_user_last_read_at_idx": {
+          "name": "reading_progress_user_last_read_at_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "last_read_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "reading_progress_book_file_id_book_files_id_fk": {
+          "name": "reading_progress_book_file_id_book_files_id_fk",
+          "tableFrom": "reading_progress",
+          "tableTo": "book_files",
+          "columnsFrom": ["book_file_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "reading_progress_user_id_users_id_fk": {
+          "name": "reading_progress_user_id_users_id_fk",
+          "tableFrom": "reading_progress",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "reading_progress_book_file_id_user_id_pk": {
+          "name": "reading_progress_book_file_id_user_id_pk",
+          "columns": ["book_file_id", "user_id"]
+        }
+      },
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "reading_progress_percentage_range_chk": {
+          "name": "reading_progress_percentage_range_chk",
+          "value": "\"reading_progress\".\"percentage\" >= 0 and \"reading_progress\".\"percentage\" <= 100"
+        },
+        "reading_progress_page_number_nonnegative_chk": {
+          "name": "reading_progress_page_number_nonnegative_chk",
+          "value": "\"reading_progress\".\"page_number\" is null or \"reading_progress\".\"page_number\" >= 0"
+        },
+        "reading_progress_position_seconds_nonnegative_chk": {
+          "name": "reading_progress_position_seconds_nonnegative_chk",
+          "value": "\"reading_progress\".\"position_seconds\" is null or \"reading_progress\".\"position_seconds\" >= 0"
+        },
+        "reading_progress_media_overlay_section_index_nonnegative_chk": {
+          "name": "reading_progress_media_overlay_section_index_nonnegative_chk",
+          "value": "\"reading_progress\".\"media_overlay_section_index\" is null or \"reading_progress\".\"media_overlay_section_index\" >= 0"
+        },
+        "reading_progress_kobo_content_source_progress_range_chk": {
+          "name": "reading_progress_kobo_content_source_progress_range_chk",
+          "value": "\"reading_progress\".\"kobo_content_source_progress_percent\" is null or (\"reading_progress\".\"kobo_content_source_progress_percent\" >= 0 and \"reading_progress\".\"kobo_content_source_progress_percent\" <= 100)"
+        },
+        "reading_progress_narration_percentage_range_chk": {
+          "name": "reading_progress_narration_percentage_range_chk",
+          "value": "\"reading_progress\".\"narration_percentage\" is null or (\"reading_progress\".\"narration_percentage\" >= 0 and \"reading_progress\".\"narration_percentage\" <= 100)"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.reading_session_sync_cursors": {
+      "name": "reading_session_sync_cursors",
+      "schema": "",
+      "columns": {
+        "user_id": {
+          "name": "user_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "book_id": {
+          "name": "book_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "source": {
+          "name": "source",
+          "type": "varchar(32)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "source_device_key": {
+          "name": "source_device_key",
+          "type": "varchar(128)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "counter": {
+          "name": "counter",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "generation": {
+          "name": "generation",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "last_modified": {
+          "name": "last_modified",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "rssc_book_id_idx": {
+          "name": "rssc_book_id_idx",
+          "columns": [
+            {
+              "expression": "book_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "reading_session_sync_cursors_user_id_users_id_fk": {
+          "name": "reading_session_sync_cursors_user_id_users_id_fk",
+          "tableFrom": "reading_session_sync_cursors",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "reading_session_sync_cursors_book_id_books_id_fk": {
+          "name": "reading_session_sync_cursors_book_id_books_id_fk",
+          "tableFrom": "reading_session_sync_cursors",
+          "tableTo": "books",
+          "columnsFrom": ["book_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "reading_session_sync_cursors_user_id_book_id_source_source_device_key_pk": {
+          "name": "reading_session_sync_cursors_user_id_book_id_source_source_device_key_pk",
+          "columns": ["user_id", "book_id", "source", "source_device_key"]
+        }
+      },
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "rssc_counter_nonnegative_chk": {
+          "name": "rssc_counter_nonnegative_chk",
+          "value": "\"reading_session_sync_cursors\".\"counter\" >= 0"
+        },
+        "rssc_generation_nonnegative_chk": {
+          "name": "rssc_generation_nonnegative_chk",
+          "value": "\"reading_session_sync_cursors\".\"generation\" >= 0"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.reading_sessions": {
+      "name": "reading_sessions",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "serial",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "book_file_id": {
+          "name": "book_file_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "book_id": {
+          "name": "book_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "attempt_id": {
+          "name": "attempt_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "session_id": {
+          "name": "session_id",
+          "type": "varchar(64)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "source": {
+          "name": "source",
+          "type": "varchar(10)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "source_device_key": {
+          "name": "source_device_key",
+          "type": "varchar(128)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "session_type": {
+          "name": "session_type",
+          "type": "varchar(20)",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'read'"
+        },
+        "started_at": {
+          "name": "started_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "ended_at": {
+          "name": "ended_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "duration_seconds": {
+          "name": "duration_seconds",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "progress_delta": {
+          "name": "progress_delta",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "end_progress": {
+          "name": "end_progress",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "rs_user_session_id_uidx": {
+          "name": "rs_user_session_id_uidx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "session_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "rs_user_started_at_idx": {
+          "name": "rs_user_started_at_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "started_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "rs_book_file_started_at_idx": {
+          "name": "rs_book_file_started_at_idx",
+          "columns": [
+            {
+              "expression": "book_file_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "started_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "rs_user_book_file_idx": {
+          "name": "rs_user_book_file_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "book_file_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "rs_user_book_started_at_idx": {
+          "name": "rs_user_book_started_at_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "book_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "started_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "rs_user_book_source_device_started_idx": {
+          "name": "rs_user_book_source_device_started_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "book_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "source",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "source_device_key",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "started_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "reading_sessions_book_id_idx": {
+          "name": "reading_sessions_book_id_idx",
+          "columns": [
+            {
+              "expression": "book_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "rs_attempt_started_at_idx": {
+          "name": "rs_attempt_started_at_idx",
+          "columns": [
+            {
+              "expression": "attempt_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "started_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "reading_sessions_user_id_users_id_fk": {
+          "name": "reading_sessions_user_id_users_id_fk",
+          "tableFrom": "reading_sessions",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "reading_sessions_book_file_id_book_files_id_fk": {
+          "name": "reading_sessions_book_file_id_book_files_id_fk",
+          "tableFrom": "reading_sessions",
+          "tableTo": "book_files",
+          "columnsFrom": ["book_file_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "reading_sessions_book_id_books_id_fk": {
+          "name": "reading_sessions_book_id_books_id_fk",
+          "tableFrom": "reading_sessions",
+          "tableTo": "books",
+          "columnsFrom": ["book_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "reading_sessions_attempt_id_reading_attempts_id_fk": {
+          "name": "reading_sessions_attempt_id_reading_attempts_id_fk",
+          "tableFrom": "reading_sessions",
+          "tableTo": "reading_attempts",
+          "columnsFrom": ["attempt_id"],
+          "columnsTo": ["id"],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "reading_sessions_source_chk": {
+          "name": "reading_sessions_source_chk",
+          "value": "\"reading_sessions\".\"source\" in ('web', 'ios', 'watchos', 'android', 'koreader', 'manual', 'kobo')"
+        },
+        "reading_sessions_duration_seconds_nonnegative_chk": {
+          "name": "reading_sessions_duration_seconds_nonnegative_chk",
+          "value": "\"reading_sessions\".\"duration_seconds\" >= 0"
+        },
+        "reading_sessions_end_progress_range_chk": {
+          "name": "reading_sessions_end_progress_range_chk",
+          "value": "\"reading_sessions\".\"end_progress\" is null or (\"reading_sessions\".\"end_progress\" >= 0 and \"reading_sessions\".\"end_progress\" <= 100)"
+        },
+        "reading_sessions_ended_after_started_chk": {
+          "name": "reading_sessions_ended_after_started_chk",
+          "value": "\"reading_sessions\".\"ended_at\" >= \"reading_sessions\".\"started_at\""
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.user_book_notes": {
+      "name": "user_book_notes",
+      "schema": "",
+      "columns": {
+        "user_id": {
+          "name": "user_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "book_id": {
+          "name": "book_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "note": {
+          "name": "note",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "ubn_user_id_idx": {
+          "name": "ubn_user_id_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "ubn_book_id_idx": {
+          "name": "ubn_book_id_idx",
+          "columns": [
+            {
+              "expression": "book_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "ubn_book_user_idx": {
+          "name": "ubn_book_user_idx",
+          "columns": [
+            {
+              "expression": "book_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "user_book_notes_user_id_users_id_fk": {
+          "name": "user_book_notes_user_id_users_id_fk",
+          "tableFrom": "user_book_notes",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "user_book_notes_book_id_books_id_fk": {
+          "name": "user_book_notes_book_id_books_id_fk",
+          "tableFrom": "user_book_notes",
+          "tableTo": "books",
+          "columnsFrom": ["book_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "user_book_notes_user_id_book_id_pk": {
+          "name": "user_book_notes_user_id_book_id_pk",
+          "columns": ["user_id", "book_id"]
+        }
+      },
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "user_book_notes_note_length_chk": {
+          "name": "user_book_notes_note_length_chk",
+          "value": "\"user_book_notes\".\"note\" is null or char_length(\"user_book_notes\".\"note\") <= 10000"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.user_book_ratings": {
+      "name": "user_book_ratings",
+      "schema": "",
+      "columns": {
+        "user_id": {
+          "name": "user_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "book_id": {
+          "name": "book_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "rating": {
+          "name": "rating",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "ubr_user_id_idx": {
+          "name": "ubr_user_id_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "ubr_book_id_idx": {
+          "name": "ubr_book_id_idx",
+          "columns": [
+            {
+              "expression": "book_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "ubr_book_user_rating_idx": {
+          "name": "ubr_book_user_rating_idx",
+          "columns": [
+            {
+              "expression": "book_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "user_book_ratings_user_id_users_id_fk": {
+          "name": "user_book_ratings_user_id_users_id_fk",
+          "tableFrom": "user_book_ratings",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "user_book_ratings_book_id_books_id_fk": {
+          "name": "user_book_ratings_book_id_books_id_fk",
+          "tableFrom": "user_book_ratings",
+          "tableTo": "books",
+          "columnsFrom": ["book_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "user_book_ratings_user_id_book_id_pk": {
+          "name": "user_book_ratings_user_id_book_id_pk",
+          "columns": ["user_id", "book_id"]
+        }
+      },
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "user_book_ratings_rating_range_chk": {
+          "name": "user_book_ratings_rating_range_chk",
+          "value": "\"user_book_ratings\".\"rating\" is null or (\"user_book_ratings\".\"rating\" >= 1 and \"user_book_ratings\".\"rating\" <= 5)"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.user_book_read_aloud_sync_settings": {
+      "name": "user_book_read_aloud_sync_settings",
+      "schema": "",
+      "columns": {
+        "user_id": {
+          "name": "user_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "book_id": {
+          "name": "book_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "mode": {
+          "name": "mode",
+          "type": "varchar(20)",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'auto'"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "ubrass_user_id_idx": {
+          "name": "ubrass_user_id_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "user_book_read_aloud_sync_settings_user_id_users_id_fk": {
+          "name": "user_book_read_aloud_sync_settings_user_id_users_id_fk",
+          "tableFrom": "user_book_read_aloud_sync_settings",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "user_book_read_aloud_sync_settings_book_id_books_id_fk": {
+          "name": "user_book_read_aloud_sync_settings_book_id_books_id_fk",
+          "tableFrom": "user_book_read_aloud_sync_settings",
+          "tableTo": "books",
+          "columnsFrom": ["book_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "user_book_read_aloud_sync_settings_user_id_book_id_pk": {
+          "name": "user_book_read_aloud_sync_settings_user_id_book_id_pk",
+          "columns": ["user_id", "book_id"]
+        }
+      },
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "user_book_read_aloud_sync_settings_mode_chk": {
+          "name": "user_book_read_aloud_sync_settings_mode_chk",
+          "value": "\"user_book_read_aloud_sync_settings\".\"mode\" in ('auto', 'disabled')"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.user_book_status": {
+      "name": "user_book_status",
+      "schema": "",
+      "columns": {
+        "user_id": {
+          "name": "user_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "book_id": {
+          "name": "book_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "status": {
+          "name": "status",
+          "type": "varchar(20)",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'unread'"
+        },
+        "source": {
+          "name": "source",
+          "type": "varchar(10)",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'auto'"
+        },
+        "started_at": {
+          "name": "started_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "finished_at": {
+          "name": "finished_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "ubs_user_id_idx": {
+          "name": "ubs_user_id_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "ubs_user_status_idx": {
+          "name": "ubs_user_status_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "status",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "ubs_book_user_idx": {
+          "name": "ubs_book_user_idx",
+          "columns": [
+            {
+              "expression": "book_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "user_book_status_user_id_users_id_fk": {
+          "name": "user_book_status_user_id_users_id_fk",
+          "tableFrom": "user_book_status",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "user_book_status_book_id_books_id_fk": {
+          "name": "user_book_status_book_id_books_id_fk",
+          "tableFrom": "user_book_status",
+          "tableTo": "books",
+          "columnsFrom": ["book_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "user_book_status_user_id_book_id_pk": {
+          "name": "user_book_status_user_id_book_id_pk",
+          "columns": ["user_id", "book_id"]
+        }
+      },
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "user_book_status_status_chk": {
+          "name": "user_book_status_status_chk",
+          "value": "\"user_book_status\".\"status\" in ('unread', 'want_to_read', 'reading', 'on_hold', 'rereading', 'read', 'skimmed', 'abandoned')"
+        },
+        "user_book_status_source_chk": {
+          "name": "user_book_status_source_chk",
+          "value": "\"user_book_status\".\"source\" in ('auto', 'manual')"
+        },
+        "user_book_status_finished_after_started_chk": {
+          "name": "user_book_status_finished_after_started_chk",
+          "value": "\"user_book_status\".\"finished_at\" is null or \"user_book_status\".\"started_at\" is null or \"user_book_status\".\"finished_at\" >= \"user_book_status\".\"started_at\""
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.user_reading_daily_stats": {
+      "name": "user_reading_daily_stats",
+      "schema": "",
+      "columns": {
+        "user_id": {
+          "name": "user_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "library_id": {
+          "name": "library_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "day": {
+          "name": "day",
+          "type": "date",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "reading_seconds": {
+          "name": "reading_seconds",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "progress_delta": {
+          "name": "progress_delta",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "sessions_count": {
+          "name": "sessions_count",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "urds_user_day_idx": {
+          "name": "urds_user_day_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "day",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "user_reading_daily_stats_library_id_idx": {
+          "name": "user_reading_daily_stats_library_id_idx",
+          "columns": [
+            {
+              "expression": "library_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "user_reading_daily_stats_user_id_users_id_fk": {
+          "name": "user_reading_daily_stats_user_id_users_id_fk",
+          "tableFrom": "user_reading_daily_stats",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "user_reading_daily_stats_library_id_libraries_id_fk": {
+          "name": "user_reading_daily_stats_library_id_libraries_id_fk",
+          "tableFrom": "user_reading_daily_stats",
+          "tableTo": "libraries",
+          "columnsFrom": ["library_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "user_reading_daily_stats_user_id_library_id_day_pk": {
+          "name": "user_reading_daily_stats_user_id_library_id_day_pk",
+          "columns": ["user_id", "library_id", "day"]
+        }
+      },
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "user_reading_daily_stats_reading_seconds_nonnegative_chk": {
+          "name": "user_reading_daily_stats_reading_seconds_nonnegative_chk",
+          "value": "\"user_reading_daily_stats\".\"reading_seconds\" >= 0"
+        },
+        "user_reading_daily_stats_sessions_count_nonnegative_chk": {
+          "name": "user_reading_daily_stats_sessions_count_nonnegative_chk",
+          "value": "\"user_reading_daily_stats\".\"sessions_count\" >= 0"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.oidc_group_mappings": {
+      "name": "oidc_group_mappings",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "serial",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "provider_id": {
+          "name": "provider_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "oidc_group_claim": {
+          "name": "oidc_group_claim",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "permission_name": {
+          "name": "permission_name",
+          "type": "varchar(100)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "oidc_group_mappings_provider_claim_uidx": {
+          "name": "oidc_group_mappings_provider_claim_uidx",
+          "columns": [
+            {
+              "expression": "provider_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "oidc_group_claim",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "oidc_group_mappings_provider_id_oidc_providers_id_fk": {
+          "name": "oidc_group_mappings_provider_id_oidc_providers_id_fk",
+          "tableFrom": "oidc_group_mappings",
+          "tableTo": "oidc_providers",
+          "columnsFrom": ["provider_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.oidc_identities": {
+      "name": "oidc_identities",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "serial",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "provider_id": {
+          "name": "provider_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "oidc_subject": {
+          "name": "oidc_subject",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "oidc_issuer": {
+          "name": "oidc_issuer",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "linked_at": {
+          "name": "linked_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "oidc_identities_provider_subject_uidx": {
+          "name": "oidc_identities_provider_subject_uidx",
+          "columns": [
+            {
+              "expression": "provider_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "oidc_subject",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "oidc_identities_user_provider_uidx": {
+          "name": "oidc_identities_user_provider_uidx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "provider_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "oidc_identities_issuer_subject_uidx": {
+          "name": "oidc_identities_issuer_subject_uidx",
+          "columns": [
+            {
+              "expression": "oidc_issuer",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "oidc_subject",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "oidc_identities_user_id_idx": {
+          "name": "oidc_identities_user_id_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "oidc_identities_user_id_users_id_fk": {
+          "name": "oidc_identities_user_id_users_id_fk",
+          "tableFrom": "oidc_identities",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "oidc_identities_provider_id_oidc_providers_id_fk": {
+          "name": "oidc_identities_provider_id_oidc_providers_id_fk",
+          "tableFrom": "oidc_identities",
+          "tableTo": "oidc_providers",
+          "columnsFrom": ["provider_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.oidc_permission_grants": {
+      "name": "oidc_permission_grants",
+      "schema": "",
+      "columns": {
+        "user_id": {
+          "name": "user_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "provider_id": {
+          "name": "provider_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "permission_name": {
+          "name": "permission_name",
+          "type": "varchar(100)",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "oidc_permission_grants_user_id_users_id_fk": {
+          "name": "oidc_permission_grants_user_id_users_id_fk",
+          "tableFrom": "oidc_permission_grants",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "oidc_permission_grants_provider_id_oidc_providers_id_fk": {
+          "name": "oidc_permission_grants_provider_id_oidc_providers_id_fk",
+          "tableFrom": "oidc_permission_grants",
+          "tableTo": "oidc_providers",
+          "columnsFrom": ["provider_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "oidc_permission_grants_user_id_provider_id_permission_name_pk": {
+          "name": "oidc_permission_grants_user_id_provider_id_permission_name_pk",
+          "columns": ["user_id", "provider_id", "permission_name"]
+        }
+      },
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.oidc_providers": {
+      "name": "oidc_providers",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "serial",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "slug": {
+          "name": "slug",
+          "type": "varchar(100)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "display_name": {
+          "name": "display_name",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "enabled": {
+          "name": "enabled",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "issuer_uri": {
+          "name": "issuer_uri",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "client_id": {
+          "name": "client_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "client_secret": {
+          "name": "client_secret",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "scopes": {
+          "name": "scopes",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'openid profile email'"
+        },
+        "icon_url": {
+          "name": "icon_url",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "claim_mapping": {
+          "name": "claim_mapping",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'{\"username\":\"preferred_username\",\"name\":\"name\",\"email\":\"email\",\"groups\":\"groups\"}'::jsonb"
+        },
+        "auto_provision": {
+          "name": "auto_provision",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'{\"enabled\":false,\"allowLocalLinking\":false,\"defaultPermissionNames\":[]}'::jsonb"
+        },
+        "display_order": {
+          "name": "display_order",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "oidc_providers_enabled_order_idx": {
+          "name": "oidc_providers_enabled_order_idx",
+          "columns": [
+            {
+              "expression": "enabled",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "display_order",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "oidc_providers_slug_unique": {
+          "name": "oidc_providers_slug_unique",
+          "nullsNotDistinct": false,
+          "columns": ["slug"]
+        },
+        "oidc_providers_issuer_uri_unique": {
+          "name": "oidc_providers_issuer_uri_unique",
+          "nullsNotDistinct": false,
+          "columns": ["issuer_uri"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.oidc_sessions": {
+      "name": "oidc_sessions",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "serial",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "session_id": {
+          "name": "session_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "provider_id": {
+          "name": "provider_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "oidc_subject": {
+          "name": "oidc_subject",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "oidc_issuer": {
+          "name": "oidc_issuer",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "oidc_session_id": {
+          "name": "oidc_session_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "id_token_hint": {
+          "name": "id_token_hint",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "idp_refresh_token": {
+          "name": "idp_refresh_token",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "revoked": {
+          "name": "revoked",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "expires_at": {
+          "name": "expires_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {
+        "oidc_sessions_user_active_idx": {
+          "name": "oidc_sessions_user_active_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "where": "\"oidc_sessions\".\"revoked\" = false",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "oidc_sessions_subject_issuer_idx": {
+          "name": "oidc_sessions_subject_issuer_idx",
+          "columns": [
+            {
+              "expression": "oidc_subject",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "oidc_issuer",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "oidc_sessions_sid_idx": {
+          "name": "oidc_sessions_sid_idx",
+          "columns": [
+            {
+              "expression": "oidc_session_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "oidc_sessions_session_id_idx": {
+          "name": "oidc_sessions_session_id_idx",
+          "columns": [
+            {
+              "expression": "session_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "oidc_sessions_expires_at_idx": {
+          "name": "oidc_sessions_expires_at_idx",
+          "columns": [
+            {
+              "expression": "expires_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "oidc_sessions_provider_id_idx": {
+          "name": "oidc_sessions_provider_id_idx",
+          "columns": [
+            {
+              "expression": "provider_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "oidc_sessions_user_id_users_id_fk": {
+          "name": "oidc_sessions_user_id_users_id_fk",
+          "tableFrom": "oidc_sessions",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "oidc_sessions_session_id_auth_sessions_id_fk": {
+          "name": "oidc_sessions_session_id_auth_sessions_id_fk",
+          "tableFrom": "oidc_sessions",
+          "tableTo": "auth_sessions",
+          "columnsFrom": ["session_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "oidc_sessions_provider_id_oidc_providers_id_fk": {
+          "name": "oidc_sessions_provider_id_oidc_providers_id_fk",
+          "tableFrom": "oidc_sessions",
+          "tableTo": "oidc_providers",
+          "columnsFrom": ["provider_id"],
+          "columnsTo": ["id"],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.oidc_states": {
+      "name": "oidc_states",
+      "schema": "",
+      "columns": {
+        "state": {
+          "name": "state",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "provider_id": {
+          "name": "provider_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "expires_at": {
+          "name": "expires_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "meta": {
+          "name": "meta",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "oidc_states_expires_at_idx": {
+          "name": "oidc_states_expires_at_idx",
+          "columns": [
+            {
+              "expression": "expires_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "oidc_states_provider_id_oidc_providers_id_fk": {
+          "name": "oidc_states_provider_id_oidc_providers_id_fk",
+          "tableFrom": "oidc_states",
+          "tableTo": "oidc_providers",
+          "columnsFrom": ["provider_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.oidc_used_jtis": {
+      "name": "oidc_used_jtis",
+      "schema": "",
+      "columns": {
+        "jti": {
+          "name": "jti",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "expires_at": {
+          "name": "expires_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {
+        "oidc_used_jtis_expires_at_idx": {
+          "name": "oidc_used_jtis_expires_at_idx",
+          "columns": [
+            {
+              "expression": "expires_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.opds_users": {
+      "name": "opds_users",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "serial",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "username": {
+          "name": "username",
+          "type": "varchar(100)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "password_hash": {
+          "name": "password_hash",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "sort_order": {
+          "name": "sort_order",
+          "type": "opds_sort_order",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'recent'"
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "opds_users_username_lower_uidx": {
+          "name": "opds_users_username_lower_uidx",
+          "columns": [
+            {
+              "expression": "lower(\"username\")",
+              "asc": true,
+              "isExpression": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "opds_users_user_id_users_id_fk": {
+          "name": "opds_users_user_id_users_id_fk",
+          "tableFrom": "opds_users",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "opds_users_username_unique": {
+          "name": "opds_users_username_unique",
+          "nullsNotDistinct": false,
+          "columns": ["username"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.kobo_book_entitlements": {
+      "name": "kobo_book_entitlements",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "serial",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "book_id": {
+          "name": "book_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "entitlement_id": {
+          "name": "entitlement_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "cover_image_id": {
+          "name": "cover_image_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "needs_legacy_numeric_removal": {
+          "name": "needs_legacy_numeric_removal",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "kobo_book_entitlements_user_id_idx": {
+          "name": "kobo_book_entitlements_user_id_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "kobo_book_entitlements_book_id_idx": {
+          "name": "kobo_book_entitlements_book_id_idx",
+          "columns": [
+            {
+              "expression": "book_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "kobo_book_entitlements_user_id_users_id_fk": {
+          "name": "kobo_book_entitlements_user_id_users_id_fk",
+          "tableFrom": "kobo_book_entitlements",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "kobo_book_entitlements_book_id_books_id_fk": {
+          "name": "kobo_book_entitlements_book_id_books_id_fk",
+          "tableFrom": "kobo_book_entitlements",
+          "tableTo": "books",
+          "columnsFrom": ["book_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "kobo_book_entitlements_user_book_unique": {
+          "name": "kobo_book_entitlements_user_book_unique",
+          "nullsNotDistinct": false,
+          "columns": ["user_id", "book_id"]
+        },
+        "kobo_book_entitlements_user_entitlement_unique": {
+          "name": "kobo_book_entitlements_user_entitlement_unique",
+          "nullsNotDistinct": false,
+          "columns": ["user_id", "entitlement_id"]
+        },
+        "kobo_book_entitlements_user_cover_unique": {
+          "name": "kobo_book_entitlements_user_cover_unique",
+          "nullsNotDistinct": false,
+          "columns": ["user_id", "cover_image_id"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.kobo_devices": {
+      "name": "kobo_devices",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "serial",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "name": {
+          "name": "name",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "token": {
+          "name": "token",
+          "type": "varchar(64)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "client_device_id": {
+          "name": "client_device_id",
+          "type": "varchar(128)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "last_seen_at": {
+          "name": "last_seen_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "kobo_devices_user_id_idx": {
+          "name": "kobo_devices_user_id_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "kobo_devices_user_id_users_id_fk": {
+          "name": "kobo_devices_user_id_users_id_fk",
+          "tableFrom": "kobo_devices",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "kobo_devices_token_unique": {
+          "name": "kobo_devices_token_unique",
+          "nullsNotDistinct": false,
+          "columns": ["token"]
+        },
+        "kobo_devices_client_device_id_unique": {
+          "name": "kobo_devices_client_device_id_unique",
+          "nullsNotDistinct": false,
+          "columns": ["client_device_id"]
+        },
+        "kobo_devices_id_user_id_unique": {
+          "name": "kobo_devices_id_user_id_unique",
+          "nullsNotDistinct": false,
+          "columns": ["id", "user_id"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.kobo_library_snapshots": {
+      "name": "kobo_library_snapshots",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "serial",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "legacy_device_cutoff_at": {
+          "name": "legacy_device_cutoff_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "kobo_library_snapshots_user_id_users_id_fk": {
+          "name": "kobo_library_snapshots_user_id_users_id_fk",
+          "tableFrom": "kobo_library_snapshots",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "kobo_library_snapshots_user_id_unique": {
+          "name": "kobo_library_snapshots_user_id_unique",
+          "nullsNotDistinct": false,
+          "columns": ["user_id"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.kobo_snapshot_books": {
+      "name": "kobo_snapshot_books",
+      "schema": "",
+      "columns": {
+        "snapshot_id": {
+          "name": "snapshot_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "book_id": {
+          "name": "book_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "synced": {
+          "name": "synced",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "pending_delete": {
+          "name": "pending_delete",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "is_new": {
+          "name": "is_new",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": true
+        },
+        "removed_by_device": {
+          "name": "removed_by_device",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "file_hash": {
+          "name": "file_hash",
+          "type": "varchar(64)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "delivery_hash": {
+          "name": "delivery_hash",
+          "type": "varchar(64)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "metadata_hash": {
+          "name": "metadata_hash",
+          "type": "varchar(64)",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "kobo_snapshot_books_book_id_idx": {
+          "name": "kobo_snapshot_books_book_id_idx",
+          "columns": [
+            {
+              "expression": "book_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "kobo_snapshot_books_snapshot_synced_book_idx": {
+          "name": "kobo_snapshot_books_snapshot_synced_book_idx",
+          "columns": [
+            {
+              "expression": "snapshot_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "synced",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "book_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "kobo_snapshot_books_snapshot_id_kobo_library_snapshots_id_fk": {
+          "name": "kobo_snapshot_books_snapshot_id_kobo_library_snapshots_id_fk",
+          "tableFrom": "kobo_snapshot_books",
+          "tableTo": "kobo_library_snapshots",
+          "columnsFrom": ["snapshot_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "kobo_snapshot_books_book_id_books_id_fk": {
+          "name": "kobo_snapshot_books_book_id_books_id_fk",
+          "tableFrom": "kobo_snapshot_books",
+          "tableTo": "books",
+          "columnsFrom": ["book_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "kobo_snapshot_books_snapshot_id_book_id_pk": {
+          "name": "kobo_snapshot_books_snapshot_id_book_id_pk",
+          "columns": ["snapshot_id", "book_id"]
+        }
+      },
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.kobo_device_library_snapshots": {
+      "name": "kobo_device_library_snapshots",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "serial",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "device_id": {
+          "name": "device_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "kobo_device_library_snapshots_user_id_idx": {
+          "name": "kobo_device_library_snapshots_user_id_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "kobo_device_library_snapshots_user_id_users_id_fk": {
+          "name": "kobo_device_library_snapshots_user_id_users_id_fk",
+          "tableFrom": "kobo_device_library_snapshots",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "kobo_device_library_snapshots_device_owner_fk": {
+          "name": "kobo_device_library_snapshots_device_owner_fk",
+          "tableFrom": "kobo_device_library_snapshots",
+          "tableTo": "kobo_devices",
+          "columnsFrom": ["device_id", "user_id"],
+          "columnsTo": ["id", "user_id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "kobo_device_library_snapshots_device_id_unique": {
+          "name": "kobo_device_library_snapshots_device_id_unique",
+          "nullsNotDistinct": false,
+          "columns": ["device_id"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.kobo_reading_states": {
+      "name": "kobo_reading_states",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "serial",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "book_id": {
+          "name": "book_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "entitlement_id": {
+          "name": "entitlement_id",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at_kobo": {
+          "name": "created_at_kobo",
+          "type": "varchar(50)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "last_modified_kobo": {
+          "name": "last_modified_kobo",
+          "type": "varchar(50)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "priority_timestamp": {
+          "name": "priority_timestamp",
+          "type": "varchar(50)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "current_bookmark": {
+          "name": "current_bookmark",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "statistics": {
+          "name": "statistics",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "status_info": {
+          "name": "status_info",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "kobo_reading_states_book_id_idx": {
+          "name": "kobo_reading_states_book_id_idx",
+          "columns": [
+            {
+              "expression": "book_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "kobo_reading_states_user_id_users_id_fk": {
+          "name": "kobo_reading_states_user_id_users_id_fk",
+          "tableFrom": "kobo_reading_states",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "kobo_reading_states_book_id_books_id_fk": {
+          "name": "kobo_reading_states_book_id_books_id_fk",
+          "tableFrom": "kobo_reading_states",
+          "tableTo": "books",
+          "columnsFrom": ["book_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "kobo_reading_states_user_id_book_id_unique": {
+          "name": "kobo_reading_states_user_id_book_id_unique",
+          "nullsNotDistinct": false,
+          "columns": ["user_id", "book_id"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.kobo_device_snapshot_books": {
+      "name": "kobo_device_snapshot_books",
+      "schema": "",
+      "columns": {
+        "snapshot_id": {
+          "name": "snapshot_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "book_id": {
+          "name": "book_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "synced": {
+          "name": "synced",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "pending_delete": {
+          "name": "pending_delete",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "is_new": {
+          "name": "is_new",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": true
+        },
+        "removed_by_device": {
+          "name": "removed_by_device",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "needs_legacy_numeric_removal": {
+          "name": "needs_legacy_numeric_removal",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "file_hash": {
+          "name": "file_hash",
+          "type": "varchar(64)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "delivery_hash": {
+          "name": "delivery_hash",
+          "type": "varchar(64)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "metadata_hash": {
+          "name": "metadata_hash",
+          "type": "varchar(64)",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "kobo_device_snapshot_books_book_id_idx": {
+          "name": "kobo_device_snapshot_books_book_id_idx",
+          "columns": [
+            {
+              "expression": "book_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "kobo_device_snapshot_books_snapshot_synced_book_idx": {
+          "name": "kobo_device_snapshot_books_snapshot_synced_book_idx",
+          "columns": [
+            {
+              "expression": "snapshot_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "synced",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "book_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "kobo_device_snapshot_books_snapshot_id_kobo_device_library_snapshots_id_fk": {
+          "name": "kobo_device_snapshot_books_snapshot_id_kobo_device_library_snapshots_id_fk",
+          "tableFrom": "kobo_device_snapshot_books",
+          "tableTo": "kobo_device_library_snapshots",
+          "columnsFrom": ["snapshot_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "kobo_device_snapshot_books_book_id_books_id_fk": {
+          "name": "kobo_device_snapshot_books_book_id_books_id_fk",
+          "tableFrom": "kobo_device_snapshot_books",
+          "tableTo": "books",
+          "columnsFrom": ["book_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "kobo_device_snapshot_books_snapshot_id_book_id_pk": {
+          "name": "kobo_device_snapshot_books_snapshot_id_book_id_pk",
+          "columns": ["snapshot_id", "book_id"]
+        }
+      },
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.kobo_sync_history": {
+      "name": "kobo_sync_history",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "serial",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "device_id": {
+          "name": "device_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "event": {
+          "name": "event",
+          "type": "varchar(32)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "status": {
+          "name": "status",
+          "type": "varchar(16)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "counts": {
+          "name": "counts",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'{}'::jsonb"
+        },
+        "duration_ms": {
+          "name": "duration_ms",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "error_class": {
+          "name": "error_class",
+          "type": "varchar(128)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "error": {
+          "name": "error",
+          "type": "varchar(500)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "kobo_sync_history_user_created_idx": {
+          "name": "kobo_sync_history_user_created_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "kobo_sync_history_device_created_idx": {
+          "name": "kobo_sync_history_device_created_idx",
+          "columns": [
+            {
+              "expression": "device_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "kobo_sync_history_user_id_users_id_fk": {
+          "name": "kobo_sync_history_user_id_users_id_fk",
+          "tableFrom": "kobo_sync_history",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "kobo_sync_history_device_id_kobo_devices_id_fk": {
+          "name": "kobo_sync_history_device_id_kobo_devices_id_fk",
+          "tableFrom": "kobo_sync_history",
+          "tableTo": "kobo_devices",
+          "columnsFrom": ["device_id"],
+          "columnsTo": ["id"],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "kobo_sync_history_event_chk": {
+          "name": "kobo_sync_history_event_chk",
+          "value": "\"kobo_sync_history\".\"event\" in ('library_sync', 'book_download', 'progress_update', 'annotations_pull', 'annotations_push')"
+        },
+        "kobo_sync_history_status_chk": {
+          "name": "kobo_sync_history_status_chk",
+          "value": "\"kobo_sync_history\".\"status\" in ('success', 'failed')"
+        },
+        "kobo_sync_history_duration_nonnegative_chk": {
+          "name": "kobo_sync_history_duration_nonnegative_chk",
+          "value": "\"kobo_sync_history\".\"duration_ms\" >= 0"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.kobo_sync_settings": {
+      "name": "kobo_sync_settings",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "serial",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "reading_threshold": {
+          "name": "reading_threshold",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 1
+        },
+        "finished_threshold": {
+          "name": "finished_threshold",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 99
+        },
+        "convert_to_kepub": {
+          "name": "convert_to_kepub",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": true
+        },
+        "force_enable_hyphenation": {
+          "name": "force_enable_hyphenation",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "kepub_conversion_limit_mb": {
+          "name": "kepub_conversion_limit_mb",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 100
+        },
+        "two_way_progress_sync": {
+          "name": "two_way_progress_sync",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "sync_bookorbit_annotations_to_kobo": {
+          "name": "sync_bookorbit_annotations_to_kobo",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "store_sync": {
+          "name": "store_sync",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "kobo_sync_settings_user_id_users_id_fk": {
+          "name": "kobo_sync_settings_user_id_users_id_fk",
+          "tableFrom": "kobo_sync_settings",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "kobo_sync_settings_user_id_unique": {
+          "name": "kobo_sync_settings_user_id_unique",
+          "nullsNotDistinct": false,
+          "columns": ["user_id"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {
+        "kobo_sync_settings_reading_threshold_range_chk": {
+          "name": "kobo_sync_settings_reading_threshold_range_chk",
+          "value": "\"kobo_sync_settings\".\"reading_threshold\" >= 0 and \"kobo_sync_settings\".\"reading_threshold\" <= 100"
+        },
+        "kobo_sync_settings_finished_threshold_range_chk": {
+          "name": "kobo_sync_settings_finished_threshold_range_chk",
+          "value": "\"kobo_sync_settings\".\"finished_threshold\" >= 0 and \"kobo_sync_settings\".\"finished_threshold\" <= 100"
+        },
+        "kobo_sync_settings_conversion_limit_nonnegative_chk": {
+          "name": "kobo_sync_settings_conversion_limit_nonnegative_chk",
+          "value": "\"kobo_sync_settings\".\"kepub_conversion_limit_mb\" >= 0"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.book_dock_files": {
+      "name": "book_dock_files",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "serial",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "file_name": {
+          "name": "file_name",
+          "type": "varchar(500)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "absolute_path": {
+          "name": "absolute_path",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "file_size": {
+          "name": "file_size",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "format": {
+          "name": "format",
+          "type": "varchar(20)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "unit_directory": {
+          "name": "unit_directory",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "status": {
+          "name": "status",
+          "type": "varchar(20)",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'pending'"
+        },
+        "embedded_metadata": {
+          "name": "embedded_metadata",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "selected_metadata": {
+          "name": "selected_metadata",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "fetched_metadata": {
+          "name": "fetched_metadata",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "cover_path": {
+          "name": "cover_path",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "target_library_id": {
+          "name": "target_library_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "target_folder_id": {
+          "name": "target_folder_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "confidence": {
+          "name": "confidence",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "fetched_metadata_sources": {
+          "name": "fetched_metadata_sources",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "error_message": {
+          "name": "error_message",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "metadata_edited_at": {
+          "name": "metadata_edited_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "uploaded_by": {
+          "name": "uploaded_by",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "auto_finalize_suppressed": {
+          "name": "auto_finalize_suppressed",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "book_dock_files_status_idx": {
+          "name": "book_dock_files_status_idx",
+          "columns": [
+            {
+              "expression": "status",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "book_dock_files_target_library_id_idx": {
+          "name": "book_dock_files_target_library_id_idx",
+          "columns": [
+            {
+              "expression": "target_library_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "book_dock_files_uploaded_by_idx": {
+          "name": "book_dock_files_uploaded_by_idx",
+          "columns": [
+            {
+              "expression": "uploaded_by",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "book_dock_files_target_library_id_libraries_id_fk": {
+          "name": "book_dock_files_target_library_id_libraries_id_fk",
+          "tableFrom": "book_dock_files",
+          "tableTo": "libraries",
+          "columnsFrom": ["target_library_id"],
+          "columnsTo": ["id"],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "book_dock_files_target_folder_id_library_folders_id_fk": {
+          "name": "book_dock_files_target_folder_id_library_folders_id_fk",
+          "tableFrom": "book_dock_files",
+          "tableTo": "library_folders",
+          "columnsFrom": ["target_folder_id"],
+          "columnsTo": ["id"],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "book_dock_files_uploaded_by_users_id_fk": {
+          "name": "book_dock_files_uploaded_by_users_id_fk",
+          "tableFrom": "book_dock_files",
+          "tableTo": "users",
+          "columnsFrom": ["uploaded_by"],
+          "columnsTo": ["id"],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "book_dock_files_absolute_path_unique": {
+          "name": "book_dock_files_absolute_path_unique",
+          "nullsNotDistinct": false,
+          "columns": ["absolute_path"]
+        },
+        "book_dock_files_unit_directory_unique": {
+          "name": "book_dock_files_unit_directory_unique",
+          "nullsNotDistinct": false,
+          "columns": ["unit_directory"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {
+        "book_dock_files_status_chk": {
+          "name": "book_dock_files_status_chk",
+          "value": "\"book_dock_files\".\"status\" in ('pending', 'extracting', 'fetching', 'ready', 'error')"
+        },
+        "book_dock_files_confidence_range_chk": {
+          "name": "book_dock_files_confidence_range_chk",
+          "value": "\"book_dock_files\".\"confidence\" is null or (\"book_dock_files\".\"confidence\" >= 0 and \"book_dock_files\".\"confidence\" <= 100)"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.book_dock_unit_files": {
+      "name": "book_dock_unit_files",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "serial",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "dock_file_id": {
+          "name": "dock_file_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "absolute_path": {
+          "name": "absolute_path",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "file_name": {
+          "name": "file_name",
+          "type": "varchar(500)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "file_size": {
+          "name": "file_size",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "format": {
+          "name": "format",
+          "type": "varchar(20)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "role": {
+          "name": "role",
+          "type": "varchar(20)",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'content'"
+        },
+        "sort_order": {
+          "name": "sort_order",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "book_dock_unit_files_dock_file_id_sort_order_idx": {
+          "name": "book_dock_unit_files_dock_file_id_sort_order_idx",
+          "columns": [
+            {
+              "expression": "dock_file_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "sort_order",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "book_dock_unit_files_dock_file_id_book_dock_files_id_fk": {
+          "name": "book_dock_unit_files_dock_file_id_book_dock_files_id_fk",
+          "tableFrom": "book_dock_unit_files",
+          "tableTo": "book_dock_files",
+          "columnsFrom": ["dock_file_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "book_dock_unit_files_absolute_path_unique": {
+          "name": "book_dock_unit_files_absolute_path_unique",
+          "nullsNotDistinct": false,
+          "columns": ["absolute_path"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {
+        "book_dock_unit_files_role_chk": {
+          "name": "book_dock_unit_files_role_chk",
+          "value": "\"book_dock_unit_files\".\"role\" in ('content', 'cover', 'metadata', 'supplement')"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.book_request_dedupe_aliases": {
+      "name": "book_request_dedupe_aliases",
+      "schema": "",
+      "columns": {
+        "request_id": {
+          "name": "request_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "dedupe_key": {
+          "name": "dedupe_key",
+          "type": "varchar(500)",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {
+        "book_request_dedupe_aliases_key_idx": {
+          "name": "book_request_dedupe_aliases_key_idx",
+          "columns": [
+            {
+              "expression": "dedupe_key",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "book_request_dedupe_aliases_request_id_book_requests_id_fk": {
+          "name": "book_request_dedupe_aliases_request_id_book_requests_id_fk",
+          "tableFrom": "book_request_dedupe_aliases",
+          "tableTo": "book_requests",
+          "columnsFrom": ["request_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "book_request_dedupe_aliases_request_id_dedupe_key_pk": {
+          "name": "book_request_dedupe_aliases_request_id_dedupe_key_pk",
+          "columns": ["request_id", "dedupe_key"]
+        }
+      },
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.book_request_dismissals": {
+      "name": "book_request_dismissals",
+      "schema": "",
+      "columns": {
+        "request_id": {
+          "name": "request_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "book_request_dismissals_user_id_idx": {
+          "name": "book_request_dismissals_user_id_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "book_request_dismissals_request_id_book_requests_id_fk": {
+          "name": "book_request_dismissals_request_id_book_requests_id_fk",
+          "tableFrom": "book_request_dismissals",
+          "tableTo": "book_requests",
+          "columnsFrom": ["request_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "book_request_dismissals_user_id_users_id_fk": {
+          "name": "book_request_dismissals_user_id_users_id_fk",
+          "tableFrom": "book_request_dismissals",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "book_request_dismissals_request_id_user_id_pk": {
+          "name": "book_request_dismissals_request_id_user_id_pk",
+          "columns": ["request_id", "user_id"]
+        }
+      },
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.book_request_subscribers": {
+      "name": "book_request_subscribers",
+      "schema": "",
+      "columns": {
+        "request_id": {
+          "name": "request_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "book_request_subscribers_user_id_idx": {
+          "name": "book_request_subscribers_user_id_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "book_request_subscribers_request_id_book_requests_id_fk": {
+          "name": "book_request_subscribers_request_id_book_requests_id_fk",
+          "tableFrom": "book_request_subscribers",
+          "tableTo": "book_requests",
+          "columnsFrom": ["request_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "book_request_subscribers_user_id_users_id_fk": {
+          "name": "book_request_subscribers_user_id_users_id_fk",
+          "tableFrom": "book_request_subscribers",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "book_request_subscribers_request_id_user_id_pk": {
+          "name": "book_request_subscribers_request_id_user_id_pk",
+          "columns": ["request_id", "user_id"]
+        }
+      },
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.book_requests": {
+      "name": "book_requests",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "serial",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "media_kind": {
+          "name": "media_kind",
+          "type": "book_request_media_kind",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "status": {
+          "name": "status",
+          "type": "varchar(20)",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'pending'"
+        },
+        "title": {
+          "name": "title",
+          "type": "varchar(500)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "subtitle": {
+          "name": "subtitle",
+          "type": "varchar(500)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "authors": {
+          "name": "authors",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'[]'::jsonb"
+        },
+        "series_name": {
+          "name": "series_name",
+          "type": "varchar(500)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "series_index": {
+          "name": "series_index",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "isbn10": {
+          "name": "isbn10",
+          "type": "varchar(20)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "isbn13": {
+          "name": "isbn13",
+          "type": "varchar(20)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "published_year": {
+          "name": "published_year",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "language": {
+          "name": "language",
+          "type": "varchar(20)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "cover_url": {
+          "name": "cover_url",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "provider_key": {
+          "name": "provider_key",
+          "type": "varchar(50)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "provider_id": {
+          "name": "provider_id",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "metadata_sources": {
+          "name": "metadata_sources",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'[]'::jsonb"
+        },
+        "preferred_formats": {
+          "name": "preferred_formats",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'[]'::jsonb"
+        },
+        "note": {
+          "name": "note",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "target_library_id": {
+          "name": "target_library_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "target_folder_id": {
+          "name": "target_folder_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_by_user_id": {
+          "name": "created_by_user_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "decided_by_user_id": {
+          "name": "decided_by_user_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "decided_at": {
+          "name": "decided_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "decision_note": {
+          "name": "decision_note",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "matched_book_id": {
+          "name": "matched_book_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "book_dock_file_id": {
+          "name": "book_dock_file_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "status_reason": {
+          "name": "status_reason",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "failure_code": {
+          "name": "failure_code",
+          "type": "varchar(50)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "failure_meta": {
+          "name": "failure_meta",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "self_serve": {
+          "name": "self_serve",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "fulfiller_user_id": {
+          "name": "fulfiller_user_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "dedupe_key": {
+          "name": "dedupe_key",
+          "type": "varchar(500)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "book_requests_user_status_idx": {
+          "name": "book_requests_user_status_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "status",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "book_requests_status_created_at_idx": {
+          "name": "book_requests_status_created_at_idx",
+          "columns": [
+            {
+              "expression": "status",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "book_requests_target_library_id_idx": {
+          "name": "book_requests_target_library_id_idx",
+          "columns": [
+            {
+              "expression": "target_library_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "book_requests_created_at_idx": {
+          "name": "book_requests_created_at_idx",
+          "columns": [
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "book_requests_title_idx": {
+          "name": "book_requests_title_idx",
+          "columns": [
+            {
+              "expression": "title",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "book_requests_matched_book_user_idx": {
+          "name": "book_requests_matched_book_user_idx",
+          "columns": [
+            {
+              "expression": "matched_book_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "where": "\"book_requests\".\"matched_book_id\" is not null",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "book_requests_self_serve_idx": {
+          "name": "book_requests_self_serve_idx",
+          "columns": [
+            {
+              "expression": "self_serve",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "status",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "where": "\"book_requests\".\"self_serve\"",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "book_requests_active_dedupe_key_uidx": {
+          "name": "book_requests_active_dedupe_key_uidx",
+          "columns": [
+            {
+              "expression": "dedupe_key",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "where": "\"book_requests\".\"status\" in ('pending', 'approved', 'searching', 'grabbed', 'downloading', 'importing', 'needs_review')",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "book_requests_user_id_users_id_fk": {
+          "name": "book_requests_user_id_users_id_fk",
+          "tableFrom": "book_requests",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "book_requests_target_library_id_libraries_id_fk": {
+          "name": "book_requests_target_library_id_libraries_id_fk",
+          "tableFrom": "book_requests",
+          "tableTo": "libraries",
+          "columnsFrom": ["target_library_id"],
+          "columnsTo": ["id"],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "book_requests_target_folder_id_library_folders_id_fk": {
+          "name": "book_requests_target_folder_id_library_folders_id_fk",
+          "tableFrom": "book_requests",
+          "tableTo": "library_folders",
+          "columnsFrom": ["target_folder_id"],
+          "columnsTo": ["id"],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "book_requests_created_by_user_id_users_id_fk": {
+          "name": "book_requests_created_by_user_id_users_id_fk",
+          "tableFrom": "book_requests",
+          "tableTo": "users",
+          "columnsFrom": ["created_by_user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "book_requests_decided_by_user_id_users_id_fk": {
+          "name": "book_requests_decided_by_user_id_users_id_fk",
+          "tableFrom": "book_requests",
+          "tableTo": "users",
+          "columnsFrom": ["decided_by_user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "book_requests_matched_book_id_books_id_fk": {
+          "name": "book_requests_matched_book_id_books_id_fk",
+          "tableFrom": "book_requests",
+          "tableTo": "books",
+          "columnsFrom": ["matched_book_id"],
+          "columnsTo": ["id"],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "book_requests_book_dock_file_id_book_dock_files_id_fk": {
+          "name": "book_requests_book_dock_file_id_book_dock_files_id_fk",
+          "tableFrom": "book_requests",
+          "tableTo": "book_dock_files",
+          "columnsFrom": ["book_dock_file_id"],
+          "columnsTo": ["id"],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "book_requests_fulfiller_user_id_users_id_fk": {
+          "name": "book_requests_fulfiller_user_id_users_id_fk",
+          "tableFrom": "book_requests",
+          "tableTo": "users",
+          "columnsFrom": ["fulfiller_user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "book_requests_status_chk": {
+          "name": "book_requests_status_chk",
+          "value": "\"book_requests\".\"status\" in ('pending', 'approved', 'rejected', 'cancelled', 'searching', 'grabbed', 'downloading', 'importing', 'needs_review', 'available', 'failed')"
+        },
+        "book_requests_series_index_nonnegative_chk": {
+          "name": "book_requests_series_index_nonnegative_chk",
+          "value": "\"book_requests\".\"series_index\" is null or \"book_requests\".\"series_index\" >= 0"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.book_request_downloads": {
+      "name": "book_request_downloads",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "serial",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "request_id": {
+          "name": "request_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "download_client_id": {
+          "name": "download_client_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "indexer_id": {
+          "name": "indexer_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "source": {
+          "name": "source",
+          "type": "varchar(20)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "automated": {
+          "name": "automated",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "release_title": {
+          "name": "release_title",
+          "type": "varchar(500)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "release_guid": {
+          "name": "release_guid",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "release_size_bytes": {
+          "name": "release_size_bytes",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "release_seeders": {
+          "name": "release_seeders",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "release_format": {
+          "name": "release_format",
+          "type": "varchar(20)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "freeleech": {
+          "name": "freeleech",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "client_key": {
+          "name": "client_key",
+          "type": "varchar(64)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "status": {
+          "name": "status",
+          "type": "varchar(20)",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'queued'"
+        },
+        "progress_percent": {
+          "name": "progress_percent",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "downloaded_bytes": {
+          "name": "downloaded_bytes",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "total_bytes": {
+          "name": "total_bytes",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "direct_url": {
+          "name": "direct_url",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "direct_file_name": {
+          "name": "direct_file_name",
+          "type": "varchar(500)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "direct_etag": {
+          "name": "direct_etag",
+          "type": "varchar(1024)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "direct_last_modified": {
+          "name": "direct_last_modified",
+          "type": "varchar(200)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "content_path": {
+          "name": "content_path",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "local_path": {
+          "name": "local_path",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "book_dock_file_id": {
+          "name": "book_dock_file_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "release_units": {
+          "name": "release_units",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "error_message": {
+          "name": "error_message",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "grabbed_at": {
+          "name": "grabbed_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "last_progress_at": {
+          "name": "last_progress_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "completed_at": {
+          "name": "completed_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "imported_at": {
+          "name": "imported_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "book_request_downloads_status_idx": {
+          "name": "book_request_downloads_status_idx",
+          "columns": [
+            {
+              "expression": "status",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "book_request_downloads_request_latest_idx": {
+          "name": "book_request_downloads_request_latest_idx",
+          "columns": [
+            {
+              "expression": "request_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "id",
+              "isExpression": false,
+              "asc": false,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "book_request_downloads_book_dock_file_id_idx": {
+          "name": "book_request_downloads_book_dock_file_id_idx",
+          "columns": [
+            {
+              "expression": "book_dock_file_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "book_request_downloads_active_hash_uidx": {
+          "name": "book_request_downloads_active_hash_uidx",
+          "columns": [
+            {
+              "expression": "coalesce(\"download_client_id\", 0)",
+              "asc": true,
+              "isExpression": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "client_key",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "where": "\"book_request_downloads\".\"status\" in ('queued', 'downloading', 'completed', 'importing', 'needs_review')",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "book_request_downloads_request_id_book_requests_id_fk": {
+          "name": "book_request_downloads_request_id_book_requests_id_fk",
+          "tableFrom": "book_request_downloads",
+          "tableTo": "book_requests",
+          "columnsFrom": ["request_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "book_request_downloads_download_client_id_download_clients_id_fk": {
+          "name": "book_request_downloads_download_client_id_download_clients_id_fk",
+          "tableFrom": "book_request_downloads",
+          "tableTo": "download_clients",
+          "columnsFrom": ["download_client_id"],
+          "columnsTo": ["id"],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "book_request_downloads_indexer_id_request_indexers_id_fk": {
+          "name": "book_request_downloads_indexer_id_request_indexers_id_fk",
+          "tableFrom": "book_request_downloads",
+          "tableTo": "request_indexers",
+          "columnsFrom": ["indexer_id"],
+          "columnsTo": ["id"],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "book_request_downloads_book_dock_file_id_book_dock_files_id_fk": {
+          "name": "book_request_downloads_book_dock_file_id_book_dock_files_id_fk",
+          "tableFrom": "book_request_downloads",
+          "tableTo": "book_dock_files",
+          "columnsFrom": ["book_dock_file_id"],
+          "columnsTo": ["id"],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "book_request_downloads_source_chk": {
+          "name": "book_request_downloads_source_chk",
+          "value": "\"book_request_downloads\".\"source\" in ('magnet', 'torrent_file', 'direct_url', 'nzb_file')"
+        },
+        "book_request_downloads_status_chk": {
+          "name": "book_request_downloads_status_chk",
+          "value": "\"book_request_downloads\".\"status\" in ('queued', 'downloading', 'completed', 'importing', 'needs_review', 'imported', 'failed')"
+        },
+        "book_request_downloads_progress_range_chk": {
+          "name": "book_request_downloads_progress_range_chk",
+          "value": "\"book_request_downloads\".\"progress_percent\" >= 0 and \"book_request_downloads\".\"progress_percent\" <= 100"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.download_client_path_mappings": {
+      "name": "download_client_path_mappings",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "serial",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "download_client_id": {
+          "name": "download_client_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "remote_path": {
+          "name": "remote_path",
+          "type": "varchar(4096)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "local_path": {
+          "name": "local_path",
+          "type": "varchar(4096)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "download_client_path_mappings_client_remote_uidx": {
+          "name": "download_client_path_mappings_client_remote_uidx",
+          "columns": [
+            {
+              "expression": "download_client_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "remote_path",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "download_client_path_mappings_download_client_id_download_clients_id_fk": {
+          "name": "download_client_path_mappings_download_client_id_download_clients_id_fk",
+          "tableFrom": "download_client_path_mappings",
+          "tableTo": "download_clients",
+          "columnsFrom": ["download_client_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.download_clients": {
+      "name": "download_clients",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "serial",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "name": {
+          "name": "name",
+          "type": "varchar(100)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "color": {
+          "name": "color",
+          "type": "varchar(16)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "adapter_type": {
+          "name": "adapter_type",
+          "type": "varchar(30)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "enabled": {
+          "name": "enabled",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": true
+        },
+        "priority": {
+          "name": "priority",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 1
+        },
+        "base_url": {
+          "name": "base_url",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "username": {
+          "name": "username",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "credentials_enc": {
+          "name": "credentials_enc",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "category": {
+          "name": "category",
+          "type": "varchar(100)",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'bookorbit'"
+        },
+        "use_hardlinks": {
+          "name": "use_hardlinks",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": true
+        },
+        "allow_private_address": {
+          "name": "allow_private_address",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": true
+        },
+        "settings": {
+          "name": "settings",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "last_tested_at": {
+          "name": "last_tested_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "last_test_ok": {
+          "name": "last_test_ok",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "last_error_message": {
+          "name": "last_error_message",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "download_clients_name_lower_uidx": {
+          "name": "download_clients_name_lower_uidx",
+          "columns": [
+            {
+              "expression": "lower(\"name\")",
+              "asc": true,
+              "isExpression": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "download_clients_enabled_priority_idx": {
+          "name": "download_clients_enabled_priority_idx",
+          "columns": [
+            {
+              "expression": "enabled",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "priority",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "download_clients_adapter_type_chk": {
+          "name": "download_clients_adapter_type_chk",
+          "value": "\"download_clients\".\"adapter_type\" in ('qbittorrent', 'transmission', 'deluge', 'nzbget', 'sabnzbd')"
+        },
+        "download_clients_priority_range_chk": {
+          "name": "download_clients_priority_range_chk",
+          "value": "\"download_clients\".\"priority\" >= 1 and \"download_clients\".\"priority\" <= 100"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.request_indexers": {
+      "name": "request_indexers",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "serial",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "name": {
+          "name": "name",
+          "type": "varchar(100)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "color": {
+          "name": "color",
+          "type": "varchar(16)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "adapter_type": {
+          "name": "adapter_type",
+          "type": "varchar(30)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "manager_id": {
+          "name": "manager_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "manager_external_id": {
+          "name": "manager_external_id",
+          "type": "varchar(100)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "manager_available": {
+          "name": "manager_available",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": true
+        },
+        "manager_last_seen_at": {
+          "name": "manager_last_seen_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "manager_metadata": {
+          "name": "manager_metadata",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "enabled": {
+          "name": "enabled",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": true
+        },
+        "base_url": {
+          "name": "base_url",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "credentials_enc": {
+          "name": "credentials_enc",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "allow_private_address": {
+          "name": "allow_private_address",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "apply_tracker_seed_goals": {
+          "name": "apply_tracker_seed_goals",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": true
+        },
+        "seed_ratio_goal": {
+          "name": "seed_ratio_goal",
+          "type": "double precision",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "seed_time_minutes": {
+          "name": "seed_time_minutes",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "categories": {
+          "name": "categories",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "disabled_media_kinds": {
+          "name": "disabled_media_kinds",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'[]'::jsonb"
+        },
+        "isbn_search_disabled": {
+          "name": "isbn_search_disabled",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "settings": {
+          "name": "settings",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "network_profile": {
+          "name": "network_profile",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "last_tested_at": {
+          "name": "last_tested_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "last_test_ok": {
+          "name": "last_test_ok",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "last_error_message": {
+          "name": "last_error_message",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "last_search_at": {
+          "name": "last_search_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "last_search_ok": {
+          "name": "last_search_ok",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "last_search_error": {
+          "name": "last_search_error",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "search_failure_streak": {
+          "name": "search_failure_streak",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "request_indexers_name_lower_uidx": {
+          "name": "request_indexers_name_lower_uidx",
+          "columns": [
+            {
+              "expression": "lower(\"name\")",
+              "asc": true,
+              "isExpression": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "request_indexers_manager_external_uidx": {
+          "name": "request_indexers_manager_external_uidx",
+          "columns": [
+            {
+              "expression": "manager_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "manager_external_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "request_indexers_enabled_idx": {
+          "name": "request_indexers_enabled_idx",
+          "columns": [
+            {
+              "expression": "enabled",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "request_indexers_manager_idx": {
+          "name": "request_indexers_manager_idx",
+          "columns": [
+            {
+              "expression": "manager_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "request_indexers_manager_id_request_indexer_managers_id_fk": {
+          "name": "request_indexers_manager_id_request_indexer_managers_id_fk",
+          "tableFrom": "request_indexers",
+          "tableTo": "request_indexer_managers",
+          "columnsFrom": ["manager_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "request_indexers_adapter_type_chk": {
+          "name": "request_indexers_adapter_type_chk",
+          "value": "\"request_indexers\".\"adapter_type\" ~ '^[a-z0-9][a-z0-9-]{0,29}$'"
+        },
+        "request_indexers_manager_fields_chk": {
+          "name": "request_indexers_manager_fields_chk",
+          "value": "(\"request_indexers\".\"manager_id\" is null and \"request_indexers\".\"manager_external_id\" is null and \"request_indexers\".\"manager_metadata\" is null) or (\"request_indexers\".\"manager_id\" is not null and \"request_indexers\".\"manager_external_id\" is not null and \"request_indexers\".\"manager_metadata\" is not null and \"request_indexers\".\"credentials_enc\" is null and \"request_indexers\".\"adapter_type\" in ('torznab', 'newznab'))"
+        },
+        "request_indexers_seed_ratio_goal_chk": {
+          "name": "request_indexers_seed_ratio_goal_chk",
+          "value": "\"request_indexers\".\"seed_ratio_goal\" is null or (\"request_indexers\".\"seed_ratio_goal\" > 0 and \"request_indexers\".\"seed_ratio_goal\" < 'Infinity'::double precision)"
+        },
+        "request_indexers_seed_time_minutes_chk": {
+          "name": "request_indexers_seed_time_minutes_chk",
+          "value": "\"request_indexers\".\"seed_time_minutes\" is null or \"request_indexers\".\"seed_time_minutes\" > 0"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.request_indexer_managers": {
+      "name": "request_indexer_managers",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "serial",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "name": {
+          "name": "name",
+          "type": "varchar(100)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "color": {
+          "name": "color",
+          "type": "varchar(16)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "type": {
+          "name": "type",
+          "type": "varchar(30)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "enabled": {
+          "name": "enabled",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": true
+        },
+        "base_url": {
+          "name": "base_url",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "credentials_enc": {
+          "name": "credentials_enc",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "allow_private_address": {
+          "name": "allow_private_address",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "sync_new_indexers": {
+          "name": "sync_new_indexers",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": true
+        },
+        "per_indexer_timeout_seconds": {
+          "name": "per_indexer_timeout_seconds",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 20
+        },
+        "overall_search_budget_seconds": {
+          "name": "overall_search_budget_seconds",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 60
+        },
+        "auto_expand_categories": {
+          "name": "auto_expand_categories",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "inherit_seed_limits": {
+          "name": "inherit_seed_limits",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": true
+        },
+        "network_profile": {
+          "name": "network_profile",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "version": {
+          "name": "version",
+          "type": "varchar(100)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "last_tested_at": {
+          "name": "last_tested_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "last_test_ok": {
+          "name": "last_test_ok",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "last_error_message": {
+          "name": "last_error_message",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "last_synced_at": {
+          "name": "last_synced_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "last_sync_ok": {
+          "name": "last_sync_ok",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "last_sync_error": {
+          "name": "last_sync_error",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "request_indexer_managers_name_lower_uidx": {
+          "name": "request_indexer_managers_name_lower_uidx",
+          "columns": [
+            {
+              "expression": "lower(\"name\")",
+              "asc": true,
+              "isExpression": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "request_indexer_managers_type_chk": {
+          "name": "request_indexer_managers_type_chk",
+          "value": "\"request_indexer_managers\".\"type\" in ('prowlarr')"
+        },
+        "request_indexer_managers_timeout_chk": {
+          "name": "request_indexer_managers_timeout_chk",
+          "value": "\"request_indexer_managers\".\"per_indexer_timeout_seconds\" between 5 and 180"
+        },
+        "request_indexer_managers_budget_chk": {
+          "name": "request_indexer_managers_budget_chk",
+          "value": "\"request_indexer_managers\".\"overall_search_budget_seconds\" between 5 and 300"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.file_write_log": {
+      "name": "file_write_log",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "serial",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "book_id": {
+          "name": "book_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "book_file_id": {
+          "name": "book_file_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "format": {
+          "name": "format",
+          "type": "varchar(20)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "status": {
+          "name": "status",
+          "type": "varchar(10)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "fields_written": {
+          "name": "fields_written",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "error_message": {
+          "name": "error_message",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "duration_ms": {
+          "name": "duration_ms",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "triggered_by": {
+          "name": "triggered_by",
+          "type": "varchar(10)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "written_at": {
+          "name": "written_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "fwl_book_id_written_at_idx": {
+          "name": "fwl_book_id_written_at_idx",
+          "columns": [
+            {
+              "expression": "book_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "written_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "file_write_log_book_file_id_idx": {
+          "name": "file_write_log_book_file_id_idx",
+          "columns": [
+            {
+              "expression": "book_file_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "file_write_log_book_id_books_id_fk": {
+          "name": "file_write_log_book_id_books_id_fk",
+          "tableFrom": "file_write_log",
+          "tableTo": "books",
+          "columnsFrom": ["book_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "file_write_log_book_file_id_book_files_id_fk": {
+          "name": "file_write_log_book_file_id_book_files_id_fk",
+          "tableFrom": "file_write_log",
+          "tableTo": "book_files",
+          "columnsFrom": ["book_file_id"],
+          "columnsTo": ["id"],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "file_write_log_user_id_users_id_fk": {
+          "name": "file_write_log_user_id_users_id_fk",
+          "tableFrom": "file_write_log",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "file_write_log_status_chk": {
+          "name": "file_write_log_status_chk",
+          "value": "\"file_write_log\".\"status\" in ('success', 'skipped', 'failed')"
+        },
+        "file_write_log_triggered_by_chk": {
+          "name": "file_write_log_triggered_by_chk",
+          "value": "\"file_write_log\".\"triggered_by\" in ('auto', 'sync')"
+        },
+        "file_write_log_duration_ms_nonnegative_chk": {
+          "name": "file_write_log_duration_ms_nonnegative_chk",
+          "value": "\"file_write_log\".\"duration_ms\" is null or \"file_write_log\".\"duration_ms\" >= 0"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.email_templates": {
+      "name": "email_templates",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "serial",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "name": {
+          "name": "name",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "subject": {
+          "name": "subject",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "body_text": {
+          "name": "body_text",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "is_default": {
+          "name": "is_default",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "is_system": {
+          "name": "is_system",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "email_templates_one_default_per_user_uidx": {
+          "name": "email_templates_one_default_per_user_uidx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "where": "\"email_templates\".\"is_default\" = true and \"email_templates\".\"user_id\" is not null",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "email_templates_system_name_unique": {
+          "name": "email_templates_system_name_unique",
+          "columns": [
+            {
+              "expression": "name",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "where": "\"email_templates\".\"user_id\" is null",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "email_templates_user_id_users_id_fk": {
+          "name": "email_templates_user_id_users_id_fk",
+          "tableFrom": "email_templates",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "email_templates_user_id_name_unique": {
+          "name": "email_templates_user_id_name_unique",
+          "nullsNotDistinct": false,
+          "columns": ["user_id", "name"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.email_providers": {
+      "name": "email_providers",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "serial",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "name": {
+          "name": "name",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "host": {
+          "name": "host",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "port": {
+          "name": "port",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "username": {
+          "name": "username",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "password_enc": {
+          "name": "password_enc",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "from_name": {
+          "name": "from_name",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "from_address": {
+          "name": "from_address",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "auth": {
+          "name": "auth",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": true
+        },
+        "ssl": {
+          "name": "ssl",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "start_tls": {
+          "name": "start_tls",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": true
+        },
+        "is_default": {
+          "name": "is_default",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "is_shared": {
+          "name": "is_shared",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "is_system_provider": {
+          "name": "is_system_provider",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "tls_reject_unauthorized": {
+          "name": "tls_reject_unauthorized",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "email_providers_one_default_per_user_uidx": {
+          "name": "email_providers_one_default_per_user_uidx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "where": "\"email_providers\".\"is_default\" = true and \"email_providers\".\"user_id\" is not null",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "email_providers_one_system_provider_uidx": {
+          "name": "email_providers_one_system_provider_uidx",
+          "columns": [
+            {
+              "expression": "is_system_provider",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "where": "\"email_providers\".\"is_system_provider\" = true",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "email_providers_user_id_users_id_fk": {
+          "name": "email_providers_user_id_users_id_fk",
+          "tableFrom": "email_providers",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "email_providers_user_id_name_unique": {
+          "name": "email_providers_user_id_name_unique",
+          "nullsNotDistinct": false,
+          "columns": ["user_id", "name"]
+        },
+        "email_providers_id_user_id_unique": {
+          "name": "email_providers_id_user_id_unique",
+          "nullsNotDistinct": false,
+          "columns": ["id", "user_id"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {
+        "email_providers_port_range_chk": {
+          "name": "email_providers_port_range_chk",
+          "value": "\"email_providers\".\"port\" >= 1 and \"email_providers\".\"port\" <= 65535"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.email_recipient_group_members": {
+      "name": "email_recipient_group_members",
+      "schema": "",
+      "columns": {
+        "user_id": {
+          "name": "user_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "group_id": {
+          "name": "group_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "recipient_id": {
+          "name": "recipient_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "email_recipient_group_members_user_id_users_id_fk": {
+          "name": "email_recipient_group_members_user_id_users_id_fk",
+          "tableFrom": "email_recipient_group_members",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "email_recipient_group_members_group_id_email_recipient_groups_id_fk": {
+          "name": "email_recipient_group_members_group_id_email_recipient_groups_id_fk",
+          "tableFrom": "email_recipient_group_members",
+          "tableTo": "email_recipient_groups",
+          "columnsFrom": ["group_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "email_recipient_group_members_recipient_id_email_recipients_id_fk": {
+          "name": "email_recipient_group_members_recipient_id_email_recipients_id_fk",
+          "tableFrom": "email_recipient_group_members",
+          "tableTo": "email_recipients",
+          "columnsFrom": ["recipient_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "email_recipient_group_members_group_user_fk": {
+          "name": "email_recipient_group_members_group_user_fk",
+          "tableFrom": "email_recipient_group_members",
+          "tableTo": "email_recipient_groups",
+          "columnsFrom": ["group_id", "user_id"],
+          "columnsTo": ["id", "user_id"],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        },
+        "email_recipient_group_members_recipient_user_fk": {
+          "name": "email_recipient_group_members_recipient_user_fk",
+          "tableFrom": "email_recipient_group_members",
+          "tableTo": "email_recipients",
+          "columnsFrom": ["recipient_id", "user_id"],
+          "columnsTo": ["id", "user_id"],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "email_recipient_group_members_group_id_recipient_id_pk": {
+          "name": "email_recipient_group_members_group_id_recipient_id_pk",
+          "columns": ["group_id", "recipient_id"]
+        }
+      },
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.email_recipient_groups": {
+      "name": "email_recipient_groups",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "serial",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "name": {
+          "name": "name",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "default_template_id": {
+          "name": "default_template_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "email_recipient_groups_user_id_users_id_fk": {
+          "name": "email_recipient_groups_user_id_users_id_fk",
+          "tableFrom": "email_recipient_groups",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "email_recipient_groups_default_template_id_email_templates_id_fk": {
+          "name": "email_recipient_groups_default_template_id_email_templates_id_fk",
+          "tableFrom": "email_recipient_groups",
+          "tableTo": "email_templates",
+          "columnsFrom": ["default_template_id"],
+          "columnsTo": ["id"],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "email_recipient_groups_user_id_name_unique": {
+          "name": "email_recipient_groups_user_id_name_unique",
+          "nullsNotDistinct": false,
+          "columns": ["user_id", "name"]
+        },
+        "email_recipient_groups_id_user_id_unique": {
+          "name": "email_recipient_groups_id_user_id_unique",
+          "nullsNotDistinct": false,
+          "columns": ["id", "user_id"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.email_recipients": {
+      "name": "email_recipients",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "serial",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "name": {
+          "name": "name",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "email": {
+          "name": "email",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "is_default": {
+          "name": "is_default",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "device_type": {
+          "name": "device_type",
+          "type": "varchar(20)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "preferred_format": {
+          "name": "preferred_format",
+          "type": "varchar(20)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "default_template_id": {
+          "name": "default_template_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "email_recipients_user_email_lower_uidx": {
+          "name": "email_recipients_user_email_lower_uidx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "lower(\"email\")",
+              "asc": true,
+              "isExpression": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "email_recipients_one_default_per_user_uidx": {
+          "name": "email_recipients_one_default_per_user_uidx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "where": "\"email_recipients\".\"is_default\" = true",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "email_recipients_user_id_users_id_fk": {
+          "name": "email_recipients_user_id_users_id_fk",
+          "tableFrom": "email_recipients",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "email_recipients_default_template_id_email_templates_id_fk": {
+          "name": "email_recipients_default_template_id_email_templates_id_fk",
+          "tableFrom": "email_recipients",
+          "tableTo": "email_templates",
+          "columnsFrom": ["default_template_id"],
+          "columnsTo": ["id"],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "email_recipients_user_id_email_unique": {
+          "name": "email_recipients_user_id_email_unique",
+          "nullsNotDistinct": false,
+          "columns": ["user_id", "email"]
+        },
+        "email_recipients_id_user_id_unique": {
+          "name": "email_recipients_id_user_id_unique",
+          "nullsNotDistinct": false,
+          "columns": ["id", "user_id"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {
+        "email_recipients_device_type_chk": {
+          "name": "email_recipients_device_type_chk",
+          "value": "\"email_recipients\".\"device_type\" is null or \"email_recipients\".\"device_type\" in ('kindle', 'kobo', 'other')"
+        },
+        "email_recipients_preferred_format_chk": {
+          "name": "email_recipients_preferred_format_chk",
+          "value": "\"email_recipients\".\"preferred_format\" is null or \"email_recipients\".\"preferred_format\" in ('epub', 'pdf', 'mobi', 'azw3', 'cbz', 'cbr')"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.email_preferences": {
+      "name": "email_preferences",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "serial",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "default_provider_id": {
+          "name": "default_provider_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "default_recipient_id": {
+          "name": "default_recipient_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "default_template_id": {
+          "name": "default_template_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "email_preferences_user_id_users_id_fk": {
+          "name": "email_preferences_user_id_users_id_fk",
+          "tableFrom": "email_preferences",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "email_preferences_default_provider_id_email_providers_id_fk": {
+          "name": "email_preferences_default_provider_id_email_providers_id_fk",
+          "tableFrom": "email_preferences",
+          "tableTo": "email_providers",
+          "columnsFrom": ["default_provider_id"],
+          "columnsTo": ["id"],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "email_preferences_default_recipient_id_email_recipients_id_fk": {
+          "name": "email_preferences_default_recipient_id_email_recipients_id_fk",
+          "tableFrom": "email_preferences",
+          "tableTo": "email_recipients",
+          "columnsFrom": ["default_recipient_id"],
+          "columnsTo": ["id"],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "email_preferences_default_template_id_email_templates_id_fk": {
+          "name": "email_preferences_default_template_id_email_templates_id_fk",
+          "tableFrom": "email_preferences",
+          "tableTo": "email_templates",
+          "columnsFrom": ["default_template_id"],
+          "columnsTo": ["id"],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "email_preferences_default_recipient_owner_fk": {
+          "name": "email_preferences_default_recipient_owner_fk",
+          "tableFrom": "email_preferences",
+          "tableTo": "email_recipients",
+          "columnsFrom": ["default_recipient_id", "user_id"],
+          "columnsTo": ["id", "user_id"],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "email_preferences_user_id_unique": {
+          "name": "email_preferences_user_id_unique",
+          "nullsNotDistinct": false,
+          "columns": ["user_id"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.email_send_log": {
+      "name": "email_send_log",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "serial",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "book_id": {
+          "name": "book_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "book_file_id": {
+          "name": "book_file_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "provider_id": {
+          "name": "provider_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "template_id": {
+          "name": "template_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "to_email": {
+          "name": "to_email",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "to_name": {
+          "name": "to_name",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "subject": {
+          "name": "subject",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "status": {
+          "name": "status",
+          "type": "varchar(20)",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'pending'"
+        },
+        "attempt_count": {
+          "name": "attempt_count",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "next_retry_at": {
+          "name": "next_retry_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "error_message": {
+          "name": "error_message",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "sent_at": {
+          "name": "sent_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "email_send_log_user_created_at_idx": {
+          "name": "email_send_log_user_created_at_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "email_send_log_book_id_idx": {
+          "name": "email_send_log_book_id_idx",
+          "columns": [
+            {
+              "expression": "book_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "email_send_log_book_file_id_idx": {
+          "name": "email_send_log_book_file_id_idx",
+          "columns": [
+            {
+              "expression": "book_file_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "email_send_log_created_at_idx": {
+          "name": "email_send_log_created_at_idx",
+          "columns": [
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "email_send_log_status_next_retry_idx": {
+          "name": "email_send_log_status_next_retry_idx",
+          "columns": [
+            {
+              "expression": "status",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "next_retry_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "email_send_log_user_id_users_id_fk": {
+          "name": "email_send_log_user_id_users_id_fk",
+          "tableFrom": "email_send_log",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "email_send_log_book_id_books_id_fk": {
+          "name": "email_send_log_book_id_books_id_fk",
+          "tableFrom": "email_send_log",
+          "tableTo": "books",
+          "columnsFrom": ["book_id"],
+          "columnsTo": ["id"],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "email_send_log_book_file_id_book_files_id_fk": {
+          "name": "email_send_log_book_file_id_book_files_id_fk",
+          "tableFrom": "email_send_log",
+          "tableTo": "book_files",
+          "columnsFrom": ["book_file_id"],
+          "columnsTo": ["id"],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "email_send_log_provider_id_email_providers_id_fk": {
+          "name": "email_send_log_provider_id_email_providers_id_fk",
+          "tableFrom": "email_send_log",
+          "tableTo": "email_providers",
+          "columnsFrom": ["provider_id"],
+          "columnsTo": ["id"],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "email_send_log_template_id_email_templates_id_fk": {
+          "name": "email_send_log_template_id_email_templates_id_fk",
+          "tableFrom": "email_send_log",
+          "tableTo": "email_templates",
+          "columnsFrom": ["template_id"],
+          "columnsTo": ["id"],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "email_send_log_status_chk": {
+          "name": "email_send_log_status_chk",
+          "value": "\"email_send_log\".\"status\" in ('pending', 'sent', 'failed')"
+        },
+        "email_send_log_attempt_count_nonnegative_chk": {
+          "name": "email_send_log_attempt_count_nonnegative_chk",
+          "value": "\"email_send_log\".\"attempt_count\" >= 0"
+        },
+        "email_send_log_sent_after_created_chk": {
+          "name": "email_send_log_sent_after_created_chk",
+          "value": "\"email_send_log\".\"sent_at\" is null or \"email_send_log\".\"sent_at\" >= \"email_send_log\".\"created_at\""
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.notifications": {
+      "name": "notifications",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "serial",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "type": {
+          "name": "type",
+          "type": "varchar(50)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "title": {
+          "name": "title",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "message": {
+          "name": "message",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "action_url": {
+          "name": "action_url",
+          "type": "varchar(2048)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "meta": {
+          "name": "meta",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "read": {
+          "name": "read",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "group_key": {
+          "name": "group_key",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "count": {
+          "name": "count",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 1
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "notifications_user_id_idx": {
+          "name": "notifications_user_id_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "notifications_user_unread_idx": {
+          "name": "notifications_user_unread_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "read",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "notifications_created_at_idx": {
+          "name": "notifications_created_at_idx",
+          "columns": [
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "notifications_user_updated_at_idx": {
+          "name": "notifications_user_updated_at_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "updated_at",
+              "isExpression": false,
+              "asc": false,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "notifications_updated_at_idx": {
+          "name": "notifications_updated_at_idx",
+          "columns": [
+            {
+              "expression": "updated_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "notifications_user_unread_group_key_idx": {
+          "name": "notifications_user_unread_group_key_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "group_key",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "where": "\"notifications\".\"read\" = false and \"notifications\".\"group_key\" is not null",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "notifications_user_id_users_id_fk": {
+          "name": "notifications_user_id_users_id_fk",
+          "tableFrom": "notifications",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.dismissed_duplicate_pairs": {
+      "name": "dismissed_duplicate_pairs",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "serial",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "entity_type": {
+          "name": "entity_type",
+          "type": "varchar(50)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "entity_id_a": {
+          "name": "entity_id_a",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "entity_id_b": {
+          "name": "entity_id_b",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "reason": {
+          "name": "reason",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "dismissed_by": {
+          "name": "dismissed_by",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "dismissed_at": {
+          "name": "dismissed_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "dismissed_duplicate_pairs_entity_a_idx": {
+          "name": "dismissed_duplicate_pairs_entity_a_idx",
+          "columns": [
+            {
+              "expression": "entity_type",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "entity_id_a",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "dismissed_duplicate_pairs_entity_b_idx": {
+          "name": "dismissed_duplicate_pairs_entity_b_idx",
+          "columns": [
+            {
+              "expression": "entity_type",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "entity_id_b",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "dismissed_duplicate_pairs_dismissed_by_users_id_fk": {
+          "name": "dismissed_duplicate_pairs_dismissed_by_users_id_fk",
+          "tableFrom": "dismissed_duplicate_pairs",
+          "tableTo": "users",
+          "columnsFrom": ["dismissed_by"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "dismissed_duplicate_pairs_unique": {
+          "name": "dismissed_duplicate_pairs_unique",
+          "nullsNotDistinct": false,
+          "columns": ["entity_type", "entity_id_a", "entity_id_b"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.dismissed_inline_duplicate_pairs": {
+      "name": "dismissed_inline_duplicate_pairs",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "serial",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "entity_type": {
+          "name": "entity_type",
+          "type": "varchar(50)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "value_a": {
+          "name": "value_a",
+          "type": "varchar(500)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "value_b": {
+          "name": "value_b",
+          "type": "varchar(500)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "reason": {
+          "name": "reason",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "dismissed_by": {
+          "name": "dismissed_by",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "dismissed_at": {
+          "name": "dismissed_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "dismissed_inline_pairs_entity_a_idx": {
+          "name": "dismissed_inline_pairs_entity_a_idx",
+          "columns": [
+            {
+              "expression": "entity_type",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "value_a",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "dismissed_inline_pairs_entity_b_idx": {
+          "name": "dismissed_inline_pairs_entity_b_idx",
+          "columns": [
+            {
+              "expression": "entity_type",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "value_b",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "dismissed_inline_duplicate_pairs_dismissed_by_users_id_fk": {
+          "name": "dismissed_inline_duplicate_pairs_dismissed_by_users_id_fk",
+          "tableFrom": "dismissed_inline_duplicate_pairs",
+          "tableTo": "users",
+          "columnsFrom": ["dismissed_by"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "dismissed_inline_duplicate_pairs_unique": {
+          "name": "dismissed_inline_duplicate_pairs_unique",
+          "nullsNotDistinct": false,
+          "columns": ["entity_type", "value_a", "value_b"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.entity_duplicate_candidates": {
+      "name": "entity_duplicate_candidates",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "serial",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "entity_type": {
+          "name": "entity_type",
+          "type": "varchar(50)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "entity_id_a": {
+          "name": "entity_id_a",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "entity_id_b": {
+          "name": "entity_id_b",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "sim_score": {
+          "name": "sim_score",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "computed_at": {
+          "name": "computed_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "entity_dup_candidates_type_sim_idx": {
+          "name": "entity_dup_candidates_type_sim_idx",
+          "columns": [
+            {
+              "expression": "entity_type",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "sim_score",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "entity_dup_candidates_entity_a_idx": {
+          "name": "entity_dup_candidates_entity_a_idx",
+          "columns": [
+            {
+              "expression": "entity_type",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "entity_id_a",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "entity_dup_candidates_entity_b_idx": {
+          "name": "entity_dup_candidates_entity_b_idx",
+          "columns": [
+            {
+              "expression": "entity_type",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "entity_id_b",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "entity_duplicate_candidates_unique": {
+          "name": "entity_duplicate_candidates_unique",
+          "nullsNotDistinct": false,
+          "columns": ["entity_type", "entity_id_a", "entity_id_b"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.entity_duplicate_scan_status": {
+      "name": "entity_duplicate_scan_status",
+      "schema": "",
+      "columns": {
+        "entity_type": {
+          "name": "entity_type",
+          "type": "varchar(50)",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "is_computing": {
+          "name": "is_computing",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "computed_at": {
+          "name": "computed_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "total_pairs": {
+          "name": "total_pairs",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "threshold": {
+          "name": "threshold",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "processed_count": {
+          "name": "processed_count",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "total_count": {
+          "name": "total_count",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "error_message": {
+          "name": "error_message",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.server_fonts": {
+      "name": "server_fonts",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "serial",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "uploaded_by": {
+          "name": "uploaded_by",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "family_name": {
+          "name": "family_name",
+          "type": "varchar(200)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "original_file_name": {
+          "name": "original_file_name",
+          "type": "varchar(500)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "stored_file_name": {
+          "name": "stored_file_name",
+          "type": "varchar(500)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "format": {
+          "name": "format",
+          "type": "varchar(10)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "weight": {
+          "name": "weight",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 400
+        },
+        "style": {
+          "name": "style",
+          "type": "varchar(10)",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'normal'"
+        },
+        "weight_min": {
+          "name": "weight_min",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "weight_max": {
+          "name": "weight_max",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "instances": {
+          "name": "instances",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "file_size": {
+          "name": "file_size",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "file_hash": {
+          "name": "file_hash",
+          "type": "varchar(64)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "sf_hash_uidx": {
+          "name": "sf_hash_uidx",
+          "columns": [
+            {
+              "expression": "file_hash",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "sf_family_weight_style_uidx": {
+          "name": "sf_family_weight_style_uidx",
+          "columns": [
+            {
+              "expression": "family_name",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "weight",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "style",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "server_fonts_uploaded_by_users_id_fk": {
+          "name": "server_fonts_uploaded_by_users_id_fk",
+          "tableFrom": "server_fonts",
+          "tableTo": "users",
+          "columnsFrom": ["uploaded_by"],
+          "columnsTo": ["id"],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "server_fonts_format_chk": {
+          "name": "server_fonts_format_chk",
+          "value": "\"server_fonts\".\"format\" in ('ttf', 'otf', 'woff', 'woff2')"
+        },
+        "server_fonts_weight_chk": {
+          "name": "server_fonts_weight_chk",
+          "value": "\"server_fonts\".\"weight\" >= 1 and \"server_fonts\".\"weight\" <= 1000"
+        },
+        "server_fonts_style_chk": {
+          "name": "server_fonts_style_chk",
+          "value": "\"server_fonts\".\"style\" in ('normal', 'italic')"
+        },
+        "server_fonts_weight_range_chk": {
+          "name": "server_fonts_weight_range_chk",
+          "value": "(\"server_fonts\".\"weight_min\" is null) = (\"server_fonts\".\"weight_max\" is null) and (\"server_fonts\".\"weight_min\" is null or (\"server_fonts\".\"weight_min\" >= 1 and \"server_fonts\".\"weight_max\" <= 1000 and \"server_fonts\".\"weight_min\" < \"server_fonts\".\"weight_max\"))"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.user_fonts": {
+      "name": "user_fonts",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "serial",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "family_name": {
+          "name": "family_name",
+          "type": "varchar(200)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "original_file_name": {
+          "name": "original_file_name",
+          "type": "varchar(500)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "stored_file_name": {
+          "name": "stored_file_name",
+          "type": "varchar(500)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "format": {
+          "name": "format",
+          "type": "varchar(10)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "weight": {
+          "name": "weight",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 400
+        },
+        "style": {
+          "name": "style",
+          "type": "varchar(10)",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'normal'"
+        },
+        "weight_min": {
+          "name": "weight_min",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "weight_max": {
+          "name": "weight_max",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "instances": {
+          "name": "instances",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "file_size": {
+          "name": "file_size",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "file_hash": {
+          "name": "file_hash",
+          "type": "varchar(64)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "uf_user_hash_uidx": {
+          "name": "uf_user_hash_uidx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "file_hash",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "uf_user_family_weight_style_uidx": {
+          "name": "uf_user_family_weight_style_uidx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "family_name",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "weight",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "style",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "user_fonts_user_id_users_id_fk": {
+          "name": "user_fonts_user_id_users_id_fk",
+          "tableFrom": "user_fonts",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "user_fonts_format_chk": {
+          "name": "user_fonts_format_chk",
+          "value": "\"user_fonts\".\"format\" in ('ttf', 'otf', 'woff', 'woff2')"
+        },
+        "user_fonts_weight_chk": {
+          "name": "user_fonts_weight_chk",
+          "value": "\"user_fonts\".\"weight\" >= 1 and \"user_fonts\".\"weight\" <= 1000"
+        },
+        "user_fonts_style_chk": {
+          "name": "user_fonts_style_chk",
+          "value": "\"user_fonts\".\"style\" in ('normal', 'italic')"
+        },
+        "user_fonts_weight_range_chk": {
+          "name": "user_fonts_weight_range_chk",
+          "value": "(\"user_fonts\".\"weight_min\" is null) = (\"user_fonts\".\"weight_max\" is null) and (\"user_fonts\".\"weight_min\" is null or (\"user_fonts\".\"weight_min\" >= 1 and \"user_fonts\".\"weight_max\" <= 1000 and \"user_fonts\".\"weight_min\" < \"user_fonts\".\"weight_max\"))"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.book_file_chapters": {
+      "name": "book_file_chapters",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "serial",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "book_file_id": {
+          "name": "book_file_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "chapter_index": {
+          "name": "chapter_index",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "title": {
+          "name": "title",
+          "type": "varchar(500)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "href": {
+          "name": "href",
+          "type": "varchar(1000)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "spine_index": {
+          "name": "spine_index",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "book_file_chapters_book_file_id_chapter_index_uidx": {
+          "name": "book_file_chapters_book_file_id_chapter_index_uidx",
+          "columns": [
+            {
+              "expression": "book_file_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "chapter_index",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "book_file_chapters_book_file_id_idx": {
+          "name": "book_file_chapters_book_file_id_idx",
+          "columns": [
+            {
+              "expression": "book_file_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "book_file_chapters_book_file_id_book_files_id_fk": {
+          "name": "book_file_chapters_book_file_id_book_files_id_fk",
+          "tableFrom": "book_file_chapters",
+          "tableTo": "book_files",
+          "columnsFrom": ["book_file_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.book_file_hash_history": {
+      "name": "book_file_hash_history",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "serial",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "book_file_id": {
+          "name": "book_file_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "file_hash": {
+          "name": "file_hash",
+          "type": "varchar(32)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "reason": {
+          "name": "reason",
+          "type": "varchar(30)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "book_file_hash_history_book_file_id_file_hash_idx": {
+          "name": "book_file_hash_history_book_file_id_file_hash_idx",
+          "columns": [
+            {
+              "expression": "book_file_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "file_hash",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "book_file_hash_history_file_hash_idx": {
+          "name": "book_file_hash_history_file_hash_idx",
+          "columns": [
+            {
+              "expression": "file_hash",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "book_file_hash_history_book_file_id_book_files_id_fk": {
+          "name": "book_file_hash_history_book_file_id_book_files_id_fk",
+          "tableFrom": "book_file_hash_history",
+          "tableTo": "book_files",
+          "columnsFrom": ["book_file_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "book_file_hash_history_reason_chk": {
+          "name": "book_file_hash_history_reason_chk",
+          "value": "\"book_file_hash_history\".\"reason\" in ('file_write', 'external_change', 'rescan')"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.koreader_book_hash_links": {
+      "name": "koreader_book_hash_links",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "serial",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "hash": {
+          "name": "hash",
+          "type": "varchar(32)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "book_file_id": {
+          "name": "book_file_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "koreader_title": {
+          "name": "koreader_title",
+          "type": "varchar(500)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "koreader_authors": {
+          "name": "koreader_authors",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "koreader_last_open": {
+          "name": "koreader_last_open",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "koreader_book_hash_links_user_hash_uidx": {
+          "name": "koreader_book_hash_links_user_hash_uidx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "hash",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "koreader_book_hash_links_user_updated_idx": {
+          "name": "koreader_book_hash_links_user_updated_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "\"updated_at\" desc",
+              "asc": true,
+              "isExpression": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "koreader_book_hash_links_book_file_id_idx": {
+          "name": "koreader_book_hash_links_book_file_id_idx",
+          "columns": [
+            {
+              "expression": "book_file_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "koreader_book_hash_links_user_id_users_id_fk": {
+          "name": "koreader_book_hash_links_user_id_users_id_fk",
+          "tableFrom": "koreader_book_hash_links",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "koreader_book_hash_links_book_file_id_book_files_id_fk": {
+          "name": "koreader_book_hash_links_book_file_id_book_files_id_fk",
+          "tableFrom": "koreader_book_hash_links",
+          "tableTo": "book_files",
+          "columnsFrom": ["book_file_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "koreader_book_hash_links_hash_chk": {
+          "name": "koreader_book_hash_links_hash_chk",
+          "value": "\"koreader_book_hash_links\".\"hash\" ~ '^[0-9a-f]{32}$'"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.koreader_bookmark_links": {
+      "name": "koreader_bookmark_links",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "serial",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "bookmark_id": {
+          "name": "bookmark_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "device_id": {
+          "name": "device_id",
+          "type": "varchar(100)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "koreader_key": {
+          "name": "koreader_key",
+          "type": "varchar(32)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "device_datetime": {
+          "name": "device_datetime",
+          "type": "varchar(19)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "applied_at": {
+          "name": "applied_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "koreader_bookmark_links_bookmark_device_uidx": {
+          "name": "koreader_bookmark_links_bookmark_device_uidx",
+          "columns": [
+            {
+              "expression": "bookmark_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "device_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "koreader_bookmark_links_user_device_key_idx": {
+          "name": "koreader_bookmark_links_user_device_key_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "device_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "koreader_key",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "koreader_bookmark_links_user_device_idx": {
+          "name": "koreader_bookmark_links_user_device_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "device_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "koreader_bookmark_links_bookmark_id_idx": {
+          "name": "koreader_bookmark_links_bookmark_id_idx",
+          "columns": [
+            {
+              "expression": "bookmark_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "koreader_bookmark_links_bookmark_id_bookmarks_id_fk": {
+          "name": "koreader_bookmark_links_bookmark_id_bookmarks_id_fk",
+          "tableFrom": "koreader_bookmark_links",
+          "tableTo": "bookmarks",
+          "columnsFrom": ["bookmark_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "koreader_bookmark_links_user_id_users_id_fk": {
+          "name": "koreader_bookmark_links_user_id_users_id_fk",
+          "tableFrom": "koreader_bookmark_links",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.koreader_device_progress": {
+      "name": "koreader_device_progress",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "serial",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "book_file_id": {
+          "name": "book_file_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "device": {
+          "name": "device",
+          "type": "varchar(100)",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'KOReader'"
+        },
+        "device_id": {
+          "name": "device_id",
+          "type": "varchar(100)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "percentage": {
+          "name": "percentage",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "progress": {
+          "name": "progress",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "chapter_index": {
+          "name": "chapter_index",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "sync_timestamp": {
+          "name": "sync_timestamp",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "orphaned": {
+          "name": "orphaned",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "orphaned_hash": {
+          "name": "orphaned_hash",
+          "type": "varchar(64)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "koreader_device_progress_book_user_device_uidx": {
+          "name": "koreader_device_progress_book_user_device_uidx",
+          "columns": [
+            {
+              "expression": "book_file_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "device",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "device_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "where": "\"koreader_device_progress\".\"orphaned\" = false",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "koreader_device_progress_orphaned_hash_idx": {
+          "name": "koreader_device_progress_orphaned_hash_idx",
+          "columns": [
+            {
+              "expression": "orphaned_hash",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "where": "\"koreader_device_progress\".\"orphaned\" = true",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "koreader_device_progress_user_updated_at_idx": {
+          "name": "koreader_device_progress_user_updated_at_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "updated_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "koreader_device_progress_book_file_id_idx": {
+          "name": "koreader_device_progress_book_file_id_idx",
+          "columns": [
+            {
+              "expression": "book_file_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "where": "\"koreader_device_progress\".\"book_file_id\" is not null",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "koreader_device_progress_book_file_id_book_files_id_fk": {
+          "name": "koreader_device_progress_book_file_id_book_files_id_fk",
+          "tableFrom": "koreader_device_progress",
+          "tableTo": "book_files",
+          "columnsFrom": ["book_file_id"],
+          "columnsTo": ["id"],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "koreader_device_progress_user_id_users_id_fk": {
+          "name": "koreader_device_progress_user_id_users_id_fk",
+          "tableFrom": "koreader_device_progress",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "koreader_device_progress_percentage_range_chk": {
+          "name": "koreader_device_progress_percentage_range_chk",
+          "value": "\"koreader_device_progress\".\"percentage\" is null or (\"koreader_device_progress\".\"percentage\" >= 0 and \"koreader_device_progress\".\"percentage\" <= 1)"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.koreader_device_retirements": {
+      "name": "koreader_device_retirements",
+      "schema": "",
+      "columns": {
+        "user_id": {
+          "name": "user_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "device_id": {
+          "name": "device_id",
+          "type": "varchar(100)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "retired_at": {
+          "name": "retired_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "koreader_device_retirements_user_id_idx": {
+          "name": "koreader_device_retirements_user_id_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "koreader_device_retirements_user_id_users_id_fk": {
+          "name": "koreader_device_retirements_user_id_users_id_fk",
+          "tableFrom": "koreader_device_retirements",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "koreader_device_retirements_user_id_device_id_pk": {
+          "name": "koreader_device_retirements_user_id_device_id_pk",
+          "columns": ["user_id", "device_id"]
+        }
+      },
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.koreader_device_settings": {
+      "name": "koreader_device_settings",
+      "schema": "",
+      "columns": {
+        "user_id": {
+          "name": "user_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "device_id": {
+          "name": "device_id",
+          "type": "varchar(100)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "file_naming_pattern": {
+          "name": "file_naming_pattern",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "series_file_naming_pattern": {
+          "name": "series_file_naming_pattern",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "standalone_file_naming_pattern": {
+          "name": "standalone_file_naming_pattern",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "koreader_device_settings_user_id_idx": {
+          "name": "koreader_device_settings_user_id_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "koreader_device_settings_user_id_users_id_fk": {
+          "name": "koreader_device_settings_user_id_users_id_fk",
+          "tableFrom": "koreader_device_settings",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "koreader_device_settings_user_id_device_id_pk": {
+          "name": "koreader_device_settings_user_id_device_id_pk",
+          "columns": ["user_id", "device_id"]
+        }
+      },
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.koreader_device_sweeps": {
+      "name": "koreader_device_sweeps",
+      "schema": "",
+      "columns": {
+        "user_id": {
+          "name": "user_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "device_id": {
+          "name": "device_id",
+          "type": "varchar(100)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "device_model": {
+          "name": "device_model",
+          "type": "varchar(100)",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'KOReader'"
+        },
+        "plugin_version": {
+          "name": "plugin_version",
+          "type": "varchar(20)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "last_sweep_at": {
+          "name": "last_sweep_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "last_sweep_books_matched": {
+          "name": "last_sweep_books_matched",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "last_sweep_page_stats": {
+          "name": "last_sweep_page_stats",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "last_sweep_annotations": {
+          "name": "last_sweep_annotations",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "kds_user_id_idx": {
+          "name": "kds_user_id_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "koreader_device_sweeps_user_id_users_id_fk": {
+          "name": "koreader_device_sweeps_user_id_users_id_fk",
+          "tableFrom": "koreader_device_sweeps",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "koreader_device_sweeps_user_id_device_id_pk": {
+          "name": "koreader_device_sweeps_user_id_device_id_pk",
+          "columns": ["user_id", "device_id"]
+        }
+      },
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.koreader_page_stats": {
+      "name": "koreader_page_stats",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "serial",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "book_file_id": {
+          "name": "book_file_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "device_id": {
+          "name": "device_id",
+          "type": "varchar(100)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "page": {
+          "name": "page",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "start_time": {
+          "name": "start_time",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "duration_seconds": {
+          "name": "duration_seconds",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "total_pages": {
+          "name": "total_pages",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "kps_user_file_device_page_start_uidx": {
+          "name": "kps_user_file_device_page_start_uidx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "book_file_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "device_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "page",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "start_time",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "kps_user_file_device_start_idx": {
+          "name": "kps_user_file_device_start_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "book_file_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "device_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "start_time",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "kps_user_id_idx": {
+          "name": "kps_user_id_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "koreader_page_stats_book_file_id_idx": {
+          "name": "koreader_page_stats_book_file_id_idx",
+          "columns": [
+            {
+              "expression": "book_file_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "koreader_page_stats_user_id_users_id_fk": {
+          "name": "koreader_page_stats_user_id_users_id_fk",
+          "tableFrom": "koreader_page_stats",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "koreader_page_stats_book_file_id_book_files_id_fk": {
+          "name": "koreader_page_stats_book_file_id_book_files_id_fk",
+          "tableFrom": "koreader_page_stats",
+          "tableTo": "book_files",
+          "columnsFrom": ["book_file_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "koreader_page_stats_duration_nonnegative_chk": {
+          "name": "koreader_page_stats_duration_nonnegative_chk",
+          "value": "\"koreader_page_stats\".\"duration_seconds\" >= 0"
+        },
+        "koreader_page_stats_page_nonnegative_chk": {
+          "name": "koreader_page_stats_page_nonnegative_chk",
+          "value": "\"koreader_page_stats\".\"page\" >= 0"
+        },
+        "koreader_page_stats_total_pages_positive_chk": {
+          "name": "koreader_page_stats_total_pages_positive_chk",
+          "value": "\"koreader_page_stats\".\"total_pages\" > 0"
+        },
+        "koreader_page_stats_start_time_positive_chk": {
+          "name": "koreader_page_stats_start_time_positive_chk",
+          "value": "\"koreader_page_stats\".\"start_time\" > 0"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.koreader_progress_reset_devices": {
+      "name": "koreader_progress_reset_devices",
+      "schema": "",
+      "columns": {
+        "user_id": {
+          "name": "user_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "book_file_id": {
+          "name": "book_file_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "device_id": {
+          "name": "device_id",
+          "type": "varchar(100)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "converged_at": {
+          "name": "converged_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "koreader_progress_reset_devices_reset_fk": {
+          "name": "koreader_progress_reset_devices_reset_fk",
+          "tableFrom": "koreader_progress_reset_devices",
+          "tableTo": "koreader_progress_resets",
+          "columnsFrom": ["user_id", "book_file_id"],
+          "columnsTo": ["user_id", "book_file_id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "koreader_progress_reset_devices_user_id_book_file_id_device_id_pk": {
+          "name": "koreader_progress_reset_devices_user_id_book_file_id_device_id_pk",
+          "columns": ["user_id", "book_file_id", "device_id"]
+        }
+      },
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.koreader_progress_resets": {
+      "name": "koreader_progress_resets",
+      "schema": "",
+      "columns": {
+        "user_id": {
+          "name": "user_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "book_file_id": {
+          "name": "book_file_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "reset_at": {
+          "name": "reset_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "koreader_progress_resets_book_file_id_idx": {
+          "name": "koreader_progress_resets_book_file_id_idx",
+          "columns": [
+            {
+              "expression": "book_file_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "koreader_progress_resets_user_id_users_id_fk": {
+          "name": "koreader_progress_resets_user_id_users_id_fk",
+          "tableFrom": "koreader_progress_resets",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "koreader_progress_resets_book_file_id_book_files_id_fk": {
+          "name": "koreader_progress_resets_book_file_id_book_files_id_fk",
+          "tableFrom": "koreader_progress_resets",
+          "tableTo": "book_files",
+          "columnsFrom": ["book_file_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "koreader_progress_resets_user_id_book_file_id_pk": {
+          "name": "koreader_progress_resets_user_id_book_file_id_pk",
+          "columns": ["user_id", "book_file_id"]
+        }
+      },
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.koreader_unmatched_book_devices": {
+      "name": "koreader_unmatched_book_devices",
+      "schema": "",
+      "columns": {
+        "user_id": {
+          "name": "user_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "hash": {
+          "name": "hash",
+          "type": "varchar(32)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "device_id": {
+          "name": "device_id",
+          "type": "varchar(100)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "last_seen_at": {
+          "name": "last_seen_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "koreader_unmatched_book_devices_user_device_idx": {
+          "name": "koreader_unmatched_book_devices_user_device_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "device_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "koreader_unmatched_book_devices_user_id_users_id_fk": {
+          "name": "koreader_unmatched_book_devices_user_id_users_id_fk",
+          "tableFrom": "koreader_unmatched_book_devices",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "koreader_unmatched_book_devices_user_hash_fk": {
+          "name": "koreader_unmatched_book_devices_user_hash_fk",
+          "tableFrom": "koreader_unmatched_book_devices",
+          "tableTo": "koreader_unmatched_books",
+          "columnsFrom": ["user_id", "hash"],
+          "columnsTo": ["user_id", "hash"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "koreader_unmatched_book_devices_user_id_hash_device_id_pk": {
+          "name": "koreader_unmatched_book_devices_user_id_hash_device_id_pk",
+          "columns": ["user_id", "hash", "device_id"]
+        }
+      },
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "koreader_unmatched_book_devices_hash_chk": {
+          "name": "koreader_unmatched_book_devices_hash_chk",
+          "value": "\"koreader_unmatched_book_devices\".\"hash\" ~ '^[0-9a-f]{32}$'"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.koreader_unmatched_books": {
+      "name": "koreader_unmatched_books",
+      "schema": "",
+      "columns": {
+        "user_id": {
+          "name": "user_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "hash": {
+          "name": "hash",
+          "type": "varchar(32)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "title": {
+          "name": "title",
+          "type": "varchar(500)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "authors": {
+          "name": "authors",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "last_open": {
+          "name": "last_open",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "source": {
+          "name": "source",
+          "type": "varchar(20)",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'statistics'"
+        },
+        "metadata_ambiguous": {
+          "name": "metadata_ambiguous",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "first_seen_at": {
+          "name": "first_seen_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "last_seen_at": {
+          "name": "last_seen_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "koreader_unmatched_books_user_seen_idx": {
+          "name": "koreader_unmatched_books_user_seen_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "\"last_seen_at\" desc",
+              "asc": true,
+              "isExpression": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "koreader_unmatched_books_user_id_users_id_fk": {
+          "name": "koreader_unmatched_books_user_id_users_id_fk",
+          "tableFrom": "koreader_unmatched_books",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "koreader_unmatched_books_user_id_hash_pk": {
+          "name": "koreader_unmatched_books_user_id_hash_pk",
+          "columns": ["user_id", "hash"]
+        }
+      },
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "koreader_unmatched_books_hash_chk": {
+          "name": "koreader_unmatched_books_hash_chk",
+          "value": "\"koreader_unmatched_books\".\"hash\" ~ '^[0-9a-f]{32}$'"
+        },
+        "koreader_unmatched_books_source_chk": {
+          "name": "koreader_unmatched_books_source_chk",
+          "value": "\"koreader_unmatched_books\".\"source\" in ('current_file', 'file', 'statistics')"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.koreader_user_settings": {
+      "name": "koreader_user_settings",
+      "schema": "",
+      "columns": {
+        "user_id": {
+          "name": "user_id",
+          "type": "integer",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "default_file_naming_pattern": {
+          "name": "default_file_naming_pattern",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "koreader_user_settings_user_id_users_id_fk": {
+          "name": "koreader_user_settings_user_id_users_id_fk",
+          "tableFrom": "koreader_user_settings",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.koreader_users": {
+      "name": "koreader_users",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "serial",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "username": {
+          "name": "username",
+          "type": "varchar(100)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "password_hash": {
+          "name": "password_hash",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "password_md5": {
+          "name": "password_md5",
+          "type": "varchar(32)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "sync_enabled": {
+          "name": "sync_enabled",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "koreader_users_user_id_uidx": {
+          "name": "koreader_users_user_id_uidx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "koreader_users_username_uidx": {
+          "name": "koreader_users_username_uidx",
+          "columns": [
+            {
+              "expression": "username",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "koreader_users_user_id_users_id_fk": {
+          "name": "koreader_users_user_id_users_id_fk",
+          "tableFrom": "koreader_users",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.achievements": {
+      "name": "achievements",
+      "schema": "",
+      "columns": {
+        "key": {
+          "name": "key",
+          "type": "varchar(64)",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "group_key": {
+          "name": "group_key",
+          "type": "varchar(64)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "tier": {
+          "name": "tier",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "category": {
+          "name": "category",
+          "type": "varchar(20)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "name": {
+          "name": "name",
+          "type": "varchar(100)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "description": {
+          "name": "description",
+          "type": "varchar(500)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "icon_name": {
+          "name": "icon_name",
+          "type": "varchar(50)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "rarity": {
+          "name": "rarity",
+          "type": "varchar(20)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "threshold": {
+          "name": "threshold",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "hidden": {
+          "name": "hidden",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "sort_order": {
+          "name": "sort_order",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {
+        "achievements_category_sort_idx": {
+          "name": "achievements_category_sort_idx",
+          "columns": [
+            {
+              "expression": "category",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "sort_order",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "achievements_group_key_idx": {
+          "name": "achievements_group_key_idx",
+          "columns": [
+            {
+              "expression": "group_key",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "achievements_category_chk": {
+          "name": "achievements_category_chk",
+          "value": "\"achievements\".\"category\" in ('reading', 'library', 'exploration', 'dedication', 'devices')"
+        },
+        "achievements_rarity_chk": {
+          "name": "achievements_rarity_chk",
+          "value": "\"achievements\".\"rarity\" in ('common', 'rare', 'epic', 'legendary')"
+        },
+        "achievements_tier_chk": {
+          "name": "achievements_tier_chk",
+          "value": "\"achievements\".\"tier\" is null or (\"achievements\".\"tier\" >= 1 and \"achievements\".\"tier\" <= 4)"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.user_achievements": {
+      "name": "user_achievements",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "serial",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "achievement_key": {
+          "name": "achievement_key",
+          "type": "varchar(64)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "awarded_at": {
+          "name": "awarded_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "context_json": {
+          "name": "context_json",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "celebration_claim_id": {
+          "name": "celebration_claim_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "celebration_claimed_at": {
+          "name": "celebration_claimed_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "celebrated_at": {
+          "name": "celebrated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "user_achievements_user_key_uidx": {
+          "name": "user_achievements_user_key_uidx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "achievement_key",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "user_achievements_user_id_idx": {
+          "name": "user_achievements_user_id_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "user_achievements_user_awarded_at_idx": {
+          "name": "user_achievements_user_awarded_at_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "awarded_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "user_achievements_pending_celebration_idx": {
+          "name": "user_achievements_pending_celebration_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "celebrated_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "awarded_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "user_achievements_celebration_claim_uidx": {
+          "name": "user_achievements_celebration_claim_uidx",
+          "columns": [
+            {
+              "expression": "celebration_claim_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "user_achievements_user_id_users_id_fk": {
+          "name": "user_achievements_user_id_users_id_fk",
+          "tableFrom": "user_achievements",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "user_achievements_achievement_key_achievements_key_fk": {
+          "name": "user_achievements_achievement_key_achievements_key_fk",
+          "tableFrom": "user_achievements",
+          "tableTo": "achievements",
+          "columnsFrom": ["achievement_key"],
+          "columnsTo": ["key"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.hardcover_book_state": {
+      "name": "hardcover_book_state",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "serial",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "book_id": {
+          "name": "book_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "hardcover_book_id": {
+          "name": "hardcover_book_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "hardcover_edition_id": {
+          "name": "hardcover_edition_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "hardcover_user_book_id": {
+          "name": "hardcover_user_book_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "hardcover_read_id": {
+          "name": "hardcover_read_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "match_method": {
+          "name": "match_method",
+          "type": "varchar(20)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "match_error": {
+          "name": "match_error",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "last_synced_at": {
+          "name": "last_synced_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "last_synced_status": {
+          "name": "last_synced_status",
+          "type": "varchar(20)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "last_synced_progress": {
+          "name": "last_synced_progress",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "last_synced_rating": {
+          "name": "last_synced_rating",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "last_synced_started_at": {
+          "name": "last_synced_started_at",
+          "type": "varchar(10)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "last_synced_finished_at": {
+          "name": "last_synced_finished_at",
+          "type": "varchar(10)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "sync_error": {
+          "name": "sync_error",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "sync_override": {
+          "name": "sync_override",
+          "type": "varchar(20)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "sync_excluded": {
+          "name": "sync_excluded",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "hardcover_book_state_book_id_idx": {
+          "name": "hardcover_book_state_book_id_idx",
+          "columns": [
+            {
+              "expression": "book_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "hardcover_book_state_user_id_users_id_fk": {
+          "name": "hardcover_book_state_user_id_users_id_fk",
+          "tableFrom": "hardcover_book_state",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "hardcover_book_state_book_id_books_id_fk": {
+          "name": "hardcover_book_state_book_id_books_id_fk",
+          "tableFrom": "hardcover_book_state",
+          "tableTo": "books",
+          "columnsFrom": ["book_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "hardcover_book_state_user_book_uidx": {
+          "name": "hardcover_book_state_user_book_uidx",
+          "nullsNotDistinct": false,
+          "columns": ["user_id", "book_id"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.hardcover_user_settings": {
+      "name": "hardcover_user_settings",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "serial",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "api_token": {
+          "name": "api_token",
+          "type": "varchar(2048)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "enabled": {
+          "name": "enabled",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": true
+        },
+        "book_sync_mode": {
+          "name": "book_sync_mode",
+          "type": "varchar(20)",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'all_eligible'"
+        },
+        "auto_sync_on_status_change": {
+          "name": "auto_sync_on_status_change",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": true
+        },
+        "auto_sync_on_progress_update": {
+          "name": "auto_sync_on_progress_update",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": true
+        },
+        "auto_sync_on_rating_change": {
+          "name": "auto_sync_on_rating_change",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": true
+        },
+        "privacy_setting_id": {
+          "name": "privacy_setting_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 3
+        },
+        "last_synced_at": {
+          "name": "last_synced_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "hardcover_user_settings_user_id_users_id_fk": {
+          "name": "hardcover_user_settings_user_id_users_id_fk",
+          "tableFrom": "hardcover_user_settings",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "hardcover_user_settings_user_id_unique": {
+          "name": "hardcover_user_settings_user_id_unique",
+          "nullsNotDistinct": false,
+          "columns": ["user_id"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.readwise_user_settings": {
+      "name": "readwise_user_settings",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "serial",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "api_token": {
+          "name": "api_token",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "enabled": {
+          "name": "enabled",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": true
+        },
+        "last_synced_annotation_id": {
+          "name": "last_synced_annotation_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "disabled_reason": {
+          "name": "disabled_reason",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "last_synced_at": {
+          "name": "last_synced_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "readwise_user_settings_user_id_users_id_fk": {
+          "name": "readwise_user_settings_user_id_users_id_fk",
+          "tableFrom": "readwise_user_settings",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "readwise_user_settings_user_id_unique": {
+          "name": "readwise_user_settings_user_id_unique",
+          "nullsNotDistinct": false,
+          "columns": ["user_id"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.storygraph_book_state": {
+      "name": "storygraph_book_state",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "serial",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "book_id": {
+          "name": "book_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "storygraph_book_id": {
+          "name": "storygraph_book_id",
+          "type": "varchar(64)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "match_method": {
+          "name": "match_method",
+          "type": "varchar(20)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "match_error": {
+          "name": "match_error",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "last_synced_at": {
+          "name": "last_synced_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "last_synced_status": {
+          "name": "last_synced_status",
+          "type": "varchar(20)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "last_synced_progress": {
+          "name": "last_synced_progress",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "sync_error": {
+          "name": "sync_error",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "sync_override": {
+          "name": "sync_override",
+          "type": "varchar(20)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "storygraph_book_state_book_id_idx": {
+          "name": "storygraph_book_state_book_id_idx",
+          "columns": [
+            {
+              "expression": "book_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "storygraph_book_state_user_sync_override_idx": {
+          "name": "storygraph_book_state_user_sync_override_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "sync_override",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "book_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "storygraph_book_state_user_sync_error_idx": {
+          "name": "storygraph_book_state_user_sync_error_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "book_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "where": "\"storygraph_book_state\".\"sync_error\" is not null",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "storygraph_book_state_user_id_users_id_fk": {
+          "name": "storygraph_book_state_user_id_users_id_fk",
+          "tableFrom": "storygraph_book_state",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "storygraph_book_state_book_id_books_id_fk": {
+          "name": "storygraph_book_state_book_id_books_id_fk",
+          "tableFrom": "storygraph_book_state",
+          "tableTo": "books",
+          "columnsFrom": ["book_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "storygraph_book_state_user_book_uidx": {
+          "name": "storygraph_book_state_user_book_uidx",
+          "nullsNotDistinct": false,
+          "columns": ["user_id", "book_id"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.storygraph_user_settings": {
+      "name": "storygraph_user_settings",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "serial",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "session_cookie": {
+          "name": "session_cookie",
+          "type": "varchar(4096)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "remember_token": {
+          "name": "remember_token",
+          "type": "varchar(4096)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "enabled": {
+          "name": "enabled",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": true
+        },
+        "book_sync_mode": {
+          "name": "book_sync_mode",
+          "type": "varchar(20)",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'all_eligible'"
+        },
+        "auto_sync_on_status_change": {
+          "name": "auto_sync_on_status_change",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": true
+        },
+        "auto_sync_on_progress_update": {
+          "name": "auto_sync_on_progress_update",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": true
+        },
+        "last_synced_at": {
+          "name": "last_synced_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "storygraph_user_settings_user_id_users_id_fk": {
+          "name": "storygraph_user_settings_user_id_users_id_fk",
+          "tableFrom": "storygraph_user_settings",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "storygraph_user_settings_user_id_unique": {
+          "name": "storygraph_user_settings_user_id_unique",
+          "nullsNotDistinct": false,
+          "columns": ["user_id"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.shared_reading_insight_view_sessions": {
+      "name": "shared_reading_insight_view_sessions",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "viewer_user_id": {
+          "name": "viewer_user_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "subject_user_id": {
+          "name": "subject_user_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "sharing_level": {
+          "name": "sharing_level",
+          "type": "reading_insights_sharing_level",
+          "typeSchema": "public",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "expires_at": {
+          "name": "expires_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "shared_insight_view_subject_created_idx": {
+          "name": "shared_insight_view_subject_created_idx",
+          "columns": [
+            {
+              "expression": "subject_user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "shared_insight_view_expires_idx": {
+          "name": "shared_insight_view_expires_idx",
+          "columns": [
+            {
+              "expression": "expires_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "shared_reading_insight_view_sessions_viewer_user_id_users_id_fk": {
+          "name": "shared_reading_insight_view_sessions_viewer_user_id_users_id_fk",
+          "tableFrom": "shared_reading_insight_view_sessions",
+          "tableTo": "users",
+          "columnsFrom": ["viewer_user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "shared_reading_insight_view_sessions_subject_user_id_users_id_fk": {
+          "name": "shared_reading_insight_view_sessions_subject_user_id_users_id_fk",
+          "tableFrom": "shared_reading_insight_view_sessions",
+          "tableTo": "users",
+          "columnsFrom": ["subject_user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.user_preferences": {
+      "name": "user_preferences",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "serial",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "category": {
+          "name": "category",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "data": {
+          "name": "data",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "up_user_category_idx": {
+          "name": "up_user_category_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "category",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "user_preferences_user_id_users_id_fk": {
+          "name": "user_preferences_user_id_users_id_fk",
+          "tableFrom": "user_preferences",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.tts_book_preferences": {
+      "name": "tts_book_preferences",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "serial",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "book_id": {
+          "name": "book_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "provider_id": {
+          "name": "provider_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "voice_id": {
+          "name": "voice_id",
+          "type": "varchar(200)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "speed": {
+          "name": "speed",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "tts_book_prefs_user_book_uidx": {
+          "name": "tts_book_prefs_user_book_uidx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "book_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "tts_book_preferences_user_id_users_id_fk": {
+          "name": "tts_book_preferences_user_id_users_id_fk",
+          "tableFrom": "tts_book_preferences",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "tts_book_preferences_book_id_books_id_fk": {
+          "name": "tts_book_preferences_book_id_books_id_fk",
+          "tableFrom": "tts_book_preferences",
+          "tableTo": "books",
+          "columnsFrom": ["book_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "tts_book_preferences_provider_id_tts_providers_id_fk": {
+          "name": "tts_book_preferences_provider_id_tts_providers_id_fk",
+          "tableFrom": "tts_book_preferences",
+          "tableTo": "tts_providers",
+          "columnsFrom": ["provider_id"],
+          "columnsTo": ["id"],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.tts_providers": {
+      "name": "tts_providers",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "serial",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "name": {
+          "name": "name",
+          "type": "varchar(100)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "type": {
+          "name": "type",
+          "type": "varchar(30)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "enabled": {
+          "name": "enabled",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": true
+        },
+        "base_url": {
+          "name": "base_url",
+          "type": "varchar(500)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "api_key": {
+          "name": "api_key",
+          "type": "varchar(500)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "default_model": {
+          "name": "default_model",
+          "type": "varchar(100)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "static_voices": {
+          "name": "static_voices",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "supports_voice_discovery": {
+          "name": "supports_voice_discovery",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": true
+        },
+        "display_order": {
+          "name": "display_order",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.tts_reading_position": {
+      "name": "tts_reading_position",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "serial",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "book_file_id": {
+          "name": "book_file_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "cfi": {
+          "name": "cfi",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "chapter_index": {
+          "name": "chapter_index",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "tts_reading_pos_user_file_uidx": {
+          "name": "tts_reading_pos_user_file_uidx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "book_file_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "tts_reading_position_user_id_users_id_fk": {
+          "name": "tts_reading_position_user_id_users_id_fk",
+          "tableFrom": "tts_reading_position",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "tts_reading_position_book_file_id_book_files_id_fk": {
+          "name": "tts_reading_position_book_file_id_book_files_id_fk",
+          "tableFrom": "tts_reading_position",
+          "tableTo": "book_files",
+          "columnsFrom": ["book_file_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.tts_user_preferences": {
+      "name": "tts_user_preferences",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "serial",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "provider_id": {
+          "name": "provider_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "voice_id": {
+          "name": "voice_id",
+          "type": "varchar(200)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "speed": {
+          "name": "speed",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 1
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "tts_user_prefs_user_uidx": {
+          "name": "tts_user_prefs_user_uidx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "tts_user_preferences_user_id_users_id_fk": {
+          "name": "tts_user_preferences_user_id_users_id_fk",
+          "tableFrom": "tts_user_preferences",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "tts_user_preferences_provider_id_tts_providers_id_fk": {
+          "name": "tts_user_preferences_provider_id_tts_providers_id_fk",
+          "tableFrom": "tts_user_preferences",
+          "tableTo": "tts_providers",
+          "columnsFrom": ["provider_id"],
+          "columnsTo": ["id"],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.upload_sessions": {
+      "name": "upload_sessions",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "idempotency_key": {
+          "name": "idempotency_key",
+          "type": "varchar(100)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "target_kind": {
+          "name": "target_kind",
+          "type": "varchar(30)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "target_library_id": {
+          "name": "target_library_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "target_folder_id": {
+          "name": "target_folder_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "target_book_id": {
+          "name": "target_book_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "filename": {
+          "name": "filename",
+          "type": "varchar(500)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "content_type": {
+          "name": "content_type",
+          "type": "varchar(200)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "size_bytes": {
+          "name": "size_bytes",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "received_bytes": {
+          "name": "received_bytes",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "staging_path": {
+          "name": "staging_path",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "status": {
+          "name": "status",
+          "type": "varchar(20)",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'receiving'"
+        },
+        "expected_sha256": {
+          "name": "expected_sha256",
+          "type": "varchar(64)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "error_code": {
+          "name": "error_code",
+          "type": "varchar(80)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "error_message": {
+          "name": "error_message",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "result_book_id": {
+          "name": "result_book_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "result_book_dock_file_id": {
+          "name": "result_book_dock_file_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "expires_at": {
+          "name": "expires_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "completed_at": {
+          "name": "completed_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "upload_sessions_user_idempotency_uidx": {
+          "name": "upload_sessions_user_idempotency_uidx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "idempotency_key",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "upload_sessions_user_created_idx": {
+          "name": "upload_sessions_user_created_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "\"created_at\" desc",
+              "asc": true,
+              "isExpression": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "upload_sessions_status_expires_idx": {
+          "name": "upload_sessions_status_expires_idx",
+          "columns": [
+            {
+              "expression": "status",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "expires_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "upload_sessions_user_id_users_id_fk": {
+          "name": "upload_sessions_user_id_users_id_fk",
+          "tableFrom": "upload_sessions",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "upload_sessions_target_library_id_libraries_id_fk": {
+          "name": "upload_sessions_target_library_id_libraries_id_fk",
+          "tableFrom": "upload_sessions",
+          "tableTo": "libraries",
+          "columnsFrom": ["target_library_id"],
+          "columnsTo": ["id"],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "upload_sessions_target_folder_id_library_folders_id_fk": {
+          "name": "upload_sessions_target_folder_id_library_folders_id_fk",
+          "tableFrom": "upload_sessions",
+          "tableTo": "library_folders",
+          "columnsFrom": ["target_folder_id"],
+          "columnsTo": ["id"],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "upload_sessions_target_book_id_books_id_fk": {
+          "name": "upload_sessions_target_book_id_books_id_fk",
+          "tableFrom": "upload_sessions",
+          "tableTo": "books",
+          "columnsFrom": ["target_book_id"],
+          "columnsTo": ["id"],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "upload_sessions_result_book_id_books_id_fk": {
+          "name": "upload_sessions_result_book_id_books_id_fk",
+          "tableFrom": "upload_sessions",
+          "tableTo": "books",
+          "columnsFrom": ["result_book_id"],
+          "columnsTo": ["id"],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "upload_sessions_staging_path_unique": {
+          "name": "upload_sessions_staging_path_unique",
+          "nullsNotDistinct": false,
+          "columns": ["staging_path"]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {
+        "upload_sessions_target_kind_chk": {
+          "name": "upload_sessions_target_kind_chk",
+          "value": "\"upload_sessions\".\"target_kind\" in ('library', 'existing_book', 'book_dock')"
+        },
+        "upload_sessions_status_chk": {
+          "name": "upload_sessions_status_chk",
+          "value": "\"upload_sessions\".\"status\" in ('receiving', 'processing', 'completed', 'failed', 'cancelled', 'expired')"
+        },
+        "upload_sessions_size_positive_chk": {
+          "name": "upload_sessions_size_positive_chk",
+          "value": "\"upload_sessions\".\"size_bytes\" > 0"
+        },
+        "upload_sessions_received_range_chk": {
+          "name": "upload_sessions_received_range_chk",
+          "value": "\"upload_sessions\".\"received_bytes\" >= 0 and \"upload_sessions\".\"received_bytes\" <= \"upload_sessions\".\"size_bytes\""
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.podcast_bookmarks": {
+      "name": "podcast_bookmarks",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "serial",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "episode_id": {
+          "name": "episode_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "position_seconds": {
+          "name": "position_seconds",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "title": {
+          "name": "title",
+          "type": "varchar(500)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "note": {
+          "name": "note",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "podcast_bookmarks_user_episode_idx": {
+          "name": "podcast_bookmarks_user_episode_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "episode_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "podcast_bookmarks_user_episode_position_idx": {
+          "name": "podcast_bookmarks_user_episode_position_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "episode_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "position_seconds",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "podcast_bookmarks_user_id_users_id_fk": {
+          "name": "podcast_bookmarks_user_id_users_id_fk",
+          "tableFrom": "podcast_bookmarks",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "podcast_bookmarks_episode_id_podcast_episodes_id_fk": {
+          "name": "podcast_bookmarks_episode_id_podcast_episodes_id_fk",
+          "tableFrom": "podcast_bookmarks",
+          "tableTo": "podcast_episodes",
+          "columnsFrom": ["episode_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "podcast_bookmarks_position_nonnegative_chk": {
+          "name": "podcast_bookmarks_position_nonnegative_chk",
+          "value": "\"podcast_bookmarks\".\"position_seconds\" >= 0"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.podcast_episode_media": {
+      "name": "podcast_episode_media",
+      "schema": "",
+      "columns": {
+        "episode_id": {
+          "name": "episode_id",
+          "type": "integer",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "status": {
+          "name": "status",
+          "type": "varchar(20)",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'remote'"
+        },
+        "local_path": {
+          "name": "local_path",
+          "type": "varchar(4096)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "file_name": {
+          "name": "file_name",
+          "type": "varchar(1000)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "format": {
+          "name": "format",
+          "type": "varchar(30)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "mime_type": {
+          "name": "mime_type",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "size_bytes": {
+          "name": "size_bytes",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "checksum": {
+          "name": "checksum",
+          "type": "varchar(64)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "last_error": {
+          "name": "last_error",
+          "type": "varchar(2000)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "downloaded_at": {
+          "name": "downloaded_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "last_remote_validated_at": {
+          "name": "last_remote_validated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "podcast_episode_media_status_idx": {
+          "name": "podcast_episode_media_status_idx",
+          "columns": [
+            {
+              "expression": "status",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "podcast_episode_media_downloaded_idx": {
+          "name": "podcast_episode_media_downloaded_idx",
+          "columns": [
+            {
+              "expression": "downloaded_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "podcast_episode_media_episode_id_podcast_episodes_id_fk": {
+          "name": "podcast_episode_media_episode_id_podcast_episodes_id_fk",
+          "tableFrom": "podcast_episode_media",
+          "tableTo": "podcast_episodes",
+          "columnsFrom": ["episode_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "podcast_episode_media_status_chk": {
+          "name": "podcast_episode_media_status_chk",
+          "value": "\"podcast_episode_media\".\"status\" in ('remote', 'queued', 'downloading', 'local', 'failed', 'unavailable')"
+        },
+        "podcast_episode_media_size_nonnegative_chk": {
+          "name": "podcast_episode_media_size_nonnegative_chk",
+          "value": "\"podcast_episode_media\".\"size_bytes\" is null or \"podcast_episode_media\".\"size_bytes\" >= 0"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.podcast_episodes": {
+      "name": "podcast_episodes",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "serial",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "podcast_id": {
+          "name": "podcast_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "identity_hash": {
+          "name": "identity_hash",
+          "type": "varchar(64)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "origin": {
+          "name": "origin",
+          "type": "varchar(10)",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'feed'"
+        },
+        "guid": {
+          "name": "guid",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "title": {
+          "name": "title",
+          "type": "varchar(2000)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "subtitle": {
+          "name": "subtitle",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "published_at": {
+          "name": "published_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "season": {
+          "name": "season",
+          "type": "varchar(100)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "episode": {
+          "name": "episode",
+          "type": "varchar(100)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "episode_type": {
+          "name": "episode_type",
+          "type": "varchar(50)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "duration_seconds": {
+          "name": "duration_seconds",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "explicit": {
+          "name": "explicit",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "enclosure_url_encrypted": {
+          "name": "enclosure_url_encrypted",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "enclosure_url_hash": {
+          "name": "enclosure_url_hash",
+          "type": "varchar(64)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "enclosure_type": {
+          "name": "enclosure_type",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "enclosure_size_bytes": {
+          "name": "enclosure_size_bytes",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "chapters": {
+          "name": "chapters",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'[]'::jsonb"
+        },
+        "transcripts": {
+          "name": "transcripts",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'[]'::jsonb"
+        },
+        "locked_fields": {
+          "name": "locked_fields",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'[]'::jsonb"
+        },
+        "in_feed": {
+          "name": "in_feed",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": true
+        },
+        "last_seen_at": {
+          "name": "last_seen_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "unavailable_at": {
+          "name": "unavailable_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "podcast_episodes_podcast_identity_uidx": {
+          "name": "podcast_episodes_podcast_identity_uidx",
+          "columns": [
+            {
+              "expression": "podcast_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "identity_hash",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "podcast_episodes_podcast_id_idx": {
+          "name": "podcast_episodes_podcast_id_idx",
+          "columns": [
+            {
+              "expression": "podcast_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "podcast_episodes_podcast_created_idx": {
+          "name": "podcast_episodes_podcast_created_idx",
+          "columns": [
+            {
+              "expression": "podcast_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "podcast_episodes_podcast_published_id_idx": {
+          "name": "podcast_episodes_podcast_published_id_idx",
+          "columns": [
+            {
+              "expression": "podcast_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "\"published_at\" desc nulls last",
+              "asc": true,
+              "isExpression": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "\"id\" desc",
+              "asc": true,
+              "isExpression": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "podcast_episodes_title_trgm_idx": {
+          "name": "podcast_episodes_title_trgm_idx",
+          "columns": [
+            {
+              "expression": "title",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last",
+              "opclass": "gin_trgm_ops"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "gin",
+          "with": {}
+        },
+        "podcast_episodes_duration_idx": {
+          "name": "podcast_episodes_duration_idx",
+          "columns": [
+            {
+              "expression": "duration_seconds",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "podcast_episodes_enclosure_hash_idx": {
+          "name": "podcast_episodes_enclosure_hash_idx",
+          "columns": [
+            {
+              "expression": "enclosure_url_hash",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "podcast_episodes_in_feed_idx": {
+          "name": "podcast_episodes_in_feed_idx",
+          "columns": [
+            {
+              "expression": "podcast_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "in_feed",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "podcast_episodes_podcast_id_podcasts_id_fk": {
+          "name": "podcast_episodes_podcast_id_podcasts_id_fk",
+          "tableFrom": "podcast_episodes",
+          "tableTo": "podcasts",
+          "columnsFrom": ["podcast_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "podcast_episodes_origin_chk": {
+          "name": "podcast_episodes_origin_chk",
+          "value": "\"podcast_episodes\".\"origin\" in ('feed', 'local')"
+        },
+        "podcast_episodes_feed_origin_requires_enclosure_chk": {
+          "name": "podcast_episodes_feed_origin_requires_enclosure_chk",
+          "value": "\"podcast_episodes\".\"origin\" = 'local' or \"podcast_episodes\".\"enclosure_url_hash\" is not null"
+        },
+        "podcast_episodes_duration_nonnegative_chk": {
+          "name": "podcast_episodes_duration_nonnegative_chk",
+          "value": "\"podcast_episodes\".\"duration_seconds\" is null or \"podcast_episodes\".\"duration_seconds\" >= 0"
+        },
+        "podcast_episodes_size_nonnegative_chk": {
+          "name": "podcast_episodes_size_nonnegative_chk",
+          "value": "\"podcast_episodes\".\"enclosure_size_bytes\" is null or \"podcast_episodes\".\"enclosure_size_bytes\" >= 0"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.podcast_feed_aliases": {
+      "name": "podcast_feed_aliases",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "serial",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "podcast_id": {
+          "name": "podcast_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "url_hash": {
+          "name": "url_hash",
+          "type": "varchar(64)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "url_encrypted": {
+          "name": "url_encrypted",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "podcast_feed_aliases_podcast_hash_uidx": {
+          "name": "podcast_feed_aliases_podcast_hash_uidx",
+          "columns": [
+            {
+              "expression": "podcast_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "url_hash",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "podcast_feed_aliases_hash_idx": {
+          "name": "podcast_feed_aliases_hash_idx",
+          "columns": [
+            {
+              "expression": "url_hash",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "podcast_feed_aliases_podcast_id_podcasts_id_fk": {
+          "name": "podcast_feed_aliases_podcast_id_podcasts_id_fk",
+          "tableFrom": "podcast_feed_aliases",
+          "tableTo": "podcasts",
+          "columnsFrom": ["podcast_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.podcast_jobs": {
+      "name": "podcast_jobs",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "serial",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "type": {
+          "name": "type",
+          "type": "varchar(30)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "dedupe_key": {
+          "name": "dedupe_key",
+          "type": "varchar(255)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "library_id": {
+          "name": "library_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "podcast_id": {
+          "name": "podcast_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "episode_id": {
+          "name": "episode_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "requested_by_user_id": {
+          "name": "requested_by_user_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "download_batch_id": {
+          "name": "download_batch_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "status": {
+          "name": "status",
+          "type": "varchar(20)",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'queued'"
+        },
+        "payload": {
+          "name": "payload",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'{}'::jsonb"
+        },
+        "progress_current": {
+          "name": "progress_current",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "progress_total": {
+          "name": "progress_total",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "attempt_count": {
+          "name": "attempt_count",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "next_attempt_at": {
+          "name": "next_attempt_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "lease_until": {
+          "name": "lease_until",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "last_error": {
+          "name": "last_error",
+          "type": "varchar(2000)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "cancel_requested": {
+          "name": "cancel_requested",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "podcast_jobs_active_dedupe_uidx": {
+          "name": "podcast_jobs_active_dedupe_uidx",
+          "columns": [
+            {
+              "expression": "dedupe_key",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "where": "\"podcast_jobs\".\"status\" in ('queued', 'processing')",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "podcast_jobs_due_idx": {
+          "name": "podcast_jobs_due_idx",
+          "columns": [
+            {
+              "expression": "status",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "next_attempt_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "created_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "podcast_jobs_library_status_idx": {
+          "name": "podcast_jobs_library_status_idx",
+          "columns": [
+            {
+              "expression": "library_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "status",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "podcast_jobs_status_updated_idx": {
+          "name": "podcast_jobs_status_updated_idx",
+          "columns": [
+            {
+              "expression": "status",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "updated_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "podcast_jobs_download_batch_idx": {
+          "name": "podcast_jobs_download_batch_idx",
+          "columns": [
+            {
+              "expression": "requested_by_user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "download_batch_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "status",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "where": "\"podcast_jobs\".\"type\" = 'download' and \"podcast_jobs\".\"download_batch_id\" is not null",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "podcast_jobs_active_podcast_type_idx": {
+          "name": "podcast_jobs_active_podcast_type_idx",
+          "columns": [
+            {
+              "expression": "podcast_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "type",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "requested_by_user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "where": "\"podcast_jobs\".\"status\" in ('queued', 'processing') and \"podcast_jobs\".\"podcast_id\" is not null",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "podcast_jobs_active_episode_type_idx": {
+          "name": "podcast_jobs_active_episode_type_idx",
+          "columns": [
+            {
+              "expression": "episode_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "type",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "where": "\"podcast_jobs\".\"status\" in ('queued', 'processing') and \"podcast_jobs\".\"episode_id\" is not null",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "podcast_jobs_library_id_libraries_id_fk": {
+          "name": "podcast_jobs_library_id_libraries_id_fk",
+          "tableFrom": "podcast_jobs",
+          "tableTo": "libraries",
+          "columnsFrom": ["library_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "podcast_jobs_podcast_id_podcasts_id_fk": {
+          "name": "podcast_jobs_podcast_id_podcasts_id_fk",
+          "tableFrom": "podcast_jobs",
+          "tableTo": "podcasts",
+          "columnsFrom": ["podcast_id"],
+          "columnsTo": ["id"],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "podcast_jobs_episode_id_podcast_episodes_id_fk": {
+          "name": "podcast_jobs_episode_id_podcast_episodes_id_fk",
+          "tableFrom": "podcast_jobs",
+          "tableTo": "podcast_episodes",
+          "columnsFrom": ["episode_id"],
+          "columnsTo": ["id"],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "podcast_jobs_requested_by_user_id_users_id_fk": {
+          "name": "podcast_jobs_requested_by_user_id_users_id_fk",
+          "tableFrom": "podcast_jobs",
+          "tableTo": "users",
+          "columnsFrom": ["requested_by_user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "podcast_jobs_type_chk": {
+          "name": "podcast_jobs_type_chk",
+          "value": "\"podcast_jobs\".\"type\" in ('refresh', 'reparse', 'download', 'retention', 'purge', 'opml_import', 'import_scan', 'local_import', 'merge', 'digest', 'file_cleanup')"
+        },
+        "podcast_jobs_status_chk": {
+          "name": "podcast_jobs_status_chk",
+          "value": "\"podcast_jobs\".\"status\" in ('queued', 'processing', 'completed', 'failed', 'cancelled')"
+        },
+        "podcast_jobs_attempt_nonnegative_chk": {
+          "name": "podcast_jobs_attempt_nonnegative_chk",
+          "value": "\"podcast_jobs\".\"attempt_count\" >= 0"
+        },
+        "podcast_jobs_progress_nonnegative_chk": {
+          "name": "podcast_jobs_progress_nonnegative_chk",
+          "value": "\"podcast_jobs\".\"progress_current\" >= 0 and (\"podcast_jobs\".\"progress_total\" is null or \"podcast_jobs\".\"progress_total\" >= 0)"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.podcast_library_settings": {
+      "name": "podcast_library_settings",
+      "schema": "",
+      "columns": {
+        "library_id": {
+          "name": "library_id",
+          "type": "integer",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "storage_quota_bytes": {
+          "name": "storage_quota_bytes",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "107374182400"
+        },
+        "minimum_free_space_bytes": {
+          "name": "minimum_free_space_bytes",
+          "type": "bigint",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "5368709120"
+        },
+        "default_refresh_interval_minutes": {
+          "name": "default_refresh_interval_minutes",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 60
+        },
+        "completion_remaining_seconds": {
+          "name": "completion_remaining_seconds",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 60
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "podcast_library_settings_library_id_libraries_id_fk": {
+          "name": "podcast_library_settings_library_id_libraries_id_fk",
+          "tableFrom": "podcast_library_settings",
+          "tableTo": "libraries",
+          "columnsFrom": ["library_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "podcast_library_storage_quota_nonnegative_chk": {
+          "name": "podcast_library_storage_quota_nonnegative_chk",
+          "value": "\"podcast_library_settings\".\"storage_quota_bytes\" >= 0"
+        },
+        "podcast_library_free_space_nonnegative_chk": {
+          "name": "podcast_library_free_space_nonnegative_chk",
+          "value": "\"podcast_library_settings\".\"minimum_free_space_bytes\" >= 0"
+        },
+        "podcast_library_refresh_positive_chk": {
+          "name": "podcast_library_refresh_positive_chk",
+          "value": "\"podcast_library_settings\".\"default_refresh_interval_minutes\" > 0"
+        },
+        "podcast_library_completion_nonnegative_chk": {
+          "name": "podcast_library_completion_nonnegative_chk",
+          "value": "\"podcast_library_settings\".\"completion_remaining_seconds\" >= 0"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.podcast_listening_sessions": {
+      "name": "podcast_listening_sessions",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "serial",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "episode_id": {
+          "name": "episode_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "session_id": {
+          "name": "session_id",
+          "type": "varchar(64)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "started_at": {
+          "name": "started_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "ended_at": {
+          "name": "ended_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "duration_seconds": {
+          "name": "duration_seconds",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "end_position_seconds": {
+          "name": "end_position_seconds",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "podcast_sessions_user_session_uidx": {
+          "name": "podcast_sessions_user_session_uidx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "session_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "podcast_sessions_user_started_idx": {
+          "name": "podcast_sessions_user_started_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "\"started_at\" desc",
+              "asc": true,
+              "isExpression": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "podcast_sessions_episode_started_idx": {
+          "name": "podcast_sessions_episode_started_idx",
+          "columns": [
+            {
+              "expression": "episode_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "\"started_at\" desc",
+              "asc": true,
+              "isExpression": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "podcast_listening_sessions_user_id_users_id_fk": {
+          "name": "podcast_listening_sessions_user_id_users_id_fk",
+          "tableFrom": "podcast_listening_sessions",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "podcast_listening_sessions_episode_id_podcast_episodes_id_fk": {
+          "name": "podcast_listening_sessions_episode_id_podcast_episodes_id_fk",
+          "tableFrom": "podcast_listening_sessions",
+          "tableTo": "podcast_episodes",
+          "columnsFrom": ["episode_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "podcast_sessions_duration_nonnegative_chk": {
+          "name": "podcast_sessions_duration_nonnegative_chk",
+          "value": "\"podcast_listening_sessions\".\"duration_seconds\" >= 0"
+        },
+        "podcast_sessions_position_nonnegative_chk": {
+          "name": "podcast_sessions_position_nonnegative_chk",
+          "value": "\"podcast_listening_sessions\".\"end_position_seconds\" >= 0"
+        },
+        "podcast_sessions_time_order_chk": {
+          "name": "podcast_sessions_time_order_chk",
+          "value": "\"podcast_listening_sessions\".\"ended_at\" >= \"podcast_listening_sessions\".\"started_at\""
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.podcasts": {
+      "name": "podcasts",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "serial",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "library_id": {
+          "name": "library_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "title": {
+          "name": "title",
+          "type": "varchar(1000)",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "author": {
+          "name": "author",
+          "type": "varchar(1000)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "origin": {
+          "name": "origin",
+          "type": "varchar(10)",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'feed'"
+        },
+        "feed_url_encrypted": {
+          "name": "feed_url_encrypted",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "feed_url_hash": {
+          "name": "feed_url_hash",
+          "type": "varchar(64)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "local_folder_path": {
+          "name": "local_folder_path",
+          "type": "varchar(4096)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "image_url_encrypted": {
+          "name": "image_url_encrypted",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "site_url": {
+          "name": "site_url",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "language": {
+          "name": "language",
+          "type": "varchar(100)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "podcast_type": {
+          "name": "podcast_type",
+          "type": "varchar(50)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "explicit": {
+          "name": "explicit",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "categories": {
+          "name": "categories",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'[]'::jsonb"
+        },
+        "acquisition_policy": {
+          "name": "acquisition_policy",
+          "type": "varchar(20)",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'remote_only'"
+        },
+        "auto_download_limit": {
+          "name": "auto_download_limit",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "auto_download_window_days": {
+          "name": "auto_download_window_days",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "download_cleanup": {
+          "name": "download_cleanup",
+          "type": "varchar(20)",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'keep'"
+        },
+        "download_cleanup_delay_hours": {
+          "name": "download_cleanup_delay_hours",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 24
+        },
+        "refresh_interval_minutes": {
+          "name": "refresh_interval_minutes",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 60
+        },
+        "next_refresh_at": {
+          "name": "next_refresh_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "last_refresh_at": {
+          "name": "last_refresh_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "last_refresh_success_at": {
+          "name": "last_refresh_success_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "consecutive_failures": {
+          "name": "consecutive_failures",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "last_error": {
+          "name": "last_error",
+          "type": "varchar(2000)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "last_http_status": {
+          "name": "last_http_status",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "etag": {
+          "name": "etag",
+          "type": "varchar(1000)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "last_modified": {
+          "name": "last_modified",
+          "type": "varchar(1000)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "locked_fields": {
+          "name": "locked_fields",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'[]'::jsonb"
+        },
+        "custom_artwork_at": {
+          "name": "custom_artwork_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "feed_snapshot_at": {
+          "name": "feed_snapshot_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "archived_at": {
+          "name": "archived_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "missing_at": {
+          "name": "missing_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "podcasts_library_feed_hash_uidx": {
+          "name": "podcasts_library_feed_hash_uidx",
+          "columns": [
+            {
+              "expression": "library_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "feed_url_hash",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "where": "\"podcasts\".\"feed_url_hash\" is not null",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "podcasts_library_local_folder_uidx": {
+          "name": "podcasts_library_local_folder_uidx",
+          "columns": [
+            {
+              "expression": "library_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "local_folder_path",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "where": "\"podcasts\".\"local_folder_path\" is not null",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "podcasts_library_archived_title_idx": {
+          "name": "podcasts_library_archived_title_idx",
+          "columns": [
+            {
+              "expression": "library_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "archived_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "title",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "podcasts_title_trgm_idx": {
+          "name": "podcasts_title_trgm_idx",
+          "columns": [
+            {
+              "expression": "title",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last",
+              "opclass": "gin_trgm_ops"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "gin",
+          "with": {}
+        },
+        "podcasts_author_trgm_idx": {
+          "name": "podcasts_author_trgm_idx",
+          "columns": [
+            {
+              "expression": "author",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last",
+              "opclass": "gin_trgm_ops"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "gin",
+          "with": {}
+        },
+        "podcasts_due_refresh_idx": {
+          "name": "podcasts_due_refresh_idx",
+          "columns": [
+            {
+              "expression": "next_refresh_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "where": "\"podcasts\".\"archived_at\" is null and \"podcasts\".\"origin\" = 'feed'",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "podcasts_library_cleanup_idx": {
+          "name": "podcasts_library_cleanup_idx",
+          "columns": [
+            {
+              "expression": "library_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "where": "\"podcasts\".\"download_cleanup\" <> 'keep'",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "podcasts_library_id_libraries_id_fk": {
+          "name": "podcasts_library_id_libraries_id_fk",
+          "tableFrom": "podcasts",
+          "tableTo": "libraries",
+          "columnsFrom": ["library_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "podcasts_origin_chk": {
+          "name": "podcasts_origin_chk",
+          "value": "\"podcasts\".\"origin\" in ('feed', 'local')"
+        },
+        "podcasts_feed_origin_requires_feed_chk": {
+          "name": "podcasts_feed_origin_requires_feed_chk",
+          "value": "\"podcasts\".\"origin\" = 'local' or \"podcasts\".\"feed_url_hash\" is not null"
+        },
+        "podcasts_acquisition_policy_chk": {
+          "name": "podcasts_acquisition_policy_chk",
+          "value": "\"podcasts\".\"acquisition_policy\" in ('remote_only', 'manual', 'newest', 'window')"
+        },
+        "podcasts_download_cleanup_chk": {
+          "name": "podcasts_download_cleanup_chk",
+          "value": "\"podcasts\".\"download_cleanup\" in ('keep', 'after_finished')"
+        },
+        "podcasts_download_cleanup_delay_chk": {
+          "name": "podcasts_download_cleanup_delay_chk",
+          "value": "\"podcasts\".\"download_cleanup_delay_hours\" >= 0"
+        },
+        "podcasts_refresh_interval_positive_chk": {
+          "name": "podcasts_refresh_interval_positive_chk",
+          "value": "\"podcasts\".\"refresh_interval_minutes\" > 0"
+        },
+        "podcasts_failures_nonnegative_chk": {
+          "name": "podcasts_failures_nonnegative_chk",
+          "value": "\"podcasts\".\"consecutive_failures\" >= 0"
+        },
+        "podcasts_auto_download_limit_chk": {
+          "name": "podcasts_auto_download_limit_chk",
+          "value": "\"podcasts\".\"auto_download_limit\" is null or \"podcasts\".\"auto_download_limit\" > 0"
+        },
+        "podcasts_auto_download_window_chk": {
+          "name": "podcasts_auto_download_window_chk",
+          "value": "\"podcasts\".\"auto_download_window_days\" is null or \"podcasts\".\"auto_download_window_days\" > 0"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.user_podcast_episode_state": {
+      "name": "user_podcast_episode_state",
+      "schema": "",
+      "columns": {
+        "user_id": {
+          "name": "user_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "episode_id": {
+          "name": "episode_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "position_seconds": {
+          "name": "position_seconds",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "progress_percent": {
+          "name": "progress_percent",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 0
+        },
+        "finished": {
+          "name": "finished",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "finished_at": {
+          "name": "finished_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "pinned": {
+          "name": "pinned",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "last_listened_at": {
+          "name": "last_listened_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "user_podcast_episode_state_user_finished_idx": {
+          "name": "user_podcast_episode_state_user_finished_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "finished",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "\"updated_at\" desc",
+              "asc": true,
+              "isExpression": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "user_podcast_episode_state_episode_active_idx": {
+          "name": "user_podcast_episode_state_episode_active_idx",
+          "columns": [
+            {
+              "expression": "episode_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "finished",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "position_seconds",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "user_podcast_episode_state_user_id_users_id_fk": {
+          "name": "user_podcast_episode_state_user_id_users_id_fk",
+          "tableFrom": "user_podcast_episode_state",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "user_podcast_episode_state_episode_id_podcast_episodes_id_fk": {
+          "name": "user_podcast_episode_state_episode_id_podcast_episodes_id_fk",
+          "tableFrom": "user_podcast_episode_state",
+          "tableTo": "podcast_episodes",
+          "columnsFrom": ["episode_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "user_podcast_episode_state_user_id_episode_id_pk": {
+          "name": "user_podcast_episode_state_user_id_episode_id_pk",
+          "columns": ["user_id", "episode_id"]
+        }
+      },
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "user_podcast_episode_state_position_chk": {
+          "name": "user_podcast_episode_state_position_chk",
+          "value": "\"user_podcast_episode_state\".\"position_seconds\" >= 0"
+        },
+        "user_podcast_episode_state_progress_chk": {
+          "name": "user_podcast_episode_state_progress_chk",
+          "value": "\"user_podcast_episode_state\".\"progress_percent\" >= 0 and \"user_podcast_episode_state\".\"progress_percent\" <= 100"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.user_podcast_follows": {
+      "name": "user_podcast_follows",
+      "schema": "",
+      "columns": {
+        "user_id": {
+          "name": "user_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "podcast_id": {
+          "name": "podcast_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "notification_mode": {
+          "name": "notification_mode",
+          "type": "varchar(20)",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'off'"
+        },
+        "last_notified_at": {
+          "name": "last_notified_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "user_podcast_follows_podcast_idx": {
+          "name": "user_podcast_follows_podcast_idx",
+          "columns": [
+            {
+              "expression": "podcast_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "user_podcast_follows_due_digest_idx": {
+          "name": "user_podcast_follows_due_digest_idx",
+          "columns": [
+            {
+              "expression": "notification_mode",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "last_notified_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "podcast_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "where": "\"user_podcast_follows\".\"notification_mode\" in ('daily', 'weekly')",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "user_podcast_follows_user_id_users_id_fk": {
+          "name": "user_podcast_follows_user_id_users_id_fk",
+          "tableFrom": "user_podcast_follows",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "user_podcast_follows_podcast_id_podcasts_id_fk": {
+          "name": "user_podcast_follows_podcast_id_podcasts_id_fk",
+          "tableFrom": "user_podcast_follows",
+          "tableTo": "podcasts",
+          "columnsFrom": ["podcast_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "user_podcast_follows_user_id_podcast_id_pk": {
+          "name": "user_podcast_follows_user_id_podcast_id_pk",
+          "columns": ["user_id", "podcast_id"]
+        }
+      },
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "user_podcast_follows_notification_chk": {
+          "name": "user_podcast_follows_notification_chk",
+          "value": "\"user_podcast_follows\".\"notification_mode\" in ('off', 'immediate', 'daily', 'weekly')"
+        }
+      },
+      "isRLSEnabled": false
+    },
+    "public.user_podcast_queue": {
+      "name": "user_podcast_queue",
+      "schema": "",
+      "columns": {
+        "user_id": {
+          "name": "user_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "episode_id": {
+          "name": "episode_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "position": {
+          "name": "position",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "user_podcast_queue_user_position_uidx": {
+          "name": "user_podcast_queue_user_position_uidx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "position",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "user_podcast_queue_user_id_users_id_fk": {
+          "name": "user_podcast_queue_user_id_users_id_fk",
+          "tableFrom": "user_podcast_queue",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "user_podcast_queue_episode_id_podcast_episodes_id_fk": {
+          "name": "user_podcast_queue_episode_id_podcast_episodes_id_fk",
+          "tableFrom": "user_podcast_queue",
+          "tableTo": "podcast_episodes",
+          "columnsFrom": ["episode_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "user_podcast_queue_user_id_episode_id_pk": {
+          "name": "user_podcast_queue_user_id_episode_id_pk",
+          "columns": ["user_id", "episode_id"]
+        }
+      },
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "user_podcast_queue_position_nonnegative_chk": {
+          "name": "user_podcast_queue_position_nonnegative_chk",
+          "value": "\"user_podcast_queue\".\"position\" >= 0"
+        }
+      },
+      "isRLSEnabled": false
+    }
+  },
+  "enums": {
+    "public.content_filter_type": {
+      "name": "content_filter_type",
+      "schema": "public",
+      "values": ["include", "exclude"]
+    },
+    "public.library_access_level": {
+      "name": "library_access_level",
+      "schema": "public",
+      "values": ["viewer", "editor", "owner"]
+    },
+    "public.reading_insights_sharing_level": {
+      "name": "reading_insights_sharing_level",
+      "schema": "public",
+      "values": ["private", "summary", "detailed"]
+    },
+    "public.user_avatar_source": {
+      "name": "user_avatar_source",
+      "schema": "public",
+      "values": ["none", "external", "uploaded"]
+    },
+    "public.opds_sort_order": {
+      "name": "opds_sort_order",
+      "schema": "public",
+      "values": ["recent", "title_asc", "title_desc", "author_asc", "author_desc", "series_asc", "series_desc"]
+    },
+    "public.book_request_media_kind": {
+      "name": "book_request_media_kind",
+      "schema": "public",
+      "values": ["ebook", "audiobook", "comic"]
+    }
+  },
+  "schemas": {},
+  "sequences": {},
+  "roles": {},
+  "policies": {},
+  "views": {},
+  "_meta": {
+    "columns": {},
+    "schemas": {},
+    "tables": {}
+  }
+}
diff --git a/server/src/db/migrations/meta/_journal.json b/server/src/db/migrations/meta/_journal.json
index 2ea36eb1b..d12023f13 100644
--- a/server/src/db/migrations/meta/_journal.json
+++ b/server/src/db/migrations/meta/_journal.json
@@ -680,6 +680,13 @@
       "when": 1790119788880,
       "tag": "0096_add_android_reading_session_source",
       "breakpoints": true
+    },
+    {
+      "idx": 97,
+      "version": "7",
+      "when": 1790137565077,
+      "tag": "0097_add_book_covers",
+      "breakpoints": true
     }
   ]
 }
diff --git a/server/src/db/schema/book-covers.ts b/server/src/db/schema/book-covers.ts
new file mode 100644
index 000000000..fab2d7494
--- /dev/null
+++ b/server/src/db/schema/book-covers.ts
@@ -0,0 +1,31 @@
+import { sql } from 'drizzle-orm';
+import { check, integer, pgTable, primaryKey, timestamp, varchar } from 'drizzle-orm/pg-core';
+
+import { books } from './books';
+
+export const bookCovers = pgTable(
+  'book_covers',
+  {
+    bookId: integer('book_id')
+      .notNull()
+      .references(() => books.id, { onDelete: 'cascade' }),
+    medium: varchar('medium', { length: 5 }).notNull(),
+    source: varchar('source', { length: 9 }).notNull(),
+    origin: varchar('origin', { length: 12 }).notNull(),
+    width: integer('width'),
+    height: integer('height'),
+    updatedAt: timestamp('updated_at', { withTimezone: true }).defaultNow().notNull(),
+    dormantSince: timestamp('dormant_since', { withTimezone: true }),
+  },
+  (t) => [
+    primaryKey({ columns: [t.bookId, t.medium] }),
+    check('book_covers_medium_chk', sql`${t.medium} in ('ebook', 'audio')`),
+    check('book_covers_source_chk', sql`${t.source} in ('extracted', 'custom')`),
+    check('book_covers_origin_chk', sql`${t.origin} in ('embedded', 'folder_image', 'opf', 'provider', 'dock', 'upload', 'legacy')`),
+    check('book_covers_width_positive_chk', sql`${t.width} is null or ${t.width} > 0`),
+    check('book_covers_height_positive_chk', sql`${t.height} is null or ${t.height} > 0`),
+  ],
+);
+
+export type BookCover = typeof bookCovers.$inferSelect;
+export type NewBookCover = typeof bookCovers.$inferInsert;
diff --git a/server/src/db/schema/index.ts b/server/src/db/schema/index.ts
index 1f9fa1cdd..9d41defaf 100644
--- a/server/src/db/schema/index.ts
+++ b/server/src/db/schema/index.ts
@@ -6,6 +6,7 @@ export * from './custom-icons';
 export * from './migration';
 export * from './libraries';
 export * from './books';
+export * from './book-covers';
 export * from './book-duplicates';
 export * from './book-move';
 export * from './collections';
diff --git a/server/src/modules/architecture/architecture-boundaries.test.ts b/server/src/modules/architecture/architecture-boundaries.test.ts
index 3020f171b..666b2f22b 100644
--- a/server/src/modules/architecture/architecture-boundaries.test.ts
+++ b/server/src/modules/architecture/architecture-boundaries.test.ts
@@ -43,7 +43,6 @@ describe('Architecture boundaries', () => {
       'src/modules/authors/author-metadata-preferences.service.ts',
       'src/modules/book/book-query-builder.service.ts',
       'src/modules/book-metadata-fetch/book-metadata-fetch-config.service.ts',
-      'src/modules/cover/cover.service.ts',
       'src/modules/entity-manager/duplicate-compute.service.ts',
       'src/modules/kobo/services/kobo-analytics-resolver.service.ts',
       'src/modules/kobo/services/kobo-book-access.service.ts',
diff --git a/server/src/modules/authors/authors.module.ts b/server/src/modules/authors/authors.module.ts
index 27a909d37..c732993bb 100644
--- a/server/src/modules/authors/authors.module.ts
+++ b/server/src/modules/authors/authors.module.ts
@@ -6,6 +6,7 @@ import type { StringValue } from 'ms';
 import { AppSettingsModule } from '../app-settings/app-settings.module';
 import { AuthModule } from '../auth/auth.module';
 import { BookModule } from '../book/book.module';
+import { BookCoverStoreModule } from '../book-cover-store/book-cover-store.module';
 import { LibraryModule } from '../library/library.module';
 import { MetadataModule } from '../metadata/metadata.module';
 import { MetadataScoreModule } from '../metadata-score/metadata-score.module';
@@ -36,6 +37,7 @@ const AUTHOR_PROVIDER_CLASSES = [AudnexusAuthorMetadataProvider, GoodreadsAuthor
 @Module({
   imports: [
     BookModule,
+    BookCoverStoreModule,
     LibraryModule,
     AppSettingsModule,
     MetadataModule,
diff --git a/server/src/modules/authors/authors.service.test.ts b/server/src/modules/authors/authors.service.test.ts
index 41e37a735..37d0287e1 100644
--- a/server/src/modules/authors/authors.service.test.ts
+++ b/server/src/modules/authors/authors.service.test.ts
@@ -115,6 +115,7 @@ describe('AuthorsService', () => {
       enrichmentExecutor as any,
       enrichmentOrchestrator as any,
       metadataScoreService as any,
+      { enrichCardVersions: vi.fn().mockResolvedValue(undefined) } as any,
     );
     libraryService.findAll.mockResolvedValue([{ id: 1 }, { id: 2 }]);
     libraryService.findAccessibleLibraryIds.mockResolvedValue([1, 2]);
diff --git a/server/src/modules/authors/authors.service.ts b/server/src/modules/authors/authors.service.ts
index d33cd874b..720b8bb6b 100644
--- a/server/src/modules/authors/authors.service.ts
+++ b/server/src/modules/authors/authors.service.ts
@@ -17,6 +17,7 @@ import { sanitizeLogValue } from '../../common/utils/log-sanitize.utils';
 import { normalizeMetadataText } from '../../common/utils/metadata-text-normalize.utils';
 import type { RequestUser } from '../../common/types/request-user';
 import { BookReadService } from '../book/book-read.service';
+import { BookCoverStore } from '../book-cover-store/book-cover-store.service';
 import { LibraryService } from '../library/library.service';
 import { AuthorMetadataPreferencesService } from './author-metadata-preferences.service';
 import { MetadataScoreService } from '../metadata-score/metadata-score.service';
@@ -51,6 +52,7 @@ export class AuthorsService {
     private readonly enrichmentExecutor: AuthorEnrichmentExecutorService,
     private readonly enrichmentOrchestrator: AuthorEnrichmentOrchestratorService,
     private readonly metadataScoreService: MetadataScoreService,
+    private readonly coverStore: BookCoverStore,
   ) {}
 
   private assertPaginationWindow(page: number, size: number): void {
@@ -174,7 +176,9 @@ export class AuthorsService {
       cardData.narratorRows,
       cardData.tagRows,
       cardData.seriesMembershipRows,
-    ).sort((a, b) => (orderMap.get(a.id) ?? 0) - (orderMap.get(b.id) ?? 0));
+    );
+    await this.coverStore.enrichCardVersions(items);
+    items.sort((a, b) => (orderMap.get(a.id) ?? 0) - (orderMap.get(b.id) ?? 0));
 
     return { items, total: page.total, bookTotal: page.total, page: page.page, size: page.size };
   }
@@ -217,6 +221,7 @@ export class AuthorsService {
       collapsed.tagRows,
       collapsed.seriesMembershipRows,
     );
+    await this.coverStore.enrichCardVersions(items);
 
     return { items, total: collapsed.total, bookTotal: collapsed.bookTotal, page, size };
   }
diff --git a/server/src/modules/book-cover-store/book-cover-events.service.ts b/server/src/modules/book-cover-store/book-cover-events.service.ts
new file mode 100644
index 000000000..21838313f
--- /dev/null
+++ b/server/src/modules/book-cover-store/book-cover-events.service.ts
@@ -0,0 +1,12 @@
+import { Injectable } from '@nestjs/common';
+import { EventEmitter } from 'events';
+import type { CoverRefreshedEvent } from '@bookorbit/types';
+
+export const BOOK_COVER_CHANGED = 'book-cover.changed';
+
+@Injectable()
+export class BookCoverEventsService extends EventEmitter {
+  emitChanged(event: CoverRefreshedEvent): void {
+    this.emit(BOOK_COVER_CHANGED, event);
+  }
+}
diff --git a/server/src/modules/book-cover-store/book-cover-media.test.ts b/server/src/modules/book-cover-store/book-cover-media.test.ts
new file mode 100644
index 000000000..674771f1e
--- /dev/null
+++ b/server/src/modules/book-cover-store/book-cover-media.test.ts
@@ -0,0 +1,127 @@
+import { getCoverMedia } from '@bookorbit/types';
+import { drizzle } from 'drizzle-orm/node-postgres';
+import { describe, expect, it } from 'vitest';
+
+import * as schema from '../../db/schema';
+import { bookMetadata, books } from '../../db/schema';
+import {
+  activeCoverSlotSql,
+  coverMediaSql,
+  didKoboCoverChange,
+  getCoverMediaFromDatabaseFiles,
+  type BookCoverSlotRow,
+} from './book-cover-store.repository';
+
+const fixtures = [
+  { name: 'plain ebook', files: [{ format: 'epub', role: 'content', mediaOverlayAvailable: false }], expected: { hasEbook: true, hasAudio: false } },
+  { name: 'audiobook', files: [{ format: 'm4b', role: 'primary', mediaOverlayAvailable: false }], expected: { hasEbook: false, hasAudio: true } },
+  {
+    name: 'mixed media',
+    files: [
+      { format: 'pdf', role: 'content', mediaOverlayAvailable: false },
+      { format: 'mp3', role: 'content', mediaOverlayAvailable: false },
+    ],
+    expected: { hasEbook: true, hasAudio: true },
+  },
+  {
+    name: 'EPUB media overlay',
+    files: [{ format: 'epub', role: 'content', mediaOverlayAvailable: true }],
+    expected: { hasEbook: true, hasAudio: true },
+  },
+  {
+    name: 'non-content files',
+    files: [{ format: 'jpg', role: 'cover', mediaOverlayAvailable: false }],
+    expected: { hasEbook: false, hasAudio: false },
+  },
+] as const;
+
+describe('cover media parity', () => {
+  it.each(fixtures)('$name', ({ files, expected }) => {
+    expect(getCoverMedia(files.map((file) => ({ ...file, mediaOverlay: file.mediaOverlayAvailable ? { available: true } : null })))).toEqual(
+      expected,
+    );
+    expect(getCoverMediaFromDatabaseFiles(files)).toEqual(expected);
+  });
+});
+
+describe('cover media SQL', () => {
+  // Rendering only; the connection string is never dialled.
+  const db = drizzle('postgres://unused@localhost:1/unused', { schema });
+
+  it('ties the subqueries to the outer book even when the outer query reads a single table', () => {
+    const { hasEbook, hasAudio } = coverMediaSql(books.id);
+    const fromBooks = db.select({ hasEbook, hasAudio }).from(books).toSQL().sql;
+    expect(fromBooks.match(/"book_id" = "books"\."id"/g)).toHaveLength(2);
+    expect(fromBooks).not.toMatch(/= "id"/);
+
+    const fromMetadata = db
+      .select({ audio: activeCoverSlotSql(bookMetadata.bookId, 'audio'), hasAudio: coverMediaSql(bookMetadata.bookId).hasAudio })
+      .from(bookMetadata)
+      .toSQL().sql;
+    expect(fromMetadata.match(/"book_id" = "book_metadata"\."book_id"/g)).toHaveLength(2);
+  });
+
+  it('binds a literal book id as a parameter', () => {
+    const query = db
+      .select({ audio: activeCoverSlotSql(42, 'audio') })
+      .from(books)
+      .toSQL();
+    expect(query.params).toContain(42);
+  });
+});
+
+function slot(medium: 'ebook' | 'audio'): BookCoverSlotRow {
+  return {
+    bookId: 1,
+    medium,
+    source: 'extracted',
+    origin: 'embedded',
+    width: null,
+    height: null,
+    updatedAt: new Date('2026-01-01T00:00:00.000Z'),
+    dormantSince: null,
+  };
+}
+
+describe('Kobo-visible cover changes', () => {
+  const mixedMedia = { hasEbook: true, hasAudio: true };
+
+  it('does not move the Kobo stamp when only the audio slot bytes change behind an ebook slot', () => {
+    const rows = [slot('ebook'), slot('audio')];
+    expect(didKoboCoverChange(rows, rows, mixedMedia, 'audio', true)).toBe(false);
+  });
+
+  it('moves the Kobo stamp when deleting the ebook slot falls back to audio', () => {
+    expect(didKoboCoverChange([slot('ebook'), slot('audio')], [slot('audio')], mixedMedia, 'ebook', true)).toBe(true);
+  });
+
+  it('moves the Kobo stamp when the ebook leaves and its slot goes dormant behind an audio slot', () => {
+    const dormantEbook = { ...slot('ebook'), dormantSince: new Date('2026-02-01T00:00:00.000Z') };
+
+    expect(
+      didKoboCoverChange(
+        [slot('ebook'), slot('audio')],
+        [dormantEbook, slot('audio')],
+        { hasEbook: false, hasAudio: true },
+        'ebook',
+        false,
+        mixedMedia,
+      ),
+    ).toBe(true);
+  });
+
+  it('leaves the Kobo stamp alone when the audio slot goes dormant behind an ebook slot', () => {
+    const dormantAudio = { ...slot('audio'), dormantSince: new Date('2026-02-01T00:00:00.000Z') };
+
+    expect(
+      didKoboCoverChange(
+        [slot('ebook'), slot('audio')],
+        [slot('ebook'), dormantAudio],
+        { hasEbook: true, hasAudio: false },
+        'audio',
+        false,
+        mixedMedia,
+      ),
+    ).toBe(false);
+  });
+});
diff --git a/server/src/modules/book-cover-store/book-cover-store.module.ts b/server/src/modules/book-cover-store/book-cover-store.module.ts
new file mode 100644
index 000000000..3c330244d
--- /dev/null
+++ b/server/src/modules/book-cover-store/book-cover-store.module.ts
@@ -0,0 +1,11 @@
+import { Module } from '@nestjs/common';
+
+import { BookCoverEventsService } from './book-cover-events.service';
+import { BookCoverStoreRepository } from './book-cover-store.repository';
+import { BookCoverStore } from './book-cover-store.service';
+
+@Module({
+  providers: [BookCoverStoreRepository, BookCoverEventsService, BookCoverStore],
+  exports: [BookCoverStoreRepository, BookCoverEventsService, BookCoverStore],
+})
+export class BookCoverStoreModule {}
diff --git a/server/src/modules/book-cover-store/book-cover-store.repository.ts b/server/src/modules/book-cover-store/book-cover-store.repository.ts
new file mode 100644
index 000000000..ebdf095be
--- /dev/null
+++ b/server/src/modules/book-cover-store/book-cover-store.repository.ts
@@ -0,0 +1,414 @@
+import { Inject, Injectable } from '@nestjs/common';
+import { AUDIO_FORMAT_LIST, type CoverMedia, type CoverMedium } from '@bookorbit/types';
+import { and, eq, getTableName, gt, inArray, isNotNull, lte, sql, type SQL } from 'drizzle-orm';
+import { NodePgDatabase } from 'drizzle-orm/node-postgres';
+
+import { DB } from '../../db';
+import * as schema from '../../db/schema';
+import { bookCovers, bookFiles, bookMetadata, books, libraries } from '../../db/schema';
+
+type Db = NodePgDatabase<typeof schema>;
+type DbTransaction = Parameters<Parameters<Db['transaction']>[0]>[0];
+
+export type BookCoverOrigin = 'embedded' | 'folder_image' | 'opf' | 'provider' | 'dock' | 'upload' | 'legacy';
+export type BookCoverSource = 'extracted' | 'custom';
+export type BookCoverSlotRow = typeof bookCovers.$inferSelect;
+
+type DatabaseCoverMediaFile = Pick<typeof bookFiles.$inferSelect, 'format' | 'role' | 'mediaOverlayAvailable'>;
+
+export function getCoverMediaFromDatabaseFiles(files: readonly DatabaseCoverMediaFile[]): CoverMedia {
+  let hasEbook = false;
+  let hasAudio = false;
+  for (const file of files) {
+    if (file.role !== 'content' && file.role !== 'primary') continue;
+    const format = file.format?.trim().toLowerCase();
+    if (!format) continue;
+    if ((AUDIO_FORMAT_LIST as readonly string[]).includes(format)) hasAudio = true;
+    else hasEbook = true;
+    if (format === 'epub' && file.mediaOverlayAvailable) hasAudio = true;
+  }
+  return { hasEbook, hasAudio };
+}
+
+const AUDIO_FORMAT_SQL = sql.join(
+  AUDIO_FORMAT_LIST.map((format) => sql`${format}`),
+  sql`, `,
+);
+
+type OuterBookId = number | typeof books.id | typeof bookMetadata.bookId;
+
+/**
+ * Drizzle leaves a column unqualified when the outer query reads a single table, and inside these
+ * subqueries a bare `"id"` or `"book_id"` then binds to the subquery's own table, so every book
+ * would get the same answer. Naming the table keeps the reference on the outer row.
+ */
+function outerBookIdSql(bookId: OuterBookId): SQL {
+  if (typeof bookId === 'number') return sql`${bookId}`;
+  return sql`${sql.identifier(getTableName(bookId.table))}.${sql.identifier(bookId.name)}`;
+}
+
+export function coverMediaSql(bookId: OuterBookId) {
+  const outer = outerBookIdSql(bookId);
+  return {
+    hasEbook: sql<boolean>`exists (
+      select 1 from ${bookFiles}
+      where ${bookFiles.bookId} = ${outer}
+        and ${bookFiles.role} in ('content', 'primary')
+        and ${bookFiles.format} is not null
+        and lower(${bookFiles.format}) not in (${AUDIO_FORMAT_SQL})
+    )`,
+    hasAudio: sql<boolean>`exists (
+      select 1 from ${bookFiles}
+      where ${bookFiles.bookId} = ${outer}
+        and ${bookFiles.role} in ('content', 'primary')
+        and (
+          lower(${bookFiles.format}) in (${AUDIO_FORMAT_SQL})
+          or (lower(${bookFiles.format}) = 'epub' and ${bookFiles.mediaOverlayAvailable} = true)
+        )
+    )`,
+  };
+}
+
+/** A filled, served slot of this medium. Callers pair it with `coverMediaSql` for the medium's presence. */
+export function activeCoverSlotSql(bookId: OuterBookId, medium: CoverMedium) {
+  return sql<boolean>`exists (
+    select 1 from ${bookCovers}
+    where ${bookCovers.bookId} = ${outerBookIdSql(bookId)}
+      and ${bookCovers.medium} = ${medium}
+      and ${bookCovers.dormantSince} is null
+  )`;
+}
+
+export type BookCoverContext = {
+  bookId: number;
+  libraryId: number;
+  coverAspectRatio: string;
+  primaryFileId: number | null;
+  coverSource: BookCoverSource | null;
+  coverUpdatedAt: Date | null;
+  metadataUpdatedAt: Date | null;
+  lockedFields: string[];
+  media: CoverMedia;
+  files: Array<{ id: number; format: string | null; role: string; mediaOverlayAvailable: boolean }>;
+  slots: BookCoverSlotRow[];
+};
+
+export type BookCoverSourceFile = {
+  id: number;
+  absolutePath: string;
+  format: string | null;
+  role: string;
+  sizeBytes: number | null;
+  mediaOverlayAvailable: boolean;
+};
+
+export type BookCoverSources = {
+  formatPriority: string[];
+  files: BookCoverSourceFile[];
+};
+
+type SlotMutation =
+  | {
+      kind: 'upsert';
+      row: Omit<typeof bookCovers.$inferInsert, 'bookId' | 'medium'>;
+    }
+  | { kind: 'delete' };
+
+function mediumIsActive(medium: CoverMedium, media: CoverMedia): boolean {
+  return medium === 'ebook' ? media.hasEbook : media.hasAudio;
+}
+
+export function resolveKoboCoverMedium(rows: readonly BookCoverSlotRow[], media: CoverMedia): CoverMedium | null {
+  const active = new Set(
+    rows.filter((row) => row.dormantSince === null && mediumIsActive(row.medium as CoverMedium, media)).map((row) => row.medium as CoverMedium),
+  );
+  if (active.has('ebook')) return 'ebook';
+  if (active.has('audio')) return 'audio';
+  return null;
+}
+
+export function didKoboCoverChange(
+  before: readonly BookCoverSlotRow[],
+  after: readonly BookCoverSlotRow[],
+  media: CoverMedia,
+  mutatedMedium: CoverMedium,
+  servedBytesChanged: boolean,
+  beforeMedia: CoverMedia = media,
+): boolean {
+  const beforeKobo = resolveKoboCoverMedium(before, beforeMedia);
+  const afterKobo = resolveKoboCoverMedium(after, media);
+  return beforeKobo !== afterKobo || (servedBytesChanged && (beforeKobo === mutatedMedium || afterKobo === mutatedMedium));
+}
+
+@Injectable()
+export class BookCoverStoreRepository {
+  constructor(@Inject(DB) private readonly db: Db) {}
+
+  async findContext(bookId: number): Promise<BookCoverContext | null> {
+    const mediaProjection = coverMediaSql(books.id);
+    const [book] = await this.db
+      .select({
+        bookId: books.id,
+        libraryId: books.libraryId,
+        coverAspectRatio: libraries.coverAspectRatio,
+        primaryFileId: books.primaryFileId,
+        coverSource: bookMetadata.coverSource,
+        coverUpdatedAt: bookMetadata.coverUpdatedAt,
+        metadataUpdatedAt: bookMetadata.updatedAt,
+        lockedFields: bookMetadata.lockedFields,
+        ...mediaProjection,
+      })
+      .from(books)
+      .innerJoin(libraries, eq(libraries.id, books.libraryId))
+      .leftJoin(bookMetadata, eq(bookMetadata.bookId, books.id))
+      .where(eq(books.id, bookId))
+      .limit(1);
+    if (!book) return null;
+
+    const [files, slots] = await Promise.all([
+      this.db
+        .select({
+          id: bookFiles.id,
+          format: bookFiles.format,
+          role: bookFiles.role,
+          mediaOverlayAvailable: bookFiles.mediaOverlayAvailable,
+        })
+        .from(bookFiles)
+        .where(eq(bookFiles.bookId, bookId)),
+      this.db.select().from(bookCovers).where(eq(bookCovers.bookId, bookId)),
+    ]);
+
+    return {
+      bookId: book.bookId,
+      libraryId: book.libraryId,
+      coverAspectRatio: book.coverAspectRatio,
+      primaryFileId: book.primaryFileId,
+      coverSource: (book.coverSource as BookCoverSource | null) ?? null,
+      coverUpdatedAt: book.coverUpdatedAt ?? null,
+      metadataUpdatedAt: book.metadataUpdatedAt ?? null,
+      lockedFields: book.lockedFields ?? [],
+      media: { hasEbook: book.hasEbook, hasAudio: book.hasAudio },
+      files,
+      slots,
+    };
+  }
+
+  async slotsFor(bookIds: number[]): Promise<Map<number, BookCoverSlotRow[]>> {
+    const result = new Map<number, BookCoverSlotRow[]>();
+    if (bookIds.length === 0) return result;
+    const rows = await this.db.select().from(bookCovers).where(inArray(bookCovers.bookId, bookIds));
+    for (const row of rows) {
+      const list = result.get(row.bookId) ?? [];
+      list.push(row);
+      result.set(row.bookId, list);
+    }
+    return result;
+  }
+
+  async applySlotMutation(
+    bookId: number,
+    medium: CoverMedium,
+    media: CoverMedia,
+    mutation: SlotMutation,
+    options: { bumpBook: boolean; servedBytesChanged: boolean; updatedAt: Date; beforeMedia?: CoverMedia },
+  ): Promise<{ libraryId: number; koboCoverChanged: boolean }> {
+    return this.db.transaction(async (tx) => {
+      const before = await this.selectSlots(bookId, tx);
+      if (mutation.kind === 'delete') {
+        await tx.delete(bookCovers).where(and(eq(bookCovers.bookId, bookId), eq(bookCovers.medium, medium)));
+      } else {
+        await tx
+          .insert(bookCovers)
+          .values({ bookId, medium, ...mutation.row })
+          .onConflictDoUpdate({
+            target: [bookCovers.bookId, bookCovers.medium],
+            set: mutation.row,
+          });
+      }
+      const after = await this.selectSlots(bookId, tx);
+      const koboCoverChanged = didKoboCoverChange(before, after, media, medium, options.servedBytesChanged, options.beforeMedia);
+      const activeRows = after.filter((row) => row.dormantSince === null && mediumIsActive(row.medium as CoverMedium, media));
+      const coverSource: BookCoverSource | null = activeRows.some((row) => row.source === 'custom')
+        ? 'custom'
+        : activeRows.length > 0
+          ? 'extracted'
+          : null;
+
+      const [existingMetadata] = await tx
+        .select({ updatedAt: bookMetadata.updatedAt, coverUpdatedAt: bookMetadata.coverUpdatedAt })
+        .from(bookMetadata)
+        .where(eq(bookMetadata.bookId, bookId))
+        .limit(1);
+      const metadataUpdatedAt = koboCoverChanged ? options.updatedAt : (existingMetadata?.updatedAt ?? options.updatedAt);
+      const coverUpdatedAt = koboCoverChanged ? options.updatedAt : (existingMetadata?.coverUpdatedAt ?? null);
+
+      await tx
+        .insert(bookMetadata)
+        .values({ bookId, coverSource, coverUpdatedAt, updatedAt: metadataUpdatedAt })
+        .onConflictDoUpdate({
+          target: bookMetadata.bookId,
+          set: { coverSource, coverUpdatedAt, updatedAt: metadataUpdatedAt },
+        });
+
+      if (options.bumpBook) {
+        await tx.update(books).set({ updatedAt: options.updatedAt }).where(eq(books.id, bookId));
+      }
+
+      const [book] = await tx.select({ libraryId: books.libraryId }).from(books).where(eq(books.id, bookId)).limit(1);
+      return { libraryId: book?.libraryId ?? 0, koboCoverChanged };
+    });
+  }
+
+  async importSlotWithoutStamp(bookId: number, medium: CoverMedium, row: Omit<typeof bookCovers.$inferInsert, 'bookId' | 'medium'>): Promise<number> {
+    return this.db.transaction(async (tx) => {
+      await tx
+        .insert(bookCovers)
+        .values({ bookId, medium, ...row })
+        .onConflictDoNothing({ target: [bookCovers.bookId, bookCovers.medium] });
+      await this.recomputeSummary(bookId, tx);
+      const [book] = await tx.select({ libraryId: books.libraryId }).from(books).where(eq(books.id, bookId)).limit(1);
+      return book?.libraryId ?? 0;
+    });
+  }
+
+  async copyCoverLockToAudio(bookId: number): Promise<void> {
+    await this.db
+      .update(bookMetadata)
+      .set({
+        lockedFields: sql`case
+          when 'cover' = any(${bookMetadata.lockedFields}) and not ('audioCover' = any(${bookMetadata.lockedFields}))
+          then array_append(${bookMetadata.lockedFields}, 'audioCover')
+          else ${bookMetadata.lockedFields}
+        end`,
+        updatedAt: sql`${bookMetadata.updatedAt}`,
+      })
+      .where(eq(bookMetadata.bookId, bookId));
+  }
+
+  async listBookIdsAfter(afterId: number, limit: number): Promise<number[]> {
+    const rows = await this.db
+      .select({ id: books.id })
+      .from(books)
+      .where(sql`${books.id} > ${afterId}`)
+      .orderBy(books.id)
+      .limit(limit);
+    return rows.map((row) => row.id);
+  }
+
+  async findCoverSources(bookId: number): Promise<BookCoverSources | null> {
+    const [book] = await this.db
+      .select({ formatPriority: libraries.formatPriority })
+      .from(books)
+      .innerJoin(libraries, eq(libraries.id, books.libraryId))
+      .where(eq(books.id, bookId))
+      .limit(1);
+    if (!book) return null;
+    const files = await this.db
+      .select({
+        id: bookFiles.id,
+        absolutePath: bookFiles.absolutePath,
+        format: bookFiles.format,
+        role: bookFiles.role,
+        sizeBytes: bookFiles.sizeBytes,
+        mediaOverlayAvailable: bookFiles.mediaOverlayAvailable,
+      })
+      .from(bookFiles)
+      .where(eq(bookFiles.bookId, bookId));
+    return { formatPriority: book.formatPriority, files };
+  }
+
+  /**
+   * Rewrites `cover_source` wherever it disagrees with the book's active slots, leaving
+   * `updated_at` and the Kobo stamp alone. Only books with slot rows are touched: a book without any
+   * may still hold a legacy root cover that its summary rightly describes.
+   */
+  async repairCoverSummaries(): Promise<Array<{ bookId: number; libraryId: number }>> {
+    const { hasEbook, hasAudio } = coverMediaSql(bookCovers.bookId);
+    const result = await this.db.execute<{ book_id: number; library_id: number }>(sql`
+      with slot_states as (
+        select
+          "book_covers"."book_id" as book_id,
+          "book_covers"."source" as source,
+          "book_covers"."dormant_since" is null
+            and (("book_covers"."medium" = 'ebook' and ${hasEbook}) or ("book_covers"."medium" = 'audio' and ${hasAudio})) as active
+        from "book_covers"
+      ),
+      derived as (
+        select
+          book_id,
+          case
+            when bool_or(active and source = 'custom') then 'custom'
+            when bool_or(active) then 'extracted'
+          end as cover_source
+        from slot_states
+        group by book_id
+      )
+      update "book_metadata"
+      set "cover_source" = derived.cover_source
+      from derived, "books"
+      where "book_metadata"."book_id" = derived.book_id
+        and "books"."id" = derived.book_id
+        and "book_metadata"."cover_source" is distinct from derived.cover_source
+      returning "book_metadata"."book_id" as book_id, "books"."library_id" as library_id
+    `);
+    return result.rows.map((row) => ({ bookId: Number(row.book_id), libraryId: Number(row.library_id) }));
+  }
+
+  async listBookIdsWithBothCoverMediaAfter(afterId: number, limit: number): Promise<number[]> {
+    const media = coverMediaSql(books.id);
+    const rows = await this.db
+      .select({ id: books.id })
+      .from(books)
+      .where(and(gt(books.id, afterId), media.hasEbook, media.hasAudio))
+      .orderBy(books.id)
+      .limit(limit);
+    return rows.map((row) => row.id);
+  }
+
+  async listBookIdsWithExpiredDormantSlots(libraryId: number, dormantBefore: Date, limit: number): Promise<number[]> {
+    const rows = await this.db
+      .selectDistinct({ id: bookCovers.bookId })
+      .from(bookCovers)
+      .innerJoin(books, eq(books.id, bookCovers.bookId))
+      .where(
+        and(
+          eq(books.libraryId, libraryId),
+          eq(bookCovers.source, 'extracted'),
+          isNotNull(bookCovers.dormantSince),
+          lte(bookCovers.dormantSince, dormantBefore),
+        ),
+      )
+      .orderBy(bookCovers.bookId)
+      .limit(limit);
+    return rows.map((row) => row.id);
+  }
+
+  private async selectSlots(bookId: number, executor: Db | DbTransaction): Promise<BookCoverSlotRow[]> {
+    return executor.select().from(bookCovers).where(eq(bookCovers.bookId, bookId));
+  }
+
+  private async recomputeSummary(bookId: number, tx: DbTransaction): Promise<void> {
+    const mediaProjection = coverMediaSql(books.id);
+    const [book] = await tx
+      .select({ ...mediaProjection })
+      .from(books)
+      .where(eq(books.id, bookId))
+      .limit(1);
+    if (!book) return;
+    const slots = await this.selectSlots(bookId, tx);
+    const activeRows = slots.filter(
+      (row) => row.dormantSince === null && mediumIsActive(row.medium as CoverMedium, { hasEbook: book.hasEbook, hasAudio: book.hasAudio }),
+    );
+    const coverSource: BookCoverSource | null = activeRows.some((row) => row.source === 'custom')
+      ? 'custom'
+      : activeRows.length > 0
+        ? 'extracted'
+        : null;
+    const [metadata] = await tx.select({ updatedAt: bookMetadata.updatedAt }).from(bookMetadata).where(eq(bookMetadata.bookId, bookId)).limit(1);
+    const updatedAt = metadata?.updatedAt ?? new Date();
+    await tx
+      .insert(bookMetadata)
+      .values({ bookId, coverSource, updatedAt })
+      .onConflictDoUpdate({ target: bookMetadata.bookId, set: { coverSource, updatedAt } });
+  }
+}
diff --git a/server/src/modules/book-cover-store/book-cover-store.service.test.ts b/server/src/modules/book-cover-store/book-cover-store.service.test.ts
new file mode 100644
index 000000000..97908ff80
--- /dev/null
+++ b/server/src/modules/book-cover-store/book-cover-store.service.test.ts
@@ -0,0 +1,414 @@
+import { mkdir, mkdtemp, readFile, readdir, rm, writeFile } from 'fs/promises';
+import { tmpdir } from 'os';
+import { join } from 'path';
+import sharp from 'sharp';
+
+import { bookCoverDirPath, bookCoverSlotDirPath } from '../../common/book-cover-storage';
+import type { BookCoverContext, BookCoverSlotRow } from './book-cover-store.repository';
+import { BookCoverStore } from './book-cover-store.service';
+
+function slot(medium: 'ebook' | 'audio', source: 'extracted' | 'custom' = 'extracted'): BookCoverSlotRow {
+  return {
+    bookId: 7,
+    medium,
+    source,
+    origin: 'embedded',
+    width: null,
+    height: null,
+    updatedAt: new Date('2026-01-01T00:00:00.000Z'),
+    dormantSince: null,
+  };
+}
+
+function context(overrides: Partial<BookCoverContext> = {}): BookCoverContext {
+  return {
+    bookId: 7,
+    libraryId: 3,
+    coverAspectRatio: '2/3',
+    primaryFileId: 70,
+    coverSource: 'extracted',
+    coverUpdatedAt: new Date('2026-01-01T00:00:00.000Z'),
+    metadataUpdatedAt: new Date('2026-01-01T00:00:00.000Z'),
+    lockedFields: [],
+    media: { hasEbook: true, hasAudio: true },
+    files: [
+      { id: 70, format: 'epub', role: 'content', mediaOverlayAvailable: false },
+      { id: 71, format: 'm4b', role: 'content', mediaOverlayAvailable: false },
+    ],
+    slots: [slot('ebook'), slot('audio')],
+    ...overrides,
+  };
+}
+
+async function image(width: number, height: number): Promise<Buffer> {
+  return sharp({
+    create: {
+      width,
+      height,
+      channels: 3,
+      background: { r: 40, g: 120, b: 200 },
+    },
+  })
+    .jpeg()
+    .toBuffer();
+}
+
+function makeStore(root: string, current: BookCoverContext) {
+  const repository = {
+    findContext: vi.fn().mockResolvedValue(current),
+    slotsFor: vi.fn().mockResolvedValue(new Map()),
+    applySlotMutation: vi.fn().mockResolvedValue({ libraryId: current.libraryId, koboCoverChanged: true }),
+    importSlotWithoutStamp: vi.fn().mockResolvedValue(current.libraryId),
+    copyCoverLockToAudio: vi.fn().mockResolvedValue(undefined),
+  };
+  const events = { emitChanged: vi.fn() };
+  const config = { getOrThrow: vi.fn().mockReturnValue(root) };
+  return { store: new BookCoverStore(config as never, repository as never, events as never), repository, events };
+}
+
+/** A book with no slot rows until the store imports one, after which it has that slot. */
+function makeLegacyStore(root: string, legacy: BookCoverContext) {
+  const made = makeStore(root, legacy);
+  made.repository.findContext.mockImplementation(() => {
+    const imported = made.repository.importSlotWithoutStamp.mock.calls.map(([, medium, row]) => ({ ...row, bookId: 7, medium }) as BookCoverSlotRow);
+    return Promise.resolve(imported.length > 0 ? { ...legacy, slots: imported } : legacy);
+  });
+  return made;
+}
+
+describe('BookCoverStore', () => {
+  it('versions the face slot together with its fallback slot', () => {
+    const { store } = makeStore(join(tmpdir(), 'unused-cover-store'), context());
+    const ebook = slot('ebook');
+    const audio = { ...slot('audio'), updatedAt: new Date('2026-02-01T00:00:00.000Z') };
+
+    expect(store.coverVersion('2/3', [ebook, audio], 'unused')).toBe('ebook:2026-01-01T00:00:00.000Z:2026-02-01T00:00:00.000Z');
+    expect(store.coverVersion('1/1', [ebook, audio], 'unused')).toBe('audio:2026-02-01T00:00:00.000Z:2026-01-01T00:00:00.000Z');
+    expect(store.coverVersion('2/3', [{ ...ebook, dormantSince: new Date('2026-03-01T00:00:00.000Z') }, audio], 'unused')).toBe(
+      'ebook:-:2026-02-01T00:00:00.000Z',
+    );
+  });
+
+  it('resolves the library face and honors explicit strict and fallback reads', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'cover-store-resolve-'));
+    try {
+      const ebookDir = bookCoverSlotDirPath(root, 7, 'ebook');
+      const audioDir = bookCoverSlotDirPath(root, 7, 'audio');
+      await Promise.all([mkdir(ebookDir, { recursive: true }), mkdir(audioDir, { recursive: true })]);
+      await Promise.all([writeFile(join(ebookDir, 'cover_extracted.jpg'), 'ebook'), writeFile(join(audioDir, 'cover_extracted.jpg'), 'audio')]);
+      const { store } = makeStore(root, context({ coverAspectRatio: '1/1' }));
+
+      await expect(store.resolve(7, { variant: 'cover' })).resolves.toBe(join(audioDir, 'cover_extracted.jpg'));
+      await expect(store.resolve(7, { medium: 'ebook', variant: 'cover', strict: true })).resolves.toBe(join(ebookDir, 'cover_extracted.jpg'));
+      await rm(join(ebookDir, 'cover_extracted.jpg'));
+      await expect(store.resolve(7, { medium: 'ebook', variant: 'cover' })).resolves.toBe(join(audioDir, 'cover_extracted.jpg'));
+      await expect(store.resolve(7, { medium: 'ebook', variant: 'cover', strict: true })).resolves.toBeNull();
+    } finally {
+      await rm(root, { recursive: true, force: true });
+    }
+  });
+
+  it('converts a legacy root cover on first read and serves it from its slot, even with no coverSource', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'cover-store-legacy-'));
+    try {
+      const legacyDir = bookCoverDirPath(root, 7);
+      await mkdir(legacyDir, { recursive: true });
+      const portrait = await image(60, 90);
+      await writeFile(join(legacyDir, 'cover.jpg'), portrait);
+      const { store, repository } = makeLegacyStore(root, context({ coverSource: null, slots: [] }));
+
+      const ebookDir = bookCoverSlotDirPath(root, 7, 'ebook');
+      await expect(store.resolve(7, { variant: 'cover' })).resolves.toBe(join(ebookDir, 'cover_extracted.jpg'));
+      expect(repository.importSlotWithoutStamp).toHaveBeenCalledWith(7, 'ebook', expect.objectContaining({ source: 'extracted', origin: 'legacy' }));
+      await expect(readFile(join(ebookDir, 'cover_extracted.jpg'))).resolves.toEqual(portrait);
+      await expect(readFile(join(legacyDir, 'cover.jpg'))).rejects.toMatchObject({ code: 'ENOENT' });
+    } finally {
+      await rm(root, { recursive: true, force: true });
+    }
+  });
+
+  it('joins a conversion already running, so a cover and a thumbnail read do not race over the root files', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'cover-store-legacy-join-'));
+    try {
+      const legacyDir = bookCoverDirPath(root, 7);
+      await mkdir(legacyDir, { recursive: true });
+      await writeFile(join(legacyDir, 'cover_extracted.jpg'), await image(60, 90));
+      await writeFile(join(legacyDir, 'thumbnail.jpg'), await image(20, 30));
+      const { store, repository } = makeLegacyStore(root, context({ slots: [] }));
+
+      const ebookDir = bookCoverSlotDirPath(root, 7, 'ebook');
+      await expect(Promise.all([store.resolve(7, { variant: 'cover' }), store.resolve(7, { variant: 'thumbnail' })])).resolves.toEqual([
+        join(ebookDir, 'cover_extracted.jpg'),
+        join(ebookDir, 'thumbnail.jpg'),
+      ]);
+      expect(repository.importSlotWithoutStamp).toHaveBeenCalledOnce();
+    } finally {
+      await rm(root, { recursive: true, force: true });
+    }
+  });
+
+  it('serves no cover, and never the root file, when a read cannot convert it', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'cover-store-legacy-fail-'));
+    try {
+      const legacyDir = bookCoverDirPath(root, 7);
+      await mkdir(legacyDir, { recursive: true });
+      await writeFile(join(legacyDir, 'cover_custom.jpg'), await image(60, 90));
+      const { store, repository } = makeLegacyStore(root, context({ slots: [] }));
+      repository.importSlotWithoutStamp.mockRejectedValue(new Error('database unavailable'));
+
+      await expect(store.resolve(7, { variant: 'cover' })).resolves.toBeNull();
+      await expect(readFile(join(legacyDir, 'cover_custom.jpg'))).resolves.toBeInstanceOf(Buffer);
+    } finally {
+      await rm(root, { recursive: true, force: true });
+    }
+  });
+
+  describe('thumbnail repair', () => {
+    const ebookOnly = () => context({ media: { hasEbook: true, hasAudio: false }, slots: [slot('ebook')] });
+
+    async function withSlot(cover: Buffer | null, run: (store: BookCoverStore, dir: string) => Promise<void>): Promise<void> {
+      const root = await mkdtemp(join(tmpdir(), 'cover-store-thumbnail-'));
+      try {
+        const dir = bookCoverSlotDirPath(root, 7, 'ebook');
+        if (cover) {
+          await mkdir(dir, { recursive: true });
+          await writeFile(join(dir, 'cover_custom.jpg'), cover);
+        }
+        await run(makeStore(root, ebookOnly()).store, dir);
+      } finally {
+        await rm(root, { recursive: true, force: true });
+      }
+    }
+
+    it('rebuilds a thumbnail missing beside an intact cover and leaves no temporary file', async () => {
+      await withSlot(await image(800, 1200), async (store, dir) => {
+        await expect(store.resolve(7, { variant: 'thumbnail' })).resolves.toBe(join(dir, 'thumbnail.jpg'));
+
+        expect(await sharp(await readFile(join(dir, 'thumbnail.jpg'))).metadata()).toMatchObject({ format: 'jpeg', width: 400, height: 600 });
+        expect((await readdir(dir)).sort()).toEqual(['cover_custom.jpg', 'thumbnail.jpg']);
+      });
+    });
+
+    it('keeps a thumbnail written while the repair was in flight', async () => {
+      await withSlot(await image(800, 1200), async (store, dir) => {
+        const existing = Buffer.from('thumbnail written by a concurrent cover update');
+
+        const repair = store.resolve(7, { variant: 'thumbnail' });
+        await writeFile(join(dir, 'thumbnail.jpg'), existing);
+
+        await expect(repair).resolves.toBe(join(dir, 'thumbnail.jpg'));
+        await expect(readFile(join(dir, 'thumbnail.jpg'))).resolves.toEqual(existing);
+      });
+    });
+
+    it('resolves null instead of throwing when the cover cannot be decoded', async () => {
+      await withSlot(Buffer.alloc(0), async (store) => {
+        await expect(store.resolve(7, { variant: 'thumbnail' })).resolves.toBeNull();
+      });
+    });
+
+    it('resolves null when the slot directory is gone', async () => {
+      await withSlot(null, async (store) => {
+        await expect(store.resolve(7, { variant: 'thumbnail' })).resolves.toBeNull();
+      });
+    });
+  });
+
+  it('keeps an extracted fallback when a custom cover is reverted', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'cover-store-revert-'));
+    try {
+      const ebookDir = bookCoverSlotDirPath(root, 7, 'ebook');
+      await mkdir(ebookDir, { recursive: true });
+      const extracted = await image(60, 90);
+      await writeFile(join(ebookDir, 'cover_extracted.jpg'), extracted);
+      const current = context({ media: { hasEbook: true, hasAudio: false }, slots: [slot('ebook')] });
+      const { store, repository, events } = makeStore(root, current);
+
+      await expect(store.saveCustom(7, 'ebook', await image(90, 90))).resolves.toBe(true);
+      await expect(store.revert(7, 'ebook')).resolves.toBe('extracted');
+
+      expect(repository.applySlotMutation).toHaveBeenLastCalledWith(
+        7,
+        'ebook',
+        current.media,
+        expect.objectContaining({ kind: 'upsert', row: expect.objectContaining({ source: 'extracted' }) }),
+        expect.objectContaining({ bumpBook: true, servedBytesChanged: true }),
+      );
+      expect(events.emitChanged).toHaveBeenCalledTimes(2);
+      expect(await readFile(join(ebookDir, 'cover_extracted.jpg'))).toEqual(extracted);
+    } finally {
+      await rm(root, { recursive: true, force: true });
+    }
+  });
+
+  it('routes a square legacy cover to audio and copies the cover lock', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'cover-store-backfill-'));
+    try {
+      const legacyDir = bookCoverDirPath(root, 7);
+      await mkdir(legacyDir, { recursive: true });
+      const square = await image(80, 80);
+      await writeFile(join(legacyDir, 'cover_custom.jpg'), square);
+      const current = context({ coverSource: 'custom', lockedFields: ['cover'], slots: [] });
+      const { store, repository } = makeStore(root, current);
+
+      await expect(store.convertLegacy(7)).resolves.toEqual({ converted: true, libraryId: 3 });
+
+      expect(repository.importSlotWithoutStamp).toHaveBeenCalledWith(
+        7,
+        'audio',
+        expect.objectContaining({ source: 'custom', origin: 'legacy', updatedAt: current.coverUpdatedAt }),
+      );
+      expect(repository.copyCoverLockToAudio).toHaveBeenCalledWith(7);
+      await expect(readFile(join(bookCoverSlotDirPath(root, 7, 'audio'), 'cover_custom.jpg'))).resolves.toEqual(square);
+      await expect(readFile(join(legacyDir, 'cover_custom.jpg'))).rejects.toMatchObject({ code: 'ENOENT' });
+    } finally {
+      await rm(root, { recursive: true, force: true });
+    }
+  });
+
+  it('normalizes a generic legacy custom cover so reverting removes it', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'cover-store-generic-legacy-'));
+    try {
+      const legacyDir = bookCoverDirPath(root, 7);
+      await mkdir(legacyDir, { recursive: true });
+      const portrait = await image(60, 90);
+      await writeFile(join(legacyDir, 'cover.jpg'), portrait);
+      const current = context({
+        coverSource: 'custom',
+        media: { hasEbook: true, hasAudio: false },
+        slots: [],
+      });
+      const { store, repository } = makeStore(root, current);
+
+      await expect(store.convertLegacy(7)).resolves.toEqual({ converted: true, libraryId: 3 });
+      const ebookDir = bookCoverSlotDirPath(root, 7, 'ebook');
+      await expect(readFile(join(ebookDir, 'cover_custom.jpg'))).resolves.toEqual(portrait);
+      await expect(readFile(join(ebookDir, 'cover.jpg'))).rejects.toMatchObject({ code: 'ENOENT' });
+
+      await expect(store.revert(7, 'ebook')).resolves.toBeNull();
+      await expect(readFile(join(ebookDir, 'cover_custom.jpg'))).rejects.toMatchObject({ code: 'ENOENT' });
+      expect(repository.applySlotMutation).toHaveBeenLastCalledWith(
+        7,
+        'ebook',
+        current.media,
+        { kind: 'delete' },
+        expect.objectContaining({ servedBytesChanged: true }),
+      );
+    } finally {
+      await rm(root, { recursive: true, force: true });
+    }
+  });
+
+  it('does not mutate a locked slot', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'cover-store-lock-'));
+    try {
+      const { store, repository, events } = makeStore(root, context({ lockedFields: ['audioCover'] }));
+
+      await expect(store.saveExtracted(7, 'audio', await image(80, 80), { origin: 'embedded' })).resolves.toBe(false);
+      expect(repository.applySlotMutation).not.toHaveBeenCalled();
+      expect(events.emitChanged).not.toHaveBeenCalled();
+    } finally {
+      await rm(root, { recursive: true, force: true });
+    }
+  });
+
+  it('fills only an empty slot or one that came from a folder image', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'cover-store-fill-'));
+    try {
+      const folderImageSlot = { ...slot('audio'), origin: 'folder_image' };
+      const { store, repository } = makeStore(root, context({ slots: [slot('ebook'), folderImageSlot] }));
+      const fill = { replaceOrigins: ['folder_image'] as const };
+
+      await expect(store.saveExtracted(7, 'ebook', await image(60, 90), { origin: 'folder_image', fill })).resolves.toBe(false);
+      await expect(store.saveExtracted(7, 'audio', await image(80, 80), { origin: 'embedded', fill })).resolves.toBe(true);
+      expect(repository.applySlotMutation).toHaveBeenCalledOnce();
+      expect(repository.applySlotMutation.mock.calls[0]?.[1]).toBe('audio');
+    } finally {
+      await rm(root, { recursive: true, force: true });
+    }
+  });
+
+  it('marks a slot dormant with the medium it had, so a Kobo cover switch moves the stamp', async () => {
+    const { store, repository } = makeStore(join(tmpdir(), 'unused-cover-store'), context({ media: { hasEbook: false, hasAudio: true } }));
+
+    await expect(store.markDormant(7, 'ebook')).resolves.toBe(true);
+
+    const [, medium, media, mutation, options] = repository.applySlotMutation.mock.calls[0]!;
+    expect(medium).toBe('ebook');
+    expect(media).toEqual({ hasEbook: false, hasAudio: true });
+    expect(mutation).toMatchObject({ kind: 'upsert', row: { dormantSince: expect.any(Date), source: 'extracted' } });
+    expect(options).toMatchObject({ beforeMedia: { hasEbook: true, hasAudio: true }, servedBytesChanged: false });
+  });
+
+  it('routes a sidecar cover by shape, but keeps it on the ebook side of a read-along EPUB', async () => {
+    const both = makeStore(join(tmpdir(), 'unused-cover-store'), context());
+    await expect(both.store.chooseSidecarMedium(7, await image(80, 80))).resolves.toBe('audio');
+    await expect(both.store.chooseSidecarMedium(7, await image(60, 90))).resolves.toBe('ebook');
+    await expect(both.store.chooseSidecarMedium(7, await image(160, 90))).resolves.toBe('ebook');
+
+    const readAlong = makeStore(
+      join(tmpdir(), 'unused-cover-store'),
+      context({ files: [{ id: 70, format: 'epub', role: 'content', mediaOverlayAvailable: true }] }),
+    );
+    await expect(readAlong.store.chooseSidecarMedium(7, await image(80, 80))).resolves.toBe('ebook');
+  });
+
+  it('writes image bytes by shape, and a write with no image to the face slot of the library shape', async () => {
+    const portrait = makeStore(join(tmpdir(), 'unused-cover-store'), context());
+    await expect(portrait.store.chooseWriteMedium(7, await image(80, 80))).resolves.toBe('audio');
+    await expect(portrait.store.chooseWriteMedium(7)).resolves.toBe('ebook');
+
+    const square = makeStore(join(tmpdir(), 'unused-cover-store'), context({ coverAspectRatio: '1/1' }));
+    await expect(square.store.chooseWriteMedium(7)).resolves.toBe('audio');
+  });
+
+  it('hands a merged book’s slot to the target only for a medium the target has no cover for', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'cover-store-adopt-'));
+    try {
+      const target = context({ bookId: 8, slots: [{ ...slot('ebook'), bookId: 8 }] });
+      const { store, repository } = makeStore(root, target);
+      for (const medium of ['ebook', 'audio'] as const) {
+        const dir = bookCoverSlotDirPath(root, 7, medium);
+        await mkdir(dir, { recursive: true });
+        await writeFile(join(dir, 'cover_extracted.jpg'), await image(80, 80));
+      }
+
+      await expect(store.adoptSlots(7, [slot('ebook'), slot('audio', 'custom')], 8)).resolves.toEqual(['audio']);
+
+      expect(await readFile(join(bookCoverSlotDirPath(root, 8, 'audio'), 'cover_extracted.jpg'))).toBeInstanceOf(Buffer);
+      expect(repository.applySlotMutation).toHaveBeenCalledOnce();
+      expect(repository.applySlotMutation.mock.calls[0]?.slice(0, 2)).toEqual([8, 'audio']);
+      expect(repository.applySlotMutation.mock.calls[0]?.[3]).toMatchObject({ kind: 'upsert', row: { source: 'custom', dormantSince: null } });
+    } finally {
+      await rm(root, { recursive: true, force: true });
+    }
+  });
+
+  it('reports each slot a fetch may fill, sorting a legacy cover into its slot first', async () => {
+    const withAudioOnlyEmpty = makeStore(join(tmpdir(), 'unused-cover-store'), context({ slots: [slot('ebook')], lockedFields: ['audioCover'] }));
+    await expect(withAudioOnlyEmpty.store.fetchState(7)).resolves.toEqual({
+      media: { hasEbook: true, hasAudio: true },
+      filled: { ebook: true, audio: false },
+      locked: ['audio'],
+    });
+
+    const root = await mkdtemp(join(tmpdir(), 'cover-store-fetch-legacy-'));
+    try {
+      await mkdir(bookCoverDirPath(root, 7), { recursive: true });
+      await writeFile(join(bookCoverDirPath(root, 7), 'cover_custom.jpg'), await image(80, 80));
+      const legacy = makeLegacyStore(root, context({ slots: [], coverSource: 'custom' }));
+      await expect(legacy.store.fetchState(7)).resolves.toMatchObject({ filled: { ebook: false, audio: true } });
+    } finally {
+      await rm(root, { recursive: true, force: true });
+    }
+
+    const summaryOnly = makeStore(join(tmpdir(), 'unused-cover-store'), context({ slots: [], coverSource: 'custom' }));
+    await expect(summaryOnly.store.fetchState(7)).resolves.toMatchObject({ filled: { ebook: false, audio: false } });
+
+    const dormant = makeStore(
+      join(tmpdir(), 'unused-cover-store'),
+      context({ slots: [{ ...slot('audio'), dormantSince: new Date() }], media: { hasEbook: true, hasAudio: true } }),
+    );
+    await expect(dormant.store.fetchState(7)).resolves.toMatchObject({ filled: { ebook: false, audio: false } });
+  });
+});
diff --git a/server/src/modules/book-cover-store/book-cover-store.service.ts b/server/src/modules/book-cover-store/book-cover-store.service.ts
new file mode 100644
index 000000000..96908e922
--- /dev/null
+++ b/server/src/modules/book-cover-store/book-cover-store.service.ts
@@ -0,0 +1,883 @@
+import { BadRequestException, Injectable, Logger, NotFoundException } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import { COVER_MEDIA, isAudioFormat, type BookCard, type BookCoverSlot, type CoverMedia, type CoverMedium } from '@bookorbit/types';
+import { randomUUID } from 'crypto';
+import { access, copyFile, cp, link, mkdir, readFile, readdir, rename, rm, stat, writeFile } from 'fs/promises';
+import { basename, join } from 'path';
+import sharp from 'sharp';
+
+import {
+  COVER_CUSTOM_FILE_PREFIX,
+  COVER_EXTRACTED_FILE_PREFIX,
+  COVER_THUMBNAIL_FILE_NAME,
+  bookCoverDirPath,
+  bookCoverSlotDirPath,
+  bookCoverSlotThumbnailPath,
+  findPreferredBookCoverFileName,
+  isCustomBookCoverFileName,
+  isExtractedBookCoverFileName,
+} from '../../common/book-cover-storage';
+import { sanitizeLogValue } from '../../common/utils/log-sanitize.utils';
+import { generateThumbnail, imageExt, normalizeProgressiveJpeg } from '../metadata/lib/cover';
+import { BookCoverEventsService } from './book-cover-events.service';
+import { classifyCoverShape } from './cover-shape';
+import {
+  BookCoverStoreRepository,
+  type BookCoverContext,
+  type BookCoverOrigin,
+  type BookCoverSlotRow,
+  type BookCoverSource,
+  type BookCoverSources,
+} from './book-cover-store.repository';
+
+export type CoverVariant = 'cover' | 'thumbnail';
+
+type SaveOptions = {
+  origin: BookCoverOrigin;
+  overwrite?: boolean;
+  backfill?: boolean;
+  /** Writes only into an empty slot, or into an extracted slot whose origin is listed. */
+  fill?: { replaceOrigins?: readonly BookCoverOrigin[] };
+  skipIfUnchanged?: boolean;
+};
+
+type SlotStateOptions = { backfill?: boolean };
+
+// A grid of books with missing thumbnails would otherwise resize every cover at once.
+const THUMBNAIL_REPAIR_CONCURRENCY = 4;
+
+@Injectable()
+export class BookCoverStore {
+  private readonly logger = new Logger(BookCoverStore.name);
+  private readonly appDataPath: string;
+  private readonly thumbnailRepairs = new Map<string, Promise<string | null>>();
+  private readonly thumbnailRepairWaiters: Array<() => void> = [];
+  private activeThumbnailRepairs = 0;
+  private readonly conversions = new Map<number, Promise<{ converted: boolean; libraryId: number }>>();
+
+  constructor(
+    config: ConfigService,
+    private readonly repository: BookCoverStoreRepository,
+    private readonly events: BookCoverEventsService,
+  ) {
+    this.appDataPath = config.getOrThrow<string>('storage.appDataPath');
+  }
+
+  async resolve(bookId: number, options: { medium?: CoverMedium; variant: CoverVariant; strict?: boolean }): Promise<string | null> {
+    const existing = await this.repository.findContext(bookId);
+    if (!existing) return null;
+    const context = await this.convertOnRead(existing);
+    const activeSlots = new Map(
+      context.slots
+        .filter((slot) => slot.dormantSince === null && this.mediumIsActive(slot.medium as CoverMedium, context.media))
+        .map((slot) => [slot.medium as CoverMedium, slot]),
+    );
+    const order = this.resolutionOrder(context, options.medium, options.strict === true);
+
+    for (const medium of order) {
+      if (!activeSlots.has(medium)) continue;
+      const path = await this.resolveSlotArtifact(bookId, medium, options.variant);
+      if (path) return path;
+    }
+    return null;
+  }
+
+  async saveExtracted(bookId: number, medium: CoverMedium, bytes: Buffer, options: SaveOptions): Promise<boolean> {
+    const context = await this.convertedContext(bookId);
+    if (this.isLocked(context, medium)) return false;
+    const currentSlot = this.slotFor(context, medium);
+    if (options.fill && currentSlot && !this.canFill(currentSlot, options.fill.replaceOrigins ?? [])) return false;
+    const dir = bookCoverSlotDirPath(this.appDataPath, bookId, medium);
+    if (options.skipIfUnchanged && currentSlot?.source === 'extracted' && currentSlot.dormantSince === null && (await this.servesBytes(dir, bytes))) {
+      return false;
+    }
+    const dimensions = await this.measure(bytes);
+    await mkdir(dir, { recursive: true });
+    const files = await this.readDirIfExists(dir);
+    const customFile = files.find(isCustomBookCoverFileName);
+    const preserveCustom = options.overwrite !== true && currentSlot?.source === 'custom' && customFile !== undefined;
+    const storedCustomMissing = options.overwrite !== true && currentSlot?.source === 'custom' && customFile === undefined;
+    const replaceMissingCustom = storedCustomMissing && files.length > 0;
+
+    if (preserveCustom) {
+      await this.replaceCoverFile(dir, COVER_EXTRACTED_FILE_PREFIX, bytes);
+      if (!files.includes(COVER_THUMBNAIL_FILE_NAME) && customFile) {
+        await this.writeThumbnailAtomically(dir, await readFile(join(dir, customFile)));
+      }
+      this.emitChanged(context, options.backfill);
+      return true;
+    }
+
+    await this.replaceServedArtifacts(dir, COVER_EXTRACTED_FILE_PREFIX, bytes);
+    if (options.overwrite === true || replaceMissingCustom) await this.deleteFilesByPrefix(dir, COVER_CUSTOM_FILE_PREFIX);
+    const now = new Date();
+    await this.repository.applySlotMutation(
+      bookId,
+      medium,
+      context.media,
+      {
+        kind: 'upsert',
+        row: {
+          source: 'extracted',
+          origin: options.origin,
+          width: dimensions.width,
+          height: dimensions.height,
+          updatedAt: now,
+          dormantSince: null,
+        },
+      },
+      { bumpBook: options.backfill !== true, servedBytesChanged: true, updatedAt: now },
+    );
+    this.emitChanged(context, options.backfill);
+    return true;
+  }
+
+  async saveCustom(
+    bookId: number,
+    medium: CoverMedium,
+    bytes: Buffer,
+    options: { origin?: BookCoverOrigin; backfill?: boolean } = {},
+  ): Promise<boolean> {
+    const context = await this.convertedContext(bookId);
+    if (this.isLocked(context, medium)) return false;
+    let coverBytes: Buffer;
+    try {
+      coverBytes = await normalizeProgressiveJpeg(bytes);
+      await sharp(coverBytes, { failOn: 'error' }).metadata();
+    } catch {
+      throw new BadRequestException('Invalid image file');
+    }
+    const dimensions = await this.measure(coverBytes);
+    const dir = bookCoverSlotDirPath(this.appDataPath, bookId, medium);
+    await mkdir(dir, { recursive: true });
+    await this.replaceServedArtifacts(dir, COVER_CUSTOM_FILE_PREFIX, coverBytes);
+    const now = new Date();
+    await this.repository.applySlotMutation(
+      bookId,
+      medium,
+      context.media,
+      {
+        kind: 'upsert',
+        row: {
+          source: 'custom',
+          origin: options.origin ?? 'upload',
+          width: dimensions.width,
+          height: dimensions.height,
+          updatedAt: now,
+          dormantSince: null,
+        },
+      },
+      { bumpBook: options.backfill !== true, servedBytesChanged: true, updatedAt: now },
+    );
+    this.events.emitChanged({ bookIds: [bookId], libraryId: context.libraryId });
+    return true;
+  }
+
+  async revert(bookId: number, medium: CoverMedium, options: { backfill?: boolean } = {}): Promise<BookCoverSource | null> {
+    const context = await this.convertedContext(bookId);
+    if (this.isLocked(context, medium)) return (this.slotFor(context, medium)?.source as BookCoverSource | undefined) ?? null;
+    const dir = bookCoverSlotDirPath(this.appDataPath, bookId, medium);
+    const files = await this.readDirIfExists(dir);
+    const extracted = files.find(isExtractedBookCoverFileName);
+    const now = new Date();
+    if (!extracted) {
+      await this.deleteFilesByPrefix(dir, COVER_CUSTOM_FILE_PREFIX);
+      await rm(bookCoverSlotThumbnailPath(this.appDataPath, bookId, medium), { force: true });
+      await this.repository.applySlotMutation(
+        bookId,
+        medium,
+        context.media,
+        { kind: 'delete' },
+        {
+          bumpBook: options.backfill !== true,
+          servedBytesChanged: true,
+          updatedAt: now,
+        },
+      );
+      this.events.emitChanged({ bookIds: [bookId], libraryId: context.libraryId });
+      return null;
+    }
+
+    const bytes = await readFile(join(dir, extracted));
+    const thumbnail = await generateThumbnail(bytes);
+    const dimensions = await this.measure(bytes);
+    await this.deleteFilesByPrefix(dir, COVER_CUSTOM_FILE_PREFIX);
+    await this.writeThumbnailBytesAtomically(dir, thumbnail);
+    const prior = this.slotFor(context, medium);
+    await this.repository.applySlotMutation(
+      bookId,
+      medium,
+      context.media,
+      {
+        kind: 'upsert',
+        row: {
+          source: 'extracted',
+          origin: prior?.origin ?? 'embedded',
+          width: dimensions.width,
+          height: dimensions.height,
+          updatedAt: now,
+          dormantSince: null,
+        },
+      },
+      { bumpBook: options.backfill !== true, servedBytesChanged: true, updatedAt: now },
+    );
+    this.events.emitChanged({ bookIds: [bookId], libraryId: context.libraryId });
+    return 'extracted';
+  }
+
+  async markDormant(bookId: number, medium: CoverMedium, options: SlotStateOptions = {}): Promise<boolean> {
+    const context = await this.requireContext(bookId);
+    const slot = this.slotFor(context, medium);
+    if (!slot || slot.dormantSince !== null) return false;
+    const now = new Date();
+    await this.repository.applySlotMutation(
+      bookId,
+      medium,
+      context.media,
+      { kind: 'upsert', row: { ...this.rowValues(slot), dormantSince: now } },
+      { bumpBook: options.backfill !== true, servedBytesChanged: false, updatedAt: now, beforeMedia: this.withMedium(context.media, medium, true) },
+    );
+    this.emitChanged(context, options.backfill);
+    return true;
+  }
+
+  async reactivate(bookId: number, medium: CoverMedium, options: SlotStateOptions = {}): Promise<boolean> {
+    const context = await this.requireContext(bookId);
+    const slot = this.slotFor(context, medium);
+    if (!slot || slot.dormantSince === null || !this.mediumIsActive(medium, context.media)) return false;
+    const now = new Date();
+    await this.repository.applySlotMutation(
+      bookId,
+      medium,
+      context.media,
+      { kind: 'upsert', row: { ...this.rowValues(slot), dormantSince: null } },
+      { bumpBook: options.backfill !== true, servedBytesChanged: false, updatedAt: now, beforeMedia: this.withMedium(context.media, medium, false) },
+    );
+    this.emitChanged(context, options.backfill);
+    return true;
+  }
+
+  /** Removes a dormant extracted slot. Custom slots and slots back in use are left alone. */
+  async pruneDormant(bookId: number, medium: CoverMedium, dormantBefore: Date): Promise<boolean> {
+    const context = await this.requireContext(bookId);
+    const slot = this.slotFor(context, medium);
+    if (!slot || slot.source !== 'extracted' || slot.dormantSince === null || slot.dormantSince > dormantBefore) return false;
+    if (this.mediumIsActive(medium, context.media)) return false;
+    await this.repository.applySlotMutation(
+      bookId,
+      medium,
+      context.media,
+      { kind: 'delete' },
+      { bumpBook: false, servedBytesChanged: false, updatedAt: new Date() },
+    );
+    await rm(bookCoverSlotDirPath(this.appDataPath, bookId, medium), { recursive: true, force: true });
+    return true;
+  }
+
+  /** The slots a book will hand over when it is merged into another book, read before it goes. */
+  async slotsForAdoption(bookId: number): Promise<BookCoverSlotRow[]> {
+    const context = await this.repository.findContext(bookId);
+    if (!context) return [];
+    return (await this.ensureConverted(context)).slots.filter((slot) => slot.dormantSince === null);
+  }
+
+  /**
+   * Moves the slots of a book that was merged away into the book that absorbed its files, for each
+   * medium the target has no slot for. Call it after the merge and before the source's cover
+   * directory is removed.
+   */
+  async adoptSlots(sourceBookId: number, sourceSlots: readonly BookCoverSlotRow[], targetBookId: number): Promise<CoverMedium[]> {
+    if (sourceSlots.length === 0) return [];
+    const target = await this.convertedContext(targetBookId);
+    const adopted: CoverMedium[] = [];
+    for (const slot of sourceSlots) {
+      const medium = slot.medium as CoverMedium;
+      if (this.slotFor(target, medium) || this.isLocked(target, medium)) continue;
+      const sourceDir = bookCoverSlotDirPath(this.appDataPath, sourceBookId, medium);
+      if (!findPreferredBookCoverFileName(await this.readDirIfExists(sourceDir))) continue;
+      const targetDir = bookCoverSlotDirPath(this.appDataPath, targetBookId, medium);
+      await rm(targetDir, { recursive: true, force: true });
+      await mkdir(bookCoverDirPath(this.appDataPath, targetBookId), { recursive: true });
+      try {
+        await rename(sourceDir, targetDir);
+      } catch {
+        await cp(sourceDir, targetDir, { recursive: true });
+      }
+      const now = new Date();
+      await this.repository.applySlotMutation(
+        targetBookId,
+        medium,
+        target.media,
+        {
+          kind: 'upsert',
+          row: { ...this.rowValues(slot), updatedAt: now, dormantSince: this.mediumIsActive(medium, target.media) ? null : now },
+        },
+        { bumpBook: true, servedBytesChanged: true, updatedAt: now },
+      );
+      adopted.push(medium);
+    }
+    if (adopted.length > 0) this.emitChanged(target, false);
+    return adopted;
+  }
+
+  async removeCoverDirectory(bookId: number): Promise<void> {
+    await rm(bookCoverDirPath(this.appDataPath, bookId), { recursive: true, force: true });
+  }
+
+  /**
+   * Picks the slot for a cover that belongs to no medium of its own, such as an OPF sidecar's image.
+   * An EPUB with read-along audio is the only audio its book has, so a sidecar image stays on the
+   * ebook side there: that audio slot fills only from a square folder image, a fetch or an upload.
+   */
+  async chooseSidecarMedium(bookId: number, bytes: Buffer): Promise<CoverMedium> {
+    const context = await this.requireContext(bookId);
+    if (!context.media.hasAudio) return 'ebook';
+    if (!context.media.hasEbook) return 'audio';
+    if (!context.files.some((file) => this.isContent(file.role) && this.isAudioFile(file.format))) return 'ebook';
+    const { width, height } = await this.measure(bytes);
+    const shape = classifyCoverShape(width, height);
+    if (shape === 'square') return 'audio';
+    if (shape === 'portrait') return 'ebook';
+    return this.primaryMedium(context);
+  }
+
+  async bookIdsWithExpiredDormantSlots(libraryId: number, dormantBefore: Date, limit: number): Promise<number[]> {
+    return this.repository.listBookIdsWithExpiredDormantSlots(libraryId, dormantBefore, limit);
+  }
+
+  async reconcileInput(bookId: number): Promise<{ context: BookCoverContext; sources: BookCoverSources } | null> {
+    const existing = await this.repository.findContext(bookId);
+    if (!existing) return null;
+    const context = await this.ensureConverted(existing);
+    const sources = await this.repository.findCoverSources(bookId);
+    return sources ? { context, sources } : null;
+  }
+
+  async chooseWriteMedium(bookId: number, bytes?: Buffer): Promise<CoverMedium> {
+    const context = await this.requireContext(bookId);
+    if (context.media.hasEbook && !context.media.hasAudio) return 'ebook';
+    if (context.media.hasAudio && !context.media.hasEbook) return 'audio';
+    if (context.media.hasEbook && context.media.hasAudio && bytes) {
+      const { width, height } = await this.measure(bytes);
+      const shape = classifyCoverShape(width, height);
+      if (shape === 'square') return 'audio';
+      if (shape === 'portrait') return 'ebook';
+    }
+    return this.faceMedium(context);
+  }
+
+  async faceMediumFor(bookId: number): Promise<CoverMedium> {
+    const context = await this.requireContext(bookId);
+    const preferred = this.faceMedium(context);
+    const alternate = preferred === 'ebook' ? 'audio' : 'ebook';
+    const active = new Set(
+      context.slots
+        .filter((slot) => slot.dormantSince === null && this.mediumIsActive(slot.medium as CoverMedium, context.media))
+        .map((slot) => slot.medium as CoverMedium),
+    );
+    if (active.has(preferred)) return preferred;
+    if (active.has(alternate)) return alternate;
+    if (this.mediumIsActive(preferred, context.media)) return preferred;
+    if (this.mediumIsActive(alternate, context.media)) return alternate;
+    return preferred;
+  }
+
+  async mediaFor(bookId: number): Promise<CoverMedia> {
+    return (await this.requireContext(bookId)).media;
+  }
+
+  /** Whether the slot is filled and served, after bringing a legacy root cover into its slot. */
+  async hasActiveSlot(bookId: number, medium: CoverMedium): Promise<boolean> {
+    const context = await this.convertedContext(bookId);
+    return context.slots.some((slot) => slot.medium === medium && slot.dormantSince === null) && this.mediumIsActive(medium, context.media);
+  }
+
+  /** What a metadata fetch needs to know about a book's covers: its media, which slots are filled, and which are locked. */
+  async fetchState(bookId: number): Promise<{ media: CoverMedia; filled: Record<CoverMedium, boolean>; locked: CoverMedium[] } | null> {
+    const existing = await this.repository.findContext(bookId);
+    if (!existing) return null;
+    const context = await this.ensureConverted(existing);
+    const active = (medium: CoverMedium) =>
+      this.mediumIsActive(medium, context.media) && context.slots.some((slot) => slot.medium === medium && slot.dormantSince === null);
+    return {
+      media: context.media,
+      filled: { ebook: active('ebook'), audio: active('audio') },
+      locked: COVER_MEDIA.filter((medium) => this.isLocked(context, medium)),
+    };
+  }
+
+  async slotsFor(bookIds: number[]): Promise<Map<number, BookCoverSlotRow[]>> {
+    return this.repository.slotsFor(bookIds);
+  }
+
+  async enrichCardVersions(cards: BookCard[]): Promise<void> {
+    const slotsByBookId = await this.repository.slotsFor(cards.map((card) => card.id));
+    for (const card of cards) {
+      card.coverVersion = this.coverVersion(card.coverAspectRatio, slotsByBookId.get(card.id) ?? [], card.updatedAt ?? card.addedAt);
+    }
+  }
+
+  slotDtos(context: Pick<BookCoverContext, 'media' | 'slots'>): Record<CoverMedium, BookCoverSlot | null> {
+    return {
+      ebook: this.toSlotDto(context.slots.find((slot) => slot.medium === 'ebook' && slot.dormantSince === null && context.media.hasEbook)),
+      audio: this.toSlotDto(context.slots.find((slot) => slot.medium === 'audio' && slot.dormantSince === null && context.media.hasAudio)),
+    };
+  }
+
+  coverVersion(coverAspectRatio: string, slots: readonly BookCoverSlotRow[], legacyVersion: string): string {
+    if (slots.length === 0) return `legacy:${legacyVersion}`;
+    const face: CoverMedium = coverAspectRatio === '1/1' ? 'audio' : 'ebook';
+    const other: CoverMedium = face === 'ebook' ? 'audio' : 'ebook';
+    const stamp = (medium: CoverMedium) => slots.find((slot) => slot.medium === medium && slot.dormantSince === null)?.updatedAt.toISOString() ?? '-';
+    return `${face}:${stamp(face)}:${stamp(other)}`;
+  }
+
+  async contextFor(bookId: number): Promise<BookCoverContext | null> {
+    const context = await this.repository.findContext(bookId);
+    return context ? this.convertOnRead(context) : null;
+  }
+
+  /**
+   * Moves a legacy root cover into the slot that matches its shape. Stage A, writes and reads all
+   * land here, so a conversion already running for the book is joined rather than raced: a second
+   * run would find the root files gone halfway through.
+   */
+  async convertLegacy(bookId: number, options: { emit?: boolean } = {}): Promise<{ converted: boolean; libraryId: number }> {
+    const running = this.conversions.get(bookId);
+    if (running) return running;
+    const conversion = this.convertLegacyOnce(bookId, options);
+    this.conversions.set(bookId, conversion);
+    try {
+      return await conversion;
+    } finally {
+      if (this.conversions.get(bookId) === conversion) this.conversions.delete(bookId);
+    }
+  }
+
+  private async convertLegacyOnce(bookId: number, options: { emit?: boolean }): Promise<{ converted: boolean; libraryId: number }> {
+    const context = await this.requireContext(bookId);
+    if (context.slots.length > 0) {
+      await this.repository.copyCoverLockToAudio(bookId);
+      return { converted: false, libraryId: context.libraryId };
+    }
+
+    const restored = await this.restoreSlotRows(context);
+    if (restored) {
+      await this.repository.copyCoverLockToAudio(bookId);
+      if (options.emit !== false) this.events.emitChanged({ bookIds: [bookId], libraryId: context.libraryId });
+      return { converted: true, libraryId: context.libraryId };
+    }
+
+    const root = bookCoverDirPath(this.appDataPath, bookId);
+    const files = await this.readDirIfExists(root);
+    const coverFile = findPreferredBookCoverFileName(files);
+    if (!coverFile) {
+      await this.repository.copyCoverLockToAudio(bookId);
+      return { converted: false, libraryId: context.libraryId };
+    }
+
+    const coverBytes = await readFile(join(root, coverFile));
+    const medium = await this.legacyMedium(context, coverBytes);
+    const slotDir = bookCoverSlotDirPath(this.appDataPath, bookId, medium);
+    await mkdir(slotDir, { recursive: true });
+    const source = isCustomBookCoverFileName(coverFile) || context.coverSource === 'custom' ? 'custom' : 'extracted';
+    const rootArtifacts = files.filter(
+      (file) =>
+        file === COVER_THUMBNAIL_FILE_NAME ||
+        file.startsWith(COVER_CUSTOM_FILE_PREFIX) ||
+        file.startsWith(COVER_EXTRACTED_FILE_PREFIX) ||
+        file.startsWith('cover.'),
+    );
+    const prefixedArtifacts = rootArtifacts.filter(
+      (file) => file.startsWith(COVER_CUSTOM_FILE_PREFIX) || file.startsWith(COVER_EXTRACTED_FILE_PREFIX),
+    );
+    const artifactCopies = prefixedArtifacts.map((file) => ({ source: file, destination: file }));
+    if (files.includes(COVER_THUMBNAIL_FILE_NAME)) {
+      artifactCopies.push({ source: COVER_THUMBNAIL_FILE_NAME, destination: COVER_THUMBNAIL_FILE_NAME });
+    }
+    if (!isCustomBookCoverFileName(coverFile) && !isExtractedBookCoverFileName(coverFile)) {
+      artifactCopies.push({
+        source: coverFile,
+        destination: `${source === 'custom' ? COVER_CUSTOM_FILE_PREFIX : COVER_EXTRACTED_FILE_PREFIX}${imageExt(coverBytes)}`,
+      });
+    }
+    for (const artifact of artifactCopies) {
+      await this.linkOrCopy(join(root, artifact.source), join(slotDir, artifact.destination));
+    }
+
+    const dimensions = await this.measure(coverBytes);
+    const { mtime } = await stat(join(root, coverFile));
+    await this.repository.importSlotWithoutStamp(bookId, medium, {
+      source,
+      origin: 'legacy',
+      width: dimensions.width,
+      height: dimensions.height,
+      updatedAt: context.coverUpdatedAt ?? mtime,
+      dormantSince: null,
+    });
+    await Promise.all(rootArtifacts.map((file) => rm(join(root, file), { force: true })));
+    await this.repository.copyCoverLockToAudio(bookId);
+    if (options.emit !== false) this.events.emitChanged({ bookIds: [bookId], libraryId: context.libraryId });
+    return { converted: true, libraryId: context.libraryId };
+  }
+
+  async removeBrokenSlots(bookId: number): Promise<{ hadSlots: boolean; removed: number }> {
+    let context = await this.requireContext(bookId);
+    if (context.slots.length === 0) return { hadSlots: false, removed: 0 };
+    let removed = 0;
+    for (const slot of context.slots) {
+      const medium = slot.medium as CoverMedium;
+      if (await this.resolveSlotArtifact(bookId, medium, 'cover')) continue;
+      await this.repository.applySlotMutation(
+        bookId,
+        medium,
+        context.media,
+        { kind: 'delete' },
+        {
+          bumpBook: true,
+          servedBytesChanged: true,
+          updatedAt: new Date(),
+        },
+      );
+      removed++;
+      context = (await this.repository.findContext(bookId)) ?? context;
+    }
+    if (removed > 0) this.events.emitChanged({ bookIds: [bookId], libraryId: context.libraryId });
+    return { hadSlots: true, removed };
+  }
+
+  private async convertedContext(bookId: number): Promise<BookCoverContext> {
+    return this.ensureConverted(await this.requireContext(bookId));
+  }
+
+  /**
+   * Root cover files are never served, so a book stage A has not reached yet, or one whose covers
+   * came back from a restore, is converted before anything reads or writes its slots. A write that
+   * skipped this would create the first slot row and strand the root cover for good.
+   */
+  private async ensureConverted(context: BookCoverContext): Promise<BookCoverContext> {
+    if (context.slots.length > 0 || !(await this.hasLegacyArtifacts(context.bookId))) return context;
+    await this.convertLegacy(context.bookId, { emit: false });
+    return this.requireContext(context.bookId);
+  }
+
+  /** A read that cannot convert serves no cover rather than failing the request. */
+  private async convertOnRead(context: BookCoverContext): Promise<BookCoverContext> {
+    const startedAt = Date.now();
+    try {
+      return await this.ensureConverted(context);
+    } catch (error) {
+      const errorClass = error instanceof Error ? error.name : 'Error';
+      const message = sanitizeLogValue(error instanceof Error ? error.message : String(error));
+      this.logger.warn(
+        `[cover.legacy_convert] [fail] bookId=${context.bookId} durationMs=${Date.now() - startedAt} errorClass=${errorClass} error="${message}" - legacy cover conversion on read failed`,
+      );
+      return context;
+    }
+  }
+
+  private async hasLegacyArtifacts(bookId: number): Promise<boolean> {
+    const root = bookCoverDirPath(this.appDataPath, bookId);
+    if (findPreferredBookCoverFileName(await this.readDirIfExists(root))) return true;
+    for (const medium of COVER_MEDIA) {
+      if (findPreferredBookCoverFileName(await this.readDirIfExists(bookCoverSlotDirPath(this.appDataPath, bookId, medium)))) return true;
+    }
+    return false;
+  }
+
+  private canFill(slot: BookCoverSlotRow, replaceOrigins: readonly BookCoverOrigin[]): boolean {
+    return slot.source === 'extracted' && slot.dormantSince === null && replaceOrigins.includes(slot.origin as BookCoverOrigin);
+  }
+
+  private async servesBytes(dir: string, bytes: Buffer): Promise<boolean> {
+    const files = await this.readDirIfExists(dir);
+    const served = findPreferredBookCoverFileName(files);
+    if (!served || !isExtractedBookCoverFileName(served)) return false;
+    try {
+      return (await readFile(join(dir, served))).equals(bytes);
+    } catch {
+      return false;
+    }
+  }
+
+  private rowValues(slot: BookCoverSlotRow): Omit<BookCoverSlotRow, 'bookId' | 'medium'> {
+    return {
+      source: slot.source,
+      origin: slot.origin,
+      width: slot.width,
+      height: slot.height,
+      updatedAt: slot.updatedAt,
+      dormantSince: slot.dormantSince,
+    };
+  }
+
+  private withMedium(media: CoverMedia, medium: CoverMedium, present: boolean): CoverMedia {
+    return medium === 'ebook' ? { ...media, hasEbook: present } : { ...media, hasAudio: present };
+  }
+
+  private primaryMedium(context: BookCoverContext): CoverMedium {
+    const primary = context.files.find((file) => file.id === context.primaryFileId) ?? context.files.find((file) => this.isContent(file.role));
+    return primary?.format ? this.formatMedium(primary.format) : 'ebook';
+  }
+
+  private isContent(role: string): boolean {
+    return role === 'content' || role === 'primary';
+  }
+
+  private isAudioFile(format: string | null): boolean {
+    return format !== null && this.formatMedium(format) === 'audio';
+  }
+
+  private emitChanged(context: Pick<BookCoverContext, 'bookId' | 'libraryId'>, backfill: boolean | undefined): void {
+    if (backfill === true) return;
+    this.events.emitChanged({ bookIds: [context.bookId], libraryId: context.libraryId });
+  }
+
+  private async requireContext(bookId: number): Promise<BookCoverContext> {
+    const context = await this.repository.findContext(bookId);
+    if (!context) throw new NotFoundException(`Book ${bookId} not found`);
+    return context;
+  }
+
+  private async restoreSlotRows(context: BookCoverContext): Promise<boolean> {
+    let restored = false;
+    for (const medium of ['ebook', 'audio'] as const) {
+      const dir = bookCoverSlotDirPath(this.appDataPath, context.bookId, medium);
+      const files = await this.readDirIfExists(dir);
+      const cover = findPreferredBookCoverFileName(files);
+      if (!cover) continue;
+      const coverBytes = await readFile(join(dir, cover));
+      const dimensions = await this.measure(coverBytes);
+      const { mtime } = await stat(join(dir, cover));
+      await this.repository.importSlotWithoutStamp(context.bookId, medium, {
+        source: isCustomBookCoverFileName(cover) || context.coverSource === 'custom' ? 'custom' : 'extracted',
+        origin: 'legacy',
+        width: dimensions.width,
+        height: dimensions.height,
+        updatedAt: context.coverUpdatedAt ?? mtime,
+        dormantSince: this.mediumIsActive(medium, context.media) ? null : new Date(),
+      });
+      restored = true;
+    }
+    return restored;
+  }
+
+  private async legacyMedium(context: BookCoverContext, bytes: Buffer): Promise<CoverMedium> {
+    if (context.media.hasEbook && !context.media.hasAudio) return 'ebook';
+    if (context.media.hasAudio && !context.media.hasEbook) return 'audio';
+    const dimensions = await this.measure(bytes);
+    const shape = classifyCoverShape(dimensions.width, dimensions.height);
+    if (shape === 'square') return 'audio';
+    if (shape === 'portrait') return 'ebook';
+    const primary = context.files.find((file) => file.id === context.primaryFileId) ?? context.files[0];
+    return primary?.format ? this.formatMedium(primary.format) : 'ebook';
+  }
+
+  private formatMedium(format: string): CoverMedium {
+    return isAudioFormat(format.toLowerCase()) ? 'audio' : 'ebook';
+  }
+
+  private async linkOrCopy(source: string, destination: string): Promise<void> {
+    try {
+      await link(source, destination);
+    } catch {
+      await copyFile(source, destination);
+    }
+  }
+
+  private resolutionOrder(context: BookCoverContext, requested: CoverMedium | undefined, strict: boolean): CoverMedium[] {
+    if (requested) return strict ? [requested] : [requested, requested === 'ebook' ? 'audio' : 'ebook'];
+    const face = this.faceMedium(context);
+    return [face, face === 'ebook' ? 'audio' : 'ebook'];
+  }
+
+  private faceMedium(context: Pick<BookCoverContext, 'coverAspectRatio'>): CoverMedium {
+    return context.coverAspectRatio === '1/1' ? 'audio' : 'ebook';
+  }
+
+  private mediumIsActive(medium: CoverMedium, media: CoverMedia): boolean {
+    return medium === 'ebook' ? media.hasEbook : media.hasAudio;
+  }
+
+  private isLocked(context: BookCoverContext, medium: CoverMedium): boolean {
+    return context.lockedFields.includes(medium === 'ebook' ? 'cover' : 'audioCover');
+  }
+
+  private slotFor(context: BookCoverContext, medium: CoverMedium): BookCoverSlotRow | undefined {
+    return context.slots.find((slot) => slot.medium === medium);
+  }
+
+  private toSlotDto(slot: BookCoverSlotRow | undefined): BookCoverSlot | null {
+    if (!slot) return null;
+    return {
+      source: slot.source as BookCoverSource,
+      updatedAt: slot.updatedAt.toISOString(),
+      width: slot.width,
+      height: slot.height,
+    };
+  }
+
+  private async resolveSlotArtifact(bookId: number, medium: CoverMedium, variant: CoverVariant): Promise<string | null> {
+    const dir = bookCoverSlotDirPath(this.appDataPath, bookId, medium);
+    if (variant === 'thumbnail') {
+      const thumbnailPath = bookCoverSlotThumbnailPath(this.appDataPath, bookId, medium);
+      if (await this.exists(thumbnailPath)) return thumbnailPath;
+      const key = `${bookId}:${medium}`;
+      const existing = this.thumbnailRepairs.get(key);
+      if (existing) return existing;
+      const repair = this.withThumbnailRepairSlot(() => this.repairThumbnail(bookId, medium, dir, thumbnailPath));
+      this.thumbnailRepairs.set(key, repair);
+      try {
+        return await repair;
+      } finally {
+        if (this.thumbnailRepairs.get(key) === repair) this.thumbnailRepairs.delete(key);
+      }
+    }
+    const files = await this.readDirIfExists(dir);
+    const cover = findPreferredBookCoverFileName(files);
+    return cover ? join(dir, cover) : null;
+  }
+
+  /**
+   * Regenerates a thumbnail that went missing beside an intact cover (issue #1475). Resolves to
+   * null rather than throwing, so a cover sharp cannot read stays a placeholder in the grid instead
+   * of failing the request.
+   */
+  private async repairThumbnail(bookId: number, medium: CoverMedium, dir: string, thumbnailPath: string): Promise<string | null> {
+    const startedAt = Date.now();
+    try {
+      const cover = findPreferredBookCoverFileName(await this.readDirIfExists(dir));
+      if (!cover) return null;
+      const thumbnail = await generateThumbnail(await readFile(join(dir, cover)));
+      await this.publishRepairedThumbnail(dir, thumbnailPath, thumbnail);
+      this.logger.log(
+        `[cover.thumbnail_repair] [end] bookId=${bookId} medium=${medium} durationMs=${Date.now() - startedAt} source="${sanitizeLogValue(cover)}" - thumbnail repair completed`,
+      );
+      return thumbnailPath;
+    } catch (error) {
+      const errorClass = error instanceof Error ? error.name : 'Error';
+      const message = sanitizeLogValue(error instanceof Error ? error.message : String(error));
+      this.logger.warn(
+        `[cover.thumbnail_repair] [fail] bookId=${bookId} medium=${medium} durationMs=${Date.now() - startedAt} errorClass=${errorClass} error="${message}" - thumbnail repair failed`,
+      );
+      return null;
+    }
+  }
+
+  /**
+   * Publishes from a fully written temporary file, so an interrupted write never leaves a truncated
+   * thumbnail at the served path. A hard link fails when the path already exists, which leaves a
+   * cover write that landed first in possession of its own thumbnail. Mounts without hard links fall
+   * back to a rename, still atomic, that only loses that exclusive create.
+   */
+  private async publishRepairedThumbnail(dir: string, thumbnailPath: string, bytes: Buffer): Promise<void> {
+    const tempPath = join(dir, `.thumbnail-repair-${randomUUID()}.tmp`);
+    try {
+      await writeFile(tempPath, bytes);
+      try {
+        await link(tempPath, thumbnailPath);
+        return;
+      } catch (error) {
+        if ((error as NodeJS.ErrnoException | undefined)?.code === 'EEXIST') return;
+      }
+      if (await this.exists(thumbnailPath)) return;
+      await rename(tempPath, thumbnailPath);
+    } finally {
+      await rm(tempPath, { force: true }).catch(() => undefined);
+    }
+  }
+
+  private async withThumbnailRepairSlot<T>(operation: () => Promise<T>): Promise<T> {
+    if (this.activeThumbnailRepairs < THUMBNAIL_REPAIR_CONCURRENCY) {
+      this.activeThumbnailRepairs++;
+    } else {
+      await new Promise<void>((resolve) => this.thumbnailRepairWaiters.push(resolve));
+    }
+    try {
+      return await operation();
+    } finally {
+      const next = this.thumbnailRepairWaiters.shift();
+      if (next) next();
+      else this.activeThumbnailRepairs--;
+    }
+  }
+
+  private async replaceCoverFile(dir: string, prefix: string, bytes: Buffer): Promise<void> {
+    const ext = imageExt(bytes);
+    const finalPath = join(dir, `${prefix}${ext}`);
+    const tempPath = join(dir, `.${prefix}${randomUUID()}.${ext}.tmp`);
+    try {
+      await writeFile(tempPath, bytes);
+      await rename(tempPath, finalPath);
+      await this.deleteFilesByPrefix(dir, prefix, basename(finalPath));
+    } finally {
+      await rm(tempPath, { force: true }).catch(() => undefined);
+    }
+  }
+
+  private async writeThumbnailAtomically(dir: string, bytes: Buffer): Promise<void> {
+    const thumbnail = await generateThumbnail(bytes);
+    await this.writeThumbnailBytesAtomically(dir, thumbnail);
+  }
+
+  private async writeThumbnailBytesAtomically(dir: string, thumbnail: Buffer): Promise<void> {
+    const tempPath = join(dir, `.thumbnail-${randomUUID()}.tmp`);
+    try {
+      await writeFile(tempPath, thumbnail);
+      await rename(tempPath, join(dir, COVER_THUMBNAIL_FILE_NAME));
+    } finally {
+      await rm(tempPath, { force: true }).catch(() => undefined);
+    }
+  }
+
+  private async replaceServedArtifacts(dir: string, prefix: string, coverBytes: Buffer): Promise<void> {
+    const thumbnail = await generateThumbnail(coverBytes);
+    const ext = imageExt(coverBytes);
+    const finalCoverPath = join(dir, `${prefix}${ext}`);
+    const tempId = randomUUID();
+    const tempCoverPath = join(dir, `.${prefix}${tempId}.${ext}.tmp`);
+    const tempThumbnailPath = join(dir, `.thumbnail-${tempId}.tmp`);
+    try {
+      await writeFile(tempCoverPath, coverBytes);
+      await writeFile(tempThumbnailPath, thumbnail);
+      await rename(tempThumbnailPath, join(dir, COVER_THUMBNAIL_FILE_NAME));
+      await rename(tempCoverPath, finalCoverPath);
+      await this.deleteFilesByPrefix(dir, prefix, basename(finalCoverPath));
+    } finally {
+      await Promise.all([rm(tempCoverPath, { force: true }).catch(() => undefined), rm(tempThumbnailPath, { force: true }).catch(() => undefined)]);
+    }
+  }
+
+  private async measure(bytes: Buffer): Promise<{ width: number | null; height: number | null }> {
+    try {
+      const metadata = await sharp(bytes, { failOn: 'none' }).metadata();
+      return { width: metadata.width ?? null, height: metadata.height ?? null };
+    } catch {
+      return { width: null, height: null };
+    }
+  }
+
+  private async deleteFilesByPrefix(dir: string, prefix: string, except?: string): Promise<void> {
+    const files = await this.readDirIfExists(dir);
+    await Promise.all(files.filter((file) => file.startsWith(prefix) && file !== except).map((file) => rm(join(dir, file), { force: true })));
+  }
+
+  private async readDirIfExists(dir: string): Promise<string[]> {
+    try {
+      return await readdir(dir);
+    } catch (error) {
+      const code = (error as NodeJS.ErrnoException | undefined)?.code;
+      if (code === 'ENOENT' || code === 'ENOTDIR') return [];
+      throw error;
+    }
+  }
+
+  private async exists(path: string): Promise<boolean> {
+    try {
+      await access(path);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+}
diff --git a/server/src/modules/book-cover-store/cover-shape.test.ts b/server/src/modules/book-cover-store/cover-shape.test.ts
new file mode 100644
index 000000000..4c36acc9e
--- /dev/null
+++ b/server/src/modules/book-cover-store/cover-shape.test.ts
@@ -0,0 +1,71 @@
+import { assignFolderImages, classifyCoverShape, type FolderImageCandidate } from './cover-shape';
+
+function image(name: string, width: number, height: number): FolderImageCandidate {
+  return { path: `/book/${name}`, name, width, height };
+}
+
+const bothMedia = { bothMedia: true, squareOnlyAudio: false, primaryMedium: 'ebook' as const };
+
+describe('classifyCoverShape', () => {
+  it.each([
+    [500, 500, 'square'],
+    [475, 500, 'square'],
+    [550, 500, 'square'],
+    [400, 600, 'portrait'],
+    [425, 500, 'portrait'],
+    // Portrait jackets padded to near-square, as Goodreads serves some, are not audiobook art.
+    [400, 430, 'ambiguous'],
+    [430, 500, 'ambiguous'],
+    [800, 500, 'ambiguous'],
+    [null, 500, 'ambiguous'],
+  ] as const)('%s x %s is %s', (width, height, shape) => {
+    expect(classifyCoverShape(width, height)).toBe(shape);
+  });
+});
+
+describe('assignFolderImages', () => {
+  it('gives a single-medium book its best-fitting image whatever the shape', () => {
+    const result = assignFolderImages([image('cover.jpg', 400, 600), image('folder.jpg', 500, 520)], ['audio'], {
+      ...bothMedia,
+      bothMedia: false,
+    });
+
+    expect(result.get('audio')?.name).toBe('folder.jpg');
+  });
+
+  it('sends square art to the audio slot and portrait art to the ebook slot', () => {
+    const result = assignFolderImages([image('cover.jpg', 400, 600), image('folder.jpg', 500, 500)], ['ebook', 'audio'], bothMedia);
+
+    expect(result.get('ebook')?.name).toBe('cover.jpg');
+    expect(result.get('audio')?.name).toBe('folder.jpg');
+  });
+
+  it('never crosses shapes on a book with both media', () => {
+    expect(assignFolderImages([image('cover.jpg', 400, 600)], ['audio'], bothMedia).size).toBe(0);
+    expect(assignFolderImages([image('cover.jpg', 500, 500)], ['ebook'], bothMedia).size).toBe(0);
+  });
+
+  it('gives an ambiguous image to the empty slot of the primary medium first', () => {
+    const landscape = [image('cover.jpg', 800, 500)];
+
+    expect([...assignFolderImages(landscape, ['ebook', 'audio'], bothMedia).keys()]).toEqual(['ebook']);
+    expect([...assignFolderImages(landscape, ['ebook', 'audio'], { ...bothMedia, primaryMedium: 'audio' }).keys()]).toEqual(['audio']);
+  });
+
+  it('keeps ambiguous art out of the audio slot of a read-along EPUB', () => {
+    const result = assignFolderImages([image('cover.jpg', 800, 500)], ['audio'], { ...bothMedia, squareOnlyAudio: true });
+
+    expect(result.size).toBe(0);
+  });
+
+  it('prefers the closest fit, then basename order, and never uses one image twice', () => {
+    const result = assignFolderImages(
+      [image('folder.jpg', 500, 500), image('cover.jpg', 500, 500), image('front.jpg', 520, 500), image('extra.jpg', 800, 500)],
+      ['ebook', 'audio'],
+      bothMedia,
+    );
+
+    expect(result.get('audio')?.name).toBe('cover.jpg');
+    expect(result.get('ebook')?.name).toBe('extra.jpg');
+  });
+});
diff --git a/server/src/modules/book-cover-store/cover-shape.ts b/server/src/modules/book-cover-store/cover-shape.ts
new file mode 100644
index 000000000..fed1d9ef5
--- /dev/null
+++ b/server/src/modules/book-cover-store/cover-shape.ts
@@ -0,0 +1,94 @@
+import { coverShapeFromSize, type CoverMedium } from '@bookorbit/types';
+
+const TARGET_RATIO: Record<CoverMedium, number> = { ebook: 2 / 3, audio: 1 };
+
+export type CoverShape = 'square' | 'portrait' | 'ambiguous';
+
+export function classifyCoverShape(width: number | null | undefined, height: number | null | undefined): CoverShape {
+  const shape = coverShapeFromSize(width, height);
+  return shape === 'unknown' ? 'ambiguous' : shape;
+}
+
+export type FolderImageCandidate = {
+  path: string;
+  name: string;
+  width: number;
+  height: number;
+};
+
+export type FolderImageAssignmentOptions = {
+  /** The book has both media, so an image's shape decides which slot it may fill. */
+  bothMedia: boolean;
+  /** The only audio is an EPUB's read-along, so its slot takes nothing but square art. */
+  squareOnlyAudio: boolean;
+  primaryMedium: CoverMedium;
+};
+
+/**
+ * Chooses a folder image for each slot that still needs one. With both media, square art belongs
+ * to the audio slot and portrait art to the ebook slot, and anything in between fills whichever
+ * slot is still empty, the primary file's medium first. Ties keep basename order.
+ */
+export function assignFolderImages(
+  images: readonly FolderImageCandidate[],
+  needed: readonly CoverMedium[],
+  options: FolderImageAssignmentOptions,
+): Map<CoverMedium, FolderImageCandidate> {
+  const sorted = [...images].sort((a, b) => a.name.localeCompare(b.name, undefined, { numeric: true }));
+  const assigned = new Map<CoverMedium, FolderImageCandidate>();
+  if (needed.length === 0 || sorted.length === 0) return assigned;
+
+  if (!options.bothMedia) {
+    const medium = needed[0]!;
+    const best = bestFit(sorted, medium);
+    if (best) assigned.set(medium, best);
+    return assigned;
+  }
+
+  const used = new Set<FolderImageCandidate>();
+  const take = (medium: CoverMedium, pool: FolderImageCandidate[]) => {
+    const best = bestFit(
+      pool.filter((image) => !used.has(image)),
+      medium,
+    );
+    if (!best) return;
+    assigned.set(medium, best);
+    used.add(best);
+  };
+
+  if (needed.includes('audio'))
+    take(
+      'audio',
+      sorted.filter((image) => classifyCoverShape(image.width, image.height) === 'square'),
+    );
+  if (needed.includes('ebook'))
+    take(
+      'ebook',
+      sorted.filter((image) => classifyCoverShape(image.width, image.height) === 'portrait'),
+    );
+
+  const ambiguous = sorted.filter((image) => classifyCoverShape(image.width, image.height) === 'ambiguous');
+  const order: CoverMedium[] = options.primaryMedium === 'audio' ? ['audio', 'ebook'] : ['ebook', 'audio'];
+  for (const medium of order) {
+    if (!needed.includes(medium) || assigned.has(medium)) continue;
+    if (medium === 'audio' && options.squareOnlyAudio) continue;
+    const next = ambiguous.find((image) => !used.has(image));
+    if (!next) continue;
+    assigned.set(medium, next);
+    used.add(next);
+  }
+  return assigned;
+}
+
+function bestFit(images: readonly FolderImageCandidate[], medium: CoverMedium): FolderImageCandidate | null {
+  let best: FolderImageCandidate | null = null;
+  let bestDistance = Number.POSITIVE_INFINITY;
+  for (const image of images) {
+    const distance = Math.abs(image.width / image.height - TARGET_RATIO[medium]);
+    if (distance < bestDistance) {
+      best = image;
+      bestDistance = distance;
+    }
+  }
+  return best;
+}
diff --git a/server/src/modules/book-cover-store/cover-sources.test.ts b/server/src/modules/book-cover-store/cover-sources.test.ts
new file mode 100644
index 000000000..09a1eea3a
--- /dev/null
+++ b/server/src/modules/book-cover-store/cover-sources.test.ts
@@ -0,0 +1,53 @@
+import { hasAudioFiles, selectEmbeddedCoverSources, selectFolderImages } from './cover-sources';
+
+let nextId = 1;
+function file(absolutePath: string, overrides: { role?: string; mediaOverlayAvailable?: boolean; sizeBytes?: number } = {}) {
+  return {
+    id: nextId++,
+    absolutePath,
+    format: absolutePath.split('.').pop()!,
+    role: overrides.role ?? 'content',
+    sizeBytes: overrides.sizeBytes ?? 100,
+    mediaOverlayAvailable: overrides.mediaOverlayAvailable ?? false,
+  };
+}
+
+describe('selectEmbeddedCoverSources', () => {
+  it('takes the first ebook by library priority and the first audio track by natural name order', () => {
+    const files = [file('/b/book.pdf'), file('/b/book.kepub'), file('/b/Part 10.mp3'), file('/b/Part 2.mp3'), file('/b/Part 1.mp3')];
+
+    const sources = selectEmbeddedCoverSources(files, ['kepub', 'pdf', 'mp3']);
+
+    expect(sources.ebook?.absolutePath).toBe('/b/book.kepub');
+    expect(sources.audio?.absolutePath).toBe('/b/Part 1.mp3');
+  });
+
+  it('gives a read-along EPUB no audio source, because its art is the book cover', () => {
+    const sources = selectEmbeddedCoverSources([file('/b/book.epub', { mediaOverlayAvailable: true })], ['epub']);
+
+    expect(sources.ebook?.absolutePath).toBe('/b/book.epub');
+    expect(sources.audio).toBeNull();
+  });
+
+  it('ignores folder images, sidecars and supplements', () => {
+    const sources = selectEmbeddedCoverSources(
+      [file('/b/cover.jpg', { role: 'cover' }), file('/b/metadata.opf', { role: 'metadata' }), file('/b/notes.pdf', { role: 'supplement' })],
+      ['pdf'],
+    );
+
+    expect(sources).toEqual({ ebook: null, audio: null });
+  });
+});
+
+describe('folder images', () => {
+  it('lists cover-role images in natural name order', () => {
+    const images = selectFolderImages([file('/b/folder.jpg', { role: 'cover' }), file('/b/book.epub'), file('/b/cover.png', { role: 'cover' })]);
+
+    expect(images.map((image) => image.absolutePath)).toEqual(['/b/cover.png', '/b/folder.jpg']);
+  });
+
+  it('tells real audio tracks apart from read-along audio', () => {
+    expect(hasAudioFiles([file('/b/book.epub', { mediaOverlayAvailable: true })])).toBe(false);
+    expect(hasAudioFiles([file('/b/book.m4b')])).toBe(true);
+  });
+});
diff --git a/server/src/modules/book-cover-store/cover-sources.ts b/server/src/modules/book-cover-store/cover-sources.ts
new file mode 100644
index 000000000..3592ed4cc
--- /dev/null
+++ b/server/src/modules/book-cover-store/cover-sources.ts
@@ -0,0 +1,50 @@
+import { isAudioFormat, type CoverMedium } from '@bookorbit/types';
+import { basename } from 'path';
+
+import { naturalCompare } from '../../common/utils/natural-sort.utils';
+import { selectPrimaryFile } from '../../common/utils/primary-file-selection.utils';
+
+export const FOLDER_IMAGE_FORMATS: ReadonlySet<string> = new Set(['jpg', 'jpeg', 'png', 'webp', 'gif', 'bmp']);
+
+type CoverSourceCandidate = {
+  id: number;
+  absolutePath: string;
+  format: string | null;
+  role: string;
+  sizeBytes: number | null;
+  mediaOverlayAvailable?: boolean | null;
+};
+
+function isContent(role: string): boolean {
+  return role === 'content' || role === 'primary';
+}
+
+/**
+ * The file whose embedded art fills each slot: the first ebook in the library's format priority,
+ * and the first audio track in natural name order. An EPUB's read-along audio is never an audio
+ * source, because its art is the ebook cover.
+ */
+export function selectEmbeddedCoverSources<T extends CoverSourceCandidate>(
+  files: readonly T[],
+  formatPriority: readonly string[],
+): Record<CoverMedium, T | null> {
+  const content = files.filter((file) => isContent(file.role) && file.format);
+  const ebooks = content.filter((file) => !isAudioFormat(file.format!.toLowerCase()));
+  const audio = content
+    .filter((file) => isAudioFormat(file.format!.toLowerCase()))
+    .sort((a, b) => naturalCompare(basename(a.absolutePath), basename(b.absolutePath)));
+  return {
+    ebook: selectPrimaryFile(ebooks, formatPriority, { allowZeroByteFallback: true }),
+    audio: audio[0] ?? null,
+  };
+}
+
+export function hasAudioFiles(files: readonly Pick<CoverSourceCandidate, 'format' | 'role'>[]): boolean {
+  return files.some((file) => isContent(file.role) && file.format !== null && isAudioFormat(file.format.toLowerCase()));
+}
+
+export function selectFolderImages<T extends CoverSourceCandidate>(files: readonly T[]): T[] {
+  return files
+    .filter((file) => file.role === 'cover' && file.format !== null && FOLDER_IMAGE_FORMATS.has(file.format.toLowerCase()))
+    .sort((a, b) => naturalCompare(basename(a.absolutePath), basename(b.absolutePath)));
+}
diff --git a/server/src/modules/book-dock/book-dock-finalize.service.test.ts b/server/src/modules/book-dock/book-dock-finalize.service.test.ts
index 5dacb8beb..23bec1832 100644
--- a/server/src/modules/book-dock/book-dock-finalize.service.test.ts
+++ b/server/src/modules/book-dock/book-dock-finalize.service.test.ts
@@ -77,6 +77,7 @@ function makeService() {
   const processor = {
     createUnitBookRecords: vi.fn().mockResolvedValue({ bookIds: [101], createdBookIds: [101], attachedFileIds: [] }),
     deleteUnitBookRecords: vi.fn().mockResolvedValue(undefined),
+    reconcileCoversAsync: vi.fn(),
   };
   const events = {
     on: vi.fn(),
@@ -1439,7 +1440,7 @@ describe('BookDockFinalizeService', () => {
       }),
     );
 
-    expect(metadataService.downloadAndSaveCover).toHaveBeenCalledWith('https://covers.example/1.jpg', 20);
+    expect(metadataService.downloadAndSaveCover).toHaveBeenCalledWith([{ url: 'https://covers.example/1.jpg' }], 20, 'ebook', { userChosen: true });
     expect(metadataService.saveExtractedCoverBytes).not.toHaveBeenCalled();
     expect(mockReadFile).not.toHaveBeenCalled();
   });
@@ -1603,6 +1604,27 @@ describe('BookDockFinalizeService', () => {
     expect(updateChain.set).toHaveBeenCalledWith(expect.objectContaining({ durationSeconds: 1000 }));
   });
 
+  it('applyMetadata writes the staged cover of an audiobook into the audio slot, and never into a sibling book', async () => {
+    const { service, db, metadataService } = makeService();
+    const updateChain = { set: vi.fn(), where: vi.fn().mockResolvedValue(undefined) };
+    updateChain.set.mockReturnValue(updateChain);
+    db.update.mockReturnValue(updateChain);
+    mockReadFile.mockResolvedValue(Buffer.from('square-art'));
+
+    await (service as any).applyMetadata(
+      31,
+      makeRow({ coverPath: '/tmp/cover.jpg', format: 'm4b', selectedMetadata: { title: 'T' } as BookDockMetadata }),
+    );
+    await (service as any).applyMetadata(
+      32,
+      makeRow({ coverPath: '/tmp/cover.jpg', format: 'm4b', selectedMetadata: { title: 'T' } as BookDockMetadata }),
+      false,
+    );
+
+    expect(metadataService.saveExtractedCoverBytes).toHaveBeenCalledOnce();
+    expect(metadataService.saveExtractedCoverBytes).toHaveBeenCalledWith(31, Buffer.from('square-art'), 'audio');
+  });
+
   it('applyMetadata falls back to extracted cover bytes when cover download is unavailable', async () => {
     const { service, db, metadataService } = makeService();
     metadataService.downloadAndSaveCover.mockResolvedValueOnce(false);
@@ -1622,7 +1644,7 @@ describe('BookDockFinalizeService', () => {
       }),
     );
 
-    expect(metadataService.saveExtractedCoverBytes).toHaveBeenCalledWith(21, Buffer.from('cover-bytes'));
+    expect(metadataService.saveExtractedCoverBytes).toHaveBeenCalledWith(21, Buffer.from('cover-bytes'), 'ebook');
   });
 
   describe('multi-file units', () => {
@@ -1926,6 +1948,9 @@ describe('BookDockFinalizeService', () => {
       const [, , looseFiles] = harness.processor.createUnitBookRecords.mock.calls[0];
       expect(looseFiles.map((file: { folderPath: string }) => file.folderPath)).toEqual(['/library/Dune.epub', '/library/Dune.pdf']);
       expect(applyMetadata.mock.calls.map((call: unknown[]) => call[0])).toEqual([81, 82]);
+      // The staged cover came from the primary file, so only its book gets it; reconcile fills the rest.
+      expect(applyMetadata.mock.calls.map((call: unknown[]) => call[2])).toEqual([true, false]);
+      expect(harness.processor.reconcileCoversAsync).toHaveBeenCalledWith([81, 82]);
     });
 
     /**
diff --git a/server/src/modules/book-dock/book-dock-finalize.service.ts b/server/src/modules/book-dock/book-dock-finalize.service.ts
index cb696f235..e62a6da28 100644
--- a/server/src/modules/book-dock/book-dock-finalize.service.ts
+++ b/server/src/modules/book-dock/book-dock-finalize.service.ts
@@ -407,7 +407,7 @@ export class BookDockFinalizeService implements OnModuleInit, OnApplicationBoots
         bookId = written.bookIds[0]!;
         // Several ids only in a loose-file library, where each format is its own book. They are the
         // same work, so they get the same metadata rather than one of them getting all of it.
-        for (const created of written.bookIds) await this.applyMetadata(created, row);
+        for (const created of written.bookIds) await this.applyMetadata(created, row, created === bookId);
       } catch (err) {
         // The books committed before the failure, and metadata runs against services that cannot
         // join that transaction, so the compensation is explicit: take back exactly what this unit
@@ -417,6 +417,7 @@ export class BookDockFinalizeService implements OnModuleInit, OnApplicationBoots
         throw err;
       }
 
+      this.processor.reconcileCoversAsync(written.bookIds);
       await this.cleanupBookDockRecord(row);
       existingDestinations.set(this.destinationKey(library.id, destPath), bookId);
       existingDestinations.set(this.destinationKey(library.id, persistedDestPath), bookId);
@@ -1110,20 +1111,25 @@ export class BookDockFinalizeService implements OnModuleInit, OnApplicationBoots
     });
   }
 
-  private async applyMetadata(bookId: number, row: BookDockFileRow): Promise<void> {
+  /**
+   * The staged cover was read from the unit's primary file, so it fills only that file's medium on
+   * the book that owns it. The other books of a loose-file unit get their own art from reconcile.
+   */
+  private async applyMetadata(bookId: number, row: BookDockFileRow, ownsStagedCover = true): Promise<void> {
     const meta = normalizeFinalizeMetadata(row.selectedMetadata ?? row.embeddedMetadata);
     const audio = resolveAudioFinalizeFields(row.embeddedMetadata, row.selectedMetadata);
     let selectedCoverApplied = false;
 
+    const medium = row.format && isAudioFormat(row.format) ? 'audio' : 'ebook';
     const selectedCoverUrl = meta.coverUrl;
     if (selectedCoverUrl) {
-      selectedCoverApplied = await this.metadataService.downloadAndSaveCover(selectedCoverUrl, bookId);
+      selectedCoverApplied = await this.metadataService.downloadAndSaveCover([{ url: selectedCoverUrl }], bookId, medium, { userChosen: true });
     }
 
-    if (!selectedCoverApplied && row.coverPath) {
+    if (!selectedCoverApplied && ownsStagedCover && row.coverPath) {
       try {
         const bytes = await readFile(row.coverPath);
-        await this.metadataService.saveExtractedCoverBytes(bookId, bytes);
+        await this.metadataService.saveExtractedCoverBytes(bookId, bytes, medium);
       } catch (err) {
         this.logger.warn(`Failed to copy Book Dock cover to book ${bookId}: ${err instanceof Error ? err.message : String(err)}`);
       }
diff --git a/server/src/modules/book-dock/book-dock-ingest.service.test.ts b/server/src/modules/book-dock/book-dock-ingest.service.test.ts
index 3dba08d81..c7346a58c 100644
--- a/server/src/modules/book-dock/book-dock-ingest.service.test.ts
+++ b/server/src/modules/book-dock/book-dock-ingest.service.test.ts
@@ -571,6 +571,26 @@ describe('BookDockIngestService', () => {
       expect(metadataFetchPipeline.runWithSources).toHaveBeenCalledWith(expect.objectContaining({ isAudiobook: true }), {});
     });
 
+    it('stages the audiobook cover as the cover of a docked audio file', async () => {
+      const { service, appSettings, repo, metadataFetchPipeline } = makeService();
+      appSettings.isBookDockAutoFetchEnabled.mockResolvedValue(true);
+      repo.findById.mockResolvedValue({ id: 8, fileName: 'dune.m4b', format: 'm4b', status: 'ready', embeddedMetadata: { title: 'Dune' } });
+      (metadataFetchPipeline as any).runWithSources = vi.fn().mockResolvedValue({
+        resolved: { title: 'Dune', audioCoverUrl: 'https://audible/dune.jpg' },
+        sources: { title: 'audible', audioCoverUrl: 'audible' },
+      });
+
+      await (service as any).autoFetchMetadataAsync(8);
+
+      expect(repo.update).toHaveBeenLastCalledWith(
+        8,
+        expect.objectContaining({
+          fetchedMetadata: { title: 'Dune', coverUrl: 'https://audible/dune.jpg' },
+          fetchedMetadataSources: { title: 'audible', coverUrl: 'audible' },
+        }),
+      );
+    });
+
     it('updates fetched metadata and confidence after pipeline resolution', async () => {
       const { service, appSettings, repo, metadataFetchPipeline } = makeService();
       appSettings.isBookDockAutoFetchEnabled.mockResolvedValue(true);
diff --git a/server/src/modules/book-dock/book-dock-ingest.service.ts b/server/src/modules/book-dock/book-dock-ingest.service.ts
index 6a2b79a6a..57f22c351 100644
--- a/server/src/modules/book-dock/book-dock-ingest.service.ts
+++ b/server/src/modules/book-dock/book-dock-ingest.service.ts
@@ -357,6 +357,13 @@ export class BookDockIngestService implements OnApplicationBootstrap, OnModuleDe
     this.emitChange();
     try {
       const { resolved, sources, providerIds = {} } = await this.metadataFetchPipeline.runWithSources(params, {});
+      // A dock file has one medium, so its one cover is that medium's slot.
+      if (params.isAudiobook) {
+        resolved.coverUrl = resolved.audioCoverUrl;
+        if (sources.audioCoverUrl) sources.coverUrl = sources.audioCoverUrl;
+      }
+      delete resolved.audioCoverUrl;
+      delete sources.audioCoverUrl;
       const fetched = normalizeBookDockMetadata(resolved) ?? {};
       for (const [provider, providerId] of Object.entries(providerIds)) {
         const field = BOOK_DOCK_PROVIDER_ID_FIELDS[provider as MetadataProviderKey];
diff --git a/server/src/modules/book-metadata-fetch/book-metadata-fetch-eligibility.service.test.ts b/server/src/modules/book-metadata-fetch/book-metadata-fetch-eligibility.service.test.ts
index 35b502bca..1cb09672e 100644
--- a/server/src/modules/book-metadata-fetch/book-metadata-fetch-eligibility.service.test.ts
+++ b/server/src/modules/book-metadata-fetch/book-metadata-fetch-eligibility.service.test.ts
@@ -16,6 +16,8 @@ const baseBook = (): BookEligibilityData => ({
   seriesName: 'Series',
   seriesIndex: '1',
   coverSource: 'cover.jpg',
+  hasAudioCoverMedia: false,
+  hasAudioCover: false,
   hasAuthors: true,
   hasGenres: true,
   hasNarrators: true,
@@ -150,4 +152,22 @@ describe('BookMetadataFetchEligibilityService', () => {
       expect(service.isEligible(testCase.book, config)).toBe(testCase.eligible);
     }
   });
+
+  it('counts the audiobook cover as missing only for a book whose cover media include audio', () => {
+    const config = baseConfig();
+    config.conditions.missingFields.enabled = true;
+    config.conditions.missingFields.fields = ['audioCover'];
+
+    expect(service.isEligible({ ...baseBook(), hasAudioCoverMedia: true, hasAudioCover: false }, config)).toBe(true);
+    expect(service.isEligible({ ...baseBook(), hasAudioCoverMedia: true, hasAudioCover: true }, config)).toBe(false);
+    expect(service.isEligible({ ...baseBook(), hasAudioCoverMedia: false, hasAudioCover: false }, config)).toBe(false);
+  });
+
+  it('keeps the cover trigger meaning no cover at all, so an empty audio slot alone does not queue a book', () => {
+    const config = baseConfig();
+    config.conditions.missingFields.enabled = true;
+    config.conditions.missingFields.fields = ['cover'];
+
+    expect(service.isEligible({ ...baseBook(), hasAudioCoverMedia: true, hasAudioCover: false }, config)).toBe(false);
+  });
 });
diff --git a/server/src/modules/book-metadata-fetch/book-metadata-fetch-eligibility.service.ts b/server/src/modules/book-metadata-fetch/book-metadata-fetch-eligibility.service.ts
index 8bdd4540d..c83dc2046 100644
--- a/server/src/modules/book-metadata-fetch/book-metadata-fetch-eligibility.service.ts
+++ b/server/src/modules/book-metadata-fetch/book-metadata-fetch-eligibility.service.ts
@@ -15,6 +15,9 @@ export interface BookEligibilityData {
   seriesName: string | null;
   seriesIndex: string | null;
   coverSource: string | null;
+  /** The book's cover media include audio: real audio files, or an EPUB with read-along audio. */
+  hasAudioCoverMedia: boolean;
+  hasAudioCover: boolean;
   hasAuthors: boolean;
   hasGenres: boolean;
   hasNarrators: boolean;
@@ -61,6 +64,8 @@ export class BookMetadataFetchEligibilityService {
         return book.abridged === null;
       case 'cover':
         return book.coverSource === null;
+      case 'audioCover':
+        return book.hasAudioCoverMedia && !book.hasAudioCover;
       case 'title':
         return book.title === null || book.title === '';
       case 'subtitle':
diff --git a/server/src/modules/book-metadata-fetch/book-metadata-fetch-orchestrator.service.test.ts b/server/src/modules/book-metadata-fetch/book-metadata-fetch-orchestrator.service.test.ts
index 19cf55ef0..5430fdb87 100644
--- a/server/src/modules/book-metadata-fetch/book-metadata-fetch-orchestrator.service.test.ts
+++ b/server/src/modules/book-metadata-fetch/book-metadata-fetch-orchestrator.service.test.ts
@@ -78,6 +78,9 @@ function makeService(withGateway = true) {
   const notificationService = {
     notify: vi.fn().mockResolvedValue(undefined),
   };
+  const coverStore = {
+    fetchState: vi.fn().mockResolvedValue({ media: { hasEbook: true, hasAudio: false }, filled: { ebook: false, audio: false }, locked: [] }),
+  };
 
   const service = new BookMetadataFetchOrchestratorService(
     queueRepo as never,
@@ -92,6 +95,7 @@ function makeService(withGateway = true) {
     session,
     throttleTracker as never,
     notificationService as never,
+    coverStore as never,
     withGateway ? (gateway as never) : undefined,
   );
 
@@ -110,6 +114,7 @@ function makeService(withGateway = true) {
     throttleTracker,
     gateway,
     notificationService,
+    coverStore,
   };
 }
 
@@ -222,6 +227,47 @@ describe('BookMetadataFetchOrchestratorService', () => {
     expect(session.getSnapshot().sessionDone).toBe(1);
   });
 
+  it('processOne marks queue row as done when the book disappears before its cover state is read', async () => {
+    const { service, queueRepo, bookReadService, pipeline, session, coverStore } = makeService();
+    session.addToTotal(1);
+    bookReadService.findById.mockResolvedValue({
+      book: { books: { libraryId: 2, status: 'present' }, book_metadata: { title: 'Gone' } },
+      authorRows: [],
+      genreRows: [],
+      narratorRows: [],
+      communityRatingRows: [],
+    });
+    coverStore.fetchState.mockResolvedValue(null);
+
+    await (service as any).processOne(16, 'Gone');
+
+    expect(queueRepo.markDone).toHaveBeenCalledWith(16);
+    expect(queueRepo.markFailed).not.toHaveBeenCalled();
+    expect(pipeline.runWithSources).not.toHaveBeenCalled();
+    expect(session.getSnapshot().sessionDone).toBe(1);
+  });
+
+  it('processOne passes the cover slot state from the store to the pipeline', async () => {
+    const { service, bookReadService, pipeline, coverStore } = makeService();
+    bookReadService.findById.mockResolvedValue({
+      book: { books: { libraryId: 2, status: 'present' }, book_metadata: { title: 'Both media' } },
+      authorRows: [],
+      genreRows: [],
+      narratorRows: [],
+      communityRatingRows: [],
+    });
+    coverStore.fetchState.mockResolvedValue({ media: { hasEbook: true, hasAudio: true }, filled: { ebook: false, audio: true }, locked: ['ebook'] });
+    vi.spyOn(service as any, 'persistResolved').mockResolvedValue(undefined);
+
+    await (service as any).processOne(17, 'Both media');
+
+    expect(coverStore.fetchState).toHaveBeenCalledWith(17);
+    expect(pipeline.runWithSources).toHaveBeenCalledWith(expect.any(Object), expect.objectContaining({ cover: null, audioCover: true }), 2, {
+      coverMedia: { hasEbook: true, hasAudio: true },
+      lockedCoverSlots: ['ebook'],
+    });
+  });
+
   it('processOne persists resolved metadata and handles provider ids + related entities', async () => {
     const { service, bookMetadataLockService, bookReadService, metadataService } = makeService();
     bookMetadataLockService.filterResolvedMetadata.mockResolvedValue({
@@ -281,7 +327,7 @@ describe('BookMetadataFetchOrchestratorService', () => {
     expect(metadataService.replaceGenres).toHaveBeenCalledWith(88, ['Genre A']);
     expect(metadataService.replaceNarrators).toHaveBeenCalledWith(88, [{ name: 'Narrator A', sortName: null }]);
     expect(metadataService.upsertComicMetadata).toHaveBeenCalledWith(88, { issueNumber: '12' });
-    expect(metadataService.downloadAndSaveCover).toHaveBeenCalledWith('https://cover', 88);
+    expect(metadataService.downloadAndSaveCover).toHaveBeenCalledWith([{ url: 'https://cover' }], 88, 'ebook');
   });
 
   it('processOne marks failures with extracted http status', async () => {
@@ -465,7 +511,7 @@ describe('BookMetadataFetchOrchestratorService', () => {
         comicMetadata: { issueNumber: '28', volumeName: null },
       }),
       2,
-      { preserveExisting: true },
+      expect.objectContaining({ preserveExisting: true }),
     );
   });
 
@@ -644,6 +690,7 @@ describe('BookMetadataFetchOrchestratorService', () => {
       }),
       expect.any(Object),
       5,
+      expect.any(Object),
     );
   });
 
diff --git a/server/src/modules/book-metadata-fetch/book-metadata-fetch-orchestrator.service.ts b/server/src/modules/book-metadata-fetch/book-metadata-fetch-orchestrator.service.ts
index e9b4dadf5..a45cfda5d 100644
--- a/server/src/modules/book-metadata-fetch/book-metadata-fetch-orchestrator.service.ts
+++ b/server/src/modules/book-metadata-fetch/book-metadata-fetch-orchestrator.service.ts
@@ -2,7 +2,8 @@ import { Injectable, Logger, OnApplicationBootstrap, OnModuleDestroy, Optional }
 import type { BookMetadataFetchReason } from '@bookorbit/types';
 import { MetadataProviderKey, NotificationType, Permission, parseSeriesIndex } from '@bookorbit/types';
 import { NotificationService } from '../notification/notification.service';
-import { resolveIsAudiobook } from '../../common/utils/book-media.utils';
+import { coverFetchInputs, resolveIsAudiobook, type CoverFetchState } from '../../common/utils/book-media.utils';
+import { BookCoverStore } from '../book-cover-store/book-cover-store.service';
 import { sanitizeLogValue } from '../../common/utils/log-sanitize.utils';
 import { normalizePublishedDate, publishedYearFromDateKey } from '../../common/utils/published-date.utils';
 import { BookReadService } from '../book/book-read.service';
@@ -46,6 +47,7 @@ export class BookMetadataFetchOrchestratorService implements OnApplicationBootst
     private readonly session: BookMetadataFetchSessionService,
     private readonly throttleTracker: ProviderThrottleTracker,
     private readonly notificationService: NotificationService,
+    private readonly coverStore: BookCoverStore,
     @Optional() private readonly gateway?: BookMetadataFetchGateway,
   ) {}
 
@@ -168,13 +170,7 @@ export class BookMetadataFetchOrchestratorService implements OnApplicationBootst
     try {
       const found = await this.bookReadService.findById(bookId);
       if (!found) {
-        await this.queueRepo.markDone(bookId);
-        this.session.incrementDone();
-        this.session.setCurrentItemName(null);
-        this.logger.debug(
-          `[book.metadata_fetch] [end] bookId=${bookId} durationMs=${Date.now() - startedAt} outcome=book_missing - metadata fetch completed`,
-        );
-        await this.emitStatus();
+        await this.completeMissingBook(bookId, startedAt);
         return;
       }
 
@@ -203,10 +199,15 @@ export class BookMetadataFetchOrchestratorService implements OnApplicationBootst
         return;
       }
 
+      const coverState = await this.coverStore.fetchState(bookId);
+      if (!coverState) {
+        await this.completeMissingBook(bookId, startedAt);
+        return;
+      }
       const preserveExisting = reason === 'event_import';
       if (preserveExisting) {
         const config = await this.configService.getEffectiveConfig(libraryId);
-        if (!config.enabled || !config.triggerOnImport || !this.eligibilityService.isEligible(this.toEligibilityData(found), config)) {
+        if (!config.enabled || !config.triggerOnImport || !this.eligibilityService.isEligible(this.toEligibilityData(found, coverState), config)) {
           await this.queueRepo.markDone(bookId);
           this.session.incrementDone();
           this.session.setCurrentItemName(null);
@@ -243,21 +244,23 @@ export class BookMetadataFetchOrchestratorService implements OnApplicationBootst
         seriesName: meta?.seriesName,
         seriesIndex: meta?.seriesIndex,
         genres: genreRows.map((g) => g.name),
-        cover: meta?.coverSource,
         duration: meta?.durationSeconds ?? undefined,
         abridged: meta?.abridged ?? undefined,
         narrators: narratorRows.map((n) => n.name),
         chapters: meta?.chapters,
         hardcoverEditionId: meta?.hardcoverEditionId,
       };
+      const coverInputs = coverFetchInputs(coverState);
+      Object.assign(existingFields, coverInputs.existing);
 
       if (preserveExisting) {
         existingFields.comicMetadata = await this.comicMetadataRepository.findByBookId(bookId);
       }
 
-      const { resolved, providerIds } = preserveExisting
-        ? await this.pipeline.runWithSources(searchParams, existingFields, libraryId, { preserveExisting: true })
-        : await this.pipeline.runWithSources(searchParams, existingFields, libraryId);
+      const { resolved, providerIds } = await this.pipeline.runWithSources(searchParams, existingFields, libraryId, {
+        ...coverInputs.options,
+        ...(preserveExisting ? { preserveExisting: true } : {}),
+      });
 
       await this.persistResolved(bookId, resolved, providerIds, authorRows, genreRows, narratorRows);
 
@@ -405,11 +408,28 @@ export class BookMetadataFetchOrchestratorService implements OnApplicationBootst
     }
 
     if (filteredResolved.coverUrl) {
-      await this.metadataService.downloadAndSaveCover(filteredResolved.coverUrl, bookId);
+      await this.metadataService.downloadAndSaveCover(filteredResolved.coverChoices ?? [{ url: filteredResolved.coverUrl }], bookId, 'ebook');
+    }
+    if (filteredResolved.audioCoverUrl) {
+      await this.metadataService.downloadAndSaveCover(
+        filteredResolved.audioCoverChoices ?? [{ url: filteredResolved.audioCoverUrl }],
+        bookId,
+        'audio',
+      );
     }
   }
 
-  private toEligibilityData(found: BookReadResult) {
+  private async completeMissingBook(bookId: number, startedAt: number): Promise<void> {
+    await this.queueRepo.markDone(bookId);
+    this.session.incrementDone();
+    this.session.setCurrentItemName(null);
+    this.logger.debug(
+      `[book.metadata_fetch] [end] bookId=${bookId} durationMs=${Date.now() - startedAt} outcome=book_missing - metadata fetch completed`,
+    );
+    await this.emitStatus();
+  }
+
+  private toEligibilityData(found: BookReadResult, coverState: CoverFetchState) {
     const { book, authorRows, genreRows, narratorRows, communityRatingRows } = found;
     const meta = book.book_metadata;
     return {
@@ -426,6 +446,8 @@ export class BookMetadataFetchOrchestratorService implements OnApplicationBootst
       seriesName: meta?.seriesName ?? null,
       seriesIndex: meta?.seriesIndex ?? null,
       coverSource: meta?.coverSource ?? null,
+      hasAudioCoverMedia: coverState.media.hasAudio,
+      hasAudioCover: coverState.filled.audio,
       hasAuthors: authorRows.length > 0,
       hasGenres: genreRows.length > 0,
       hasNarrators: narratorRows.length > 0,
diff --git a/server/src/modules/book-metadata-fetch/book-metadata-fetch-queue.repository.test.ts b/server/src/modules/book-metadata-fetch/book-metadata-fetch-queue.repository.test.ts
index bcf40704e..ad8465483 100644
--- a/server/src/modules/book-metadata-fetch/book-metadata-fetch-queue.repository.test.ts
+++ b/server/src/modules/book-metadata-fetch/book-metadata-fetch-queue.repository.test.ts
@@ -5,12 +5,14 @@ vi.mock('drizzle-orm', () => {
     chunks,
     separator,
   }));
+  (sqlFn as typeof sqlFn & { identifier: ReturnType<typeof vi.fn> }).identifier = vi.fn((value: string) => ({ op: 'sql.identifier', value }));
 
   return {
     and: vi.fn((...clauses: unknown[]) => ({ op: 'and', clauses })),
     asc: vi.fn((value: unknown) => ({ op: 'asc', value })),
     count: vi.fn(() => ({ op: 'count' })),
     eq: vi.fn((left: unknown, right: unknown) => ({ op: 'eq', left, right })),
+    getTableName: vi.fn(() => 'table'),
     inArray: vi.fn((left: unknown, values: unknown[]) => ({ op: 'inArray', left, values })),
     isNull: vi.fn((value: unknown) => ({ op: 'isNull', value })),
     max: vi.fn((value: unknown) => ({ op: 'max', value })),
@@ -22,7 +24,7 @@ vi.mock('drizzle-orm', () => {
 import { and, eq, inArray, sql } from 'drizzle-orm';
 import type { BookMetadataFetchConfig } from '@bookorbit/types';
 
-import { bookMetadata, bookMetadataFetchQueue, bookNarrators, books } from '../../db/schema';
+import { bookCovers, bookFiles, bookMetadata, bookMetadataFetchQueue, bookNarrators, books } from '../../db/schema';
 import { BookMetadataFetchQueueRepository } from './book-metadata-fetch-queue.repository';
 
 describe('BookMetadataFetchQueueRepository', () => {
@@ -139,6 +141,21 @@ describe('BookMetadataFetchQueueRepository', () => {
     expect(hasAbridgedClause).toBe(true);
   });
 
+  it('fetchEligibleBookIds finds books whose cover media include audio and whose audio slot is empty', async () => {
+    const { db, selectBuilder } = makeDb();
+    selectBuilder.where.mockResolvedValueOnce([{ bookId: 9 }]);
+    const repo = new BookMetadataFetchQueueRepository(db as never);
+    const config = baseConfig();
+    config.conditions.missingFields.enabled = true;
+    config.conditions.missingFields.fields = ['audioCover'];
+
+    await expect(repo.fetchEligibleBookIds(config)).resolves.toEqual([9]);
+
+    const sqlCalls = vi.mocked(sql).mock.calls;
+    expect(sqlCalls.some((call) => call.slice(1).includes(bookCovers) && call.slice(1).includes('audio'))).toBe(true);
+    expect(sqlCalls.some((call) => call.slice(1).includes(bookFiles.mediaOverlayAvailable))).toBe(true);
+  });
+
   it('returns empty results without touching the database when no conditions are enabled', async () => {
     const { db } = makeDb();
     const repo = new BookMetadataFetchQueueRepository(db as never);
diff --git a/server/src/modules/book-metadata-fetch/book-metadata-fetch-queue.repository.ts b/server/src/modules/book-metadata-fetch/book-metadata-fetch-queue.repository.ts
index 073a81615..6509924b5 100644
--- a/server/src/modules/book-metadata-fetch/book-metadata-fetch-queue.repository.ts
+++ b/server/src/modules/book-metadata-fetch/book-metadata-fetch-queue.repository.ts
@@ -11,6 +11,7 @@ import { and, asc, count, eq, inArray, isNull, max, or, sql } from 'drizzle-orm'
 import { NodePgDatabase } from 'drizzle-orm/node-postgres';
 
 import { DB } from '../../db';
+import { activeCoverSlotSql, coverMediaSql } from '../book-cover-store/book-cover-store.repository';
 import * as schema from '../../db/schema';
 import {
   bookAuthors,
@@ -363,6 +364,10 @@ export class BookMetadataFetchQueueRepository {
         return sql`${bookMetadata.abridged} IS NULL`;
       case 'cover':
         return sql`${bookMetadata.coverSource} IS NULL`;
+      case 'audioCover': {
+        const { hasAudio } = coverMediaSql(bookMetadata.bookId);
+        return sql`(${hasAudio} AND NOT ${activeCoverSlotSql(bookMetadata.bookId, 'audio')})`;
+      }
       case 'title':
         return sql`(${bookMetadata.title} IS NULL OR ${bookMetadata.title} = '')`;
       case 'subtitle':
diff --git a/server/src/modules/book-metadata-fetch/book-metadata-fetch.module.ts b/server/src/modules/book-metadata-fetch/book-metadata-fetch.module.ts
index a3b5fb18b..3e94e43cf 100644
--- a/server/src/modules/book-metadata-fetch/book-metadata-fetch.module.ts
+++ b/server/src/modules/book-metadata-fetch/book-metadata-fetch.module.ts
@@ -5,6 +5,7 @@ import type { StringValue } from 'ms';
 
 import { AuthModule } from '../auth/auth.module';
 import { BookModule } from '../book/book.module';
+import { BookCoverStoreModule } from '../book-cover-store/book-cover-store.module';
 import { BookMetadataLockModule } from '../book-metadata-lock/book-metadata-lock.module';
 import { MetadataFetchModule } from '../metadata-fetch/metadata-fetch.module';
 import { MetadataModule } from '../metadata/metadata.module';
@@ -21,6 +22,7 @@ import { BookMetadataFetchSessionService } from './book-metadata-fetch-session.s
 @Module({
   imports: [
     forwardRef(() => BookModule),
+    BookCoverStoreModule,
     BookMetadataLockModule,
     MetadataModule,
     MetadataFetchModule,
diff --git a/server/src/modules/book-metadata-lock/book-metadata-lock.service.test.ts b/server/src/modules/book-metadata-lock/book-metadata-lock.service.test.ts
index 059a52363..c0b4760b0 100644
--- a/server/src/modules/book-metadata-lock/book-metadata-lock.service.test.ts
+++ b/server/src/modules/book-metadata-lock/book-metadata-lock.service.test.ts
@@ -255,4 +255,23 @@ describe('BookMetadataLockService', () => {
     });
     expect(result.skippedFields).toEqual(['authors', 'hardcoverEditionId', 'openLibraryId', 'librofmId', 'comicVolumeName', 'cover']);
   });
+
+  it('filters each cover slot by its own lock, carrying the fallback choices along', async () => {
+    const { service } = makeService(['audioCover']);
+    const coverChoices = [{ url: 'https://example.com/book.jpg', provider: MetadataProviderKey.AMAZON, fit: 'match' as const }];
+
+    const result = await service.filterResolvedMetadata(
+      12,
+      {
+        coverUrl: 'https://example.com/book.jpg',
+        coverChoices,
+        audioCoverUrl: 'https://example.com/audio.jpg',
+        audioCoverChoices: [{ url: 'https://example.com/audio.jpg', provider: MetadataProviderKey.AUDIBLE, fit: 'match' }],
+      },
+      {},
+    );
+
+    expect(result.resolved).toEqual({ coverUrl: 'https://example.com/book.jpg', coverChoices });
+    expect(result.skippedFields).toEqual(['audioCover']);
+  });
 });
diff --git a/server/src/modules/book-metadata-lock/book-metadata-lock.service.ts b/server/src/modules/book-metadata-lock/book-metadata-lock.service.ts
index 0edb53772..6ceed3beb 100644
--- a/server/src/modules/book-metadata-lock/book-metadata-lock.service.ts
+++ b/server/src/modules/book-metadata-lock/book-metadata-lock.service.ts
@@ -174,7 +174,18 @@ export class BookMetadataLockService {
 
     if (resolved.coverUrl !== undefined) {
       if (lockedSet.has('cover')) skippedFields.add('cover');
-      else filteredResolved.coverUrl = resolved.coverUrl;
+      else {
+        filteredResolved.coverUrl = resolved.coverUrl;
+        if (resolved.coverChoices !== undefined) filteredResolved.coverChoices = resolved.coverChoices;
+      }
+    }
+
+    if (resolved.audioCoverUrl !== undefined) {
+      if (lockedSet.has('audioCover')) skippedFields.add('audioCover');
+      else {
+        filteredResolved.audioCoverUrl = resolved.audioCoverUrl;
+        if (resolved.audioCoverChoices !== undefined) filteredResolved.audioCoverChoices = resolved.audioCoverChoices;
+      }
     }
 
     if (resolved.comicMetadata) {
diff --git a/server/src/modules/book-move/book-move-executor.service.test.ts b/server/src/modules/book-move/book-move-executor.service.test.ts
index e08de024c..789a6e564 100644
--- a/server/src/modules/book-move/book-move-executor.service.test.ts
+++ b/server/src/modules/book-move/book-move-executor.service.test.ts
@@ -18,6 +18,7 @@ let executor: BookMoveExecutorService;
 let registry: SelfWriteRegistry;
 type ApplyMoveResult = { moved: boolean; mergedBookId: number | null };
 let applyBookMove: Mock<(input: unknown) => Promise<ApplyMoveResult>>;
+let coverStore: { removeCoverDirectory: Mock<(bookId: number) => Promise<void>> };
 
 function makeTarget(): MoveTargetLibrary {
   return {
@@ -70,7 +71,8 @@ beforeEach(async () => {
   registry = new SelfWriteRegistry();
   applyBookMove = vi.fn<(input: unknown) => Promise<ApplyMoveResult>>().mockResolvedValue({ moved: true, mergedBookId: null });
   const repo = { applyBookMove } as unknown as BookMoveRepository;
-  executor = new BookMoveExecutorService(repo, new FileLockService(), registry);
+  coverStore = { removeCoverDirectory: vi.fn<(bookId: number) => Promise<void>>().mockResolvedValue(undefined) };
+  executor = new BookMoveExecutorService(repo, new FileLockService(), registry, coverStore as never);
 });
 
 afterEach(async () => {
@@ -169,6 +171,16 @@ describe('successful move', () => {
     expect(result).toMatchObject({ status: 'merged', mergedBookId: 55 });
     expect(applyBookMove.mock.calls[0][0].mergeDuplicateBookId).toBe(55);
   });
+
+  it('removes the cover folder of the duplicate the merge deleted', async () => {
+    const plan = makePlan();
+    await writeFile(plan.files[0].from, 'x');
+    applyBookMove.mockResolvedValue({ moved: true, mergedBookId: 55 });
+
+    await executor.execute({ plan, target: makeTarget(), mergeDuplicateBookId: 55 });
+
+    expect(coverStore.removeCoverDirectory).toHaveBeenCalledWith(55);
+  });
 });
 
 describe('pre-flight checks', () => {
diff --git a/server/src/modules/book-move/book-move-executor.service.ts b/server/src/modules/book-move/book-move-executor.service.ts
index 1c9938c6c..58ad61c5e 100644
--- a/server/src/modules/book-move/book-move-executor.service.ts
+++ b/server/src/modules/book-move/book-move-executor.service.ts
@@ -3,6 +3,7 @@ import { dirname, relative } from 'path';
 
 import { SelfWriteRegistry } from '../../common/services/self-write-registry.service';
 import { sanitizeLogValue } from '../../common/utils/log-sanitize.utils';
+import { BookCoverStore } from '../book-cover-store/book-cover-store.service';
 import { FileLockService, bookOperationLockKey } from '../file-write/file-lock.service';
 import type { BookMovePlan, PlannedFileMove } from './book-move-planner.service';
 import type { BookFileMoveUpdate, MoveTargetLibrary } from './book-move.repository';
@@ -53,6 +54,7 @@ export class BookMoveExecutorService {
     private readonly moveRepo: BookMoveRepository,
     private readonly lockService: FileLockService,
     private readonly selfWriteRegistry: SelfWriteRegistry,
+    private readonly coverStore: BookCoverStore,
   ) {}
 
   async execute(input: ExecuteMoveInput): Promise<ExecuteMoveResult> {
@@ -130,6 +132,7 @@ export class BookMoveExecutorService {
       );
 
       if (applied.mergedBookId != null) {
+        await this.coverStore.removeCoverDirectory(applied.mergedBookId).catch(() => undefined);
         return { status: 'merged', crossDevice, mergedBookId: applied.mergedBookId };
       }
       return { status: 'success', crossDevice };
diff --git a/server/src/modules/book-move/book-move.module.ts b/server/src/modules/book-move/book-move.module.ts
index 2c7bb3fc3..343abc093 100644
--- a/server/src/modules/book-move/book-move.module.ts
+++ b/server/src/modules/book-move/book-move.module.ts
@@ -2,6 +2,7 @@ import { Module, forwardRef } from '@nestjs/common';
 
 import { SelfWriteRegistryModule } from '../../common/self-write-registry.module';
 import { AppSettingsModule } from '../app-settings/app-settings.module';
+import { BookCoverStoreModule } from '../book-cover-store/book-cover-store.module';
 import { BookModule } from '../book/book.module';
 import { FileWriteModule } from '../file-write/file-write.module';
 import { NotificationModule } from '../notification/notification.module';
@@ -13,7 +14,15 @@ import { BookMoveRepository } from './book-move.repository';
 import { BookMoveService } from './book-move.service';
 
 @Module({
-  imports: [BookModule, ScannerModule, FileWriteModule, AppSettingsModule, SelfWriteRegistryModule, forwardRef(() => NotificationModule)],
+  imports: [
+    BookModule,
+    BookCoverStoreModule,
+    ScannerModule,
+    FileWriteModule,
+    AppSettingsModule,
+    SelfWriteRegistryModule,
+    forwardRef(() => NotificationModule),
+  ],
   controllers: [BookMoveController],
   providers: [BookMoveService, BookMovePlannerService, BookMoveExecutorService, BookMoveRepository],
   exports: [BookMoveService],
diff --git a/server/src/modules/book/book-query-builder.service.test.ts b/server/src/modules/book/book-query-builder.service.test.ts
index de511ac05..dc53c2364 100644
--- a/server/src/modules/book/book-query-builder.service.test.ts
+++ b/server/src/modules/book/book-query-builder.service.test.ts
@@ -3,6 +3,8 @@ vi.mock('drizzle-orm', () => {
     vi.fn((strings: TemplateStringsArray, ...values: unknown[]) => ({ type: 'sql', text: strings.join(''), values })),
     {
       raw: vi.fn((value: string) => ({ type: 'raw', value })),
+      join: vi.fn((chunks: unknown[]) => ({ type: 'join', chunks })),
+      identifier: vi.fn((value: string) => ({ type: 'identifier', value })),
     },
   );
 
@@ -22,6 +24,7 @@ vi.mock('drizzle-orm', () => {
     isNull: vi.fn((value: unknown) => ({ type: 'isNull', value })),
     isNotNull: vi.fn((value: unknown) => ({ type: 'isNotNull', value })),
     not: vi.fn((value: unknown) => ({ type: 'not', value })),
+    getTableName: vi.fn(() => 'table'),
     sql: sqlTag,
   };
 });
@@ -1721,6 +1724,38 @@ describe('coverRuleToSql', () => {
   });
 });
 
+describe('audioCoverRuleToSql', () => {
+  it('isMissing keeps books with audio cover media and no active audio slot', () => {
+    const { builder } = makeBuilder();
+    const where = builder.buildWhere(wrapRule({ type: 'rule', field: 'audioCover', operator: 'isMissing' }) as never, BASE_CTX) as any;
+    const clause = getRuleSql(where);
+    expect(clause.type).toBe('and');
+    const [hasAudio, missingSlot] = clause.clauses;
+    expect(hasAudio.text).toContain("= 'epub'");
+    expect(missingSlot.type).toBe('not');
+    expect(missingSlot.value.values).toContain('audio');
+    expect(missingSlot.value.text).toContain('is null');
+  });
+
+  it('isPresent keeps books with audio cover media and an active audio slot', () => {
+    const { builder } = makeBuilder();
+    const where = builder.buildWhere(wrapRule({ type: 'rule', field: 'audioCover', operator: 'isPresent' }) as never, BASE_CTX) as any;
+    const clause = getRuleSql(where);
+    expect(clause.type).toBe('and');
+    const [hasAudio, activeSlot] = clause.clauses;
+    expect(hasAudio.type).toBe('sql');
+    expect(activeSlot.type).toBe('sql');
+    expect(activeSlot.values).toContain('audio');
+  });
+
+  it('rejects operators the field does not offer', () => {
+    const { builder } = makeBuilder();
+    expect(() => builder.buildWhere(wrapRule({ type: 'rule', field: 'audioCover', operator: 'isEmpty' }) as never, BASE_CTX)).toThrow(
+      BadRequestException,
+    );
+  });
+});
+
 describe('lockStatusRuleToSql', () => {
   it('isLocked produces cardinality(lockedFields) > 0', () => {
     const { builder } = makeBuilder();
diff --git a/server/src/modules/book/book-query-builder.service.ts b/server/src/modules/book/book-query-builder.service.ts
index 4c602ef60..97b4c8205 100644
--- a/server/src/modules/book/book-query-builder.service.ts
+++ b/server/src/modules/book/book-query-builder.service.ts
@@ -19,6 +19,7 @@ import { buildContentFilterClauses } from '../../common/utils/content-filter-sql
 import { accentInsensitiveIlike, buildSearchPattern, escapeLikePattern } from '../../common/utils/accent-insensitive-search.utils';
 import { compareSeriesIndexSql, seriesIndexSortKey, seriesIndexSortKeySql } from '../../common/utils/series-index-sql.utils';
 import * as schema from '../../db/schema';
+import { activeCoverSlotSql, coverMediaSql } from '../book-cover-store/book-cover-store.repository';
 import { BookSortBuilder, customMetadataValueColumn, resolveRandomSortSeed, type BookSortContext } from './book-sort-builder.service';
 import {
   audiobookProgress,
@@ -228,6 +229,8 @@ export class BookQueryBuilder {
         return this.numericRuleToSql(bookMetadata.metadataScore, operator, value as number, valueTo as number | undefined);
       case 'cover':
         return this.coverRuleToSql(operator);
+      case 'audioCover':
+        return this.audioCoverRuleToSql(operator);
       case 'lockStatus':
         return this.lockStatusRuleToSql(operator);
       case 'seriesStatus':
@@ -834,6 +837,21 @@ export class BookQueryBuilder {
     }
   }
 
+  // Only books whose cover media include audio have an audio slot to fill, so both operators
+  // leave ebook-only books out rather than reporting them as missing one.
+  private audioCoverRuleToSql(operator: string): SQL {
+    const activeAudioSlot = activeCoverSlotSql(books.id, 'audio');
+    const { hasAudio } = coverMediaSql(books.id);
+    switch (operator) {
+      case 'isMissing':
+        return and(hasAudio, not(activeAudioSlot))!;
+      case 'isPresent':
+        return and(hasAudio, activeAudioSlot)!;
+      default:
+        throw new BadRequestException(`Invalid operator '${operator}' for audio cover field`);
+    }
+  }
+
   private lockStatusRuleToSql(operator: string): SQL {
     switch (operator) {
       case 'isLocked':
diff --git a/server/src/modules/book/book.controller.test.ts b/server/src/modules/book/book.controller.test.ts
index 9a7aa0a46..f5acb0a67 100644
--- a/server/src/modules/book/book.controller.test.ts
+++ b/server/src/modules/book/book.controller.test.ts
@@ -229,7 +229,7 @@ describe('BookController', () => {
     bookService.getCoverPath.mockResolvedValue('/tmp/cover.jpg');
     mockStat.mockResolvedValue({ mtimeMs: 1234 } as never);
 
-    await controller.getCover(7, makeUser(), reply, '1234567890', '"1234"');
+    await controller.getCover(7, makeUser(), reply, { t: '1234567890' }, '"1234"');
 
     expect(reply.status).toHaveBeenCalledWith(304);
     expect(headers['Cache-Control']).toBe('public, max-age=31536000, immutable');
@@ -256,7 +256,7 @@ describe('BookController', () => {
     bookService.getCoverPath.mockResolvedValue('/tmp/cover.jpg');
     mockStat.mockResolvedValue({ mtimeMs: 4321 } as never);
 
-    await controller.getCover(7, makeUser(), reply, '1234567890', undefined);
+    await controller.getCover(7, makeUser(), reply, { t: '1234567890' }, undefined);
 
     expect(headers['Cache-Control']).toBe('public, max-age=31536000, immutable');
     expect(reply.type).toHaveBeenCalledWith('image/jpeg');
@@ -732,7 +732,7 @@ describe('BookController', () => {
     bookService.getThumbnailPath.mockResolvedValue('/tmp/thumb.jpg');
     mockStat.mockResolvedValue({ mtimeMs: 1000 } as never);
 
-    await controller.getThumbnail(7, makeUser(), reply, '1234567890', undefined);
+    await controller.getThumbnail(7, makeUser(), reply, { t: '1234567890' }, undefined);
     expect(headers['Cache-Control']).toBe('public, max-age=31536000, immutable');
   });
 
@@ -754,6 +754,16 @@ describe('BookController', () => {
     expect(bookService.bulkReExtractCover).toHaveBeenCalledWith([42], user);
   });
 
+  it('passes an explicit medium through re-extract-cover', async () => {
+    const { controller, bookService } = makeController();
+    const user = makeUser();
+    bookService.bulkReExtractCover.mockResolvedValue({ processed: 1, updated: 1 });
+
+    await controller.reExtractCover(42, user, { medium: 'audio' });
+
+    expect(bookService.bulkReExtractCover).toHaveBeenCalledWith([42], user, undefined, { medium: 'audio' });
+  });
+
   it('logs and rethrows download failures', async () => {
     const { controller, bookService } = makeController();
     const { reply } = makeReply();
diff --git a/server/src/modules/book/book.controller.ts b/server/src/modules/book/book.controller.ts
index 5dad68ff7..0b7a18c7c 100644
--- a/server/src/modules/book/book.controller.ts
+++ b/server/src/modules/book/book.controller.ts
@@ -46,6 +46,8 @@ import { UpsertAudioProgressDto } from './dto/upsert-audio-progress.dto';
 import { UpdateBookMetadataAndLocksDto } from './dto/update-book-metadata-and-locks.dto';
 import { UpdateBookMetadataDto } from './dto/update-book-metadata.dto';
 import { UpdateBookAddedAtDto } from './dto/update-book-added-at.dto';
+import { CoverReadQueryDto } from './dto/cover-read-query.dto';
+import { CoverMediumQueryDto } from '../cover/dto/cover-medium-query.dto';
 import { UpdatePersonalNoteDto } from './dto/update-personal-note.dto';
 import { SearchBooksDto } from './dto/search-books.dto';
 import { UpdateBookFileDto } from './dto/update-book-file.dto';
@@ -212,8 +214,10 @@ export class BookController {
 
   @Post(':id/re-extract-cover')
   @RequirePermission(Permission.LibraryEditMetadata)
-  reExtractCover(@Param('id', ParseIntPipe) id: number, @CurrentUser() user: RequestUser) {
-    return this.bookService.bulkReExtractCover([id], user);
+  reExtractCover(@Param('id', ParseIntPipe) id: number, @CurrentUser() user: RequestUser, @Query() query?: CoverMediumQueryDto) {
+    return query?.medium
+      ? this.bookService.bulkReExtractCover([id], user, undefined, { medium: query.medium })
+      : this.bookService.bulkReExtractCover([id], user);
   }
 
   @Post('export')
@@ -338,15 +342,15 @@ export class BookController {
     @Param('id', ParseIntPipe) id: number,
     @CurrentUser() user: RequestUser,
     @Res() reply: FastifyReply,
-    @Query('t') t?: string,
+    @Query() query: CoverReadQueryDto = {},
     @Headers('if-none-match') ifNoneMatch?: string,
   ) {
-    const coverPath = await this.bookService.getCoverPath(id, user);
+    const coverPath = await this.bookService.getCoverPath(id, user, { medium: query.medium, strict: query.strict });
     if (!coverPath) throw new NotFoundException(`No cover for book ${id}`);
 
     const { mtimeMs } = await stat(coverPath);
     const etag = `"${Math.floor(mtimeMs)}"`;
-    const cacheControl = t ? 'public, max-age=31536000, immutable' : 'private, max-age=86400';
+    const cacheControl = query.t ? 'public, max-age=31536000, immutable' : 'private, max-age=86400';
 
     if (ifNoneMatch === etag) {
       reply.status(304).header('Cache-Control', cacheControl).header('ETag', etag).send();
@@ -365,15 +369,15 @@ export class BookController {
     @Param('id', ParseIntPipe) id: number,
     @CurrentUser() user: RequestUser,
     @Res() reply: FastifyReply,
-    @Query('t') t?: string,
+    @Query() query: CoverReadQueryDto = {},
     @Headers('if-none-match') ifNoneMatch?: string,
   ) {
-    const thumbnailPath = await this.bookService.getThumbnailPath(id, user);
+    const thumbnailPath = await this.bookService.getThumbnailPath(id, user, { medium: query.medium, strict: query.strict });
     if (!thumbnailPath) throw new NotFoundException(`No thumbnail for book ${id}`);
 
     const { mtimeMs } = await stat(thumbnailPath);
     const etag = `"${Math.floor(mtimeMs)}"`;
-    const cacheControl = t ? 'public, max-age=31536000, immutable' : 'private, max-age=86400';
+    const cacheControl = query.t ? 'public, max-age=31536000, immutable' : 'private, max-age=86400';
 
     if (ifNoneMatch === etag) {
       reply.status(304).header('Cache-Control', cacheControl).header('ETag', etag).send();
diff --git a/server/src/modules/book/book.module.ts b/server/src/modules/book/book.module.ts
index c0adf9d68..84687f2e6 100644
--- a/server/src/modules/book/book.module.ts
+++ b/server/src/modules/book/book.module.ts
@@ -6,6 +6,7 @@ import { EmbeddingModule } from '../embedding/embedding.module';
 import { FileWriteModule } from '../file-write/file-write.module';
 import { LibraryModule } from '../library/library.module';
 import { BookMetadataLockModule } from '../book-metadata-lock/book-metadata-lock.module';
+import { BookCoverStoreModule } from '../book-cover-store/book-cover-store.module';
 import { CustomMetadataModule } from '../custom-metadata/custom-metadata.module';
 import { MetadataModule } from '../metadata/metadata.module';
 import { MetadataFetchModule } from '../metadata-fetch/metadata-fetch.module';
@@ -29,6 +30,7 @@ import { ReadingAttemptController } from './reading-attempt.controller';
   imports: [
     forwardRef(() => LibraryModule),
     BookMetadataLockModule,
+    BookCoverStoreModule,
     CustomMetadataModule,
     MetadataModule,
     EmbeddingModule,
diff --git a/server/src/modules/book/book.repository.ts b/server/src/modules/book/book.repository.ts
index bc9942bbf..ee3c9c41b 100644
--- a/server/src/modules/book/book.repository.ts
+++ b/server/src/modules/book/book.repository.ts
@@ -2073,6 +2073,37 @@ export class BookRepository {
       .orderBy(asc(bookFiles.bookId), asc(bookFiles.sortOrder), asc(bookFiles.id));
   }
 
+  async findCoverSourceFilesByBookIds(bookIds: number[]): Promise<
+    {
+      id: number;
+      bookId: number;
+      absolutePath: string;
+      format: string | null;
+      role: string;
+      sizeBytes: number | null;
+      mediaOverlayAvailable: boolean;
+      formatPriority: string[];
+    }[]
+  > {
+    if (bookIds.length === 0) return [];
+    return this.db
+      .select({
+        id: bookFiles.id,
+        bookId: bookFiles.bookId,
+        absolutePath: bookFiles.absolutePath,
+        format: bookFiles.format,
+        role: bookFiles.role,
+        sizeBytes: bookFiles.sizeBytes,
+        mediaOverlayAvailable: bookFiles.mediaOverlayAvailable,
+        formatPriority: libraries.formatPriority,
+      })
+      .from(bookFiles)
+      .innerJoin(books, eq(books.id, bookFiles.bookId))
+      .innerJoin(libraries, eq(libraries.id, books.libraryId))
+      .where(inArray(bookFiles.bookId, bookIds))
+      .orderBy(asc(bookFiles.bookId), asc(bookFiles.sortOrder), asc(bookFiles.id));
+  }
+
   async deleteByIds(bookIds: number[]): Promise<void> {
     await this.db.delete(books).where(inArray(books.id, bookIds));
   }
diff --git a/server/src/modules/book/book.service.test.ts b/server/src/modules/book/book.service.test.ts
index 6f5cd3adf..b49c3dbab 100644
--- a/server/src/modules/book/book.service.test.ts
+++ b/server/src/modules/book/book.service.test.ts
@@ -1,6 +1,6 @@
 import { BadRequestException, ConflictException, ForbiddenException, InternalServerErrorException, Logger, NotFoundException } from '@nestjs/common';
 import type { MockedFunction } from 'vitest';
-import { access, readdir, rm, stat, rename } from 'fs/promises';
+import { rm, stat, rename } from 'fs/promises';
 
 import type { RequestUser } from '../../common/types/request-user';
 import { AUDIO_BOOK_FILE_WRITE_FIELDS, MetadataProviderKey, Permission, type BookQuery, type MetadataFetchDiagnostics } from '@bookorbit/types';
@@ -22,8 +22,6 @@ vi.mock('fs/promises', async () => {
   const actual = await vi.importActual('fs/promises');
   return {
     ...actual,
-    access: vi.fn(),
-    readdir: vi.fn(),
     rm: vi.fn(),
     rename: vi.fn(),
     stat: vi.fn(),
@@ -56,8 +54,6 @@ vi.mock('../metadata/lib/pdf-parser', () => ({
   parsePdfFile: vi.fn(),
 }));
 
-const mockAccess = access as MockedFunction<typeof access>;
-const mockReaddir = readdir as MockedFunction<typeof readdir>;
 const mockRm = rm as MockedFunction<typeof rm>;
 const mockStat = stat as MockedFunction<typeof stat>;
 const mockExtractEpubMetadata = extractEpubMetadata as MockedFunction<typeof extractEpubMetadata>;
@@ -113,6 +109,7 @@ function makeService(overrides: { bookMetadataLockService?: unknown } = {}) {
     findDeletionAuditBooksByIds: vi.fn(),
     findPrimaryFilesByBookIds: vi.fn(),
     findAllFilesByBookIds: vi.fn(),
+    findCoverSourceFilesByBookIds: vi.fn().mockResolvedValue([]),
     findTagsByBookIds: vi.fn(),
     findAuthorsByBookIds: vi.fn(),
     findGenresByBookIds: vi.fn(),
@@ -170,9 +167,8 @@ function makeService(overrides: { bookMetadataLockService?: unknown } = {}) {
     replaceGenres: vi.fn().mockResolvedValue(undefined),
     replaceTags: vi.fn().mockResolvedValue(undefined),
     emitAuthorsReplaced: vi.fn(),
-    downloadAndSaveCover: vi.fn().mockResolvedValue(undefined),
+    downloadAndSaveCover: vi.fn().mockResolvedValue(true),
     refreshCoverForBook: vi.fn(),
-    ensureThumbnailForBook: vi.fn().mockResolvedValue(null),
   };
   const pipeline = {
     run: vi.fn(),
@@ -258,6 +254,14 @@ function makeService(overrides: { bookMetadataLockService?: unknown } = {}) {
     findOne: vi.fn().mockResolvedValue(null),
     setNote: vi.fn().mockResolvedValue({ note: null, updatedAt: '2026-01-01T00:00:00.000Z' }),
   };
+  const coverStore = {
+    resolve: vi.fn().mockResolvedValue(null),
+    fetchState: vi.fn().mockResolvedValue({ media: { hasEbook: true, hasAudio: false }, filled: { ebook: false, audio: false }, locked: [] }),
+    enrichCardVersions: vi.fn().mockResolvedValue(undefined),
+    contextFor: vi.fn().mockResolvedValue(null),
+    slotDtos: vi.fn().mockReturnValue({ ebook: null, audio: null }),
+    coverVersion: vi.fn((_coverAspectRatio: string, _slots: unknown[], legacyVersion: string) => `legacy:${legacyVersion}`),
+  };
 
   bookRepo.withTransaction.mockImplementation(async (callback: (tx: unknown) => Promise<unknown>) => callback({}));
 
@@ -276,6 +280,7 @@ function makeService(overrides: { bookMetadataLockService?: unknown } = {}) {
     comicMetadataService as never,
     customMetadataService as never,
     (overrides.bookMetadataLockService ?? bookMetadataLockService) as never,
+    coverStore as never,
     embedder as never,
     fileWriteService as never,
     fileRenameService as never,
@@ -302,6 +307,7 @@ function makeService(overrides: { bookMetadataLockService?: unknown } = {}) {
     comicMetadataService,
     customMetadataService,
     bookMetadataLockService,
+    coverStore,
   };
 }
 
@@ -362,8 +368,6 @@ function makeBookCard(id: number, overrides?: Record<string, unknown>) {
 describe('BookService', () => {
   beforeEach(() => {
     vi.clearAllMocks();
-    mockAccess.mockReset();
-    mockReaddir.mockReset();
     mockRm.mockReset();
     mockStat.mockReset();
     mockExtractEpubMetadata.mockReset();
@@ -826,62 +830,35 @@ describe('BookService', () => {
       await expect(service.verifyFileAccess(99, makeUser())).rejects.toThrow(NotFoundException);
     });
 
-    it('returns cover path with custom cover preferred over extracted cover', async () => {
-      const { service, bookRepo } = makeService();
+    it('resolves the cover through the slot store after checking access', async () => {
+      const { service, bookRepo, coverStore } = makeService();
       bookRepo.findLibraryIdByBookId.mockResolvedValue(5);
-      mockReaddir.mockResolvedValue(['cover_extracted.jpg', 'cover_custom.png'] as never);
+      coverStore.resolve.mockResolvedValue('/tmp/books/covers/9/audio/cover_custom.png');
 
-      const result = await service.getCoverPath(9, makeUser());
+      await expect(service.getCoverPath(9, makeUser(), { medium: 'audio', strict: true })).resolves.toBe(
+        '/tmp/books/covers/9/audio/cover_custom.png',
+      );
 
-      expect(result).toBe('/tmp/books/covers/9/cover_custom.png');
+      expect(coverStore.resolve).toHaveBeenCalledWith(9, { variant: 'cover', medium: 'audio', strict: true });
     });
 
-    it('returns null cover path when cover directory cannot be read', async () => {
-      const { service, bookRepo } = makeService();
+    it('resolves the thumbnail through the slot store', async () => {
+      const { service, bookRepo, coverStore } = makeService();
       bookRepo.findLibraryIdByBookId.mockResolvedValue(5);
-      const missingError = Object.assign(new Error('missing'), { code: 'ENOENT' });
-      mockReaddir.mockRejectedValue(missingError);
 
-      await expect(service.getCoverPath(9, makeUser())).resolves.toBeNull();
-    });
-
-    it('throws when cover directory lookup fails for non-missing errors', async () => {
-      const { service, bookRepo } = makeService();
-      bookRepo.findLibraryIdByBookId.mockResolvedValue(5);
-      mockReaddir.mockRejectedValue(Object.assign(new Error('permission denied'), { code: 'EACCES' }));
-
-      await expect(service.getCoverPath(9, makeUser())).rejects.toThrow('permission denied');
-    });
-
-    it('returns thumbnail path only when file is accessible', async () => {
-      const { service, bookRepo, metadataService } = makeService();
-      bookRepo.findLibraryIdByBookId.mockResolvedValue(5);
-      mockAccess.mockResolvedValue(undefined);
-
-      await expect(service.getThumbnailPath(9, makeUser())).resolves.toBe('/tmp/books/covers/9/thumbnail.jpg');
-
-      mockAccess.mockRejectedValue(Object.assign(new Error('missing'), { code: 'ENOENT' }));
       await expect(service.getThumbnailPath(9, makeUser())).resolves.toBeNull();
-      expect(metadataService.ensureThumbnailForBook).toHaveBeenCalledWith(9);
+
+      expect(coverStore.resolve).toHaveBeenCalledWith(9, { variant: 'thumbnail' });
     });
 
-    it('repairs and returns a missing thumbnail from the active cover', async () => {
-      const { service, bookRepo, metadataService } = makeService();
+    it('does not resolve a cover for a book the user cannot access', async () => {
+      const { service, bookRepo, libraryService, coverStore } = makeService();
       bookRepo.findLibraryIdByBookId.mockResolvedValue(5);
-      mockAccess.mockRejectedValue(Object.assign(new Error('missing'), { code: 'ENOENT' }));
-      metadataService.ensureThumbnailForBook.mockResolvedValue('/tmp/books/covers/9/thumbnail.jpg');
+      libraryService.verifyUserAccess.mockRejectedValue(new ForbiddenException('no access'));
 
-      await expect(service.getThumbnailPath(9, makeUser())).resolves.toBe('/tmp/books/covers/9/thumbnail.jpg');
+      await expect(service.getThumbnailPath(9, makeUser())).rejects.toThrow(NotFoundException);
 
-      expect(metadataService.ensureThumbnailForBook).toHaveBeenCalledWith(9);
-    });
-
-    it('throws when thumbnail access fails for non-missing errors', async () => {
-      const { service, bookRepo } = makeService();
-      bookRepo.findLibraryIdByBookId.mockResolvedValue(5);
-      mockAccess.mockRejectedValue(Object.assign(new Error('permission denied'), { code: 'EACCES' }));
-
-      await expect(service.getThumbnailPath(9, makeUser())).rejects.toThrow('permission denied');
+      expect(coverStore.resolve).not.toHaveBeenCalled();
     });
 
     it('returns file info with unknown format fallback', async () => {
@@ -911,7 +888,7 @@ describe('BookService', () => {
 
   describe('metadata refresh + update', () => {
     it('refreshMetadata preview returns resolved fields without mutating metadata', async () => {
-      const { service, bookRepo, libraryService, pipeline, metadataService } = makeService();
+      const { service, bookRepo, libraryService, pipeline, metadataService, coverStore } = makeService();
       const user = makeUser();
       bookRepo.findById.mockResolvedValue({
         book: {
@@ -939,6 +916,7 @@ describe('BookService', () => {
         authorRows: [{ id: 1, name: 'Author One', sortName: null }],
         genreRows: [],
         communityRatingRows: [],
+        fileRows: [{ format: 'epub', role: 'primary', mediaOverlayAvailable: false }],
       });
       pipeline.runWithSources.mockResolvedValue({
         resolved: { title: 'New Title' },
@@ -946,10 +924,12 @@ describe('BookService', () => {
         providerIds: {},
         diagnostics: makeMetadataFetchDiagnostics({ resolvedFieldCount: 1 }),
       });
+      coverStore.fetchState.mockResolvedValue({ media: { hasEbook: true, hasAudio: false }, filled: { ebook: true, audio: false }, locked: [] });
       const updateSpy = vi.spyOn(service, 'updateMetadata');
 
       const result = await service.refreshMetadata(1, true, user);
 
+      expect(coverStore.fetchState).toHaveBeenCalledWith(1);
       expect(result).toEqual({
         metadata: { title: 'New Title' },
         diagnostics: makeMetadataFetchDiagnostics({ resolvedFieldCount: 1 }),
@@ -980,11 +960,13 @@ describe('BookService', () => {
           seriesName: null,
           seriesIndex: null,
           genres: [],
-          cover: 'extracted',
+          cover: true,
+          audioCover: null,
           duration: undefined,
           abridged: undefined,
         },
         7,
+        { coverMedia: { hasEbook: true, hasAudio: false }, lockedCoverSlots: [] },
       );
       expect(updateSpy).not.toHaveBeenCalled();
       expect(metadataService.downloadAndSaveCover).not.toHaveBeenCalled();
@@ -1017,11 +999,92 @@ describe('BookService', () => {
       const result = await service.refreshMetadata(1, false, user);
 
       expect(updateSpy).toHaveBeenCalledWith(1, { title: 'Resolved', authors: ['A'], genres: ['G'] }, user, { postSaveMode: 'schedule' });
-      expect(metadataService.downloadAndSaveCover).toHaveBeenCalledWith('https://img/c.jpg', 1);
+      expect(metadataService.downloadAndSaveCover).toHaveBeenCalledWith([{ url: 'https://img/c.jpg' }], 1, 'ebook');
       expect(getDetailSpy).toHaveBeenCalledWith(1, user);
       expect(result).toEqual({ id: 1, title: 'Final' });
     });
 
+    it('refreshMetadata saves each fetched cover into its own slot and passes the slot state to the pipeline', async () => {
+      const { service, bookRepo, pipeline, metadataService, coverStore } = makeService();
+      const user = makeUser();
+      bookRepo.findById.mockResolvedValue({
+        book: {
+          books: { id: 1, libraryId: 7 },
+          book_metadata: { title: 'Old', isbn13: null, isbn10: null, coverSource: null, lockedFields: ['cover'] },
+        },
+        authorRows: [],
+        genreRows: [],
+        fileRows: [
+          { format: 'epub', role: 'primary', mediaOverlayAvailable: false },
+          { format: 'm4b', role: 'content', mediaOverlayAvailable: false },
+        ],
+      });
+      const audioCoverChoices = [
+        { url: 'https://img/a.jpg', provider: MetadataProviderKey.AUDIBLE, fit: 'match' as const },
+        { url: 'https://img/b.jpg', provider: MetadataProviderKey.ITUNES, fit: 'match' as const },
+      ];
+      pipeline.runWithSources.mockResolvedValue({
+        resolved: { audioCoverUrl: 'https://img/a.jpg', audioCoverChoices },
+        sources: {},
+        providerIds: {},
+      });
+      coverStore.fetchState.mockResolvedValue({
+        media: { hasEbook: true, hasAudio: true },
+        filled: { ebook: false, audio: false },
+        locked: ['ebook'],
+      });
+      const getDetailSpy = vi.spyOn(service, 'getDetail').mockResolvedValue({ id: 1 } as never);
+
+      await service.refreshMetadata(1, false, user);
+
+      expect(pipeline.runWithSources).toHaveBeenCalledWith(expect.any(Object), expect.objectContaining({ cover: null, audioCover: null }), 7, {
+        coverMedia: { hasEbook: true, hasAudio: true },
+        lockedCoverSlots: ['ebook'],
+      });
+      expect(metadataService.downloadAndSaveCover).toHaveBeenCalledTimes(1);
+      expect(metadataService.downloadAndSaveCover).toHaveBeenCalledWith(audioCoverChoices, 1, 'audio');
+      expect(getDetailSpy).toHaveBeenCalledWith(1, user);
+    });
+
+    it('refreshMetadata answers not found when the book disappears before its cover state is read', async () => {
+      const { service, bookRepo, pipeline, coverStore } = makeService();
+      bookRepo.findById.mockResolvedValue({
+        book: { books: { id: 1, libraryId: 7 }, book_metadata: { title: 'Old' } },
+        authorRows: [],
+        genreRows: [],
+        fileRows: [],
+      });
+      coverStore.fetchState.mockResolvedValue(null);
+
+      await expect(service.refreshMetadata(1, true, makeUser())).rejects.toThrow(NotFoundException);
+
+      expect(pipeline.runWithSources).not.toHaveBeenCalled();
+    });
+
+    it('refreshMetadata preview returns both cover slots', async () => {
+      const { service, bookRepo, pipeline } = makeService();
+      bookRepo.findById.mockResolvedValue({
+        book: { books: { id: 1, libraryId: 7 }, book_metadata: { title: 'Old' } },
+        authorRows: [],
+        genreRows: [],
+        fileRows: [],
+      });
+      pipeline.runWithSources.mockResolvedValue({
+        resolved: {
+          coverUrl: 'https://img/e.jpg',
+          coverChoices: [{ url: 'https://img/e.jpg', provider: MetadataProviderKey.AMAZON, fit: 'match' }],
+          audioCoverUrl: 'https://img/a.jpg',
+        },
+        sources: {},
+        providerIds: {},
+        diagnostics: makeMetadataFetchDiagnostics({ resolvedFieldCount: 2 }),
+      });
+
+      const result = (await service.refreshMetadata(1, true, makeUser())) as { metadata: Record<string, unknown> };
+
+      expect(result.metadata).toEqual({ coverUrl: 'https://img/e.jpg', audioCoverUrl: 'https://img/a.jpg' });
+    });
+
     it('refreshMetadata preview includes provider ids returned by pipeline', async () => {
       const { service, bookRepo, pipeline } = makeService();
       const user = makeUser();
@@ -1269,7 +1332,12 @@ describe('BookService', () => {
 
       await service.refreshMetadata(1, true, user);
 
-      expect(pipeline.runWithSources).toHaveBeenCalledWith(expect.objectContaining({ hardcoverEditionId: '8941973' }), expect.any(Object), 7);
+      expect(pipeline.runWithSources).toHaveBeenCalledWith(
+        expect.objectContaining({ hardcoverEditionId: '8941973' }),
+        expect.any(Object),
+        7,
+        expect.any(Object),
+      );
     });
 
     it('refreshMetadata persists provider-specific community rating rows', async () => {
@@ -2119,9 +2187,27 @@ describe('BookService', () => {
         { id: 1, libraryId: 7 },
         { id: 2, libraryId: 7 },
       ]);
-      bookRepo.findPrimaryFilesByBookIds.mockResolvedValue([
-        { bookId: 1, absolutePath: '/books/1.epub', format: 'epub' },
-        { bookId: 2, absolutePath: '/books/2.epub', format: 'epub' },
+      bookRepo.findCoverSourceFilesByBookIds.mockResolvedValue([
+        {
+          id: 10,
+          bookId: 1,
+          absolutePath: '/books/1.epub',
+          format: 'epub',
+          role: 'content',
+          sizeBytes: 10,
+          mediaOverlayAvailable: false,
+          formatPriority: ['epub', 'm4b'],
+        },
+        {
+          id: 20,
+          bookId: 2,
+          absolutePath: '/books/2.epub',
+          format: 'epub',
+          role: 'content',
+          sizeBytes: 10,
+          mediaOverlayAvailable: false,
+          formatPriority: ['epub', 'm4b'],
+        },
       ]);
       metadataService.refreshCoverForBook.mockResolvedValueOnce(true).mockResolvedValueOnce(false);
 
@@ -2142,9 +2228,27 @@ describe('BookService', () => {
         { id: 1, libraryId: 7 },
         { id: 2, libraryId: 7 },
       ]);
-      bookRepo.findPrimaryFilesByBookIds.mockResolvedValue([
-        { bookId: 1, absolutePath: '/books/1.epub', format: 'epub' },
-        { bookId: 2, absolutePath: '/books/2.epub', format: 'epub' },
+      bookRepo.findCoverSourceFilesByBookIds.mockResolvedValue([
+        {
+          id: 10,
+          bookId: 1,
+          absolutePath: '/books/1.epub',
+          format: 'epub',
+          role: 'content',
+          sizeBytes: 10,
+          mediaOverlayAvailable: false,
+          formatPriority: ['epub', 'm4b'],
+        },
+        {
+          id: 20,
+          bookId: 2,
+          absolutePath: '/books/2.epub',
+          format: 'epub',
+          role: 'content',
+          sizeBytes: 10,
+          mediaOverlayAvailable: false,
+          formatPriority: ['epub', 'm4b'],
+        },
       ]);
       metadataService.refreshCoverForBook.mockResolvedValue(true);
 
@@ -2161,13 +2265,97 @@ describe('BookService', () => {
       expect(metadataService.refreshCoverForBook).toHaveBeenCalledTimes(1);
     });
 
+    it('bulkReExtractCover re-extracts both slots of a book with both media, and one slot when a medium is named', async () => {
+      const { service, bookRepo, metadataService } = makeService();
+      const user = makeUser();
+      bookRepo.findLibraryIdsByBookIds.mockResolvedValue([{ id: 1, libraryId: 7 }]);
+      bookRepo.findCoverSourceFilesByBookIds.mockResolvedValue([
+        {
+          id: 10,
+          bookId: 1,
+          absolutePath: '/books/1.epub',
+          format: 'epub',
+          role: 'content',
+          sizeBytes: 10,
+          mediaOverlayAvailable: false,
+          formatPriority: ['epub', 'm4b'],
+        },
+        {
+          id: 11,
+          bookId: 1,
+          absolutePath: '/books/1.m4b',
+          format: 'm4b',
+          role: 'content',
+          sizeBytes: 10,
+          mediaOverlayAvailable: false,
+          formatPriority: ['epub', 'm4b'],
+        },
+      ]);
+      metadataService.refreshCoverForBook.mockResolvedValue(true);
+
+      await expect(service.bulkReExtractCover([1], user)).resolves.toEqual({ processed: 1, updated: 1 });
+      expect(metadataService.refreshCoverForBook).toHaveBeenNthCalledWith(1, 1, '/books/1.epub', 'epub', 'ebook');
+      expect(metadataService.refreshCoverForBook).toHaveBeenNthCalledWith(2, 1, '/books/1.m4b', 'm4b', 'audio');
+
+      metadataService.refreshCoverForBook.mockClear();
+      await service.bulkReExtractCover([1], user, undefined, { medium: 'audio' });
+      expect(metadataService.refreshCoverForBook).toHaveBeenCalledOnce();
+      expect(metadataService.refreshCoverForBook).toHaveBeenCalledWith(1, '/books/1.m4b', 'm4b', 'audio');
+    });
+
+    it('bulkReExtractCover leaves a locked audio slot alone while refreshing the book cover', async () => {
+      const { service, bookRepo, bookMetadataLockService, metadataService } = makeService();
+      const user = makeUser();
+      bookRepo.findLibraryIdsByBookIds.mockResolvedValue([{ id: 1, libraryId: 7 }]);
+      bookRepo.findCoverSourceFilesByBookIds.mockResolvedValue([
+        {
+          id: 10,
+          bookId: 1,
+          absolutePath: '/books/1.epub',
+          format: 'epub',
+          role: 'content',
+          sizeBytes: 10,
+          mediaOverlayAvailable: false,
+          formatPriority: ['epub', 'm4b'],
+        },
+        {
+          id: 11,
+          bookId: 1,
+          absolutePath: '/books/1.m4b',
+          format: 'm4b',
+          role: 'content',
+          sizeBytes: 10,
+          mediaOverlayAvailable: false,
+          formatPriority: ['epub', 'm4b'],
+        },
+      ]);
+      bookMetadataLockService.getBookIdsWithLockedField.mockResolvedValue(new Set([1]));
+      metadataService.refreshCoverForBook.mockResolvedValue(true);
+
+      await expect(service.bulkReExtractCover([1], user)).resolves.toEqual({ processed: 1, updated: 1 });
+      expect(bookMetadataLockService.getBookIdsWithLockedField).toHaveBeenCalledWith([1], 'audioCover');
+      expect(metadataService.refreshCoverForBook).toHaveBeenCalledOnce();
+      expect(metadataService.refreshCoverForBook).toHaveBeenCalledWith(1, '/books/1.epub', 'epub', 'ebook');
+    });
+
     it('bulkReExtractCover skips locked cover mutations', async () => {
       const { service, bookRepo, bookMetadataLockService, metadataService } = makeService();
       const user = makeUser();
       const onProgress = vi.fn();
 
       bookRepo.findLibraryIdsByBookIds.mockResolvedValue([{ id: 1, libraryId: 7 }]);
-      bookRepo.findPrimaryFilesByBookIds.mockResolvedValue([{ bookId: 1, absolutePath: '/books/1.epub', format: 'epub' }]);
+      bookRepo.findCoverSourceFilesByBookIds.mockResolvedValue([
+        {
+          id: 10,
+          bookId: 1,
+          absolutePath: '/books/1.epub',
+          format: 'epub',
+          role: 'content',
+          sizeBytes: 10,
+          mediaOverlayAvailable: false,
+          formatPriority: ['epub', 'm4b'],
+        },
+      ]);
       bookMetadataLockService.getCoverLockedBookIds.mockResolvedValue(new Set([1]));
 
       await expect(service.bulkReExtractCover([1], user, onProgress)).resolves.toEqual({ processed: 0, updated: 0 });
@@ -3473,7 +3661,18 @@ describe('BookService', () => {
       const { service, bookRepo } = makeService();
       const user = makeUser();
       bookRepo.findLibraryIdsByBookIds.mockResolvedValue([{ id: 1, libraryId: 7 }]);
-      bookRepo.findPrimaryFilesByBookIds.mockResolvedValue([{ bookId: 1, absolutePath: '/books/1.epub', format: 'epub' }]);
+      bookRepo.findCoverSourceFilesByBookIds.mockResolvedValue([
+        {
+          id: 10,
+          bookId: 1,
+          absolutePath: '/books/1.epub',
+          format: 'epub',
+          role: 'content',
+          sizeBytes: 10,
+          mediaOverlayAvailable: false,
+          formatPriority: ['epub', 'm4b'],
+        },
+      ]);
 
       const result = await service.bulkReExtractCover([1], user, undefined, { isCancelled: () => true });
 
@@ -5094,6 +5293,7 @@ describe('BookService', () => {
         comicMetadataService,
         customMetadataService,
         bookMetadataLockService,
+        coverStore,
         embedder,
         fileRenameService,
         achievementEvents,
@@ -5116,6 +5316,7 @@ describe('BookService', () => {
         comicMetadataService as never,
         customMetadataService as never,
         bookMetadataLockService as never,
+        coverStore as never,
         embedder as never,
         null as never,
         fileRenameService as never,
@@ -5144,6 +5345,7 @@ describe('BookService', () => {
         comicMetadataService,
         customMetadataService,
         bookMetadataLockService,
+        coverStore,
         embedder,
         fileWriteService,
         achievementEvents,
@@ -5166,6 +5368,7 @@ describe('BookService', () => {
         comicMetadataService as never,
         customMetadataService as never,
         bookMetadataLockService as never,
+        coverStore as never,
         embedder as never,
         fileWriteService as never,
         null as never,
@@ -5280,11 +5483,15 @@ describe('BookService', () => {
       bookRepo.findBookBase = vi.fn().mockResolvedValue({ id: 10, primaryFileId: 100 });
       bookRepo.updateBookPrimaryFile = vi.fn().mockResolvedValue(undefined);
 
+      const coverReconciler = { enqueue: vi.fn().mockResolvedValue(undefined) };
+      (service as unknown as { coverReconciler: typeof coverReconciler }).coverReconciler = coverReconciler;
+
       await service.deleteFile(fileId, user);
 
       expect(rm).toHaveBeenCalledWith('/path/to/old.epub', { force: true });
       expect(bookRepo.deleteBookFile).toHaveBeenCalledWith(fileId);
       expect(bookRepo.updateBookPrimaryFile).toHaveBeenCalledWith(10, null);
+      expect(coverReconciler.enqueue).toHaveBeenCalledWith([10], { filesChanged: true });
     });
 
     it('elects new primary file if deleted file was primary and other files exist', async () => {
diff --git a/server/src/modules/book/book.service.ts b/server/src/modules/book/book.service.ts
index 4ea22c3ce..36be454f8 100644
--- a/server/src/modules/book/book.service.ts
+++ b/server/src/modules/book/book.service.ts
@@ -10,12 +10,11 @@ import {
   Optional,
 } from '@nestjs/common';
 import { ConfigService } from '@nestjs/config';
-import { access, mkdtemp, readdir, rm, stat, rename } from 'fs/promises';
+import { mkdtemp, rm, stat, rename } from 'fs/promises';
 import { inArray, type SQL } from 'drizzle-orm';
 
-import { bookCoverDirPath, bookThumbnailPath, findPreferredBookCoverFileName } from '../../common/book-cover-storage';
 import { MAX_BOOK_QUERY_OFFSET_ROWS, isBookQueryOffsetWithinLimit } from '../../common/constants/pagination.constants';
-import { resolveIsAudiobook } from '../../common/utils/book-media.utils';
+import { coverFetchInputs, resolveIsAudiobook } from '../../common/utils/book-media.utils';
 import { sanitizeLogValue } from '../../common/utils/log-sanitize.utils';
 import { selectPrimaryFile } from '../../common/utils/primary-file-selection.utils';
 import { normalizeMetadataText, normalizeMetadataTextKey } from '../../common/utils/metadata-text-normalize.utils';
@@ -37,6 +36,7 @@ import { tmpdir } from 'os';
 import {
   BOOK_METADATA_LOCK_FIELDS,
   DEFAULT_DOWNLOAD_PATTERN,
+  COVER_MEDIA,
   DEFAULT_FORMAT_PRIORITY,
   MetadataProviderKey,
   Permission,
@@ -59,6 +59,7 @@ import type {
   BookWriteAndRenameResult,
   BooksPage,
   CustomMetadataFieldTypeMap,
+  CoverMedium,
   FileRenameResult,
   GroupRule,
   JumpBucketsResponse,
@@ -96,6 +97,9 @@ import {
   AchievementEventsService,
 } from '../achievement/achievement-events.service';
 import { BookMetadataLockService } from '../book-metadata-lock/book-metadata-lock.service';
+import { BookCoverStore } from '../book-cover-store/book-cover-store.service';
+import { selectEmbeddedCoverSources } from '../book-cover-store/cover-sources';
+import { CoverSlotReconciler } from '../metadata/cover-slot-reconciler.service';
 import { BookQueryBuilder } from './book-query-builder.service';
 import { AudiobookEbookProgressSyncService } from './audiobook-ebook-progress-sync.service';
 import { AudiolessEpubService } from './audioless-epub.service';
@@ -287,6 +291,7 @@ export class BookService {
     private readonly comicMetadataService: ComicMetadataRepository,
     private readonly customMetadataService: CustomMetadataService,
     private readonly bookMetadataLockService: BookMetadataLockService,
+    private readonly coverStore: BookCoverStore,
     @Optional() private readonly embedder: BookEmbedderService,
     @Optional() private readonly fileWriteService: FileWriteService,
     @Optional() private readonly fileRenameService: FileRenameService,
@@ -295,6 +300,7 @@ export class BookService {
     @Optional() private readonly seriesExpectedCount?: SeriesExpectedCountService,
     @Optional() private readonly audiobookEbookProgressSync?: AudiobookEbookProgressSyncService,
     @Optional() private readonly audiolessEpubService?: AudiolessEpubService,
+    @Optional() private readonly coverReconciler?: CoverSlotReconciler,
   ) {
     this.appDataPath = this.config.get<string>('storage.appDataPath')!;
   }
@@ -418,6 +424,7 @@ export class BookService {
     if (r.seriesIndex !== undefined) preview.seriesIndex = r.seriesIndex as string | null;
     if (r.seriesMemberships !== undefined) preview.seriesMemberships = r.seriesMemberships as BookMetadataRefreshPreviewFields['seriesMemberships'];
     if (r.coverUrl !== undefined) preview.coverUrl = r.coverUrl as string;
+    if (r.audioCoverUrl !== undefined) preview.audioCoverUrl = r.audioCoverUrl as string;
     if (r.hardcoverEditionId !== undefined) preview.hardcoverEditionId = r.hardcoverEditionId as string | null;
     if (r.comicMetadata !== undefined) preview.comicMetadata = r.comicMetadata as BookMetadataRefreshPreviewFields['comicMetadata'];
 
@@ -1125,18 +1132,20 @@ export class BookService {
           ...(query.randomSeed !== undefined ? { randomSeed: query.randomSeed } : {}),
         });
       // Collapsed rows render BookTableCollapsedSeriesCell which does not display custom metadata.
+      const cards = assembleCollapsedBookCards(
+        rows,
+        authorRows,
+        fileRows,
+        genreRows,
+        progressRows,
+        statusRows,
+        narratorRows,
+        tagRows,
+        seriesMembershipRows,
+      );
+      await this.coverStore.enrichCardVersions(cards);
       const result = {
-        items: assembleCollapsedBookCards(
-          rows,
-          authorRows,
-          fileRows,
-          genreRows,
-          progressRows,
-          statusRows,
-          narratorRows,
-          tagRows,
-          seriesMembershipRows,
-        ),
+        items: cards,
         total,
         page,
         size,
@@ -1165,19 +1174,21 @@ export class BookService {
       });
     const bookIds = rows.map((r) => r.id);
     const customMetadataRows = await this.customMetadataService.getCardValues(bookIds);
+    const cards = assembleBookCards(
+      rows,
+      authorRows,
+      fileRows,
+      genreRows,
+      progressRows,
+      statusRows,
+      narratorRows,
+      tagRows,
+      seriesMembershipRows,
+      customMetadataRows,
+    );
+    await this.coverStore.enrichCardVersions(cards);
     const result = {
-      items: assembleBookCards(
-        rows,
-        authorRows,
-        fileRows,
-        genreRows,
-        progressRows,
-        statusRows,
-        narratorRows,
-        tagRows,
-        seriesMembershipRows,
-        customMetadataRows,
-      ),
+      items: cards,
       total,
       page,
       size,
@@ -1287,43 +1298,14 @@ export class BookService {
     }
   }
 
-  async getCoverPath(id: number, user: RequestUser): Promise<string | null> {
-    const event = 'book.get_cover_path';
+  async getCoverPath(id: number, user: RequestUser, options: { medium?: CoverMedium; strict?: boolean } = {}): Promise<string | null> {
     await this.verifyBookAccess(id, user);
-    const dir = bookCoverDirPath(this.appDataPath, id);
-    try {
-      const files = await readdir(dir);
-      const cover = findPreferredBookCoverFileName(files);
-      return cover ? join(dir, cover) : null;
-    } catch (err) {
-      if (this.isMissingFilesystemEntry(err)) return null;
-      const errorClass = err instanceof Error ? err.name : 'Error';
-      const errorMessage = sanitizeLogValue(err instanceof Error ? err.message : String(err));
-      const pathValue = sanitizeLogValue(dir);
-      this.logger.warn(
-        `[${event}] [fail] bookId=${id} userId=${user.id} path="${pathValue}" errorClass=${errorClass} error="${errorMessage}" - get cover path failed`,
-      );
-      throw err;
-    }
+    return this.coverStore.resolve(id, { variant: 'cover', ...options });
   }
 
-  async getThumbnailPath(id: number, user: RequestUser): Promise<string | null> {
-    const event = 'book.get_thumbnail_path';
+  async getThumbnailPath(id: number, user: RequestUser, options: { medium?: CoverMedium; strict?: boolean } = {}): Promise<string | null> {
     await this.verifyBookAccess(id, user);
-    const path = bookThumbnailPath(this.appDataPath, id);
-    try {
-      await access(path);
-      return path;
-    } catch (err) {
-      if (this.isMissingFilesystemEntry(err)) return this.metadataService.ensureThumbnailForBook(id);
-      const errorClass = err instanceof Error ? err.name : 'Error';
-      const errorMessage = sanitizeLogValue(err instanceof Error ? err.message : String(err));
-      const pathValue = sanitizeLogValue(path);
-      this.logger.warn(
-        `[${event}] [fail] bookId=${id} userId=${user.id} path="${pathValue}" errorClass=${errorClass} error="${errorMessage}" - get thumbnail path failed`,
-      );
-      throw err;
-    }
+    return this.coverStore.resolve(id, { variant: 'thumbnail', ...options });
   }
 
   private sanitizeFilenameSegment(raw: string, fallback = 'download'): string {
@@ -1595,6 +1577,7 @@ export class BookService {
           selectPrimaryFile(contentFiles, library.formatPriority ?? DEFAULT_FORMAT_PRIORITY, { allowZeroByteFallback: true }) ?? remaining[0];
         await this.bookRepo.updateBookPrimaryFile(file.bookId, newPrimary?.id ?? null);
       }
+      void this.coverReconciler?.enqueue([file.bookId], { filesChanged: true });
 
       this.logger.log(`[${event}] [end] fileId=${fileId} durationMs=${Date.now() - startedAt} - delete file completed`);
     } catch (err) {
@@ -2884,16 +2867,19 @@ export class BookService {
         seriesName: meta?.seriesName,
         seriesIndex: meta?.seriesIndex,
         genres: genreRows.map((g) => g.name),
-        cover: meta?.coverSource,
         duration: meta?.durationSeconds ?? undefined,
         abridged: meta?.abridged ?? undefined,
       };
+      const coverState = await this.coverStore.fetchState(id);
+      if (!coverState) throw new NotFoundException(`Book ${id} not found`);
+      const coverInputs = coverFetchInputs(coverState);
+      Object.assign(existingFields, coverInputs.existing);
 
       const {
         resolved,
         providerIds: resolvedProviderIds,
         diagnostics,
-      } = await this.pipeline.runWithSources(searchParams, existingFields, book.books.libraryId);
+      } = await this.pipeline.runWithSources(searchParams, existingFields, book.books.libraryId, coverInputs.options);
 
       if (preview) {
         const previewResult = this.buildMetadataRefreshPreview(resolved, resolvedProviderIds);
@@ -2949,11 +2935,14 @@ export class BookService {
       await this.bookRepo.updateMetadataFields(id, { lastMetadataFetchAt: new Date(), updatedAt: new Date() });
 
       let coverDownloaded = false;
-      if (filteredResolved.coverUrl) {
-        await this.metadataService.downloadAndSaveCover(filteredResolved.coverUrl, id);
-        detail = await this.getDetail(id, user);
-        coverDownloaded = true;
+      for (const { medium, url, choices } of [
+        { medium: 'ebook' as const, url: filteredResolved.coverUrl, choices: filteredResolved.coverChoices },
+        { medium: 'audio' as const, url: filteredResolved.audioCoverUrl, choices: filteredResolved.audioCoverChoices },
+      ]) {
+        if (!url) continue;
+        if (await this.metadataService.downloadAndSaveCover(choices ?? [{ url }], id, medium)) coverDownloaded = true;
       }
+      if (coverDownloaded) detail = await this.getDetail(id, user);
 
       const result = detail ?? (await this.getDetail(id, user));
       this.logger.log(
@@ -3037,7 +3026,7 @@ export class BookService {
     bookIds: number[],
     user: RequestUser,
     onProgress?: (bookId: number) => void,
-    options?: { isCancelled?: () => boolean },
+    options?: { isCancelled?: () => boolean; medium?: CoverMedium },
   ): Promise<{ processed: number; updated: number }> {
     const event = 'book.bulk_reextract_cover';
     const startedAt = Date.now();
@@ -3049,11 +3038,18 @@ export class BookService {
       }
       await this.verifyLibraryAccessForBookIds(bookIds, user);
 
-      const [files, coverLockedBookIds] = await Promise.all([
-        this.bookRepo.findPrimaryFilesByBookIds(bookIds),
+      const [files, coverLockedBookIds, audioCoverLockedBookIds] = await Promise.all([
+        this.bookRepo.findCoverSourceFilesByBookIds(bookIds),
         this.bookMetadataLockService.getCoverLockedBookIds(bookIds),
+        this.bookMetadataLockService.getBookIdsWithLockedField(bookIds, 'audioCover'),
       ]);
-      const filesByBookId = new Map(files.map((f) => [f.bookId, f]));
+      const filesByBookId = new Map<number, (typeof files)[number][]>();
+      for (const file of files) {
+        const entries = filesByBookId.get(file.bookId) ?? [];
+        entries.push(file);
+        filesByBookId.set(file.bookId, entries);
+      }
+      const media: readonly CoverMedium[] = options?.medium ? [options.medium] : COVER_MEDIA;
 
       let processed = 0;
       let updated = 0;
@@ -3065,17 +3061,27 @@ export class BookService {
           cancelled = true;
           break;
         }
-        const file = filesByBookId.get(id);
-        if (!file) continue;
-        if (coverLockedBookIds.has(id)) {
+        const candidateFiles = filesByBookId.get(id) ?? [];
+        const sources = selectEmbeddedCoverSources(candidateFiles, candidateFiles[0]?.formatPriority ?? DEFAULT_FORMAT_PRIORITY);
+        const targets = media.flatMap((medium) => {
+          const source = sources[medium];
+          return source ? [{ medium, source }] : [];
+        });
+        if (targets.length === 0) continue;
+        const unlocked = targets.filter(({ medium }) => !(medium === 'audio' ? audioCoverLockedBookIds : coverLockedBookIds).has(id));
+        if (unlocked.length === 0) {
           skipped++;
           continue;
         }
         processed++;
-        const saved = await this.metadataService.refreshCoverForBook(id, file.absolutePath, file.format ?? '');
+        let saved = false;
+        for (const { medium, source } of unlocked) {
+          saved = (await this.metadataService.refreshCoverForBook(id, source.absolutePath, source.format ?? '', medium)) || saved;
+        }
         if (saved) {
           updated++;
         }
+        if (!options?.medium) await this.coverReconciler?.enqueue([id]);
         try {
           onProgress?.(id);
         } catch {
@@ -3205,7 +3211,7 @@ export class BookService {
 
   async getDetail(id: number, user: RequestUser): Promise<BookDetailDto> {
     await this.verifyBookAccess(id, user);
-    const [result, personalRating, personalNote, readStatus, comicMeta, collectionRows, readAloudSyncMode] = await Promise.all([
+    const [result, personalRating, personalNote, readStatus, comicMeta, collectionRows, readAloudSyncMode, coverContext] = await Promise.all([
       this.bookRepo.findById(id),
       this.bookRepo.findRatingByBookAndUser(id, user.id),
       this.userBookNoteService.findOne(user.id, id),
@@ -3213,6 +3219,7 @@ export class BookService {
       this.comicMetadataService.findByBookId(id),
       this.bookRepo.findCollectionsByBookId(id, user.id),
       this.bookRepo.findReadAloudSyncMode(user.id, id),
+      this.coverStore.contextFor(id),
     ]);
     if (!result) throw new NotFoundException(`Book ${id} not found`);
 
@@ -3266,6 +3273,13 @@ export class BookService {
       personalNoteUpdatedAt: personalNote ? new Date(personalNote.updatedAt) : null,
       communityRatings: this.mapCommunityRatingRows(communityRatingRows),
       coverSource: (meta?.coverSource as 'extracted' | 'custom' | null) ?? null,
+      coverMedia: [...(coverContext?.media.hasEbook ? (['ebook'] as const) : []), ...(coverContext?.media.hasAudio ? (['audio'] as const) : [])],
+      covers: coverContext ? this.coverStore.slotDtos(coverContext) : { ebook: null, audio: null },
+      coverVersion: this.coverStore.coverVersion(
+        book.libraries?.coverAspectRatio ?? '2/3',
+        coverContext?.slots ?? [],
+        (meta?.coverUpdatedAt ?? book.books.updatedAt ?? book.books.addedAt).toISOString(),
+      ),
       hardcoverEditionId: meta?.hardcoverEditionId ?? null,
       lockedFields: this.bookMetadataLockService.normalizeLockedFields(meta?.lockedFields),
       providerIds: {
diff --git a/server/src/modules/book/dto/book-detail.dto.ts b/server/src/modules/book/dto/book-detail.dto.ts
index 3149e4106..8262c4fa3 100644
--- a/server/src/modules/book/dto/book-detail.dto.ts
+++ b/server/src/modules/book/dto/book-detail.dto.ts
@@ -6,6 +6,8 @@ import type {
   BookCommunityRating,
   CustomMetadataBookValue,
   ComicMetadataFields,
+  BookCoverSlot,
+  CoverMedium,
   NarratorRef,
   ProviderIds,
   ReadAloudProgressSync,
@@ -59,6 +61,9 @@ export class BookDetailDto {
   personalNoteUpdatedAt: Date | null;
   communityRatings: BookCommunityRating[];
   coverSource: 'extracted' | 'custom' | null;
+  coverMedia: CoverMedium[];
+  covers: Record<CoverMedium, BookCoverSlot | null>;
+  coverVersion: string;
   hardcoverEditionId: string | null;
   providerIds: ProviderIds;
   authors: { id: number; name: string; sortName: string | null }[];
diff --git a/server/src/modules/book/dto/cover-read-query.dto.ts b/server/src/modules/book/dto/cover-read-query.dto.ts
new file mode 100644
index 000000000..3a6c6be3f
--- /dev/null
+++ b/server/src/modules/book/dto/cover-read-query.dto.ts
@@ -0,0 +1 @@
+export { CoverReadQueryDto } from '../../cover/dto/cover-medium-query.dto';
diff --git a/server/src/modules/book/utils/assemble-book-cards.ts b/server/src/modules/book/utils/assemble-book-cards.ts
index 9b7ffe5a4..5a4d4a91f 100644
--- a/server/src/modules/book/utils/assemble-book-cards.ts
+++ b/server/src/modules/book/utils/assemble-book-cards.ts
@@ -237,6 +237,7 @@ export function assembleBookCards(
       readStatus: statusByBookId.get(row.id) ?? null,
       addedAt: row.addedAt.toISOString(),
       updatedAt: row.updatedAt?.toISOString() ?? null,
+      coverVersion: `legacy:${(row.updatedAt ?? row.addedAt).toISOString()}`,
       metadataScore: row.metadataScore ?? null,
       hasCover: row.coverSource != null,
       hasMetadataLocks: (row.lockedFields?.length ?? 0) > 0,
diff --git a/server/src/modules/cover/cover-slot-backfill.service.test.ts b/server/src/modules/cover/cover-slot-backfill.service.test.ts
new file mode 100644
index 000000000..96f5b7b66
--- /dev/null
+++ b/server/src/modules/cover/cover-slot-backfill.service.test.ts
@@ -0,0 +1,142 @@
+import { CoverSlotBackfillService } from './cover-slot-backfill.service';
+
+function makeService(options: { marker?: string | null; bothMediaIds?: number[]; repaired?: Array<{ bookId: number; libraryId: number }> } = {}) {
+  const appSettings = {
+    getValue: vi.fn().mockResolvedValue(options.marker ?? null),
+    setValue: vi.fn().mockResolvedValue(undefined),
+  };
+  const repository = {
+    listBookIdsAfter: vi.fn().mockResolvedValueOnce([1, 2, 3]).mockResolvedValueOnce([]),
+    listBookIdsWithBothCoverMediaAfter: vi
+      .fn()
+      .mockResolvedValueOnce(options.bothMediaIds ?? [])
+      .mockResolvedValueOnce([]),
+    repairCoverSummaries: vi.fn().mockResolvedValue(options.repaired ?? []),
+  };
+  const store = {
+    convertLegacy: vi.fn().mockImplementation((bookId: number) =>
+      Promise.resolve({
+        converted: bookId !== 3,
+        libraryId: bookId === 3 ? 20 : 10,
+      }),
+    ),
+  };
+  const reconciler = {
+    reconcile: vi
+      .fn()
+      .mockImplementation((bookId: number) => Promise.resolve({ libraryId: 10, changed: bookId !== 8, filled: bookId === 7 ? ['audio'] : [] })),
+  };
+  const events = { emitChanged: vi.fn() };
+  const config = { backfillMode: 'sync' };
+  const service = new CoverSlotBackfillService(
+    appSettings as never,
+    repository as never,
+    store as never,
+    events as never,
+    config as never,
+    reconciler as never,
+  );
+  return { service, appSettings, repository, store, reconciler, events };
+}
+
+function markers(appSettings: { setValue: ReturnType<typeof vi.fn> }) {
+  return appSettings.setValue.mock.calls.map(([, value]) => JSON.parse(value as string) as unknown);
+}
+
+describe('CoverSlotBackfillService', () => {
+  it('converts legacy covers, fills the second slot of books with both media, then repairs summaries', async () => {
+    const { service, appSettings, repository, store, reconciler, events } = makeService({ bothMediaIds: [7, 8] });
+
+    await expect(service.run()).resolves.toEqual({ processed: 5, converted: 2, filled: 1, failed: 0, repaired: 0 });
+
+    expect(repository.listBookIdsAfter).toHaveBeenNthCalledWith(1, 0, 200);
+    expect(repository.listBookIdsAfter).toHaveBeenNthCalledWith(2, 3, 200);
+    expect(store.convertLegacy).toHaveBeenNthCalledWith(1, 1, { emit: false });
+    expect(repository.listBookIdsWithBothCoverMediaAfter).toHaveBeenNthCalledWith(1, 0, 200);
+    expect(reconciler.reconcile).toHaveBeenCalledWith(7, { backfill: true });
+    expect(reconciler.reconcile).toHaveBeenCalledWith(8, { backfill: true });
+    expect(events.emitChanged.mock.calls).toEqual([[{ bookIds: [1, 2], libraryId: 10 }], [{ bookIds: [7], libraryId: 10 }]]);
+    expect(repository.repairCoverSummaries).toHaveBeenCalledOnce();
+    expect(markers(appSettings)).toEqual([
+      { version: 3, stage: 'a', lastBookId: 3 },
+      { version: 3, stage: 'b', lastBookId: 0 },
+      { version: 3, stage: 'b', lastBookId: 8 },
+      { version: 3, stage: 'c', lastBookId: 0 },
+      { version: 3, stage: 'complete', lastBookId: 0 },
+    ]);
+  });
+
+  it('resumes at stage B when only the first upgrade has completed', async () => {
+    const marker = JSON.stringify({ version: 1, stage: 'complete', lastBookId: 500 });
+    const { service, repository, store, reconciler } = makeService({ marker, bothMediaIds: [7] });
+
+    await expect(service.run()).resolves.toEqual({ processed: 1, converted: 0, filled: 1, failed: 0, repaired: 0 });
+
+    expect(repository.listBookIdsAfter).not.toHaveBeenCalled();
+    expect(store.convertLegacy).not.toHaveBeenCalled();
+    expect(repository.listBookIdsWithBothCoverMediaAfter).toHaveBeenNthCalledWith(1, 0, 200);
+    expect(reconciler.reconcile).toHaveBeenCalledOnce();
+  });
+
+  it('reruns stage B and then repairs summaries after a completed version 2 marker', async () => {
+    const marker = JSON.stringify({ version: 2, stage: 'complete', lastBookId: 0 });
+    const { service, appSettings, repository, store } = makeService({ marker, bothMediaIds: [7] });
+
+    await expect(service.run()).resolves.toMatchObject({ processed: 1, filled: 1, repaired: 0 });
+
+    expect(store.convertLegacy).not.toHaveBeenCalled();
+    expect(repository.listBookIdsWithBothCoverMediaAfter).toHaveBeenNthCalledWith(1, 0, 200);
+    expect(repository.repairCoverSummaries).toHaveBeenCalledOnce();
+    expect(markers(appSettings).at(-1)).toEqual({ version: 3, stage: 'complete', lastBookId: 0 });
+  });
+
+  it('announces every repaired book, batched per library', async () => {
+    const marker = JSON.stringify({ version: 3, stage: 'c', lastBookId: 0 });
+    const repaired = [
+      { bookId: 276, libraryId: 2 },
+      { bookId: 277, libraryId: 2 },
+      { bookId: 9, libraryId: 5 },
+    ];
+    const { service, repository, reconciler, events } = makeService({ marker, repaired });
+
+    await expect(service.run()).resolves.toEqual({ processed: 0, converted: 0, filled: 0, failed: 0, repaired: 3 });
+
+    expect(repository.listBookIdsWithBothCoverMediaAfter).not.toHaveBeenCalled();
+    expect(reconciler.reconcile).not.toHaveBeenCalled();
+    expect(events.emitChanged.mock.calls).toEqual([[{ bookIds: [276, 277], libraryId: 2 }], [{ bookIds: [9], libraryId: 5 }]]);
+  });
+
+  it('resumes stage B after the saved cursor', async () => {
+    const marker = JSON.stringify({ version: 2, stage: 'b', lastBookId: 40 });
+    const { service, repository } = makeService({ marker });
+
+    await service.run();
+
+    expect(repository.listBookIdsWithBothCoverMediaAfter).toHaveBeenNthCalledWith(1, 40, 200);
+  });
+
+  it('logs and skips a book that fails without stopping the stage', async () => {
+    const { service, appSettings, repository, reconciler } = makeService({ bothMediaIds: [7, 8] });
+    reconciler.reconcile.mockRejectedValueOnce(new Error('ffmpeg exploded'));
+
+    await expect(service.run()).resolves.toMatchObject({ processed: 5, failed: 1 });
+
+    expect(markers(appSettings).at(-1)).toEqual({ version: 3, stage: 'b', lastBookId: 8 });
+    expect(repository.repairCoverSummaries).not.toHaveBeenCalled();
+  });
+
+  it('does no work after the version marker is complete', async () => {
+    const marker = JSON.stringify({ version: 3, stage: 'complete', lastBookId: 0 });
+    const { service, appSettings, repository, store, reconciler, events } = makeService({ marker });
+
+    await expect(service.run()).resolves.toEqual({ processed: 0, converted: 0, filled: 0, failed: 0, repaired: 0 });
+
+    expect(repository.listBookIdsAfter).not.toHaveBeenCalled();
+    expect(repository.listBookIdsWithBothCoverMediaAfter).not.toHaveBeenCalled();
+    expect(store.convertLegacy).not.toHaveBeenCalled();
+    expect(reconciler.reconcile).not.toHaveBeenCalled();
+    expect(repository.repairCoverSummaries).not.toHaveBeenCalled();
+    expect(events.emitChanged).not.toHaveBeenCalled();
+    expect(appSettings.setValue).not.toHaveBeenCalled();
+  });
+});
diff --git a/server/src/modules/cover/cover-slot-backfill.service.ts b/server/src/modules/cover/cover-slot-backfill.service.ts
new file mode 100644
index 000000000..038777fb0
--- /dev/null
+++ b/server/src/modules/cover/cover-slot-backfill.service.ts
@@ -0,0 +1,225 @@
+import { Inject, Injectable, Logger, OnApplicationBootstrap } from '@nestjs/common';
+import type { ConfigType } from '@nestjs/config';
+
+import { sanitizeLogValue } from '../../common/utils/log-sanitize.utils';
+import { coverSlotsConfig } from '../../config/config';
+import { AppSettingsService } from '../app-settings/app-settings.service';
+import { BookCoverEventsService } from '../book-cover-store/book-cover-events.service';
+import { BookCoverStoreRepository } from '../book-cover-store/book-cover-store.repository';
+import { BookCoverStore } from '../book-cover-store/book-cover-store.service';
+import { CoverSlotReconciler } from '../metadata/cover-slot-reconciler.service';
+
+const SETTING_KEY = 'cover_slots_backfill';
+const VERSION = 3;
+const BATCH_SIZE = 200;
+const EVENT_BATCH_SIZE = 100;
+const PROGRESS_EVERY = 500;
+const STAGE_A_CONCURRENCY = 4;
+// Stage B spawns ffmpeg for every audiobook whose audio slot is empty.
+const STAGE_B_CONCURRENCY = 2;
+
+type Stage = 'a' | 'b' | 'c';
+type Marker = { version: number; stage: Stage | 'complete'; lastBookId: number };
+type BackfillTotals = { processed: number; converted: number; filled: number; failed: number; repaired: number };
+type BookOutcome = { libraryId: number | null; changed: boolean; converted: boolean; filled: number };
+
+/**
+ * The upgrade to per-medium cover slots. Stage A moves every legacy root cover into the slot that
+ * matches its shape; stage B fills the other slot of every book that has both media; stage C
+ * rewrites any `cover_source` summary that disagrees with the slots. A and B resume from an id
+ * cursor, C is one idempotent statement, and none of them moves `books.updated_at`.
+ */
+@Injectable()
+export class CoverSlotBackfillService implements OnApplicationBootstrap {
+  private readonly logger = new Logger(CoverSlotBackfillService.name);
+
+  constructor(
+    private readonly appSettings: AppSettingsService,
+    private readonly repository: BookCoverStoreRepository,
+    private readonly store: BookCoverStore,
+    private readonly events: BookCoverEventsService,
+    @Inject(coverSlotsConfig.KEY) private readonly config: ConfigType<typeof coverSlotsConfig>,
+    private readonly reconciler: CoverSlotReconciler,
+  ) {}
+
+  async onApplicationBootstrap(): Promise<void> {
+    if (this.config.backfillMode === 'skip') return;
+    if (this.config.backfillMode === 'sync') {
+      await this.run();
+      return;
+    }
+    const startedAt = Date.now();
+    void this.run().catch((error: unknown) => this.logFailure(error, startedAt));
+  }
+
+  async run(): Promise<BackfillTotals> {
+    const totals: BackfillTotals = { processed: 0, converted: 0, filled: 0, failed: 0, repaired: 0 };
+    const marker = this.parseMarker(await this.appSettings.getValue(SETTING_KEY));
+    if (marker?.stage === 'complete') return totals;
+
+    let stage: Stage = marker?.stage ?? 'a';
+    let cursor = marker?.lastBookId ?? 0;
+    if (stage === 'a') {
+      this.add(totals, await this.runStage('a', cursor));
+      stage = 'b';
+      cursor = 0;
+      await this.saveMarker({ version: VERSION, stage, lastBookId: cursor });
+    }
+
+    if (stage === 'b') {
+      const stageB = await this.runStage('b', cursor);
+      this.add(totals, stageB);
+      if (stageB.failed > 0) return totals;
+      await this.saveMarker({ version: VERSION, stage: 'c', lastBookId: 0 });
+    }
+
+    totals.repaired += await this.repairSummaries();
+    await this.saveMarker({ version: VERSION, stage: 'complete', lastBookId: 0 });
+    return totals;
+  }
+
+  private async repairSummaries(): Promise<number> {
+    const startedAt = Date.now();
+    this.logger.log(`[cover.slot_backfill] [start] stage=c processed=0 converted=0 filled=0 failed=0 repaired=0 - ${this.stageLabel('c')} started`);
+    const repaired = await this.repository.repairCoverSummaries();
+    const pendingEvents = new Map<number, number[]>();
+    for (const { bookId, libraryId } of repaired) this.bufferEvent(pendingEvents, libraryId, bookId);
+    this.flushEvents(pendingEvents);
+    this.logger.log(
+      `[cover.slot_backfill] [end] stage=c processed=0 converted=0 filled=0 failed=0 repaired=${repaired.length} durationMs=${Date.now() - startedAt} - ${this.stageLabel('c')} completed`,
+    );
+    return repaired.length;
+  }
+
+  private async runStage(stage: 'a' | 'b', startAfter: number): Promise<BackfillTotals> {
+    const startedAt = Date.now();
+    const totals: BackfillTotals = { processed: 0, converted: 0, filled: 0, failed: 0, repaired: 0 };
+    const pendingEvents = new Map<number, number[]>();
+    let cursor = startAfter;
+    let nextProgressAt = PROGRESS_EVERY;
+    const concurrency = stage === 'a' ? STAGE_A_CONCURRENCY : STAGE_B_CONCURRENCY;
+    this.logger.log(
+      `[cover.slot_backfill] [start] stage=${stage} processed=0 converted=0 filled=0 failed=0 lastBookId=${cursor} - ${this.stageLabel(stage)} started`,
+    );
+
+    while (true) {
+      const ids =
+        stage === 'a'
+          ? await this.repository.listBookIdsAfter(cursor, BATCH_SIZE)
+          : await this.repository.listBookIdsWithBothCoverMediaAfter(cursor, BATCH_SIZE);
+      if (ids.length === 0) break;
+      for (let offset = 0; offset < ids.length; offset += concurrency) {
+        const batch = ids.slice(offset, offset + concurrency);
+        const results = await Promise.allSettled(batch.map((bookId) => this.processBook(stage, bookId)));
+        for (let index = 0; index < results.length; index++) {
+          totals.processed++;
+          const result = results[index]!;
+          const bookId = batch[index]!;
+          if (result.status === 'rejected') {
+            totals.failed++;
+            this.logBookFailure(stage, bookId, totals, startedAt, result.reason);
+            continue;
+          }
+          if (result.value.converted) totals.converted++;
+          totals.filled += result.value.filled;
+          if (result.value.changed && result.value.libraryId !== null) this.bufferEvent(pendingEvents, result.value.libraryId, bookId);
+        }
+        if (totals.processed >= nextProgressAt) {
+          this.logger.log(
+            `[cover.slot_backfill] [end] stage=${stage} processed=${totals.processed} converted=${totals.converted} filled=${totals.filled} failed=${totals.failed} lastBookId=${batch.at(-1)!} durationMs=${Date.now() - startedAt} - progress`,
+          );
+          while (nextProgressAt <= totals.processed) nextProgressAt += PROGRESS_EVERY;
+        }
+      }
+      this.flushEvents(pendingEvents);
+      cursor = ids.at(-1)!;
+      await this.saveMarker({ version: VERSION, stage, lastBookId: cursor });
+    }
+
+    this.flushEvents(pendingEvents);
+    this.logger.log(
+      `[cover.slot_backfill] [end] stage=${stage} processed=${totals.processed} converted=${totals.converted} filled=${totals.filled} failed=${totals.failed} durationMs=${Date.now() - startedAt} - ${this.stageLabel(stage)} completed`,
+    );
+    return totals;
+  }
+
+  private async processBook(stage: 'a' | 'b', bookId: number): Promise<BookOutcome> {
+    if (stage === 'a') {
+      const result = await this.store.convertLegacy(bookId, { emit: false });
+      return { libraryId: result.libraryId, changed: result.converted, converted: result.converted, filled: 0 };
+    }
+    const result = await this.reconciler.reconcile(bookId, { backfill: true });
+    return { libraryId: result.libraryId, changed: result.changed, converted: false, filled: result.filled.length };
+  }
+
+  private bufferEvent(pending: Map<number, number[]>, libraryId: number, bookId: number): void {
+    const bookIds = pending.get(libraryId) ?? [];
+    bookIds.push(bookId);
+    pending.set(libraryId, bookIds);
+    if (bookIds.length < EVENT_BATCH_SIZE) return;
+    this.events.emitChanged({ bookIds, libraryId });
+    pending.delete(libraryId);
+  }
+
+  private flushEvents(pending: Map<number, number[]>): void {
+    for (const [libraryId, bookIds] of pending) this.events.emitChanged({ bookIds, libraryId });
+    pending.clear();
+  }
+
+  private add(totals: BackfillTotals, stage: BackfillTotals): void {
+    totals.processed += stage.processed;
+    totals.converted += stage.converted;
+    totals.filled += stage.filled;
+    totals.failed += stage.failed;
+    totals.repaired += stage.repaired;
+  }
+
+  private async saveMarker(marker: Marker): Promise<void> {
+    await this.appSettings.setValue(SETTING_KEY, JSON.stringify(marker));
+  }
+
+  private stageLabel(stage: Stage): string {
+    if (stage === 'a') return 'legacy cover conversion';
+    return stage === 'b' ? 'second cover extraction' : 'cover summary repair';
+  }
+
+  /**
+   * Markers older than version 3 predate stage C, and version 2's stage B chose its books with a
+   * cover media query that answered the same for every book. A completed older marker therefore
+   * resumes at stage B. Only unreleased builds ever wrote versions 1 and 2.
+   */
+  private parseMarker(raw: string | null): Omit<Marker, 'version'> | null {
+    if (!raw) return null;
+    try {
+      const parsed = JSON.parse(raw) as Partial<Marker>;
+      if (!Number.isSafeInteger(parsed.lastBookId)) return null;
+      if (parsed.version === 1 || parsed.version === 2) {
+        if (parsed.stage === 'complete') return { stage: 'b', lastBookId: 0 };
+        if (parsed.stage === 'a' || (parsed.version === 2 && parsed.stage === 'b')) return { stage: parsed.stage, lastBookId: parsed.lastBookId! };
+        return null;
+      }
+      if (parsed.version !== VERSION || (parsed.stage !== 'a' && parsed.stage !== 'b' && parsed.stage !== 'c' && parsed.stage !== 'complete')) {
+        return null;
+      }
+      return { stage: parsed.stage, lastBookId: parsed.lastBookId! };
+    } catch {
+      return null;
+    }
+  }
+
+  private logBookFailure(stage: Stage, bookId: number, totals: BackfillTotals, startedAt: number, reason: unknown): void {
+    const errorClass = reason instanceof Error ? reason.name : 'Error';
+    const error = sanitizeLogValue(reason instanceof Error ? reason.message : String(reason));
+    this.logger.warn(
+      `[cover.slot_backfill] [fail] stage=${stage} bookId=${bookId} processed=${totals.processed} converted=${totals.converted} filled=${totals.filled} failed=${totals.failed} durationMs=${Date.now() - startedAt} errorClass=${errorClass} error="${error}" - ${this.stageLabel(stage)} failed for one book`,
+    );
+  }
+
+  private logFailure(error: unknown, startedAt: number): void {
+    const errorClass = error instanceof Error ? error.name : 'Error';
+    const message = sanitizeLogValue(error instanceof Error ? error.message : String(error));
+    this.logger.error(
+      `[cover.slot_backfill] [fail] processed=0 converted=0 filled=0 failed=0 durationMs=${Date.now() - startedAt} errorClass=${errorClass} error="${message}" - cover slot upgrade stopped`,
+    );
+  }
+}
diff --git a/server/src/modules/cover/cover.controller.test.ts b/server/src/modules/cover/cover.controller.test.ts
index c4eb302fb..3fcafc7b1 100644
--- a/server/src/modules/cover/cover.controller.test.ts
+++ b/server/src/modules/cover/cover.controller.test.ts
@@ -80,4 +80,24 @@ describe('CoverController', () => {
     expect(coverService.uploadCoverFromUrl).toHaveBeenCalledWith(11, 'https://example.com/cover.jpg', user);
     expect(coverService.deleteCover).toHaveBeenCalledWith(11, user);
   });
+
+  it('forwards an explicit cover medium on every write route', async () => {
+    const buffer = Buffer.from('bytes');
+    const req = {
+      file: vi.fn().mockResolvedValue({
+        mimetype: 'image/png',
+        toBuffer: vi.fn().mockResolvedValue(buffer),
+      }),
+    };
+    const user = { id: 9 };
+    coverService.deleteCover.mockResolvedValue('custom');
+
+    await controller.uploadCover(11, user as never, req as never, { medium: 'audio' });
+    await controller.uploadCoverFromUrl(11, { url: 'https://example.com/cover.jpg' }, user as never, { medium: 'audio' });
+    await controller.deleteCover(11, user as never, { medium: 'audio' });
+
+    expect(coverService.uploadCover).toHaveBeenCalledWith(11, buffer, 'image/png', user, 'audio');
+    expect(coverService.uploadCoverFromUrl).toHaveBeenCalledWith(11, 'https://example.com/cover.jpg', user, 'audio');
+    expect(coverService.deleteCover).toHaveBeenCalledWith(11, user, 'audio');
+  });
 });
diff --git a/server/src/modules/cover/cover.controller.ts b/server/src/modules/cover/cover.controller.ts
index 6009a2340..c9b842303 100644
--- a/server/src/modules/cover/cover.controller.ts
+++ b/server/src/modules/cover/cover.controller.ts
@@ -9,6 +9,7 @@ import { CoverService } from './cover.service';
 import { SearchCoversQueryDto } from './dto/search-covers-query.dto';
 import { UploadCoverFromUrlDto } from './dto/upload-cover-from-url.dto';
 import { ProxyCoverQueryDto } from './dto/proxy-cover-query.dto';
+import { CoverMediumQueryDto } from './dto/cover-medium-query.dto';
 
 @Controller('books')
 export class CoverController {
@@ -35,24 +36,37 @@ export class CoverController {
   @Post(':id/cover')
   @HttpCode(HttpStatus.NO_CONTENT)
   @RequirePermission(Permission.LibraryEditMetadata)
-  async uploadCover(@Param('id', ParseIntPipe) id: number, @CurrentUser() user: RequestUser, @Req() req: MultipartRequest) {
+  async uploadCover(
+    @Param('id', ParseIntPipe) id: number,
+    @CurrentUser() user: RequestUser,
+    @Req() req: MultipartRequest,
+    @Query() query?: CoverMediumQueryDto,
+  ) {
     const data = await req.file();
     if (!data) throw new BadRequestException('No file provided');
     const buffer = await data.toBuffer();
-    await this.coverService.uploadCover(id, buffer, data.mimetype, user);
+    if (query?.medium) await this.coverService.uploadCover(id, buffer, data.mimetype, user, query.medium);
+    else await this.coverService.uploadCover(id, buffer, data.mimetype, user);
   }
 
   @Post(':id/cover/from-url')
   @HttpCode(HttpStatus.NO_CONTENT)
   @RequirePermission(Permission.LibraryEditMetadata)
-  uploadCoverFromUrl(@Param('id', ParseIntPipe) id: number, @Body() dto: UploadCoverFromUrlDto, @CurrentUser() user: RequestUser) {
-    return this.coverService.uploadCoverFromUrl(id, dto.url, user);
+  uploadCoverFromUrl(
+    @Param('id', ParseIntPipe) id: number,
+    @Body() dto: UploadCoverFromUrlDto,
+    @CurrentUser() user: RequestUser,
+    @Query() query?: CoverMediumQueryDto,
+  ) {
+    return query?.medium
+      ? this.coverService.uploadCoverFromUrl(id, dto.url, user, query.medium)
+      : this.coverService.uploadCoverFromUrl(id, dto.url, user);
   }
 
   @Delete(':id/cover')
   @RequirePermission(Permission.LibraryEditMetadata)
-  async deleteCover(@Param('id', ParseIntPipe) id: number, @CurrentUser() user: RequestUser) {
-    const coverSource = await this.coverService.deleteCover(id, user);
+  async deleteCover(@Param('id', ParseIntPipe) id: number, @CurrentUser() user: RequestUser, @Query() query?: CoverMediumQueryDto) {
+    const coverSource = query?.medium ? await this.coverService.deleteCover(id, user, query.medium) : await this.coverService.deleteCover(id, user);
     return { coverSource };
   }
 }
diff --git a/server/src/modules/cover/cover.module.ts b/server/src/modules/cover/cover.module.ts
index 436970506..c9af8d443 100644
--- a/server/src/modules/cover/cover.module.ts
+++ b/server/src/modules/cover/cover.module.ts
@@ -1,13 +1,17 @@
 import { Module } from '@nestjs/common';
 import { BookModule } from '../book/book.module';
+import { AppSettingsModule } from '../app-settings/app-settings.module';
+import { BookCoverStoreModule } from '../book-cover-store/book-cover-store.module';
 import { BookMetadataLockModule } from '../book-metadata-lock/book-metadata-lock.module';
 import { FileWriteModule } from '../file-write/file-write.module';
 import { LibraryModule } from '../library/library.module';
+import { MetadataModule } from '../metadata/metadata.module';
 import { MetadataPreferencesModule } from '../metadata-preferences/metadata-preferences.module';
 import { MetadataScoreModule } from '../metadata-score/metadata-score.module';
 import { COVER_PROVIDERS } from './constants';
 import { CoverController } from './cover.controller';
 import { CoverService } from './cover.service';
+import { CoverSlotBackfillService } from './cover-slot-backfill.service';
 import type { CoverProvider } from './providers/cover-provider';
 import { AudiobookCoversCoverProvider } from './providers/audiobookcovers-cover-provider';
 import { DuckDuckGoCoverProvider } from './providers/duckduckgo-cover-provider';
@@ -17,7 +21,17 @@ import { CoverProviderRegistry } from './provider-registry';
 const PROVIDER_CLASSES = [DuckDuckGoCoverProvider, ITunesCoverProvider, AudiobookCoversCoverProvider];
 
 @Module({
-  imports: [BookModule, BookMetadataLockModule, FileWriteModule, LibraryModule, MetadataPreferencesModule, MetadataScoreModule],
+  imports: [
+    AppSettingsModule,
+    BookModule,
+    BookCoverStoreModule,
+    BookMetadataLockModule,
+    FileWriteModule,
+    LibraryModule,
+    MetadataModule,
+    MetadataPreferencesModule,
+    MetadataScoreModule,
+  ],
   controllers: [CoverController],
   providers: [
     ...PROVIDER_CLASSES,
@@ -28,6 +42,7 @@ const PROVIDER_CLASSES = [DuckDuckGoCoverProvider, ITunesCoverProvider, Audioboo
     },
     CoverProviderRegistry,
     CoverService,
+    CoverSlotBackfillService,
   ],
   exports: [CoverService],
 })
diff --git a/server/src/modules/cover/cover.service.test.ts b/server/src/modules/cover/cover.service.test.ts
index acac1494e..c55c5c5b5 100644
--- a/server/src/modules/cover/cover.service.test.ts
+++ b/server/src/modules/cover/cover.service.test.ts
@@ -1,36 +1,18 @@
 import { type LookupAddress, lookup } from 'dns/promises';
-import { mkdir, readdir, readFile, rename, unlink, writeFile } from 'fs/promises';
+import { BadRequestException } from '@nestjs/common';
 import type { CoverSearchResult } from '@bookorbit/types';
 
 import type { RequestUser } from '../../common/types/request-user';
-import { coverDirPath, generateThumbnail, imageExt, normalizeProgressiveJpeg } from '../metadata/lib/cover';
-import { COVER_CUSTOM_FILE_PREFIX, COVER_PROXY_MAX_IMAGE_BYTES, COVER_PROXY_USER_AGENT, COVER_THUMBNAIL_FILE_NAME } from './constants';
+import { COVER_PROXY_MAX_IMAGE_BYTES, COVER_PROXY_USER_AGENT } from './constants';
 import { CoverService } from './cover.service';
 import type { CoverProviderRegistry } from './provider-registry';
 import { DUCKDUCKGO_PROVIDER_KEY, ITUNES_PROVIDER_KEY } from './providers/cover-provider';
 import { EMPTY_CONTENT_FILTER_RULES } from '@bookorbit/types';
-import { books } from '../../db/schema';
 
 vi.mock('dns/promises', () => ({
   lookup: vi.fn(),
 }));
 
-vi.mock('fs/promises', () => ({
-  mkdir: vi.fn(),
-  readdir: vi.fn(),
-  readFile: vi.fn(),
-  rename: vi.fn(),
-  writeFile: vi.fn(),
-  unlink: vi.fn(),
-}));
-
-vi.mock('../metadata/lib/cover', () => ({
-  coverDirPath: vi.fn(),
-  generateThumbnail: vi.fn(),
-  imageExt: vi.fn(),
-  normalizeProgressiveJpeg: vi.fn(),
-}));
-
 function makeResult(url: string, previewUrl: string): CoverSearchResult {
   return {
     url,
@@ -97,42 +79,33 @@ function makeUser(overrides: Partial<RequestUser> = {}): RequestUser {
 }
 
 function createService(providerRegistry: CoverProviderRegistry, options?: { assertFieldsUnlocked?: ReturnType<typeof vi.fn> }): CoverService {
-  return new CoverService(
-    {} as never,
-    { findLibraryIdByBookId: vi.fn().mockResolvedValue(7) } as never,
-    { assertFieldsUnlocked: options?.assertFieldsUnlocked ?? vi.fn().mockResolvedValue(undefined) } as never,
-    { scheduleWrite: vi.fn() } as never,
-    { verifyUserAccess: vi.fn().mockResolvedValue(undefined) } as never,
-    { get: vi.fn().mockReturnValue('/tmp/books') } as never,
-    providerRegistry,
-    { calculateAndSave: vi.fn().mockResolvedValue(undefined) } as never,
-  );
+  return createMutationService({ ...options, providerRegistry }).service;
 }
 
-function createMutationService(options?: { assertFieldsUnlocked?: ReturnType<typeof vi.fn> }) {
-  const onConflictDoUpdate = vi.fn().mockResolvedValue(undefined);
-  const values = vi.fn().mockReturnValue({ onConflictDoUpdate });
-  const insert = vi.fn().mockReturnValue({ values });
-  const updateWhere = vi.fn().mockResolvedValue(undefined);
-  const updateSet = vi.fn().mockReturnValue({ where: updateWhere });
-  const update = vi.fn().mockReturnValue({ set: updateSet });
-  const mockDb = { insert, update };
+function createMutationService(options?: { assertFieldsUnlocked?: ReturnType<typeof vi.fn>; providerRegistry?: CoverProviderRegistry }) {
   const scoreService = {
     calculateAndSave: vi.fn().mockResolvedValue(undefined),
   };
+  const fileWriteService = { scheduleWrite: vi.fn() };
+  const assertFieldsUnlocked = options?.assertFieldsUnlocked ?? vi.fn().mockResolvedValue(undefined);
+  const coverStore = {
+    chooseWriteMedium: vi.fn().mockResolvedValue('ebook'),
+    faceMediumFor: vi.fn().mockResolvedValue('ebook'),
+    saveCustom: vi.fn().mockResolvedValue(true),
+    revert: vi.fn().mockResolvedValue('extracted'),
+  };
 
   const service = new CoverService(
-    mockDb as never,
     { findLibraryIdByBookId: vi.fn().mockResolvedValue(7) } as never,
-    { assertFieldsUnlocked: options?.assertFieldsUnlocked ?? vi.fn().mockResolvedValue(undefined) } as never,
-    { scheduleWrite: vi.fn() } as never,
+    { assertFieldsUnlocked } as never,
+    fileWriteService as never,
     { verifyUserAccess: vi.fn().mockResolvedValue(undefined) } as never,
-    { get: vi.fn().mockReturnValue('/tmp/books') } as never,
-    { select: vi.fn().mockReturnValue([]) } as unknown as CoverProviderRegistry,
+    options?.providerRegistry ?? ({ select: vi.fn().mockReturnValue([]) } as unknown as CoverProviderRegistry),
     scoreService as never,
+    coverStore as never,
   );
 
-  return { service, mockDb, updateSet, scoreService, values, onConflictDoUpdate };
+  return { service, scoreService, fileWriteService, assertFieldsUnlocked, coverStore };
 }
 
 describe('CoverService', () => {
@@ -146,7 +119,6 @@ describe('CoverService', () => {
     lookupMock.mockResolvedValue([{ address: '93.184.216.34', family: 4 } as LookupAddress]);
     fetchMock = vi.fn();
     global.fetch = fetchMock as unknown as typeof fetch;
-    vi.mocked(normalizeProgressiveJpeg).mockImplementation((bytes) => Promise.resolve(bytes));
   });
 
   afterEach(() => {
@@ -444,226 +416,131 @@ describe('CoverService', () => {
   });
 
   describe('manual cover mutations', () => {
-    it('blocks upload when cover is locked', async () => {
+    it('blocks upload when the chosen slot is locked', async () => {
       const assertFieldsUnlocked = vi.fn().mockRejectedValue(new Error('locked'));
-      const service = createService({ select: vi.fn().mockReturnValue([]) } as unknown as CoverProviderRegistry, { assertFieldsUnlocked });
+      const { service, coverStore } = createMutationService({ assertFieldsUnlocked });
 
       await expect(service.uploadCover(12, Buffer.from('img'), 'image/png', makeUser())).rejects.toThrow('locked');
 
+      expect(coverStore.chooseWriteMedium).toHaveBeenCalledWith(12);
       expect(assertFieldsUnlocked).toHaveBeenCalledWith(12, ['cover']);
+      expect(coverStore.saveCustom).not.toHaveBeenCalled();
     });
 
-    it('blocks URL upload when cover is locked', async () => {
+    it('checks the audio cover lock for an upload into the audio slot', async () => {
       const assertFieldsUnlocked = vi.fn().mockRejectedValue(new Error('locked'));
-      const service = createService({ select: vi.fn().mockReturnValue([]) } as unknown as CoverProviderRegistry, { assertFieldsUnlocked });
+      const { service, coverStore } = createMutationService({ assertFieldsUnlocked });
 
-      await expect(service.uploadCoverFromUrl(12, 'https://example.com/cover.jpg', makeUser())).rejects.toThrow('locked');
+      await expect(service.uploadCover(12, Buffer.from('img'), 'image/png', makeUser(), 'audio')).rejects.toThrow('locked');
+
+      expect(coverStore.chooseWriteMedium).not.toHaveBeenCalled();
+      expect(assertFieldsUnlocked).toHaveBeenCalledWith(12, ['audioCover']);
+    });
+
+    it('checks a requested slot lock before fetching a URL upload', async () => {
+      const assertFieldsUnlocked = vi.fn().mockRejectedValue(new Error('locked'));
+      const { service, coverStore } = createMutationService({ assertFieldsUnlocked });
+
+      await expect(service.uploadCoverFromUrl(12, 'https://example.com/cover.jpg', makeUser(), 'ebook')).rejects.toThrow('locked');
 
       expect(fetchMock).not.toHaveBeenCalled();
       expect(assertFieldsUnlocked).toHaveBeenCalledWith(12, ['cover']);
+      expect(coverStore.saveCustom).not.toHaveBeenCalled();
     });
 
-    it('blocks delete when cover is locked', async () => {
+    it('puts an upload that names no slot in the face slot, whatever its shape, checking that lock before fetching', async () => {
       const assertFieldsUnlocked = vi.fn().mockRejectedValue(new Error('locked'));
-      const service = createService({ select: vi.fn().mockReturnValue([]) } as unknown as CoverProviderRegistry, { assertFieldsUnlocked });
+      const { service, coverStore } = createMutationService({ assertFieldsUnlocked });
+      coverStore.chooseWriteMedium.mockResolvedValue('audio');
+
+      await expect(service.uploadCoverFromUrl(12, 'https://example.com/cover.jpg', makeUser())).rejects.toThrow('locked');
+
+      expect(coverStore.chooseWriteMedium).toHaveBeenCalledWith(12);
+      expect(fetchMock).not.toHaveBeenCalled();
+      expect(assertFieldsUnlocked).toHaveBeenCalledTimes(1);
+      expect(assertFieldsUnlocked).toHaveBeenCalledWith(12, ['audioCover']);
+      expect(coverStore.saveCustom).not.toHaveBeenCalled();
+    });
+
+    it('saves a URL upload into the chosen slot', async () => {
+      const { service, coverStore, scoreService, fileWriteService } = createMutationService();
+      fetchMock.mockResolvedValueOnce(makeImageResponse(Buffer.from('remote'), 'image/png'));
+
+      await service.uploadCoverFromUrl(12, 'https://example.com/cover.png', makeUser());
+
+      expect(coverStore.saveCustom).toHaveBeenCalledWith(12, 'ebook', Buffer.from('remote'));
+      expect(scoreService.calculateAndSave).toHaveBeenCalledWith(12);
+      expect(fileWriteService.scheduleWrite).toHaveBeenCalledWith(12, 'auto', 1);
+    });
+
+    it('blocks delete when the face slot is locked', async () => {
+      const assertFieldsUnlocked = vi.fn().mockRejectedValue(new Error('locked'));
+      const { service, coverStore } = createMutationService({ assertFieldsUnlocked });
 
       await expect(service.deleteCover(12, makeUser())).rejects.toThrow('locked');
 
+      expect(coverStore.faceMediumFor).toHaveBeenCalledWith(12);
       expect(assertFieldsUnlocked).toHaveBeenCalledWith(12, ['cover']);
+      expect(coverStore.revert).not.toHaveBeenCalled();
     });
 
     it('rejects non-image mimetype on upload', async () => {
-      const { service } = createMutationService();
+      const { service, coverStore } = createMutationService();
 
       await expect(service.uploadCover(12, Buffer.from('img'), 'text/plain', makeUser())).rejects.toThrow('File must be an image');
+      expect(coverStore.saveCustom).not.toHaveBeenCalled();
     });
 
-    it('saves custom cover file and thumbnail when unlocked', async () => {
-      const { service, mockDb, updateSet, scoreService } = createMutationService();
+    it('saves the custom cover into the chosen slot when unlocked', async () => {
+      const { service, coverStore, scoreService, fileWriteService } = createMutationService();
       const source = Buffer.from('image-data');
-      const normalized = Buffer.from('normalized-image');
-
-      vi.mocked(coverDirPath).mockReturnValue('/tmp/books/covers/12');
-      vi.mocked(normalizeProgressiveJpeg).mockResolvedValue(normalized);
-      vi.mocked(imageExt).mockReturnValue('jpg');
-      vi.mocked(generateThumbnail).mockResolvedValue(Buffer.from('thumb'));
-      vi.mocked(readdir).mockResolvedValue([] as never);
-      vi.mocked(mkdir).mockResolvedValue(undefined as never);
-      vi.mocked(writeFile).mockResolvedValue(undefined);
-      vi.mocked(rename).mockResolvedValue(undefined);
 
       await service.uploadCover(12, source, 'image/jpeg', makeUser());
 
-      expect(normalizeProgressiveJpeg).toHaveBeenCalledWith(source);
-      expect(generateThumbnail).toHaveBeenCalledWith(normalized);
-      expect(mkdir).toHaveBeenCalledWith('/tmp/books/covers/12', { recursive: true });
-      expect(writeFile).toHaveBeenCalledTimes(2);
-      expect(writeFile).toHaveBeenCalledWith(expect.stringMatching(/^\/tmp\/books\/covers\/12\/\.cover-upload-.*\.jpg\.tmp$/), normalized);
-      expect(writeFile).toHaveBeenCalledWith(
-        expect.stringMatching(/^\/tmp\/books\/covers\/12\/\.cover-upload-.*\.thumbnail\.tmp$/),
-        Buffer.from('thumb'),
-      );
-      expect(rename).toHaveBeenNthCalledWith(
-        1,
-        expect.stringMatching(/^\/tmp\/books\/covers\/12\/\.cover-upload-.*\.thumbnail\.tmp$/),
-        `/tmp/books/covers/12/${COVER_THUMBNAIL_FILE_NAME}`,
-      );
-      expect(rename).toHaveBeenNthCalledWith(
-        2,
-        expect.stringMatching(/^\/tmp\/books\/covers\/12\/\.cover-upload-.*\.jpg\.tmp$/),
-        `/tmp/books/covers/12/${COVER_CUSTOM_FILE_PREFIX}jpg`,
-      );
-      expect(mockDb.update).toHaveBeenCalledWith(books);
-      expect(updateSet).toHaveBeenCalledWith({ updatedAt: expect.any(Date) });
+      expect(coverStore.saveCustom).toHaveBeenCalledWith(12, 'ebook', source);
       expect(scoreService.calculateAndSave).toHaveBeenCalledWith(12);
+      expect(fileWriteService.scheduleWrite).toHaveBeenCalledWith(12, 'auto', 1);
     });
 
-    it('propagates score persistence failures after updating the cover source', async () => {
-      const { service, scoreService } = createMutationService();
-      scoreService.calculateAndSave.mockRejectedValue(new Error('score failed'));
-      vi.mocked(coverDirPath).mockReturnValue('/tmp/books/covers/12');
-      vi.mocked(imageExt).mockReturnValue('jpg');
-      vi.mocked(generateThumbnail).mockResolvedValue(Buffer.from('thumb'));
-      vi.mocked(readdir).mockResolvedValue([] as never);
-      vi.mocked(mkdir).mockResolvedValue(undefined as never);
-      vi.mocked(writeFile).mockResolvedValue(undefined);
-      vi.mocked(rename).mockResolvedValue(undefined);
-
-      await expect(service.uploadCover(12, Buffer.from('image-data'), 'image/jpeg', makeUser())).rejects.toThrow('score failed');
-    });
-
-    it('preserves the existing cover when image normalization fails', async () => {
-      const { service, mockDb } = createMutationService();
-      vi.mocked(normalizeProgressiveJpeg).mockRejectedValue(new Error('invalid image'));
+    it('propagates an invalid image from the store without scoring or scheduling a write', async () => {
+      const { service, coverStore, scoreService, fileWriteService } = createMutationService();
+      coverStore.saveCustom.mockRejectedValue(new BadRequestException('Invalid image file'));
 
       await expect(service.uploadCover(12, Buffer.from('invalid'), 'image/jpeg', makeUser())).rejects.toThrow('Invalid image file');
 
-      expect(mkdir).not.toHaveBeenCalled();
-      expect(writeFile).not.toHaveBeenCalled();
-      expect(rename).not.toHaveBeenCalled();
-      expect(unlink).not.toHaveBeenCalled();
-      expect(mockDb.insert).not.toHaveBeenCalled();
+      expect(scoreService.calculateAndSave).not.toHaveBeenCalled();
+      expect(fileWriteService.scheduleWrite).not.toHaveBeenCalled();
     });
 
-    it('removes obsolete custom-cover formats only after replacing both files', async () => {
-      const { service } = createMutationService();
+    it('propagates score persistence failures after saving the cover', async () => {
+      const { service, coverStore, scoreService } = createMutationService();
+      scoreService.calculateAndSave.mockRejectedValue(new Error('score failed'));
 
-      vi.mocked(coverDirPath).mockReturnValue('/tmp/books/covers/12');
-      vi.mocked(imageExt).mockReturnValue('jpg');
-      vi.mocked(generateThumbnail).mockResolvedValue(Buffer.from('thumb'));
-      vi.mocked(readdir).mockResolvedValue(['cover_custom.png', 'cover_custom.jpg'] as never);
-      vi.mocked(mkdir).mockResolvedValue(undefined as never);
-      vi.mocked(writeFile).mockResolvedValue(undefined);
-      vi.mocked(rename).mockResolvedValue(undefined);
-      vi.mocked(unlink).mockResolvedValue(undefined);
-
-      await service.uploadCover(12, Buffer.from('image-data'), 'image/jpeg', makeUser());
-
-      expect(unlink).toHaveBeenCalledWith('/tmp/books/covers/12/cover_custom.png');
-      expect(unlink).not.toHaveBeenCalledWith('/tmp/books/covers/12/cover_custom.jpg');
-      expect(vi.mocked(unlink).mock.invocationCallOrder[0]).toBeGreaterThan(vi.mocked(rename).mock.invocationCallOrder[1]);
+      await expect(service.uploadCover(12, Buffer.from('image-data'), 'image/jpeg', makeUser())).rejects.toThrow('score failed');
+      expect(coverStore.saveCustom).toHaveBeenCalled();
     });
 
-    it('keeps the old custom cover when atomic replacement fails', async () => {
-      const { service, mockDb } = createMutationService();
+    it('reverts the requested slot and schedules a write when a cover remains', async () => {
+      const { service, coverStore, scoreService, fileWriteService } = createMutationService();
 
-      vi.mocked(coverDirPath).mockReturnValue('/tmp/books/covers/12');
-      vi.mocked(imageExt).mockReturnValue('jpg');
-      vi.mocked(generateThumbnail).mockResolvedValue(Buffer.from('thumb'));
-      vi.mocked(mkdir).mockResolvedValue(undefined as never);
-      vi.mocked(writeFile).mockResolvedValue(undefined);
-      vi.mocked(rename).mockResolvedValueOnce(undefined).mockRejectedValueOnce(new Error('rename failed'));
-      vi.mocked(unlink).mockRejectedValue(new Error('cleanup failed'));
-
-      await expect(service.uploadCover(12, Buffer.from('image-data'), 'image/jpeg', makeUser())).rejects.toThrow('rename failed');
-
-      expect(readdir).not.toHaveBeenCalled();
-      expect(unlink).not.toHaveBeenCalledWith('/tmp/books/covers/12/cover_custom.jpg');
-      expect(unlink).toHaveBeenCalledWith(expect.stringMatching(/^\/tmp\/books\/covers\/12\/\.cover-upload-.*\.jpg\.tmp$/));
-      expect(mockDb.insert).not.toHaveBeenCalled();
-    });
-
-    it('removes custom cover and restores extracted if available', async () => {
-      const { service } = createMutationService();
-
-      vi.mocked(coverDirPath).mockReturnValue('/tmp/books/covers/12');
-      vi.mocked(readdir).mockResolvedValue(['cover_custom.jpg', 'cover_extracted.png'] as never);
-      vi.mocked(readFile).mockResolvedValue(Buffer.from('extracted-img'));
-      vi.mocked(generateThumbnail).mockResolvedValue(Buffer.from('thumb'));
-      vi.mocked(unlink).mockResolvedValue(undefined);
-      vi.mocked(writeFile).mockResolvedValue(undefined);
-
-      const result = await service.deleteCover(12, makeUser());
+      const result = await service.deleteCover(12, makeUser(), 'audio');
 
       expect(result).toBe('extracted');
-      expect(unlink).toHaveBeenCalledWith('/tmp/books/covers/12/cover_custom.jpg');
+      expect(coverStore.faceMediumFor).not.toHaveBeenCalled();
+      expect(coverStore.revert).toHaveBeenCalledWith(12, 'audio');
+      expect(scoreService.calculateAndSave).toHaveBeenCalledWith(12);
+      expect(fileWriteService.scheduleWrite).toHaveBeenCalledWith(12, 'auto', 1);
     });
 
-    it('returns null when no extracted cover exists after delete', async () => {
-      const { service } = createMutationService();
-
-      vi.mocked(coverDirPath).mockReturnValue('/tmp/books/covers/12');
-      vi.mocked(readdir).mockResolvedValue(['cover_custom.jpg'] as never);
-      vi.mocked(unlink).mockResolvedValue(undefined);
+    it('returns null and schedules no write when no cover remains after delete', async () => {
+      const { service, coverStore, fileWriteService } = createMutationService();
+      coverStore.revert.mockResolvedValue(null);
 
       const result = await service.deleteCover(12, makeUser());
 
       expect(result).toBeNull();
-    });
-  });
-
-  // A Kobo device keys its locally stored cover by CoverImageId, which is versioned from
-  // coverUpdatedAt. Leaving the stamp behind here strands the device on a stale picture.
-  describe('coverUpdatedAt stamping (issue #943)', () => {
-    it('stamps coverUpdatedAt when a custom cover is uploaded', async () => {
-      const { service, values, onConflictDoUpdate } = createMutationService();
-
-      vi.mocked(coverDirPath).mockReturnValue('/tmp/books/covers/12');
-      vi.mocked(imageExt).mockReturnValue('jpg');
-      vi.mocked(generateThumbnail).mockResolvedValue(Buffer.from('thumb'));
-      vi.mocked(readdir).mockResolvedValue([] as never);
-      vi.mocked(mkdir).mockResolvedValue(undefined as never);
-      vi.mocked(writeFile).mockResolvedValue(undefined);
-      vi.mocked(rename).mockResolvedValue(undefined);
-
-      await service.uploadCover(12, Buffer.from('image-data'), 'image/jpeg', makeUser());
-
-      expect(values).toHaveBeenCalledWith({ bookId: 12, coverSource: 'custom', coverUpdatedAt: expect.any(Date), updatedAt: expect.any(Date) });
-      expect(onConflictDoUpdate).toHaveBeenCalledWith(
-        expect.objectContaining({ set: { coverSource: 'custom', coverUpdatedAt: expect.any(Date), updatedAt: expect.any(Date) } }),
-      );
-    });
-
-    it('stamps coverUpdatedAt when deleting the last cover leaves the book without one', async () => {
-      const { service, values } = createMutationService();
-
-      vi.mocked(coverDirPath).mockReturnValue('/tmp/books/covers/12');
-      vi.mocked(readdir).mockResolvedValue(['cover_custom.jpg'] as never);
-      vi.mocked(unlink).mockResolvedValue(undefined);
-
-      await service.deleteCover(12, makeUser());
-
-      expect(values).toHaveBeenCalledWith({ bookId: 12, coverSource: null, coverUpdatedAt: expect.any(Date), updatedAt: expect.any(Date) });
-    });
-
-    it('stamps coverUpdatedAt when deleting a custom cover falls back to the extracted one', async () => {
-      const { service, values } = createMutationService();
-
-      vi.mocked(coverDirPath).mockReturnValue('/tmp/books/covers/12');
-      vi.mocked(readdir).mockResolvedValue(['cover_custom.jpg', 'cover_extracted.png'] as never);
-      vi.mocked(readFile).mockResolvedValue(Buffer.from('extracted-img'));
-      vi.mocked(generateThumbnail).mockResolvedValue(Buffer.from('thumb'));
-      vi.mocked(unlink).mockResolvedValue(undefined);
-      vi.mocked(writeFile).mockResolvedValue(undefined);
-
-      await service.deleteCover(12, makeUser());
-
-      expect(values).toHaveBeenCalledWith({
-        bookId: 12,
-        coverSource: 'extracted',
-        coverUpdatedAt: expect.any(Date),
-        updatedAt: expect.any(Date),
-      });
+      expect(coverStore.revert).toHaveBeenCalledWith(12, 'ebook');
+      expect(fileWriteService.scheduleWrite).not.toHaveBeenCalled();
     });
   });
 });
diff --git a/server/src/modules/cover/cover.service.ts b/server/src/modules/cover/cover.service.ts
index e1630a51a..cc51cfd0e 100644
--- a/server/src/modules/cover/cover.service.ts
+++ b/server/src/modules/cover/cover.service.ts
@@ -1,32 +1,17 @@
-import { BadRequestException, Inject, Injectable, Logger, NotFoundException } from '@nestjs/common';
-import { ConfigService } from '@nestjs/config';
-import { CoverSearchResult } from '@bookorbit/types';
-import { randomUUID } from 'crypto';
-import { eq } from 'drizzle-orm';
-import { NodePgDatabase } from 'drizzle-orm/node-postgres';
-import { mkdir, readdir, readFile, rename, unlink, writeFile } from 'fs/promises';
-import { basename, join } from 'path';
+import { BadRequestException, Injectable, Logger, NotFoundException } from '@nestjs/common';
+import { CoverSearchResult, type CoverMedium } from '@bookorbit/types';
+import type { BookCoverSource } from '../book-cover-store/book-cover-store.repository';
 
-import { bookCoverDirPath, bookThumbnailPath, findPreferredBookCoverFileName, isCustomBookCoverFileName } from '../../common/book-cover-storage';
 import type { RequestUser } from '../../common/types/request-user';
 import { sanitizeLogValue } from '../../common/utils/log-sanitize.utils';
 import { ensureSafeRemoteHost } from '../../common/utils/ssrf.utils';
-import { DB } from '../../db';
-import * as schema from '../../db/schema';
-import { bookMetadata, books } from '../../db/schema';
 import { BookReadService } from '../book/book-read.service';
+import { BookCoverStore } from '../book-cover-store/book-cover-store.service';
 import { BookMetadataLockService } from '../book-metadata-lock/book-metadata-lock.service';
 import { FileWriteService } from '../file-write/file-write.service';
 import { LibraryService } from '../library/library.service';
-import { generateThumbnail, imageExt, normalizeProgressiveJpeg } from '../metadata/lib/cover';
 import { MetadataScoreService } from '../metadata-score/metadata-score.service';
-import {
-  COVER_CUSTOM_FILE_PREFIX,
-  COVER_PROXY_MAX_IMAGE_BYTES,
-  COVER_PROXY_MAX_REDIRECTS,
-  COVER_PROXY_TIMEOUT_MS,
-  COVER_PROXY_USER_AGENT,
-} from './constants';
+import { COVER_PROXY_MAX_IMAGE_BYTES, COVER_PROXY_MAX_REDIRECTS, COVER_PROXY_TIMEOUT_MS, COVER_PROXY_USER_AGENT } from './constants';
 import { CoverProviderRegistry } from './provider-registry';
 import {
   COVER_PROVIDER_ALL_KEY,
@@ -36,8 +21,6 @@ import {
   ITUNES_PROVIDER_KEY,
 } from './providers/cover-provider';
 
-type Db = NodePgDatabase<typeof schema>;
-
 const SAFE_REMOTE_PROTOCOLS = new Set(['http:', 'https:']);
 const REDIRECT_STATUS_CODES = new Set([301, 302, 303, 307, 308]);
 const ITUNES_INTERLEAVE_LIMIT = 5;
@@ -45,20 +28,16 @@ const ITUNES_INTERLEAVE_LIMIT = 5;
 @Injectable()
 export class CoverService {
   private readonly logger = new Logger(CoverService.name);
-  private readonly appDataPath: string;
 
   constructor(
-    @Inject(DB) private readonly db: Db,
     private readonly bookReadService: BookReadService,
     private readonly bookMetadataLockService: BookMetadataLockService,
     private readonly fileWriteService: FileWriteService,
     private readonly libraryService: LibraryService,
-    private readonly config: ConfigService,
     private readonly providerRegistry: CoverProviderRegistry,
     private readonly metadataScoreService: MetadataScoreService,
-  ) {
-    this.appDataPath = this.config.get<string>('storage.appDataPath')!;
-  }
+    private readonly coverStore: BookCoverStore,
+  ) {}
 
   async searchCovers(params: CoverSearchParams & { provider?: string }): Promise<CoverSearchResult[]> {
     const { provider, ...searchParams } = params;
@@ -111,16 +90,17 @@ export class CoverService {
     }
   }
 
-  async uploadCover(bookId: number, buffer: Buffer, mimeType: string, user: RequestUser): Promise<void> {
+  async uploadCover(bookId: number, buffer: Buffer, mimeType: string, user: RequestUser, requestedMedium?: CoverMedium): Promise<void> {
     const startedAt = Date.now();
     this.logger.log(`[cover.upload] [start] bookId=${bookId} userId=${user.id} - custom cover upload started`);
 
     try {
       if (!mimeType.startsWith('image/')) throw new BadRequestException('File must be an image');
       await this.verifyAccess(bookId, user);
-      await this.bookMetadataLockService.assertFieldsUnlocked(bookId, ['cover']);
-      await this.saveCustomCover(bookId, buffer);
-      await this.setCoverSource(bookId, 'custom');
+      const medium = requestedMedium ?? (await this.unspecifiedWriteMedium(bookId));
+      await this.bookMetadataLockService.assertFieldsUnlocked(bookId, [this.lockField(medium)]);
+      await this.coverStore.saveCustom(bookId, medium, buffer);
+      await this.metadataScoreService.calculateAndSave(bookId);
       this.fileWriteService.scheduleWrite(bookId, 'auto', user.id);
       this.logger.log(
         `[cover.upload] [end] bookId=${bookId} userId=${user.id} durationMs=${Date.now() - startedAt} coverSource=custom - custom cover upload completed`,
@@ -133,7 +113,7 @@ export class CoverService {
     }
   }
 
-  async uploadCoverFromUrl(bookId: number, url: string, user: RequestUser): Promise<void> {
+  async uploadCoverFromUrl(bookId: number, url: string, user: RequestUser, requestedMedium?: CoverMedium): Promise<void> {
     const startedAt = Date.now();
     this.logger.log(
       `[cover.upload_from_url] [start] bookId=${bookId} userId=${user.id} urlHost=${hostForLog(url)} - custom cover upload from URL started`,
@@ -141,10 +121,11 @@ export class CoverService {
 
     try {
       await this.verifyAccess(bookId, user);
-      await this.bookMetadataLockService.assertFieldsUnlocked(bookId, ['cover']);
+      const medium = requestedMedium ?? (await this.unspecifiedWriteMedium(bookId));
+      await this.bookMetadataLockService.assertFieldsUnlocked(bookId, [this.lockField(medium)]);
       const { buffer } = await this.fetchRemoteImage(url);
-      await this.saveCustomCover(bookId, buffer);
-      await this.setCoverSource(bookId, 'custom');
+      await this.coverStore.saveCustom(bookId, medium, buffer);
+      await this.metadataScoreService.calculateAndSave(bookId);
       this.fileWriteService.scheduleWrite(bookId, 'auto', user.id);
       this.logger.log(
         `[cover.upload_from_url] [end] bookId=${bookId} userId=${user.id} urlHost=${hostForLog(url)} durationMs=${Date.now() - startedAt} coverSource=custom - custom cover upload from URL completed`,
@@ -157,35 +138,21 @@ export class CoverService {
     }
   }
 
-  async deleteCover(bookId: number, user: RequestUser): Promise<'extracted' | null> {
+  async deleteCover(bookId: number, user: RequestUser, requestedMedium?: CoverMedium): Promise<BookCoverSource | null> {
     const startedAt = Date.now();
     this.logger.log(`[cover.delete] [start] bookId=${bookId} userId=${user.id} - cover deletion started`);
 
     try {
       await this.verifyAccess(bookId, user);
-      await this.bookMetadataLockService.assertFieldsUnlocked(bookId, ['cover']);
-      const dir = bookCoverDirPath(this.appDataPath, bookId);
-      await this.deleteFilesByPrefix(dir, COVER_CUSTOM_FILE_PREFIX);
-
-      const fallbackPath = await this.findFallbackCover(bookId);
-      if (!fallbackPath) {
-        await this.removeFileIfPresent(bookThumbnailPath(this.appDataPath, bookId));
-        await this.setCoverSource(bookId, null);
-        this.logger.log(
-          `[cover.delete] [end] bookId=${bookId} userId=${user.id} durationMs=${Date.now() - startedAt} coverSource=null - cover deletion completed`,
-        );
-        return null;
-      }
-
-      const bytes = await readFile(fallbackPath);
-      const thumb = await generateThumbnail(bytes);
-      await writeFile(bookThumbnailPath(this.appDataPath, bookId), thumb);
-      await this.setCoverSource(bookId, 'extracted');
-      this.fileWriteService.scheduleWrite(bookId, 'auto', user.id);
+      const medium = requestedMedium ?? (await this.coverStore.faceMediumFor(bookId));
+      await this.bookMetadataLockService.assertFieldsUnlocked(bookId, [this.lockField(medium)]);
+      const coverSource = await this.coverStore.revert(bookId, medium);
+      await this.metadataScoreService.calculateAndSave(bookId);
+      if (coverSource) this.fileWriteService.scheduleWrite(bookId, 'auto', user.id);
       this.logger.log(
-        `[cover.delete] [end] bookId=${bookId} userId=${user.id} durationMs=${Date.now() - startedAt} coverSource=extracted - cover deletion completed`,
+        `[cover.delete] [end] bookId=${bookId} userId=${user.id} durationMs=${Date.now() - startedAt} coverSource=${coverSource ?? 'null'} - cover deletion completed`,
       );
-      return 'extracted';
+      return coverSource;
     } catch (error) {
       this.logger.warn(
         `[cover.delete] [fail] bookId=${bookId} userId=${user.id} durationMs=${Date.now() - startedAt} errorClass=${errorClass(error)} error="${sanitizeErrorMessage(error)}" - cover deletion failed`,
@@ -242,71 +209,23 @@ export class CoverService {
     return deduped;
   }
 
-  private async saveCustomCover(bookId: number, buffer: Buffer): Promise<void> {
-    let coverBytes: Buffer;
-    let thumb: Buffer;
-    try {
-      coverBytes = await normalizeProgressiveJpeg(buffer);
-      thumb = await generateThumbnail(coverBytes);
-    } catch {
-      throw new BadRequestException('Invalid image file');
-    }
-
-    const dir = bookCoverDirPath(this.appDataPath, bookId);
-    await mkdir(dir, { recursive: true });
-
-    const ext = imageExt(coverBytes);
-    const coverPath = join(dir, `${COVER_CUSTOM_FILE_PREFIX}${ext}`);
-    const thumbnailPath = bookThumbnailPath(this.appDataPath, bookId);
-    const tempId = randomUUID();
-    const tempCoverPath = join(dir, `.cover-upload-${tempId}.${ext}.tmp`);
-    const tempThumbnailPath = join(dir, `.cover-upload-${tempId}.thumbnail.tmp`);
-    let tempCoverExists = false;
-    let tempThumbnailExists = false;
-
-    try {
-      await writeFile(tempCoverPath, coverBytes);
-      tempCoverExists = true;
-      await writeFile(tempThumbnailPath, thumb);
-      tempThumbnailExists = true;
-
-      await rename(tempThumbnailPath, thumbnailPath);
-      tempThumbnailExists = false;
-      await rename(tempCoverPath, coverPath);
-      tempCoverExists = false;
-      await this.deleteFilesByPrefix(dir, COVER_CUSTOM_FILE_PREFIX, basename(coverPath));
-    } finally {
-      const cleanupPaths = [...(tempCoverExists ? [tempCoverPath] : []), ...(tempThumbnailExists ? [tempThumbnailPath] : [])];
-      await Promise.all(cleanupPaths.map((path) => this.cleanupTemporaryCoverFile(bookId, path)));
-    }
-  }
-
-  /**
-   * Resolves the cover left behind once the custom cover is deleted. This must use the same
-   * preference order the cover endpoint serves from, including legacy `cover.*` files: matching on
-   * extracted covers alone dropped the thumbnail for a book the endpoint still served (issue #1475).
-   */
-  private async findFallbackCover(bookId: number): Promise<string | null> {
-    const dir = bookCoverDirPath(this.appDataPath, bookId);
-    const files = await this.readDirIfExists(dir);
-    const found = findPreferredBookCoverFileName(files.filter((fileName) => !isCustomBookCoverFileName(fileName)));
-    return found ? join(dir, found) : null;
-  }
-
   private async verifyAccess(bookId: number, user: RequestUser): Promise<void> {
     const libraryId = await this.bookReadService.findLibraryIdByBookId(bookId);
     if (libraryId === null) throw new NotFoundException(`Book ${bookId} not found`);
     await this.libraryService.verifyUserAccess(user.id, libraryId, user.isSuperuser);
   }
 
-  private async setCoverSource(bookId: number, source: 'extracted' | 'custom' | null): Promise<void> {
-    const now = new Date();
-    await this.db
-      .insert(bookMetadata)
-      .values({ bookId, coverSource: source, coverUpdatedAt: now, updatedAt: now })
-      .onConflictDoUpdate({ target: bookMetadata.bookId, set: { coverSource: source, coverUpdatedAt: now, updatedAt: now } });
-    await this.db.update(books).set({ updatedAt: now }).where(eq(books.id, bookId));
-    await this.metadataScoreService.calculateAndSave(bookId);
+  /**
+   * A write that names no slot comes from a client that shows one cover per book, the face, such as
+   * an iOS build from before cover slots. It lands in the slot the face shows, not in the slot its
+   * shape suits, or a square image picked for a 2:3 library would change nothing that client sees.
+   */
+  private unspecifiedWriteMedium(bookId: number): Promise<CoverMedium> {
+    return this.coverStore.chooseWriteMedium(bookId);
+  }
+
+  private lockField(medium: CoverMedium): 'cover' | 'audioCover' {
+    return medium === 'ebook' ? 'cover' : 'audioCover';
   }
 
   private async fetchRemoteImage(rawUrl: string): Promise<{ buffer: Buffer; contentType: string }> {
@@ -423,42 +342,6 @@ export class CoverService {
     return Buffer.concat(chunks);
   }
 
-  private async readDirIfExists(path: string): Promise<string[]> {
-    try {
-      return await readdir(path);
-    } catch (error) {
-      if (hasErrorCode(error, 'ENOENT')) return [];
-      throw error;
-    }
-  }
-
-  private async deleteFilesByPrefix(path: string, prefix: string, exceptFileName?: string): Promise<void> {
-    const files = await this.readDirIfExists(path);
-    for (const fileName of files) {
-      if (!fileName.startsWith(prefix) || fileName === exceptFileName) continue;
-      await this.removeFileIfPresent(join(path, fileName));
-    }
-  }
-
-  private async removeFileIfPresent(path: string): Promise<void> {
-    try {
-      await unlink(path);
-    } catch (error) {
-      if (hasErrorCode(error, 'ENOENT')) return;
-      throw error;
-    }
-  }
-
-  private async cleanupTemporaryCoverFile(bookId: number, path: string): Promise<void> {
-    try {
-      await this.removeFileIfPresent(path);
-    } catch (error) {
-      this.logger.warn(
-        `[cover.upload_cleanup] [fail] bookId=${bookId} errorClass=${errorClass(error)} error="${sanitizeErrorMessage(error)}" - temporary cover upload file cleanup failed`,
-      );
-    }
-  }
-
   private isRedirectStatus(status: number): boolean {
     return REDIRECT_STATUS_CODES.has(status);
   }
@@ -472,10 +355,6 @@ function hostForLog(rawUrl: string): string {
   }
 }
 
-function hasErrorCode(error: unknown, code: string): boolean {
-  return Boolean(error && typeof error === 'object' && 'code' in error && (error as { code?: string }).code === code);
-}
-
 function sanitizeErrorMessage(error: unknown): string {
   const message = error instanceof Error ? error.message : String(error);
   return sanitizeLogValue(message);
diff --git a/server/src/modules/cover/dto/cover-medium-query.dto.test.ts b/server/src/modules/cover/dto/cover-medium-query.dto.test.ts
new file mode 100644
index 000000000..6f194c028
--- /dev/null
+++ b/server/src/modules/cover/dto/cover-medium-query.dto.test.ts
@@ -0,0 +1,27 @@
+import { plainToInstance } from 'class-transformer';
+import { validate } from 'class-validator';
+
+import { CoverMediumQueryDto, CoverReadQueryDto } from './cover-medium-query.dto';
+
+describe('cover query DTOs', () => {
+  it.each(['ebook', 'audio'])('accepts the %s medium', async (medium) => {
+    await expect(validate(plainToInstance(CoverMediumQueryDto, { medium }))).resolves.toHaveLength(0);
+  });
+
+  it('rejects unknown media', async () => {
+    await expect(validate(plainToInstance(CoverMediumQueryDto, { medium: 'print' }))).resolves.not.toHaveLength(0);
+  });
+
+  it.each([
+    ['true', true],
+    ['false', false],
+  ] as const)('transforms strict=%s to %s', async (input, expected) => {
+    const dto = plainToInstance(CoverReadQueryDto, { strict: input });
+    await expect(validate(dto)).resolves.toHaveLength(0);
+    expect(dto.strict).toBe(expected);
+  });
+
+  it('rejects non-boolean strict values', async () => {
+    await expect(validate(plainToInstance(CoverReadQueryDto, { strict: 'yes' }))).resolves.not.toHaveLength(0);
+  });
+});
diff --git a/server/src/modules/cover/dto/cover-medium-query.dto.ts b/server/src/modules/cover/dto/cover-medium-query.dto.ts
new file mode 100644
index 000000000..35c9bf500
--- /dev/null
+++ b/server/src/modules/cover/dto/cover-medium-query.dto.ts
@@ -0,0 +1,19 @@
+import { COVER_MEDIA, type CoverMedium } from '@bookorbit/types';
+import { Transform } from 'class-transformer';
+import { IsBoolean, IsIn, IsOptional } from 'class-validator';
+
+export class CoverMediumQueryDto {
+  @IsOptional()
+  @IsIn(COVER_MEDIA)
+  medium?: CoverMedium;
+}
+
+export class CoverReadQueryDto extends CoverMediumQueryDto {
+  @IsOptional()
+  @Transform(({ value }) => (value === 'true' || value === true ? true : value === 'false' || value === false ? false : value))
+  @IsBoolean()
+  strict?: boolean;
+
+  @IsOptional()
+  t?: string;
+}
diff --git a/server/src/modules/dashboard/dashboard.module.ts b/server/src/modules/dashboard/dashboard.module.ts
index 74b7371c9..4511c5b29 100644
--- a/server/src/modules/dashboard/dashboard.module.ts
+++ b/server/src/modules/dashboard/dashboard.module.ts
@@ -1,6 +1,7 @@
 import { Module } from '@nestjs/common';
 
 import { BookModule } from '../book/book.module';
+import { BookCoverStoreModule } from '../book-cover-store/book-cover-store.module';
 import { SmartScopeModule } from '../smart-scope/smart-scope.module';
 import { LibraryModule } from '../library/library.module';
 import { DashboardController } from './dashboard.controller';
@@ -10,7 +11,7 @@ import { DashboardWidgetRepository } from './dashboard-widget.repository';
 import { DashboardWidgetService } from './dashboard-widget.service';
 
 @Module({
-  imports: [BookModule, LibraryModule, SmartScopeModule],
+  imports: [BookModule, BookCoverStoreModule, LibraryModule, SmartScopeModule],
   controllers: [DashboardController],
   providers: [DashboardService, DashboardRepository, DashboardWidgetService, DashboardWidgetRepository],
   exports: [DashboardService, DashboardWidgetService],
diff --git a/server/src/modules/dashboard/dashboard.service.test.ts b/server/src/modules/dashboard/dashboard.service.test.ts
index 6f764f7ad..8d8f29d61 100644
--- a/server/src/modules/dashboard/dashboard.service.test.ts
+++ b/server/src/modules/dashboard/dashboard.service.test.ts
@@ -50,7 +50,14 @@ function makeService() {
     findOne: vi.fn().mockResolvedValue({ mediaType: 'books' }),
   };
 
-  const service = new DashboardService(dashboardRepo as never, bookReadService as never, libraryService as never, smartScopeService as never);
+  const coverStore = { enrichCardVersions: vi.fn().mockResolvedValue(undefined) };
+  const service = new DashboardService(
+    dashboardRepo as never,
+    bookReadService as never,
+    libraryService as never,
+    smartScopeService as never,
+    coverStore as never,
+  );
   return { service, dashboardRepo, bookReadService, libraryService, smartScopeService };
 }
 
diff --git a/server/src/modules/dashboard/dashboard.service.ts b/server/src/modules/dashboard/dashboard.service.ts
index b4f16c17d..397ef2414 100644
--- a/server/src/modules/dashboard/dashboard.service.ts
+++ b/server/src/modules/dashboard/dashboard.service.ts
@@ -5,6 +5,7 @@ import type { RequestUser } from '../../common/types/request-user';
 import { mapWithConcurrency } from '../../common/utils/batch.utils';
 import { sanitizeLogValue } from '../../common/utils/log-sanitize.utils';
 import { BookReadService } from '../book/book-read.service';
+import { BookCoverStore } from '../book-cover-store/book-cover-store.service';
 import { assembleBookCards } from '../book/utils/assemble-book-cards';
 import { SmartScopeService } from '../smart-scope/smart-scope.service';
 import { LibraryService } from '../library/library.service';
@@ -24,6 +25,7 @@ export class DashboardService {
     private readonly bookReadService: BookReadService,
     private readonly libraryService: LibraryService,
     private readonly smartScopeService: SmartScopeService,
+    private readonly coverStore: BookCoverStore,
   ) {}
 
   private async loadCardsByIds(bookIds: number[], userId: number): Promise<BookCard[]> {
@@ -33,6 +35,7 @@ export class DashboardService {
       userId,
     );
     const cards = assembleBookCards(rows, authorRows, fileRows, genreRows, progressRows, statusRows, narratorRows, tagRows);
+    await this.coverStore.enrichCardVersions(cards);
     const cardsById = new Map(cards.map((card) => [card.id, card]));
     return bookIds.map((id) => cardsById.get(id)).filter((card): card is BookCard => card != null);
   }
diff --git a/server/src/modules/file-write/file-rename.narrators.test.ts b/server/src/modules/file-write/file-rename.narrators.test.ts
index 0cdae64b8..489c3b0fd 100644
--- a/server/src/modules/file-write/file-rename.narrators.test.ts
+++ b/server/src/modules/file-write/file-rename.narrators.test.ts
@@ -72,6 +72,7 @@ describe('FileRenameService narrator-specific editions', () => {
       notificationService as never,
       config,
       new SelfWriteRegistry(),
+      { slotsForAdoption: vi.fn().mockResolvedValue([]), adoptSlots: vi.fn(), removeCoverDirectory: vi.fn() } as never,
     );
 
     const simonResult = await service.performRename(1, 7);
diff --git a/server/src/modules/file-write/file-rename.service.test.ts b/server/src/modules/file-write/file-rename.service.test.ts
index 8f591e093..2457d1d80 100644
--- a/server/src/modules/file-write/file-rename.service.test.ts
+++ b/server/src/modules/file-write/file-rename.service.test.ts
@@ -73,7 +73,10 @@ describe('FileRenameService', () => {
     };
   }
 
-  function makeService(configValues: Record<string, unknown> = {}) {
+  function makeService(
+    configValues: Record<string, unknown> = {},
+    covers: { coverStore?: Record<string, ReturnType<typeof vi.fn>>; coverReconciler?: { enqueue: ReturnType<typeof vi.fn> } } = {},
+  ) {
     const renameRepo = {
       findBookRenameData: vi.fn(),
       checkPathTakenByOtherBook: vi.fn().mockResolvedValue(false),
@@ -109,6 +112,12 @@ describe('FileRenameService', () => {
       get: vi.fn().mockImplementation((key: string) => configValues[key]),
     } as unknown as ConfigService;
 
+    const coverStore = covers.coverStore ?? {
+      slotsForAdoption: vi.fn().mockResolvedValue([]),
+      adoptSlots: vi.fn().mockResolvedValue([]),
+      removeCoverDirectory: vi.fn().mockResolvedValue(undefined),
+    };
+
     const selfWriteRegistry = new SelfWriteRegistry();
     const service = new FileRenameService(
       renameRepo as never,
@@ -117,9 +126,11 @@ describe('FileRenameService', () => {
       notificationService as never,
       config,
       selfWriteRegistry,
+      coverStore as never,
+      covers.coverReconciler as never,
     );
 
-    return { service, renameRepo, lockService, appSettings, notificationService, selfWriteRegistry };
+    return { service, renameRepo, lockService, appSettings, notificationService, selfWriteRegistry, coverStore };
   }
 
   beforeEach(() => {
@@ -1270,6 +1281,59 @@ describe('FileRenameService', () => {
     expect(mockRename).toHaveBeenNthCalledWith(2, '/library/Incoming/old.opf', '/library/Frank Herbert/Dune (1965)/old.opf');
   });
 
+  it('hands the merged book’s covers to the target book it was merged into', async () => {
+    const sourceSlots = [{ bookId: 5, medium: 'audio' }];
+    const order: string[] = [];
+    const coverStore = {
+      slotsForAdoption: vi.fn().mockImplementation(() => {
+        order.push('read');
+        return Promise.resolve(sourceSlots);
+      }),
+      adoptSlots: vi.fn().mockImplementation(() => {
+        order.push('adopt');
+        return Promise.resolve(['audio']);
+      }),
+      removeCoverDirectory: vi.fn().mockImplementation(() => {
+        order.push('remove');
+        return Promise.resolve();
+      }),
+    };
+    const coverReconciler = { enqueue: vi.fn().mockResolvedValue(undefined) };
+    const { service, renameRepo } = makeService({}, { coverStore, coverReconciler });
+    renameRepo.findBookRenameData.mockResolvedValue(
+      makeRenameData({
+        organizationMode: 'book_per_folder',
+        fileNamingPattern: '{authors}/{title} ({year})/{title} ({year})',
+        file: { absolutePath: '/library/Incoming/old.m4b', relPath: 'Incoming/old.m4b', format: 'm4b' },
+        bookFolderPath: '/library/Incoming',
+      }),
+    );
+    renameRepo.findAllBookFiles.mockResolvedValue([
+      { id: 10, absolutePath: '/library/Incoming/old.m4b', relPath: 'Incoming/old.m4b', role: 'primary', format: 'm4b' },
+    ]);
+    renameRepo.applyExistingFolderMerge.mockImplementation(() => {
+      order.push('merge');
+      return Promise.resolve();
+    });
+    mockAccess.mockImplementation((path: any) => {
+      if (path.toString() === '/library/Frank Herbert/Dune (1965)') return Promise.resolve(undefined);
+      return Promise.reject(Object.assign(new Error('missing'), { code: 'ENOENT' }));
+    });
+    renameRepo.findBookByExactFolderPath.mockResolvedValue({
+      id: 99,
+      folderPath: '/library/Frank Herbert/Dune (1965)',
+      primaryFileId: 42,
+      status: 'present',
+    });
+
+    await expect(service.performRename(5, 12)).resolves.toEqual(expect.objectContaining({ status: 'success' }));
+
+    expect(order).toEqual(['read', 'merge', 'adopt', 'remove']);
+    expect(coverStore.adoptSlots).toHaveBeenCalledWith(5, sourceSlots, 99);
+    expect(coverStore.removeCoverDirectory).toHaveBeenCalledWith(5);
+    expect(coverReconciler.enqueue).toHaveBeenCalledWith([99], { filesChanged: true });
+  });
+
   it('skips existing-folder merge when the concrete target file already exists on disk', async () => {
     const { service, renameRepo } = makeService();
     renameRepo.findBookRenameData.mockResolvedValue(
diff --git a/server/src/modules/file-write/file-rename.service.ts b/server/src/modules/file-write/file-rename.service.ts
index 78d30cb3d..7ca00aa77 100644
--- a/server/src/modules/file-write/file-rename.service.ts
+++ b/server/src/modules/file-write/file-rename.service.ts
@@ -1,4 +1,4 @@
-import { Injectable, Logger, OnModuleDestroy } from '@nestjs/common';
+import { Injectable, Logger, OnModuleDestroy, Optional } from '@nestjs/common';
 import { ConfigService } from '@nestjs/config';
 import { access, mkdir, readdir, rename as fsRename, rmdir } from 'fs/promises';
 import { basename, dirname, extname, isAbsolute, join, normalize, relative, sep } from 'path';
@@ -9,6 +9,9 @@ import { SelfWriteRegistry } from '../../common/services/self-write-registry.ser
 import { sanitizeLogValue } from '../../common/utils/log-sanitize.utils';
 import { pathsReferToSameEntry } from '../../common/utils/path-identity.utils';
 import { AppSettingsService } from '../app-settings/app-settings.service';
+import type { BookCoverSlotRow } from '../book-cover-store/book-cover-store.repository';
+import { BookCoverStore } from '../book-cover-store/book-cover-store.service';
+import { CoverSlotReconciler } from '../metadata/cover-slot-reconciler.service';
 import { NotificationService } from '../notification/notification.service';
 import type { BookFilePathUpdate, BookRenameData } from './file-rename.repository';
 import { FileRenameRepository } from './file-rename.repository';
@@ -38,6 +41,8 @@ export class FileRenameService implements OnModuleDestroy {
     private readonly notificationService: NotificationService,
     private readonly config: ConfigService,
     private readonly selfWriteRegistry: SelfWriteRegistry,
+    private readonly coverStore: BookCoverStore,
+    @Optional() private readonly coverReconciler?: CoverSlotReconciler,
   ) {
     this.debounceMs = resolvePositiveInteger(this.config.get('fileWrite.debounceMs'), DEFAULT_RENAME_DEBOUNCE_MS);
   }
@@ -484,6 +489,8 @@ export class FileRenameService implements OnModuleDestroy {
       absolutePath: fileTargets.get(file.id)!,
       relPath: relative(data.libraryFolderPath, fileTargets.get(file.id)!),
     }));
+    // The merge deletes the source book and its slot rows with it, so they are read first.
+    const sourceSlots = await this.coverStore.slotsForAdoption(bookId);
 
     const movedFiles: Array<{ from: string; to: string }> = [];
     try {
@@ -522,10 +529,24 @@ export class FileRenameService implements OnModuleDestroy {
       throw error;
     }
 
+    await this.handOverCovers(bookId, sourceSlots, targetBookId);
     await this.tryRemoveEmptyDir(oldFolderPath);
     await this.tryRemoveEmptyDir(dirname(oldFolderPath));
   }
 
+  /** The target keeps its own art and takes the source's for any medium it had no cover for. */
+  private async handOverCovers(sourceBookId: number, sourceSlots: BookCoverSlotRow[], targetBookId: number): Promise<void> {
+    try {
+      await this.coverStore.adoptSlots(sourceBookId, sourceSlots, targetBookId);
+      await this.coverStore.removeCoverDirectory(sourceBookId);
+    } catch (error) {
+      this.logger.warn(
+        `[${FILE_RENAME_EVENT}] [fail] bookId=${sourceBookId} targetBookId=${targetBookId} errorClass=${error instanceof Error ? error.name : 'Error'} error="${sanitizeLogValue(error instanceof Error ? error.message : String(error))}" - merged book covers not handed over`,
+      );
+    }
+    void this.coverReconciler?.enqueue([targetBookId], { filesChanged: true });
+  }
+
   private async moveBookFilesIndividually(
     bookId: number,
     allFiles: Awaited<ReturnType<FileRenameRepository['findAllBookFiles']>>,
diff --git a/server/src/modules/file-write/file-write.module.ts b/server/src/modules/file-write/file-write.module.ts
index 3fb01a4cb..ae47fe023 100644
--- a/server/src/modules/file-write/file-write.module.ts
+++ b/server/src/modules/file-write/file-write.module.ts
@@ -2,6 +2,8 @@ import { Module, forwardRef } from '@nestjs/common';
 
 import { SelfWriteRegistryModule } from '../../common/self-write-registry.module';
 import { AppSettingsModule } from '../app-settings/app-settings.module';
+import { BookCoverStoreModule } from '../book-cover-store/book-cover-store.module';
+import { MetadataModule } from '../metadata/metadata.module';
 import { NotificationModule } from '../notification/notification.module';
 import { BulkRenameRepository } from './bulk-rename.repository';
 import { FileLockService } from './file-lock.service';
@@ -21,7 +23,7 @@ import { PdfFormatWriter } from './formats/pdf/pdf-format-writer';
 import { FORMAT_WRITERS } from './interfaces/format-writer.interface';
 
 @Module({
-  imports: [forwardRef(() => NotificationModule), AppSettingsModule, SelfWriteRegistryModule],
+  imports: [forwardRef(() => NotificationModule), AppSettingsModule, BookCoverStoreModule, MetadataModule, SelfWriteRegistryModule],
   providers: [
     FileWriteService,
     FileWriteRepository,
diff --git a/server/src/modules/file-write/file-write.service.test.ts b/server/src/modules/file-write/file-write.service.test.ts
index 898bf3a23..d3730597d 100644
--- a/server/src/modules/file-write/file-write.service.test.ts
+++ b/server/src/modules/file-write/file-write.service.test.ts
@@ -1,6 +1,6 @@
 import { ConfigService } from '@nestjs/config';
 import type { MockedFunction } from 'vitest';
-import { readdir, readFile, stat } from 'fs/promises';
+import { readFile, stat } from 'fs/promises';
 import {
   AUDIO_BOOK_FILE_WRITE_FIELDS,
   EPUB_BOOK_FILE_WRITE_FIELDS,
@@ -25,13 +25,11 @@ vi.mock('fs/promises', async () => {
   const actual = await vi.importActual('fs/promises');
   return {
     ...actual,
-    readdir: vi.fn(),
     readFile: vi.fn(),
     stat: vi.fn(),
   };
 });
 
-const mockReaddir = readdir as MockedFunction<typeof readdir>;
 const mockReadFile = readFile as MockedFunction<typeof readFile>;
 const mockStat = stat as MockedFunction<typeof stat>;
 const POST_WRITE_MTIME = new Date('2026-07-22T12:34:56.789Z');
@@ -54,7 +52,7 @@ const DEFAULT_LIB_CONFIG = {
 };
 
 describe('FileWriteService', () => {
-  function makeService(configValues: Record<string, unknown> = {}) {
+  function makeService(configValues: Record<string, unknown> = {}, coverStore = { resolve: vi.fn().mockResolvedValue(null) }) {
     const fileWriteRepo = {
       findPrimaryFileForBook: vi.fn(),
       findFilesForBook: vi.fn(),
@@ -79,7 +77,7 @@ describe('FileWriteService', () => {
       withLock: vi.fn().mockImplementation(async (_path: string, fn: () => Promise<unknown>) => fn()),
     };
     const config = {
-      get: vi.fn().mockImplementation((key: string) => (key === 'storage.appDataPath' ? '/books' : configValues[key])),
+      get: vi.fn().mockImplementation((key: string) => configValues[key]),
     } as unknown as ConfigService;
 
     const notificationService = {
@@ -93,14 +91,14 @@ describe('FileWriteService', () => {
       config,
       notificationService as never,
       selfWriteRegistry,
+      coverStore as never,
     );
 
-    return { service, fileWriteRepo, registry, writer, lockService, notificationService, selfWriteRegistry };
+    return { service, fileWriteRepo, registry, writer, lockService, notificationService, selfWriteRegistry, coverStore };
   }
 
   beforeEach(() => {
     vi.clearAllMocks();
-    mockReaddir.mockReset();
     mockReadFile.mockReset();
     mockStat.mockReset();
     mockStat.mockResolvedValue({ mtime: POST_WRITE_MTIME, size: 57n, ino: 9_007_199_254_740_993n } as never);
@@ -395,7 +393,7 @@ describe('FileWriteService', () => {
   });
 
   it('writes successfully with lock, cover loading, logging, and lastWrittenAt update', async () => {
-    const { service, fileWriteRepo, writer, lockService } = makeService();
+    const { service, fileWriteRepo, writer, lockService, coverStore } = makeService();
 
     fileWriteRepo.findPrimaryFileForBook.mockResolvedValue({
       id: 1,
@@ -409,7 +407,7 @@ describe('FileWriteService', () => {
     fileWriteRepo.findLibraryFileWriteConfig.mockResolvedValue({ ...DEFAULT_LIB_CONFIG, fileWriteWriteCover: true });
 
     const coverBytes = Buffer.from('cover');
-    mockReaddir.mockResolvedValue(['cover_extracted.jpg', 'cover_custom.png'] as never);
+    coverStore.resolve.mockResolvedValue('/books/covers/5/ebook/cover_custom.png');
     mockReadFile.mockResolvedValue(coverBytes as never);
 
     writer.write.mockResolvedValue({ status: 'success', fieldsWritten: ['title'], durationMs: 13 });
@@ -424,7 +422,7 @@ describe('FileWriteService', () => {
       expect.objectContaining({ title: 'Dune', coverBytes }),
       expect.objectContaining({ dryRun: false }),
     );
-    expect(mockReadFile).toHaveBeenCalledWith('/books/covers/5/cover_custom.png');
+    expect(mockReadFile).toHaveBeenCalledWith('/books/covers/5/ebook/cover_custom.png');
 
     expect(fileWriteRepo.insertLog).toHaveBeenCalledTimes(1);
     expect(fileWriteRepo.setLastWrittenAt).toHaveBeenCalledWith(5, expect.any(Date));
@@ -705,8 +703,60 @@ describe('FileWriteService', () => {
     expect(result.reason).toBe('file exceeds size limit');
   });
 
+  it('embeds only the book cover into an EPUB, never the audiobook cover', async () => {
+    const coverStore = { resolve: vi.fn().mockResolvedValue('/books/covers/5/ebook/cover_extracted.jpg') };
+    const { service, fileWriteRepo, writer } = makeService({}, coverStore);
+    fileWriteRepo.findPrimaryFileForBook.mockResolvedValue({
+      id: 1,
+      absolutePath: '/books/lib/book.epub',
+      format: 'epub',
+      sizeBytes: 40,
+      fileHash: 'oldhash',
+      libraryId: 2,
+    });
+    fileWriteRepo.loadPayload.mockResolvedValue({ title: 'Dune' });
+    fileWriteRepo.findLibraryFileWriteConfig.mockResolvedValue({ ...DEFAULT_LIB_CONFIG, fileWriteWriteCover: true });
+    mockReadFile.mockResolvedValue(Buffer.from('portrait') as never);
+    writer.write.mockResolvedValue({ status: 'success', fieldsWritten: ['coverBytes'], durationMs: 5 });
+
+    await service.writeToFile(5, 'auto');
+
+    expect(coverStore.resolve).toHaveBeenCalledWith(5, { medium: 'ebook', variant: 'cover', strict: true });
+    expect(mockReadFile).toHaveBeenCalledWith('/books/covers/5/ebook/cover_extracted.jpg');
+    expect(writer.write).toHaveBeenCalledWith(
+      '/books/lib/book.epub',
+      expect.objectContaining({ coverBytes: Buffer.from('portrait') }),
+      expect.anything(),
+    );
+  });
+
+  it('writes no cover into audio tracks when the book has no audiobook cover of its own', async () => {
+    const coverStore = { resolve: vi.fn().mockResolvedValue(null) };
+    const { service, fileWriteRepo, writer } = makeService({}, coverStore);
+    fileWriteRepo.findPrimaryFileForBook.mockResolvedValue({
+      id: 1,
+      absolutePath: '/books/audio/book.m4b',
+      format: 'm4b',
+      sizeBytes: 100,
+      fileHash: 'm4bhash',
+      libraryId: 2,
+    });
+    fileWriteRepo.findFilesForBook.mockResolvedValue([
+      { id: 1, absolutePath: '/books/audio/book.m4b', format: 'm4b', sizeBytes: 100, fileHash: 'm4bhash', libraryId: 2 },
+    ]);
+    fileWriteRepo.loadPayload.mockResolvedValue({ title: 'Audio Book' });
+    fileWriteRepo.findLibraryFileWriteConfig.mockResolvedValue({ ...DEFAULT_LIB_CONFIG, fileWriteAudioEnabled: true, fileWriteWriteCover: true });
+    writer.write.mockResolvedValue({ status: 'success', fieldsWritten: ['title'], durationMs: 5 });
+
+    await service.writeToFile(20, 'auto');
+
+    expect(coverStore.resolve).toHaveBeenCalledWith(20, { medium: 'audio', variant: 'cover', strict: true });
+    expect(mockReadFile).not.toHaveBeenCalled();
+    expect(writer.write).toHaveBeenCalledWith('/books/audio/book.m4b', expect.objectContaining({ coverBytes: null }), expect.anything());
+  });
+
   it('writes supported multi-track audio files and skips unsupported audio tracks explicitly', async () => {
-    const { service, fileWriteRepo, registry, writer, lockService } = makeService();
+    const { service, fileWriteRepo, registry, writer, lockService, coverStore } = makeService();
     fileWriteRepo.findPrimaryFileForBook.mockResolvedValue({
       id: 1,
       absolutePath: '/books/audio/book.m4b',
@@ -723,7 +773,7 @@ describe('FileWriteService', () => {
     registry.supports.mockImplementation((format: string) => ['m4b', 'mp3'].includes(format));
     fileWriteRepo.loadPayload.mockResolvedValue({ title: 'Audio Book' });
     fileWriteRepo.findLibraryFileWriteConfig.mockResolvedValue({ ...DEFAULT_LIB_CONFIG, fileWriteAudioEnabled: true, fileWriteWriteCover: true });
-    mockReaddir.mockResolvedValue(['cover_custom.jpg'] as never);
+    coverStore.resolve.mockResolvedValue('/books/covers/20/audio/cover_custom.jpg');
     mockReadFile.mockResolvedValue(Buffer.from('cover') as never);
     writer.write.mockResolvedValue({ status: 'success', fieldsWritten: ['coverBytes'], durationMs: 5 });
     computeFileHashMock.mockResolvedValueOnce('new-m4b').mockResolvedValueOnce('new-mp3');
@@ -819,7 +869,7 @@ describe('FileWriteService', () => {
   });
 
   it('aggregates failed multi-track audio writes and does not mark the book written', async () => {
-    const { service, fileWriteRepo, registry, writer } = makeService();
+    const { service, fileWriteRepo, registry, writer, coverStore } = makeService();
     fileWriteRepo.findPrimaryFileForBook.mockResolvedValue({
       id: 1,
       absolutePath: '/books/audio/book.m4b',
@@ -835,7 +885,7 @@ describe('FileWriteService', () => {
     registry.supports.mockImplementation((format: string) => ['m4b', 'mp3'].includes(format));
     fileWriteRepo.loadPayload.mockResolvedValue({ title: 'Audio Book' });
     fileWriteRepo.findLibraryFileWriteConfig.mockResolvedValue({ ...DEFAULT_LIB_CONFIG, fileWriteAudioEnabled: true, fileWriteWriteCover: true });
-    mockReaddir.mockResolvedValue(['cover_custom.jpg'] as never);
+    coverStore.resolve.mockResolvedValue('/books/covers/20/audio/cover_custom.jpg');
     mockReadFile.mockResolvedValue(Buffer.from('cover') as never);
     writer.write.mockImplementation((filePath: string) => {
       if (filePath.endsWith('.mp3')) {
@@ -954,7 +1004,7 @@ describe('FileWriteService', () => {
   });
 
   it('dry-run bypasses disabled gate and avoids cover read', async () => {
-    const { service, fileWriteRepo, writer } = makeService();
+    const { service, fileWriteRepo, writer, coverStore } = makeService();
 
     fileWriteRepo.findPrimaryFileForBook.mockResolvedValue({
       id: 1,
@@ -970,7 +1020,8 @@ describe('FileWriteService', () => {
     const result = await service.writeToFile(5, 'auto', undefined, true);
 
     expect(result.status).toBe('skipped');
-    expect(mockReaddir).not.toHaveBeenCalled();
+    expect(coverStore.resolve).not.toHaveBeenCalled();
+    expect(mockReadFile).not.toHaveBeenCalled();
     expect(writer.write).toHaveBeenCalledWith(
       '/books/lib/book.epub',
       expect.not.objectContaining({ coverBytes: expect.anything() }),
@@ -1140,9 +1191,10 @@ describe('FileWriteService', () => {
         fileWriteRepo as never,
         { supports: vi.fn().mockReturnValue(true), get: vi.fn().mockReturnValue(writer) } as never,
         { withLock: vi.fn().mockImplementation(async (_: string, fn: () => Promise<unknown>) => fn()) } as never,
-        { get: vi.fn().mockImplementation((key: string) => (key === 'storage.appDataPath' ? '/books' : undefined)) } as unknown as ConfigService,
+        { get: vi.fn() } as unknown as ConfigService,
         notificationService as never,
         new SelfWriteRegistry(),
+        { resolve: vi.fn().mockResolvedValue(null) } as never,
       );
 
       fileWriteRepo.findPrimaryFileForBook.mockResolvedValue({
@@ -1168,9 +1220,10 @@ describe('FileWriteService', () => {
         fileWriteRepo as never,
         { supports: vi.fn().mockReturnValue(true), get: vi.fn().mockReturnValue(writer) } as never,
         { withLock: vi.fn().mockImplementation(async (_: string, fn: () => Promise<unknown>) => fn()) } as never,
-        { get: vi.fn().mockImplementation((key: string) => (key === 'storage.appDataPath' ? '/books' : undefined)) } as unknown as ConfigService,
+        { get: vi.fn() } as unknown as ConfigService,
         notificationService as never,
         new SelfWriteRegistry(),
+        { resolve: vi.fn().mockResolvedValue(null) } as never,
       );
 
       fileWriteRepo.findPrimaryFileForBook.mockResolvedValue({
diff --git a/server/src/modules/file-write/file-write.service.ts b/server/src/modules/file-write/file-write.service.ts
index 6f6b6e103..3eea38a34 100644
--- a/server/src/modules/file-write/file-write.service.ts
+++ b/server/src/modules/file-write/file-write.service.ts
@@ -1,13 +1,13 @@
 import { Injectable, Logger, OnModuleDestroy } from '@nestjs/common';
 import { ConfigService } from '@nestjs/config';
-import { readdir, readFile, stat } from 'fs/promises';
-import { basename, extname, join } from 'path';
+import { readFile, stat } from 'fs/promises';
+import { basename, extname } from 'path';
 
-import type { BookFileWriteDisabledReason, BookFileWriteField, BookFileWriteStatus, BookFormat, WriteResult } from '@bookorbit/types';
+import type { BookFileWriteDisabledReason, BookFileWriteField, BookFileWriteStatus, BookFormat, CoverMedium, WriteResult } from '@bookorbit/types';
 import { BOOK_FORMATS, getBookFileWriteFormatFields, isAudioFormat, NotificationType } from '@bookorbit/types';
-import { bookCoverDirPath, findPreferredBookCoverFileName } from '../../common/book-cover-storage';
 import { SelfWriteRegistry } from '../../common/services/self-write-registry.service';
 import { sanitizeLogValue } from '../../common/utils/log-sanitize.utils';
+import { BookCoverStore } from '../book-cover-store/book-cover-store.service';
 import { NotificationService } from '../notification/notification.service';
 import { computeFileHash } from '../scanner/lib/hash';
 import {
@@ -54,7 +54,6 @@ type FileWriteCapabilityLibraryConfig = Partial<LibraryFileWriteConfig> | null |
 @Injectable()
 export class FileWriteService implements OnModuleDestroy {
   private readonly logger = new Logger(FileWriteService.name);
-  private readonly appDataPath: string;
   private readonly debounceMs: number;
   private readonly maxConcurrentWrites: number;
   private readonly debounceMap = new Map<number, NodeJS.Timeout>();
@@ -69,8 +68,8 @@ export class FileWriteService implements OnModuleDestroy {
     private readonly config: ConfigService,
     private readonly notificationService: NotificationService,
     private readonly selfWriteRegistry: SelfWriteRegistry,
+    private readonly coverStore: BookCoverStore,
   ) {
-    this.appDataPath = this.config.get<string>('storage.appDataPath')!;
     this.debounceMs = resolvePositiveInteger(this.config.get('fileWrite.debounceMs'), DEFAULT_WRITE_DEBOUNCE_MS);
     this.maxConcurrentWrites = resolvePositiveInteger(this.config.get('fileWrite.maxConcurrentWrites'), DEFAULT_MAX_CONCURRENT_WRITES);
   }
@@ -214,7 +213,7 @@ export class FileWriteService implements OnModuleDestroy {
       const payload: BookWritePayload = { ...rawPayload };
 
       if (libConfig.fileWriteWriteCover && !dryRun) {
-        payload.coverBytes = await this.loadCoverBytes(bookId);
+        payload.coverBytes = await this.loadCoverBytes(bookId, this.coverMediumForTargets(targets));
       }
 
       const audioWriteContexts = this.resolveAudioWriteContexts(targets);
@@ -502,14 +501,21 @@ export class FileWriteService implements OnModuleDestroy {
     return this.fileWriteRepo.findLibraryWriteSettingsForBook(bookId);
   }
 
-  private async loadCoverBytes(bookId: number): Promise<Buffer | null> {
+  /** Targets are the ebook primary alone, or every audio track, so they share one medium. */
+  private coverMediumForTargets(targets: readonly FileWriteTarget[]): CoverMedium {
+    const format = normalizeFormat(targets[0]?.format);
+    return format && isAudioFormat(format) ? 'audio' : 'ebook';
+  }
+
+  /**
+   * Only the target medium's own slot is ever embedded. A square audiobook cover baked into an
+   * EPUB would come back as the ebook cover on the next scan.
+   */
+  private async loadCoverBytes(bookId: number, medium: CoverMedium): Promise<Buffer | null> {
     const startedAt = Date.now();
-    const dir = bookCoverDirPath(this.appDataPath, bookId);
     try {
-      const files = await readdir(dir);
-      const cover = findPreferredBookCoverFileName(files);
-      if (!cover) return null;
-      return readFile(join(dir, cover));
+      const path = await this.coverStore.resolve(bookId, { medium, variant: 'cover', strict: true });
+      return path ? await readFile(path) : null;
     } catch (error) {
       const errorClass = error instanceof Error ? error.name : 'Error';
       const errorMessage = sanitizeErrorMessage(error instanceof Error ? error.message : String(error));
diff --git a/server/src/modules/kobo/kobo.module.ts b/server/src/modules/kobo/kobo.module.ts
index 5862296db..6310163fd 100644
--- a/server/src/modules/kobo/kobo.module.ts
+++ b/server/src/modules/kobo/kobo.module.ts
@@ -4,6 +4,7 @@ import { CommonModule } from '../../common/common.module';
 import { AchievementModule } from '../achievement/achievement.module';
 import { AnnotationModule } from '../annotation/annotation.module';
 import { BookModule } from '../book/book.module';
+import { BookCoverStoreModule } from '../book-cover-store/book-cover-store.module';
 import { MetadataModule } from '../metadata/metadata.module';
 import { PositionConverterModule } from '../position-converter/position-converter.module';
 import { ReadingSessionModule } from '../reading-session/reading-session.module';
@@ -42,6 +43,7 @@ import { KoboAnalyticsService } from './services/kobo-analytics.service';
     AchievementModule,
     AnnotationModule,
     BookModule,
+    BookCoverStoreModule,
     MetadataModule,
     PositionConverterModule,
     UserModule,
diff --git a/server/src/modules/kobo/services/kobo-thumbnail.service.test.ts b/server/src/modules/kobo/services/kobo-thumbnail.service.test.ts
index 6b48a9346..a5723b65e 100644
--- a/server/src/modules/kobo/services/kobo-thumbnail.service.test.ts
+++ b/server/src/modules/kobo/services/kobo-thumbnail.service.test.ts
@@ -1,5 +1,4 @@
 vi.mock('fs/promises', () => ({
-  readdir: vi.fn(),
   stat: vi.fn(),
 }));
 
@@ -9,12 +8,11 @@ vi.mock('fs', () => ({
 
 import { NotFoundException } from '@nestjs/common';
 import { createReadStream } from 'fs';
-import { readdir, stat } from 'fs/promises';
+import { stat } from 'fs/promises';
 
 import { KoboThumbnailService } from './kobo-thumbnail.service';
 
 const statMock = vi.mocked(stat);
-const readdirMock = vi.mocked(readdir);
 const createReadStreamMock = vi.mocked(createReadStream);
 
 function makeReply() {
@@ -30,16 +28,19 @@ describe('KoboThumbnailService', () => {
   const bookAccessService = {
     assertBookAccessible: vi.fn(),
   };
-  const config = {
-    get: vi.fn().mockReturnValue('/app-data'),
+  const coverStore = {
+    resolve: vi.fn(),
   };
   let service: KoboThumbnailService;
 
   beforeEach(() => {
     vi.restoreAllMocks();
     vi.clearAllMocks();
-    service = new KoboThumbnailService(config as never, bookAccessService as never);
+    service = new KoboThumbnailService(bookAccessService as never, coverStore as never);
     bookAccessService.assertBookAccessible.mockResolvedValue(undefined);
+    coverStore.resolve.mockImplementation((bookId: number, options: { variant: string }) =>
+      Promise.resolve(`/app-data/covers/${bookId}/ebook/${options.variant === 'thumbnail' ? 'thumbnail.jpg' : 'cover_custom.png'}`),
+    );
   });
 
   it('returns 304 when thumbnail etag matches if-none-match', async () => {
@@ -62,6 +63,8 @@ describe('KoboThumbnailService', () => {
 
     await service.serveThumbnail(7, 12, undefined, reply as never);
 
+    expect(coverStore.resolve).toHaveBeenCalledWith(12, { medium: 'ebook', variant: 'thumbnail' });
+    expect(createReadStreamMock).toHaveBeenCalledWith('/app-data/covers/12/ebook/thumbnail.jpg');
     expect(reply.header).toHaveBeenCalledWith('Cache-Control', 'max-age=86400');
     expect(reply.header).toHaveBeenCalledWith('ETag', '"5678"');
     expect(reply.type).toHaveBeenCalledWith('image/jpeg');
@@ -78,15 +81,27 @@ describe('KoboThumbnailService', () => {
     expect(coverSpy).toHaveBeenCalledWith(12, undefined, reply);
   });
 
-  it('serveCover uses preferred cover file and returns matching content type', async () => {
+  it('falls back to cover serving when the book has no thumbnail', async () => {
+    const reply = makeReply();
+    coverStore.resolve.mockResolvedValueOnce(null);
+    const coverSpy = vi.spyOn(service, 'serveCover').mockResolvedValue(undefined);
+
+    await service.serveThumbnail(7, 12, undefined, reply as never);
+
+    expect(statMock).not.toHaveBeenCalled();
+    expect(coverSpy).toHaveBeenCalledWith(12, undefined, reply);
+  });
+
+  it('serveCover serves the resolved ebook cover with its content type', async () => {
     const reply = makeReply();
     const stream = {} as never;
-    readdirMock.mockResolvedValueOnce(['cover_extracted.jpg', 'cover_custom.png']);
     statMock.mockResolvedValueOnce({ mtimeMs: 9999 } as never);
     createReadStreamMock.mockReturnValue(stream);
 
     await service.serveCover(25, undefined, reply as never);
 
+    expect(coverStore.resolve).toHaveBeenCalledWith(25, { medium: 'ebook', variant: 'cover' });
+    expect(createReadStreamMock).toHaveBeenCalledWith('/app-data/covers/25/ebook/cover_custom.png');
     expect(reply.header).toHaveBeenCalledWith('ETag', '"9999"');
     expect(reply.type).toHaveBeenCalledWith('image/png');
     expect(reply.send).toHaveBeenCalledWith(stream);
@@ -94,7 +109,6 @@ describe('KoboThumbnailService', () => {
 
   it('serveCover returns 304 for matching cover etag', async () => {
     const reply = makeReply();
-    readdirMock.mockResolvedValueOnce(['cover_extracted.jpg']);
     statMock.mockResolvedValueOnce({ mtimeMs: 2222 } as never);
 
     await service.serveCover(13, '"2222"', reply as never);
@@ -104,7 +118,7 @@ describe('KoboThumbnailService', () => {
   });
 
   it('throws NotFoundException when no cover image is available', async () => {
-    readdirMock.mockResolvedValueOnce([]);
+    coverStore.resolve.mockResolvedValueOnce(null);
 
     await expect(service.serveCover(25, undefined, makeReply() as never)).rejects.toThrow(NotFoundException);
   });
diff --git a/server/src/modules/kobo/services/kobo-thumbnail.service.ts b/server/src/modules/kobo/services/kobo-thumbnail.service.ts
index 02ead19e6..986ea27c3 100644
--- a/server/src/modules/kobo/services/kobo-thumbnail.service.ts
+++ b/server/src/modules/kobo/services/kobo-thumbnail.service.ts
@@ -1,29 +1,24 @@
 import { Injectable, NotFoundException } from '@nestjs/common';
-import { ConfigService } from '@nestjs/config';
-import { readdir, stat } from 'fs/promises';
+import { stat } from 'fs/promises';
 import { createReadStream } from 'fs';
-import { join } from 'path';
 import type { FastifyReply } from 'fastify';
-import { bookCoverDirPath, bookThumbnailPath, findPreferredBookCoverFileName } from '../../../common/book-cover-storage';
 import { imageContentTypeFromPath } from '../../../common/image-content-type';
 import { KoboBookAccessService } from './kobo-book-access.service';
+import { BookCoverStore } from '../../book-cover-store/book-cover-store.service';
 
 @Injectable()
 export class KoboThumbnailService {
-  private readonly appDataPath: string;
-
   constructor(
-    private readonly config: ConfigService,
     private readonly bookAccessService: KoboBookAccessService,
-  ) {
-    this.appDataPath = this.config.get<string>('storage.appDataPath')!;
-  }
+    private readonly coverStore: BookCoverStore,
+  ) {}
 
   async serveThumbnail(userId: number, bookId: number, ifNoneMatch: string | undefined, reply: FastifyReply) {
     await this.bookAccessService.assertBookAccessible(userId, bookId);
 
-    const thumbnailPath = bookThumbnailPath(this.appDataPath, bookId);
+    const thumbnailPath = await this.coverStore.resolve(bookId, { medium: 'ebook', variant: 'thumbnail' });
     try {
+      if (!thumbnailPath) throw new NotFoundException('No thumbnail');
       const { mtimeMs } = await stat(thumbnailPath);
       const etag = `"${Math.floor(mtimeMs)}"`;
       if (ifNoneMatch === etag) {
@@ -40,12 +35,9 @@ export class KoboThumbnailService {
   }
 
   async serveCover(bookId: number, ifNoneMatch: string | undefined, reply: FastifyReply) {
-    const dir = bookCoverDirPath(this.appDataPath, bookId);
     try {
-      const files = await readdir(dir);
-      const cover = findPreferredBookCoverFileName(files);
-      if (!cover) throw new NotFoundException('No cover');
-      const coverPath = join(dir, cover);
+      const coverPath = await this.coverStore.resolve(bookId, { medium: 'ebook', variant: 'cover' });
+      if (!coverPath) throw new NotFoundException('No cover');
       const { mtimeMs } = await stat(coverPath);
       const etag = `"${Math.floor(mtimeMs)}"`;
       if (ifNoneMatch === etag) {
diff --git a/server/src/modules/koreader/koreader-catalog.service.test.ts b/server/src/modules/koreader/koreader-catalog.service.test.ts
index dece3a6d9..6e874aeda 100644
--- a/server/src/modules/koreader/koreader-catalog.service.test.ts
+++ b/server/src/modules/koreader/koreader-catalog.service.test.ts
@@ -852,7 +852,7 @@ describe('KoreaderCatalogService', () => {
 
     await service.streamThumbnail(makeUser(), 10, reply as never);
 
-    expect(bookService.getThumbnailPath).toHaveBeenCalledWith(10, expect.objectContaining({ id: 1 }));
+    expect(bookService.getThumbnailPath).toHaveBeenCalledWith(10, expect.objectContaining({ id: 1 }), { medium: 'ebook' });
     expect(reply.header).toHaveBeenCalledWith('ETag', '"5000"');
     expect(reply.type).toHaveBeenCalledWith('image/jpeg');
     expect(mockCreateReadStream).toHaveBeenCalledWith(join('/data', 'covers', '10', 'thumbnail.jpg'));
diff --git a/server/src/modules/koreader/koreader-catalog.service.ts b/server/src/modules/koreader/koreader-catalog.service.ts
index bdcf3b01a..c55309519 100644
--- a/server/src/modules/koreader/koreader-catalog.service.ts
+++ b/server/src/modules/koreader/koreader-catalog.service.ts
@@ -477,7 +477,7 @@ export class KoreaderCatalogService {
   }
 
   async streamThumbnail(user: RequestUser, bookId: number, reply: FastifyReply, ifNoneMatch?: string): Promise<void> {
-    const thumbnailPath = await this.bookService.getThumbnailPath(bookId, user);
+    const thumbnailPath = await this.bookService.getThumbnailPath(bookId, user, { medium: 'ebook' });
     if (!thumbnailPath) throw new NotFoundException('No thumbnail');
     try {
       const { mtimeMs } = await stat(thumbnailPath);
diff --git a/server/src/modules/maintenance/cover-sweep.store.ts b/server/src/modules/maintenance/cover-sweep.store.ts
index 11dda8730..d6494adb1 100644
--- a/server/src/modules/maintenance/cover-sweep.store.ts
+++ b/server/src/modules/maintenance/cover-sweep.store.ts
@@ -1,5 +1,5 @@
 import { Injectable } from '@nestjs/common';
-import type { CoverSweepStatus } from '@bookorbit/types';
+import type { CoverMedium, CoverSweepStatus } from '@bookorbit/types';
 
 /**
  * Sweep results are held in memory rather than a table: a sweep is cheap to repeat, its
@@ -14,6 +14,7 @@ export interface OrphanedCoverDir {
   bookId: number;
   fileCount: number;
   sizeBytes: number;
+  media: CoverMedium[];
 }
 
 export interface SweepRecord {
diff --git a/server/src/modules/maintenance/lib/cover-disk.test.ts b/server/src/modules/maintenance/lib/cover-disk.test.ts
index bda51747c..b6c59c7ac 100644
--- a/server/src/modules/maintenance/lib/cover-disk.test.ts
+++ b/server/src/modules/maintenance/lib/cover-disk.test.ts
@@ -3,7 +3,7 @@ import { tmpdir } from 'os';
 import { join } from 'path';
 import { afterEach, beforeEach, describe, expect, it } from 'vitest';
 
-import { hasServableCover, mapWithConcurrency, measureCoverDir, readCoverDirBookIds } from './cover-disk';
+import { findBrokenCoverSlots, hasServableCover, mapWithConcurrency, measureCoverDir, readCoverDirBookIds } from './cover-disk';
 
 describe('cover-disk', () => {
   let coversRoot: string;
@@ -60,12 +60,34 @@ describe('cover-disk', () => {
 
   describe('measureCoverDir', () => {
     it('reports zero for a directory that is gone', async () => {
-      expect(await measureCoverDir(coversRoot, 9)).toEqual({ fileCount: 0, sizeBytes: 0 });
+      expect(await measureCoverDir(coversRoot, 9)).toEqual({ fileCount: 0, sizeBytes: 0, media: [] });
     });
 
     it('sums the files it holds', async () => {
       await makeCoverDir(9, { 'cover_custom.jpg': 'abcde', 'thumbnail.jpg': 'xyz' });
-      expect(await measureCoverDir(coversRoot, 9)).toEqual({ fileCount: 2, sizeBytes: 8 });
+      expect(await measureCoverDir(coversRoot, 9)).toEqual({ fileCount: 2, sizeBytes: 8, media: [] });
+    });
+
+    it('counts slot folders and names the ones it finds', async () => {
+      await makeCoverDir(9, { 'thumbnail.jpg': 'xyz' });
+      await mkdir(join(coversRoot, '9', 'audio'), { recursive: true });
+      await writeFile(join(coversRoot, '9', 'audio', 'cover_custom.jpg'), 'abcde');
+      await mkdir(join(coversRoot, '9', 'stray'), { recursive: true });
+
+      expect(await measureCoverDir(coversRoot, 9)).toEqual({ fileCount: 2, sizeBytes: 8, media: ['audio'] });
+    });
+  });
+
+  describe('findBrokenCoverSlots', () => {
+    it('returns the slots whose folder is missing or holds no servable cover', async () => {
+      await mkdir(join(coversRoot, '4', 'ebook'), { recursive: true });
+      await writeFile(join(coversRoot, '4', 'ebook', 'cover_extracted.jpg'), 'x');
+      await mkdir(join(coversRoot, '4', 'audio'), { recursive: true });
+      await writeFile(join(coversRoot, '4', 'audio', 'thumbnail.jpg'), 'x');
+
+      expect(await findBrokenCoverSlots(coversRoot, 4, ['ebook', 'audio'])).toEqual(['audio']);
+      expect(await findBrokenCoverSlots(coversRoot, 5, ['ebook'])).toEqual(['ebook']);
+      expect(await findBrokenCoverSlots(coversRoot, 4, [])).toEqual([]);
     });
   });
 
diff --git a/server/src/modules/maintenance/lib/cover-disk.ts b/server/src/modules/maintenance/lib/cover-disk.ts
index 57ce5500a..8bed4029a 100644
--- a/server/src/modules/maintenance/lib/cover-disk.ts
+++ b/server/src/modules/maintenance/lib/cover-disk.ts
@@ -1,5 +1,6 @@
 import { readdir, stat } from 'fs/promises';
 import { join } from 'path';
+import { COVER_MEDIA, type CoverMedium } from '@bookorbit/types';
 
 import { findPreferredBookCoverFileName } from '../../../common/book-cover-storage';
 
@@ -35,33 +36,85 @@ export async function readCoverDirBookIds(coversRoot: string): Promise<Set<numbe
  */
 export async function hasServableCover(coversRoot: string, bookId: number): Promise<boolean> {
   try {
-    const files = await readdir(join(coversRoot, String(bookId)));
-    return findPreferredBookCoverFileName(files) !== null;
+    const dir = join(coversRoot, String(bookId));
+    const files = await readdir(dir, { withFileTypes: true });
+    if (findPreferredBookCoverFileName(files.filter((entry) => entry.isFile()).map((entry) => entry.name)) !== null) return true;
+    for (const medium of ['ebook', 'audio']) {
+      const slotFiles = await readdir(join(dir, medium)).catch((error: unknown) => {
+        if (isMissingEntry(error)) return [];
+        throw error;
+      });
+      if (findPreferredBookCoverFileName(slotFiles) !== null) return true;
+    }
+    return false;
   } catch (err) {
     if (isMissingEntry(err)) return false;
     throw err;
   }
 }
 
-export async function measureCoverDir(coversRoot: string, bookId: number): Promise<{ fileCount: number; sizeBytes: number }> {
+/** The slots, of those a book has rows for, whose folder holds no cover that would be served. */
+export async function findBrokenCoverSlots(coversRoot: string, bookId: number, media: readonly CoverMedium[]): Promise<CoverMedium[]> {
+  const broken: CoverMedium[] = [];
+  for (const medium of media) {
+    let files: string[];
+    try {
+      files = await readdir(join(coversRoot, String(bookId), medium));
+    } catch (err) {
+      if (!isMissingEntry(err)) throw err;
+      files = [];
+    }
+    if (findPreferredBookCoverFileName(files) === null) broken.push(medium);
+  }
+  return broken;
+}
+
+export async function measureCoverDir(coversRoot: string, bookId: number): Promise<{ fileCount: number; sizeBytes: number; media: CoverMedium[] }> {
   const dir = join(coversRoot, String(bookId));
-  let files: string[];
+  let files;
   try {
-    files = await readdir(dir);
+    files = await readdir(dir, { withFileTypes: true });
   } catch (err) {
-    if (isMissingEntry(err)) return { fileCount: 0, sizeBytes: 0 };
+    if (isMissingEntry(err)) return { fileCount: 0, sizeBytes: 0, media: [] };
     throw err;
   }
   let sizeBytes = 0;
+  let fileCount = 0;
+  const media = COVER_MEDIA.filter((medium) => files.some((file) => file.isDirectory() && file.name === medium));
   for (const file of files) {
     try {
-      const stats = await stat(join(dir, file));
-      if (stats.isFile()) sizeBytes += stats.size;
+      if (file.isDirectory()) {
+        const nested = await measureDirectory(join(dir, file.name));
+        fileCount += nested.fileCount;
+        sizeBytes += nested.sizeBytes;
+      } else if (file.isFile()) {
+        const stats = await stat(join(dir, file.name));
+        fileCount++;
+        sizeBytes += stats.size;
+      }
     } catch (err) {
       if (!isMissingEntry(err)) throw err;
     }
   }
-  return { fileCount: files.length, sizeBytes };
+  return { fileCount, sizeBytes, media };
+}
+
+async function measureDirectory(dir: string): Promise<{ fileCount: number; sizeBytes: number }> {
+  const entries = await readdir(dir, { withFileTypes: true });
+  let fileCount = 0;
+  let sizeBytes = 0;
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      const nested = await measureDirectory(join(dir, entry.name));
+      fileCount += nested.fileCount;
+      sizeBytes += nested.sizeBytes;
+    } else if (entry.isFile()) {
+      const info = await stat(join(dir, entry.name));
+      fileCount++;
+      sizeBytes += info.size;
+    }
+  }
+  return { fileCount, sizeBytes };
 }
 
 /** Chunked fan-out; keeps open file handles bounded on libraries with tens of thousands of covers. */
diff --git a/server/src/modules/maintenance/maintenance.module.ts b/server/src/modules/maintenance/maintenance.module.ts
index 819e92e51..b485c13a1 100644
--- a/server/src/modules/maintenance/maintenance.module.ts
+++ b/server/src/modules/maintenance/maintenance.module.ts
@@ -1,6 +1,7 @@
 import { Module } from '@nestjs/common';
 
 import { BookModule } from '../book/book.module';
+import { BookCoverStoreModule } from '../book-cover-store/book-cover-store.module';
 import { LibraryModule } from '../library/library.module';
 import { CoverSweepStore } from './cover-sweep.store';
 import { MissingResourcesController } from './missing-resources.controller';
@@ -8,7 +9,7 @@ import { MissingResourcesRepository } from './missing-resources.repository';
 import { MissingResourcesService } from './missing-resources.service';
 
 @Module({
-  imports: [BookModule, LibraryModule],
+  imports: [BookModule, BookCoverStoreModule, LibraryModule],
   controllers: [MissingResourcesController],
   providers: [MissingResourcesService, MissingResourcesRepository, CoverSweepStore],
 })
diff --git a/server/src/modules/maintenance/missing-resources.service.test.ts b/server/src/modules/maintenance/missing-resources.service.test.ts
index 3b1613860..79247975f 100644
--- a/server/src/modules/maintenance/missing-resources.service.test.ts
+++ b/server/src/modules/maintenance/missing-resources.service.test.ts
@@ -33,7 +33,28 @@ describe('MissingResourcesService', () => {
     for (const [name, content] of Object.entries(files)) await writeFile(join(dir, name), content);
   }
 
-  function setup(overrides: Partial<Record<string, unknown>> = {}) {
+  function slotRow(bookId: number, medium: 'ebook' | 'audio', source: 'extracted' | 'custom' = 'extracted') {
+    return { bookId, medium, source, origin: 'embedded', width: null, height: null, updatedAt: new Date(), dormantSince: null };
+  }
+
+  function coverStoreWith(rows: ReturnType<typeof slotRow>[]) {
+    return {
+      slotsFor: vi.fn().mockImplementation((ids: number[]) => {
+        const byBook = new Map<number, ReturnType<typeof slotRow>[]>();
+        for (const row of rows.filter((candidate) => ids.includes(candidate.bookId))) {
+          byBook.set(row.bookId, [...(byBook.get(row.bookId) ?? []), row]);
+        }
+        return Promise.resolve(byBook);
+      }),
+      removeBrokenSlots: vi
+        .fn()
+        .mockImplementation((bookId: number) =>
+          Promise.resolve(rows.some((row) => row.bookId === bookId) ? { hadSlots: true, removed: 1 } : { hadSlots: false, removed: 0 }),
+        ),
+    };
+  }
+
+  function setup(overrides: Partial<Record<string, unknown>> = {}, coverStore = coverStoreWith([])) {
     const repo = {
       countMissingBooks: vi.fn().mockResolvedValue(0),
       findMissingBooks: vi.fn().mockResolvedValue([]),
@@ -50,8 +71,15 @@ describe('MissingResourcesService', () => {
     const libraryService = { findAccessibleLibraryIds: vi.fn().mockResolvedValue([1, 2]) };
     const bookService = { deleteBooks: vi.fn().mockImplementation((ids: number[]) => Promise.resolve({ total: ids.length, books: [], omitted: 0 })) };
     const config = { get: vi.fn().mockReturnValue(appDataPath) };
-    const service = new MissingResourcesService(repo as never, store, libraryService as never, bookService as never, config as never);
-    return { service, repo, libraryService, bookService };
+    const service = new MissingResourcesService(
+      repo as never,
+      store,
+      libraryService as never,
+      bookService as never,
+      config as never,
+      coverStore as never,
+    );
+    return { service, repo, libraryService, bookService, coverStore };
   }
 
   async function runSweep(service: MissingResourcesService): Promise<void> {
@@ -106,10 +134,41 @@ describe('MissingResourcesService', () => {
 
       await runSweep(service);
 
-      expect(store.get(user.id)?.orphanedCoverDirs).toEqual([{ bookId: 42, fileCount: 1, sizeBytes: 2 }]);
+      expect(store.get(user.id)?.orphanedCoverDirs).toEqual([{ bookId: 42, fileCount: 1, sizeBytes: 2, media: [] }]);
       expect(service.getSweep(user)).toMatchObject({ orphanedCoverDirs: 1, orphanedBytes: 2 });
     });
 
+    it('names the slot folders an orphaned cover directory holds', async () => {
+      await makeCoverDir(43, {});
+      await mkdir(join(coversRoot, '43', 'audio'), { recursive: true });
+      await writeFile(join(coversRoot, '43', 'audio', 'cover_custom.jpg'), 'abc');
+      const { service } = setup();
+
+      await runSweep(service);
+
+      expect(store.get(user.id)?.orphanedCoverDirs).toEqual([{ bookId: 43, fileCount: 1, sizeBytes: 3, media: ['audio'] }]);
+    });
+
+    it('flags a book whose audiobook slot lost its image while its book slot still serves', async () => {
+      await mkdir(join(coversRoot, '5', 'ebook'), { recursive: true });
+      await writeFile(join(coversRoot, '5', 'ebook', 'cover_extracted.jpg'), 'image');
+      await mkdir(join(coversRoot, '6', 'ebook'), { recursive: true });
+      await writeFile(join(coversRoot, '6', 'ebook', 'cover_extracted.jpg'), 'image');
+      const coverStore = coverStoreWith([slotRow(5, 'ebook'), slotRow(5, 'audio', 'custom'), slotRow(6, 'ebook')]);
+      const { service } = setup(
+        {
+          countBooksWithCoverSource: vi.fn().mockResolvedValue(2),
+          findBookIdsWithCoverSource: vi.fn().mockResolvedValueOnce([5, 6]).mockResolvedValue([]),
+          findExistingBookIds: vi.fn().mockResolvedValue([5, 6]),
+        },
+        coverStore,
+      );
+
+      await runSweep(service);
+
+      expect(store.get(user.id)?.brokenCoverBookIds).toEqual([5]);
+    });
+
     it('records a failure when the sweep throws', async () => {
       const { service } = setup({ countBooksWithCoverSource: vi.fn().mockRejectedValue(new Error('db down')) });
 
@@ -198,10 +257,73 @@ describe('MissingResourcesService', () => {
     });
   });
 
+  describe('listBrokenCovers', () => {
+    it('names the broken slots of each book, and none for a book without slots', async () => {
+      await mkdir(join(coversRoot, '5', 'ebook'), { recursive: true });
+      await writeFile(join(coversRoot, '5', 'ebook', 'cover_extracted.jpg'), 'image');
+      const coverStore = coverStoreWith([slotRow(5, 'audio', 'custom'), slotRow(5, 'ebook')]);
+      const { service } = setup(
+        {
+          findBrokenCoverEntries: vi.fn().mockResolvedValue([
+            { id: 5, title: 'Dune', authors: ['Frank Herbert'], libraryId: 1, libraryName: 'Main', coverSource: 'custom' },
+            { id: 8, title: 'Legacy', authors: null, libraryId: 1, libraryName: 'Main', coverSource: 'extracted' },
+          ]),
+        },
+        coverStore,
+      );
+      await runSweep(service);
+      store.get(user.id)!.brokenCoverBookIds = [5, 8];
+
+      const page = await service.listBrokenCovers(user, 1, 50);
+
+      expect(page.items).toEqual([
+        {
+          id: 5,
+          title: 'Dune',
+          authors: ['Frank Herbert'],
+          libraryId: 1,
+          libraryName: 'Main',
+          coverSource: 'custom',
+          slots: [{ medium: 'audio', source: 'custom' }],
+        },
+        { id: 8, title: 'Legacy', authors: [], libraryId: 1, libraryName: 'Main', coverSource: 'extracted', slots: [] },
+      ]);
+    });
+  });
+
   describe('cleanBrokenCovers', () => {
+    it('removes a broken slot even when the other slot of the book still serves', async () => {
+      await mkdir(join(coversRoot, '5', 'ebook'), { recursive: true });
+      await writeFile(join(coversRoot, '5', 'ebook', 'cover_extracted.jpg'), 'image');
+      const coverStore = coverStoreWith([slotRow(5, 'ebook'), slotRow(5, 'audio')]);
+      const { service, repo } = setup({}, coverStore);
+      await runSweep(service);
+      store.get(user.id)!.brokenCoverBookIds = [5];
+
+      const result = await service.cleanBrokenCovers(user, { bookIds: [5] });
+
+      expect(coverStore.removeBrokenSlots).toHaveBeenCalledWith(5);
+      expect(repo.clearCoverSource).not.toHaveBeenCalled();
+      expect(result).toMatchObject({ cleaned: 1, skipped: 0 });
+    });
+
+    it('skips a slotted book whose slots all serve again', async () => {
+      await mkdir(join(coversRoot, '5', 'audio'), { recursive: true });
+      await writeFile(join(coversRoot, '5', 'audio', 'cover_custom.jpg'), 'image');
+      const coverStore = coverStoreWith([slotRow(5, 'audio', 'custom')]);
+      const { service } = setup({}, coverStore);
+      await runSweep(service);
+      store.get(user.id)!.brokenCoverBookIds = [5];
+
+      const result = await service.cleanBrokenCovers(user, { bookIds: [5] });
+
+      expect(coverStore.removeBrokenSlots).not.toHaveBeenCalled();
+      expect(result).toMatchObject({ cleaned: 0, skipped: 1 });
+    });
+
     it('clears only the books that are still missing a cover on disk', async () => {
       await makeCoverDir(2, { 'cover_extracted.jpg': 'image' });
-      const { service, repo } = setup({
+      const { service, repo, coverStore } = setup({
         countBooksWithCoverSource: vi.fn().mockResolvedValue(2),
         findBookIdsWithCoverSource: vi.fn().mockResolvedValueOnce([1, 2]).mockResolvedValue([]),
       });
@@ -211,6 +333,7 @@ describe('MissingResourcesService', () => {
 
       const result = await service.cleanBrokenCovers(user, { bookIds: [1, 2] });
 
+      expect(coverStore.removeBrokenSlots).toHaveBeenCalledWith(1);
       expect(repo.clearCoverSource).toHaveBeenCalledWith([1]);
       expect(result).toMatchObject({ category: 'broken_covers', requested: 2, cleaned: 1, skipped: 1 });
     });
diff --git a/server/src/modules/maintenance/missing-resources.service.ts b/server/src/modules/maintenance/missing-resources.service.ts
index 8847049f1..6e9491744 100644
--- a/server/src/modules/maintenance/missing-resources.service.ts
+++ b/server/src/modules/maintenance/missing-resources.service.ts
@@ -1,9 +1,12 @@
 import { BadRequestException, ConflictException, Injectable, Logger } from '@nestjs/common';
+import { COVER_MEDIA } from '@bookorbit/types';
 import { ConfigService } from '@nestjs/config';
 import { rm } from 'fs/promises';
 import { join } from 'path';
 import type {
   BrokenCoverEntry,
+  BrokenCoverSlot,
+  CoverMedium,
   CoverSweep,
   MissingBookEntry,
   MissingResourceCleanupResult,
@@ -15,9 +18,18 @@ import type {
 import type { RequestUser } from '../../common/types/request-user';
 import { sanitizeLogValue } from '../../common/utils/log-sanitize.utils';
 import { BookService } from '../book/book.service';
+import type { BookCoverSlotRow } from '../book-cover-store/book-cover-store.repository';
+import { BookCoverStore } from '../book-cover-store/book-cover-store.service';
 import { LibraryService } from '../library/library.service';
 import { CoverSweepStore, type SweepRecord } from './cover-sweep.store';
-import { COVER_DISK_CONCURRENCY, hasServableCover, mapWithConcurrency, measureCoverDir, readCoverDirBookIds } from './lib/cover-disk';
+import {
+  COVER_DISK_CONCURRENCY,
+  findBrokenCoverSlots,
+  hasServableCover,
+  mapWithConcurrency,
+  measureCoverDir,
+  readCoverDirBookIds,
+} from './lib/cover-disk';
 import { MissingResourcesRepository } from './missing-resources.repository';
 import type { MissingResourceCleanupDto } from './dto/missing-resources.dto';
 
@@ -36,6 +48,7 @@ export class MissingResourcesService {
     private readonly libraryService: LibraryService,
     private readonly bookService: BookService,
     config: ConfigService,
+    private readonly coverStore: BookCoverStore,
   ) {
     this.coversRoot = join(config.get<string>('storage.appDataPath')!, 'covers');
   }
@@ -84,6 +97,7 @@ export class MissingResourcesService {
     const pageIds = record.brokenCoverBookIds.slice((page - 1) * pageSize, page * pageSize);
     const rows = await this.repo.findBrokenCoverEntries(pageIds);
     const byId = new Map(rows.map((row) => [row.id, row]));
+    const brokenSlots = await this.brokenSlotsFor(pageIds);
     return {
       items: pageIds.flatMap((bookId) => {
         const row = byId.get(bookId);
@@ -96,6 +110,7 @@ export class MissingResourcesService {
             libraryId: row.libraryId,
             libraryName: row.libraryName,
             coverSource: row.coverSource,
+            slots: brokenSlots.get(bookId) ?? [],
           },
         ];
       }),
@@ -157,14 +172,17 @@ export class MissingResourcesService {
       `[${event}] [start] userId=${user.id} requested=${requestedIds.length} candidates=${candidates.length} - broken cover cleanup started`,
     );
     try {
-      const stillBroken: number[] = [];
-      await mapWithConcurrency(candidates, COVER_DISK_CONCURRENCY, async (bookId) => {
-        if (!(await hasServableCover(this.coversRoot, bookId))) stillBroken.push(bookId);
-      });
+      const stillBroken = await this.findBrokenBookIds(candidates);
 
       let cleaned = 0;
-      for (let index = 0; index < stillBroken.length; index += DELETE_BATCH_SIZE) {
-        cleaned += await this.repo.clearCoverSource(stillBroken.slice(index, index + DELETE_BATCH_SIZE));
+      const legacyBroken: number[] = [];
+      for (const bookId of stillBroken) {
+        const result = await this.coverStore.removeBrokenSlots(bookId);
+        if (result.hadSlots) cleaned += result.removed > 0 ? 1 : 0;
+        else legacyBroken.push(bookId);
+      }
+      for (let index = 0; index < legacyBroken.length; index += DELETE_BATCH_SIZE) {
+        cleaned += await this.repo.clearCoverSource(legacyBroken.slice(index, index + DELETE_BATCH_SIZE));
       }
       const handled = new Set(requestedIds);
       record.brokenCoverBookIds = record.brokenCoverBookIds.filter((bookId) => !handled.has(bookId));
@@ -240,6 +258,45 @@ export class MissingResourcesService {
     }
   }
 
+  /**
+   * A book with slots is broken as soon as one slot has lost its image, even while the other still
+   * serves. A book the upgrade has not converted yet is judged by its folder as a whole.
+   */
+  private async findBrokenBookIds(bookIds: readonly number[]): Promise<number[]> {
+    const slotsByBook = await this.slotRowsFor(bookIds);
+    const flags = await mapWithConcurrency(bookIds, COVER_DISK_CONCURRENCY, async (bookId) => {
+      const media = (slotsByBook.get(bookId) ?? []).map((slot) => slot.medium as CoverMedium);
+      if (media.length === 0) return !(await hasServableCover(this.coversRoot, bookId));
+      return (await findBrokenCoverSlots(this.coversRoot, bookId, media)).length > 0;
+    });
+    return bookIds.filter((_, index) => flags[index]);
+  }
+
+  private async brokenSlotsFor(bookIds: readonly number[]): Promise<Map<number, BrokenCoverSlot[]>> {
+    const slotsByBook = await this.slotRowsFor(bookIds);
+    const entries = await mapWithConcurrency(bookIds, COVER_DISK_CONCURRENCY, async (bookId) => {
+      const slots = slotsByBook.get(bookId) ?? [];
+      const broken = new Set(
+        await findBrokenCoverSlots(
+          this.coversRoot,
+          bookId,
+          slots.map((slot) => slot.medium as CoverMedium),
+        ),
+      );
+      const brokenSlots = COVER_MEDIA.flatMap((medium) => {
+        const slot = slots.find((candidate) => candidate.medium === medium);
+        return slot && broken.has(medium) ? [{ medium, source: slot.source as BrokenCoverSlot['source'] }] : [];
+      });
+      return [bookId, brokenSlots] as const;
+    });
+    return new Map(entries);
+  }
+
+  private async slotRowsFor(bookIds: readonly number[]): Promise<Map<number, BookCoverSlotRow[]>> {
+    if (bookIds.length === 0) return new Map();
+    return this.coverStore.slotsFor([...bookIds]);
+  }
+
   private async runSweep(user: RequestUser, record: SweepRecord): Promise<void> {
     const event = 'maintenance.cover_sweep';
     const startedAt = Date.now();
@@ -256,9 +313,7 @@ export class MissingResourcesService {
 
         const onDisk = batch.filter((bookId) => diskBookIds.has(bookId));
         const broken = batch.filter((bookId) => !diskBookIds.has(bookId));
-        await mapWithConcurrency(onDisk, COVER_DISK_CONCURRENCY, async (bookId) => {
-          if (!(await hasServableCover(this.coversRoot, bookId))) broken.push(bookId);
-        });
+        broken.push(...(await this.findBrokenBookIds(onDisk)));
 
         this.store.addBrokenCovers(record, broken);
         record.processedBooks += batch.length;
diff --git a/server/src/modules/metadata-fetch/candidate-agreement.test.ts b/server/src/modules/metadata-fetch/candidate-agreement.test.ts
index cf4ec4150..f37576b7f 100644
--- a/server/src/modules/metadata-fetch/candidate-agreement.test.ts
+++ b/server/src/modules/metadata-fetch/candidate-agreement.test.ts
@@ -1,7 +1,7 @@
 import { MetadataCandidate, MetadataProviderKey } from '@bookorbit/types';
 import { describe, expect, it } from 'vitest';
 
-import { resolveCandidateAgreement } from './candidate-agreement';
+import { acceptAgainstAnchor, resolveCandidateAgreement } from './candidate-agreement';
 import { MetadataSearchParams } from './providers/metadata-search-params';
 
 function candidate(provider: MetadataProviderKey, data: Partial<MetadataCandidate> = {}): MetadataCandidate {
@@ -160,3 +160,19 @@ describe('resolveCandidateAgreement', () => {
     });
   });
 });
+
+describe('acceptAgainstAnchor', () => {
+  const anchor = candidate(MetadataProviderKey.GOOGLE, { title: 'The Hobbit', authors: ['J.R.R. Tolkien'] });
+
+  it('checks even a lone candidate against the anchor, which a fresh agreement would accept unjudged', () => {
+    const wrong = candidate(MetadataProviderKey.ITUNES, { title: 'Dune', authors: ['Frank Herbert'] });
+
+    expect(acceptAgainstAnchor(anchor, [wrong])).toEqual({ accepted: [], rejected: [wrong] });
+  });
+
+  it('accepts the same book in another edition', () => {
+    const audiobook = candidate(MetadataProviderKey.ITUNES, { title: 'The Hobbit (Unabridged)', authors: ['J. R. R. Tolkien'] });
+
+    expect(providersOf(acceptAgainstAnchor(anchor, [audiobook]).accepted)).toEqual([MetadataProviderKey.ITUNES]);
+  });
+});
diff --git a/server/src/modules/metadata-fetch/candidate-agreement.ts b/server/src/modules/metadata-fetch/candidate-agreement.ts
index 75cfbb4f8..3500828fe 100644
--- a/server/src/modules/metadata-fetch/candidate-agreement.ts
+++ b/server/src/modules/metadata-fetch/candidate-agreement.ts
@@ -52,6 +52,24 @@ export function resolveCandidateAgreement(candidates: readonly MetadataCandidate
   return { anchor, accepted, rejected };
 }
 
+/**
+ * Holds candidates from a later search to an anchor chosen earlier, such as the audiobook edition's
+ * art to the book a first pass identified. Unlike `resolveCandidateAgreement`, a single candidate
+ * is checked too: it has no peers to outvote it, but the anchor still describes the book.
+ */
+export function acceptAgainstAnchor(
+  anchor: MetadataCandidate,
+  candidates: readonly MetadataCandidate[],
+): Pick<CandidateAgreement, 'accepted' | 'rejected'> {
+  const accepted: MetadataCandidate[] = [];
+  const rejected: MetadataCandidate[] = [];
+  for (const candidate of candidates) {
+    if (candidate === anchor || describesSameBook(anchor, candidate)) accepted.push(candidate);
+    else rejected.push(candidate);
+  }
+  return { accepted, rejected };
+}
+
 /**
  * The candidate the others are measured against: an edition confirmed by the book's own ISBN when
  * one is available, otherwise whichever candidate the query supports most strongly. Ties fall to
diff --git a/server/src/modules/metadata-fetch/metadata-fetch-pipeline.test.ts b/server/src/modules/metadata-fetch/metadata-fetch-pipeline.test.ts
index 14e9a324d..45b6f2ad7 100644
--- a/server/src/modules/metadata-fetch/metadata-fetch-pipeline.test.ts
+++ b/server/src/modules/metadata-fetch/metadata-fetch-pipeline.test.ts
@@ -1,6 +1,7 @@
 import type { Mocked } from 'vitest';
 import {
   ALL_METADATA_FIELDS,
+  CoverMedia,
   FieldPreference,
   MetadataCandidate,
   MetadataFetchPreferences,
@@ -18,6 +19,8 @@ import { MetadataFetchPipeline } from './metadata-fetch-pipeline';
 import { MetadataFetchService } from './metadata-fetch.service';
 import { ProviderRegistry } from './provider-registry';
 import { ProviderThrottleTracker } from './provider-throttle.tracker';
+import type { MetadataProvider } from './providers/metadata-provider';
+import type { MetadataSearchParams } from './providers/metadata-search-params';
 
 function createPreferences(mutate?: (fields: Record<MetadataField, FieldPreference>) => void): MetadataFetchPreferences {
   const fields = Object.fromEntries(
@@ -35,6 +38,15 @@ function createPreferences(mutate?: (fields: Record<MetadataField, FieldPreferen
   return { fields };
 }
 
+const PROVIDER_TRAITS: Partial<Record<MetadataProviderKey, Partial<MetadataProvider>>> = {
+  [MetadataProviderKey.AUDIBLE]: { mediaKinds: ['audiobook'], coverShape: 'square' },
+  [MetadataProviderKey.AUDNEXUS]: { mediaKinds: ['audiobook'], coverShape: 'square' },
+  [MetadataProviderKey.LIBROFM]: { mediaKinds: ['audiobook'], coverShape: 'square' },
+  [MetadataProviderKey.COMICVINE]: { mediaKinds: ['comic'], coverShape: 'portrait' },
+  [MetadataProviderKey.ITUNES]: { editionFollowsMedium: true },
+  [MetadataProviderKey.HARDCOVER]: { editionFollowsMedium: true },
+};
+
 // Candidates share a title by default so that fixtures exercising field-rule precedence describe
 // one book. Cross-provider agreement drops candidates that describe a different book, which is a
 // separate concern with its own tests.
@@ -78,8 +90,15 @@ describe('MetadataFetchPipeline', () => {
       withForwardCompatibility: vi.fn(),
     } as unknown as Mocked<MetadataPreferenceResolver>;
 
+    // The media helpers run the real registry over whatever providers a test registers, with each
+    // provider's real media and edition traits.
+    const live = () =>
+      new ProviderRegistry(((registry.all() ?? []) as MetadataProvider[]).map((provider) => ({ ...PROVIDER_TRAITS[provider.key], ...provider })));
     registry = {
       all: vi.fn(),
+      keysForMedia: vi.fn((keys: MetadataProviderKey[], media: CoverMedia) => live().keysForMedia(keys, media)),
+      servesOnlyAudiobooks: vi.fn((key: MetadataProviderKey) => live().servesOnlyAudiobooks(key)),
+      editionFollowsMedium: vi.fn((key: MetadataProviderKey) => live().editionFollowsMedium(key)),
     } as unknown as Mocked<ProviderRegistry>;
 
     throttleTracker = { isThrottled: vi.fn().mockReturnValue(false) };
@@ -284,11 +303,11 @@ describe('MetadataFetchPipeline', () => {
     expect(fetchService.searchCandidates).toHaveBeenCalledWith({ title: 'Query' }, [MetadataProviderKey.KOBO]);
   });
 
-  it('lets Field Rules run an audiobook provider without switching the search to audiobook editions', async () => {
+  it('keeps an audiobook-only provider out of a book without audio, even when a Field Rule names it', async () => {
     const global = createPreferences((fields) => {
       fields.title = {
         enabled: true,
-        providers: [MetadataProviderKey.LIBROFM],
+        providers: [MetadataProviderKey.LIBROFM, MetadataProviderKey.GOOGLE],
         mergeStrategy: 'overwriteIfProvided',
       };
     });
@@ -301,36 +320,16 @@ describe('MetadataFetchPipeline', () => {
     preferencesService.getGlobal.mockResolvedValue(global);
     resolver.resolve.mockReturnValue(global);
     resolver.withForwardCompatibility.mockReturnValue(global);
-    registry.all.mockReturnValue([{ key: MetadataProviderKey.LIBROFM }] as never);
-    fetchService.searchCandidates.mockReturnValue(
-      of(
-        candidate(MetadataProviderKey.LIBROFM, '9798217174331', {
-          title: 'Yesteryear: A GMA Book Club Pick',
-          authors: ['Caro Claire Burke'],
-        }),
-      ),
-    );
+    registry.all.mockReturnValue([{ key: MetadataProviderKey.LIBROFM }, { key: MetadataProviderKey.GOOGLE }] as never);
+    fetchService.searchCandidates.mockReturnValue(of(candidate(MetadataProviderKey.GOOGLE, 'g1', { title: 'Yesteryear' })));
 
-    await pipeline.run(
-      {
-        title: 'Yesteryear',
-        author: 'Caro Claire Burke',
-        isbn: '9780593804223',
-        isAudiobook: false,
-      },
-      {},
-    );
+    const params = { title: 'Yesteryear', author: 'Caro Claire Burke', isbn: '9780593804223', isAudiobook: false };
+    const { diagnostics } = await pipeline.runWithSources(params, {}, undefined, { coverMedia: { hasEbook: true, hasAudio: false } });
 
-    expect(fetchService.searchCandidates).toHaveBeenCalledWith(
-      {
-        title: 'Yesteryear',
-        author: 'Caro Claire Burke',
-        isbn: '9780593804223',
-        isAudiobook: false,
-        includeAudiobookProviders: true,
-      },
-      [MetadataProviderKey.LIBROFM],
-    );
+    expect(fetchService.searchCandidates).toHaveBeenCalledTimes(1);
+    expect(fetchService.searchCandidates).toHaveBeenCalledWith(params, [MetadataProviderKey.GOOGLE]);
+    expect(diagnostics.fieldRuleProviders).not.toContain(MetadataProviderKey.LIBROFM);
+    expect(diagnostics.enabledUnreferencedProviders).not.toContain(MetadataProviderKey.LIBROFM);
   });
 
   it('returns diagnostics when field rules only reference disabled providers', async () => {
@@ -1692,6 +1691,366 @@ describe('MetadataFetchPipeline', () => {
     expect(preferencesService.getForLibrary).toHaveBeenCalledWith(10, global);
     expect(result).toEqual([MetadataProviderKey.KOBO, MetadataProviderKey.GOOGLE]);
   });
+
+  describe('cover slots', () => {
+    const EBOOK_ONLY: CoverMedia = { hasEbook: true, hasAudio: false };
+    const AUDIO_ONLY: CoverMedia = { hasEbook: false, hasAudio: true };
+    const BOTH: CoverMedia = { hasEbook: true, hasAudio: true };
+    type Editions = { ebook?: Partial<MetadataCandidate>; audio?: Partial<MetadataCandidate> };
+
+    function usePreferences(mutate?: (preferences: MetadataFetchPreferences) => void): MetadataFetchPreferences {
+      const preferences = new MetadataPreferenceResolver().getDefaultPreferences();
+      mutate?.(preferences);
+      preferencesService.getGlobal.mockResolvedValue(preferences);
+      resolver.resolve.mockReturnValue(preferences);
+      resolver.withForwardCompatibility.mockReturnValue(preferences);
+      return preferences;
+    }
+
+    function register(...keys: MetadataProviderKey[]): void {
+      registry.all.mockReturnValue(keys.map((key) => ({ key })) as never);
+    }
+
+    /** Answers every search from a table, giving each provider's edition for the medium asked about. */
+    function answer(table: Partial<Record<MetadataProviderKey, Editions>>): void {
+      fetchService.searchCandidates.mockImplementation((params: MetadataSearchParams, providers?: MetadataProviderKey[]) =>
+        of(
+          ...(providers ?? []).flatMap((provider) => {
+            const data = table[provider]?.[params.isAudiobook ? 'audio' : 'ebook'];
+            return data ? [candidate(provider, `${provider}-${params.isAudiobook ? 'audio' : 'ebook'}`, data)] : [];
+          }),
+        ),
+      );
+    }
+
+    function searches(): { params: MetadataSearchParams; providers: MetadataProviderKey[] }[] {
+      return fetchService.searchCandidates.mock.calls.map(([params, providers]) => ({ params, providers: providers ?? [] }));
+    }
+
+    const square = (url: string): Partial<MetadataCandidate> => ({ coverUrl: url, coverShape: 'square' });
+    const portrait = (url: string): Partial<MetadataCandidate> => ({ coverUrl: url, coverShape: 'portrait' });
+
+    it('never asks an audiobook provider about a book without audio, even with a stored Audible id', async () => {
+      usePreferences();
+      register(MetadataProviderKey.GOOGLE, MetadataProviderKey.ITUNES, MetadataProviderKey.AUDIBLE, MetadataProviderKey.LIBROFM);
+      answer({ [MetadataProviderKey.GOOGLE]: { ebook: portrait('https://google/e.jpg') } });
+
+      const { resolved } = await pipeline.runWithSources(
+        { title: 'Dune', isAudiobook: false, existingProviderIds: { [MetadataProviderKey.AUDIBLE]: 'B0STORED' } },
+        {},
+        undefined,
+        { coverMedia: EBOOK_ONLY },
+      );
+
+      expect(searches()).toHaveLength(1);
+      expect(searches()[0]!.providers).not.toContain(MetadataProviderKey.AUDIBLE);
+      expect(searches()[0]!.providers).not.toContain(MetadataProviderKey.LIBROFM);
+      expect(searches()[0]!.params.includeAudiobookProviders).toBeUndefined();
+      expect(resolved.coverUrl).toBe('https://google/e.jpg');
+      expect(resolved.audioCoverUrl).toBeUndefined();
+    });
+
+    it('fills the audio slot of an audiobook in one pass, Audible first', async () => {
+      usePreferences();
+      register(MetadataProviderKey.GOOGLE, MetadataProviderKey.ITUNES, MetadataProviderKey.AUDIBLE);
+      answer({
+        [MetadataProviderKey.AUDIBLE]: { audio: square('https://audible/a.jpg') },
+        [MetadataProviderKey.ITUNES]: { audio: square('https://itunes/a.jpg') },
+        [MetadataProviderKey.GOOGLE]: { audio: portrait('https://google/a.jpg') },
+      });
+
+      const { resolved, sources, diagnostics } = await pipeline.runWithSources({ title: 'Dune', isAudiobook: true }, {}, undefined, {
+        coverMedia: AUDIO_ONLY,
+      });
+
+      expect(searches()).toHaveLength(1);
+      expect(searches()[0]!.params.includeAudiobookProviders).toBe(true);
+      expect(resolved.coverUrl).toBeUndefined();
+      expect(resolved.audioCoverUrl).toBe('https://audible/a.jpg');
+      expect(resolved.audioCoverChoices?.map((choice) => [choice.provider, choice.fit])).toEqual([
+        [MetadataProviderKey.AUDIBLE, 'match'],
+        [MetadataProviderKey.ITUNES, 'match'],
+        [MetadataProviderKey.GOOGLE, 'mismatch'],
+      ]);
+      expect(sources.audioCoverUrl).toBe(MetadataProviderKey.AUDIBLE);
+      expect(diagnostics.coverSlots).toEqual({ audio: { provider: MetadataProviderKey.AUDIBLE, pass: 1 } });
+    });
+
+    it('asks only the edition-aware providers again, as the other medium and without the ids naming the first edition', async () => {
+      usePreferences();
+      register(MetadataProviderKey.GOOGLE, MetadataProviderKey.ITUNES, MetadataProviderKey.AMAZON);
+      answer({
+        [MetadataProviderKey.GOOGLE]: { ebook: portrait('https://google/e.jpg') },
+        [MetadataProviderKey.AMAZON]: { ebook: portrait('https://amazon/e.jpg') },
+        [MetadataProviderKey.ITUNES]: { ebook: portrait('https://itunes/e.jpg'), audio: square('https://itunes/a.jpg') },
+      });
+
+      const { resolved, diagnostics } = await pipeline.runWithSources(
+        {
+          title: 'Dune',
+          isbn: '9780441013593',
+          hardcoverEditionId: '42',
+          isAudiobook: false,
+          existingProviderIds: { [MetadataProviderKey.ITUNES]: 'itunes-ebook', [MetadataProviderKey.GOOGLE]: 'g1' },
+        },
+        { cover: null, audioCover: null },
+        undefined,
+        { coverMedia: BOTH },
+      );
+
+      expect(searches()).toHaveLength(2);
+      const pass2 = searches()[1]!;
+      expect(pass2.providers).toEqual([MetadataProviderKey.ITUNES]);
+      expect(pass2.params).toMatchObject({ title: 'Dune', isAudiobook: true, includeAudiobookProviders: false });
+      expect(pass2.params.isbn).toBeUndefined();
+      expect(pass2.params.hardcoverEditionId).toBeUndefined();
+      expect(pass2.params.existingProviderIds).toEqual({ [MetadataProviderKey.GOOGLE]: 'g1' });
+      expect(resolved.coverUrl).toBe('https://amazon/e.jpg');
+      expect(resolved.audioCoverUrl).toBe('https://itunes/a.jpg');
+      expect(diagnostics.coverSlots).toEqual({
+        ebook: { provider: MetadataProviderKey.AMAZON, pass: 1 },
+        audio: { provider: MetadataProviderKey.ITUNES, pass: 2 },
+      });
+    });
+
+    it('holds pass-2 candidates to the book pass 1 identified', async () => {
+      usePreferences((preferences) => {
+        preferences.fields.audioCover.providers = [MetadataProviderKey.ITUNES];
+      });
+      register(MetadataProviderKey.GOOGLE, MetadataProviderKey.ITUNES);
+      answer({
+        [MetadataProviderKey.GOOGLE]: { ebook: { title: 'Dune', authors: ['Frank Herbert'] } },
+        [MetadataProviderKey.ITUNES]: {
+          ebook: { title: 'Dune', authors: ['Frank Herbert'] },
+          audio: { title: 'The Dune Cookbook Companion', authors: ['Someone Else'], ...square('https://itunes/wrong.jpg') },
+        },
+      });
+
+      const { resolved, diagnostics } = await pipeline.runWithSources({ title: 'Dune', author: 'Frank Herbert', isAudiobook: false }, {}, undefined, {
+        coverMedia: BOTH,
+      });
+
+      expect(searches()).toHaveLength(2);
+      expect(resolved.audioCoverUrl).toBeUndefined();
+      expect(diagnostics.coverSlots?.audio).toEqual({ provider: null, pass: null });
+    });
+
+    it('never saves the ids pass 2 found, since each id column is shared by both media', async () => {
+      usePreferences((preferences) => {
+        preferences.fields.title.providers = [MetadataProviderKey.ITUNES, MetadataProviderKey.HARDCOVER];
+        preferences.fields.audioCover.providers = [MetadataProviderKey.ITUNES, MetadataProviderKey.HARDCOVER];
+      });
+      register(MetadataProviderKey.ITUNES, MetadataProviderKey.HARDCOVER);
+      answer({
+        [MetadataProviderKey.ITUNES]: { ebook: {}, audio: square('https://itunes/a.jpg') },
+        [MetadataProviderKey.HARDCOVER]: { ebook: { hardcoverEditionId: 'ebook-edition' }, audio: { hardcoverEditionId: 'audio-edition' } },
+      });
+
+      const { resolved, providerIds } = await pipeline.runWithSources({ title: 'Dune', isAudiobook: false }, {}, undefined, { coverMedia: BOTH });
+
+      expect(searches()).toHaveLength(2);
+      expect(resolved.audioCoverUrl).toBe('https://itunes/a.jpg');
+      expect(providerIds[MetadataProviderKey.ITUNES]).toBe('itunes-ebook');
+      expect(providerIds[MetadataProviderKey.HARDCOVER]).toBe('hardcover-ebook');
+      expect(resolved.hardcoverEditionId).toBe('ebook-edition');
+    });
+
+    it('takes nothing but art from a provider only a cover rule brought in, apart from an audiobook id', async () => {
+      usePreferences((preferences) => {
+        // Community ratings name Audible and Hardcover by default, which would make them full providers.
+        preferences.fields.communityRating.providers = [MetadataProviderKey.GOOGLE];
+        preferences.fields.audioCover.providers = [MetadataProviderKey.AUDIBLE, MetadataProviderKey.HARDCOVER];
+      });
+      register(MetadataProviderKey.GOOGLE, MetadataProviderKey.AUDIBLE, MetadataProviderKey.HARDCOVER);
+      answer({
+        [MetadataProviderKey.GOOGLE]: { audio: { description: 'From Google' } },
+        [MetadataProviderKey.AUDIBLE]: {
+          audio: {
+            ...square('https://audible/a.jpg'),
+            providerId: 'B0AUDIBLE',
+            description: 'From Audible',
+            chapters: [{ title: 'One', startMs: 0 }],
+            comicMetadata: { issueNumber: '3' },
+          },
+        },
+        [MetadataProviderKey.HARDCOVER]: { audio: { hardcoverEditionId: 'hc-edition' } },
+      });
+
+      const { resolved, providerIds } = await pipeline.runWithSources({ title: 'Dune', isAudiobook: true }, {}, undefined, {
+        coverMedia: AUDIO_ONLY,
+      });
+
+      expect(resolved.audioCoverUrl).toBe('https://audible/a.jpg');
+      expect(resolved.description).toBe('From Google');
+      expect(resolved.chapters).toBeUndefined();
+      expect(resolved.comicMetadata).toBeUndefined();
+      expect(resolved.hardcoverEditionId).toBeUndefined();
+      expect(providerIds[MetadataProviderKey.AUDIBLE]).toBe('B0AUDIBLE');
+      expect(providerIds[MetadataProviderKey.HARDCOVER]).toBeUndefined();
+    });
+
+    it('lets a cover-only provider be checked against the anchor without choosing it', async () => {
+      usePreferences((preferences) => {
+        preferences.fields.communityRating.providers = [MetadataProviderKey.GOOGLE];
+        preferences.fields.audioCover.providers = [MetadataProviderKey.AUDIBLE, MetadataProviderKey.GOOGLE];
+      });
+      register(MetadataProviderKey.GOOGLE, MetadataProviderKey.AUDIBLE);
+      answer({
+        [MetadataProviderKey.GOOGLE]: { audio: { title: 'Dune', authors: ['Frank Herbert'], ...portrait('https://google/a.jpg') } },
+        [MetadataProviderKey.AUDIBLE]: { audio: { title: 'The Hobbit', authors: ['J. R. R. Tolkien'], ...square('https://audible/wrong.jpg') } },
+      });
+
+      // The query suits Audible's record better, but only a provider that supplies fields may say which book this is.
+      const { resolved } = await pipeline.runWithSources({ title: 'The Hobbit', isAudiobook: true }, {}, undefined, {
+        coverMedia: AUDIO_ONLY,
+      });
+
+      expect(resolved.audioCoverUrl).toBe('https://google/a.jpg');
+    });
+
+    it('fills an empty ebook slot under fill-missing while the audio slot is already filled', async () => {
+      usePreferences((preferences) => {
+        preferences.fields.cover.mergeStrategy = 'fillMissing';
+        preferences.fields.audioCover.mergeStrategy = 'fillMissing';
+      });
+      register(MetadataProviderKey.GOOGLE, MetadataProviderKey.ITUNES, MetadataProviderKey.AUDIBLE);
+      answer({
+        [MetadataProviderKey.GOOGLE]: { ebook: portrait('https://google/e.jpg') },
+        [MetadataProviderKey.AUDIBLE]: { ebook: square('https://audible/a.jpg') },
+      });
+
+      const { resolved } = await pipeline.runWithSources({ title: 'Dune', isAudiobook: false }, { cover: null, audioCover: true }, undefined, {
+        coverMedia: BOTH,
+      });
+
+      expect(resolved.coverUrl).toBe('https://google/e.jpg');
+      expect(resolved.audioCoverUrl).toBeUndefined();
+      expect(searches()).toHaveLength(1);
+    });
+
+    it('runs the Audiobook cover rule for a book whose only file is a read-along EPUB', async () => {
+      usePreferences();
+      register(MetadataProviderKey.GOOGLE, MetadataProviderKey.ITUNES, MetadataProviderKey.AUDIBLE);
+      answer({
+        [MetadataProviderKey.GOOGLE]: { ebook: portrait('https://google/e.jpg') },
+        [MetadataProviderKey.ITUNES]: { ebook: portrait('https://itunes/e.jpg'), audio: square('https://itunes/a.jpg') },
+        [MetadataProviderKey.AUDIBLE]: { ebook: square('https://audible/a.jpg') },
+      });
+
+      const { resolved } = await pipeline.runWithSources({ title: 'Dune', isAudiobook: false }, {}, undefined, { coverMedia: BOTH });
+
+      const [pass1, pass2] = searches();
+      expect(pass1!.params).toMatchObject({ isAudiobook: false, includeAudiobookProviders: true });
+      expect(pass1!.providers).toContain(MetadataProviderKey.AUDIBLE);
+      expect(pass2!.params.isAudiobook).toBe(true);
+      expect(pass2!.providers).toEqual([MetadataProviderKey.ITUNES]);
+      expect(resolved.coverUrl).toBe('https://itunes/e.jpg');
+      expect(resolved.audioCoverUrl).toBe('https://audible/a.jpg');
+      expect(resolved.audioCoverChoices?.map((choice) => [choice.provider, choice.fit])).toEqual([
+        [MetadataProviderKey.AUDIBLE, 'match'],
+        [MetadataProviderKey.ITUNES, 'match'],
+        [MetadataProviderKey.GOOGLE, 'mismatch'],
+      ]);
+    });
+
+    it('orders a slot by shape and offers wrong-shape art only to an empty slot', async () => {
+      usePreferences((preferences) => {
+        preferences.fields.audioCover.providers = [MetadataProviderKey.AMAZON, MetadataProviderKey.GOODREADS, MetadataProviderKey.KOBO];
+      });
+      register(MetadataProviderKey.AMAZON, MetadataProviderKey.GOODREADS, MetadataProviderKey.KOBO);
+      answer({
+        [MetadataProviderKey.AMAZON]: { audio: portrait('https://amazon/a.jpg') },
+        [MetadataProviderKey.GOODREADS]: { audio: { coverUrl: 'https://goodreads/a.jpg' } },
+        [MetadataProviderKey.KOBO]: { audio: square('https://kobo/a.jpg') },
+      });
+      const params = { title: 'Dune', isAudiobook: true };
+
+      const empty = await pipeline.runWithSources(params, { audioCover: null }, undefined, { coverMedia: AUDIO_ONLY });
+      const filled = await pipeline.runWithSources(params, { audioCover: true }, undefined, { coverMedia: AUDIO_ONLY });
+
+      expect(empty.resolved.audioCoverChoices?.map((choice) => [choice.provider, choice.fit])).toEqual([
+        [MetadataProviderKey.KOBO, 'match'],
+        [MetadataProviderKey.GOODREADS, 'unknown'],
+        [MetadataProviderKey.AMAZON, 'mismatch'],
+      ]);
+      expect(filled.resolved.audioCoverChoices?.map((choice) => choice.provider)).toEqual([MetadataProviderKey.KOBO, MetadataProviderKey.GOODREADS]);
+    });
+
+    it('skips a cover the provider says is a thumbnail', async () => {
+      usePreferences((preferences) => {
+        preferences.fields.audioCover.providers = [MetadataProviderKey.HARDCOVER, MetadataProviderKey.KOBO];
+      });
+      register(MetadataProviderKey.HARDCOVER, MetadataProviderKey.KOBO);
+      answer({
+        [MetadataProviderKey.HARDCOVER]: { audio: { ...square('https://hardcover/thumb.jpg'), coverWidth: 98, coverHeight: 98 } },
+        [MetadataProviderKey.KOBO]: { audio: square('https://kobo/a.jpg') },
+      });
+
+      const { resolved } = await pipeline.runWithSources({ title: 'Dune', isAudiobook: true }, {}, undefined, { coverMedia: AUDIO_ONLY });
+
+      expect(resolved.audioCoverChoices?.map((choice) => choice.url)).toEqual(['https://kobo/a.jpg']);
+    });
+
+    it('neither resolves nor searches for a locked slot', async () => {
+      usePreferences();
+      register(MetadataProviderKey.GOOGLE, MetadataProviderKey.ITUNES, MetadataProviderKey.AUDIBLE);
+      answer({
+        [MetadataProviderKey.GOOGLE]: { ebook: portrait('https://google/e.jpg') },
+        [MetadataProviderKey.AUDIBLE]: { ebook: square('https://audible/a.jpg') },
+      });
+
+      const { resolved, diagnostics } = await pipeline.runWithSources({ title: 'Dune', isAudiobook: false }, {}, undefined, {
+        coverMedia: BOTH,
+        lockedCoverSlots: ['audio'],
+      });
+
+      expect(searches()).toHaveLength(1);
+      expect(resolved.coverUrl).toBe('https://google/e.jpg');
+      expect(resolved.audioCoverUrl).toBeUndefined();
+      expect(diagnostics.coverSlots).toEqual({ ebook: { provider: MetadataProviderKey.GOOGLE, pass: 1 } });
+    });
+
+    it('asks nobody again in existing-only mode and fills the other slot from pass 1', async () => {
+      usePreferences((preferences) => {
+        preferences.options = { ...preferences.options!, providerIdMode: 'existingOnly' };
+      });
+      register(MetadataProviderKey.GOOGLE, MetadataProviderKey.ITUNES, MetadataProviderKey.AUDIBLE);
+      answer({
+        [MetadataProviderKey.GOOGLE]: { ebook: portrait('https://google/e.jpg') },
+        [MetadataProviderKey.ITUNES]: { ebook: portrait('https://itunes/e.jpg') },
+        [MetadataProviderKey.AUDIBLE]: { ebook: square('https://audible/a.jpg') },
+      });
+
+      const { resolved } = await pipeline.runWithSources(
+        {
+          title: 'Dune',
+          isAudiobook: false,
+          existingProviderIds: {
+            [MetadataProviderKey.GOOGLE]: 'g1',
+            [MetadataProviderKey.ITUNES]: 'i1',
+            [MetadataProviderKey.AUDIBLE]: 'B0',
+          },
+        },
+        {},
+        undefined,
+        { coverMedia: BOTH },
+      );
+
+      expect(searches()).toHaveLength(1);
+      expect(resolved.audioCoverUrl).toBe('https://audible/a.jpg');
+      expect(resolved.audioCoverChoices?.map((choice) => choice.provider)).not.toContain(MetadataProviderKey.ITUNES);
+    });
+
+    it('narrows the effective provider keys to a book without audio', async () => {
+      usePreferences();
+      register(MetadataProviderKey.GOOGLE, MetadataProviderKey.AUDIBLE, MetadataProviderKey.LIBROFM);
+
+      await expect(pipeline.getEffectiveProviderKeys(undefined, EBOOK_ONLY)).resolves.toEqual([MetadataProviderKey.GOOGLE]);
+      await expect(pipeline.getEffectiveProviderKeys(undefined, AUDIO_ONLY)).resolves.toEqual(
+        expect.arrayContaining([MetadataProviderKey.GOOGLE, MetadataProviderKey.AUDIBLE, MetadataProviderKey.LIBROFM]),
+      );
+    });
+  });
 });
 
 function makeProviderConfig(overrides: Partial<ProviderConfigurations> = {}): ProviderConfigurations {
diff --git a/server/src/modules/metadata-fetch/metadata-fetch-pipeline.ts b/server/src/modules/metadata-fetch/metadata-fetch-pipeline.ts
index d591b6900..0b25ee700 100644
--- a/server/src/modules/metadata-fetch/metadata-fetch-pipeline.ts
+++ b/server/src/modules/metadata-fetch/metadata-fetch-pipeline.ts
@@ -3,14 +3,18 @@ import {
   AudiobookChapter,
   BookCommunityRating,
   ComicMetadataFields,
+  CoverMedia,
+  CoverMedium,
   FieldPreference,
   MetadataCandidate,
+  MetadataFetchCoverSlotDiagnostics,
   MetadataFetchDiagnostics,
   MetadataFetchPreferences,
   MetadataField,
   MetadataMergeStrategy,
   MetadataProviderKey,
   MetadataSeriesMembership,
+  MIN_COVER_SHORT_SIDE_PX,
   ProviderConfigurations,
   parseSeriesIndex,
 } from '@bookorbit/types';
@@ -23,14 +27,29 @@ import { SeriesExpectedCountService } from '../../common/services/series-expecte
 import { applyGenreFetchOptions, createGenreBlocklistTokenSet, mergeExistingGenres } from '../../common/utils/genre-fetch-options.utils';
 import { normalizeMetadataText, normalizeMetadataTextKey } from '../../common/utils/metadata-text-normalize.utils';
 import { sanitizeLogValue } from '../../common/utils/log-sanitize.utils';
-import { resolveCandidateAgreement } from './candidate-agreement';
+import { acceptAgainstAnchor, resolveCandidateAgreement } from './candidate-agreement';
 import { MetadataFetchService } from './metadata-fetch.service';
 import { ProviderRegistry } from './provider-registry';
 import { ProviderThrottleTracker } from './provider-throttle.tracker';
 import { MetadataSearchParams } from './providers/metadata-search-params';
 
+/**
+ * One fetched cover a slot may take, in the order the apply step tries them. `fit` compares the
+ * shape the provider stated with the slot's: a `mismatch` only ever fills an empty slot.
+ */
+export interface ResolvedCoverChoice {
+  url: string;
+  provider: MetadataProviderKey;
+  fit: 'match' | 'unknown' | 'mismatch';
+}
+
 export type ResolvedMetadataFields = Partial<Record<MetadataField, string | string[] | number | null>> & {
+  /** The ebook slot's first choice. */
   coverUrl?: string;
+  coverChoices?: ResolvedCoverChoice[];
+  /** The audio slot's first choice. */
+  audioCoverUrl?: string;
+  audioCoverChoices?: ResolvedCoverChoice[];
   hardcoverEditionId?: string | null;
   publishedDate?: string | null;
   seriesMemberships?: MetadataSeriesMembership[];
@@ -39,6 +58,7 @@ export type ResolvedMetadataFields = Partial<Record<MetadataField, string | stri
   communityRatings?: BookCommunityRating[];
 };
 
+/** `cover` is the ebook slot and `audioCover` the audio slot; each is present when its slot is filled. */
 export interface ExistingMetadataFields extends Partial<Record<MetadataField, unknown>> {
   chapters?: unknown;
   comicMetadata?: Partial<Record<keyof ComicMetadataFields, unknown>> | null;
@@ -47,15 +67,42 @@ export interface ExistingMetadataFields extends Partial<Record<MetadataField, un
 
 export interface MetadataFetchRunOptions {
   preserveExisting?: boolean;
+  /**
+   * The book's cover media (`getCoverMedia`). They decide which cover rules run, which providers are
+   * worth asking, and whether a second pass fetches the other medium's art. Flows without a stored
+   * book omit it and count as the one medium `isAudiobook` names.
+   */
+  coverMedia?: CoverMedia;
+  /** Cover slots whose lock is set. A locked slot is neither resolved nor searched for. */
+  lockedCoverSlots?: readonly CoverMedium[];
 }
 
 type ResolvedProviderIds = Partial<Record<MetadataProviderKey, string>>;
-const AUDIOBOOK_PROVIDER_KEYS = new Set<MetadataProviderKey>([
+type CandidatesByProvider = Map<string, MetadataCandidate>;
+
+const COVER_FIELD_BY_MEDIUM: Record<CoverMedium, 'cover' | 'audioCover'> = { ebook: 'cover', audio: 'audioCover' };
+const EXPECTED_SHAPE: Record<CoverMedium, 'portrait' | 'square'> = { ebook: 'portrait', audio: 'square' };
+// The apply step downloads at most three; the rest only cover choices it had to skip.
+const MAX_COVER_CHOICES = 5;
+// An audiobook source's id is worth keeping even when it only supplied art: the next fetch of the
+// audio slot is then a direct lookup instead of a search.
+const COVER_ONLY_SAVED_ID_PROVIDERS = new Set<MetadataProviderKey>([
   MetadataProviderKey.AUDIBLE,
   MetadataProviderKey.AUDNEXUS,
   MetadataProviderKey.LIBROFM,
 ]);
 
+interface FetchScope {
+  media: CoverMedia;
+  primaryMedium: CoverMedium;
+  lockedSlots: ReadonlySet<CoverMedium>;
+}
+
+interface CoverSlotResolution {
+  choices: ResolvedCoverChoice[];
+  pass: 1 | 2;
+}
+
 type ProviderSelectionDiagnostics = Pick<
   MetadataFetchDiagnostics,
   'activeProviders' | 'fieldRuleProviders' | 'disabledFieldRuleProviders' | 'enabledUnreferencedProviders' | 'throttledProviders'
@@ -114,9 +161,10 @@ export class MetadataFetchPipeline {
     return this.runInternal(params, existingFields, libraryId, options);
   }
 
-  async getEffectiveProviderKeys(libraryId?: number): Promise<MetadataProviderKey[]> {
+  /** The providers the field rules would query, narrowed to a book's media when one is given. */
+  async getEffectiveProviderKeys(libraryId?: number, media?: CoverMedia): Promise<MetadataProviderKey[]> {
     const { preferences, registeredKeys, providerConfig } = await this.resolveProviderPreferenceContext(libraryId);
-    return this.deriveConfiguredProviderSelection(preferences, registeredKeys, providerConfig).configuredFieldRuleProviders;
+    return this.deriveConfiguredProviderSelection(preferences, registeredKeys, providerConfig, media).configuredFieldRuleProviders;
   }
 
   private async runInternal(
@@ -131,22 +179,21 @@ export class MetadataFetchPipeline {
     diagnostics: MetadataFetchDiagnostics;
   }> {
     const { preferences, registeredKeys, providerConfig } = await this.resolveProviderPreferenceContext(libraryId);
+    const scope = this.fetchScope(params, options);
     const existingProviderIdsOnly = preferences.options?.providerIdMode === 'existingOnly' && params.existingProviderIds !== undefined;
     const providerSelection = this.deriveProviderSet(
       preferences,
       registeredKeys,
       providerConfig,
+      scope.media,
       existingProviderIdsOnly ? params.existingProviderIds : undefined,
     );
+    const coverOnlyProviders = this.coverOnlyProviders(preferences, scope.media, providerSelection.activeProviders);
     const providerSearchParams = existingProviderIdsOnly ? { ...params, existingProviderIdsOnly: true } : params;
-    const searchParams = providerSelection.activeProviders.some((provider) => AUDIOBOOK_PROVIDER_KEYS.has(provider))
+    const searchParams = providerSelection.activeProviders.some((provider) => this.registry.servesOnlyAudiobooks(provider))
       ? { ...providerSearchParams, includeAudiobookProviders: true }
       : providerSearchParams;
-    const candidates = providerSelection.activeProviders.length
-      ? await firstValueFrom(this.fetchService.searchCandidates(searchParams, providerSelection.activeProviders).pipe(toArray()), {
-          defaultValue: [] as MetadataCandidate[],
-        })
-      : [];
+    const candidates = await this.searchCandidates(searchParams, providerSelection.activeProviders);
 
     // The service already swallows its own failures; this guards the invariant at the boundary so
     // that a future change there can never turn a series total into a failed metadata refresh.
@@ -154,39 +201,294 @@ export class MetadataFetchPipeline {
       this.logger.warn(`[metadata.seriesTotals] [fail] errorClass=${err.name} - series totals not recorded; resolution continues`);
     });
 
-    const byProvider = new Map<string, MetadataCandidate>();
-    for (const c of candidates) {
-      if (!byProvider.has(c.provider)) byProvider.set(c.provider, c);
+    const { anchor, accepted: agreeing } = this.rejectDisagreeingCandidates(
+      preferences,
+      providerSelection.activeProviders,
+      this.firstPerProvider(candidates),
+      params,
+      coverOnlyProviders,
+    );
+    const { resolved, sources, providerIds } = this.applyPreferences(
+      preferences,
+      agreeing,
+      existingFields,
+      params.existingProviderIds,
+      options,
+      coverOnlyProviders,
+    );
+
+    const coverSlots: Partial<Record<CoverMedium, MetadataFetchCoverSlotDiagnostics>> = {};
+    const primary = this.resolveCoverSlotForMedium(preferences, scope, scope.primaryMedium, agreeing, existingFields, options, 1);
+    if (primary) this.applyCoverSlot(resolved, sources, scope.primaryMedium, primary, coverSlots);
+
+    const otherMedium: CoverMedium = scope.primaryMedium === 'ebook' ? 'audio' : 'ebook';
+    let pass2Candidates: MetadataCandidate[] = [];
+    let pass2Providers: MetadataProviderKey[] = [];
+    if (this.hasMedium(scope.media, otherMedium)) {
+      const other = await this.resolveOtherMediumSlot(
+        preferences,
+        scope,
+        otherMedium,
+        { params: providerSearchParams, existingProviderIdsOnly, activeProviders: providerSelection.activeProviders },
+        { anchor, agreeing },
+        existingFields,
+        options,
+      );
+      pass2Candidates = other.pass2Candidates;
+      pass2Providers = other.pass2Providers;
+      if (other.slot) this.applyCoverSlot(resolved, sources, otherMedium, other.slot, coverSlots);
     }
 
-    const agreeing = this.rejectDisagreeingCandidates(preferences, providerSelection.activeProviders, byProvider, params);
-    const { resolved, sources, providerIds } = this.applyPreferences(preferences, agreeing, existingFields, params.existingProviderIds, options);
-    const diagnostics = this.buildDiagnostics(providerSelection, [...agreeing.values()], resolved);
+    for (const medium of ['ebook', 'audio'] as const) {
+      if (this.coverSlotApplies(preferences, scope, medium) && !coverSlots[medium]) coverSlots[medium] = { provider: null, pass: null };
+    }
+
+    const diagnostics = this.buildDiagnostics(
+      {
+        ...providerSelection,
+        activeProviders: [...new Set([...providerSelection.activeProviders, ...pass2Providers])],
+      },
+      [...agreeing.values(), ...pass2Candidates],
+      resolved,
+      coverSlots,
+    );
     return { resolved, sources, providerIds, diagnostics };
   }
 
+  private async searchCandidates(params: MetadataSearchParams, providers: MetadataProviderKey[]): Promise<MetadataCandidate[]> {
+    if (providers.length === 0) return [];
+    return firstValueFrom(this.fetchService.searchCandidates(params, providers).pipe(toArray()), { defaultValue: [] as MetadataCandidate[] });
+  }
+
+  private firstPerProvider(candidates: readonly MetadataCandidate[]): CandidatesByProvider {
+    const byProvider: CandidatesByProvider = new Map();
+    for (const candidate of candidates) {
+      if (!byProvider.has(candidate.provider)) byProvider.set(candidate.provider, candidate);
+    }
+    return byProvider;
+  }
+
+  private fetchScope(params: MetadataSearchParams, options: MetadataFetchRunOptions | undefined): FetchScope {
+    const stated = options?.coverMedia;
+    const media = stated && (stated.hasEbook || stated.hasAudio) ? stated : { hasEbook: !params.isAudiobook, hasAudio: params.isAudiobook === true };
+    let primaryMedium: CoverMedium = params.isAudiobook ? 'audio' : 'ebook';
+    if (!this.hasMedium(media, primaryMedium)) primaryMedium = primaryMedium === 'ebook' ? 'audio' : 'ebook';
+    return { media, primaryMedium, lockedSlots: new Set(options?.lockedCoverSlots ?? []) };
+  }
+
+  private hasMedium(media: CoverMedia, medium: CoverMedium): boolean {
+    return medium === 'ebook' ? media.hasEbook : media.hasAudio;
+  }
+
+  /** A cover rule only applies to a book that has its medium. */
+  private fieldApplies(field: MetadataField, media: CoverMedia): boolean {
+    if (field === 'cover') return media.hasEbook;
+    if (field === 'audioCover') return media.hasAudio;
+    return true;
+  }
+
+  private coverSlotApplies(preferences: MetadataFetchPreferences, scope: FetchScope, medium: CoverMedium): boolean {
+    const field = COVER_FIELD_BY_MEDIUM[medium];
+    return this.hasMedium(scope.media, medium) && preferences.fields[field]?.enabled === true && !scope.lockedSlots.has(medium);
+  }
+
+  /**
+   * Providers that only a cover rule put in play. They help decide which book this is and supply
+   * that slot's art, but nothing else: an audiobook source brought in for its square art must not
+   * replace a book's chapters, ids or comic data.
+   */
+  private coverOnlyProviders(
+    preferences: MetadataFetchPreferences,
+    media: CoverMedia,
+    activeProviders: readonly MetadataProviderKey[],
+  ): Set<MetadataProviderKey> {
+    const fullRole = new Set<MetadataProviderKey>();
+    for (const [field, fieldPreference] of Object.entries(preferences.fields) as [MetadataField, FieldPreference][]) {
+      if (!fieldPreference.enabled || field === 'cover' || field === 'audioCover' || !this.fieldApplies(field, media)) continue;
+      for (const provider of fieldPreference.providers) fullRole.add(provider);
+    }
+    return new Set(activeProviders.filter((provider) => !fullRole.has(provider)));
+  }
+
+  private resolveCoverSlotForMedium(
+    preferences: MetadataFetchPreferences,
+    scope: FetchScope,
+    medium: CoverMedium,
+    candidates: CandidatesByProvider,
+    existingFields: ExistingMetadataFields,
+    options: MetadataFetchRunOptions | undefined,
+    pass: 1 | 2,
+  ): CoverSlotResolution | null {
+    if (!this.coverSlotApplies(preferences, scope, medium)) return null;
+    const field = COVER_FIELD_BY_MEDIUM[medium];
+    const fieldPreference = preferences.fields[field];
+    const mergeStrategy = options?.preserveExisting ? 'fillMissing' : fieldPreference.mergeStrategy;
+    const present = !this.isMissing(existingFields[field]);
+    if (mergeStrategy === 'fillMissing' && present) return null;
+    const choices = this.orderCoverChoices(medium, fieldPreference.providers, candidates, present);
+    return choices.length > 0 ? { choices, pass } : null;
+  }
+
+  /**
+   * The slot's covers in the rule's order, grouped by how well the provider's stated shape fits:
+   * matching art first, then art of unknown shape, and last, only while the slot is empty, art of
+   * the other shape. A wrong-shape image never replaces a cover the book already has.
+   */
+  private orderCoverChoices(
+    medium: CoverMedium,
+    providers: readonly MetadataProviderKey[],
+    candidates: CandidatesByProvider,
+    slotFilled: boolean,
+  ): ResolvedCoverChoice[] {
+    const byFit: Record<ResolvedCoverChoice['fit'], ResolvedCoverChoice[]> = { match: [], unknown: [], mismatch: [] };
+    const seenUrls = new Set<string>();
+    for (const provider of providers) {
+      const candidate = candidates.get(provider);
+      const url = candidate?.coverUrl?.trim();
+      if (!candidate || !url || seenUrls.has(url) || this.isStatedTooSmall(candidate)) continue;
+      seenUrls.add(url);
+      const shape = candidate.coverShape ?? 'unknown';
+      const fit: ResolvedCoverChoice['fit'] = shape === 'unknown' ? 'unknown' : shape === EXPECTED_SHAPE[medium] ? 'match' : 'mismatch';
+      byFit[fit].push({ url, provider, fit });
+    }
+    return [...byFit.match, ...byFit.unknown, ...(slotFilled ? [] : byFit.mismatch)].slice(0, MAX_COVER_CHOICES);
+  }
+
+  /** A provider that states its image's size lets a thumbnail be skipped without a download. */
+  private isStatedTooSmall(candidate: MetadataCandidate): boolean {
+    const { coverWidth, coverHeight } = candidate;
+    return typeof coverWidth === 'number' && typeof coverHeight === 'number' && Math.min(coverWidth, coverHeight) < MIN_COVER_SHORT_SIDE_PX;
+  }
+
+  private applyCoverSlot(
+    resolved: ResolvedMetadataFields,
+    sources: Record<string, string>,
+    medium: CoverMedium,
+    slot: CoverSlotResolution,
+    coverSlots: Partial<Record<CoverMedium, MetadataFetchCoverSlotDiagnostics>>,
+  ): void {
+    const [first] = slot.choices;
+    if (!first) return;
+    if (medium === 'ebook') {
+      resolved.coverUrl = first.url;
+      resolved.coverChoices = slot.choices;
+      sources.coverUrl = first.provider;
+    } else {
+      resolved.audioCoverUrl = first.url;
+      resolved.audioCoverChoices = slot.choices;
+      sources.audioCoverUrl = first.provider;
+    }
+    coverSlots[medium] = { provider: first.provider, pass: slot.pass };
+  }
+
+  /**
+   * The slot of the medium the book was not searched as. Providers that ignore the medium already
+   * answered in pass 1; iTunes and Hardcover hold a separate edition per medium, so pass 2 asks
+   * them again for this one. Pass 2 searches without the ISBN and the stored iTunes id and
+   * Hardcover edition, which all name the other edition, and saves no ids, since each id column is
+   * shared by both media.
+   */
+  private async resolveOtherMediumSlot(
+    preferences: MetadataFetchPreferences,
+    scope: FetchScope,
+    medium: CoverMedium,
+    pass1: { params: MetadataSearchParams; existingProviderIdsOnly: boolean; activeProviders: readonly MetadataProviderKey[] },
+    agreement: { anchor: MetadataCandidate | undefined; agreeing: CandidatesByProvider },
+    existingFields: ExistingMetadataFields,
+    options: MetadataFetchRunOptions | undefined,
+  ): Promise<{ slot: CoverSlotResolution | null; pass2Candidates: MetadataCandidate[]; pass2Providers: MetadataProviderKey[] }> {
+    const none = { slot: null, pass2Candidates: [], pass2Providers: [] };
+    if (!this.coverSlotApplies(preferences, scope, medium)) return none;
+    const field = COVER_FIELD_BY_MEDIUM[medium];
+    const mergeStrategy = options?.preserveExisting ? 'fillMissing' : preferences.fields[field].mergeStrategy;
+    if (mergeStrategy === 'fillMissing' && !this.isMissing(existingFields[field])) return none;
+
+    const carried: CandidatesByProvider = new Map(
+      [...agreement.agreeing].filter(([provider]) => !this.registry.editionFollowsMedium(provider as MetadataProviderKey)),
+    );
+    const pass2Providers = pass1.existingProviderIdsOnly
+      ? []
+      : preferences.fields[field].providers.filter(
+          (provider) => pass1.activeProviders.includes(provider) && this.registry.editionFollowsMedium(provider),
+        );
+    if (pass2Providers.length === 0) {
+      return {
+        slot: this.resolveCoverSlotForMedium(preferences, scope, medium, carried, existingFields, options, 1),
+        pass2Candidates: [],
+        pass2Providers,
+      };
+    }
+
+    const existingProviderIds = pass1.params.existingProviderIds ? { ...pass1.params.existingProviderIds } : undefined;
+    if (existingProviderIds) delete existingProviderIds[MetadataProviderKey.ITUNES];
+    const pass2Params: MetadataSearchParams = {
+      ...pass1.params,
+      isbn: undefined,
+      hardcoverEditionId: undefined,
+      existingProviderIds,
+      isAudiobook: medium === 'audio',
+      includeAudiobookProviders: false,
+    };
+    const found = this.firstPerProvider(await this.searchCandidates(pass2Params, pass2Providers));
+    const pass2Candidates = this.acceptPass2Candidates(agreement.anchor, [...found.values()], pass2Params);
+    for (const candidate of pass2Candidates) carried.set(candidate.provider, candidate);
+
+    const slot = this.resolveCoverSlotForMedium(preferences, scope, medium, carried, existingFields, options, 1);
+    if (slot && pass2Candidates.some((candidate) => candidate.provider === slot.choices[0]?.provider)) slot.pass = 2;
+    return { slot, pass2Candidates, pass2Providers };
+  }
+
+  private acceptPass2Candidates(
+    anchor: MetadataCandidate | undefined,
+    candidates: MetadataCandidate[],
+    params: MetadataSearchParams,
+  ): MetadataCandidate[] {
+    const { accepted, rejected } = anchor ? acceptAgainstAnchor(anchor, candidates) : resolveCandidateAgreement(candidates, params);
+    if (rejected.length > 0) {
+      this.logger.warn(
+        `[metadata_fetch.candidate_agreement] [end] pass=2 anchorProvider=${anchor?.provider ?? 'none'} acceptedCount=${accepted.length} rejectedProviders=${rejected.map((candidate) => candidate.provider).join('|')} anchorTitle="${sanitizeLogValue(anchor?.title ?? '')}" rejectedTitles="${sanitizeLogValue(rejected.map((candidate) => candidate.title ?? '').join('|'))}" - other-medium candidates describing a different book were dropped`,
+      );
+    }
+    return accepted;
+  }
+
   /**
    * Drops candidates that describe a different book from the anchor, before field rules get to
    * source individual fields from them. Without this, every provider that matched the wrong book
    * still contributes whichever fields it ranks first for, and the result is one record assembled
-   * out of several books.
+   * out of several books. Cover-only providers are held to the anchor but never pick it, unless no
+   * other provider found anything.
    */
   private rejectDisagreeingCandidates(
     preferences: MetadataFetchPreferences,
     activeProviders: readonly MetadataProviderKey[],
     byProvider: ReadonlyMap<string, MetadataCandidate>,
     params: MetadataSearchParams,
-  ): Map<string, MetadataCandidate> {
+    coverOnlyProviders: ReadonlySet<MetadataProviderKey>,
+  ): { anchor: MetadataCandidate | undefined; accepted: CandidatesByProvider } {
     const ordered = this.orderByIdentityTrust(preferences, activeProviders, byProvider);
-    const { anchor, accepted, rejected } = resolveCandidateAgreement(ordered, params);
+    const identifying = ordered.filter((candidate) => !coverOnlyProviders.has(candidate.provider));
+    const coverOnly = ordered.filter((candidate) => coverOnlyProviders.has(candidate.provider));
+    const agreement = resolveCandidateAgreement(identifying.length > 0 ? identifying : coverOnly, params);
+    const accepted = [...agreement.accepted];
+    const rejected = [...agreement.rejected];
+    if (identifying.length > 0 && coverOnly.length > 0) {
+      if (agreement.anchor) {
+        const checked = acceptAgainstAnchor(agreement.anchor, coverOnly);
+        accepted.push(...checked.accepted);
+        rejected.push(...checked.rejected);
+      } else {
+        accepted.push(...coverOnly);
+      }
+    }
 
     if (rejected.length > 0) {
       this.logger.warn(
-        `[metadata_fetch.candidate_agreement] [end] anchorProvider=${anchor?.provider ?? 'none'} acceptedCount=${accepted.length} rejectedProviders=${rejected.map((candidate) => candidate.provider).join('|')} anchorTitle="${sanitizeLogValue(anchor?.title ?? '')}" rejectedTitles="${sanitizeLogValue(rejected.map((candidate) => candidate.title ?? '').join('|'))}" - candidates describing a different book were dropped`,
+        `[metadata_fetch.candidate_agreement] [end] anchorProvider=${agreement.anchor?.provider ?? 'none'} acceptedCount=${accepted.length} rejectedProviders=${rejected.map((candidate) => candidate.provider).join('|')} anchorTitle="${sanitizeLogValue(agreement.anchor?.title ?? '')}" rejectedTitles="${sanitizeLogValue(rejected.map((candidate) => candidate.title ?? '').join('|'))}" - candidates describing a different book were dropped`,
       );
     }
 
-    return new Map(accepted.map((candidate) => [candidate.provider, candidate]));
+    return { anchor: agreement.anchor, accepted: new Map(accepted.map((candidate) => [candidate.provider, candidate])) };
   }
 
   /**
@@ -222,20 +524,27 @@ export class MetadataFetchPipeline {
     return { preferences, registeredKeys, providerConfig };
   }
 
+  /**
+   * Field-rule providers, narrowed to what can answer for the book's media when they are known: an
+   * audiobook source is neither queried for nor reported missing from a book without audio, and a
+   * cover rule for a medium the book lacks contributes nothing.
+   */
   private deriveConfiguredProviderSelection(
     preferences: MetadataFetchPreferences,
     registeredKeys: MetadataProviderKey[],
     providerConfig: ProviderConfigurations,
+    media?: CoverMedia,
   ): ConfiguredProviderSelection {
-    const registered = new Set(registeredKeys);
+    const eligible = new Set(media ? this.registry.keysForMedia(registeredKeys, media) : registeredKeys);
     const fieldRuleProviders = new Set<MetadataProviderKey>();
     const configuredFieldRuleProviders = new Set<MetadataProviderKey>();
     const disabledFieldRuleProviders = new Set<MetadataProviderKey>();
 
-    for (const [, fieldPreference] of Object.entries(preferences.fields) as [MetadataField, FieldPreference][]) {
+    for (const [field, fieldPreference] of Object.entries(preferences.fields) as [MetadataField, FieldPreference][]) {
       if (!fieldPreference.enabled) continue;
+      if (media && !this.fieldApplies(field, media)) continue;
       for (const providerKey of fieldPreference.providers) {
-        if (!registered.has(providerKey)) continue;
+        if (!eligible.has(providerKey)) continue;
         fieldRuleProviders.add(providerKey);
         if (providerConfig[providerKey]?.enabled === false) {
           disabledFieldRuleProviders.add(providerKey);
@@ -245,7 +554,7 @@ export class MetadataFetchPipeline {
       }
     }
 
-    const enabledUnreferencedProviders = registeredKeys.filter(
+    const enabledUnreferencedProviders = [...eligible].filter(
       (providerKey) => providerConfig[providerKey]?.enabled !== false && !fieldRuleProviders.has(providerKey),
     );
 
@@ -261,9 +570,10 @@ export class MetadataFetchPipeline {
     preferences: MetadataFetchPreferences,
     registeredKeys: MetadataProviderKey[],
     providerConfig: ProviderConfigurations,
+    media: CoverMedia,
     requiredProviderIds?: Partial<Record<MetadataProviderKey, string>>,
   ): ProviderSelectionDiagnostics {
-    const configuredProviderSelection = this.deriveConfiguredProviderSelection(preferences, registeredKeys, providerConfig);
+    const configuredProviderSelection = this.deriveConfiguredProviderSelection(preferences, registeredKeys, providerConfig, media);
 
     const activeProviders: MetadataProviderKey[] = [];
     const throttledProviders: MetadataProviderKey[] = [];
@@ -302,9 +612,10 @@ export class MetadataFetchPipeline {
     providerSelection: ProviderSelectionDiagnostics,
     candidates: MetadataCandidate[],
     resolved: ResolvedMetadataFields,
+    coverSlots: Partial<Record<CoverMedium, MetadataFetchCoverSlotDiagnostics>>,
   ): MetadataFetchDiagnostics {
     const candidateProviders = [...new Set(candidates.map((candidate) => candidate.provider))];
-    const resolvedFieldCount = Object.keys(resolved).length;
+    const resolvedFieldCount = Object.keys(resolved).filter((key) => key !== 'coverChoices' && key !== 'audioCoverChoices').length;
     const { missingExistingProviderIdCount, ...diagnosticProviderSelection } = providerSelection;
 
     let reason: MetadataFetchDiagnostics['reason'] = null;
@@ -326,6 +637,7 @@ export class MetadataFetchPipeline {
       candidateCount: candidates.length,
       resolvedFieldCount,
       reason,
+      coverSlots,
     };
   }
 
@@ -335,15 +647,19 @@ export class MetadataFetchPipeline {
     existing: ExistingMetadataFields,
     existingProviderIds: Partial<Record<MetadataProviderKey, string>> | undefined,
     options: MetadataFetchRunOptions | undefined,
+    coverOnlyProviders: ReadonlySet<MetadataProviderKey>,
   ): { resolved: ResolvedMetadataFields; sources: Record<string, string>; providerIds: ResolvedProviderIds } {
     const result: ResolvedMetadataFields = {};
     const sources: Record<string, string> = {};
     const genreOptions = preferences.options?.genres;
     const blockedGenreTokens = createGenreBlocklistTokenSet(genreOptions?.blocklist);
+    const identifying = new Map([...byProvider].filter(([provider]) => !coverOnlyProviders.has(provider as MetadataProviderKey)));
 
     for (const field of Object.keys(preferences.fields) as MetadataField[]) {
       const fieldPreference = preferences.fields[field];
       if (!fieldPreference.enabled) continue;
+      // Each cover slot resolves separately, with its own shape preference and fallbacks.
+      if (field === 'cover' || field === 'audioCover') continue;
       const mergeStrategy = options?.preserveExisting ? 'fillMissing' : fieldPreference.mergeStrategy;
 
       if (field === 'genres' && preferences.options?.genres.mode === 'merge') {
@@ -383,14 +699,6 @@ export class MetadataFetchPipeline {
         if (value === undefined || value === null) continue;
         if (mergeStrategy !== 'overwrite' && this.isEmptyProviderValue(value)) continue;
 
-        if (field === 'cover') {
-          const existingValue = existing[field];
-          if (mergeStrategy === 'fillMissing' && !this.isMissing(existingValue)) break;
-          result.coverUrl = candidate.coverUrl;
-          sources['coverUrl'] = providerKey;
-          break;
-        }
-
         if (field === 'genres') {
           if (!Array.isArray(value)) continue;
           const genres = applyGenreFetchOptions(value, blockedGenreTokens, genreOptions?.maxCount);
@@ -431,6 +739,7 @@ export class MetadataFetchPipeline {
     const providerIds: ResolvedProviderIds = {};
     if (preferences.options?.saveProviderIds) {
       for (const candidate of byProvider.values()) {
+        if (coverOnlyProviders.has(candidate.provider) && !COVER_ONLY_SAVED_ID_PROVIDERS.has(candidate.provider)) continue;
         const providerIdKey = candidate.provider === MetadataProviderKey.AUDNEXUS ? MetadataProviderKey.AUDIBLE : candidate.provider;
         const providerId = candidate.provider === MetadataProviderKey.AUDNEXUS ? (candidate.audibleId ?? candidate.providerId) : candidate.providerId;
         if (providerId && (!options?.preserveExisting || !existingProviderIds?.[providerIdKey])) {
@@ -449,16 +758,16 @@ export class MetadataFetchPipeline {
     // Pass through chapters from the first candidate that has them, using the
     // narrators field's provider preference order as the authority for audiobook data.
     const narratorProviders = preferences.fields['narrators']?.providers ?? [];
-    const chapterProviders = [...narratorProviders, ...byProvider.keys()];
+    const chapterProviders = [...narratorProviders, ...identifying.keys()];
     for (const providerKey of chapterProviders) {
-      const candidate = byProvider.get(providerKey);
+      const candidate = identifying.get(providerKey);
       if (candidate?.chapters?.length && (!options?.preserveExisting || this.isMissing(existing.chapters))) {
         result.chapters = candidate.chapters;
         break;
       }
     }
 
-    const comicMetadata = this.resolveComicMetadata(preferences, byProvider);
+    const comicMetadata = this.resolveComicMetadata(preferences, identifying);
     const filteredComicMetadata = options?.preserveExisting ? this.filterExistingComicMetadata(comicMetadata, existing.comicMetadata) : comicMetadata;
     if (filteredComicMetadata) result.comicMetadata = filteredComicMetadata;
 
@@ -478,7 +787,6 @@ export class MetadataFetchPipeline {
       seriesName: 'seriesName',
       seriesIndex: 'seriesIndex',
       genres: 'genres',
-      cover: 'coverUrl',
       narrators: 'narrators',
       duration: 'durationSeconds',
       abridged: 'abridged',
diff --git a/server/src/modules/metadata-fetch/metadata-fetch.controller.test.ts b/server/src/modules/metadata-fetch/metadata-fetch.controller.test.ts
index 9ac190909..0523ae83e 100644
--- a/server/src/modules/metadata-fetch/metadata-fetch.controller.test.ts
+++ b/server/src/modules/metadata-fetch/metadata-fetch.controller.test.ts
@@ -20,6 +20,8 @@ import { MetadataPreferencesService } from '../metadata-preferences/metadata-pre
 import { MetadataPreferenceResolver } from '../metadata-preferences/metadata-preference-resolver';
 import { ProviderThrottleTracker } from './provider-throttle.tracker';
 
+const AUDIOBOOK_ONLY = new Set<MetadataProviderKey>([MetadataProviderKey.AUDIBLE, MetadataProviderKey.AUDNEXUS, MetadataProviderKey.LIBROFM]);
+
 function candidateEvent(candidate: MetadataCandidate): MetadataSearchEvent {
   return { kind: 'candidate', candidate };
 }
@@ -48,7 +50,6 @@ describe('MetadataFetchController', () => {
       search: vi.fn(),
       getStoredProviderIds: vi.fn(),
       getStoredProviderContext: vi.fn(),
-      getAccessibleBookLibraryId: vi.fn(),
       lookupById: vi.fn(),
     } as unknown as Mocked<MetadataFetchService>;
 
@@ -59,6 +60,7 @@ describe('MetadataFetchController', () => {
     registry = {
       all: vi.fn(),
       keysForMediaKind: vi.fn(),
+      servesOnlyAudiobooks: vi.fn((key: MetadataProviderKey) => AUDIOBOOK_ONLY.has(key)),
     } as unknown as Mocked<ProviderRegistry>;
 
     providerConfig = {
@@ -102,13 +104,21 @@ describe('MetadataFetchController', () => {
     ] as never);
 
     await expect(controller.listProviders({}, user)).resolves.toEqual([
-      { key: MetadataProviderKey.GOOGLE, label: 'Google Books', identifiable: true, coverPriority: 4 },
-      { key: MetadataProviderKey.OPEN_LIBRARY, label: 'OpenLibrary', identifiable: false, coverPriority: 5 },
+      { key: MetadataProviderKey.GOOGLE, label: 'Google Books', identifiable: true, coverPriority: 4, audioCoverPriority: 6 },
+      { key: MetadataProviderKey.OPEN_LIBRARY, label: 'OpenLibrary', identifiable: false, coverPriority: 5, audioCoverPriority: 7 },
     ]);
   });
 
   it('returns provider metadata scoped to the current book library when bookId is provided', async () => {
-    service.getAccessibleBookLibraryId.mockResolvedValue(9);
+    const coverMedia = { hasEbook: true, hasAudio: false };
+    service.getStoredProviderContext.mockResolvedValue({
+      libraryId: 9,
+      title: null,
+      seriesName: null,
+      seriesIndex: null,
+      providerIds: {},
+      coverMedia,
+    });
     pipeline.getEffectiveProviderKeys.mockResolvedValue([MetadataProviderKey.KOBO, MetadataProviderKey.GOOGLE]);
     registry.all.mockReturnValue([
       { key: MetadataProviderKey.GOOGLE, label: 'Google Books', identifiable: true },
@@ -118,20 +128,35 @@ describe('MetadataFetchController', () => {
 
     const result = await controller.listProviders({ bookId: 12 }, user);
 
-    expect(service.getAccessibleBookLibraryId).toHaveBeenCalledWith(12, user);
-    expect(pipeline.getEffectiveProviderKeys).toHaveBeenCalledWith(9);
+    expect(service.getStoredProviderContext).toHaveBeenCalledWith(12, user);
+    expect(pipeline.getEffectiveProviderKeys).toHaveBeenCalledWith(9, coverMedia);
     expect(metadataPreferences.getForLibrary).toHaveBeenCalledWith(9);
     expect(result).toEqual([
-      { key: MetadataProviderKey.GOOGLE, label: 'Google Books', identifiable: true, selectedByFieldRules: true, coverPriority: 4 },
-      { key: MetadataProviderKey.OPEN_LIBRARY, label: 'OpenLibrary', identifiable: false, selectedByFieldRules: false, coverPriority: 5 },
-      { key: MetadataProviderKey.KOBO, label: 'Kobo', identifiable: true, selectedByFieldRules: true, coverPriority: 2 },
+      {
+        key: MetadataProviderKey.GOOGLE,
+        label: 'Google Books',
+        identifiable: true,
+        selectedByFieldRules: true,
+        coverPriority: 4,
+        audioCoverPriority: 6,
+      },
+      {
+        key: MetadataProviderKey.OPEN_LIBRARY,
+        label: 'OpenLibrary',
+        identifiable: false,
+        selectedByFieldRules: false,
+        coverPriority: 5,
+        audioCoverPriority: 7,
+      },
+      { key: MetadataProviderKey.KOBO, label: 'Kobo', identifiable: true, selectedByFieldRules: true, coverPriority: 2, audioCoverPriority: 4 },
     ]);
   });
 
-  it('exposes the configured Cover field order independently of registry order', async () => {
+  it('exposes the configured Cover and Audiobook cover orders independently of registry order', async () => {
     const resolver = new MetadataPreferenceResolver();
     const preferences = resolver.getDefaultPreferences();
     preferences.fields.cover.providers = [MetadataProviderKey.OPEN_LIBRARY, MetadataProviderKey.GOOGLE];
+    preferences.fields.audioCover.providers = [MetadataProviderKey.GOOGLE];
     metadataPreferences.getGlobal.mockResolvedValue(preferences);
     registry.all.mockReturnValue([
       { key: MetadataProviderKey.GOOGLE, label: 'Google Books', identifiable: true },
@@ -141,7 +166,7 @@ describe('MetadataFetchController', () => {
     const result = await controller.listProviders({}, user);
 
     expect(result).toEqual([
-      { key: MetadataProviderKey.GOOGLE, label: 'Google Books', identifiable: true, coverPriority: 1 },
+      { key: MetadataProviderKey.GOOGLE, label: 'Google Books', identifiable: true, coverPriority: 1, audioCoverPriority: 0 },
       { key: MetadataProviderKey.OPEN_LIBRARY, label: 'OpenLibrary', identifiable: false, coverPriority: 0 },
     ]);
   });
diff --git a/server/src/modules/metadata-fetch/metadata-fetch.controller.ts b/server/src/modules/metadata-fetch/metadata-fetch.controller.ts
index 098de0a9a..91d8259e7 100644
--- a/server/src/modules/metadata-fetch/metadata-fetch.controller.ts
+++ b/server/src/modules/metadata-fetch/metadata-fetch.controller.ts
@@ -1,5 +1,6 @@
 import { Controller, Get, MessageEvent, Query, Sse } from '@nestjs/common';
 import {
+  CoverMedia,
   METADATA_PROVIDER_STATUS_EVENT,
   MetadataCandidate,
   MetadataProviderInfo,
@@ -40,10 +41,6 @@ function isExplicitQuery(searchTitle: string | undefined, storedTitle: string |
   return searchTitle.trim().toLowerCase() !== (stored ?? '').trim().toLowerCase();
 }
 
-function isAudiobookProvider(providerKey: MetadataProviderKey): boolean {
-  return providerKey === MetadataProviderKey.AUDIBLE || providerKey === MetadataProviderKey.AUDNEXUS || providerKey === MetadataProviderKey.LIBROFM;
-}
-
 @Controller('metadata-fetch')
 export class MetadataFetchController {
   constructor(
@@ -58,17 +55,18 @@ export class MetadataFetchController {
   @Get('providers')
   async listProviders(@Query() dto: ListMetadataProvidersDto, @CurrentUser() user: RequestUser): Promise<MetadataProviderInfo[]> {
     if (dto.bookId) {
-      const libraryId = await this.metadataFetchService.getAccessibleBookLibraryId(dto.bookId, user);
+      const { libraryId, coverMedia } = await this.metadataFetchService.getStoredProviderContext(dto.bookId, user);
       const [enabledProviderKeys, fieldRuleProviderKeys, libraryPreferences] = await Promise.all([
         this.resolveEnabledProviderKeys(),
-        this.resolveFieldRuleProviderKeys(undefined, libraryId),
+        this.resolveFieldRuleProviderKeys(undefined, libraryId, coverMedia),
         this.metadataPreferences.getForLibrary(libraryId),
       ]);
-      return this.providerInfosForKeys(enabledProviderKeys, new Set(fieldRuleProviderKeys), libraryPreferences.effective.fields.cover.providers);
+      const { fields } = libraryPreferences.effective;
+      return this.providerInfosForKeys(enabledProviderKeys, new Set(fieldRuleProviderKeys), fields.cover.providers, fields.audioCover.providers);
     }
 
     const [providerKeys, preferences] = await Promise.all([this.resolveEnabledProviderKeys(), this.metadataPreferences.getGlobal()]);
-    return this.providerInfosForKeys(providerKeys, undefined, preferences.fields.cover.providers);
+    return this.providerInfosForKeys(providerKeys, undefined, preferences.fields.cover.providers, preferences.fields.audioCover.providers);
   }
 
   @Get('providers/runtime')
@@ -87,13 +85,14 @@ export class MetadataFetchController {
     const existingProviderIds = storedContext?.providerIds ?? {};
     const [preferences, enabledProviderKeys] = await Promise.all([
       this.metadataPreferences.getGlobal(),
-      this.resolveSearchProviderKeys(dto.providers, storedContext?.libraryId),
+      this.resolveSearchProviderKeys(dto.providers, storedContext?.libraryId, storedContext?.coverMedia),
     ]);
     // A stated medium describes the book, so it settles which providers can answer at all. It
     // narrows the caller's provider list rather than widening it, and never adds a disabled one.
     const providerKeys = dto.mediaKind ? this.registry.keysForMediaKind(enabledProviderKeys, dto.mediaKind) : enabledProviderKeys;
-    const requestedAudiobookProvider = (dto.providers ?? []).some(isAudiobookProvider);
-    const onlyAudiobookProviders = providerKeys.length > 0 && providerKeys.every(isAudiobookProvider);
+    const servesOnlyAudiobooks = (providerKey: MetadataProviderKey) => this.registry.servesOnlyAudiobooks(providerKey);
+    const requestedAudiobookProvider = (dto.providers ?? []).some(servesOnlyAudiobooks);
+    const onlyAudiobookProviders = providerKeys.length > 0 && providerKeys.every(servesOnlyAudiobooks);
     const inferredIsAudiobook =
       requestedAudiobookProvider ||
       onlyAudiobookProviders ||
@@ -110,7 +109,7 @@ export class MetadataFetchController {
       titleIsExplicitQuery: isExplicitQuery(searchTitle, storedContext?.title),
       existingProviderIds,
       isAudiobook,
-      includeAudiobookProviders: isAudiobook || providerKeys.some(isAudiobookProvider),
+      includeAudiobookProviders: isAudiobook || providerKeys.some(servesOnlyAudiobooks),
       validateCoverPlaceholders: true,
     };
 
@@ -156,39 +155,48 @@ export class MetadataFetchController {
   private async resolveFieldRuleProviderKeys(
     requestedProviders: MetadataProviderKey[] | undefined,
     libraryId: number,
+    coverMedia?: CoverMedia,
   ): Promise<MetadataProviderKey[]> {
-    const effectiveProviderKeys = await this.pipeline.getEffectiveProviderKeys(libraryId);
+    const effectiveProviderKeys = await this.pipeline.getEffectiveProviderKeys(libraryId, coverMedia);
     if (requestedProviders === undefined) return effectiveProviderKeys;
     const requested = new Set(requestedProviders);
     return effectiveProviderKeys.filter((providerKey) => requested.has(providerKey));
   }
 
-  private async resolveSearchProviderKeys(requestedProviders: MetadataProviderKey[] | undefined, libraryId?: number): Promise<MetadataProviderKey[]> {
+  private async resolveSearchProviderKeys(
+    requestedProviders: MetadataProviderKey[] | undefined,
+    libraryId?: number,
+    coverMedia?: CoverMedia,
+  ): Promise<MetadataProviderKey[]> {
     if (requestedProviders !== undefined || libraryId === undefined) {
       return this.resolveEnabledProviderKeys(requestedProviders);
     }
 
-    return this.resolveFieldRuleProviderKeys(undefined, libraryId);
+    return this.resolveFieldRuleProviderKeys(undefined, libraryId, coverMedia);
   }
 
   private providerInfosForKeys(
     providerKeys: MetadataProviderKey[],
-    fieldRuleProviderKeys?: Set<MetadataProviderKey>,
-    coverProviderKeys: MetadataProviderKey[] = [],
+    fieldRuleProviderKeys: Set<MetadataProviderKey> | undefined,
+    coverProviderKeys: MetadataProviderKey[],
+    audioCoverProviderKeys: MetadataProviderKey[],
   ): MetadataProviderInfo[] {
     const keySet = new Set(providerKeys);
     const coverPriorities = new Map(coverProviderKeys.map((key, index) => [key, index]));
+    const audioCoverPriorities = new Map(audioCoverProviderKeys.map((key, index) => [key, index]));
     return this.registry
       .all()
       .filter((p) => keySet.has(p.key))
       .map((p) => {
         const coverPriority = coverPriorities.get(p.key);
+        const audioCoverPriority = audioCoverPriorities.get(p.key);
         return {
           key: p.key,
           label: p.label,
           identifiable: p.identifiable,
           ...(fieldRuleProviderKeys ? { selectedByFieldRules: fieldRuleProviderKeys.has(p.key) } : {}),
           ...(coverPriority !== undefined ? { coverPriority } : {}),
+          ...(audioCoverPriority !== undefined ? { audioCoverPriority } : {}),
         };
       });
   }
diff --git a/server/src/modules/metadata-fetch/metadata-fetch.repository.test.ts b/server/src/modules/metadata-fetch/metadata-fetch.repository.test.ts
index 3d4a732ce..59d5c71f1 100644
--- a/server/src/modules/metadata-fetch/metadata-fetch.repository.test.ts
+++ b/server/src/modules/metadata-fetch/metadata-fetch.repository.test.ts
@@ -31,7 +31,7 @@ function makeRepository() {
 describe('MetadataFetchRepository', () => {
   it('returns provider-id row for a known book', async () => {
     const { repo, limit } = makeRepository();
-    const row: StoredProviderIdsRow = {
+    const row = {
       libraryId: 5,
       googleBooksId: 'google-1',
       goodreadsId: 'goodreads-1',
@@ -42,9 +42,12 @@ describe('MetadataFetchRepository', () => {
       audibleId: 'audible-1',
       comicvineId: 'comicvine-1',
     };
-    limit.mockResolvedValue([row]);
+    limit.mockResolvedValue([{ ...row, hasEbook: true, hasAudio: false }]);
 
-    await expect(repo.findStoredProviderIdsRow(99)).resolves.toEqual(row);
+    await expect(repo.findStoredProviderIdsRow(99)).resolves.toEqual({
+      ...row,
+      coverMedia: { hasEbook: true, hasAudio: false },
+    } satisfies Partial<StoredProviderIdsRow>);
   });
 
   it('returns null when provider-id row is missing for a book', async () => {
diff --git a/server/src/modules/metadata-fetch/metadata-fetch.repository.ts b/server/src/modules/metadata-fetch/metadata-fetch.repository.ts
index 78215d5a5..fbd75b181 100644
--- a/server/src/modules/metadata-fetch/metadata-fetch.repository.ts
+++ b/server/src/modules/metadata-fetch/metadata-fetch.repository.ts
@@ -2,9 +2,12 @@ import { Inject, Injectable } from '@nestjs/common';
 import { and, eq } from 'drizzle-orm';
 import { NodePgDatabase } from 'drizzle-orm/node-postgres';
 
+import type { CoverMedia } from '@bookorbit/types';
+
 import { DB } from '../../db';
 import * as schema from '../../db/schema';
 import { bookMetadata, books, userLibraryAccess } from '../../db/schema';
+import { coverMediaSql } from '../book-cover-store/book-cover-store.repository';
 
 type Db = NodePgDatabase<typeof schema>;
 
@@ -26,6 +29,7 @@ export interface StoredProviderIdsRow {
   ranobedbId: string | null;
   lubimyczytacId: string | null;
   aladinId: string | null;
+  coverMedia: CoverMedia;
 }
 
 @Injectable()
@@ -33,6 +37,7 @@ export class MetadataFetchRepository {
   constructor(@Inject(DB) private readonly db: Db) {}
 
   async findStoredProviderIdsRow(bookId: number): Promise<StoredProviderIdsRow | null> {
+    const media = coverMediaSql(books.id);
     const [row] = await this.db
       .select({
         libraryId: books.libraryId,
@@ -52,13 +57,17 @@ export class MetadataFetchRepository {
         ranobedbId: bookMetadata.ranobedbId,
         lubimyczytacId: bookMetadata.lubimyczytacId,
         aladinId: bookMetadata.aladinId,
+        hasEbook: media.hasEbook,
+        hasAudio: media.hasAudio,
       })
       .from(books)
       .leftJoin(bookMetadata, eq(bookMetadata.bookId, books.id))
       .where(eq(books.id, bookId))
       .limit(1);
 
-    return row ?? null;
+    if (!row) return null;
+    const { hasEbook, hasAudio, ...stored } = row;
+    return { ...stored, coverMedia: { hasEbook: hasEbook === true, hasAudio: hasAudio === true } };
   }
 
   async hasLibraryAccess(userId: number, libraryId: number): Promise<boolean> {
diff --git a/server/src/modules/metadata-fetch/metadata-fetch.service.test.ts b/server/src/modules/metadata-fetch/metadata-fetch.service.test.ts
index f56d2daf0..8484855e7 100644
--- a/server/src/modules/metadata-fetch/metadata-fetch.service.test.ts
+++ b/server/src/modules/metadata-fetch/metadata-fetch.service.test.ts
@@ -127,6 +127,35 @@ describe('MetadataFetchService', () => {
     expect(openLibrary.search).toHaveBeenCalledWith(expect.objectContaining({ title: 'Dune' }));
   });
 
+  it('states every cover shape, from the provider when the candidate does not say', async () => {
+    const withCover = (id: string, data: Partial<MetadataCandidate> = {}) => ({
+      ...candidate(MetadataProviderKey.GOOGLE, id, 'Dune'),
+      coverUrl: `https://img/${id}.jpg`,
+      ...data,
+    });
+    const fixed: MetadataProvider = {
+      key: MetadataProviderKey.GOOGLE,
+      label: 'Google',
+      identifiable: false,
+      coverShape: 'portrait',
+      search: vi
+        .fn()
+        .mockResolvedValue([withCover('a'), withCover('b', { coverShape: 'square' }), candidate(MetadataProviderKey.GOOGLE, 'c', 'Dune')]),
+    };
+    const unknown: MetadataProvider = {
+      key: MetadataProviderKey.OPEN_LIBRARY,
+      label: 'OpenLibrary',
+      identifiable: false,
+      search: vi.fn().mockResolvedValue([{ ...withCover('d'), provider: MetadataProviderKey.OPEN_LIBRARY }]),
+    };
+    registry.select.mockReturnValue([fixed, unknown]);
+
+    const results = await firstValueFrom(service.search({ title: 'Dune' }).pipe(candidatesOnly(), toArray()));
+    const shapes = Object.fromEntries(results.map((result) => [result.providerId, result.coverShape]));
+
+    expect(shapes).toEqual({ a: 'portrait', b: 'square', c: undefined, d: 'unknown' });
+  });
+
   it('starts selected providers concurrently within one search', async () => {
     let active = 0;
     let maxActive = 0;
diff --git a/server/src/modules/metadata-fetch/metadata-fetch.service.ts b/server/src/modules/metadata-fetch/metadata-fetch.service.ts
index 986fdfb66..fb335157e 100644
--- a/server/src/modules/metadata-fetch/metadata-fetch.service.ts
+++ b/server/src/modules/metadata-fetch/metadata-fetch.service.ts
@@ -1,5 +1,5 @@
 import { ForbiddenException, Injectable, Logger, NotFoundException } from '@nestjs/common';
-import { MetadataCandidate, MetadataProviderKey, MetadataProviderSearchOutcome, MetadataProviderSearchStatus } from '@bookorbit/types';
+import { CoverMedia, MetadataCandidate, MetadataProviderKey, MetadataProviderSearchOutcome, MetadataProviderSearchStatus } from '@bookorbit/types';
 import { filter, from, map, merge, Observable, switchMap } from 'rxjs';
 
 import type { RequestUser } from '../../common/types/request-user';
@@ -37,6 +37,7 @@ export interface StoredProviderContext {
   seriesName: string | null;
   seriesIndex: string | null;
   providerIds: Partial<Record<MetadataProviderKey, string>>;
+  coverMedia: CoverMedia;
 }
 
 @Injectable()
@@ -70,7 +71,8 @@ export class MetadataFetchService {
   async lookupById(key: MetadataProviderKey, providerId: string): Promise<MetadataCandidate | null> {
     const provider = this.registry.find(key);
     if (!provider || !isIdentifiable(provider)) return null;
-    return provider.lookupById(providerId);
+    const candidate = await provider.lookupById(providerId);
+    return candidate ? withCoverShape(provider, candidate) : null;
   }
 
   async getStoredProviderIds(bookId: number, user: RequestUser): Promise<Partial<Record<MetadataProviderKey, string>>> {
@@ -86,14 +88,10 @@ export class MetadataFetchService {
       seriesName: row.seriesName,
       seriesIndex: row.seriesIndex,
       providerIds: this.mapStoredProviderIds(row),
+      coverMedia: row.coverMedia,
     };
   }
 
-  async getAccessibleBookLibraryId(bookId: number, user: RequestUser): Promise<number> {
-    const row = await this.getAccessibleStoredProviderIdsRow(bookId, user);
-    return row.libraryId;
-  }
-
   private async getAccessibleStoredProviderIdsRow(bookId: number, user: RequestUser): Promise<StoredProviderIdsRow> {
     const row = await this.metadataFetchRepository.findStoredProviderIdsRow(bookId);
     if (!row) {
@@ -146,14 +144,14 @@ export class MetadataFetchService {
       this.logger.log(
         `[metadata_fetch.provider_search] [end] provider=${provider.key} durationMs=${Date.now() - startedAt} resultCount=${results.length} - provider fetch completed`,
       );
-      return { candidates: results, outcome: null };
+      return { candidates: results.map((candidate) => withCoverShape(provider, candidate)), outcome: null };
     } catch (error) {
       if (error instanceof ProviderThrottleError) {
         this.throttleTracker.record(provider.key, error.retryAfterSeconds);
         // A provider throttled part-way through hands back what it had already assembled. The
         // cooldown covers the requests it can no longer make; it is not a reason to drop finished
         // candidates, and the status event still tells the client the provider was cut short.
-        const salvaged = filterAndRank([...error.partialCandidates], params);
+        const salvaged = filterAndRank([...error.partialCandidates], params).map((candidate) => withCoverShape(provider, candidate));
         this.logger.warn(
           `[metadata_fetch.provider_search] [fail] provider=${provider.key} durationMs=${Date.now() - startedAt} resultCount=${salvaged.length} errorClass=ProviderThrottleError error="provider throttled" - provider fetch failed`,
         );
@@ -239,6 +237,12 @@ export class MetadataFetchService {
   }
 }
 
+/** Every candidate with a cover states its shape, so neither the pipeline nor a client has to guess. */
+function withCoverShape(provider: MetadataProvider, candidate: MetadataCandidate): MetadataCandidate {
+  if (!candidate.coverUrl || candidate.coverShape) return candidate;
+  return { ...candidate, coverShape: provider.coverShape ?? 'unknown' };
+}
+
 function toSearchEvents(provider: MetadataProviderKey, result: ProviderSearchResult): MetadataSearchEvent[] {
   const events: MetadataSearchEvent[] = result.candidates.map((candidate) => ({ kind: 'candidate', candidate }));
   if (result.outcome) events.push({ kind: 'status', status: { provider, outcome: result.outcome } });
diff --git a/server/src/modules/metadata-fetch/provider-registry.test.ts b/server/src/modules/metadata-fetch/provider-registry.test.ts
index debb79ca5..8abeee809 100644
--- a/server/src/modules/metadata-fetch/provider-registry.test.ts
+++ b/server/src/modules/metadata-fetch/provider-registry.test.ts
@@ -89,4 +89,31 @@ describe('ProviderRegistry', () => {
     expect(registry.find(MetadataProviderKey.GOOGLE)).toBe(google);
     expect(registry.find(MetadataProviderKey.AMAZON)).toBeUndefined();
   });
+
+  it('keeps comic specialists wherever there is an ebook, and audiobook specialists only with audio', () => {
+    const registry = new ProviderRegistry([
+      createProvider(MetadataProviderKey.GOOGLE),
+      createProvider(MetadataProviderKey.COMICVINE, 'ComicVine', ['comic']),
+      createProvider(MetadataProviderKey.AUDIBLE, 'Audible', ['audiobook']),
+    ]);
+    const keys = [MetadataProviderKey.GOOGLE, MetadataProviderKey.COMICVINE, MetadataProviderKey.AUDIBLE];
+
+    expect(registry.keysForMedia(keys, { hasEbook: true, hasAudio: false })).toEqual([MetadataProviderKey.GOOGLE, MetadataProviderKey.COMICVINE]);
+    expect(registry.keysForMedia(keys, { hasEbook: false, hasAudio: true })).toEqual([MetadataProviderKey.GOOGLE, MetadataProviderKey.AUDIBLE]);
+    expect(registry.keysForMedia(keys, { hasEbook: true, hasAudio: true })).toEqual(keys);
+  });
+
+  it('knows which providers serve only audiobooks and which answer per medium', () => {
+    const itunes = { ...createProvider(MetadataProviderKey.ITUNES), editionFollowsMedium: true };
+    const registry = new ProviderRegistry([
+      createProvider(MetadataProviderKey.GOOGLE),
+      createProvider(MetadataProviderKey.AUDIBLE, 'Audible', ['audiobook']),
+      itunes,
+    ]);
+
+    expect(registry.servesOnlyAudiobooks(MetadataProviderKey.AUDIBLE)).toBe(true);
+    expect(registry.servesOnlyAudiobooks(MetadataProviderKey.GOOGLE)).toBe(false);
+    expect(registry.editionFollowsMedium(MetadataProviderKey.ITUNES)).toBe(true);
+    expect(registry.editionFollowsMedium(MetadataProviderKey.GOOGLE)).toBe(false);
+  });
 });
diff --git a/server/src/modules/metadata-fetch/provider-registry.ts b/server/src/modules/metadata-fetch/provider-registry.ts
index 18398ebfc..36eff1c04 100644
--- a/server/src/modules/metadata-fetch/provider-registry.ts
+++ b/server/src/modules/metadata-fetch/provider-registry.ts
@@ -1,5 +1,5 @@
 import { BadRequestException, Inject, Injectable } from '@nestjs/common';
-import { ConcreteBookMediaKind, MetadataProviderKey } from '@bookorbit/types';
+import { ConcreteBookMediaKind, CoverMedia, MetadataProviderKey } from '@bookorbit/types';
 
 import { METADATA_PROVIDERS } from './constants';
 import { MetadataProvider } from './providers/metadata-provider';
@@ -39,4 +39,29 @@ export class ProviderRegistry {
       return !mediaKinds || mediaKinds.includes(mediaKind);
     });
   }
+
+  /**
+   * Narrows keys to the providers that can answer for a book with these media. Cover media fold
+   * comics into ebooks, and a comic can sit in any ebook container, so comic specialists stay
+   * eligible wherever there is an ebook.
+   */
+  keysForMedia(keys: MetadataProviderKey[], media: CoverMedia): MetadataProviderKey[] {
+    const kinds: ConcreteBookMediaKind[] = [];
+    if (media.hasEbook) kinds.push('ebook', 'comic');
+    if (media.hasAudio) kinds.push('audiobook');
+    return keys.filter((key) => {
+      const mediaKinds = this.find(key)?.mediaKinds;
+      return !mediaKinds || mediaKinds.some((kind) => kinds.includes(kind));
+    });
+  }
+
+  /** A provider that serves nothing but audiobooks, so a book without audio never needs it. */
+  servesOnlyAudiobooks(key: MetadataProviderKey): boolean {
+    const mediaKinds = this.find(key)?.mediaKinds;
+    return mediaKinds !== undefined && mediaKinds.length > 0 && mediaKinds.every((kind) => kind === 'audiobook');
+  }
+
+  editionFollowsMedium(key: MetadataProviderKey): boolean {
+    return this.find(key)?.editionFollowsMedium === true;
+  }
 }
diff --git a/server/src/modules/metadata-fetch/providers/aladin/aladin.provider.ts b/server/src/modules/metadata-fetch/providers/aladin/aladin.provider.ts
index ffde341ec..cc683c141 100644
--- a/server/src/modules/metadata-fetch/providers/aladin/aladin.provider.ts
+++ b/server/src/modules/metadata-fetch/providers/aladin/aladin.provider.ts
@@ -31,6 +31,7 @@ export class AladinProvider implements IdentifiableProvider {
   readonly key = MetadataProviderKey.ALADIN;
   readonly label = 'Aladin';
   readonly identifiable = true as const;
+  readonly coverShape = 'portrait' as const;
 
   private readonly logger = new Logger(AladinProvider.name);
 
diff --git a/server/src/modules/metadata-fetch/providers/amazon/amazon.provider.ts b/server/src/modules/metadata-fetch/providers/amazon/amazon.provider.ts
index b50863878..ff754a5e1 100644
--- a/server/src/modules/metadata-fetch/providers/amazon/amazon.provider.ts
+++ b/server/src/modules/metadata-fetch/providers/amazon/amazon.provider.ts
@@ -1,5 +1,5 @@
 import { Injectable, Logger } from '@nestjs/common';
-import { MetadataCandidate, MetadataProviderKey, parseSeriesIndex } from '@bookorbit/types';
+import { coverShapeFromSize, MetadataCandidate, MetadataProviderKey, parseSeriesIndex } from '@bookorbit/types';
 
 import { ProviderConfigService } from '../../../metadata-preferences/provider-config.service';
 import { amazonRequestHeaders, isAmazonBotChallenge } from '../../../../common/utils/amazon-http.utils';
@@ -83,6 +83,12 @@ export class AmazonProvider implements IdentifiableProvider {
       seriesIndex: parseSeriesIndex(data.seriesIndex) ?? undefined,
       seriesTotalBooks: data.seriesTotalBooks,
       coverUrl: data.coverUrl,
+      ...(data.coverUrl
+        ? {
+            coverShape: coverShapeFromSize(data.coverWidth, data.coverHeight),
+            ...(data.coverWidth && data.coverHeight ? { coverWidth: data.coverWidth, coverHeight: data.coverHeight } : {}),
+          }
+        : {}),
       genres: data.tags?.length ? data.tags : undefined,
       sourceUrl: url.toString(),
       ...(data.communityRating !== undefined ? { communityRating: data.communityRating } : {}),
diff --git a/server/src/modules/metadata-fetch/providers/amazon/amazon.scraper.test.ts b/server/src/modules/metadata-fetch/providers/amazon/amazon.scraper.test.ts
index a3372ec34..517b0a92b 100644
--- a/server/src/modules/metadata-fetch/providers/amazon/amazon.scraper.test.ts
+++ b/server/src/modules/metadata-fetch/providers/amazon/amazon.scraper.test.ts
@@ -198,3 +198,32 @@ describe('AmazonScraper', () => {
     });
   });
 });
+
+describe('Amazon cover size', () => {
+  function page(dynamicImage: string): string {
+    return `<span id="productTitle">Dune</span><img id="landingImage" data-a-dynamic-image='${dynamicImage}'>`;
+  }
+
+  it('reads an unsized pair as height then width, the order Amazon pages use', () => {
+    expect(parseBookPage(page('{"https://m.media-amazon.com/images/I/1.jpg": [461, 300]}'))).toMatchObject({
+      coverWidth: 300,
+      coverHeight: 461,
+    });
+  });
+
+  it('lets the sized side of a variant url say which number is which', () => {
+    expect(parseBookPage(page('{"https://m.media-amazon.com/images/I/1._SY522_.jpg": [522, 340]}'))).toMatchObject({
+      coverWidth: 340,
+      coverHeight: 522,
+    });
+    expect(parseBookPage(page('{"https://m.media-amazon.com/images/I/1._SX300_.jpg": [300, 461]}'))).toMatchObject({
+      coverWidth: 300,
+      coverHeight: 461,
+    });
+  });
+
+  it('keeps the largest declared size', () => {
+    const map = '{"https://m.media-amazon.com/images/I/1._SY200_.jpg": [200, 130], "https://m.media-amazon.com/images/I/1._SY522_.jpg": [522, 340]}';
+    expect(parseBookPage(page(map))).toMatchObject({ coverWidth: 340, coverHeight: 522 });
+  });
+});
diff --git a/server/src/modules/metadata-fetch/providers/amazon/amazon.scraper.ts b/server/src/modules/metadata-fetch/providers/amazon/amazon.scraper.ts
index 007733e0b..86c947ca2 100644
--- a/server/src/modules/metadata-fetch/providers/amazon/amazon.scraper.ts
+++ b/server/src/modules/metadata-fetch/providers/amazon/amazon.scraper.ts
@@ -20,6 +20,8 @@ export interface AmazonBookData {
   seriesIndex?: string;
   seriesTotalBooks?: number;
   coverUrl?: string;
+  coverWidth?: number;
+  coverHeight?: number;
   tags?: string[];
   communityRating?: number;
   communityRatingCount?: number;
@@ -46,7 +48,7 @@ export function parseBookPage(html: string): AmazonBookData {
     seriesName: extractSeriesName($),
     seriesIndex: extractSeriesIndex($),
     seriesTotalBooks: extractSeriesTotalBooks($),
-    coverUrl: extractCoverUrl($),
+    ...extractCover($),
     tags: extractCategories($),
     communityRating: extractCommunityRating($),
     communityRatingCount: extractCommunityRatingCount($),
@@ -241,11 +243,12 @@ function extractSeriesTotalBooks($: CheerioAPI): number | undefined {
   return match ? normalizeSeriesTotalBooks(match[1]) : undefined;
 }
 
-function extractCoverUrl($: CheerioAPI): string | undefined {
+function extractCover($: CheerioAPI): Pick<AmazonBookData, 'coverUrl' | 'coverWidth' | 'coverHeight'> {
   const img = $('#landingImage, #imgBlkFront').first();
 
-  // data-a-dynamic-image is a JSON map of url -> [width, height] with all available sizes.
-  // Cheerio decodes HTML entities in attr(), so &quot; becomes " automatically.
+  // data-a-dynamic-image is a JSON map of variant url -> size, one entry per available size. The
+  // pairs are [height, width]: every page checked in September 2026 agreed once the images were
+  // measured. Cheerio decodes HTML entities in attr(), so &quot; becomes " automatically.
   const dynamicRaw = img.attr('data-a-dynamic-image');
   if (dynamicRaw) {
     try {
@@ -255,7 +258,7 @@ function extractCoverUrl($: CheerioAPI): string | undefined {
         // Strip the size modifier (e.g. ._SY342_) from any variant URL to get
         // the full-resolution original. All entries are the same image at different sizes.
         const [sampleUrl] = entries[0];
-        return sampleUrl.replace(/\._[^.]+_\./, '.');
+        return { coverUrl: sampleUrl.replace(/\._[^.]+_\./, '.'), ...largestDeclaredSize(entries) };
       }
     } catch {
       // fall through
@@ -263,9 +266,29 @@ function extractCoverUrl($: CheerioAPI): string | undefined {
   }
 
   const hires = img.attr('data-old-hires');
-  if (hires) return hires;
+  if (hires) return { coverUrl: hires };
   const src = img.attr('src');
-  return src ? src.replace(/\._[A-Z0-9_,]+_\./i, '.') : undefined;
+  return src ? { coverUrl: src.replace(/\._[A-Z0-9_,]+_\./i, '.') } : {};
+}
+
+/**
+ * The largest declared size, which is the least rounded. A variant url sized by one side
+ * (`._SY522_` for height, `._SX300_` for width) settles which number is which; otherwise the pair
+ * is read as [height, width].
+ */
+function largestDeclaredSize(entries: [string, unknown][]): Pick<AmazonBookData, 'coverWidth' | 'coverHeight'> {
+  let best: { coverWidth: number; coverHeight: number } | undefined;
+  for (const [variantUrl, size] of entries) {
+    if (!Array.isArray(size)) continue;
+    const [first, second] = size as unknown[];
+    if (typeof first !== 'number' || typeof second !== 'number' || first <= 0 || second <= 0) continue;
+    const sizedWidth = Number(/\._SX(\d+)_/.exec(variantUrl)?.[1]);
+    const sizedHeight = Number(/\._SY(\d+)_/.exec(variantUrl)?.[1]);
+    const firstIsWidth = sizedWidth === first || (sizedHeight === second && sizedHeight !== first);
+    const declared = firstIsWidth ? { coverWidth: first, coverHeight: second } : { coverWidth: second, coverHeight: first };
+    if (!best || declared.coverWidth * declared.coverHeight > best.coverWidth * best.coverHeight) best = declared;
+  }
+  return best ?? {};
 }
 
 function extractCommunityRating($: CheerioAPI): number | undefined {
diff --git a/server/src/modules/metadata-fetch/providers/audible/audible.provider.ts b/server/src/modules/metadata-fetch/providers/audible/audible.provider.ts
index b1fd50fdc..99a2fa7da 100644
--- a/server/src/modules/metadata-fetch/providers/audible/audible.provider.ts
+++ b/server/src/modules/metadata-fetch/providers/audible/audible.provider.ts
@@ -19,6 +19,7 @@ export class AudibleProvider implements IdentifiableProvider {
   readonly key = MetadataProviderKey.AUDIBLE;
   readonly label = 'Audible';
   readonly identifiable = true as const;
+  readonly coverShape = 'square' as const;
   readonly mediaKinds = ['audiobook'] as const;
 
   private readonly logger = new Logger(AudibleProvider.name);
@@ -37,6 +38,8 @@ export class AudibleProvider implements IdentifiableProvider {
     url.searchParams.set('num_results', '10');
     url.searchParams.set('keywords', query);
     url.searchParams.set('response_groups', 'product_desc,media,product_attrs,series,product_plan_details,category_ladders,rating');
+    // Without it the catalog lists only the 500px image.
+    url.searchParams.set('image_sizes', '500,1024');
     const requestUrl = url.toString();
     const startedAt = Date.now();
     const safeQuery = sanitizeLogValue(query);
@@ -75,6 +78,8 @@ export class AudibleProvider implements IdentifiableProvider {
 
     const url = new URL(`/1.0/catalog/products/${encodeURIComponent(providerId)}`, audibleApiOrigin(normalizedDomain));
     url.searchParams.set('response_groups', 'product_desc,media,product_attrs,series,product_plan_details,category_ladders,rating');
+    // Without it the catalog lists only the 500px image.
+    url.searchParams.set('image_sizes', '500,1024');
     const requestUrl = url.toString();
     const startedAt = Date.now();
     this.logger.log(`[audible] [start] op=lookup providerId="${providerId}"`);
diff --git a/server/src/modules/metadata-fetch/providers/audnexus/audnexus.provider.ts b/server/src/modules/metadata-fetch/providers/audnexus/audnexus.provider.ts
index 003e7ee10..263db5848 100644
--- a/server/src/modules/metadata-fetch/providers/audnexus/audnexus.provider.ts
+++ b/server/src/modules/metadata-fetch/providers/audnexus/audnexus.provider.ts
@@ -27,6 +27,7 @@ export class AudnexusProvider implements MetadataProvider {
   readonly key = MetadataProviderKey.AUDNEXUS;
   readonly label = 'AudNexus';
   readonly identifiable = false as const;
+  readonly coverShape = 'square' as const;
   readonly mediaKinds = ['audiobook'] as const;
 
   private readonly logger = new Logger(AudnexusProvider.name);
diff --git a/server/src/modules/metadata-fetch/providers/comicvine/comicvine.provider.ts b/server/src/modules/metadata-fetch/providers/comicvine/comicvine.provider.ts
index e28e50c3e..c08e33867 100644
--- a/server/src/modules/metadata-fetch/providers/comicvine/comicvine.provider.ts
+++ b/server/src/modules/metadata-fetch/providers/comicvine/comicvine.provider.ts
@@ -94,6 +94,7 @@ export class ComicVineProvider implements IdentifiableProvider {
   readonly key = MetadataProviderKey.COMICVINE;
   readonly label = 'ComicVine';
   readonly identifiable = true as const;
+  readonly coverShape = 'portrait' as const;
   readonly mediaKinds = ['comic'] as const;
 
   private readonly logger = new Logger(ComicVineProvider.name);
diff --git a/server/src/modules/metadata-fetch/providers/goodreads/goodreads.provider.ts b/server/src/modules/metadata-fetch/providers/goodreads/goodreads.provider.ts
index 600500ce1..a79bab695 100644
--- a/server/src/modules/metadata-fetch/providers/goodreads/goodreads.provider.ts
+++ b/server/src/modules/metadata-fetch/providers/goodreads/goodreads.provider.ts
@@ -44,6 +44,7 @@ export class GoodreadsProvider implements IdentifiableProvider {
   readonly key = MetadataProviderKey.GOODREADS;
   readonly label = 'Goodreads';
   readonly identifiable = true as const;
+  readonly coverShape = 'portrait' as const;
 
   private readonly logger = new Logger(GoodreadsProvider.name);
 
diff --git a/server/src/modules/metadata-fetch/providers/google/google-cover-validator.ts b/server/src/modules/metadata-fetch/providers/google/google-cover-validator.ts
index 5237f04ad..cd6c0950a 100644
--- a/server/src/modules/metadata-fetch/providers/google/google-cover-validator.ts
+++ b/server/src/modules/metadata-fetch/providers/google/google-cover-validator.ts
@@ -2,6 +2,7 @@ import { createHash } from 'crypto';
 
 import type { MetadataCandidate } from '@bookorbit/types';
 
+import { GOOGLE_BOOKS_PLACEHOLDER_HASHES, GOOGLE_BOOKS_PLACEHOLDER_LENGTHS } from '../../../../common/utils/placeholder-cover.utils';
 import { buildRequestSignal } from '../provider-utils';
 
 const GOOGLE_BOOKS_COVER_HOST = 'books.google.com';
@@ -11,9 +12,6 @@ const MAX_FINGERPRINT_BYTES = 32 * 1024;
 const CACHE_TTL_MS = 6 * 60 * 60 * 1_000;
 const CACHE_MAX_ENTRIES = 500;
 
-const GOOGLE_BOOKS_PLACEHOLDER_LENGTHS = new Set([9_103]);
-const GOOGLE_BOOKS_PLACEHOLDER_HASHES = new Set(['3efa8c43e5b4348f303a528c81adf435f0111ea752fe9f0f6241478b60987fa6']);
-
 type FetchImage = (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
 
 interface GoogleCoverValidatorOptions {
diff --git a/server/src/modules/metadata-fetch/providers/google/google.provider.ts b/server/src/modules/metadata-fetch/providers/google/google.provider.ts
index bb2caa181..4e6822e00 100644
--- a/server/src/modules/metadata-fetch/providers/google/google.provider.ts
+++ b/server/src/modules/metadata-fetch/providers/google/google.provider.ts
@@ -20,6 +20,7 @@ export class GoogleProvider implements IdentifiableProvider {
   readonly key = MetadataProviderKey.GOOGLE;
   readonly label = 'Google Books';
   readonly identifiable = true as const;
+  readonly coverShape = 'portrait' as const;
 
   private readonly logger = new Logger(GoogleProvider.name);
   private readonly coverValidator = new GoogleCoverValidator();
diff --git a/server/src/modules/metadata-fetch/providers/hardcover/hardcover.client.ts b/server/src/modules/metadata-fetch/providers/hardcover/hardcover.client.ts
index 1b827ef86..35da2db46 100644
--- a/server/src/modules/metadata-fetch/providers/hardcover/hardcover.client.ts
+++ b/server/src/modules/metadata-fetch/providers/hardcover/hardcover.client.ts
@@ -23,7 +23,7 @@ const BOOK_FIELDS = `
   pages
   release_date
   release_year
-  image { url }
+  image { url width height }
 `;
 
 const EDITION_FIELDS = `
@@ -34,7 +34,7 @@ const EDITION_FIELDS = `
   pages
   release_date
   release_year
-  image { url }
+  image { url width height }
   publisher { name }
   isbn_10
   isbn_13
diff --git a/server/src/modules/metadata-fetch/providers/hardcover/hardcover.mapper.test.ts b/server/src/modules/metadata-fetch/providers/hardcover/hardcover.mapper.test.ts
index 141edfda9..41dd5df72 100644
--- a/server/src/modules/metadata-fetch/providers/hardcover/hardcover.mapper.test.ts
+++ b/server/src/modules/metadata-fetch/providers/hardcover/hardcover.mapper.test.ts
@@ -80,6 +80,7 @@ describe('mapSearchDocument', () => {
       seriesName: 'The Kingkiller Chronicle',
       seriesIndex: '1',
       coverUrl: 'https://assets.hardcover.app/cover.jpg',
+      coverShape: 'unknown',
       sourceUrl: 'https://hardcover.app/books/the-name-of-the-wind',
       communityRating: 4.42,
       communityRatingCount: 12345,
@@ -302,6 +303,7 @@ describe('mapBookWithEditions', () => {
       communityRating: 4.42,
       communityRatingCount: 12345,
       coverUrl: 'https://assets.hardcover.app/edition-cover.jpg',
+      coverShape: 'portrait',
       sourceUrl: 'https://hardcover.app/books/the-name-of-the-wind',
     });
   });
@@ -611,6 +613,54 @@ describe('mapBookWithEditions', () => {
     expect(results[1].pageCount).toBeUndefined();
   });
 
+  it('ranks audiobook editions first when asked for the audio medium, with square art', () => {
+    const book: HardcoverBookWithEditions = {
+      ...baseBook,
+      editions: [
+        { ...baseBook.editions![0], id: 2, isbn_13: 'PRINT', reading_format_id: 1, pages: 700 },
+        {
+          ...baseBook.editions![0],
+          id: 1,
+          isbn_13: 'AUDIO',
+          reading_format_id: 2,
+          pages: undefined,
+          image: { url: 'https://assets.hardcover.app/audio.jpg', width: 1000, height: 1000 },
+        },
+      ],
+    };
+    const results = mapBookWithEditions(book, 'audio');
+    expect(results.map((result) => result.isbn13)).toEqual(['AUDIO', 'PRINT']);
+    expect(results[0]).toMatchObject({
+      coverUrl: 'https://assets.hardcover.app/audio.jpg',
+      coverShape: 'square',
+      coverWidth: 1000,
+      coverHeight: 1000,
+    });
+    expect(results[1].coverShape).toBe('portrait');
+  });
+
+  it('reads the shape from the stated size, and does not assume an audiobook edition is square without one', () => {
+    const book: HardcoverBookWithEditions = {
+      ...baseBook,
+      editions: [
+        { ...baseBook.editions![0], id: 1, reading_format_id: 2, image: { url: 'https://assets.hardcover.app/cd.jpg' } },
+        { ...baseBook.editions![0], id: 2, reading_format_id: 2, image: { url: 'https://assets.hardcover.app/jacket.jpg', width: 400, height: 600 } },
+      ],
+    };
+    const [unsized, jacket] = mapBookWithEditions(book, 'audio');
+    expect(unsized!.coverShape).toBe('unknown');
+    expect(jacket).toMatchObject({ coverShape: 'portrait', coverWidth: 400, coverHeight: 600 });
+  });
+
+  it('calls a cover borrowed from the book unknown, since it may belong to any edition', () => {
+    const book: HardcoverBookWithEditions = {
+      ...baseBook,
+      image: { url: 'https://assets.hardcover.app/book.jpg' },
+      editions: [{ ...baseBook.editions![0], reading_format_id: 2, image: undefined }],
+    };
+    expect(mapBookWithEditions(book, 'audio')[0]).toMatchObject({ coverUrl: 'https://assets.hardcover.app/book.jpg', coverShape: 'unknown' });
+  });
+
   it('ranks editions with a page count ahead of those without when format is equal', () => {
     const book: HardcoverBookWithEditions = {
       ...baseBook,
diff --git a/server/src/modules/metadata-fetch/providers/hardcover/hardcover.mapper.ts b/server/src/modules/metadata-fetch/providers/hardcover/hardcover.mapper.ts
index cedf5e06f..5d8a31c1c 100644
--- a/server/src/modules/metadata-fetch/providers/hardcover/hardcover.mapper.ts
+++ b/server/src/modules/metadata-fetch/providers/hardcover/hardcover.mapper.ts
@@ -1,4 +1,4 @@
-import { MetadataCandidate, MetadataProviderKey, parseSeriesIndex } from '@bookorbit/types';
+import { coverShapeFromSize, MetadataCandidate, MetadataProviderKey, parseSeriesIndex, type CoverMedium } from '@bookorbit/types';
 
 import { parsePublishedDateKey, parsePublishedYear, publishedYearFromDateKey } from '../../../../common/utils/published-date.utils';
 import { normalizeSeriesTotalBooks } from '../../../../common/utils/series-total-books.utils';
@@ -7,6 +7,7 @@ import {
   HardcoverCachedContributor,
   HardcoverCachedTags,
   HardcoverEdition,
+  HardcoverImage,
   HardcoverSearchDocument,
 } from './hardcover.types';
 
@@ -64,10 +65,12 @@ function isAudiobookEdition(edition: HardcoverEdition): boolean {
   return edition.reading_format_id === AUDIOBOOK_READING_FORMAT_ID || (edition.audio_seconds ?? 0) > 0;
 }
 
-// Lower rank sorts first: physical/ebook before audiobooks, and editions with a
-// real page count before those without.
-function editionRank(edition: HardcoverEdition): number {
-  return (isAudiobookEdition(edition) ? 2 : 0) + (edition.pages == null ? 1 : 0);
+// Lower rank sorts first: editions of the requested medium before the others (physical and
+// ebook editions for a book, audiobook editions for an audiobook), then editions with a real page
+// count before those without.
+function editionRank(edition: HardcoverEdition, medium: CoverMedium): number {
+  const otherMedium = isAudiobookEdition(edition) !== (medium === 'audio');
+  return (otherMedium ? 2 : 0) + (edition.pages == null ? 1 : 0);
 }
 
 function resolveEditionPublishedYear(edition: HardcoverEdition, book: HardcoverBookWithEditions): number | undefined {
@@ -131,15 +134,41 @@ export function mapSearchDocument(doc: HardcoverSearchDocument): MetadataCandida
     seriesName: doc.featured_series?.series?.name,
     seriesIndex: parseSeriesIndex(doc.featured_series?.position) ?? undefined,
     coverUrl: doc.image?.url,
+    ...coverFromImage(doc.image, 'unknown'),
     sourceUrl: `https://hardcover.app/books/${doc.slug}`,
     ...(communityRating !== undefined ? { communityRating } : {}),
     ...(communityRatingCount !== undefined ? { communityRatingCount } : {}),
   };
 }
 
-export function mapBookWithEditions(book: HardcoverBookWithEditions): MetadataCandidate[] {
+export function mapBookWithEditions(book: HardcoverBookWithEditions, medium: CoverMedium = 'ebook'): MetadataCandidate[] {
   if (!book.editions || book.editions.length === 0) return [];
-  return [...book.editions].sort((a, b) => editionRank(a) - editionRank(b)).map((edition) => mapEdition(edition, book));
+  return [...book.editions].sort((a, b) => editionRank(a, medium) - editionRank(b, medium)).map((edition) => mapEdition(edition, book));
+}
+
+/**
+ * Hardcover states each image's size, so the shape comes from that. Without one, a print or ebook
+ * edition's own image is taken as portrait; an audiobook edition's is not taken as square, since
+ * many reuse the print jacket or show the CD box, and the book-level image may be any edition's.
+ */
+function editionCover(
+  edition: HardcoverEdition,
+  book: HardcoverBookWithEditions,
+): Pick<MetadataCandidate, 'coverShape' | 'coverWidth' | 'coverHeight'> {
+  if (edition.image?.url) return coverFromImage(edition.image, isAudiobookEdition(edition) ? 'unknown' : 'portrait');
+  return coverFromImage(book.image, 'unknown');
+}
+
+function coverFromImage(
+  image: HardcoverImage | undefined,
+  shapeWithoutSize: 'portrait' | 'unknown',
+): Pick<MetadataCandidate, 'coverShape' | 'coverWidth' | 'coverHeight'> {
+  if (!image?.url) return {};
+  const { width, height } = image;
+  if (typeof width === 'number' && typeof height === 'number' && width > 0 && height > 0) {
+    return { coverShape: coverShapeFromSize(width, height), coverWidth: width, coverHeight: height };
+  }
+  return { coverShape: shapeWithoutSize };
 }
 
 function mapEdition(edition: HardcoverEdition, book: HardcoverBookWithEditions): MetadataCandidate {
@@ -170,6 +199,7 @@ function mapEdition(edition: HardcoverEdition, book: HardcoverBookWithEditions):
     seriesIndex: parseSeriesIndex(book.featured_book_series?.position) ?? undefined,
     seriesTotalBooks: normalizeSeriesTotalBooks(book.featured_book_series?.series?.books_count),
     coverUrl: edition.image?.url ?? book.image?.url,
+    ...editionCover(edition, book),
     sourceUrl: `https://hardcover.app/books/${book.slug}`,
     ...(communityRating !== undefined ? { communityRating } : {}),
     ...(communityRatingCount !== undefined ? { communityRatingCount } : {}),
diff --git a/server/src/modules/metadata-fetch/providers/hardcover/hardcover.provider.ts b/server/src/modules/metadata-fetch/providers/hardcover/hardcover.provider.ts
index e1e609693..d398f5042 100644
--- a/server/src/modules/metadata-fetch/providers/hardcover/hardcover.provider.ts
+++ b/server/src/modules/metadata-fetch/providers/hardcover/hardcover.provider.ts
@@ -1,5 +1,5 @@
 import { Injectable, Logger } from '@nestjs/common';
-import { MetadataCandidate, MetadataProviderKey } from '@bookorbit/types';
+import { MetadataCandidate, MetadataProviderKey, type CoverMedium } from '@bookorbit/types';
 
 import { ProviderConfigService } from '../../../metadata-preferences/provider-config.service';
 import { candidateHasNormalizedIsbn, normalizeMetadataIsbn } from '../../isbn-match';
@@ -8,11 +8,16 @@ import { MetadataSearchParams } from '../metadata-search-params';
 import { HardcoverClient } from './hardcover.client';
 import { mapBookWithEditions, mapSearchDocument } from './hardcover.mapper';
 
+function editionMedium(params: MetadataSearchParams | undefined): CoverMedium {
+  return params?.isAudiobook ? 'audio' : 'ebook';
+}
+
 @Injectable()
 export class HardcoverProvider implements IdentifiableProvider {
   readonly key = MetadataProviderKey.HARDCOVER;
   readonly label = 'Hardcover';
   readonly identifiable = true as const;
+  readonly editionFollowsMedium = true;
 
   private readonly logger = new Logger(HardcoverProvider.name);
 
@@ -29,7 +34,7 @@ export class HardcoverProvider implements IdentifiableProvider {
     if (params.isbn) {
       const books = signal ? await this.client.searchByIsbn(params.isbn, apiKey, signal) : await this.client.searchByIsbn(params.isbn, apiKey);
       if (books.length > 0) {
-        const candidates = books.flatMap(mapBookWithEditions);
+        const candidates = books.flatMap((book) => mapBookWithEditions(book, editionMedium(params)));
         const pinned = params.hardcoverEditionId
           ? candidates.find((candidate) => candidate.hardcoverEditionId === params.hardcoverEditionId)
           : undefined;
@@ -60,7 +65,7 @@ export class HardcoverProvider implements IdentifiableProvider {
     const book = signal ? await this.client.lookupBySlug(providerId, apiKey, signal) : await this.client.lookupBySlug(providerId, apiKey);
     if (!book) return null;
 
-    const candidates = mapBookWithEditions(book);
+    const candidates = mapBookWithEditions(book, editionMedium(params));
 
     if (params?.hardcoverEditionId) {
       const pinned = candidates.find((candidate) => candidate.hardcoverEditionId === params.hardcoverEditionId);
diff --git a/server/src/modules/metadata-fetch/providers/hardcover/hardcover.types.ts b/server/src/modules/metadata-fetch/providers/hardcover/hardcover.types.ts
index 0cdeaaeee..777313fcc 100644
--- a/server/src/modules/metadata-fetch/providers/hardcover/hardcover.types.ts
+++ b/server/src/modules/metadata-fetch/providers/hardcover/hardcover.types.ts
@@ -101,4 +101,6 @@ export interface HardcoverCachedContributor {
 
 export interface HardcoverImage {
   url?: string;
+  width?: number | null;
+  height?: number | null;
 }
diff --git a/server/src/modules/metadata-fetch/providers/itunes/itunes.mapper.test.ts b/server/src/modules/metadata-fetch/providers/itunes/itunes.mapper.test.ts
index fc812da23..c09c41fc1 100644
--- a/server/src/modules/metadata-fetch/providers/itunes/itunes.mapper.test.ts
+++ b/server/src/modules/metadata-fetch/providers/itunes/itunes.mapper.test.ts
@@ -109,4 +109,13 @@ describe('itunes.mapper', () => {
 
     expect(() => mapITunesResult(result)).toThrow('iTunes result missing both trackId and collectionId');
   });
+
+  it('states the cover shape from the kind of item, ebook jackets portrait and audiobooks square', () => {
+    const base: ITunesResult = { trackId: 1, trackName: 'Dune', artworkUrl100: 'https://is1-ssl.mzstatic.com/a/100x100bb.jpg' };
+
+    expect(mapITunesResult({ ...base, kind: 'ebook' }).coverShape).toBe('portrait');
+    expect(mapITunesResult({ ...base, kind: 'audiobook' }).coverShape).toBe('square');
+    expect(mapITunesResult({ ...base, wrapperType: 'audiobook' }).coverShape).toBe('square');
+    expect(mapITunesResult({ ...base, artworkUrl100: undefined, kind: 'ebook' }).coverShape).toBeUndefined();
+  });
 });
diff --git a/server/src/modules/metadata-fetch/providers/itunes/itunes.mapper.ts b/server/src/modules/metadata-fetch/providers/itunes/itunes.mapper.ts
index a4f2ec836..3ae99244f 100644
--- a/server/src/modules/metadata-fetch/providers/itunes/itunes.mapper.ts
+++ b/server/src/modules/metadata-fetch/providers/itunes/itunes.mapper.ts
@@ -1,4 +1,4 @@
-import { MetadataCandidate, MetadataProviderKey, type ITunesCoverResolution } from '@bookorbit/types';
+import { MetadataCandidate, MetadataProviderKey, type ITunesCoverResolution, type MetadataCoverShape } from '@bookorbit/types';
 import { parsePublishedDateKey, publishedYearFromDateKey } from '../../../../common/utils/published-date.utils';
 import { ITunesResult } from './itunes.types';
 
@@ -10,6 +10,13 @@ function mapCoverUrl(artworkUrl100: string | undefined, coverResolution: ITunesC
   return artworkUrl100.replace('100x100bb.jpg', target);
 }
 
+// Apple sells ebooks with their print-shaped jackets and audiobooks with square art.
+function coverShapeOf(result: ITunesResult): MetadataCoverShape {
+  if (result.kind === 'ebook') return 'portrait';
+  if (result.kind === 'audiobook' || result.wrapperType === 'audiobook') return 'square';
+  return 'unknown';
+}
+
 function normalizeCommunityRating(value: number | undefined): number | undefined {
   return typeof value === 'number' && Number.isFinite(value) && value >= 0 && value <= 5 ? value : undefined;
 }
@@ -43,6 +50,7 @@ export function mapITunesResult(result: ITunesResult, coverResolution: ITunesCov
     language: result.languageCodesISO2A?.[0],
     genres: result.genres,
     coverUrl,
+    ...(coverUrl ? { coverShape: coverShapeOf(result) } : {}),
     sourceUrl: result.trackViewUrl ?? result.collectionViewUrl,
     ...(communityRating !== undefined ? { communityRating } : {}),
     ...(communityRatingCount !== undefined ? { communityRatingCount } : {}),
diff --git a/server/src/modules/metadata-fetch/providers/itunes/itunes.provider.ts b/server/src/modules/metadata-fetch/providers/itunes/itunes.provider.ts
index 46ea6435c..3754711ac 100644
--- a/server/src/modules/metadata-fetch/providers/itunes/itunes.provider.ts
+++ b/server/src/modules/metadata-fetch/providers/itunes/itunes.provider.ts
@@ -30,6 +30,7 @@ export class ITunesProvider implements IdentifiableProvider {
   readonly key = MetadataProviderKey.ITUNES;
   readonly label = 'iTunes';
   readonly identifiable = true as const;
+  readonly editionFollowsMedium = true;
 
   private readonly logger = new Logger(ITunesProvider.name);
 
diff --git a/server/src/modules/metadata-fetch/providers/kobo/kobo.provider.ts b/server/src/modules/metadata-fetch/providers/kobo/kobo.provider.ts
index 6079e01d0..f6674177b 100644
--- a/server/src/modules/metadata-fetch/providers/kobo/kobo.provider.ts
+++ b/server/src/modules/metadata-fetch/providers/kobo/kobo.provider.ts
@@ -45,6 +45,7 @@ export class KoboProvider implements IdentifiableProvider {
   readonly key = MetadataProviderKey.KOBO;
   readonly label = 'Kobo';
   readonly identifiable = true as const;
+  readonly coverShape = 'portrait' as const;
   readonly timeoutMs = PROVIDER_TIMEOUT_MS.KOBO_SCRAPE;
 
   private readonly logger = new Logger(KoboProvider.name);
diff --git a/server/src/modules/metadata-fetch/providers/librofm/librofm.provider.ts b/server/src/modules/metadata-fetch/providers/librofm/librofm.provider.ts
index 6545d0d66..215174d3a 100644
--- a/server/src/modules/metadata-fetch/providers/librofm/librofm.provider.ts
+++ b/server/src/modules/metadata-fetch/providers/librofm/librofm.provider.ts
@@ -24,6 +24,7 @@ export class LibroFmProvider implements IdentifiableProvider {
   readonly key = MetadataProviderKey.LIBROFM;
   readonly label = 'Libro.fm';
   readonly identifiable = true as const;
+  readonly coverShape = 'square' as const;
   readonly mediaKinds = ['audiobook'] as const;
 
   private readonly logger = new Logger(LibroFmProvider.name);
diff --git a/server/src/modules/metadata-fetch/providers/lubimyczytac/lubimyczytac.provider.ts b/server/src/modules/metadata-fetch/providers/lubimyczytac/lubimyczytac.provider.ts
index 1fb40da24..48354bbb3 100644
--- a/server/src/modules/metadata-fetch/providers/lubimyczytac/lubimyczytac.provider.ts
+++ b/server/src/modules/metadata-fetch/providers/lubimyczytac/lubimyczytac.provider.ts
@@ -35,6 +35,7 @@ export class LubimyczytacProvider implements IdentifiableProvider {
   readonly key = MetadataProviderKey.LUBIMYCZYTAC;
   readonly label = 'LubimyCzytac';
   readonly identifiable = true as const;
+  readonly coverShape = 'portrait' as const;
   readonly timeoutMs = PROVIDER_TIMEOUT_MS.SCRAPE;
 
   private readonly logger = new Logger(LubimyczytacProvider.name);
diff --git a/server/src/modules/metadata-fetch/providers/metadata-provider.ts b/server/src/modules/metadata-fetch/providers/metadata-provider.ts
index 9a0a0022b..29fcd9f05 100644
--- a/server/src/modules/metadata-fetch/providers/metadata-provider.ts
+++ b/server/src/modules/metadata-fetch/providers/metadata-provider.ts
@@ -1,4 +1,4 @@
-import { ConcreteBookMediaKind, MetadataCandidate, MetadataProviderKey } from '@bookorbit/types';
+import { ConcreteBookMediaKind, MetadataCandidate, MetadataCoverShape, MetadataProviderKey } from '@bookorbit/types';
 
 import { MetadataSearchParams } from './metadata-search-params';
 
@@ -12,6 +12,17 @@ export interface MetadataProvider {
    * that leaves it undefined serves every kind, so a new provider is never silently scoped out.
    */
   readonly mediaKinds?: readonly ConcreteBookMediaKind[];
+  /**
+   * The shape of every cover this provider returns, when that never varies. A provider whose art
+   * depends on the edition it matched leaves this unset and states `coverShape` per candidate.
+   */
+  readonly coverShape?: Exclude<MetadataCoverShape, 'unknown'>;
+  /**
+   * True when the provider carries both an ebook and an audiobook edition of a title and answers
+   * with the one `isAudiobook` asks for, art included. Only these are asked again for a book's
+   * other medium.
+   */
+  readonly editionFollowsMedium?: boolean;
   search(params: MetadataSearchParams): Promise<MetadataCandidate[]>;
 }
 
diff --git a/server/src/modules/metadata-fetch/providers/open-library/open-library.provider.ts b/server/src/modules/metadata-fetch/providers/open-library/open-library.provider.ts
index 05dc1e1a5..3c4a7d865 100644
--- a/server/src/modules/metadata-fetch/providers/open-library/open-library.provider.ts
+++ b/server/src/modules/metadata-fetch/providers/open-library/open-library.provider.ts
@@ -20,6 +20,7 @@ export class OpenLibraryProvider implements IdentifiableProvider {
   readonly key = MetadataProviderKey.OPEN_LIBRARY;
   readonly label = 'OpenLibrary';
   readonly identifiable = true as const;
+  readonly coverShape = 'portrait' as const;
 
   private readonly logger = new Logger(OpenLibraryProvider.name);
 
diff --git a/server/src/modules/metadata-fetch/providers/ranobedb/ranobedb.provider.ts b/server/src/modules/metadata-fetch/providers/ranobedb/ranobedb.provider.ts
index bead77943..780e12b0b 100644
--- a/server/src/modules/metadata-fetch/providers/ranobedb/ranobedb.provider.ts
+++ b/server/src/modules/metadata-fetch/providers/ranobedb/ranobedb.provider.ts
@@ -13,6 +13,7 @@ export class RanobeDbProvider implements IdentifiableProvider {
   readonly key = MetadataProviderKey.RANOBEDB;
   readonly label = 'RanobeDB';
   readonly identifiable = true as const;
+  readonly coverShape = 'portrait' as const;
 
   private readonly logger = new Logger(RanobeDbProvider.name);
 
diff --git a/server/src/modules/metadata-preferences/metadata-preference-resolver.test.ts b/server/src/modules/metadata-preferences/metadata-preference-resolver.test.ts
index 2ca57cacc..9663061c4 100644
--- a/server/src/modules/metadata-preferences/metadata-preference-resolver.test.ts
+++ b/server/src/modules/metadata-preferences/metadata-preference-resolver.test.ts
@@ -285,4 +285,55 @@ describe('MetadataPreferenceResolver', () => {
 
     expect(result.fields.title.providers).toEqual([]);
   });
+
+  describe('audiobook cover rule', () => {
+    it('defaults to audiobook sources first and leaves Audnexus out', () => {
+      const { audioCover } = new MetadataPreferenceResolver().getDefaultPreferences().fields;
+
+      expect(audioCover).toEqual({
+        enabled: true,
+        mergeStrategy: 'overwriteIfProvided',
+        providers: [
+          MetadataProviderKey.AUDIBLE,
+          MetadataProviderKey.LIBROFM,
+          MetadataProviderKey.ITUNES,
+          MetadataProviderKey.AMAZON,
+          MetadataProviderKey.KOBO,
+          MetadataProviderKey.GOODREADS,
+          MetadataProviderKey.GOOGLE,
+          MetadataProviderKey.OPEN_LIBRARY,
+        ],
+      });
+    });
+
+    it('seeds a stored scope that predates it from its Cover rule, keeping the switch and merge strategy', () => {
+      const resolver = new MetadataPreferenceResolver();
+      const stored = {
+        fields: { cover: { enabled: false, mergeStrategy: 'fillMissing', providers: [MetadataProviderKey.AMAZON, MetadataProviderKey.GOOGLE] } },
+      } as unknown as MetadataFetchPreferences;
+
+      const { audioCover } = resolver.resolve(stored).fields;
+
+      expect(audioCover.enabled).toBe(false);
+      expect(audioCover.mergeStrategy).toBe('fillMissing');
+      expect(audioCover.providers).toEqual(resolver.getDefaultPreferences().fields.audioCover.providers);
+    });
+
+    it('keeps a Cover provider list that was already tuned for audiobooks', () => {
+      const resolver = new MetadataPreferenceResolver();
+      const tuned = [MetadataProviderKey.AUDIBLE, MetadataProviderKey.AMAZON];
+
+      expect(resolver.seedAudioCoverRule({ enabled: true, mergeStrategy: 'overwrite', providers: tuned }).providers).toEqual(tuned);
+    });
+
+    it('leaves a stored Audiobook cover rule alone', () => {
+      const resolver = new MetadataPreferenceResolver();
+      const audioCover = { enabled: true, mergeStrategy: 'overwrite' as const, providers: [MetadataProviderKey.LIBROFM] };
+      const stored = {
+        fields: { cover: { enabled: false, mergeStrategy: 'fillMissing', providers: [] }, audioCover },
+      } as unknown as MetadataFetchPreferences;
+
+      expect(resolver.resolve(stored).fields.audioCover).toEqual(audioCover);
+    });
+  });
 });
diff --git a/server/src/modules/metadata-preferences/metadata-preference-resolver.ts b/server/src/modules/metadata-preferences/metadata-preference-resolver.ts
index 2c2519727..02fa7152d 100644
--- a/server/src/modules/metadata-preferences/metadata-preference-resolver.ts
+++ b/server/src/modules/metadata-preferences/metadata-preference-resolver.ts
@@ -33,6 +33,11 @@ const MERGE_STRATEGY_SET = new Set<MetadataMergeStrategy>(MERGE_STRATEGIES);
 const GENRE_MERGE_STRATEGY_SET = new Set<MetadataMergeStrategy>(GENRE_MERGE_STRATEGIES);
 const GENRE_MERGE_MODE_SET = new Set(GENRE_MERGE_MODES);
 const PROVIDER_ID_FETCH_MODE_SET = new Set(PROVIDER_ID_FETCH_MODES);
+const AUDIOBOOK_ONLY_PROVIDERS = new Set<MetadataProviderKey>([
+  MetadataProviderKey.AUDIBLE,
+  MetadataProviderKey.AUDNEXUS,
+  MetadataProviderKey.LIBROFM,
+]);
 
 const PROVIDERS_WITH_ITUNES: MetadataProviderKey[] = [
   MetadataProviderKey.GOODREADS,
@@ -57,6 +62,20 @@ const FIELD_DEFAULTS: Partial<Record<MetadataField, Partial<FieldPreference>>> =
       MetadataProviderKey.OPEN_LIBRARY,
     ],
   },
+  // Audnexus is left out: it repeats the Audible request and would bring Audible's chapter
+  // timings along with the art.
+  audioCover: {
+    providers: [
+      MetadataProviderKey.AUDIBLE,
+      MetadataProviderKey.LIBROFM,
+      MetadataProviderKey.ITUNES,
+      MetadataProviderKey.AMAZON,
+      MetadataProviderKey.KOBO,
+      MetadataProviderKey.GOODREADS,
+      MetadataProviderKey.GOOGLE,
+      MetadataProviderKey.OPEN_LIBRARY,
+    ],
+  },
   authors: { providers: PROVIDERS_WITH_ITUNES },
   genres: {
     mergeStrategy: 'mergeExisting',
@@ -93,8 +112,9 @@ export class MetadataPreferenceResolver {
   resolve(global: MetadataFetchPreferences, libraryOverrides?: FieldPreferenceOverrides | null): MetadataFetchPreferences {
     const defaults = this.getDefaultPreferences();
     const fields = {} as Record<MetadataField, FieldPreference>;
+    const globalFields = this.withSeededAudioCoverRule(global?.fields);
     for (const field of ALL_METADATA_FIELDS) {
-      const chosen = (libraryOverrides && libraryOverrides[field]) ?? global?.fields?.[field];
+      const chosen = (libraryOverrides && libraryOverrides[field]) ?? globalFields?.[field];
       fields[field] = this.normalizeFieldPreference(field, chosen, defaults.fields[field]);
     }
     const options = this.normalizeOptions(global?.options, defaults.options!);
@@ -124,6 +144,32 @@ export class MetadataPreferenceResolver {
     return { fields, options };
   }
 
+  /**
+   * The Audiobook cover rule for a scope that stored only a Cover rule, from before the two were
+   * split. A user who disabled cover fetching or chose fill-missing keeps that for audiobook art,
+   * and a provider list that already names an audiobook source was tuned for audiobooks, so it is
+   * kept too. Anything else starts from the audiobook-first default order.
+   */
+  seedAudioCoverRule(cover: unknown): FieldPreference {
+    const fallback = this.getDefaultPreferences().fields.audioCover;
+    const normalized = this.normalizeFieldPreference('cover', cover, this.getDefaultPreferences().fields.cover);
+    const tunedForAudio = normalized.providers.some((provider) => AUDIOBOOK_ONLY_PROVIDERS.has(provider));
+    return {
+      enabled: normalized.enabled,
+      mergeStrategy: normalized.mergeStrategy,
+      providers: tunedForAudio ? [...normalized.providers] : [...fallback.providers],
+    };
+  }
+
+  withSeededAudioCoverRule<T extends Partial<Record<MetadataField, unknown>>>(fields: T | null | undefined): T | null | undefined {
+    if (!this.isRecord(fields) || fields.audioCover !== undefined || !this.isRecord(fields.cover)) return fields;
+    return { ...fields, audioCover: this.seedAudioCoverRule(fields.cover) };
+  }
+
+  private isRecord(value: unknown): value is Record<string, unknown> {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+  }
+
   private normalizeFieldPreference(field: MetadataField, value: unknown, fallback: FieldPreference): FieldPreference {
     if (typeof value !== 'object' || value === null || Array.isArray(value)) {
       return { ...fallback, providers: [...fallback.providers] };
diff --git a/server/src/modules/metadata-preferences/metadata-preferences.service.test.ts b/server/src/modules/metadata-preferences/metadata-preferences.service.test.ts
index 18b8ece63..414c14019 100644
--- a/server/src/modules/metadata-preferences/metadata-preferences.service.test.ts
+++ b/server/src/modules/metadata-preferences/metadata-preferences.service.test.ts
@@ -10,6 +10,7 @@ function createResolver() {
   return {
     getDefaultPreferences: vi.fn(() => resolver.getDefaultPreferences()),
     resolve: vi.fn((global, overrides) => resolver.resolve(global, overrides)),
+    withSeededAudioCoverRule: vi.fn((fields) => resolver.withSeededAudioCoverRule(fields)),
   } as unknown as Mocked<MetadataPreferenceResolver>;
 }
 
@@ -17,6 +18,11 @@ function createDb() {
   const insertChain = {
     values: vi.fn().mockReturnThis(),
     onConflictDoUpdate: vi.fn().mockResolvedValue(undefined),
+    onConflictDoNothing: vi.fn().mockResolvedValue(undefined),
+  };
+  const selectChain = {
+    from: vi.fn().mockReturnThis(),
+    where: vi.fn().mockResolvedValue([]),
   };
 
   const updateChain = {
@@ -36,8 +42,10 @@ function createDb() {
     },
     insert: vi.fn().mockReturnValue(insertChain),
     update: vi.fn().mockReturnValue(updateChain),
+    select: vi.fn().mockReturnValue(selectChain),
     __insertChain: insertChain,
     __updateChain: updateChain,
+    __selectChain: selectChain,
   };
 }
 
@@ -200,4 +208,39 @@ describe('MetadataPreferencesService', () => {
     db.__updateChain.returning.mockResolvedValueOnce([]);
     await expect(service.resetLibraryToGlobal(50)).rejects.toThrow(NotFoundException);
   });
+
+  describe('seedAudioCoverRules', () => {
+    const cover = { enabled: false, mergeStrategy: 'fillMissing', providers: [MetadataProviderKey.AMAZON] };
+
+    it('writes an Audiobook cover rule into every stored scope that has only a Cover rule, then marks itself done', async () => {
+      db.query.appSettings.findFirst.mockResolvedValueOnce(undefined).mockResolvedValueOnce({
+        key: 'metadata_fetch_preferences',
+        value: JSON.stringify({ fields: { cover }, options: { saveProviderIds: true } }),
+      });
+      db.__selectChain.where.mockResolvedValue([
+        { id: 1, overrides: { cover } },
+        { id: 2, overrides: { cover, audioCover: { enabled: true, mergeStrategy: 'overwrite', providers: [] } } },
+        { id: 3, overrides: { title: { enabled: true, mergeStrategy: 'overwrite', providers: [] } } },
+      ]);
+
+      await expect(service.seedAudioCoverRules()).resolves.toEqual({ global: true, libraries: 1 });
+
+      const [globalWrite, libraryWrite] = db.__updateChain.set.mock.calls.map(([values]) => values as Record<string, unknown>);
+      const storedGlobal = JSON.parse(globalWrite!.value as string);
+      expect(storedGlobal.options).toEqual({ saveProviderIds: true });
+      expect(storedGlobal.fields.audioCover).toMatchObject({ enabled: false, mergeStrategy: 'fillMissing' });
+      expect(libraryWrite!.metadataFetchPreferences).toMatchObject({ cover, audioCover: { enabled: false, mergeStrategy: 'fillMissing' } });
+      expect(db.__updateChain.set).toHaveBeenCalledTimes(2);
+      expect(db.__insertChain.values).toHaveBeenCalledWith(expect.objectContaining({ key: 'metadata_fetch_audio_cover_rule_seeded' }));
+    });
+
+    it('does nothing once marked done, so a removed library override stays removed', async () => {
+      db.query.appSettings.findFirst.mockResolvedValueOnce({ key: 'metadata_fetch_audio_cover_rule_seeded', value: '2026-09-23T00:00:00.000Z' });
+
+      await expect(service.seedAudioCoverRules()).resolves.toBeNull();
+
+      expect(db.select).not.toHaveBeenCalled();
+      expect(db.update).not.toHaveBeenCalled();
+    });
+  });
 });
diff --git a/server/src/modules/metadata-preferences/metadata-preferences.service.ts b/server/src/modules/metadata-preferences/metadata-preferences.service.ts
index 118067981..c309ae506 100644
--- a/server/src/modules/metadata-preferences/metadata-preferences.service.ts
+++ b/server/src/modules/metadata-preferences/metadata-preferences.service.ts
@@ -1,5 +1,5 @@
-import { Inject, Injectable, Logger, NotFoundException } from '@nestjs/common';
-import { eq } from 'drizzle-orm';
+import { Inject, Injectable, Logger, NotFoundException, OnApplicationBootstrap } from '@nestjs/common';
+import { eq, isNotNull } from 'drizzle-orm';
 import { NodePgDatabase } from 'drizzle-orm/node-postgres';
 import { FieldPreferenceOverrides, LibraryMetadataPreferences, MetadataFetchPreferences } from '@bookorbit/types';
 
@@ -11,9 +11,10 @@ import { MetadataPreferenceResolver } from './metadata-preference-resolver';
 type Db = NodePgDatabase<typeof schema>;
 
 const GLOBAL_PREFERENCES_KEY = 'metadata_fetch_preferences';
+const AUDIO_COVER_SEED_KEY = 'metadata_fetch_audio_cover_rule_seeded';
 
 @Injectable()
-export class MetadataPreferencesService {
+export class MetadataPreferencesService implements OnApplicationBootstrap {
   private readonly logger = new Logger(MetadataPreferencesService.name);
 
   constructor(
@@ -21,6 +22,75 @@ export class MetadataPreferencesService {
     private readonly resolver: MetadataPreferenceResolver,
   ) {}
 
+  async onApplicationBootstrap(): Promise<void> {
+    const startedAt = Date.now();
+    try {
+      await this.seedAudioCoverRules();
+    } catch (error) {
+      const errorClass = error instanceof Error ? error.name : 'UnknownError';
+      const errorMessage = sanitizeLogValue(error instanceof Error ? error.message : String(error));
+      this.logger.warn(
+        `[metadata_preferences.audio_cover_seed] [fail] durationMs=${Date.now() - startedAt} errorClass=${errorClass} error="${errorMessage}" - audiobook cover rules not seeded; the Cover rule still seeds them on read`,
+      );
+    }
+  }
+
+  /**
+   * Writes an Audiobook cover rule into every stored scope that has only a Cover rule, once. A
+   * marker keeps it from running again, so a library override the user later removes stays removed.
+   */
+  async seedAudioCoverRules(): Promise<{ global: boolean; libraries: number } | null> {
+    const startedAt = Date.now();
+    const marker = await this.db.query.appSettings.findFirst({ where: eq(schema.appSettings.key, AUDIO_COVER_SEED_KEY) });
+    if (marker) return null;
+
+    let globalSeeded = false;
+    const globalRow = await this.db.query.appSettings.findFirst({ where: eq(schema.appSettings.key, GLOBAL_PREFERENCES_KEY) });
+    if (globalRow) {
+      const parsed = this.parseStoredPreferences(globalRow.value);
+      const seededFields = parsed ? this.resolver.withSeededAudioCoverRule(parsed.fields) : undefined;
+      if (parsed && seededFields && seededFields !== parsed.fields) {
+        await this.db
+          .update(schema.appSettings)
+          .set({ value: JSON.stringify({ ...parsed, fields: seededFields }) })
+          .where(eq(schema.appSettings.key, GLOBAL_PREFERENCES_KEY));
+        globalSeeded = true;
+      }
+    }
+
+    const libraryRows = await this.db
+      .select({ id: schema.libraries.id, overrides: schema.libraries.metadataFetchPreferences })
+      .from(schema.libraries)
+      .where(isNotNull(schema.libraries.metadataFetchPreferences));
+    let librariesSeeded = 0;
+    for (const row of libraryRows) {
+      const seeded = this.resolver.withSeededAudioCoverRule(row.overrides);
+      if (!seeded || seeded === row.overrides) continue;
+      await this.db.update(schema.libraries).set({ metadataFetchPreferences: seeded }).where(eq(schema.libraries.id, row.id));
+      librariesSeeded++;
+    }
+
+    await this.db
+      .insert(schema.appSettings)
+      .values({ key: AUDIO_COVER_SEED_KEY, value: new Date().toISOString() })
+      .onConflictDoNothing({ target: schema.appSettings.key });
+    this.logger.log(
+      `[metadata_preferences.audio_cover_seed] [end] globalSeeded=${globalSeeded} librariesSeeded=${librariesSeeded} durationMs=${Date.now() - startedAt} - audiobook cover rules seeded from cover rules`,
+    );
+    return { global: globalSeeded, libraries: librariesSeeded };
+  }
+
+  private parseStoredPreferences(value: string): (MetadataFetchPreferences & Record<string, unknown>) | null {
+    try {
+      const parsed = JSON.parse(value) as unknown;
+      return typeof parsed === 'object' && parsed !== null && !Array.isArray(parsed)
+        ? (parsed as MetadataFetchPreferences & Record<string, unknown>)
+        : null;
+    } catch {
+      return null;
+    }
+  }
+
   async getGlobal(): Promise<MetadataFetchPreferences> {
     const startedAt = Date.now();
     const row = await this.db.query.appSettings.findFirst({
diff --git a/server/src/modules/metadata/cover-slot-reconciler.service.test.ts b/server/src/modules/metadata/cover-slot-reconciler.service.test.ts
new file mode 100644
index 000000000..e7a915b0a
--- /dev/null
+++ b/server/src/modules/metadata/cover-slot-reconciler.service.test.ts
@@ -0,0 +1,466 @@
+import { ZipArchive } from 'archiver';
+import { execFile as execFileCallback } from 'child_process';
+import { createWriteStream } from 'fs';
+import { chmod, copyFile, mkdir, mkdtemp, readdir, rm, writeFile } from 'fs/promises';
+import { createRequire } from 'module';
+import { tmpdir } from 'os';
+import { join } from 'path';
+import sharp from 'sharp';
+import { promisify } from 'util';
+
+import type { CoverMedia, CoverMedium } from '@bookorbit/types';
+
+import type { BookCoverContext, BookCoverSlotRow, BookCoverSourceFile } from '../book-cover-store/book-cover-store.repository';
+import type { CoverSlotReconciler as CoverSlotReconcilerType } from './cover-slot-reconciler.service';
+
+const execFile = promisify(execFileCallback);
+const requireInstaller = createRequire(__filename);
+
+type SourceFile = Omit<BookCoverSourceFile, 'id'> & { id?: number };
+type MemoryBook = {
+  libraryId: number;
+  coverAspectRatio: string;
+  primaryFileId: number | null;
+  lockedFields: string[];
+  coverSource: 'extracted' | 'custom' | null;
+  coverUpdatedAt: Date | null;
+  formatPriority: string[];
+  files: BookCoverSourceFile[];
+};
+
+/** Holds the rows the store would keep in Postgres, so the real store and real extractors can run. */
+class MemoryCoverRepository {
+  readonly books = new Map<number, MemoryBook>();
+  readonly slots = new Map<string, BookCoverSlotRow>();
+  mutations = 0;
+  private nextFileId = 1;
+  private readonly helpers: typeof import('../book-cover-store/book-cover-store.repository');
+
+  constructor(helpers: typeof import('../book-cover-store/book-cover-store.repository')) {
+    this.helpers = helpers;
+  }
+
+  addBook(bookId: number, files: SourceFile[], options: Partial<MemoryBook> & { primary?: string } = {}): void {
+    const withIds = files.map((file) => ({ ...file, id: file.id ?? this.nextFileId++ }));
+    const primary = withIds.find((file) => file.absolutePath.endsWith(options.primary ?? '\0')) ?? withIds.find((file) => file.role === 'content');
+    this.books.set(bookId, {
+      libraryId: 1,
+      coverAspectRatio: '2/3',
+      primaryFileId: primary?.id ?? null,
+      lockedFields: [],
+      coverSource: null,
+      coverUpdatedAt: null,
+      formatPriority: ['epub', 'kepub', 'pdf', 'm4b', 'mp3'],
+      ...options,
+      files: withIds,
+    });
+  }
+
+  setFiles(bookId: number, files: SourceFile[]): void {
+    const book = this.books.get(bookId)!;
+    book.files = files.map((file) => ({ ...file, id: file.id ?? this.nextFileId++ }));
+  }
+
+  slot(bookId: number, medium: CoverMedium): BookCoverSlotRow | undefined {
+    return this.slots.get(`${bookId}:${medium}`);
+  }
+
+  putSlot(bookId: number, medium: CoverMedium, row: Partial<BookCoverSlotRow> = {}): void {
+    this.slots.set(`${bookId}:${medium}`, {
+      bookId,
+      medium,
+      source: 'extracted',
+      origin: 'embedded',
+      width: 10,
+      height: 10,
+      updatedAt: new Date('2026-01-01T00:00:00.000Z'),
+      dormantSince: null,
+      ...row,
+    });
+  }
+
+  findContext(bookId: number): Promise<BookCoverContext | null> {
+    const book = this.books.get(bookId);
+    if (!book) return Promise.resolve(null);
+    return Promise.resolve({
+      bookId,
+      libraryId: book.libraryId,
+      coverAspectRatio: book.coverAspectRatio,
+      primaryFileId: book.primaryFileId,
+      coverSource: book.coverSource,
+      coverUpdatedAt: book.coverUpdatedAt,
+      metadataUpdatedAt: null,
+      lockedFields: [...book.lockedFields],
+      media: this.media(book),
+      files: book.files.map(({ id, format, role, mediaOverlayAvailable }) => ({ id, format, role, mediaOverlayAvailable })),
+      slots: this.slotsOf(bookId),
+    });
+  }
+
+  findCoverSources(bookId: number) {
+    const book = this.books.get(bookId);
+    return Promise.resolve(book ? { formatPriority: book.formatPriority, files: book.files } : null);
+  }
+
+  slotsFor(bookIds: number[]): Promise<Map<number, BookCoverSlotRow[]>> {
+    return Promise.resolve(new Map(bookIds.map((bookId) => [bookId, this.slotsOf(bookId)])));
+  }
+
+  applySlotMutation(
+    bookId: number,
+    medium: CoverMedium,
+    media: CoverMedia,
+    mutation: { kind: 'upsert'; row: Omit<BookCoverSlotRow, 'bookId' | 'medium'> } | { kind: 'delete' },
+    options: { servedBytesChanged: boolean; updatedAt: Date; beforeMedia?: CoverMedia },
+  ) {
+    this.mutations++;
+    const before = this.slotsOf(bookId);
+    if (mutation.kind === 'delete') this.slots.delete(`${bookId}:${medium}`);
+    else this.slots.set(`${bookId}:${medium}`, { bookId, medium, ...mutation.row });
+    const after = this.slotsOf(bookId);
+    const book = this.books.get(bookId)!;
+    const koboCoverChanged = this.helpers.didKoboCoverChange(before, after, media, medium, options.servedBytesChanged, options.beforeMedia);
+    if (koboCoverChanged) book.coverUpdatedAt = options.updatedAt;
+    this.recomputeSummary(bookId, media);
+    return Promise.resolve({ libraryId: book.libraryId, koboCoverChanged });
+  }
+
+  importSlotWithoutStamp(bookId: number, medium: CoverMedium, row: Omit<BookCoverSlotRow, 'bookId' | 'medium'>) {
+    if (!this.slot(bookId, medium)) this.slots.set(`${bookId}:${medium}`, { bookId, medium, ...row });
+    this.recomputeSummary(bookId, this.media(this.books.get(bookId)!));
+    return Promise.resolve(1);
+  }
+
+  copyCoverLockToAudio(bookId: number): Promise<void> {
+    const book = this.books.get(bookId)!;
+    if (book.lockedFields.includes('cover') && !book.lockedFields.includes('audioCover')) book.lockedFields.push('audioCover');
+    return Promise.resolve();
+  }
+
+  listBookIdsWithExpiredDormantSlots(_libraryId: number, dormantBefore: Date): Promise<number[]> {
+    return Promise.resolve(
+      [...this.slots.values()]
+        .filter((slot) => slot.source === 'extracted' && slot.dormantSince !== null && slot.dormantSince <= dormantBefore)
+        .map((slot) => slot.bookId),
+    );
+  }
+
+  private media(book: MemoryBook): CoverMedia {
+    return this.helpers.getCoverMediaFromDatabaseFiles(book.files);
+  }
+
+  private slotsOf(bookId: number): BookCoverSlotRow[] {
+    return [...this.slots.values()].filter((slot) => slot.bookId === bookId);
+  }
+
+  private recomputeSummary(bookId: number, media: CoverMedia): void {
+    const book = this.books.get(bookId)!;
+    const active = this.slotsOf(bookId).filter((slot) => slot.dormantSince === null && (slot.medium === 'ebook' ? media.hasEbook : media.hasAudio));
+    book.coverSource = active.some((slot) => slot.source === 'custom') ? 'custom' : active.length > 0 ? 'extracted' : null;
+  }
+}
+
+describe('CoverSlotReconciler on real files', () => {
+  let root: string;
+  let dataPath: string;
+  let ffmpegPath: string;
+  let repository: MemoryCoverRepository;
+  let reconciler: CoverSlotReconcilerType;
+  let nextBookId = 1;
+
+  beforeAll(async () => {
+    root = await mkdtemp(join(tmpdir(), 'bookorbit-cover-reconcile-'));
+    ffmpegPath = (requireInstaller('@ffmpeg-installer/ffmpeg') as { path: string }).path;
+    const ffprobePath = join(root, 'ffprobe');
+    await copyFile((requireInstaller('@ffprobe-installer/ffprobe') as { path: string }).path, ffprobePath);
+    await chmod(ffprobePath, 0o755);
+    vi.stubEnv('FFMPEG_PATH', ffmpegPath);
+    vi.stubEnv('FFPROBE_PATH', ffprobePath);
+    vi.resetModules();
+  });
+
+  afterAll(async () => {
+    vi.unstubAllEnvs();
+    await rm(root, { recursive: true, force: true });
+  });
+
+  beforeEach(async () => {
+    dataPath = await mkdtemp(join(root, 'data-'));
+    const helpers = await import('../book-cover-store/book-cover-store.repository');
+    const { BookCoverStore } = await import('../book-cover-store/book-cover-store.service');
+    const { MetadataExtractionService } = await import('./metadata-extraction.service');
+    const { CoverSlotReconciler } = await import('./cover-slot-reconciler.service');
+    repository = new MemoryCoverRepository(helpers);
+    const store = new BookCoverStore({ getOrThrow: () => dataPath } as never, repository as never, { emitChanged: vi.fn() } as never);
+    reconciler = new CoverSlotReconciler(store, new MetadataExtractionService());
+  });
+
+  async function image(width: number, height: number, color = { r: 30, g: 90, b: 160 }): Promise<Buffer> {
+    return sharp({ create: { width, height, channels: 3, background: color } })
+      .jpeg()
+      .toBuffer();
+  }
+
+  async function epub(path: string, cover: Buffer | null): Promise<void> {
+    const manifestCover = cover ? '<item id="cover" href="cover.jpg" media-type="image/jpeg" properties="cover-image" />' : '';
+    const opf = `<?xml version="1.0"?><package version="3.0" unique-identifier="uid" xmlns="http://www.idpf.org/2007/opf">
+      <metadata xmlns:dc="http://purl.org/dc/elements/1.1/"><dc:identifier id="uid">urn:test</dc:identifier><dc:title>T</dc:title><dc:language>en</dc:language></metadata>
+      <manifest>${manifestCover}<item id="c1" href="c1.xhtml" media-type="application/xhtml+xml" /></manifest>
+      <spine><itemref idref="c1" /></spine></package>`;
+    const output = createWriteStream(path);
+    const archive = new ZipArchive({ zlib: { level: 6 } });
+    await new Promise<void>((resolve, reject) => {
+      output.on('close', resolve);
+      archive.on('error', reject);
+      archive.pipe(output);
+      archive.append(Buffer.from('application/epub+zip'), { name: 'mimetype', store: true });
+      archive.append(
+        Buffer.from(
+          '<?xml version="1.0"?><container xmlns="urn:oasis:names:tc:opendocument:xmlns:container"><rootfiles><rootfile full-path="OPS/content.opf" media-type="application/oebps-package+xml" /></rootfiles></container>',
+        ),
+        { name: 'META-INF/container.xml' },
+      );
+      archive.append(Buffer.from(opf), { name: 'OPS/content.opf' });
+      archive.append(Buffer.from('<html xmlns="http://www.w3.org/1999/xhtml"><body><p>x</p></body></html>'), { name: 'OPS/c1.xhtml' });
+      if (cover) archive.append(cover, { name: 'OPS/cover.jpg' });
+      void archive.finalize();
+    });
+  }
+
+  async function audio(path: string, art: { width: number; height: number } | null): Promise<void> {
+    const args = ['-v', 'error', '-y', '-f', 'lavfi', '-i', 'sine=frequency=440:duration=0.2'];
+    if (art) {
+      const artPath = `${path}.art.jpg`;
+      await writeFile(artPath, await image(art.width, art.height, { r: 200, g: 40, b: 40 }));
+      args.push('-i', artPath, '-map', '0:a', '-map', '1:v', '-c:v', 'mjpeg', '-disposition:v', 'attached_pic');
+    }
+    args.push('-c:a', path.endsWith('.mp3') ? 'libmp3lame' : 'aac', path);
+    await execFile(ffmpegPath, args);
+  }
+
+  async function folder(files: Record<string, 'epub' | 'epub-no-cover' | 'kepub' | 'm4b' | 'm4b-no-art' | 'mp3' | 'square' | 'portrait'>) {
+    const dir = await mkdtemp(join(root, 'book-'));
+    const sources: SourceFile[] = [];
+    for (const [name, kind] of Object.entries(files)) {
+      const path = join(dir, name);
+      if (kind === 'epub' || kind === 'kepub') await epub(path, await image(200, 300));
+      else if (kind === 'epub-no-cover') await epub(path, null);
+      else if (kind === 'm4b') await audio(path, { width: 300, height: 300 });
+      else if (kind === 'm4b-no-art' || kind === 'mp3') await audio(path, null);
+      else
+        await writeFile(path, kind === 'square' ? await image(500, 500, { r: 10, g: 200, b: 10 }) : await image(400, 600, { r: 10, g: 10, b: 200 }));
+      const format = name.split('.').pop()!.toLowerCase();
+      const role = kind === 'square' || kind === 'portrait' ? 'cover' : 'content';
+      sources.push({ absolutePath: path, format, role, sizeBytes: 1, mediaOverlayAvailable: false });
+    }
+    return sources;
+  }
+
+  function withOverlay(files: SourceFile[]): SourceFile[] {
+    return files.map((file) => (file.format === 'epub' ? { ...file, mediaOverlayAvailable: true } : file));
+  }
+
+  function shapeOf(bookId: number, medium: CoverMedium): string | null {
+    const slot = repository.slot(bookId, medium);
+    if (!slot) return null;
+    return `${slot.origin}:${slot.width}x${slot.height}${slot.dormantSince ? ':dormant' : ''}`;
+  }
+
+  it('fills both slots of an EPUB and M4B folder from each medium’s own embedded art', async () => {
+    const bookId = nextBookId++;
+    repository.addBook(bookId, await folder({ 'book.epub': 'epub', 'book.m4b': 'm4b' }));
+
+    const result = await reconciler.reconcile(bookId);
+
+    expect(result.filled.sort()).toEqual(['audio', 'ebook']);
+    expect(shapeOf(bookId, 'ebook')).toBe('embedded:200x300');
+    expect(shapeOf(bookId, 'audio')).toBe('embedded:300x300');
+    expect(await readdir(join(dataPath, 'covers', String(bookId), 'audio'))).toEqual(expect.arrayContaining(['thumbnail.jpg']));
+  });
+
+  it('fills the ebook slot of an M4B-primary book and leaves the audio slot the scan already wrote', async () => {
+    const bookId = nextBookId++;
+    repository.addBook(bookId, await folder({ 'book.m4b': 'm4b', 'book.epub': 'epub' }), { primary: 'book.m4b' });
+    repository.putSlot(bookId, 'audio', { width: 300, height: 300 });
+    const before = repository.slot(bookId, 'audio');
+
+    await reconciler.reconcile(bookId, { filesChanged: true });
+
+    expect(shapeOf(bookId, 'ebook')).toBe('embedded:200x300');
+    expect(repository.slot(bookId, 'audio')).toEqual(before);
+  });
+
+  it('reads a KEPUB as the ebook source', async () => {
+    const bookId = nextBookId++;
+    repository.addBook(bookId, await folder({ 'book.kepub': 'kepub', 'book.m4b': 'm4b' }));
+
+    await reconciler.reconcile(bookId);
+
+    expect(shapeOf(bookId, 'ebook')).toBe('embedded:200x300');
+    expect(shapeOf(bookId, 'audio')).toBe('embedded:300x300');
+  });
+
+  it('falls back to a square folder image for multi-track mp3 with no embedded art', async () => {
+    const bookId = nextBookId++;
+    repository.addBook(bookId, await folder({ 'book.epub': 'epub', '01.mp3': 'mp3', '02.mp3': 'mp3', 'folder.jpg': 'square' }));
+
+    await reconciler.reconcile(bookId);
+
+    expect(shapeOf(bookId, 'ebook')).toBe('embedded:200x300');
+    expect(shapeOf(bookId, 'audio')).toBe('folder_image:500x500');
+  });
+
+  it('never puts a portrait folder image into the audio slot of a book with both media', async () => {
+    const bookId = nextBookId++;
+    repository.addBook(bookId, await folder({ 'book.epub': 'epub-no-cover', 'book.m4b': 'm4b-no-art', 'cover.jpg': 'portrait' }));
+
+    await reconciler.reconcile(bookId);
+
+    expect(shapeOf(bookId, 'ebook')).toBe('folder_image:400x600');
+    expect(shapeOf(bookId, 'audio')).toBeNull();
+  });
+
+  it('fills a single-medium book from its folder image whatever the shape', async () => {
+    const bookId = nextBookId++;
+    repository.addBook(bookId, await folder({ '01.mp3': 'mp3', 'cover.jpg': 'portrait' }));
+
+    await reconciler.reconcile(bookId);
+
+    expect(shapeOf(bookId, 'audio')).toBe('folder_image:400x600');
+  });
+
+  it('keeps the audio slot of a read-along EPUB empty, because the EPUB art is the book cover', async () => {
+    const bookId = nextBookId++;
+    repository.addBook(bookId, withOverlay(await folder({ 'book.epub': 'epub', 'cover.jpg': 'portrait' })));
+
+    await reconciler.reconcile(bookId);
+
+    expect(shapeOf(bookId, 'ebook')).toBe('embedded:200x300');
+    expect(shapeOf(bookId, 'audio')).toBeNull();
+  });
+
+  it('fills the audio slot of a read-along EPUB from a square folder image', async () => {
+    const bookId = nextBookId++;
+    repository.addBook(bookId, withOverlay(await folder({ 'book.epub': 'epub', 'cover.jpg': 'square' })));
+
+    await reconciler.reconcile(bookId);
+
+    expect(shapeOf(bookId, 'ebook')).toBe('embedded:200x300');
+    expect(shapeOf(bookId, 'audio')).toBe('folder_image:500x500');
+  });
+
+  it('puts the audio slot to sleep when an EPUB loses its read-along audio, and wakes it when it returns', async () => {
+    const bookId = nextBookId++;
+    const synced = withOverlay(await folder({ 'book.epub': 'epub', 'cover.jpg': 'square' }));
+    repository.addBook(bookId, synced);
+    await reconciler.reconcile(bookId);
+
+    repository.setFiles(
+      bookId,
+      synced.map((file) => ({ ...file, mediaOverlayAvailable: false })),
+    );
+    await reconciler.reconcile(bookId, { filesChanged: true });
+    expect(shapeOf(bookId, 'audio')).toBe('folder_image:500x500:dormant');
+    expect(repository.books.get(bookId)!.coverSource).toBe('extracted');
+
+    repository.setFiles(bookId, synced);
+    await reconciler.reconcile(bookId, { filesChanged: true });
+    expect(shapeOf(bookId, 'audio')).toBe('folder_image:500x500');
+  });
+
+  it('keeps a custom audiobook cover through a replace, where the M4B is unlinked and added again', async () => {
+    const bookId = nextBookId++;
+    const files = await folder({ 'book.epub': 'epub', 'book.m4b': 'm4b' });
+    repository.addBook(bookId, files);
+    await reconciler.reconcile(bookId);
+    repository.putSlot(bookId, 'audio', { source: 'custom', origin: 'upload', width: 640, height: 640 });
+    const audioDir = join(dataPath, 'covers', String(bookId), 'audio');
+    await writeFile(join(audioDir, 'cover_custom.jpg'), await image(640, 640));
+
+    repository.setFiles(
+      bookId,
+      files.filter((file) => file.format !== 'm4b'),
+    );
+    await reconciler.reconcile(bookId, { filesChanged: true });
+    expect(repository.slot(bookId, 'audio')).toMatchObject({ source: 'custom', dormantSince: expect.any(Date) });
+
+    repository.setFiles(bookId, files);
+    await reconciler.reconcile(bookId, { filesChanged: true });
+    expect(repository.slot(bookId, 'audio')).toMatchObject({ source: 'custom', origin: 'upload', width: 640, dormantSince: null });
+    expect(await readdir(audioDir)).toContain('cover_custom.jpg');
+  });
+
+  it('prunes an extracted slot dormant for a day but keeps a dormant custom one', async () => {
+    const bookId = nextBookId++;
+    const files = await folder({ 'book.epub': 'epub' });
+    repository.addBook(bookId, files);
+    const longAgo = new Date(Date.now() - 25 * 60 * 60 * 1000);
+    repository.putSlot(bookId, 'audio', { dormantSince: longAgo });
+    await mkdir(join(dataPath, 'covers', String(bookId), 'audio'), { recursive: true });
+
+    await reconciler.reconcile(bookId);
+    expect(repository.slot(bookId, 'audio')).toBeUndefined();
+    await expect(readdir(join(dataPath, 'covers', String(bookId), 'audio'))).rejects.toThrow();
+
+    repository.putSlot(bookId, 'audio', { source: 'custom', dormantSince: longAgo });
+    await reconciler.reconcile(bookId);
+    expect(repository.slot(bookId, 'audio')).toMatchObject({ source: 'custom' });
+  });
+
+  it('does not fill a locked slot', async () => {
+    const bookId = nextBookId++;
+    repository.addBook(bookId, await folder({ 'book.epub': 'epub', 'book.m4b': 'm4b' }), { lockedFields: ['audioCover'] });
+
+    await reconciler.reconcile(bookId);
+
+    expect(shapeOf(bookId, 'ebook')).toBe('embedded:200x300');
+    expect(shapeOf(bookId, 'audio')).toBeNull();
+  });
+
+  it('replaces folder-image art with embedded art that appears later, and rewrites nothing when nothing changed', async () => {
+    const bookId = nextBookId++;
+    const files = await folder({ '01.mp3': 'mp3', 'folder.jpg': 'square' });
+    repository.addBook(bookId, files);
+    await reconciler.reconcile(bookId);
+    const mutations = repository.mutations;
+
+    await reconciler.reconcile(bookId, { filesChanged: true });
+    expect(repository.mutations).toBe(mutations);
+
+    const tagged = files.map((file) => (file.format === 'mp3' ? { ...file, absolutePath: `${file.absolutePath}.m4b`, format: 'm4b' } : file));
+    await audio(tagged[0]!.absolutePath, { width: 300, height: 300 });
+    repository.setFiles(bookId, tagged);
+    await reconciler.reconcile(bookId, { filesChanged: true });
+    expect(shapeOf(bookId, 'audio')).toBe('embedded:300x300');
+  });
+
+  it('converts a legacy root cover before filling, so the old art is not stranded', async () => {
+    const bookId = nextBookId++;
+    repository.addBook(bookId, await folder({ 'book.epub': 'epub', 'book.m4b': 'm4b' }), { coverSource: 'custom' });
+    const legacyDir = join(dataPath, 'covers', String(bookId));
+    await mkdir(legacyDir, { recursive: true });
+    await writeFile(join(legacyDir, 'cover_custom.jpg'), await image(700, 700));
+
+    await reconciler.reconcile(bookId);
+
+    expect(repository.slot(bookId, 'audio')).toMatchObject({ source: 'custom', origin: 'legacy' });
+    expect(shapeOf(bookId, 'ebook')).toBe('embedded:200x300');
+    expect(await readdir(legacyDir)).toEqual(expect.not.arrayContaining(['cover_custom.jpg']));
+  });
+
+  it('runs a book once per request, and again when a request lands mid-run', async () => {
+    const bookId = nextBookId++;
+    repository.addBook(bookId, await folder({ 'book.epub': 'epub' }));
+    const spy = vi.spyOn(reconciler, 'reconcile');
+
+    await reconciler.enqueue([bookId, bookId]);
+    expect(spy).toHaveBeenCalledTimes(1);
+
+    const running = reconciler.enqueue([bookId]);
+    const rerun = reconciler.enqueue([bookId], { filesChanged: true });
+    const absorbed = reconciler.enqueue([bookId]);
+    await Promise.all([running, rerun, absorbed]);
+    expect(spy).toHaveBeenCalledTimes(3);
+    expect(spy).toHaveBeenLastCalledWith(bookId, { filesChanged: true, backfill: false });
+  });
+});
diff --git a/server/src/modules/metadata/cover-slot-reconciler.service.ts b/server/src/modules/metadata/cover-slot-reconciler.service.ts
new file mode 100644
index 000000000..dca31620b
--- /dev/null
+++ b/server/src/modules/metadata/cover-slot-reconciler.service.ts
@@ -0,0 +1,268 @@
+import { Injectable, Logger, OnModuleDestroy } from '@nestjs/common';
+import { COVER_MEDIA, isAudioFormat, type CoverMedium } from '@bookorbit/types';
+import { readFile, stat } from 'fs/promises';
+import { basename } from 'path';
+import sharp from 'sharp';
+
+import { sanitizeLogValue } from '../../common/utils/log-sanitize.utils';
+import type { BookCoverContext, BookCoverSourceFile } from '../book-cover-store/book-cover-store.repository';
+import { BookCoverStore } from '../book-cover-store/book-cover-store.service';
+import { assignFolderImages, type FolderImageCandidate } from '../book-cover-store/cover-shape';
+import { hasAudioFiles, selectEmbeddedCoverSources, selectFolderImages } from '../book-cover-store/cover-sources';
+import { MetadataExtractionService } from './metadata-extraction.service';
+
+const RECONCILE_CONCURRENCY = 2;
+const DORMANT_PRUNE_AFTER_MS = 24 * 60 * 60 * 1000;
+const EXPIRED_DORMANT_BATCH_SIZE = 500;
+const MAX_FOLDER_IMAGES = 8;
+const MAX_FOLDER_IMAGE_BYTES = 32 * 1024 * 1024;
+
+export type CoverReconcileOptions = {
+  /** The book's files changed, so a slot filled from a folder image is resolved again. */
+  filesChanged?: boolean;
+  /** Upgrade writes: `books.updated_at` stays put and the caller batches the change events. */
+  backfill?: boolean;
+};
+
+export type CoverReconcileResult = {
+  libraryId: number | null;
+  changed: boolean;
+  filled: CoverMedium[];
+};
+
+type QueueEntry = {
+  options: CoverReconcileOptions;
+  done: Promise<void>;
+  resolve: () => void;
+};
+
+type LoadedFolderImage = FolderImageCandidate & { bytes: Buffer };
+
+/**
+ * Makes a book's cover slots match its files. Every path that changes a book's file set enqueues
+ * the book here: slots of media that left go dormant, slots of media that returned come back, and
+ * empty slots fill from that medium's embedded art, then from folder images.
+ */
+@Injectable()
+export class CoverSlotReconciler implements OnModuleDestroy {
+  private readonly logger = new Logger(CoverSlotReconciler.name);
+  private readonly queued = new Map<number, QueueEntry>();
+  private readonly order: number[] = [];
+  private readonly running = new Set<number>();
+  private active = 0;
+  private stopped = false;
+
+  constructor(
+    private readonly store: BookCoverStore,
+    private readonly extraction: MetadataExtractionService,
+  ) {}
+
+  onModuleDestroy(): void {
+    this.stopped = true;
+    this.order.length = 0;
+    for (const entry of this.queued.values()) entry.resolve();
+    this.queued.clear();
+  }
+
+  /**
+   * Schedules each book once. A book already waiting absorbs the new request; a book already
+   * running is queued again, so a change that lands mid-run is never lost. Resolves when every
+   * listed book's run has finished; failures are logged, never thrown.
+   */
+  enqueue(bookIds: Iterable<number>, options: CoverReconcileOptions = {}): Promise<void> {
+    if (this.stopped) return Promise.resolve();
+    const waits: Promise<void>[] = [];
+    for (const bookId of new Set(bookIds)) {
+      const existing = this.queued.get(bookId);
+      if (existing) {
+        existing.options = {
+          filesChanged: existing.options.filesChanged === true || options.filesChanged === true,
+          backfill: existing.options.backfill === true && options.backfill === true,
+        };
+        waits.push(existing.done);
+        continue;
+      }
+      let resolve!: () => void;
+      const done = new Promise<void>((settle) => {
+        resolve = settle;
+      });
+      this.queued.set(bookId, { options, done, resolve });
+      this.order.push(bookId);
+      waits.push(done);
+    }
+    this.drain();
+    return Promise.all(waits).then(() => undefined);
+  }
+
+  async reconcile(bookId: number, options: CoverReconcileOptions = {}): Promise<CoverReconcileResult> {
+    const input = await this.store.reconcileInput(bookId);
+    if (!input) return { libraryId: null, changed: false, filled: [] };
+    const { context, sources } = input;
+    const changed = await this.settleDormancy(context, options);
+    const needed = COVER_MEDIA.filter((medium) => this.needsFill(context, medium, options.filesChanged === true));
+    const filled = needed.length > 0 ? await this.fill(context, sources.files, sources.formatPriority, needed, options) : [];
+    return { libraryId: context.libraryId, changed: changed || filled.length > 0, filled };
+  }
+
+  /** Lets a later reconcile prune extracted slots that stayed dormant for a day. */
+  async enqueueExpiredDormant(libraryId: number): Promise<void> {
+    const cutoff = new Date(Date.now() - DORMANT_PRUNE_AFTER_MS);
+    const bookIds = await this.store.bookIdsWithExpiredDormantSlots(libraryId, cutoff, EXPIRED_DORMANT_BATCH_SIZE);
+    if (bookIds.length > 0) await this.enqueue(bookIds);
+  }
+
+  private drain(): void {
+    while (!this.stopped && this.active < RECONCILE_CONCURRENCY) {
+      const index = this.order.findIndex((bookId) => !this.running.has(bookId));
+      if (index === -1) return;
+      const [bookId] = this.order.splice(index, 1) as [number];
+      const entry = this.queued.get(bookId)!;
+      this.queued.delete(bookId);
+      this.running.add(bookId);
+      this.active++;
+      void this.reconcileSafely(bookId, entry.options).finally(() => {
+        this.active--;
+        this.running.delete(bookId);
+        entry.resolve();
+        this.drain();
+      });
+    }
+  }
+
+  private async reconcileSafely(bookId: number, options: CoverReconcileOptions): Promise<void> {
+    const startedAt = Date.now();
+    try {
+      const result = await this.reconcile(bookId, options);
+      if (result.changed) {
+        this.logger.debug(
+          `[cover.slot_reconcile] [end] bookId=${bookId} filled=${result.filled.join(',') || 'none'} durationMs=${Date.now() - startedAt} - cover slots reconciled`,
+        );
+      }
+    } catch (error) {
+      const errorClass = error instanceof Error ? error.name : 'Error';
+      const message = sanitizeLogValue(error instanceof Error ? error.message : String(error));
+      this.logger.warn(
+        `[cover.slot_reconcile] [fail] bookId=${bookId} durationMs=${Date.now() - startedAt} errorClass=${errorClass} error="${message}" - cover slot reconcile failed`,
+      );
+    }
+  }
+
+  private async settleDormancy(context: BookCoverContext, options: CoverReconcileOptions): Promise<boolean> {
+    let changed = false;
+    const dormantBefore = new Date(Date.now() - DORMANT_PRUNE_AFTER_MS);
+    for (const slot of context.slots) {
+      const medium = slot.medium as CoverMedium;
+      if (this.isPresent(context, medium)) {
+        if (slot.dormantSince !== null) changed = (await this.store.reactivate(context.bookId, medium, options)) || changed;
+      } else if (slot.dormantSince === null) {
+        changed = (await this.store.markDormant(context.bookId, medium, options)) || changed;
+      } else {
+        changed = (await this.store.pruneDormant(context.bookId, medium, dormantBefore)) || changed;
+      }
+    }
+    return changed;
+  }
+
+  private needsFill(context: BookCoverContext, medium: CoverMedium, filesChanged: boolean): boolean {
+    if (!this.isPresent(context, medium)) return false;
+    if (context.lockedFields.includes(medium === 'ebook' ? 'cover' : 'audioCover')) return false;
+    const slot = context.slots.find((candidate) => candidate.medium === medium);
+    if (!slot) return true;
+    return filesChanged && slot.source === 'extracted' && slot.origin === 'folder_image';
+  }
+
+  private async fill(
+    context: BookCoverContext,
+    files: readonly BookCoverSourceFile[],
+    formatPriority: readonly string[],
+    needed: readonly CoverMedium[],
+    options: CoverReconcileOptions,
+  ): Promise<CoverMedium[]> {
+    const filled: CoverMedium[] = [];
+    const withoutEmbeddedArt: CoverMedium[] = [];
+    const embeddedSources = selectEmbeddedCoverSources(files, formatPriority);
+
+    for (const medium of needed) {
+      const source = embeddedSources[medium];
+      const bytes = source ? await this.extractEmbedded(context.bookId, source) : null;
+      if (!bytes) {
+        withoutEmbeddedArt.push(medium);
+        continue;
+      }
+      if (await this.save(context.bookId, medium, bytes, 'embedded', options)) filled.push(medium);
+    }
+
+    if (withoutEmbeddedArt.length === 0) return filled;
+    const images = await this.loadFolderImages(context.bookId, files);
+    const assignments = assignFolderImages(images, withoutEmbeddedArt, {
+      bothMedia: context.media.hasEbook && context.media.hasAudio,
+      squareOnlyAudio: !hasAudioFiles(files),
+      primaryMedium: this.primaryMedium(context, files),
+    });
+    for (const [medium, image] of assignments) {
+      const loaded = images.find((candidate) => candidate.path === image.path)!;
+      if (await this.save(context.bookId, medium, loaded.bytes, 'folder_image', options)) filled.push(medium);
+    }
+    return filled;
+  }
+
+  private async save(
+    bookId: number,
+    medium: CoverMedium,
+    bytes: Buffer,
+    origin: 'embedded' | 'folder_image',
+    options: CoverReconcileOptions,
+  ): Promise<boolean> {
+    try {
+      return await this.store.saveExtracted(bookId, medium, bytes, {
+        origin,
+        overwrite: false,
+        backfill: options.backfill,
+        fill: { replaceOrigins: ['folder_image'] },
+        skipIfUnchanged: true,
+      });
+    } catch (error) {
+      this.logger.warn(
+        `[cover.slot_reconcile] [fail] bookId=${bookId} medium=${medium} origin=${origin} errorClass=${error instanceof Error ? error.name : 'Error'} error="${sanitizeLogValue(error instanceof Error ? error.message : String(error))}" - cover slot fill skipped`,
+      );
+      return false;
+    }
+  }
+
+  private async extractEmbedded(bookId: number, file: BookCoverSourceFile): Promise<Buffer | null> {
+    try {
+      return await this.extraction.extractEmbeddedCover(file.absolutePath, file.format!);
+    } catch (error) {
+      this.logger.debug(
+        `[cover.slot_reconcile] [fail] bookId=${bookId} format=${file.format} path="${sanitizeLogValue(file.absolutePath)}" errorClass=${error instanceof Error ? error.name : 'Error'} - embedded cover unreadable`,
+      );
+      return null;
+    }
+  }
+
+  private async loadFolderImages(bookId: number, files: readonly BookCoverSourceFile[]): Promise<LoadedFolderImage[]> {
+    const loaded: LoadedFolderImage[] = [];
+    for (const file of selectFolderImages(files).slice(0, MAX_FOLDER_IMAGES)) {
+      try {
+        const { size } = await stat(file.absolutePath);
+        if (size === 0 || size > MAX_FOLDER_IMAGE_BYTES) continue;
+        const bytes = await readFile(file.absolutePath);
+        const { width, height } = await sharp(bytes, { failOn: 'error' }).metadata();
+        if (!width || !height) continue;
+        loaded.push({ path: file.absolutePath, name: basename(file.absolutePath), width, height, bytes });
+      } catch {
+        this.logger.debug(`[cover.slot_reconcile] [fail] bookId=${bookId} path="${sanitizeLogValue(file.absolutePath)}" - folder image unreadable`);
+      }
+    }
+    return loaded;
+  }
+
+  private isPresent(context: BookCoverContext, medium: CoverMedium): boolean {
+    return medium === 'ebook' ? context.media.hasEbook : context.media.hasAudio;
+  }
+
+  private primaryMedium(context: BookCoverContext, files: readonly BookCoverSourceFile[]): CoverMedium {
+    const primary = files.find((file) => file.id === context.primaryFileId);
+    return primary?.format && isAudioFormat(primary.format.toLowerCase()) ? 'audio' : 'ebook';
+  }
+}
diff --git a/server/src/modules/metadata/extractors/audio.extractor.ts b/server/src/modules/metadata/extractors/audio.extractor.ts
index 2750cc5b5..bf367003e 100644
--- a/server/src/modules/metadata/extractors/audio.extractor.ts
+++ b/server/src/modules/metadata/extractors/audio.extractor.ts
@@ -174,6 +174,19 @@ function mapChapters(chapters: FfprobeChapter[]): AudiobookChapter[] {
   });
 }
 
+/** Reads only the embedded picture, for callers that need a cover without the rest of the tags. */
+export async function extractAudioCover(absolutePath: string): Promise<Buffer | null> {
+  try {
+    const { stdout } = await execFile(FFPROBE_PATH, ['-v', 'quiet', '-print_format', 'json', '-show_streams', absolutePath], {
+      maxBuffer: FFPROBE_OUTPUT_MAX_BUFFER_BYTES,
+    });
+    const data: FfprobeOutput = JSON.parse(stdout);
+    return await extractCoverBytes(absolutePath, data.streams ?? []);
+  } catch {
+    return null;
+  }
+}
+
 async function extractCoverBytes(absolutePath: string, streams: FfprobeStream[]): Promise<Buffer | null> {
   const hasEmbeddedImage = streams.some((s) => s.codec_type === 'video');
   if (!hasEmbeddedImage) return null;
diff --git a/server/src/modules/metadata/metadata-extraction.service.ts b/server/src/modules/metadata/metadata-extraction.service.ts
index 48238b558..75631d7fe 100644
--- a/server/src/modules/metadata/metadata-extraction.service.ts
+++ b/server/src/modules/metadata/metadata-extraction.service.ts
@@ -1,6 +1,7 @@
 import { Injectable, Logger } from '@nestjs/common';
 
 import { sanitizeLogValue } from '../../common/utils/log-sanitize.utils';
+import { extractAudioCover } from './extractors/audio.extractor';
 import { AudioFormatExtractor } from './extractors/audio-format.extractor';
 import { ComicFormatExtractor } from './extractors/comic-format.extractor';
 import { EpubFormatExtractor } from './extractors/epub-format.extractor';
@@ -75,6 +76,13 @@ export class MetadataExtractionService {
     return { metadata: null, cover };
   }
 
+  /** Reads only a file's embedded cover. KEPUB is an EPUB container, and audio art comes from ffmpeg. */
+  async extractEmbeddedCover(absolutePath: string, format: string): Promise<Buffer | null> {
+    const normalized = format.toLowerCase();
+    if ((METADATA_AUDIO_FORMATS as readonly string[]).includes(normalized)) return extractAudioCover(absolutePath);
+    return extractCover(absolutePath, normalized === 'kepub' ? 'epub' : normalized);
+  }
+
   private logPdfParseWarning(warning: PdfParseWarning): void {
     const pathValue = sanitizeLogValue(warning.absolutePath);
     if (warning.code === 'buffered-large-pdf') {
diff --git a/server/src/modules/metadata/metadata-thumbnail-repair.test.ts b/server/src/modules/metadata/metadata-thumbnail-repair.test.ts
deleted file mode 100644
index 719be5031..000000000
--- a/server/src/modules/metadata/metadata-thumbnail-repair.test.ts
+++ /dev/null
@@ -1,104 +0,0 @@
-import { ConfigService } from '@nestjs/config';
-import { Test } from '@nestjs/testing';
-import { access, mkdir, mkdtemp, readFile, readdir, rm, writeFile } from 'fs/promises';
-import { tmpdir } from 'os';
-import { join } from 'path';
-import sharp from 'sharp';
-
-import { DB } from '../../db';
-import { BookMetadataLockService } from '../book-metadata-lock/book-metadata-lock.service';
-import { BookEmbedderService } from '../embedding/book-embedder.service';
-import { MetadataScoreService } from '../metadata-score/metadata-score.service';
-import { NarratorService } from '../narrator/narrator.service';
-import { ComicMetadataRepository } from './comic-metadata.repository';
-import { MetadataExtractionService } from './metadata-extraction.service';
-import { MetadataService } from './metadata.service';
-
-describe('MetadataService thumbnail repair', () => {
-  let appDataPath: string;
-  let service: MetadataService;
-
-  async function makeCover(): Promise<Buffer> {
-    return sharp({ create: { width: 800, height: 1200, channels: 3, background: '#336699' } })
-      .jpeg()
-      .toBuffer();
-  }
-
-  beforeEach(async () => {
-    appDataPath = await mkdtemp(join(tmpdir(), 'bookorbit-thumbnail-repair-'));
-    const moduleRef = await Test.createTestingModule({
-      providers: [
-        MetadataService,
-        { provide: DB, useValue: {} },
-        { provide: ConfigService, useValue: { get: () => appDataPath } },
-        { provide: MetadataExtractionService, useValue: {} },
-        { provide: MetadataScoreService, useValue: { calculateAndSave: vi.fn() } },
-        { provide: NarratorService, useValue: {} },
-        { provide: ComicMetadataRepository, useValue: {} },
-        { provide: BookMetadataLockService, useValue: { isFieldLocked: vi.fn().mockResolvedValue(false) } },
-        { provide: BookEmbedderService, useValue: {} },
-      ],
-    }).compile();
-    service = moduleRef.get(MetadataService);
-  });
-
-  afterEach(async () => {
-    await rm(appDataPath, { recursive: true, force: true });
-  });
-
-  async function seedCoverDir(bookId: number, coverFileName: string, bytes: Buffer): Promise<string> {
-    const coverDir = join(appDataPath, 'covers', String(bookId));
-    await mkdir(coverDir, { recursive: true });
-    await writeFile(join(coverDir, coverFileName), bytes);
-    return coverDir;
-  }
-
-  it('reproduces and repairs a missing thumbnail beside an intact custom cover', async () => {
-    const coverDir = await seedCoverDir(913, 'cover_custom.jpg', await makeCover());
-    const thumbnailPath = join(coverDir, 'thumbnail.jpg');
-
-    await expect(access(thumbnailPath)).rejects.toMatchObject({ code: 'ENOENT' });
-
-    await expect(service.ensureThumbnailForBook(913)).resolves.toBe(thumbnailPath);
-
-    const metadata = await sharp(await readFile(thumbnailPath)).metadata();
-    expect(metadata).toMatchObject({ format: 'jpeg', width: 400, height: 600 });
-  });
-
-  it('repairs from a legacy cover file the cover endpoint still serves', async () => {
-    const coverDir = await seedCoverDir(914, 'cover.jpg', await makeCover());
-
-    await expect(service.ensureThumbnailForBook(914)).resolves.toBe(join(coverDir, 'thumbnail.jpg'));
-  });
-
-  it('leaves no temporary file behind once the thumbnail is published', async () => {
-    const coverDir = await seedCoverDir(915, 'cover_extracted.jpg', await makeCover());
-
-    await service.ensureThumbnailForBook(915);
-
-    await expect(readdir(coverDir)).resolves.toEqual(expect.arrayContaining(['cover_extracted.jpg', 'thumbnail.jpg']));
-    await expect(readdir(coverDir)).resolves.toHaveLength(2);
-  });
-
-  it('keeps a thumbnail written while the repair was in flight', async () => {
-    const coverDir = await seedCoverDir(916, 'cover_custom.jpg', await makeCover());
-    const thumbnailPath = join(coverDir, 'thumbnail.jpg');
-    const existing = Buffer.from('thumbnail written by a concurrent cover update');
-
-    const repair = service.ensureThumbnailForBook(916);
-    await writeFile(thumbnailPath, existing);
-
-    await expect(repair).resolves.toBe(thumbnailPath);
-    await expect(readFile(thumbnailPath)).resolves.toEqual(existing);
-  });
-
-  it('resolves null instead of throwing when the cover cannot be decoded', async () => {
-    await seedCoverDir(917, 'cover_custom.jpg', Buffer.alloc(0));
-
-    await expect(service.ensureThumbnailForBook(917)).resolves.toBeNull();
-  });
-
-  it('resolves null when the book has no cover directory at all', async () => {
-    await expect(service.ensureThumbnailForBook(918)).resolves.toBeNull();
-  });
-});
diff --git a/server/src/modules/metadata/metadata.module.ts b/server/src/modules/metadata/metadata.module.ts
index 1e39b4ac0..2e87a2166 100644
--- a/server/src/modules/metadata/metadata.module.ts
+++ b/server/src/modules/metadata/metadata.module.ts
@@ -1,17 +1,19 @@
 import { Module } from '@nestjs/common';
 
 import { BookMetadataLockModule } from '../book-metadata-lock/book-metadata-lock.module';
+import { BookCoverStoreModule } from '../book-cover-store/book-cover-store.module';
 import { EmbeddingModule } from '../embedding/embedding.module';
 import { MetadataScoreModule } from '../metadata-score/metadata-score.module';
 import { NarratorModule } from '../narrator/narrator.module';
 import { ComicMetadataRepository } from './comic-metadata.repository';
+import { CoverSlotReconciler } from './cover-slot-reconciler.service';
 import { MetadataExtractionService } from './metadata-extraction.service';
 import { MetadataEventsService } from './metadata-events.service';
 import { MetadataService } from './metadata.service';
 
 @Module({
-  imports: [BookMetadataLockModule, EmbeddingModule, MetadataScoreModule, NarratorModule],
-  providers: [MetadataService, MetadataExtractionService, MetadataEventsService, ComicMetadataRepository],
-  exports: [MetadataService, MetadataExtractionService, MetadataEventsService, ComicMetadataRepository],
+  imports: [BookMetadataLockModule, BookCoverStoreModule, EmbeddingModule, MetadataScoreModule, NarratorModule],
+  providers: [MetadataService, MetadataExtractionService, MetadataEventsService, ComicMetadataRepository, CoverSlotReconciler],
+  exports: [MetadataService, MetadataExtractionService, MetadataEventsService, ComicMetadataRepository, CoverSlotReconciler],
 })
 export class MetadataModule {}
diff --git a/server/src/modules/metadata/metadata.service.test.ts b/server/src/modules/metadata/metadata.service.test.ts
index ba159236e..939387a30 100644
--- a/server/src/modules/metadata/metadata.service.test.ts
+++ b/server/src/modules/metadata/metadata.service.test.ts
@@ -1,17 +1,5 @@
 vi.mock('fs/promises', () => ({
-  access: vi.fn(),
-  link: vi.fn(),
-  mkdir: vi.fn(),
   readFile: vi.fn(),
-  rename: vi.fn(),
-  writeFile: vi.fn(),
-  readdir: vi.fn().mockResolvedValue([]),
-  rm: vi.fn(),
-}));
-
-vi.mock('./lib/cover', () => ({
-  generateThumbnail: vi.fn(),
-  imageExt: vi.fn(),
 }));
 
 vi.mock('./lib/cbz-metadata', () => ({
@@ -87,12 +75,12 @@ vi.mock('./extractors/audio.extractor', () => ({
   probeAudioChapters: vi.fn().mockImplementation(() => Promise.resolve({ chapters: [], durationMs: null })),
 }));
 
-import { access, link, mkdir, readFile, readdir, rename, rm, writeFile } from 'fs/promises';
+import sharp from 'sharp';
+import { readFile } from 'fs/promises';
 import { Logger } from '@nestjs/common';
 
-import { authors, bookAuthors, bookGenres, bookMetadata, books, bookTags, genres, tags } from '../../db/schema';
+import { authors, bookAuthors, bookGenres, bookTags, genres, tags } from '../../db/schema';
 import { extractCbzMetadata, type ParsedCbzMetadata } from './lib/cbz-metadata';
-import { generateThumbnail, imageExt } from './lib/cover';
 import { extractCbzCover } from './lib/cover-cbz';
 import { extractEpubCover } from './lib/cover-epub';
 import { extractEpubMetadata } from './lib/epub';
@@ -104,16 +92,7 @@ import { METADATA_AUTHORS_REPLACED } from './metadata-events.service';
 import { MetadataService } from './metadata.service';
 import { MetadataExtractionService } from './metadata-extraction.service';
 
-const mockAccess = access as MockedFunction<typeof access>;
-const mockLink = link as MockedFunction<typeof link>;
-const mockRename = rename as MockedFunction<typeof rename>;
-const mockMkdir = mkdir as MockedFunction<typeof mkdir>;
 const mockReadFile = readFile as MockedFunction<typeof readFile>;
-const mockWriteFile = writeFile as MockedFunction<typeof writeFile>;
-const mockReaddir = readdir as MockedFunction<typeof readdir>;
-const mockRm = rm as MockedFunction<typeof rm>;
-const mockGenerateThumbnail = generateThumbnail as MockedFunction<typeof generateThumbnail>;
-const mockImageExt = imageExt as MockedFunction<typeof imageExt>;
 const mockParseBookFilename = parseBookFilename as MockedFunction<typeof parseBookFilename>;
 const mockParseMobiFile = parseMobiFile as MockedFunction<typeof parseMobiFile>;
 const mockParsePdfFile = parsePdfFile as MockedFunction<typeof parsePdfFile>;
@@ -170,25 +149,26 @@ const makeDb = () => {
 };
 
 describe('MetadataService', () => {
-  const config = { get: vi.fn().mockReturnValue('/books') };
   const embedder = { embedBook: vi.fn().mockResolvedValue(undefined) };
+  let defaultCoverStore: ReturnType<typeof makeCoverStore>;
+
+  function makeCoverStore() {
+    return {
+      mediaFor: vi.fn(),
+      chooseWriteMedium: vi.fn().mockResolvedValue('ebook'),
+      saveExtracted: vi.fn().mockResolvedValue(true),
+      chooseSidecarMedium: vi.fn().mockResolvedValue('ebook'),
+      hasActiveSlot: vi.fn().mockResolvedValue(false),
+    };
+  }
 
   beforeEach(() => {
     vi.resetAllMocks();
 
-    config.get.mockReturnValue('/books');
     embedder.embedBook.mockResolvedValue(undefined);
+    defaultCoverStore = makeCoverStore();
 
-    mockAccess.mockRejectedValue(Object.assign(new Error('missing'), { code: 'ENOENT' }));
-    mockLink.mockResolvedValue(undefined);
-    mockRename.mockResolvedValue(undefined);
-    mockMkdir.mockResolvedValue(undefined);
     mockReadFile.mockResolvedValue('');
-    mockWriteFile.mockResolvedValue(undefined);
-    mockReaddir.mockResolvedValue([]);
-    mockRm.mockResolvedValue(undefined);
-    mockGenerateThumbnail.mockResolvedValue(Buffer.from('thumbnail-bytes'));
-    mockImageExt.mockReturnValue('png');
     mockParseBookFilename.mockReturnValue({ title: 'Fallback Title', publishedYear: 2001 });
     mockParseMobiFile.mockResolvedValue(null);
     mockParsePdfFile.mockResolvedValue(null);
@@ -226,15 +206,21 @@ describe('MetadataService', () => {
       comicMetadataRepository?: { upsert: ReturnType<typeof vi.fn> };
       bookMetadataLockService?: {
         isFieldLocked: ReturnType<typeof vi.fn>;
-        filterAutomatedBookUpdate: ReturnType<typeof vi.fn>;
+        filterAutomatedBookUpdate?: ReturnType<typeof vi.fn>;
       };
       embedder?: { embedBook: ReturnType<typeof vi.fn> } | null;
       seriesExpectedCount?: { record: ReturnType<typeof vi.fn> };
+      coverStore?: {
+        mediaFor?: ReturnType<typeof vi.fn>;
+        chooseWriteMedium?: ReturnType<typeof vi.fn>;
+        saveExtracted: ReturnType<typeof vi.fn>;
+        chooseSidecarMedium?: ReturnType<typeof vi.fn>;
+        hasActiveSlot?: ReturnType<typeof vi.fn>;
+      };
     },
   ) {
     return new MetadataService(
       db as never,
-      config as never,
       new MetadataExtractionService(),
       (overrides?.scoreService ?? { calculateAndSave: vi.fn().mockResolvedValue(undefined) }) as never,
       (overrides?.narratorService ?? { replaceForBook: vi.fn().mockResolvedValue(undefined) }) as never,
@@ -243,6 +229,7 @@ describe('MetadataService', () => {
         isFieldLocked: vi.fn().mockResolvedValue(false),
         filterAutomatedBookUpdate: vi.fn().mockImplementation((_bookId: number, dto: unknown) => Promise.resolve({ dto, skippedFields: [] })),
       }) as never,
+      (overrides?.coverStore ?? defaultCoverStore) as never,
       (overrides?.embedder ?? embedder) as never,
       metadataEvents as never,
       undefined,
@@ -282,281 +269,168 @@ describe('MetadataService', () => {
     mockExtractEpubCover.mockResolvedValueOnce(cover);
   }
 
-  it('downloadAndSaveCover writes cover/thumbnail and updates metadata when download is valid', async () => {
-    const { db, updateSet } = makeDb();
-    const service = makeService(db);
+  describe('downloadAndSaveCover', () => {
+    async function image(width: number, height: number): Promise<Buffer> {
+      return sharp({ create: { width, height, channels: 3, background: '#336699' } })
+        .jpeg()
+        .toBuffer();
+    }
 
-    global.fetch = vi.fn().mockResolvedValue({
-      ok: true,
-      arrayBuffer: () => Promise.resolve(Buffer.from('image-bytes')),
-    }) as never;
+    function serve(images: Record<string, Buffer>) {
+      const fetchMock = vi.fn((url: URL | string) => {
+        const bytes = images[String(url)];
+        return Promise.resolve(bytes ? new Response(new Uint8Array(bytes)) : new Response(null, { status: 404 }));
+      });
+      global.fetch = fetchMock as never;
+      return fetchMock;
+    }
 
-    await expect(service.downloadAndSaveCover('https://img.example/cover.png', 9)).resolves.toBe(true);
+    function makeStore(slotFilled: boolean) {
+      return {
+        hasActiveSlot: vi.fn().mockResolvedValue(slotFilled),
+        saveExtracted: vi.fn().mockResolvedValue(true),
+      };
+    }
 
-    expect(mockMkdir).toHaveBeenCalledWith('/books/covers/9', { recursive: true });
-    expect(mockWriteFile).toHaveBeenCalledWith('/books/covers/9/cover_extracted.png', Buffer.from('image-bytes'));
-    expect(mockWriteFile).toHaveBeenCalledWith('/books/covers/9/thumbnail.jpg', Buffer.from('thumbnail-bytes'));
-    expect(db.update).toHaveBeenCalledWith(bookMetadata);
-    expect(updateSet).toHaveBeenCalledWith(expect.objectContaining({ coverSource: 'extracted', updatedAt: expect.any(Date) }));
-  });
+    it('moves past a thumbnail and a wrong-shape image to the first cover that fits the slot', async () => {
+      const coverStore = makeStore(true);
+      const service = makeService(makeDb().db, undefined, { coverStore });
+      const square = await image(600, 600);
+      const fetchMock = serve({
+        'https://img.example/thumb.jpg': await image(98, 98),
+        'https://img.example/portrait.jpg': await image(400, 600),
+        'https://img.example/square.jpg': square,
+      });
 
-  it('saveExtractedCoverBytes removes stale extracted files before writing new cover', async () => {
-    const { db } = makeDb();
-    const service = makeService(db);
-    mockReaddir.mockResolvedValue(['cover_extracted.jpg', 'cover_extracted.png']);
+      await expect(
+        service.downloadAndSaveCover(
+          [{ url: 'https://img.example/thumb.jpg' }, { url: 'https://img.example/portrait.jpg' }, { url: 'https://img.example/square.jpg' }],
+          9,
+          'audio',
+        ),
+      ).resolves.toBe(true);
 
-    await service.saveExtractedCoverBytes(11, Buffer.from('image-bytes'));
-
-    expect(mockRm).toHaveBeenCalledWith('/books/covers/11/cover_extracted.jpg', { force: true });
-    expect(mockRm).toHaveBeenCalledWith('/books/covers/11/cover_extracted.png', { force: true });
-    expect(mockWriteFile).toHaveBeenCalledWith('/books/covers/11/cover_extracted.png', Buffer.from('image-bytes'));
-  });
-
-  // The Kobo CoverImageId is versioned from coverUpdatedAt, so it must move whenever the served
-  // image does, and stay put when it does not (issue #943).
-  describe('coverUpdatedAt stamping', () => {
-    it('stamps coverUpdatedAt when an overwriting extraction replaces the cover', async () => {
-      const { db, updateSet } = makeDb();
-      const service = makeService(db);
-      mockReaddir.mockResolvedValue(['cover_extracted.png']);
-
-      await service.saveExtractedCoverBytes(21, Buffer.from('image-bytes'));
-
-      expect(db.update).toHaveBeenCalledWith(bookMetadata);
-      expect(updateSet).toHaveBeenCalledWith({ coverUpdatedAt: expect.any(Date) });
+      expect(fetchMock).toHaveBeenCalledTimes(3);
+      expect(coverStore.saveExtracted).toHaveBeenCalledTimes(1);
+      expect(coverStore.saveExtracted).toHaveBeenCalledWith(9, 'audio', square, { origin: 'provider', overwrite: true });
     });
 
-    it('stamps coverUpdatedAt when first-writer-wins matches no row but the image still changed', async () => {
-      const { db, updateSet, selectLimit } = makeDb();
-      const service = makeService(db);
-      selectLimit.mockResolvedValue([{ coverSource: 'extracted' }]);
-      mockReaddir.mockResolvedValue(['cover_extracted.png', 'thumbnail.jpg']);
-      stubEpubCoverExtraction(Buffer.from('fresher-image-bytes'));
+    it('never replaces a filled slot with a wrong-shape image', async () => {
+      const coverStore = makeStore(true);
+      const service = makeService(makeDb().db, undefined, { coverStore });
+      serve({ 'https://img.example/portrait.jpg': await image(400, 600) });
 
-      await expect(service.refreshCoverForBook(23, '/book.epub', 'epub')).resolves.toBe(true);
+      await expect(service.downloadAndSaveCover([{ url: 'https://img.example/portrait.jpg' }], 9, 'audio')).resolves.toBe(false);
 
-      expect(mockWriteFile).toHaveBeenCalledWith('/books/covers/23/cover_extracted.png', Buffer.from('fresher-image-bytes'));
-      expect(updateSet).toHaveBeenCalledWith({ coverUpdatedAt: expect.any(Date) });
+      expect(coverStore.saveExtracted).not.toHaveBeenCalled();
     });
 
-    it('leaves coverUpdatedAt alone when a DB-owned custom cover still wins', async () => {
-      const { db, updateSet, selectLimit } = makeDb();
-      const service = makeService(db);
-      selectLimit.mockResolvedValue([{ coverSource: 'custom' }]);
-      mockReaddir.mockResolvedValue(['cover_custom.jpg', 'cover_extracted.png', 'thumbnail.jpg']);
-      stubEpubCoverExtraction(Buffer.from('image-bytes'));
+    it('fills an empty slot with the first wrong-shape image when nothing fits', async () => {
+      const coverStore = makeStore(false);
+      const service = makeService(makeDb().db, undefined, { coverStore });
+      const firstPortrait = await image(400, 600);
+      serve({ 'https://img.example/a.jpg': firstPortrait, 'https://img.example/b.jpg': await image(410, 600) });
 
-      await expect(service.refreshCoverForBook(24, '/book.epub', 'epub')).resolves.toBe(true);
+      await expect(
+        service.downloadAndSaveCover(
+          [
+            { url: 'https://img.example/a.jpg', fit: 'unknown' },
+            { url: 'https://img.example/b.jpg', fit: 'mismatch' },
+          ],
+          9,
+          'audio',
+        ),
+      ).resolves.toBe(true);
 
-      expect(updateSet).not.toHaveBeenCalledWith(expect.objectContaining({ coverUpdatedAt: expect.anything() }));
+      expect(coverStore.saveExtracted).toHaveBeenCalledWith(9, 'audio', firstPortrait, { origin: 'provider', overwrite: true });
+    });
+
+    it('does not download art the provider already called the wrong shape when the slot is filled', async () => {
+      const coverStore = makeStore(true);
+      const service = makeService(makeDb().db, undefined, { coverStore });
+      const fetchMock = serve({ 'https://img.example/portrait.jpg': await image(400, 600) });
+
+      await expect(service.downloadAndSaveCover([{ url: 'https://img.example/portrait.jpg', fit: 'mismatch' }], 9, 'audio')).resolves.toBe(false);
+
+      expect(fetchMock).not.toHaveBeenCalled();
+    });
+
+    it('stops after three downloads', async () => {
+      const coverStore = makeStore(true);
+      const service = makeService(makeDb().db, undefined, { coverStore });
+      const fetchMock = serve({});
+
+      await expect(
+        service.downloadAndSaveCover(
+          ['a', 'b', 'c', 'd'].map((name) => ({ url: `https://img.example/${name}.jpg` })),
+          9,
+          'ebook',
+        ),
+      ).resolves.toBe(false);
+
+      expect(fetchMock).toHaveBeenCalledTimes(3);
+    });
+
+    it('saves a cover the user picked whatever its shape', async () => {
+      const coverStore = makeStore(true);
+      const service = makeService(makeDb().db, undefined, { coverStore });
+      const square = await image(600, 600);
+      serve({ 'https://img.example/square.jpg': square });
+
+      await expect(service.downloadAndSaveCover([{ url: 'https://img.example/square.jpg' }], 9, 'ebook', { userChosen: true })).resolves.toBe(true);
+
+      expect(coverStore.hasActiveSlot).not.toHaveBeenCalled();
+      expect(coverStore.saveExtracted).toHaveBeenCalledWith(9, 'ebook', square, { origin: 'provider', overwrite: true });
+    });
+
+    it('skips a locked slot without downloading', async () => {
+      const coverStore = makeStore(false);
+      const lockService = { isFieldLocked: vi.fn((_bookId: number, field: string) => Promise.resolve(field === 'audioCover')) };
+      const service = makeService(makeDb().db, undefined, { coverStore, bookMetadataLockService: lockService });
+      const fetchMock = serve({});
+
+      await expect(service.downloadAndSaveCover([{ url: 'https://img.example/square.jpg' }], 9, 'audio')).resolves.toBe(false);
+
+      expect(lockService.isFieldLocked).toHaveBeenCalledWith(9, 'audioCover');
+      expect(fetchMock).not.toHaveBeenCalled();
     });
   });
 
-  it('saveExtractedCoverBytes removes stale custom files unless the DB owns a custom cover', async () => {
-    const { db } = makeDb();
-    const service = makeService(db);
-    mockReaddir.mockResolvedValue(['cover_custom.jpg', 'cover_extracted.png', 'thumbnail.jpg']);
+  it('saveExtractedCoverBytes saves into the slot the image picks and rescores the book', async () => {
+    const scoreService = { calculateAndSave: vi.fn().mockResolvedValue(undefined) };
+    const service = makeService(makeDb().db, undefined, { scoreService });
+    defaultCoverStore.chooseWriteMedium.mockResolvedValue('audio');
+    const bytes = Buffer.from('image-bytes');
 
-    await service.saveExtractedCoverBytes(12, Buffer.from('image-bytes'));
+    await service.saveExtractedCoverBytes(11, bytes);
 
-    expect(mockRm).toHaveBeenCalledWith('/books/covers/12/cover_custom.jpg', { force: true });
-    expect(mockRm).toHaveBeenCalledWith('/books/covers/12/cover_extracted.png', { force: true });
-    expect(mockWriteFile).toHaveBeenCalledWith('/books/covers/12/thumbnail.jpg', Buffer.from('thumbnail-bytes'));
-    expect(db.update).toHaveBeenCalledWith(books);
+    expect(defaultCoverStore.chooseWriteMedium).toHaveBeenCalledWith(11, bytes);
+    expect(defaultCoverStore.saveExtracted).toHaveBeenCalledWith(11, 'audio', bytes, { origin: 'dock', overwrite: true });
+    expect(scoreService.calculateAndSave).toHaveBeenCalledWith(11);
   });
 
-  it('refreshCoverForBook preserves a DB-owned custom cover while refreshing extracted fallback', async () => {
-    const { db, selectLimit } = makeDb();
-    const service = makeService(db);
-    selectLimit.mockResolvedValue([{ coverSource: 'custom' }]);
-    mockReaddir.mockResolvedValue(['cover_custom.jpg', 'cover_extracted.png', 'thumbnail.jpg']);
-    mockExtractEpubMetadata.mockResolvedValueOnce({
-      title: 'Refreshable book',
-      subtitle: null,
-      description: null,
-      isbn10: null,
-      isbn13: null,
-      publisher: null,
-      publishedYear: null,
-      language: null,
-      seriesName: null,
-      seriesIndex: null,
-      authors: [],
-      narrators: [],
-      genres: [],
-      tags: [],
-      rating: null,
-      pageCount: null,
-      googleBooksId: null,
-      goodreadsId: null,
-      amazonId: null,
-      hardcoverId: null,
-      hardcoverEditionId: null,
-      openLibraryId: null,
-      ranobedbId: null,
-      itunesId: null,
-      coverBuffer: null,
-    });
-    mockExtractEpubCover.mockResolvedValueOnce(Buffer.from('image-bytes'));
+  it('saveExtractedCoverBytes writes the requested slot and skips the rescore when the store declines', async () => {
+    const scoreService = { calculateAndSave: vi.fn().mockResolvedValue(undefined) };
+    const service = makeService(makeDb().db, undefined, { scoreService });
+    defaultCoverStore.saveExtracted.mockResolvedValue(false);
+    const bytes = Buffer.from('image-bytes');
 
-    await expect(service.refreshCoverForBook(13, '/book.epub', 'epub')).resolves.toBe(true);
+    await service.saveExtractedCoverBytes(12, bytes, 'ebook');
 
-    expect(mockRm).not.toHaveBeenCalledWith('/books/covers/13/cover_custom.jpg', { force: true });
-    expect(mockRm).toHaveBeenCalledWith('/books/covers/13/cover_extracted.png', { force: true });
-    expect(mockWriteFile).toHaveBeenCalledWith('/books/covers/13/cover_extracted.png', Buffer.from('image-bytes'));
-    expect(mockWriteFile).not.toHaveBeenCalledWith('/books/covers/13/thumbnail.jpg', expect.any(Buffer));
-    expect(db.update).not.toHaveBeenCalledWith(books);
+    expect(defaultCoverStore.chooseWriteMedium).not.toHaveBeenCalled();
+    expect(defaultCoverStore.saveExtracted).toHaveBeenCalledWith(12, 'ebook', bytes, { origin: 'dock', overwrite: true });
+    expect(scoreService.calculateAndSave).not.toHaveBeenCalled();
   });
 
-  it('refreshCoverForBook repairs a missing thumbnail from the active custom cover', async () => {
-    const { db, selectLimit, updateSet } = makeDb();
-    const service = makeService(db);
-    selectLimit.mockResolvedValue([{ coverSource: 'custom' }]);
-    mockReaddir.mockResolvedValue(['cover_custom.jpg', 'cover_extracted.png']);
-    mockReadFile.mockResolvedValue(Buffer.from('custom-cover-bytes'));
-    stubEpubCoverExtraction(Buffer.from('extracted-cover-bytes'));
+  it('refreshCoverForBook reports no refresh when the store declines the cover', async () => {
+    const scoreService = { calculateAndSave: vi.fn().mockResolvedValue(undefined) };
+    const service = makeService(makeDb().db, undefined, { scoreService });
+    defaultCoverStore.saveExtracted.mockResolvedValue(false);
+    stubEpubCoverExtraction(Buffer.from('image-bytes'));
 
-    await expect(service.refreshCoverForBook(14, '/book.epub', 'epub')).resolves.toBe(true);
+    await expect(service.refreshCoverForBook(14, '/book.epub', 'epub')).resolves.toBe(false);
 
-    expect(mockReadFile).toHaveBeenCalledWith('/books/covers/14/cover_custom.jpg');
-    expect(mockGenerateThumbnail).toHaveBeenCalledWith(Buffer.from('custom-cover-bytes'));
-    expect(mockWriteFile).toHaveBeenCalledWith('/books/covers/14/thumbnail.jpg', Buffer.from('thumbnail-bytes'));
-    expect(updateSet).toHaveBeenCalledWith({ coverUpdatedAt: expect.any(Date) });
-    expect(db.update).toHaveBeenCalledWith(books);
-  });
-
-  it('refreshCoverForBook promotes the extracted cover when the stored custom cover is missing', async () => {
-    const { db, selectLimit, updateSet } = makeDb();
-    const service = makeService(db);
-    selectLimit.mockResolvedValue([{ coverSource: 'custom' }]);
-    mockReaddir.mockResolvedValue(['cover_extracted.jpg']);
-    stubEpubCoverExtraction(Buffer.from('extracted-cover-bytes'));
-
-    await expect(service.refreshCoverForBook(16, '/book.epub', 'epub')).resolves.toBe(true);
-
-    expect(mockWriteFile).toHaveBeenCalledWith('/books/covers/16/thumbnail.jpg', Buffer.from('thumbnail-bytes'));
-    expect(updateSet).toHaveBeenCalledWith({ coverSource: 'extracted', updatedAt: expect.any(Date) });
-  });
-
-  it('refreshCoverForBook keeps the custom cover source when the cover directory reads back empty', async () => {
-    const { db, selectLimit, updateSet } = makeDb();
-    const service = makeService(db);
-    selectLimit.mockResolvedValue([{ coverSource: 'custom' }]);
-    // An unmounted cover volume is recreated by mkdir and then lists empty, which must not be read
-    // as "the user deleted their custom cover".
-    mockReaddir.mockResolvedValue([]);
-    stubEpubCoverExtraction(Buffer.from('extracted-cover-bytes'));
-
-    await expect(service.refreshCoverForBook(19, '/book.epub', 'epub')).resolves.toBe(true);
-
-    expect(updateSet).not.toHaveBeenCalledWith({ coverSource: 'extracted', updatedAt: expect.any(Date) });
-  });
-
-  it('ensureThumbnailForBook lazily repairs a missing thumbnail from the preferred cover', async () => {
-    const { db } = makeDb();
-    const service = makeService(db);
-    mockReaddir.mockResolvedValue(['cover_extracted.png', 'cover_custom.jpg']);
-    mockReadFile.mockResolvedValue(Buffer.from('custom-cover-bytes'));
-
-    await expect(service.ensureThumbnailForBook(15)).resolves.toBe('/books/covers/15/thumbnail.jpg');
-
-    expect(mockReadFile).toHaveBeenCalledWith('/books/covers/15/cover_custom.jpg');
-    expect(mockGenerateThumbnail).toHaveBeenCalledWith(Buffer.from('custom-cover-bytes'));
-
-    // The thumbnail is staged in the cover directory and hard-linked into place, so an interrupted
-    // write can never leave a truncated thumbnail.jpg that later requests would accept.
-    const [tempPath, tempBytes] = mockWriteFile.mock.calls[0]!;
-    expect(tempPath).toMatch(/^\/books\/covers\/15\/\.thumbnail-repair-.+\.tmp$/);
-    expect(tempBytes).toEqual(Buffer.from('thumbnail-bytes'));
-    expect(mockLink).toHaveBeenCalledWith(tempPath, '/books/covers/15/thumbnail.jpg');
-    expect(mockRm).toHaveBeenCalledWith(tempPath, { force: true });
-  });
-
-  it('ensureThumbnailForBook keeps a thumbnail created by a concurrent cover update', async () => {
-    const { db } = makeDb();
-    const service = makeService(db);
-    mockReaddir.mockResolvedValue(['cover_custom.jpg']);
-    mockReadFile.mockResolvedValue(Buffer.from('custom-cover-bytes'));
-    mockLink.mockRejectedValue(Object.assign(new Error('already exists'), { code: 'EEXIST' }));
-
-    await expect(service.ensureThumbnailForBook(17)).resolves.toBe('/books/covers/17/thumbnail.jpg');
-    expect(mockWriteFile).not.toHaveBeenCalledWith('/books/covers/17/thumbnail.jpg', expect.anything(), expect.anything());
-  });
-
-  it('ensureThumbnailForBook publishes by rename when the filesystem has no hard links', async () => {
-    const { db } = makeDb();
-    const service = makeService(db);
-    mockReaddir.mockResolvedValue(['cover_custom.jpg']);
-    mockReadFile.mockResolvedValue(Buffer.from('custom-cover-bytes'));
-    mockLink.mockRejectedValue(Object.assign(new Error('operation not permitted'), { code: 'EPERM' }));
-
-    await expect(service.ensureThumbnailForBook(26)).resolves.toBe('/books/covers/26/thumbnail.jpg');
-
-    // The bytes must reach the served path through a rename of a fully written file, never a direct
-    // write, so an interrupted repair cannot leave a truncated thumbnail that nothing revalidates.
-    const [tempPath] = mockWriteFile.mock.calls[0]!;
-    expect(tempPath).toMatch(/^\/books\/covers\/26\/\.thumbnail-repair-.+\.tmp$/);
-    expect(mockRename).toHaveBeenCalledWith(tempPath, '/books/covers/26/thumbnail.jpg');
-    expect(mockWriteFile).not.toHaveBeenCalledWith('/books/covers/26/thumbnail.jpg', expect.anything(), expect.anything());
-  });
-
-  it('ensureThumbnailForBook leaves a published thumbnail alone when hard links are unavailable', async () => {
-    const { db } = makeDb();
-    const service = makeService(db);
-    mockReaddir.mockResolvedValue(['cover_custom.jpg']);
-    mockReadFile.mockResolvedValue(Buffer.from('custom-cover-bytes'));
-    mockLink.mockRejectedValue(Object.assign(new Error('operation not permitted'), { code: 'EPERM' }));
-    mockAccess.mockResolvedValue(undefined);
-
-    await expect(service.ensureThumbnailForBook(27)).resolves.toBe('/books/covers/27/thumbnail.jpg');
-
-    expect(mockRename).not.toHaveBeenCalled();
-  });
-
-  it('ensureThumbnailForBook resolves null instead of throwing when the cover cannot be read', async () => {
-    const { db } = makeDb();
-    const service = makeService(db);
-    mockReaddir.mockResolvedValue(['cover_custom.jpg']);
-    mockReadFile.mockResolvedValue(Buffer.from('custom-cover-bytes'));
-    mockGenerateThumbnail.mockRejectedValueOnce(new Error('Input buffer contains unsupported image format'));
-
-    await expect(service.ensureThumbnailForBook(18)).resolves.toBeNull();
-  });
-
-  it('ensureThumbnailForBook bounds concurrent thumbnail generation', async () => {
-    const { db } = makeDb();
-    const service = makeService(db);
-    let active = 0;
-    let peak = 0;
-    const releases: Array<() => void> = [];
-    mockReaddir.mockResolvedValue(['cover_custom.jpg']);
-    mockReadFile.mockImplementation(
-      () =>
-        new Promise<Buffer>((resolve) => {
-          active++;
-          peak = Math.max(peak, active);
-          releases.push(() => {
-            active--;
-            resolve(Buffer.from('custom-cover-bytes'));
-          });
-        }),
-    );
-
-    const repairs = [21, 22, 23, 24, 25].map((bookId) => service.ensureThumbnailForBook(bookId));
-    await vi.waitFor(() => expect(releases).toHaveLength(4));
-
-    expect(peak).toBe(4);
-    releases.splice(0).forEach((release) => release());
-    await vi.waitFor(() => expect(releases).toHaveLength(1));
-    releases.splice(0).forEach((release) => release());
-
-    await expect(Promise.all(repairs)).resolves.toEqual([
-      '/books/covers/21/thumbnail.jpg',
-      '/books/covers/22/thumbnail.jpg',
-      '/books/covers/23/thumbnail.jpg',
-      '/books/covers/24/thumbnail.jpg',
-      '/books/covers/25/thumbnail.jpg',
-    ]);
+    expect(scoreService.calculateAndSave).not.toHaveBeenCalled();
   });
 
   it('downloadAndSaveCover no-ops on empty payloads and network failures', async () => {
@@ -569,12 +443,12 @@ describe('MetadataService', () => {
     }) as never;
     await expect(service.downloadAndSaveCover('https://img.example/empty.png', 4)).resolves.toBe(false);
 
-    expect(mockWriteFile).not.toHaveBeenCalled();
+    expect(defaultCoverStore.saveExtracted).not.toHaveBeenCalled();
     expect(db.update).not.toHaveBeenCalled();
 
     (global.fetch as vi.Mock).mockRejectedValue(new Error('timeout'));
     await expect(service.downloadAndSaveCover('https://img.example/fail.png', 4)).resolves.toBe(false);
-    expect(mockWriteFile).not.toHaveBeenCalled();
+    expect(defaultCoverStore.saveExtracted).not.toHaveBeenCalled();
   });
 
   it('downloadAndSaveCover skips when cover is locked or HTTP response is not ok', async () => {
@@ -595,7 +469,47 @@ describe('MetadataService', () => {
 
     await expect(service.downloadAndSaveCover('https://img.example/locked.png', 4)).resolves.toBe(false);
     await expect(service.downloadAndSaveCover('https://img.example/not-found.png', 4)).resolves.toBe(false);
-    expect(mockWriteFile).not.toHaveBeenCalled();
+    expect(defaultCoverStore.saveExtracted).not.toHaveBeenCalled();
+  });
+
+  it('uses the audio lock for provider covers on audio-only books', async () => {
+    const { db } = makeDb();
+    const lockService = {
+      isFieldLocked: vi.fn().mockResolvedValue(true),
+      filterAutomatedBookUpdate: vi.fn(),
+    };
+    const coverStore = {
+      mediaFor: vi.fn().mockResolvedValue({ hasEbook: false, hasAudio: true }),
+      chooseWriteMedium: vi.fn(),
+      saveExtracted: vi.fn(),
+    };
+    const service = makeService(db, undefined, { bookMetadataLockService: lockService, coverStore });
+    global.fetch = vi.fn();
+
+    await expect(service.downloadAndSaveCover('https://img.example/audio.png', 4)).resolves.toBe(false);
+
+    expect(lockService.isFieldLocked).toHaveBeenCalledWith(4, 'audioCover');
+    expect(global.fetch).not.toHaveBeenCalled();
+    expect(coverStore.saveExtracted).not.toHaveBeenCalled();
+  });
+
+  it('uses the audio lock for explicit audio cover refreshes', async () => {
+    const { db } = makeDb();
+    const lockService = {
+      isFieldLocked: vi.fn().mockResolvedValue(true),
+      filterAutomatedBookUpdate: vi.fn(),
+    };
+    const coverStore = {
+      mediaFor: vi.fn(),
+      chooseWriteMedium: vi.fn(),
+      saveExtracted: vi.fn(),
+    };
+    const service = makeService(db, undefined, { bookMetadataLockService: lockService, coverStore });
+
+    await expect(service.refreshCoverForBook(4, '/book.epub', 'epub', 'audio')).resolves.toBe(false);
+
+    expect(lockService.isFieldLocked).toHaveBeenCalledWith(4, 'audioCover');
+    expect(coverStore.saveExtracted).not.toHaveBeenCalled();
   });
 
   it('extractAndSave short-circuits for unsupported formats and empty parser output', async () => {
@@ -645,7 +559,7 @@ describe('MetadataService', () => {
   });
 
   it('refreshCoverForBook handles missing extractors, locked cover field, and successful refresh', async () => {
-    const { db, updateSet } = makeDb();
+    const { db } = makeDb();
     const lockService = {
       isFieldLocked: vi.fn().mockResolvedValueOnce(true).mockResolvedValueOnce(false),
       filterAutomatedBookUpdate: vi.fn().mockImplementation((_bookId: number, dto: unknown) => Promise.resolve({ dto, skippedFields: [] })),
@@ -687,8 +601,8 @@ describe('MetadataService', () => {
     mockExtractEpubCover.mockResolvedValueOnce(Buffer.from('epub-cover-2'));
     await expect(service.refreshCoverForBook(8, '/book2.epub', 'epub')).resolves.toBe(true);
 
-    expect(mockWriteFile).toHaveBeenCalledWith('/books/covers/8/cover_extracted.png', expect.any(Buffer));
-    expect(updateSet).toHaveBeenCalledWith(expect.objectContaining({ coverSource: 'extracted' }));
+    expect(defaultCoverStore.saveExtracted).toHaveBeenCalledTimes(1);
+    expect(defaultCoverStore.saveExtracted).toHaveBeenCalledWith(8, 'ebook', Buffer.from('epub-cover-2'), { origin: 'embedded', overwrite: false });
   });
 
   it('extractAndSave propagates extractor errors', async () => {
@@ -863,7 +777,7 @@ describe('MetadataService', () => {
         updatedAt: expect.any(Date),
       }),
     );
-    expect(mockWriteFile).toHaveBeenCalledWith('/books/covers/22/cover_extracted.png', Buffer.from('jpeg-bytes'));
+    expect(defaultCoverStore.saveExtracted).toHaveBeenCalledWith(22, 'ebook', Buffer.from('jpeg-bytes'), { origin: 'embedded', overwrite: true });
     expect(replaceAuthorsSpy).toHaveBeenCalledWith(22, [{ name: 'Author A', sortName: null }]);
     expect(replaceGenresSpy).toHaveBeenCalledWith(22, ['Fantasy']);
     expect(replaceTagsSpy).toHaveBeenCalledWith(22, ['Shelf']);
@@ -1531,6 +1445,67 @@ describe('MetadataService', () => {
     await expect(service.extractAudioChaptersAndNarrators(72, '/tmp/book.pdf', 'pdf')).resolves.toBeUndefined();
   });
 
+  it('extractAudioChaptersAndNarrators keeps the track art for the audio slot without replacing a custom cover', async () => {
+    const { db } = makeDb();
+    const coverStore = {
+      mediaFor: vi.fn(),
+      chooseWriteMedium: vi.fn(),
+      saveExtracted: vi.fn().mockResolvedValue(true),
+    };
+    const service = makeService(db, undefined, { coverStore });
+    const art = Buffer.from('square-art');
+    mockExtractAudioMetadata.mockResolvedValueOnce({
+      title: null,
+      subtitle: null,
+      authors: [],
+      narrators: [],
+      publisher: null,
+      publishedDate: null,
+      publishedYear: null,
+      description: null,
+      language: null,
+      seriesName: null,
+      seriesIndex: null,
+      genres: [],
+      audibleId: null,
+      librofmId: null,
+      durationSeconds: null,
+      chapters: [],
+      coverBytes: art,
+    });
+
+    await service.extractAudioChaptersAndNarrators(74, '/tmp/audio.m4b', 'm4b');
+
+    expect(coverStore.saveExtracted).toHaveBeenCalledWith(74, 'audio', art, { origin: 'embedded', overwrite: false, skipIfUnchanged: true });
+  });
+
+  it('routes an OPF sidecar cover to the slot its shape picks, overwriting as the leading source', async () => {
+    const { db } = makeDb();
+    const coverStore = {
+      mediaFor: vi.fn(),
+      chooseWriteMedium: vi.fn(),
+      saveExtracted: vi.fn().mockResolvedValue(true),
+      chooseSidecarMedium: vi.fn().mockResolvedValue('audio'),
+    };
+    const service = makeService(db, undefined, { coverStore });
+    const bytes = Buffer.from('opf-cover');
+
+    await (service as unknown as { persistSourceCover: (id: number, format: string, cover: Buffer) => Promise<boolean> }).persistSourceCover(
+      55,
+      'opf',
+      bytes,
+    );
+    await (service as unknown as { persistSourceCover: (id: number, format: string, cover: Buffer) => Promise<boolean> }).persistSourceCover(
+      55,
+      'm4b',
+      bytes,
+    );
+
+    expect(coverStore.chooseSidecarMedium).toHaveBeenCalledWith(55, bytes);
+    expect(coverStore.saveExtracted).toHaveBeenNthCalledWith(1, 55, 'audio', bytes, { origin: 'opf', overwrite: true });
+    expect(coverStore.saveExtracted).toHaveBeenNthCalledWith(2, 55, 'audio', bytes, { origin: 'embedded', overwrite: true });
+  });
+
   describe('extractMergedAudioChapters', () => {
     const partOne = '/books/Red Rising/Red Rising - 01.m4b';
     const partTwo = '/books/Red Rising/Red Rising - 02.m4b';
diff --git a/server/src/modules/metadata/metadata.service.ts b/server/src/modules/metadata/metadata.service.ts
index 74cae3230..06e575ec3 100644
--- a/server/src/modules/metadata/metadata.service.ts
+++ b/server/src/modules/metadata/metadata.service.ts
@@ -1,23 +1,12 @@
 import { Inject, Injectable, Logger, Optional } from '@nestjs/common';
-import { ConfigService } from '@nestjs/config';
-import { and, eq, inArray, isNull, sql } from 'drizzle-orm';
+import { and, eq, inArray, sql } from 'drizzle-orm';
 import { NodePgDatabase } from 'drizzle-orm/node-postgres';
-import { randomUUID } from 'crypto';
-import { access, link, mkdir, readFile, readdir, rename, rm, writeFile } from 'fs/promises';
-import { join } from 'path';
+import sharp from 'sharp';
 
 import { DB } from '../../db';
 import * as schema from '../../db/schema';
-import {
-  COVER_EXTRACTED_FILE_PREFIX,
-  COVER_THUMBNAIL_FILE_NAME,
-  bookCoverDirPath,
-  bookThumbnailPath,
-  findPreferredBookCoverFileName,
-  isCustomBookCoverFileName,
-  isExtractedBookCoverFileName,
-} from '../../common/book-cover-storage';
 import { sanitizeLogValue } from '../../common/utils/log-sanitize.utils';
+import { isKnownPlaceholderCover } from '../../common/utils/placeholder-cover.utils';
 import {
   chooseCanonicalMetadataTextRow,
   normalizeMetadataText,
@@ -35,14 +24,22 @@ import { BookMetadataLockService } from '../book-metadata-lock/book-metadata-loc
 import { ComicMetadataRepository } from './comic-metadata.repository';
 import { MetadataScoreService } from '../metadata-score/metadata-score.service';
 import { NarratorService } from '../narrator/narrator.service';
-import { authors, bookAuthors, bookGenres, bookMetadata, books, bookTags, genres, tags } from '../../db/schema';
-import { type AudiobookChapter, type ComicMetadataFields, isAudioFormat } from '@bookorbit/types';
+import { authors, bookAuthors, bookGenres, bookMetadata, bookTags, genres, tags } from '../../db/schema';
+import {
+  type AudiobookChapter,
+  type ComicMetadataFields,
+  type CoverMedium,
+  coverShapeFromSize,
+  isAudioFormat,
+  MIN_COVER_SHORT_SIDE_PX,
+} from '@bookorbit/types';
 import { chaptersReachLastFile, mergeAudioChapters, type AudioChapterSource } from './extractors/audio-chapter-merge';
 import { parseAudioDuration, probeAudioChapters } from './extractors/audio.extractor';
 import type { ParsedBookData } from './extractors/format-extractor.interface';
-import { generateThumbnail, imageExt } from './lib/cover';
 import { METADATA_AUDIO_FORMATS, MetadataExtractionService } from './metadata-extraction.service';
 import { MetadataEventsService, METADATA_AUTHORS_REPLACED } from './metadata-events.service';
+import { BookCoverStore } from '../book-cover-store/book-cover-store.service';
+import type { BookCoverOrigin } from '../book-cover-store/book-cover-store.repository';
 
 type Db = NodePgDatabase<typeof schema>;
 type RelationMutationExecutor = Pick<Db, 'delete' | 'execute' | 'insert' | 'select' | 'update'>;
@@ -53,10 +50,14 @@ interface RelationMutationOptions {
 }
 
 const MAX_RELATION_NAME_LENGTH = 200;
-const EXTRACTED_COVER_SOURCE = 'extracted';
-const THUMBNAIL_REPAIR_CONCURRENCY = 4;
 const MIN_PUBLISHED_YEAR = 1000;
 const MAX_PUBLISHED_YEAR = 2200;
+const MAX_COVER_DOWNLOADS = 3;
+const MAX_COVER_DOWNLOAD_BYTES = 20 * 1024 * 1024;
+const COVER_DOWNLOAD_TIMEOUT_MS = 15_000;
+
+/** A fetched cover and how the provider's stated shape fits the slot it is meant for. */
+export type CoverDownloadChoice = { url: string; fit?: 'match' | 'unknown' | 'mismatch' };
 const NORMALIZED_AUTHOR_NAME_SQL = normalizeMetadataTextKeySql(authors.name);
 
 function normalizePublishedYear(year: number | null | undefined): number | null | undefined {
@@ -70,27 +71,21 @@ function normalizePublishedYear(year: number | null | undefined): number | null
 @Injectable()
 export class MetadataService {
   private readonly logger = new Logger(MetadataService.name);
-  private readonly appDataPath: string;
-  private readonly thumbnailRepairs = new Map<number, Promise<string | null>>();
-  private readonly thumbnailRepairWaiters: Array<() => void> = [];
-  private activeThumbnailRepairs = 0;
 
   constructor(
     @Inject(DB) private readonly db: Db,
-    private readonly config: ConfigService,
     private readonly extractionService: MetadataExtractionService,
     private readonly scoreService: MetadataScoreService,
     private readonly narratorService: NarratorService,
     private readonly comicMetadataRepository: ComicMetadataRepository,
     private readonly bookMetadataLockService: BookMetadataLockService,
+    private readonly coverStore: BookCoverStore,
     @Optional() private readonly embedder: BookEmbedderService,
     @Optional() private readonly metadataEvents?: MetadataEventsService,
     @Optional() private readonly seriesIdentity?: SeriesIdentityService,
     @Optional() private readonly seriesMemberships?: SeriesMembershipService,
     @Optional() private readonly seriesExpectedCount?: SeriesExpectedCountService,
-  ) {
-    this.appDataPath = this.config.get<string>('storage.appDataPath')!;
-  }
+  ) {}
 
   // ── Public API ───────────────────────────────────────────────────────────────
 
@@ -121,7 +116,7 @@ export class MetadataService {
 
       await Promise.all([
         this.persistMetadata(bookId, data, format),
-        data.cover ? this.persistCover(bookId, data.cover, true) : Promise.resolve(),
+        data.cover ? this.persistSourceCover(bookId, format, data.cover) : Promise.resolve(),
         this.persistFixedLayout(bookId, absolutePath, data.isFixedLayout),
       ]);
 
@@ -142,8 +137,9 @@ export class MetadataService {
   }
 
   // Called when ebook is the winner but audio files are also present.
-  // Saves audio-specific fields that no ebook format can provide, plus audio provider IDs.
-  // Cover is intentionally excluded - the winner ebook owns cover.
+  // Saves audio-specific fields that no ebook format can provide, plus audio provider IDs, and the
+  // track's art into the audio slot. The leading source owns the ebook slot, and a custom audio
+  // cover survives because this write never overwrites one.
   async extractAudioChaptersAndNarrators(bookId: number, absolutePath: string, format: string): Promise<void> {
     if (!this.extractionService.supports(format)) return;
     const data = await this.extractionService.extract(absolutePath, format);
@@ -180,53 +176,131 @@ export class MetadataService {
       updates.push(this.narratorService.replaceForBook(bookId, filtered.audioMetadata.narrators));
     }
 
+    if (data.cover) {
+      updates.push(this.coverStore.saveExtracted(bookId, 'audio', data.cover, { origin: 'embedded', overwrite: false, skipIfUnchanged: true }));
+    }
+
     await Promise.all(updates);
   }
 
-  async downloadAndSaveCover(url: string, bookId: number): Promise<boolean> {
+  /**
+   * Saves a fetched cover into one slot, trying the choices in order. An image that is too small or
+   * the wrong shape for the slot moves on to the next choice, up to three downloads, and is kept
+   * only as a last resort for an empty slot: a wrong-shape image never replaces a cover. A cover the
+   * user picked by hand skips the shape check.
+   */
+  async downloadAndSaveCover(
+    choices: readonly CoverDownloadChoice[],
+    bookId: number,
+    medium: CoverMedium,
+    options: { userChosen?: boolean } = {},
+  ): Promise<boolean> {
     const event = 'metadata.cover_download';
     const startedAt = Date.now();
-    this.logger.debug(`[${event}] [start] bookId=${bookId} - cover download started`);
+    const checkShape = options.userChosen !== true;
+    this.logger.debug(`[${event}] [start] bookId=${bookId} medium=${medium} choices=${choices.length} - cover download started`);
 
     try {
-      if (await this.bookMetadataLockService.isFieldLocked(bookId, 'cover')) {
-        this.logger.debug(`[${event}] [end] bookId=${bookId} durationMs=${Date.now() - startedAt} saved=false locked=true - cover download skipped`);
-        return false;
-      }
-      const res = await fetch(url, { signal: AbortSignal.timeout(15_000) });
-      if (!res.ok) {
+      const lockField = medium === 'ebook' ? 'cover' : 'audioCover';
+      if (await this.bookMetadataLockService.isFieldLocked(bookId, lockField)) {
         this.logger.debug(
-          `[${event}] [end] bookId=${bookId} durationMs=${Date.now() - startedAt} saved=false status=${res.status} - cover download skipped`,
+          `[${event}] [end] bookId=${bookId} medium=${medium} durationMs=${Date.now() - startedAt} saved=false locked=true - cover download skipped`,
         );
         return false;
       }
-      const buffer = Buffer.from(await res.arrayBuffer());
-      if (buffer.length === 0) {
-        this.logger.debug(`[${event}] [end] bookId=${bookId} durationMs=${Date.now() - startedAt} saved=false empty=true - cover download skipped`);
-        return false;
-      }
+      const slotFilled = checkShape ? await this.coverStore.hasActiveSlot(bookId, medium) : false;
 
-      await this.persistCover(bookId, buffer, true);
+      let lastResort: Buffer | null = null;
+      let downloads = 0;
+      let skipped = 0;
+      let saved = false;
+      for (const choice of choices) {
+        if (downloads >= MAX_COVER_DOWNLOADS) break;
+        if (checkShape && choice.fit === 'mismatch' && (slotFilled || lastResort)) continue;
+        downloads++;
+        const bytes = await this.fetchCoverBytes(choice.url);
+        if (!bytes) {
+          skipped++;
+          continue;
+        }
+        if (!checkShape) {
+          saved = await this.persistCover(bookId, medium, bytes, true, 'provider');
+          break;
+        }
+        const fit = await this.measureCoverFit(bytes, medium);
+        if (fit === 'fits') {
+          saved = await this.persistCover(bookId, medium, bytes, true, 'provider');
+          break;
+        }
+        skipped++;
+        if (fit === 'wrong_shape' && !slotFilled && !lastResort) lastResort = bytes;
+      }
+      if (!saved && lastResort) saved = await this.persistCover(bookId, medium, lastResort, true, 'provider');
+
+      this.logger.debug(
+        `[${event}] [end] bookId=${bookId} medium=${medium} durationMs=${Date.now() - startedAt} downloads=${downloads} skipped=${skipped} saved=${saved} - cover download completed`,
+      );
+      if (!saved) return false;
     } catch (error) {
       const errorClass = error instanceof Error ? error.name : 'Error';
       const errorMessage = sanitizeLogValue(error instanceof Error ? error.message : String(error));
       this.logger.warn(
-        `[${event}] [fail] bookId=${bookId} durationMs=${Date.now() - startedAt} errorClass=${errorClass} error="${errorMessage}" - cover download failed`,
+        `[${event}] [fail] bookId=${bookId} medium=${medium} durationMs=${Date.now() - startedAt} errorClass=${errorClass} error="${errorMessage}" - cover download failed`,
       );
       return false;
     }
 
     await this.scoreService.calculateAndSave(bookId);
-    this.logger.debug(`[${event}] [end] bookId=${bookId} durationMs=${Date.now() - startedAt} saved=true - cover download completed`);
     return true;
   }
 
-  async saveExtractedCoverBytes(bookId: number, bytes: Buffer): Promise<void> {
-    await this.persistCover(bookId, bytes, true);
-    await this.scoreService.calculateAndSave(bookId);
+  private async fetchCoverBytes(url: string): Promise<Buffer | null> {
+    let parsed: URL;
+    try {
+      parsed = new URL(url);
+    } catch {
+      return null;
+    }
+    if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') return null;
+    const res = await fetch(parsed, { signal: AbortSignal.timeout(COVER_DOWNLOAD_TIMEOUT_MS) });
+    if (!res.ok || !res.body) return null;
+    const declared = Number(res.headers.get('content-length'));
+    if (Number.isFinite(declared) && declared > MAX_COVER_DOWNLOAD_BYTES) return null;
+
+    const reader = res.body.getReader();
+    const chunks: Uint8Array[] = [];
+    let total = 0;
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      total += value.byteLength;
+      if (total > MAX_COVER_DOWNLOAD_BYTES) {
+        await reader.cancel();
+        return null;
+      }
+      chunks.push(value);
+    }
+    return total > 0 ? Buffer.concat(chunks) : null;
   }
 
-  async refreshCoverForBook(bookId: number, absolutePath: string, format: string): Promise<boolean> {
+  private async measureCoverFit(bytes: Buffer, medium: CoverMedium): Promise<'fits' | 'wrong_shape' | 'unusable'> {
+    let width: number | undefined;
+    let height: number | undefined;
+    try {
+      ({ width, height } = await sharp(bytes, { failOn: 'none' }).metadata());
+    } catch {
+      return 'unusable';
+    }
+    if (!width || !height || Math.min(width, height) < MIN_COVER_SHORT_SIDE_PX || isKnownPlaceholderCover(bytes)) return 'unusable';
+    return coverShapeFromSize(width, height) === (medium === 'audio' ? 'square' : 'portrait') ? 'fits' : 'wrong_shape';
+  }
+
+  async saveExtractedCoverBytes(bookId: number, bytes: Buffer, medium?: CoverMedium): Promise<void> {
+    const target = medium ?? (await this.coverStore.chooseWriteMedium(bookId, bytes));
+    if (await this.persistCover(bookId, target, bytes, true, 'dock')) await this.scoreService.calculateAndSave(bookId);
+  }
+
+  async refreshCoverForBook(bookId: number, absolutePath: string, format: string, requestedMedium?: CoverMedium): Promise<boolean> {
     const event = 'metadata.cover_refresh';
     const startedAt = Date.now();
     if (!this.extractionService.supports(format)) {
@@ -237,7 +311,9 @@ export class MetadataService {
     }
 
     try {
-      if (await this.bookMetadataLockService.isFieldLocked(bookId, 'cover')) {
+      const medium = requestedMedium ?? this.mediumForFormat(format);
+      const lockField = medium === 'ebook' ? 'cover' : 'audioCover';
+      if (await this.bookMetadataLockService.isFieldLocked(bookId, lockField)) {
         this.logger.debug(
           `[${event}] [end] bookId=${bookId} format=${format} durationMs=${Date.now() - startedAt} refreshed=false locked=true - cover refresh skipped`,
         );
@@ -250,7 +326,7 @@ export class MetadataService {
         );
         return false;
       }
-      await this.persistCover(bookId, data.cover, false);
+      if (!(await this.persistCover(bookId, medium, data.cover, false, 'embedded'))) return false;
     } catch (error) {
       const errorClass = error instanceof Error ? error.name : 'Error';
       const errorMessage = sanitizeLogValue(error instanceof Error ? error.message : String(error));
@@ -267,24 +343,6 @@ export class MetadataService {
     return true;
   }
 
-  /**
-   * Regenerates a thumbnail that went missing beside an intact cover (issue #1475). Resolves to
-   * null rather than throwing, so a cover that sharp cannot read stays a 404 placeholder in the
-   * grid instead of failing the request.
-   */
-  async ensureThumbnailForBook(bookId: number): Promise<string | null> {
-    const existing = this.thumbnailRepairs.get(bookId);
-    if (existing) return existing;
-
-    const pending = this.withThumbnailRepairSlot(() => this.repairMissingThumbnail(bookId));
-    this.thumbnailRepairs.set(bookId, pending);
-    try {
-      return await pending;
-    } finally {
-      if (this.thumbnailRepairs.get(bookId) === pending) this.thumbnailRepairs.delete(bookId);
-    }
-  }
-
   // ── Audio helpers ────────────────────────────────────────────────────────────
 
   /**
@@ -866,170 +924,26 @@ export class MetadataService {
   // ── Cover ────────────────────────────────────────────────────────────────────
 
   /**
-   * Saves cover bytes to disk and updates the cover source in the DB.
-   * When overwrite is false, the cover source is only set if it is currently null
-   * (first-writer-wins, used during initial scan of non-primary files).
-   * When overwrite is true, the cover source is always updated
-   * (used for audio primary files and manually uploaded covers).
+   * Saves extracted cover bytes into the medium's slot, resolving false when the slot is locked.
+   * When overwrite is false a custom cover in the slot is kept and only its extracted fallback is
+   * refreshed. When overwrite is true the extracted cover replaces it (used for the leading source
+   * and fetched covers).
    */
-  private async persistCover(bookId: number, bytes: Buffer, overwrite: boolean): Promise<void> {
-    if (await this.bookMetadataLockService.isFieldLocked(bookId, 'cover')) return;
-    const ext = imageExt(bytes);
-    const dir = bookCoverDirPath(this.appDataPath, bookId);
-    await mkdir(dir, { recursive: true });
-
-    const files = await readdir(dir).catch(() => [] as string[]);
-    const [currentCover] = await this.db
-      .select({ coverSource: bookMetadata.coverSource })
-      .from(bookMetadata)
-      .where(eq(bookMetadata.bookId, bookId))
-      .limit(1);
-    const customCoverFileName = files.find(isCustomBookCoverFileName);
-    const storedCustomCoverMissing = !overwrite && currentCover?.coverSource === 'custom' && customCoverFileName === undefined;
-    const preserveCustom = !overwrite && currentCover?.coverSource === 'custom' && customCoverFileName !== undefined;
-    // An empty listing cannot tell a deleted custom cover apart from cover storage that failed to
-    // mount, and mkdir above recreates the directory either way. Only demote the stored source when
-    // some other artifact proves the directory is the real one.
-    const replaceMissingCustom = storedCustomCoverMissing && files.length > 0;
-
-    const staleCoverFiles = files.filter(
-      (fileName) => isExtractedBookCoverFileName(fileName) || (!preserveCustom && isCustomBookCoverFileName(fileName)),
-    );
-    await Promise.all(staleCoverFiles.map((fileName) => rm(join(dir, fileName), { force: true })));
-
-    await writeFile(join(dir, `${COVER_EXTRACTED_FILE_PREFIX}${ext}`), bytes);
-
-    let thumbnailUpdated = false;
-    if (preserveCustom && customCoverFileName && !files.includes(COVER_THUMBNAIL_FILE_NAME)) {
-      const customCover = await readFile(join(dir, customCoverFileName));
-      const thumbnail = await generateThumbnail(customCover);
-      await writeFile(bookThumbnailPath(this.appDataPath, bookId), thumbnail);
-      thumbnailUpdated = true;
-    } else if (!preserveCustom) {
-      const thumbnail = await generateThumbnail(bytes);
-      await writeFile(bookThumbnailPath(this.appDataPath, bookId), thumbnail);
-      thumbnailUpdated = true;
-    }
-
-    const now = new Date();
-
-    if (overwrite || replaceMissingCustom) {
-      await this.db.update(bookMetadata).set({ coverSource: EXTRACTED_COVER_SOURCE, updatedAt: now }).where(eq(bookMetadata.bookId, bookId));
-    } else {
-      await this.db
-        .update(bookMetadata)
-        .set({ coverSource: EXTRACTED_COVER_SOURCE })
-        .where(and(eq(bookMetadata.bookId, bookId), isNull(bookMetadata.coverSource)));
-    }
-
-    if (thumbnailUpdated) {
-      // A served cover artifact was rewritten, so its cache version must move even when the
-      // first-writer-wins update above matched no row.
-      await this.db.update(bookMetadata).set({ coverUpdatedAt: now }).where(eq(bookMetadata.bookId, bookId));
-      await this.db.update(books).set({ updatedAt: now }).where(eq(books.id, bookId));
-    }
+  private async persistCover(bookId: number, medium: CoverMedium, bytes: Buffer, overwrite: boolean, origin: BookCoverOrigin): Promise<boolean> {
+    return this.coverStore.saveExtracted(bookId, medium, bytes, { origin, overwrite });
   }
 
-  private async repairMissingThumbnail(bookId: number): Promise<string | null> {
-    const event = 'metadata.thumbnail_repair';
-    const startedAt = Date.now();
-    const dir = bookCoverDirPath(this.appDataPath, bookId);
-    const thumbnailPath = bookThumbnailPath(this.appDataPath, bookId);
-
-    try {
-      const files = await readdir(dir);
-      if (files.includes(COVER_THUMBNAIL_FILE_NAME)) return thumbnailPath;
-
-      const coverFileName = findPreferredBookCoverFileName(files);
-      if (!coverFileName) {
-        this.logger.debug(
-          `[${event}] [end] bookId=${bookId} durationMs=${Date.now() - startedAt} repaired=false coverFound=false - thumbnail repair skipped`,
-        );
-        return null;
-      }
-
-      const cover = await readFile(join(dir, coverFileName));
-      const thumbnail = await generateThumbnail(cover);
-      await this.publishRepairedThumbnail(dir, thumbnailPath, thumbnail);
-      this.logger.log(
-        `[${event}] [end] bookId=${bookId} durationMs=${Date.now() - startedAt} repaired=true source="${sanitizeLogValue(coverFileName)}" - thumbnail repair completed`,
-      );
-      return thumbnailPath;
-    } catch (error) {
-      const code = (error as NodeJS.ErrnoException | undefined)?.code;
-      if (code === 'ENOENT' || code === 'ENOTDIR') {
-        this.logger.debug(
-          `[${event}] [end] bookId=${bookId} durationMs=${Date.now() - startedAt} repaired=false coverFound=false - thumbnail repair skipped`,
-        );
-        return null;
-      }
-      const errorClass = error instanceof Error ? error.name : 'Error';
-      const errorMessage = sanitizeLogValue(error instanceof Error ? error.message : String(error));
-      this.logger.warn(
-        `[${event}] [fail] bookId=${bookId} durationMs=${Date.now() - startedAt} errorClass=${errorClass} error="${errorMessage}" - thumbnail repair failed`,
-      );
-      return null;
+  /** An OPF image belongs to no medium, so on a book with both media its shape picks the slot. */
+  private async persistSourceCover(bookId: number, format: string, bytes: Buffer): Promise<boolean> {
+    if (format === 'opf') {
+      const medium = await this.coverStore.chooseSidecarMedium(bookId, bytes);
+      return this.persistCover(bookId, medium, bytes, true, 'opf');
     }
+    return this.persistCover(bookId, this.mediumForFormat(format), bytes, true, 'embedded');
   }
 
-  /**
-   * Publishes the repaired thumbnail from a fully written temporary file, so an interrupted write
-   * can never leave a truncated thumbnail at the served path. Nothing validates a thumbnail beyond
-   * its filename, so a truncated one would be permanent.
-   *
-   * A hard link is preferred because it also fails when the path already exists, leaving a cover
-   * write that landed first in possession of its own thumbnail. Network mounts without hard links
-   * fall back to rename, which is still atomic and so still cannot publish a partial file; it only
-   * loses the exclusive create, and losing that race costs a thumbnail that is stale by
-   * milliseconds rather than one that is broken forever.
-   */
-  private async publishRepairedThumbnail(dir: string, thumbnailPath: string, bytes: Buffer): Promise<void> {
-    const tempPath = join(dir, `.thumbnail-repair-${randomUUID()}.tmp`);
-    try {
-      await writeFile(tempPath, bytes);
-      try {
-        await link(tempPath, thumbnailPath);
-        return;
-      } catch (error) {
-        if ((error as NodeJS.ErrnoException | undefined)?.code === 'EEXIST') return;
-      }
-
-      try {
-        await access(thumbnailPath);
-        return;
-      } catch {
-        // No thumbnail published yet, so this repair still has something to contribute.
-      }
-      await rename(tempPath, thumbnailPath);
-    } finally {
-      await rm(tempPath, { force: true });
-    }
-  }
-
-  private async withThumbnailRepairSlot<T>(operation: () => Promise<T>): Promise<T> {
-    await this.acquireThumbnailRepairSlot();
-    try {
-      return await operation();
-    } finally {
-      this.releaseThumbnailRepairSlot();
-    }
-  }
-
-  private async acquireThumbnailRepairSlot(): Promise<void> {
-    if (this.activeThumbnailRepairs < THUMBNAIL_REPAIR_CONCURRENCY) {
-      this.activeThumbnailRepairs++;
-      return;
-    }
-    await new Promise<void>((resolve) => this.thumbnailRepairWaiters.push(resolve));
-  }
-
-  private releaseThumbnailRepairSlot(): void {
-    const next = this.thumbnailRepairWaiters.shift();
-    if (next) {
-      next();
-      return;
-    }
-    this.activeThumbnailRepairs--;
+  private mediumForFormat(format: string): CoverMedium {
+    return isAudioFormat(format) ? 'audio' : 'ebook';
   }
 
   private normalizeUniqueRelationNames(values: string[]): string[] {
diff --git a/server/src/modules/migration/executor/cover.importer.test.ts b/server/src/modules/migration/executor/cover.importer.test.ts
index 72e7fc281..b15f0afc3 100644
--- a/server/src/modules/migration/executor/cover.importer.test.ts
+++ b/server/src/modules/migration/executor/cover.importer.test.ts
@@ -1,4 +1,4 @@
-import { mkdtemp, readdir, rm, writeFile } from 'fs/promises';
+import { mkdir, mkdtemp, rm, symlink, writeFile } from 'fs/promises';
 import { tmpdir } from 'os';
 import { join } from 'path';
 
@@ -8,15 +8,12 @@ function makeImporter() {
   const repo = {
     setRunMetric: vi.fn().mockResolvedValue(undefined),
   };
-  const importRepo = {
-    fetchLibraryIdsByBookIds: vi.fn().mockResolvedValue(new Map<number, number>()),
-    markCoverAsCustom: vi.fn().mockResolvedValue(undefined),
+  const coverStore = {
+    chooseWriteMedium: vi.fn().mockResolvedValue('ebook'),
+    saveCustom: vi.fn().mockResolvedValue(true),
   };
-  const scanGateway = {
-    emitCoverRefreshed: vi.fn(),
-  };
-  const importer = new CoverImporter(repo as never, importRepo as never, scanGateway as never);
-  return { importer, repo, importRepo, scanGateway };
+  const importer = new CoverImporter(repo as never, coverStore as never);
+  return { importer, repo, coverStore };
 }
 
 describe('CoverImporter', () => {
@@ -25,8 +22,7 @@ describe('CoverImporter', () => {
   });
 
   it('counts rejected per-book tasks as failed while continuing batch processing', async () => {
-    const { importer, repo, importRepo, scanGateway } = makeImporter();
-    importRepo.fetchLibraryIdsByBookIds.mockResolvedValue(new Map([[901, 12]]));
+    const { importer, repo } = makeImporter();
     const processSingleMatch = vi
       .spyOn(importer as any, 'processSingleMatch')
       .mockResolvedValueOnce('imported')
@@ -48,7 +44,6 @@ describe('CoverImporter', () => {
     );
 
     expect(processSingleMatch).toHaveBeenCalledTimes(2);
-    expect(scanGateway.emitCoverRefreshed).toHaveBeenCalledWith({ bookId: 901, libraryId: 12 });
     expect(repo.setRunMetric).toHaveBeenCalledWith(
       41,
       'book_covers',
@@ -63,12 +58,17 @@ describe('CoverImporter', () => {
 
   it('returns failed when importing a single cover throws after reading source cover bytes', async () => {
     const { importer } = makeImporter();
-    vi.spyOn(importer as any, 'readOptionalFile').mockResolvedValue(Buffer.from('cover-bytes'));
-    vi.spyOn(importer as any, 'importSingleCover').mockRejectedValue(new Error('invalid image payload'));
+    const tempRoot = await mkdtemp(join(tmpdir(), 'cover-importer-failure-'));
+    try {
+      const sourceDir = join(tempRoot, 'images', 'source-1');
+      await mkdir(sourceDir, { recursive: true });
+      await writeFile(join(sourceDir, 'cover.jpg'), Buffer.from('cover-bytes'));
+      vi.spyOn(importer as any, 'importSingleCover').mockRejectedValue(new Error('invalid image payload'));
 
-    await expect((importer as any).processSingleMatch(99, { sourceBookId: 'source-1', targetBookId: 901 }, '/app', '/source-media')).resolves.toBe(
-      'failed',
-    );
+      await expect((importer as any).processSingleMatch(99, { sourceBookId: 'source-1', targetBookId: 901 }, tempRoot)).resolves.toBe('failed');
+    } finally {
+      await rm(tempRoot, { recursive: true, force: true });
+    }
   });
 
   it('readOptionalFile returns null for ENOENT and rethrows non-ENOENT read errors', async () => {
@@ -82,35 +82,37 @@ describe('CoverImporter', () => {
     }
   });
 
-  it('deleteFilesByPrefix removes only matching files and keeps unrelated entries', async () => {
-    const { importer } = makeImporter();
-    const tempRoot = await mkdtemp(join(tmpdir(), 'cover-importer-delete-'));
-    try {
-      await writeFile(join(tempRoot, 'cover_custom.jpg'), 'cover');
-      await writeFile(join(tempRoot, 'cover_custom.png'), 'cover');
-      await writeFile(join(tempRoot, 'thumbnail.jpg'), 'thumb');
+  it('routes imported bytes through the slot store as a legacy custom cover', async () => {
+    const { importer, coverStore } = makeImporter();
+    const bytes = Buffer.from('cover-bytes');
 
-      await (importer as any).deleteFilesByPrefix(tempRoot, 'cover_custom.');
-      const remaining = await readdir(tempRoot);
+    await (importer as any).importSingleCover(901, bytes);
 
-      expect(remaining).toEqual(['thumbnail.jpg']);
-    } finally {
-      await rm(tempRoot, { recursive: true, force: true });
-    }
+    expect(coverStore.chooseWriteMedium).toHaveBeenCalledWith(901, bytes);
+    expect(coverStore.saveCustom).toHaveBeenCalledWith(901, 'ebook', bytes, { origin: 'legacy' });
   });
 
-  it('readDirIfExists/removeFileIfPresent handle ENOENT and still surface other fs errors', async () => {
-    const { importer } = makeImporter();
-    const tempRoot = await mkdtemp(join(tmpdir(), 'cover-importer-fs-'));
-    const existingFile = join(tempRoot, 'existing.txt');
-    await writeFile(existingFile, 'x');
+  it('rejects source identifiers that escape the images directory', async () => {
+    const { importer, coverStore } = makeImporter();
 
+    await expect((importer as any).processSingleMatch(99, { sourceBookId: '../escape', targetBookId: 901 }, '/source-media')).resolves.toBe(
+      'unresolved',
+    );
+    expect(coverStore.saveCustom).not.toHaveBeenCalled();
+  });
+
+  it('rejects a source cover symlink that escapes its source directory', async () => {
+    const { importer, coverStore } = makeImporter();
+    const tempRoot = await mkdtemp(join(tmpdir(), 'cover-importer-symlink-'));
     try {
-      await expect((importer as any).readDirIfExists(join(tempRoot, 'missing-dir'))).resolves.toEqual([]);
-      await expect((importer as any).removeFileIfPresent(join(tempRoot, 'missing.txt'))).resolves.toBeUndefined();
+      const sourceDir = join(tempRoot, 'images', 'source-1');
+      const outsideCover = join(tempRoot, 'outside.jpg');
+      await mkdir(sourceDir, { recursive: true });
+      await writeFile(outsideCover, Buffer.from('outside-cover'));
+      await symlink(outsideCover, join(sourceDir, 'cover.jpg'));
 
-      await expect((importer as any).readDirIfExists(existingFile)).rejects.toBeInstanceOf(Error);
-      await expect((importer as any).removeFileIfPresent(tempRoot)).rejects.toBeInstanceOf(Error);
+      await expect((importer as any).processSingleMatch(99, { sourceBookId: 'source-1', targetBookId: 901 }, tempRoot)).resolves.toBe('unresolved');
+      expect(coverStore.saveCustom).not.toHaveBeenCalled();
     } finally {
       await rm(tempRoot, { recursive: true, force: true });
     }
diff --git a/server/src/modules/migration/executor/cover.importer.ts b/server/src/modules/migration/executor/cover.importer.ts
index f41129b9e..678215bbf 100644
--- a/server/src/modules/migration/executor/cover.importer.ts
+++ b/server/src/modules/migration/executor/cover.importer.ts
@@ -1,14 +1,10 @@
 import { Injectable, Logger } from '@nestjs/common';
-import { constants as fsConstants } from 'fs';
-import { access, mkdir, readdir, readFile, unlink, writeFile } from 'fs/promises';
-import { join } from 'path';
+import { readFile, realpath } from 'fs/promises';
+import { isAbsolute, join, relative, resolve, sep } from 'path';
 
-import type { CoverRefreshedEvent } from '@bookorbit/types';
-import { COVER_CUSTOM_FILE_PREFIX, COVER_THUMBNAIL_FILE_NAME, bookCoverDirPath } from '../../../common/book-cover-storage';
-import { generateThumbnail, imageExt } from '../../metadata/lib/cover';
+import { sanitizeLogValue } from '../../../common/utils/log-sanitize.utils';
 import { MigrationRepository } from '../migration.repository';
-import { MigrationImportRepository } from './migration-import.repository';
-import { ScanGateway } from '../../scanner/scan.gateway';
+import { BookCoverStore } from '../../book-cover-store/book-cover-store.service';
 import type { PlannerResult } from '../planner/planner.types';
 import { type RunStateCheck, emptyCounters, hasErrorCode } from './executor-utils';
 
@@ -20,14 +16,13 @@ export class CoverImporter {
 
   constructor(
     private readonly repo: MigrationRepository,
-    private readonly importRepo: MigrationImportRepository,
-    private readonly scanGateway: ScanGateway,
+    private readonly coverStore: BookCoverStore,
   ) {}
 
   async import(
     runId: number,
     planned: PlannerResult,
-    appDataPath: string,
+    _appDataPath: string,
     sourceMediaRootPath: string | null,
     ensureRunning: RunStateCheck,
   ): Promise<void> {
@@ -41,26 +36,17 @@ export class CoverImporter {
       return;
     }
 
-    const libraryIdByBookId = await this.importRepo.fetchLibraryIdsByBookIds(matches.map((m) => m.targetBookId));
-
     for (let i = 0; i < matches.length; i += COVER_CONCURRENCY) {
       await ensureRunning();
       const batch = matches.slice(i, i + COVER_CONCURRENCY);
 
-      const results = await Promise.allSettled(batch.map((match) => this.processSingleMatch(runId, match, appDataPath, sourceMediaRootPath)));
+      const results = await Promise.allSettled(batch.map((match) => this.processSingleMatch(runId, match, sourceMediaRootPath)));
 
       for (let j = 0; j < results.length; j++) {
         const result = results[j];
-        const match = batch[j];
         counters.processed += 1;
         if (result.status === 'fulfilled') {
           counters[result.value] += 1;
-          if (result.value === 'imported') {
-            const libraryId = libraryIdByBookId.get(match.targetBookId);
-            if (libraryId) {
-              this.scanGateway.emitCoverRefreshed({ bookId: match.targetBookId, libraryId } satisfies CoverRefreshedEvent);
-            }
-          }
         } else {
           counters.failed += 1;
         }
@@ -73,38 +59,34 @@ export class CoverImporter {
   private async processSingleMatch(
     runId: number,
     match: { sourceBookId: string; targetBookId: number },
-    appDataPath: string,
     sourceMediaRootPath: string,
   ): Promise<'imported' | 'unresolved' | 'failed'> {
-    const sourceImageDir = join(sourceMediaRootPath, 'images', match.sourceBookId);
-    const sourceCoverPath = join(sourceImageDir, 'cover.jpg');
-    const sourceThumbnailPath = join(sourceImageDir, 'thumbnail.jpg');
+    const imagesRoot = resolve(sourceMediaRootPath, 'images');
+    const sourceImageDir = resolve(imagesRoot, match.sourceBookId);
+    const relativeSourceDir = relative(imagesRoot, sourceImageDir);
+    if (!relativeSourceDir || relativeSourceDir.startsWith('..') || resolve(imagesRoot, relativeSourceDir) !== sourceImageDir) return 'unresolved';
+    const sourceCoverPath = await this.resolveSafeCoverPath(imagesRoot, sourceImageDir);
+    if (!sourceCoverPath) return 'unresolved';
     const coverBytes = await this.readOptionalFile(sourceCoverPath);
     if (!coverBytes) return 'unresolved';
 
     try {
-      await this.importSingleCover(match.targetBookId, appDataPath, coverBytes, sourceThumbnailPath);
+      await this.importSingleCover(match.targetBookId, coverBytes);
       return 'imported';
     } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      this.logger.warn(`[migration.cover] runId=${runId} sourceBookId=${match.sourceBookId} targetBookId=${match.targetBookId} error="${message}"`);
+      const errorClass = error instanceof Error ? error.name : 'Error';
+      const message = sanitizeLogValue(error instanceof Error ? error.message : String(error));
+      const sourceBookId = sanitizeLogValue(match.sourceBookId);
+      this.logger.warn(
+        `[migration.cover] [fail] runId=${runId} sourceBookId="${sourceBookId}" targetBookId=${match.targetBookId} errorClass=${errorClass} error="${message}" - cover import failed`,
+      );
       return 'failed';
     }
   }
 
-  private async importSingleCover(targetBookId: number, appDataPath: string, coverBytes: Buffer, sourceThumbnailPath: string): Promise<void> {
-    const targetCoverDir = bookCoverDirPath(appDataPath, targetBookId);
-    await mkdir(targetCoverDir, { recursive: true });
-    await this.deleteFilesByPrefix(targetCoverDir, COVER_CUSTOM_FILE_PREFIX);
-
-    const coverExt = imageExt(coverBytes);
-    await writeFile(join(targetCoverDir, `${COVER_CUSTOM_FILE_PREFIX}${coverExt}`), coverBytes);
-
-    const sourceThumbnailBytes = await this.readOptionalFile(sourceThumbnailPath);
-    const thumbnailBytes = sourceThumbnailBytes ?? (await generateThumbnail(coverBytes));
-    await writeFile(join(targetCoverDir, COVER_THUMBNAIL_FILE_NAME), thumbnailBytes);
-
-    await this.importRepo.markCoverAsCustom(targetBookId);
+  private async importSingleCover(targetBookId: number, coverBytes: Buffer): Promise<void> {
+    const medium = await this.coverStore.chooseWriteMedium(targetBookId, coverBytes);
+    await this.coverStore.saveCustom(targetBookId, medium, coverBytes, { origin: 'legacy' });
   }
 
   private async readOptionalFile(path: string): Promise<Buffer | null> {
@@ -116,30 +98,20 @@ export class CoverImporter {
     }
   }
 
-  private async deleteFilesByPrefix(dirPath: string, prefix: string): Promise<void> {
-    const files = await this.readDirIfExists(dirPath);
-    for (const fileName of files) {
-      if (!fileName.startsWith(prefix)) continue;
-      await this.removeFileIfPresent(join(dirPath, fileName));
-    }
-  }
-
-  private async readDirIfExists(dirPath: string): Promise<string[]> {
+  private async resolveSafeCoverPath(imagesRoot: string, sourceImageDir: string): Promise<string | null> {
     try {
-      await access(dirPath, fsConstants.R_OK);
-      return await readdir(dirPath);
+      const [realImagesRoot, realSourceDir] = await Promise.all([realpath(imagesRoot), realpath(sourceImageDir)]);
+      if (!this.isContainedPath(realImagesRoot, realSourceDir)) return null;
+      const realCoverPath = await realpath(join(realSourceDir, 'cover.jpg'));
+      return this.isContainedPath(realSourceDir, realCoverPath) ? realCoverPath : null;
     } catch (error) {
-      if (hasErrorCode(error, 'ENOENT')) return [];
+      if (hasErrorCode(error, 'ENOENT') || hasErrorCode(error, 'ENOTDIR')) return null;
       throw error;
     }
   }
 
-  private async removeFileIfPresent(filePath: string): Promise<void> {
-    try {
-      await unlink(filePath);
-    } catch (error) {
-      if (hasErrorCode(error, 'ENOENT')) return;
-      throw error;
-    }
+  private isContainedPath(root: string, target: string): boolean {
+    const relativePath = relative(root, target);
+    return relativePath !== '' && relativePath !== '..' && !relativePath.startsWith(`..${sep}`) && !isAbsolute(relativePath);
   }
 }
diff --git a/server/src/modules/migration/executor/migration-executor.service.test.ts b/server/src/modules/migration/executor/migration-executor.service.test.ts
index fcc776752..545a15a76 100644
--- a/server/src/modules/migration/executor/migration-executor.service.test.ts
+++ b/server/src/modules/migration/executor/migration-executor.service.test.ts
@@ -1,4 +1,4 @@
-import { mkdir, mkdtemp, readFile, readdir, rm, writeFile } from 'fs/promises';
+import { mkdir, mkdtemp, rm, writeFile } from 'fs/promises';
 import { tmpdir } from 'os';
 import { join } from 'path';
 import sharp from 'sharp';
@@ -27,9 +27,10 @@ function createRepoMock() {
   };
 }
 
-function createScanGatewayMock() {
+function createCoverStoreMock() {
   return {
-    emitCoverRefreshed: vi.fn(),
+    chooseWriteMedium: vi.fn().mockResolvedValue('ebook'),
+    saveCustom: vi.fn().mockResolvedValue(true),
   };
 }
 
@@ -292,22 +293,17 @@ describe('SharedOverlaysImporter author import', () => {
 });
 
 describe('CoverImporter book cover import', () => {
-  it('copies source cover and thumbnail into target cover directory and marks cover source custom', async () => {
+  it('reads the source cover and stores it as a legacy custom slot', async () => {
     const sourceRoot = await mkdtemp(join(tmpdir(), 'migration-source-media-'));
-    const booksPath = await mkdtemp(join(tmpdir(), 'migration-target-books-'));
     try {
       const sourceDir = join(sourceRoot, 'images', 'source-1');
       await mkdir(sourceDir, { recursive: true });
       const sourceCoverBytes = await createSampleImageBytes();
-      const sourceThumbnailBytes = await createSampleImageBytes();
       await writeFile(join(sourceDir, 'cover.jpg'), sourceCoverBytes);
-      await writeFile(join(sourceDir, 'thumbnail.jpg'), sourceThumbnailBytes);
 
       const repo = createRepoMock();
-      const importRepo = createImportRepoMock();
-      const scanGateway = createScanGatewayMock();
-      importRepo.fetchLibraryIdsByBookIds.mockResolvedValue(new Map([[901, 1]]));
-      const importer = new CoverImporter(repo as never, importRepo as never, scanGateway as never);
+      const coverStore = createCoverStoreMock();
+      const importer = new CoverImporter(repo as never, coverStore as never);
 
       const planned = {
         execution: {
@@ -315,21 +311,10 @@ describe('CoverImporter book cover import', () => {
         },
       };
 
-      await importer.import(52, planned as never, booksPath, sourceRoot, async () => {});
+      await importer.import(52, planned as never, '/target-books', sourceRoot, async () => {});
 
-      const targetDir = join(booksPath, 'covers', '901');
-      const targetFiles = await readdir(targetDir);
-      const copiedCoverName = targetFiles.find((entry) => entry.startsWith('cover_custom.'));
-      expect(copiedCoverName).toBeTruthy();
-      expect(targetFiles).toContain('thumbnail.jpg');
-
-      const copiedCoverBytes = await readFile(join(targetDir, copiedCoverName!));
-      const copiedThumbnailBytes = await readFile(join(targetDir, 'thumbnail.jpg'));
-      expect(copiedCoverBytes.equals(sourceCoverBytes)).toBe(true);
-      expect(copiedThumbnailBytes.equals(sourceThumbnailBytes)).toBe(true);
-
-      expect(importRepo.markCoverAsCustom).toHaveBeenCalledWith(901);
-      expect(scanGateway.emitCoverRefreshed).toHaveBeenCalledWith({ bookId: 901, libraryId: 1 });
+      expect(coverStore.chooseWriteMedium).toHaveBeenCalledWith(901, sourceCoverBytes);
+      expect(coverStore.saveCustom).toHaveBeenCalledWith(901, 'ebook', sourceCoverBytes, { origin: 'legacy' });
       expect(repo.setRunMetric).toHaveBeenCalledWith(
         52,
         'book_covers',
@@ -338,23 +323,18 @@ describe('CoverImporter book cover import', () => {
       );
     } finally {
       await rm(sourceRoot, { recursive: true, force: true });
-      await rm(booksPath, { recursive: true, force: true });
     }
   });
 
-  it('generates target thumbnail when source thumbnail is missing', async () => {
+  it('counts a missing source cover as unresolved', async () => {
     const sourceRoot = await mkdtemp(join(tmpdir(), 'migration-source-media-'));
-    const booksPath = await mkdtemp(join(tmpdir(), 'migration-target-books-'));
     try {
       const sourceDir = join(sourceRoot, 'images', 'source-2');
       await mkdir(sourceDir, { recursive: true });
-      await writeFile(join(sourceDir, 'cover.jpg'), await createSampleImageBytes());
 
       const repo = createRepoMock();
-      const importRepo = createImportRepoMock();
-      const scanGateway = createScanGatewayMock();
-      importRepo.fetchLibraryIdsByBookIds.mockResolvedValue(new Map([[902, 1]]));
-      const importer = new CoverImporter(repo as never, importRepo as never, scanGateway as never);
+      const coverStore = createCoverStoreMock();
+      const importer = new CoverImporter(repo as never, coverStore as never);
 
       const planned = {
         execution: {
@@ -362,28 +342,24 @@ describe('CoverImporter book cover import', () => {
         },
       };
 
-      await importer.import(53, planned as never, booksPath, sourceRoot, async () => {});
+      await importer.import(53, planned as never, '/target-books', sourceRoot, async () => {});
 
-      const generatedThumbnail = await readFile(join(booksPath, 'covers', '902', 'thumbnail.jpg'));
-      expect(generatedThumbnail.length).toBeGreaterThan(0);
-      expect(scanGateway.emitCoverRefreshed).toHaveBeenCalledWith({ bookId: 902, libraryId: 1 });
+      expect(coverStore.saveCustom).not.toHaveBeenCalled();
       expect(repo.setRunMetric).toHaveBeenCalledWith(
         53,
         'book_covers',
         'book_covers',
-        expect.objectContaining({ processed: 1, imported: 1, unresolved: 0, failed: 0 }),
+        expect.objectContaining({ processed: 1, imported: 0, unresolved: 1, failed: 0 }),
       );
     } finally {
       await rm(sourceRoot, { recursive: true, force: true });
-      await rm(booksPath, { recursive: true, force: true });
     }
   });
 
   it('skips book cover stage when source media root is not configured', async () => {
     const repo = createRepoMock();
-    const importRepo = createImportRepoMock();
-    const scanGateway = createScanGatewayMock();
-    const importer = new CoverImporter(repo as never, importRepo as never, scanGateway as never);
+    const coverStore = createCoverStoreMock();
+    const importer = new CoverImporter(repo as never, coverStore as never);
 
     const planned = {
       execution: {
@@ -393,8 +369,7 @@ describe('CoverImporter book cover import', () => {
 
     await importer.import(54, planned as never, '/tmp/books', null, async () => {});
 
-    expect(importRepo.markCoverAsCustom).not.toHaveBeenCalled();
-    expect(scanGateway.emitCoverRefreshed).not.toHaveBeenCalled();
+    expect(coverStore.saveCustom).not.toHaveBeenCalled();
     expect(repo.setRunMetric).toHaveBeenCalledWith(
       54,
       'book_covers',
diff --git a/server/src/modules/migration/migration.module.ts b/server/src/modules/migration/migration.module.ts
index 545146209..35979c94f 100644
--- a/server/src/modules/migration/migration.module.ts
+++ b/server/src/modules/migration/migration.module.ts
@@ -6,6 +6,7 @@ import type { StringValue } from 'ms';
 import { AuthModule } from '../auth/auth.module';
 import { NotificationModule } from '../notification/notification.module';
 import { ScannerModule } from '../scanner/scanner.module';
+import { BookCoverStoreModule } from '../book-cover-store/book-cover-store.module';
 import { MigrationController } from './migration.controller';
 import { MigrationProgressGateway } from './migration-progress.gateway';
 import { MigrationRepository } from './migration.repository';
@@ -39,6 +40,7 @@ import { MigrationReportingService } from './reporting/migration-reporting.servi
     AuthModule,
     forwardRef(() => NotificationModule),
     ScannerModule,
+    BookCoverStoreModule,
     JwtModule.registerAsync({
       inject: [ConfigService],
       useFactory: (config: ConfigService) => ({
diff --git a/server/src/modules/opds/opds.controller.test.ts b/server/src/modules/opds/opds.controller.test.ts
index a50ce09dc..a9c697ef2 100644
--- a/server/src/modules/opds/opds.controller.test.ts
+++ b/server/src/modules/opds/opds.controller.test.ts
@@ -3,19 +3,17 @@ vi.mock('fs', () => ({
 }));
 
 vi.mock('fs/promises', () => ({
-  readdir: vi.fn(),
   stat: vi.fn(),
 }));
 
 import { createReadStream } from 'fs';
-import { readdir, stat } from 'fs/promises';
+import { stat } from 'fs/promises';
 import { BadRequestException, NotFoundException } from '@nestjs/common';
 import type { MockedFunction } from 'vitest';
 
 import { OpdsController } from './opds.controller';
 
 const mockCreateReadStream = createReadStream as MockedFunction<typeof createReadStream>;
-const mockReaddir = readdir as MockedFunction<typeof readdir>;
 const mockStat = stat as MockedFunction<typeof stat>;
 
 function makeController() {
@@ -49,22 +47,19 @@ function makeController() {
       authorName: 'Author Name',
     }),
   } as never;
-  const config = {
-    get: vi.fn().mockReturnValue('/books'),
-  } as never;
   const bookService = {
     resolveDownloadFilename: vi.fn().mockResolvedValue('BadTitle - Author.epub'),
   } as never;
-  const metadataService = {
-    ensureThumbnailForBook: vi.fn().mockResolvedValue(null),
+  const coverStore = {
+    resolve: vi.fn().mockResolvedValue(null),
   };
 
   return {
-    controller: new OpdsController(opdsService, opdsBookService, config, bookService, metadataService as never),
+    controller: new OpdsController(opdsService, opdsBookService, bookService, coverStore as never),
     opdsService,
     opdsBookService,
     bookService,
-    metadataService,
+    coverStore,
   };
 }
 
@@ -252,30 +247,31 @@ describe('OpdsController', () => {
     expect(reply.send).toHaveBeenCalledWith('<search />');
   });
 
-  it('serves the preferred stored cover file for OPDS clients', async () => {
-    const { controller, opdsBookService } = makeController();
+  it('serves the ebook cover the slot store resolves for OPDS clients', async () => {
+    const { controller, opdsBookService, coverStore } = makeController();
     const reply = makeReply();
     const stream = { kind: 'stream' };
 
-    mockReaddir.mockResolvedValue(['cover_extracted.jpg', 'cover_custom.png'] as never);
+    coverStore.resolve.mockResolvedValue('/books/covers/42/ebook/cover_custom.png');
     mockStat.mockResolvedValue({ mtimeMs: 1234 } as never);
     mockCreateReadStream.mockReturnValue(stream as never);
 
     await controller.cover(42, { userId: 7, isSuperuser: false } as never, reply);
 
     expect(opdsBookService.validateBookAccess).toHaveBeenCalledWith(42, 7, false, undefined);
+    expect(coverStore.resolve).toHaveBeenCalledWith(42, { medium: 'ebook', variant: 'cover' });
     expect(reply.header).toHaveBeenCalledWith('Cross-Origin-Resource-Policy', 'cross-origin');
-    expect(mockCreateReadStream).toHaveBeenCalledWith('/books/covers/42/cover_custom.png');
+    expect(mockCreateReadStream).toHaveBeenCalledWith('/books/covers/42/ebook/cover_custom.png');
     expect(reply.header).toHaveBeenCalledWith('ETag', '"1234"');
     expect(reply.type).toHaveBeenCalledWith('image/png');
     expect(reply.send).toHaveBeenCalledWith(stream);
   });
 
   it('returns 304 when cover ETag matches If-None-Match', async () => {
-    const { controller } = makeController();
+    const { controller, coverStore } = makeController();
     const reply = makeReply();
 
-    mockReaddir.mockResolvedValue(['cover_custom.jpg'] as never);
+    coverStore.resolve.mockResolvedValue('/books/covers/42/ebook/cover_custom.jpg');
     mockStat.mockResolvedValue({ mtimeMs: 5000 } as never);
 
     await controller.cover(42, { userId: 7, isSuperuser: false } as never, reply, '"5000"');
@@ -288,31 +284,35 @@ describe('OpdsController', () => {
 
   it('throws NotFoundException when no cover exists', async () => {
     const { controller } = makeController();
-    mockReaddir.mockRejectedValue(new Error('missing dir'));
 
     await expect(controller.cover(42, { userId: 7, isSuperuser: false } as never, makeReply())).rejects.toThrow(NotFoundException);
+    expect(mockStat).not.toHaveBeenCalled();
   });
 
   it('serves thumbnail image when available', async () => {
-    const { controller } = makeController();
+    const { controller, coverStore } = makeController();
     const reply = makeReply();
     const stream = { kind: 'thumbnail-stream' };
 
+    coverStore.resolve.mockResolvedValue('/books/covers/12/ebook/thumbnail.jpg');
     mockStat.mockResolvedValue({ mtimeMs: 2222 } as never);
     mockCreateReadStream.mockReturnValue(stream as never);
 
     await controller.thumbnail(12, { userId: 1, isSuperuser: false } as never, reply);
 
+    expect(coverStore.resolve).toHaveBeenCalledWith(12, { medium: 'ebook', variant: 'thumbnail' });
     expect(reply.header).toHaveBeenCalledWith('Cross-Origin-Resource-Policy', 'cross-origin');
     expect(reply.type).toHaveBeenCalledWith('image/jpeg');
     expect(reply.header).toHaveBeenCalledWith('ETag', '"2222"');
+    expect(mockCreateReadStream).toHaveBeenCalledWith('/books/covers/12/ebook/thumbnail.jpg');
     expect(reply.send).toHaveBeenCalledWith(stream);
   });
 
   it('returns 304 for thumbnail when ETag matches', async () => {
-    const { controller } = makeController();
+    const { controller, coverStore } = makeController();
     const reply = makeReply();
 
+    coverStore.resolve.mockResolvedValue('/books/covers/12/ebook/thumbnail.jpg');
     mockStat.mockResolvedValue({ mtimeMs: 3333 } as never);
 
     await controller.thumbnail(12, { userId: 1, isSuperuser: false } as never, reply, '"3333"');
@@ -323,35 +323,45 @@ describe('OpdsController', () => {
     expect(mockCreateReadStream).not.toHaveBeenCalled();
   });
 
+  it('throws NotFoundException when the book has no thumbnail to serve', async () => {
+    const { controller } = makeController();
+
+    await expect(controller.thumbnail(12, { userId: 1, isSuperuser: false } as never, makeReply())).rejects.toThrow(NotFoundException);
+    expect(mockStat).not.toHaveBeenCalled();
+  });
+
   it('serves a thumbnail rebuilt on demand when the file is missing beside an intact cover', async () => {
-    const { controller, metadataService } = makeController();
+    const { controller, coverStore } = makeController();
     const reply = makeReply();
     const stream = { kind: 'repaired-thumbnail-stream' };
+    coverStore.resolve.mockResolvedValue('/books/covers/12/ebook/thumbnail.jpg');
     mockStat.mockRejectedValueOnce(Object.assign(new Error('missing thumbnail'), { code: 'ENOENT' })).mockResolvedValueOnce({ mtimeMs: 7777 });
-    metadataService.ensureThumbnailForBook.mockResolvedValueOnce('/books/covers/12/thumbnail.jpg');
     mockCreateReadStream.mockReturnValue(stream);
 
     await controller.thumbnail(12, { userId: 1, isSuperuser: false } as never, reply);
 
-    expect(metadataService.ensureThumbnailForBook).toHaveBeenCalledWith(12);
+    expect(coverStore.resolve).toHaveBeenCalledTimes(2);
     expect(reply.header).toHaveBeenCalledWith('ETag', '"7777"');
     expect(reply.send).toHaveBeenCalledWith(stream);
   });
 
   it('does not attempt a repair when the thumbnail stat fails for a reason other than a missing file', async () => {
-    const { controller, metadataService } = makeController();
+    const { controller, coverStore } = makeController();
+    coverStore.resolve.mockResolvedValue('/books/covers/42/ebook/thumbnail.jpg');
     mockStat.mockRejectedValue(Object.assign(new Error('permission denied'), { code: 'EACCES' }));
 
     await expect(controller.thumbnail(42, { userId: 7, isSuperuser: false } as never, makeReply())).rejects.toThrow(NotFoundException);
-    expect(metadataService.ensureThumbnailForBook).not.toHaveBeenCalled();
+    expect(coverStore.resolve).toHaveBeenCalledTimes(1);
   });
 
   it('throws NotFoundException when thumbnail file is missing and no cover can rebuild it', async () => {
-    const { controller, metadataService } = makeController();
+    const { controller, coverStore } = makeController();
+    coverStore.resolve.mockResolvedValueOnce('/books/covers/42/ebook/thumbnail.jpg').mockResolvedValueOnce(null);
     mockStat.mockRejectedValue(Object.assign(new Error('missing thumbnail'), { code: 'ENOENT' }));
 
     await expect(controller.thumbnail(42, { userId: 7, isSuperuser: false } as never, makeReply())).rejects.toThrow(NotFoundException);
-    expect(metadataService.ensureThumbnailForBook).toHaveBeenCalledWith(42);
+    expect(coverStore.resolve).toHaveBeenCalledTimes(2);
+    expect(mockCreateReadStream).not.toHaveBeenCalled();
   });
 
   it('downloads file with sanitized attachment name', async () => {
diff --git a/server/src/modules/opds/opds.controller.ts b/server/src/modules/opds/opds.controller.ts
index 49c5f1953..a192a4924 100644
--- a/server/src/modules/opds/opds.controller.ts
+++ b/server/src/modules/opds/opds.controller.ts
@@ -12,12 +12,9 @@ import {
   UseGuards,
 } from '@nestjs/common';
 import { createReadStream } from 'fs';
-import { readdir, stat } from 'fs/promises';
-import { join } from 'path';
-import { ConfigService } from '@nestjs/config';
+import { stat } from 'fs/promises';
 import type { FastifyReply } from 'fastify';
 
-import { bookCoverDirPath, bookThumbnailPath, findPreferredBookCoverFileName } from '../../common/book-cover-storage';
 import { MAX_OFFSET_ROWS, isOffsetWithinLimit } from '../../common/constants/pagination.constants';
 import { Public } from '../../common/decorators/public.decorator';
 import { imageContentTypeFromPath } from '../../common/image-content-type';
@@ -30,23 +27,18 @@ import { OpdsUser } from './opds-user.decorator';
 import { OpdsBookService } from './opds-book.service';
 import { OpdsService } from './opds.service';
 import { BookService } from '../book/book.service';
-import { MetadataService } from '../metadata/metadata.service';
+import { BookCoverStore } from '../book-cover-store/book-cover-store.service';
 
 @Controller('opds')
 @Public()
 @UseGuards(OpdsEnabledGuard, OpdsAuthGuard)
 export class OpdsController {
-  private readonly appDataPath: string;
-
   constructor(
     private readonly opdsService: OpdsService,
     private readonly opdsBookService: OpdsBookService,
-    private readonly config: ConfigService,
     private readonly bookService: BookService,
-    private readonly metadataService: MetadataService,
-  ) {
-    this.appDataPath = this.config.get<string>('storage.appDataPath')!;
-  }
+    private readonly coverStore: BookCoverStore,
+  ) {}
 
   private assertPaginationWindow(page: number, size: number): void {
     if (!isOffsetWithinLimit((page - 1) * size)) {
@@ -217,12 +209,9 @@ export class OpdsController {
   ) {
     await this.opdsBookService.validateBookAccess(bookId, user.userId, user.isSuperuser, user.contentFilters);
     reply.header('Cross-Origin-Resource-Policy', 'cross-origin');
-    const dir = bookCoverDirPath(this.appDataPath, bookId);
     try {
-      const files = await readdir(dir);
-      const cover = findPreferredBookCoverFileName(files);
-      if (!cover) throw new NotFoundException('No cover');
-      const coverPath = join(dir, cover);
+      const coverPath = await this.coverStore.resolve(bookId, { medium: 'ebook', variant: 'cover' });
+      if (!coverPath) throw new NotFoundException('No cover');
       const { mtimeMs } = await stat(coverPath);
       const etag = `"${Math.floor(mtimeMs)}"`;
       if (ifNoneMatch === etag) {
@@ -247,7 +236,8 @@ export class OpdsController {
   ) {
     await this.opdsBookService.validateBookAccess(bookId, user.userId, user.isSuperuser, user.contentFilters);
     reply.header('Cross-Origin-Resource-Policy', 'cross-origin');
-    const thumbnailPath = bookThumbnailPath(this.appDataPath, bookId);
+    let thumbnailPath = await this.coverStore.resolve(bookId, { medium: 'ebook', variant: 'thumbnail' });
+    if (!thumbnailPath) throw new NotFoundException('No thumbnail');
     let mtimeMs: number;
     try {
       ({ mtimeMs } = await stat(thumbnailPath));
@@ -258,13 +248,14 @@ export class OpdsController {
       if (code !== 'ENOENT' && code !== 'ENOTDIR') throw new NotFoundException('No thumbnail');
 
       // A thumbnail can be missing beside an intact cover (issue #1475); rebuild it once on demand.
-      const repaired = await this.metadataService.ensureThumbnailForBook(bookId);
+      const repaired = await this.coverStore.resolve(bookId, { medium: 'ebook', variant: 'thumbnail' });
       if (!repaired) throw new NotFoundException('No thumbnail');
       try {
         ({ mtimeMs } = await stat(repaired));
       } catch {
         throw new NotFoundException('No thumbnail');
       }
+      thumbnailPath = repaired;
     }
 
     const etag = `"${Math.floor(mtimeMs)}"`;
diff --git a/server/src/modules/opds/opds.module.test.ts b/server/src/modules/opds/opds.module.test.ts
index ae5a5a2f1..92cd532c0 100644
--- a/server/src/modules/opds/opds.module.test.ts
+++ b/server/src/modules/opds/opds.module.test.ts
@@ -5,7 +5,7 @@ import { MODULE_METADATA } from '@nestjs/common/constants';
 import { CommonModule } from '../../common/common.module';
 import { AppSettingsModule } from '../app-settings/app-settings.module';
 import { BookModule } from '../book/book.module';
-import { MetadataModule } from '../metadata/metadata.module';
+import { BookCoverStoreModule } from '../book-cover-store/book-cover-store.module';
 import { UserModule } from '../user/user.module';
 import { OpdsAuthGuard } from './opds-auth.guard';
 import { OpdsBookService } from './opds-book.service';
@@ -21,7 +21,7 @@ describe('OpdsModule', () => {
     expect(Reflect.getMetadata(MODULE_METADATA.IMPORTS, OpdsModule)).toEqual([
       AppSettingsModule,
       BookModule,
-      MetadataModule,
+      BookCoverStoreModule,
       UserModule,
       CommonModule,
     ]);
diff --git a/server/src/modules/opds/opds.module.ts b/server/src/modules/opds/opds.module.ts
index 7390c33fc..008497a01 100644
--- a/server/src/modules/opds/opds.module.ts
+++ b/server/src/modules/opds/opds.module.ts
@@ -2,7 +2,7 @@ import { Module } from '@nestjs/common';
 
 import { AppSettingsModule } from '../app-settings/app-settings.module';
 import { BookModule } from '../book/book.module';
-import { MetadataModule } from '../metadata/metadata.module';
+import { BookCoverStoreModule } from '../book-cover-store/book-cover-store.module';
 import { UserModule } from '../user/user.module';
 import { CommonModule } from '../../common/common.module';
 import { OpdsAuthGuard } from './opds-auth.guard';
@@ -14,7 +14,7 @@ import { OpdsUserController } from './opds-user.controller';
 import { OpdsUserService } from './opds-user.service';
 
 @Module({
-  imports: [AppSettingsModule, BookModule, MetadataModule, UserModule, CommonModule],
+  imports: [AppSettingsModule, BookModule, BookCoverStoreModule, UserModule, CommonModule],
   controllers: [OpdsController, OpdsUserController],
   providers: [OpdsService, OpdsBookService, OpdsUserService, OpdsAuthGuard, OpdsEnabledGuard],
   exports: [OpdsBookService],
diff --git a/server/src/modules/scanner/file-event-processor.service.test.ts b/server/src/modules/scanner/file-event-processor.service.test.ts
index 5c1203837..e4f32c4c2 100644
--- a/server/src/modules/scanner/file-event-processor.service.test.ts
+++ b/server/src/modules/scanner/file-event-processor.service.test.ts
@@ -65,8 +65,11 @@ const mockRepo: Mocked<
   replaceDuplicateBookWithMovedBook: vi.fn(),
 };
 
+const coverStore = { removeCoverDirectory: vi.fn().mockResolvedValue(undefined) };
+const coverReconciler = { enqueue: vi.fn().mockResolvedValue(undefined) };
+
 function makeService() {
-  return new FileEventProcessorService(mockRepo as unknown as ScannerRepository);
+  return new FileEventProcessorService(mockRepo as unknown as ScannerRepository, coverStore as never, coverReconciler as never);
 }
 
 function makeFileStat(overrides: Partial<{ ino: bigint; size: number | bigint; mtime: Date; isDirectory: boolean; isFile: boolean }> = {}) {
@@ -130,9 +133,23 @@ describe('handleUnlink', () => {
     expect(mockRepo.deleteBookFile).toHaveBeenCalledWith(55);
     expect(mockRepo.markBooksAsMissing).not.toHaveBeenCalled();
     expect(mockRepo.findBookFilesByBookId).not.toHaveBeenCalled();
+    expect(coverReconciler.enqueue).not.toHaveBeenCalled();
     expect(result).toEqual({ type: 'noop' });
   });
 
+  it('reconciles cover slots when a non-selected content file goes away', async () => {
+    mockRepo.findBookFileByAbsolutePath.mockResolvedValue({
+      file: { id: 56, bookId: 12, role: 'content' },
+      libraryId: 5,
+      primaryFileId: 99,
+    } as any);
+
+    await expect(makeService().handleUnlink('/books/Solo/solo.m4b')).resolves.toEqual({ type: 'noop' });
+
+    expect(mockRepo.deleteBookFile).toHaveBeenCalledWith(56);
+    expect(coverReconciler.enqueue).toHaveBeenCalledWith([12], { filesChanged: true });
+  });
+
   it('marks book missing when primary file is deleted and no other files remain', async () => {
     mockRepo.findBookFileByAbsolutePath.mockResolvedValue({
       file: { id: 99, bookId: 12, role: 'content' },
@@ -195,6 +212,7 @@ describe('handleUnlink', () => {
       duplicateFileId: 700,
     });
     expect(result).toEqual({ type: 'book-transferred', fromLibraryId: 5, toLibraryId: 9, bookIds: [12] });
+    expect(coverStore.removeCoverDirectory).toHaveBeenCalledWith(77);
   });
 
   it('keeps delayed duplicate repair as book-moved when source and destination are in the same library', async () => {
@@ -403,8 +421,27 @@ describe('handleCreate — file', () => {
 
   it('returns noop for non-content file formats', async () => {
     mockStat.mockResolvedValue(makeFileStat());
-    const result = await makeService().handleCreate('/books/Author/cover.jpg');
-    expect(result).toEqual({ type: 'noop' });
+    mockRepo.findBooksByFolderPath.mockResolvedValue([]);
+    await expect(makeService().handleCreate('/books/Author/cover.jpg')).resolves.toEqual({ type: 'noop' });
+    await expect(makeService().handleCreate('/books/Author/Book/metadata.opf')).resolves.toEqual({ type: 'noop' });
+  });
+
+  it('rescans a book folder when a folder image appears or changes in it', async () => {
+    mockStat.mockResolvedValue(makeFileStat());
+    mockRepo.findBooksByFolderPath.mockResolvedValue([
+      { id: 3, folderPath: '/books/Author/Book/Nested', status: 'present' },
+      { id: 4, folderPath: '/books/Author/Book', status: 'present' },
+    ] as any);
+
+    await expect(makeService().handleCreate('/books/Author/Book/folder.jpg')).resolves.toEqual({ type: 'scan-required', scope: 'file' });
+    expect(mockRepo.findBooksByFolderPath).toHaveBeenCalledWith('/books/Author/Book', undefined);
+  });
+
+  it('ignores a folder image beside a missing book', async () => {
+    mockStat.mockResolvedValue(makeFileStat());
+    mockRepo.findBooksByFolderPath.mockResolvedValue([{ id: 4, folderPath: '/books/Author/Book', status: 'missing' }] as any);
+
+    await expect(makeService().handleCreate('/books/Author/Book/cover.jpg')).resolves.toEqual({ type: 'noop' });
   });
 
   it('returns noop when a tracked file matches its persisted post-write state', async () => {
diff --git a/server/src/modules/scanner/file-event-processor.service.ts b/server/src/modules/scanner/file-event-processor.service.ts
index 1ab1b7129..b70652183 100644
--- a/server/src/modules/scanner/file-event-processor.service.ts
+++ b/server/src/modules/scanner/file-event-processor.service.ts
@@ -1,4 +1,4 @@
-import { Injectable, Logger } from '@nestjs/common';
+import { Injectable, Logger, Optional } from '@nestjs/common';
 import { readdir, stat } from 'fs/promises';
 import type { BigIntStats } from 'fs';
 import { dirname, join, relative } from 'path';
@@ -6,6 +6,8 @@ import { sanitizeLogValue } from '../../common/utils/log-sanitize.utils';
 import { pathsReferToSameEntry } from '../../common/utils/path-identity.utils';
 import { selectPrimaryFile } from '../../common/utils/primary-file-selection.utils';
 
+import { BookCoverStore } from '../book-cover-store/book-cover-store.service';
+import { CoverSlotReconciler } from '../metadata/cover-slot-reconciler.service';
 import { classifyFile, DEFAULT_FORMAT_PRIORITY } from './lib/classify';
 import { ScannerRepository } from './scanner.repository';
 import { inspectEpubMediaOverlayFields } from '../reader/epub/epub-media-overlay-capability';
@@ -26,7 +28,11 @@ const DUPLICATE_MOVE_REPAIR_WINDOW_MS = 30 * 60 * 1000;
 export class FileEventProcessorService {
   private readonly logger = new Logger(FileEventProcessorService.name);
 
-  constructor(private readonly scannerRepo: ScannerRepository) {}
+  constructor(
+    private readonly scannerRepo: ScannerRepository,
+    private readonly coverStore: BookCoverStore,
+    @Optional() private readonly coverReconciler?: CoverSlotReconciler,
+  ) {}
 
   private async inspectMediaOverlayFields(absolutePath: string, format: string | null) {
     return inspectEpubMediaOverlayFields(absolutePath, format, (err) => {
@@ -51,6 +57,7 @@ export class FileEventProcessorService {
 
     if (!shouldReevaluate) {
       await this.scannerRepo.deleteBookFile(file.id);
+      if (file.role === 'content') void this.coverReconciler?.enqueue([file.bookId], { filesChanged: true });
       this.logger.log(
         `[scanner.file_event.unlink] [end] libraryId=${rowLibraryId} bookId=${file.bookId} path="${sanitizeLogValue(absolutePath)}" action=remove_non_selected - non-selected file removed`,
       );
@@ -116,6 +123,7 @@ export class FileEventProcessorService {
     if (fileStat.isDirectory()) return this.handleCreateDir(absolutePath, scopeLibraryId);
 
     const { role, format } = classifyFile(absolutePath);
+    if (role === 'cover') return this.handleFolderImageChange(absolutePath, scopeLibraryId);
     if (role !== 'content') return { type: 'noop' };
 
     const existing = await this.scannerRepo.findBookFileByAbsolutePath(absolutePath, scopeLibraryId);
@@ -221,6 +229,18 @@ export class FileEventProcessorService {
     return moveResult.type === 'noop' ? { type: 'scan-required', scope: 'file' } : moveResult;
   }
 
+  /**
+   * A folder image can fill an empty cover slot or replace one that came from a folder image, so a
+   * new or edited one inside a known book folder is registered by rescanning that folder.
+   */
+  private async handleFolderImageChange(absolutePath: string, scopeLibraryId?: number): Promise<FileEventResult> {
+    const folderPath = dirname(absolutePath);
+    const books = await this.scannerRepo.findBooksByFolderPath(folderPath, scopeLibraryId);
+    return books.some((book) => book.folderPath === folderPath && book.status !== 'missing')
+      ? { type: 'scan-required', scope: 'file' }
+      : { type: 'noop' };
+  }
+
   async reconcileMissingBooks(libraryIds: number[]): Promise<FileEventResult[]> {
     const event = 'scanner.file_event.reconcile_missing';
     const startedAt = Date.now();
@@ -362,6 +382,7 @@ export class FileEventProcessorService {
         duplicateFileId: candidate.file.id,
       });
       if (!moved) continue;
+      await this.coverStore.removeCoverDirectory(moved.duplicateBookId).catch(() => undefined);
 
       this.logger.log(
         `[scanner.file_event.duplicate_move] [end] libraryId=${moved.libraryId} bookId=${bookId} duplicateBookId=${moved.duplicateBookId} from="${sanitizeLogValue(sourceFile.absolutePath)}" to="${sanitizeLogValue(candidate.file.absolutePath)}" - duplicate import reconciled as moved book`,
diff --git a/server/src/modules/scanner/file-watcher.service.test.ts b/server/src/modules/scanner/file-watcher.service.test.ts
index 3a2530cea..3c65c9314 100644
--- a/server/src/modules/scanner/file-watcher.service.test.ts
+++ b/server/src/modules/scanner/file-watcher.service.test.ts
@@ -32,6 +32,7 @@ function makeService(db: any = {}) {
     bufferBookMissingEvent: vi.fn(),
     bufferBooksUnavailableNotification: vi.fn(),
     bufferBooksRestoredNotification: vi.fn(),
+    reconcileCoverSlotsAsync: vi.fn(),
   } as unknown as ScannerService;
 
   const selfWriteRegistry = new SelfWriteRegistry();
@@ -102,6 +103,7 @@ describe('process()', () => {
     expect(processor.handleCreate).toHaveBeenCalledWith('/books/Author/book.epub', 1);
     expect((gateway as any).emitBookRestored).toHaveBeenCalledWith({ libraryId: 1, bookIds: [7] });
     expect((scannerService as any).bufferBooksRestoredNotification).toHaveBeenCalledWith(1, [7]);
+    expect((scannerService as any).reconcileCoverSlotsAsync).toHaveBeenCalledWith([7]);
     expect(gateway.emitBookMissing).not.toHaveBeenCalled();
   });
 
@@ -383,6 +385,9 @@ describe('reconcile()', () => {
     expect((scannerService as any).bufferBooksUnavailableNotification).toHaveBeenCalledWith(1, [20]);
     expect(gateway.emitBookMoved).toHaveBeenCalledWith({ libraryId: 1, bookIds: [30] });
     expect((gateway as any).emitBookTransferred).toHaveBeenCalledWith({ fromLibraryId: 1, toLibraryId: 2, bookIds: [40] });
+    expect((scannerService as any).reconcileCoverSlotsAsync).toHaveBeenCalledWith([30]);
+    expect((scannerService as any).reconcileCoverSlotsAsync).toHaveBeenCalledWith([40]);
+    expect((scannerService as any).reconcileCoverSlotsAsync).not.toHaveBeenCalledWith([20]);
   });
 
   it('emits book-transferred from cross-library reconcile results', async () => {
diff --git a/server/src/modules/scanner/file-watcher.service.ts b/server/src/modules/scanner/file-watcher.service.ts
index 086c10466..198f82eae 100644
--- a/server/src/modules/scanner/file-watcher.service.ts
+++ b/server/src/modules/scanner/file-watcher.service.ts
@@ -139,6 +139,9 @@ export class FileWatcherService implements OnApplicationBootstrap, OnModuleDestr
     try {
       const results = await this.processor.reconcileMissingBooks(libraryIds);
       for (const result of results) {
+        if (result.type === 'book-restored' || result.type === 'book-moved' || result.type === 'book-transferred') {
+          this.scannerService.reconcileCoverSlotsAsync(result.bookIds);
+        }
         if (result.type === 'book-missing') {
           this.scannerService.bufferBookMissingEvent(result.libraryId, result.bookIds);
           this.scannerService.bufferBooksUnavailableNotification(result.libraryId, result.bookIds);
@@ -495,6 +498,10 @@ export class FileWatcherService implements OnApplicationBootstrap, OnModuleDestr
       }
     }
 
+    if (result.type === 'book-restored' || result.type === 'book-moved' || result.type === 'book-transferred') {
+      this.scannerService.reconcileCoverSlotsAsync(result.bookIds);
+    }
+
     if (result.type === 'book-missing') {
       this.scannerService.bufferBookMissingEvent(result.libraryId, result.bookIds);
       this.scannerService.bufferBooksUnavailableNotification(result.libraryId, result.bookIds);
diff --git a/server/src/modules/scanner/scan.gateway.test.ts b/server/src/modules/scanner/scan.gateway.test.ts
index f20f775ea..f73fa30f4 100644
--- a/server/src/modules/scanner/scan.gateway.test.ts
+++ b/server/src/modules/scanner/scan.gateway.test.ts
@@ -82,7 +82,7 @@ describe('emitCoverRefreshed', () => {
     const { server, to, emit } = mockServer();
     gateway['server'] = server as any;
 
-    const event: CoverRefreshedEvent = { bookId: 9, libraryId: 2 };
+    const event: CoverRefreshedEvent = { bookIds: [9], libraryId: 2 };
     gateway.emitCoverRefreshed(event);
 
     expect(to).toHaveBeenCalledWith('library:2');
diff --git a/server/src/modules/scanner/scan.gateway.ts b/server/src/modules/scanner/scan.gateway.ts
index 25e517a76..0f2253839 100644
--- a/server/src/modules/scanner/scan.gateway.ts
+++ b/server/src/modules/scanner/scan.gateway.ts
@@ -1,4 +1,4 @@
-import { Inject, Logger, OnModuleDestroy, OnModuleInit, UnauthorizedException } from '@nestjs/common';
+import { Inject, Logger, OnModuleDestroy, OnModuleInit, Optional, UnauthorizedException } from '@nestjs/common';
 import type { ConfigType } from '@nestjs/config';
 import { JwtService } from '@nestjs/jwt';
 import { OnGatewayConnection, OnGatewayDisconnect, OnGatewayInit, SubscribeMessage, WebSocketGateway, WebSocketServer } from '@nestjs/websockets';
@@ -26,6 +26,7 @@ import {
 import { ScanJobStore } from './scan-job-store.service';
 import { rejectSocketConnection } from '../../common/utils/ws-auth.utils';
 import { appConfig } from '../../config/config';
+import { BOOK_COVER_CHANGED, BookCoverEventsService } from '../book-cover-store/book-cover-events.service';
 
 @WebSocketGateway({ namespace: '/scan', cors: { credentials: true } })
 export class ScanGateway implements OnGatewayInit, OnGatewayConnection, OnGatewayDisconnect, OnModuleInit, OnModuleDestroy {
@@ -35,6 +36,9 @@ export class ScanGateway implements OnGatewayInit, OnGatewayConnection, OnGatewa
   private readonly handleBookProgressChanged = (payload: BookProgressChangedPayload): void => {
     this.emitBookProgressChanged(payload);
   };
+  private readonly handleCoverChanged = (event: CoverRefreshedEvent): void => {
+    this.emitCoverRefreshed(event);
+  };
 
   constructor(
     private readonly jwtService: JwtService,
@@ -42,16 +46,19 @@ export class ScanGateway implements OnGatewayInit, OnGatewayConnection, OnGatewa
     private readonly scanJobStore: ScanJobStore,
     private readonly achievementEvents: AchievementEventsService,
     @Inject(appConfig.KEY) app: ConfigType<typeof appConfig>,
+    @Optional() private readonly coverEvents?: BookCoverEventsService,
   ) {
     this.clientOrigin = app.appUrl;
   }
 
   onModuleInit(): void {
     this.achievementEvents.on(ACHIEVEMENT_EVENT_BOOK_PROGRESS_CHANGED, this.handleBookProgressChanged);
+    this.coverEvents?.on(BOOK_COVER_CHANGED, this.handleCoverChanged);
   }
 
   onModuleDestroy(): void {
     this.achievementEvents.removeListener(ACHIEVEMENT_EVENT_BOOK_PROGRESS_CHANGED, this.handleBookProgressChanged);
+    this.coverEvents?.removeListener(BOOK_COVER_CHANGED, this.handleCoverChanged);
   }
 
   afterInit(server: Server): void {
@@ -118,6 +125,7 @@ export class ScanGateway implements OnGatewayInit, OnGatewayConnection, OnGatewa
   }
 
   emitCoverRefreshed(event: CoverRefreshedEvent): void {
+    if (event.libraryId === undefined) return;
     this.server?.to(`library:${event.libraryId}`).emit('cover:refreshed', event);
   }
 
diff --git a/server/src/modules/scanner/scanner.module.test.ts b/server/src/modules/scanner/scanner.module.test.ts
index f65bfaffc..335b97c80 100644
--- a/server/src/modules/scanner/scanner.module.test.ts
+++ b/server/src/modules/scanner/scanner.module.test.ts
@@ -9,6 +9,7 @@ vi.mock('../achievement/achievement.module', () => ({ AchievementModule: class A
 
 import { AchievementModule } from '../achievement/achievement.module';
 import { AuthModule } from '../auth/auth.module';
+import { BookCoverStoreModule } from '../book-cover-store/book-cover-store.module';
 import { BookMetadataFetchModule } from '../book-metadata-fetch/book-metadata-fetch.module';
 import { MetadataModule } from '../metadata/metadata.module';
 import { NotificationModule } from '../notification/notification.module';
@@ -25,12 +26,13 @@ describe('ScannerModule', () => {
   it('registers expected imports/controllers/providers/exports', () => {
     const imports = Reflect.getMetadata('imports', ScannerModule) as unknown[];
     expect(imports[0]).toBe(MetadataModule);
-    expect(imports[1]).toBe(AuthModule);
-    expect(imports[2]).toBe(AchievementModule);
-    expect(imports[3]).toBe(SelfWriteRegistryModule);
-    expect(imports[4]).toEqual(expect.objectContaining({ forwardRef: expect.any(Function) }));
+    expect(imports[1]).toBe(BookCoverStoreModule);
+    expect(imports[2]).toBe(AuthModule);
+    expect(imports[3]).toBe(AchievementModule);
+    expect(imports[4]).toBe(SelfWriteRegistryModule);
     expect(imports[5]).toEqual(expect.objectContaining({ forwardRef: expect.any(Function) }));
-    expect(imports[6]).toEqual(expect.objectContaining({ module: expect.any(Function) }));
+    expect(imports[6]).toEqual(expect.objectContaining({ forwardRef: expect.any(Function) }));
+    expect(imports[7]).toEqual(expect.objectContaining({ module: expect.any(Function) }));
 
     expect(Reflect.getMetadata('controllers', ScannerModule)).toEqual([ScannerController]);
     expect(Reflect.getMetadata('providers', ScannerModule)).toEqual([
diff --git a/server/src/modules/scanner/scanner.module.ts b/server/src/modules/scanner/scanner.module.ts
index b0921a504..52f7d0d54 100644
--- a/server/src/modules/scanner/scanner.module.ts
+++ b/server/src/modules/scanner/scanner.module.ts
@@ -7,6 +7,7 @@ import { SelfWriteRegistryModule } from '../../common/self-write-registry.module
 import { AchievementModule } from '../achievement/achievement.module';
 import { AuthModule } from '../auth/auth.module';
 import { BookMetadataFetchModule } from '../book-metadata-fetch/book-metadata-fetch.module';
+import { BookCoverStoreModule } from '../book-cover-store/book-cover-store.module';
 import { MetadataModule } from '../metadata/metadata.module';
 import { NotificationModule } from '../notification/notification.module';
 import { FileEventProcessorService } from './file-event-processor.service';
@@ -20,6 +21,7 @@ import { ScannerService } from './scanner.service';
 @Module({
   imports: [
     MetadataModule,
+    BookCoverStoreModule,
     AuthModule,
     AchievementModule,
     SelfWriteRegistryModule,
diff --git a/server/src/modules/scanner/scanner.service.test.ts b/server/src/modules/scanner/scanner.service.test.ts
index 075bbdb5c..930a76b29 100644
--- a/server/src/modules/scanner/scanner.service.test.ts
+++ b/server/src/modules/scanner/scanner.service.test.ts
@@ -154,6 +154,8 @@ const mockMetadata = {
 function makeService(
   repo: ReturnType<typeof makeRepo>,
   autoFetchOrchestrator?: { scheduleImportedBooksIfEligible: (...args: unknown[]) => Promise<number> },
+  coverStore: { enrichCardVersions: (cards: unknown[]) => Promise<void> } = { enrichCardVersions: vi.fn().mockResolvedValue(undefined) },
+  coverReconciler?: { enqueue: (...args: unknown[]) => Promise<void>; enqueueExpiredDormant?: (libraryId: number) => Promise<void> },
 ) {
   const jobStore = new ScanJobStore();
   const notificationService = { notify: vi.fn().mockResolvedValue(undefined) };
@@ -166,8 +168,10 @@ function makeService(
     mockGateway as any,
     notificationService as any,
     selfWriteRegistry,
+    coverStore as any,
     autoFetchOrchestrator as any,
     achievementEvents as any,
+    coverReconciler as any,
   );
   return { service, jobStore, notificationService, achievementEvents, selfWriteRegistry };
 }
@@ -3516,11 +3520,33 @@ describe('bootstrap, wrappers, and cover refresh', () => {
 
     expect(mockMetadata.refreshCoverForBook).toHaveBeenNthCalledWith(1, 1, '/library/Book/book.epub', 'epub');
     expect(mockMetadata.refreshCoverForBook).toHaveBeenNthCalledWith(2, 3, '/library/Book/book.pdf', 'pdf');
-    expect(mockGateway.emitCoverRefreshed).toHaveBeenCalledWith({ bookId: 1, libraryId: 1 });
+    expect(mockGateway.emitCoverRefreshed).not.toHaveBeenCalled();
     expect(mockGateway.emitCoverRefreshProgress).toHaveBeenNthCalledWith(1, { libraryId: 1, processed: 0, total: 2, status: 'running' });
     expect(mockGateway.emitCoverRefreshProgress).toHaveBeenNthCalledWith(2, { libraryId: 1, processed: 2, total: 2, status: 'completed' });
   });
 
+  it('re-extracts every slot the book files can fill, then reconciles the book', async () => {
+    const repo = makeRepo({
+      findPrimaryBookFilesByLibrary: vi.fn().mockResolvedValue([{ bookId: 4, absolutePath: '/library/Book/book.epub', format: 'epub' }]),
+      findLibrarySettings: vi.fn().mockResolvedValue({ formatPriority: ['epub', 'm4b'] }),
+      findBookFilesByBookIds: vi.fn().mockResolvedValue([
+        { id: 40, bookId: 4, absolutePath: '/library/Book/book.epub', format: 'epub', role: 'content', sizeBytes: 10, mediaOverlayAvailable: false },
+        { id: 41, bookId: 4, absolutePath: '/library/Book/book.m4b', format: 'm4b', role: 'content', sizeBytes: 10, mediaOverlayAvailable: false },
+        { id: 42, bookId: 4, absolutePath: '/library/Book/cover.jpg', format: 'jpg', role: 'cover', sizeBytes: 10, mediaOverlayAvailable: false },
+      ]),
+    });
+    const coverReconciler = { enqueue: vi.fn().mockResolvedValue(undefined) };
+    mockMetadata.refreshCoverForBook.mockResolvedValueOnce(true).mockResolvedValueOnce(false);
+    const { service } = makeService(repo, undefined, undefined, coverReconciler);
+
+    await expect(service.refreshCovers(1)).resolves.toEqual({ queued: 1 });
+    await vi.waitFor(() => expect(coverReconciler.enqueue).toHaveBeenCalledWith([4]));
+
+    expect(mockMetadata.refreshCoverForBook).toHaveBeenCalledTimes(2);
+    expect(mockMetadata.refreshCoverForBook).toHaveBeenNthCalledWith(1, 4, '/library/Book/book.epub', 'epub', 'ebook');
+    expect(mockMetadata.refreshCoverForBook).toHaveBeenNthCalledWith(2, 4, '/library/Book/book.m4b', 'm4b', 'audio');
+  });
+
   it('rethrows refreshCovers query failures', async () => {
     const repo = makeRepo({
       findPrimaryBookFilesByLibrary: vi.fn().mockRejectedValue(new Error('lookup failed')),
@@ -3879,3 +3905,109 @@ describe('incremental scan — settings invalidation', () => {
     expect(repo.clearDirScanState).not.toHaveBeenCalled();
   });
 });
+
+// ── Cover slot reconcile ─────────────────────────────────────────────────────
+
+describe('cover slot reconcile after a scan', () => {
+  function makeReconciler() {
+    return { enqueue: vi.fn().mockResolvedValue(undefined), enqueueExpiredDormant: vi.fn().mockResolvedValue(undefined) };
+  }
+
+  it('reconciles a book whose files changed, and lets dormant slots expire, before the job completes', async () => {
+    const candidate = makeCandidate('/library/Book', [makeFileStat({ absolutePath: '/library/Book/book.epub', relPath: 'Book/book.epub' })]);
+    mockFindCandidates.mockResolvedValue({ candidates: [candidate], skippedDirs: new Set(), unchangedDirs: new Set(), dirMtimes: new Map() });
+    const repo = makeRepo();
+    const reconciler = makeReconciler();
+    const done = awaitScan(repo);
+    const { service } = makeService(repo, undefined, undefined, reconciler);
+
+    await service.startScan(1, 'manual');
+    await done;
+
+    expect(reconciler.enqueue).toHaveBeenCalledWith([1], { filesChanged: true });
+    expect(reconciler.enqueueExpiredDormant).toHaveBeenCalledWith(1);
+    expect(reconciler.enqueue.mock.invocationCallOrder[0]).toBeLessThan(repo.completeScanJob.mock.invocationCallOrder[0]!);
+  });
+
+  it('leaves a book with unchanged files alone', async () => {
+    const mtime = new Date('2024-01-01');
+    const fileStat = makeFileStat({ mtime });
+    const repo = makeRepo({
+      findBookFilesByLibraryFolder: vi
+        .fn()
+        .mockResolvedValue([makeBookFile({ mtime, sizeBytes: fileStat.sizeBytes, mediaOverlayCheckedAt: new Date('2024-01-01') })]),
+      findBooksByLibraryFolder: vi
+        .fn()
+        .mockResolvedValue([{ id: 1, libraryId: 1, libraryFolderId: 1, folderPath: '/library/Author/Book', status: 'present' }]),
+    });
+    mockFindCandidates.mockResolvedValue({
+      candidates: [makeCandidate('/library/Author/Book', [fileStat])],
+      skippedDirs: new Set(),
+      unchangedDirs: new Set(),
+      dirMtimes: new Map(),
+    });
+    const reconciler = makeReconciler();
+    const done = awaitScan(repo);
+    const { service } = makeService(repo, undefined, undefined, reconciler);
+
+    await service.startScan(1, 'manual');
+    await done;
+
+    expect(reconciler.enqueue).not.toHaveBeenCalled();
+  });
+
+  it('reconciles the book a file was taken from as well as the book it joined', async () => {
+    const fileStat = makeFileStat({ absolutePath: '/library/Author/Book/book.m4b', relPath: 'Author/Book/book.m4b', ino: 1001n, format: 'm4b' });
+    const repo = makeRepo({
+      findBookFilesByLibraryFolder: vi
+        .fn()
+        .mockResolvedValue([makeBookFile({ id: 5, bookId: 999, absolutePath: fileStat.absolutePath, ino: fileStat.ino, format: 'm4b' })]),
+    });
+    mockFindCandidates.mockResolvedValue({
+      candidates: [makeCandidate('/library/Author/Book', [fileStat])],
+      skippedDirs: new Set(),
+      unchangedDirs: new Set(),
+      dirMtimes: new Map(),
+    });
+    const reconciler = makeReconciler();
+    const done = awaitScan(repo);
+    const { service } = makeService(repo, undefined, undefined, reconciler);
+
+    await service.startScan(1, 'manual');
+    await done;
+
+    expect(reconciler.enqueue).toHaveBeenCalledWith(expect.arrayContaining([1, 999]), { filesChanged: true });
+  });
+
+  it('reconciles a book whose EPUB turned out to carry read-along audio', async () => {
+    const mtime = new Date('2024-01-01T00:00:00Z');
+    const fileStat = makeFileStat({ absolutePath: '/library/Author/Book/book.epub', sizeBytes: 1024, mtime });
+    const repo = makeRepo({
+      findBookFilesByLibraryFolder: vi
+        .fn()
+        .mockResolvedValue([makeBookFile({ mtime, sizeBytes: fileStat.sizeBytes, mediaOverlayCheckedAt: null, mediaOverlayAvailable: false })]),
+      findBooksByLibraryFolder: vi
+        .fn()
+        .mockResolvedValue([{ id: 1, libraryId: 1, libraryFolderId: 1, folderPath: '/library/Author/Book', status: 'present' }]),
+    });
+    mockFindCandidates.mockResolvedValue({
+      candidates: [makeCandidate('/library/Author/Book', [fileStat])],
+      skippedDirs: new Set(),
+      unchangedDirs: new Set(),
+      dirMtimes: new Map(),
+    });
+    const reconciler = makeReconciler();
+    const done = awaitScan(repo);
+    const { service } = makeService(repo, undefined, undefined, reconciler);
+    vi.spyOn(service as unknown as { inspectMediaOverlayFields: () => Promise<unknown> }, 'inspectMediaOverlayFields').mockResolvedValue({
+      mediaOverlayAvailable: true,
+      mediaOverlayDurationSeconds: 60,
+      mediaOverlayCheckedAt: new Date(),
+    });
+
+    await service.startScan(1, 'manual');
+    await done;
+
+    expect(reconciler.enqueue).toHaveBeenCalledWith([1], { filesChanged: true });
+  });
+});
diff --git a/server/src/modules/scanner/scanner.service.ts b/server/src/modules/scanner/scanner.service.ts
index d31da14ee..57f44e069 100644
--- a/server/src/modules/scanner/scanner.service.ts
+++ b/server/src/modules/scanner/scanner.service.ts
@@ -11,7 +11,6 @@ import type {
   AddedAtSource,
   BookMissingEvent,
   BookTransferredEvent,
-  CoverRefreshedEvent,
   CoverRefreshProgressEvent,
   LibraryLastScan,
   LibraryScanHistoryEntry,
@@ -23,8 +22,12 @@ import type {
 import { NotificationType } from '@bookorbit/types';
 import { AchievementEventsService, ACHIEVEMENT_EVENT_LIBRARY_CATALOG_CHANGED } from '../achievement/achievement-events.service';
 import { BookMetadataFetchOrchestratorService } from '../book-metadata-fetch/book-metadata-fetch-orchestrator.service';
+import { BookCoverStore } from '../book-cover-store/book-cover-store.service';
+import { selectEmbeddedCoverSources } from '../book-cover-store/cover-sources';
+import { CoverSlotReconciler } from '../metadata/cover-slot-reconciler.service';
 import { MetadataService } from '../metadata/metadata.service';
 import { NotificationService } from '../notification/notification.service';
+import type { BookFile } from '../../db/schema';
 import { ScanGateway } from './scan.gateway';
 import { ScanJobStore } from './scan-job-store.service';
 import { basename, dirname, relative, sep } from 'path';
@@ -115,6 +118,7 @@ const METADATA_FORMATS = new Set([
   'opf',
 ]);
 const SCANNER_METADATA_SOURCES = ['embedded', 'opfFile'] as const;
+const COVER_RECONCILE_BATCH_SIZE = 500;
 const COVER_REFRESH_BATCH_SIZE = 5;
 const BOOK_EMIT_BUFFER_SIZE = 20;
 const BOOK_EMIT_FLUSH_INTERVAL_MS = 1000;
@@ -158,6 +162,10 @@ interface ProcessedFileResult {
   reassigned: boolean;
   changed: boolean;
   fileId: number | null;
+  /** The book that owned the file before this scan moved it here. */
+  previousBookId?: number;
+  /** An unchanged EPUB whose read-along audio was detected for the first time. */
+  mediaOverlayChanged?: boolean;
 }
 
 interface UpsertBookResult extends BookEntry {
@@ -171,6 +179,8 @@ interface ProcessCandidateResult {
   retainedFileIds: Set<number>;
   becameVisible: boolean;
   created: boolean;
+  /** Books whose file set changed here: this one, and any book a file was taken from. */
+  coverBookIds: number[];
 }
 
 function normalizeOrganizationMode(mode: string | null | undefined): OrganizationMode {
@@ -229,8 +239,10 @@ export class ScannerService implements OnApplicationBootstrap {
     private readonly scanGateway: ScanGateway,
     private readonly notificationService: NotificationService,
     private readonly selfWriteRegistry: SelfWriteRegistry,
+    private readonly coverStore: BookCoverStore,
     @Optional() private readonly autoFetchOrchestrator?: BookMetadataFetchOrchestratorService,
     @Optional() private readonly achievementEvents?: AchievementEventsService,
+    @Optional() private readonly coverReconciler?: CoverSlotReconciler,
   ) {}
 
   /**
@@ -447,6 +459,7 @@ export class ScannerService implements OnApplicationBootstrap {
   private async buildAndEmitBookCards(libraryId: number, bookIds: number[]): Promise<void> {
     const { rows, authorRows, fileRows, genreRows } = await this.scannerRepo.findBookCardData(bookIds);
     const cards = assembleBookCards(rows, authorRows, fileRows, genreRows, []);
+    await this.coverStore.enrichCardVersions(cards);
     if (cards.length > 0) {
       this.scanGateway.emitBooksAdded({ libraryId, books: cards } satisfies ScanBooksAddedEvent);
     }
@@ -745,6 +758,7 @@ export class ScannerService implements OnApplicationBootstrap {
       const rows = await this.scannerRepo.findPrimaryBookFilesByLibrary(libraryId);
       const candidates = rows.filter((r) => r.format && METADATA_FORMATS.has(r.format));
       const total = candidates.length;
+      const formatPriority = (await this.scannerRepo.findLibrarySettings(libraryId))?.formatPriority ?? DEFAULT_FORMAT_PRIORITY;
       const backgroundStartedAt = Date.now();
 
       this.scanGateway.emitCoverRefreshProgress({ libraryId, processed: 0, total, status: 'running' });
@@ -754,17 +768,21 @@ export class ScannerService implements OnApplicationBootstrap {
         let refreshedCount = 0;
         for (let i = 0; i < candidates.length; i += COVER_REFRESH_BATCH_SIZE) {
           const batch = candidates.slice(i, i + COVER_REFRESH_BATCH_SIZE);
+          const files = await this.scannerRepo.findBookFilesByBookIds(batch.map((row) => row.bookId));
           const results = await Promise.allSettled(
-            batch.map(async (row) => {
-              const refreshed = await this.metadataService.refreshCoverForBook(row.bookId, row.absolutePath, row.format!);
-              return { bookId: row.bookId, refreshed };
-            }),
+            batch.map(async (row) => ({
+              bookId: row.bookId,
+              refreshed: await this.refreshBookCovers(
+                row,
+                files.filter((file) => file.bookId === row.bookId),
+                formatPriority,
+              ),
+            })),
           );
           for (const result of results) {
             processed++;
             if (result.status === 'fulfilled' && result.value.refreshed) {
               refreshedCount++;
-              this.scanGateway.emitCoverRefreshed({ bookId: result.value.bookId, libraryId } satisfies CoverRefreshedEvent);
             }
           }
           this.scanGateway.emitCoverRefreshProgress({
@@ -797,6 +815,55 @@ export class ScannerService implements OnApplicationBootstrap {
     }
   }
 
+  /**
+   * Re-extracts every slot the book's files can fill, then lets reconcile fill what is still empty,
+   * which is also how a book the upgrade could not finish gets retried.
+   */
+  private async refreshBookCovers(
+    primary: { bookId: number; absolutePath: string; format: string | null },
+    files: BookFile[],
+    formatPriority: readonly string[],
+  ): Promise<boolean> {
+    const sources = selectEmbeddedCoverSources(files, formatPriority);
+    const targets = (['ebook', 'audio'] as const).flatMap((medium) => {
+      const file = sources[medium];
+      return file?.format ? [{ medium, absolutePath: file.absolutePath, format: file.format }] : [];
+    });
+    let refreshed = false;
+    if (targets.length === 0) {
+      refreshed = await this.metadataService.refreshCoverForBook(primary.bookId, primary.absolutePath, primary.format!);
+    }
+    for (const target of targets) {
+      refreshed = (await this.metadataService.refreshCoverForBook(primary.bookId, target.absolutePath, target.format, target.medium)) || refreshed;
+    }
+    await this.coverReconciler?.enqueue([primary.bookId]);
+    return refreshed;
+  }
+
+  reconcileCoverSlotsAsync(bookIds: readonly number[]): void {
+    if (bookIds.length === 0) return;
+    void this.coverReconciler?.enqueue(bookIds, { filesChanged: true });
+  }
+
+  /** Runs after the deferred prune, so a medium whose last file left is already gone. */
+  private async reconcileCoverSlots(bookIds: Iterable<number>): Promise<void> {
+    if (!this.coverReconciler) return;
+    const ids = [...new Set(bookIds)];
+    for (let offset = 0; offset < ids.length; offset += COVER_RECONCILE_BATCH_SIZE) {
+      await this.coverReconciler.enqueue(ids.slice(offset, offset + COVER_RECONCILE_BATCH_SIZE), { filesChanged: true });
+    }
+  }
+
+  private async pruneExpiredDormantCovers(libraryId: number, jobId: number): Promise<void> {
+    try {
+      await this.coverReconciler?.enqueueExpiredDormant(libraryId);
+    } catch (err) {
+      this.logger.warn(
+        `[scanner.prune_dormant_covers] [fail] libraryId=${libraryId} jobId=${jobId} errorClass=${err instanceof Error ? err.name : 'Error'} error="${sanitizeLogValue(err instanceof Error ? err.message : String(err))}" - dormant cover pruning failed`,
+      );
+    }
+  }
+
   startScanAsync(libraryId: number): void {
     if (this.scanJobStore.isRunning(libraryId) || this.scanJobStore.isStartLocked(libraryId)) {
       this.scanJobStore.markPendingRescan(libraryId);
@@ -986,6 +1053,7 @@ export class ScannerService implements OnApplicationBootstrap {
     const totals = { added: 0, updated: 0 };
     const allRetainedFileIds = new Set<number>();
     const seenBookIds = new Set<number>();
+    const coverBookIds = new Set<number>();
     const importedBookIds: number[] = [];
     const candidateFolderPaths = new Set(candidates.map((candidate) => candidate.folderPath));
     for (const candidate of candidates) {
@@ -1004,15 +1072,19 @@ export class ScannerService implements OnApplicationBootstrap {
       seenBookIds.add(result.bookId);
       if (result.created) importedBookIds.push(result.bookId);
       for (const fid of result.retainedFileIds) allRetainedFileIds.add(fid);
+      for (const coverBookId of result.coverBookIds) coverBookIds.add(coverBookId);
       totals.added += result.added;
       totals.updated += result.updated;
     }
 
     const pruneCounts = { added: 0, updated: 0 };
     for (const bookId of seenBookIds) {
-      await this.pruneMissingBookFiles(bookId, allRetainedFileIds, maps.fileIdsByBookId, maps.fileByPath, maps.fileByIno, pruneCounts);
+      if (await this.pruneMissingBookFiles(bookId, allRetainedFileIds, maps.fileIdsByBookId, maps.fileByPath, maps.fileByIno, pruneCounts)) {
+        coverBookIds.add(bookId);
+      }
     }
     totals.updated += pruneCounts.updated;
+    await this.reconcileCoverSlots(coverBookIds);
     await this.scheduleImportedBookMetadataFetch(libraryId, importedBookIds);
 
     this.logger.log(
@@ -1117,10 +1189,11 @@ export class ScannerService implements OnApplicationBootstrap {
       false,
       new Set([candidate.folderPath]),
     );
-    await this.pruneMissingBookFiles(result.bookId, result.retainedFileIds, maps.fileIdsByBookId, maps.fileByPath, maps.fileByIno, {
+    const pruned = await this.pruneMissingBookFiles(result.bookId, result.retainedFileIds, maps.fileIdsByBookId, maps.fileByPath, maps.fileByIno, {
       added: 0,
       updated: 0,
     });
+    await this.reconcileCoverSlots([...result.coverBookIds, ...(pruned ? [result.bookId] : [])]);
     this.emitTargetedScanResult(libraryId, result);
     await this.scheduleImportedBookMetadataFetch(libraryId, result.created ? [result.bookId] : []);
     this.logger.log(
@@ -1188,10 +1261,11 @@ export class ScannerService implements OnApplicationBootstrap {
       false,
       new Set([candidate.folderPath]),
     );
-    await this.pruneMissingBookFiles(result.bookId, result.retainedFileIds, maps.fileIdsByBookId, maps.fileByPath, maps.fileByIno, {
+    const pruned = await this.pruneMissingBookFiles(result.bookId, result.retainedFileIds, maps.fileIdsByBookId, maps.fileByPath, maps.fileByIno, {
       added: 0,
       updated: 0,
     });
+    await this.reconcileCoverSlots([...result.coverBookIds, ...(pruned ? [result.bookId] : [])]);
     this.emitTargetedScanResult(libraryId, result);
     await this.scheduleImportedBookMetadataFetch(libraryId, result.created ? [result.bookId] : []);
     this.logger.log(
@@ -1278,10 +1352,11 @@ export class ScannerService implements OnApplicationBootstrap {
       false,
       new Set([candidate.folderPath]),
     );
-    await this.pruneMissingBookFiles(result.bookId, result.retainedFileIds, maps.fileIdsByBookId, maps.fileByPath, maps.fileByIno, {
+    const pruned = await this.pruneMissingBookFiles(result.bookId, result.retainedFileIds, maps.fileIdsByBookId, maps.fileByPath, maps.fileByIno, {
       added: 0,
       updated: 0,
     });
+    await this.reconcileCoverSlots([...result.coverBookIds, ...(pruned ? [result.bookId] : [])]);
     this.emitTargetedScanResult(libraryId, result);
     await this.scheduleImportedBookMetadataFetch(libraryId, result.created ? [result.bookId] : []);
     this.logger.log(
@@ -1403,6 +1478,7 @@ export class ScannerService implements OnApplicationBootstrap {
         }
       }
 
+      await this.pruneExpiredDormantCovers(libraryId, jobId);
       await this.scannerRepo.completeScanJob(jobId, totals);
       this.logger.log(
         `[${event}] [end] libraryId=${libraryId} jobId=${jobId} durationMs=${Date.now() - startedAt} addedCount=${totals.addedCount} updatedCount=${totals.updatedCount} missingCount=${totals.missingCount} - scan job completed`,
@@ -1489,6 +1565,7 @@ export class ScannerService implements OnApplicationBootstrap {
 
       const seenBookIds = new Set<number>();
       const allRetainedFileIds = new Set<number>();
+      const coverBookIds = new Set<number>();
       const importedBookIds: number[] = [];
       const candidateFolderPaths = new Set(candidates.map((candidate) => candidate.folderPath));
 
@@ -1507,6 +1584,7 @@ export class ScannerService implements OnApplicationBootstrap {
         seenBookIds.add(result.bookId);
         if (result.created) importedBookIds.push(result.bookId);
         for (const fid of result.retainedFileIds) allRetainedFileIds.add(fid);
+        for (const coverBookId of result.coverBookIds) coverBookIds.add(coverBookId);
         counts.addedCount += result.added;
         counts.updatedCount += result.updated;
         if (result.becameVisible) {
@@ -1527,9 +1605,12 @@ export class ScannerService implements OnApplicationBootstrap {
       // Must happen after ALL batches so cross-book file moves are visible.
       const pruneCounts = { added: 0, updated: 0 };
       for (const bookId of seenBookIds) {
-        await this.pruneMissingBookFiles(bookId, allRetainedFileIds, maps.fileIdsByBookId, maps.fileByPath, maps.fileByIno, pruneCounts);
+        if (await this.pruneMissingBookFiles(bookId, allRetainedFileIds, maps.fileIdsByBookId, maps.fileByPath, maps.fileByIno, pruneCounts)) {
+          coverBookIds.add(bookId);
+        }
       }
       counts.updatedCount += pruneCounts.updated;
+      await this.reconcileCoverSlots(coverBookIds);
 
       // Don't mark books as missing if their folder was skipped due to permission errors
       const isUnderSkippedDir = (folderPath: string) => {
@@ -1662,6 +1743,8 @@ export class ScannerService implements OnApplicationBootstrap {
 
     // Phase 1: Register every file in bookFiles. No metadata extraction yet.
     const registeredFiles: RegisteredFile[] = [];
+    const formerOwnerBookIds = new Set<number>();
+    let mediaOverlayChanged = false;
 
     for (let sortOrder = 0; sortOrder < candidate.files.length; sortOrder++) {
       const fileStat = candidate.files[sortOrder];
@@ -1700,6 +1783,9 @@ export class ScannerService implements OnApplicationBootstrap {
       }
 
       counts.updated += fileCount.addedCount + fileCount.updatedCount;
+      if (processResult.previousBookId !== undefined && processResult.previousBookId !== book.id)
+        formerOwnerBookIds.add(processResult.previousBookId);
+      if (processResult.mediaOverlayChanged) mediaOverlayChanged = true;
 
       if (processResult.fileId !== null) {
         registeredFiles.push({
@@ -1828,7 +1914,9 @@ export class ScannerService implements OnApplicationBootstrap {
     }
 
     const becameVisible = await this.scannerRepo.promoteProcessingBookToPresent(book.id);
-    return { bookId: book.id, ...counts, retainedFileIds, becameVisible, created: book.created };
+    const fileSetChanged = mediaOverlayChanged || registeredFiles.some(hasMetadataSourceChanged);
+    const coverBookIds = [...(fileSetChanged ? [book.id] : []), ...formerOwnerBookIds];
+    return { bookId: book.id, ...counts, retainedFileIds, becameVisible, created: book.created, coverBookIds };
   }
 
   private buildMetadataExtractionSources(
@@ -2324,6 +2412,7 @@ export class ScannerService implements OnApplicationBootstrap {
     const inoUnchanged = fileStat.ino === byPath.ino;
     const relPathUnchanged = fileStat.relPath === byPath.relPath;
     const reassigned = byPath.bookId !== bookId;
+    const previousBookId = reassigned ? byPath.bookId : undefined;
     const sortOrderUnchanged = sortOrder === byPath.sortOrder;
     let mediaOverlayAvailable = byPath.mediaOverlayAvailable;
     let mediaOverlayCheckedAt = byPath.mediaOverlayCheckedAt;
@@ -2332,9 +2421,11 @@ export class ScannerService implements OnApplicationBootstrap {
       if (format?.toLowerCase() === 'epub' && byPath.mediaOverlayCheckedAt == null) {
         const mediaOverlayFields = await this.inspectMediaOverlayFields(fileStat.absolutePath, format);
         await this.scannerRepo.updateBookFile(byPath.id, mediaOverlayFields);
+        const mediaOverlayChanged = byPath.mediaOverlayAvailable !== mediaOverlayFields.mediaOverlayAvailable;
         byPath.mediaOverlayAvailable = mediaOverlayFields.mediaOverlayAvailable;
         byPath.mediaOverlayCheckedAt = mediaOverlayFields.mediaOverlayCheckedAt;
         counts.updatedCount++;
+        return { isNew: false, reassigned: false, changed: false, fileId: byPath.id, mediaOverlayChanged };
       }
       return { isNew: false, reassigned: false, changed: false, fileId: byPath.id };
     }
@@ -2392,7 +2483,7 @@ export class ScannerService implements OnApplicationBootstrap {
         mtime: fileStat.mtime,
       });
     }
-    return { isNew: false, reassigned, changed: !sizeUnchanged || !mtimeUnchanged, fileId: byPath.id };
+    return { isNew: false, reassigned, changed: !sizeUnchanged || !mtimeUnchanged, fileId: byPath.id, previousBookId };
   }
 
   private async resolveByLocalIno(
@@ -2444,7 +2535,13 @@ export class ScannerService implements OnApplicationBootstrap {
       mediaOverlayCheckedAt: mediaOverlayFields.mediaOverlayCheckedAt,
     });
     fileByIno.set(fileStat.ino, { id: byIno.id, bookId, absolutePath: fileStat.absolutePath, sizeBytes: fileStat.sizeBytes, mtime: fileStat.mtime });
-    return { isNew: false, reassigned: byIno.bookId !== bookId, changed: !sizeUnchanged || !mtimeUnchanged, fileId: byIno.id };
+    return {
+      isNew: false,
+      reassigned: byIno.bookId !== bookId,
+      changed: !sizeUnchanged || !mtimeUnchanged,
+      fileId: byIno.id,
+      previousBookId: byIno.bookId !== bookId ? byIno.bookId : undefined,
+    };
   }
 
   private async resolveByGlobalIno(
@@ -2526,6 +2623,7 @@ export class ScannerService implements OnApplicationBootstrap {
       reassigned: globalByIno.file.bookId !== bookId,
       changed: !sizeUnchanged || !mtimeUnchanged,
       fileId: globalByIno.file.id,
+      previousBookId: globalByIno.file.bookId !== bookId ? globalByIno.file.bookId : undefined,
     };
   }
 
@@ -2603,7 +2701,13 @@ export class ScannerService implements OnApplicationBootstrap {
             mtime: fileStat.mtime,
           });
         }
-        return { isNew: false, reassigned: byHash.bookId !== bookId, changed: false, fileId: byHash.id };
+        return {
+          isNew: false,
+          reassigned: byHash.bookId !== bookId,
+          changed: false,
+          fileId: byHash.id,
+          previousBookId: byHash.bookId !== bookId ? byHash.bookId : undefined,
+        };
       }
 
       let globalByHash = await this.scannerRepo.findBookFileWithContextByHash(fileHash);
@@ -2668,7 +2772,13 @@ export class ScannerService implements OnApplicationBootstrap {
             mtime: fileStat.mtime,
           });
         }
-        return { isNew: false, reassigned: globalByHash.file.bookId !== bookId, changed: false, fileId: globalByHash.file.id };
+        return {
+          isNew: false,
+          reassigned: globalByHash.file.bookId !== bookId,
+          changed: false,
+          fileId: globalByHash.file.id,
+          previousBookId: globalByHash.file.bookId !== bookId ? globalByHash.file.bookId : undefined,
+        };
       }
     }
 
@@ -2749,10 +2859,10 @@ export class ScannerService implements OnApplicationBootstrap {
     fileByPath: Map<string, FileByPathEntry>,
     fileByIno: Map<bigint, FileByInoEntry>,
     counts: { added: number; updated: number },
-  ): Promise<void> {
+  ): Promise<boolean> {
     // Use in-memory index instead of DB query per book
     const knownFileIds = fileIdsByBookId.get(bookId);
-    if (!knownFileIds) return;
+    if (!knownFileIds) return false;
 
     const missingIds: number[] = [];
     for (const fileId of knownFileIds) {
@@ -2760,7 +2870,7 @@ export class ScannerService implements OnApplicationBootstrap {
         missingIds.push(fileId);
       }
     }
-    if (missingIds.length === 0) return;
+    if (missingIds.length === 0) return false;
 
     for (const fileId of missingIds) {
       await this.scannerRepo.deleteBookFile(fileId);
@@ -2780,6 +2890,7 @@ export class ScannerService implements OnApplicationBootstrap {
         }
       }
     }
+    return true;
   }
 
   private emitFromStore(libraryId: number, jobId: number, status: 'running' | 'completed' | 'failed', errorMessage?: string): void {
diff --git a/server/src/modules/series/series.module.ts b/server/src/modules/series/series.module.ts
index 6af439b6a..9da863894 100644
--- a/server/src/modules/series/series.module.ts
+++ b/server/src/modules/series/series.module.ts
@@ -1,13 +1,14 @@
 import { Module } from '@nestjs/common';
 
 import { BookModule } from '../book/book.module';
+import { BookCoverStoreModule } from '../book-cover-store/book-cover-store.module';
 import { LibraryModule } from '../library/library.module';
 import { SeriesController } from './series.controller';
 import { SeriesRepository } from './series.repository';
 import { SeriesService } from './series.service';
 
 @Module({
-  imports: [BookModule, LibraryModule],
+  imports: [BookModule, BookCoverStoreModule, LibraryModule],
   controllers: [SeriesController],
   providers: [SeriesService, SeriesRepository],
   exports: [SeriesService],
diff --git a/server/src/modules/series/series.service.test.ts b/server/src/modules/series/series.service.test.ts
index 32838dc43..4c29a19ad 100644
--- a/server/src/modules/series/series.service.test.ts
+++ b/server/src/modules/series/series.service.test.ts
@@ -65,7 +65,12 @@ describe('SeriesService', () => {
 
   beforeEach(() => {
     vi.resetAllMocks();
-    service = new SeriesService(seriesRepo as any, bookReadService as any, libraryService as any);
+    service = new SeriesService(
+      seriesRepo as any,
+      bookReadService as any,
+      libraryService as any,
+      { enrichCardVersions: vi.fn().mockResolvedValue(undefined) } as any,
+    );
     libraryService.findAll.mockResolvedValue([{ id: 1 }, { id: 2 }]);
     libraryService.findAccessibleLibraryIds.mockResolvedValue([1, 2]);
   });
diff --git a/server/src/modules/series/series.service.ts b/server/src/modules/series/series.service.ts
index db54e6d46..d30ef585b 100644
--- a/server/src/modules/series/series.service.ts
+++ b/server/src/modules/series/series.service.ts
@@ -7,6 +7,7 @@ import type { RequestUser } from '../../common/types/request-user';
 import { normalizeSeriesTotalBooks } from '../../common/utils/series-total-books.utils';
 import { assembleBookCards } from '../book/utils/assemble-book-cards';
 import { BookReadService } from '../book/book-read.service';
+import { BookCoverStore } from '../book-cover-store/book-cover-store.service';
 import { LibraryService } from '../library/library.service';
 import { FindNextSeriesBookDto } from './dto/find-next-series-book.dto';
 import { ListSeriesBooksDto } from './dto/list-series-books.dto';
@@ -23,6 +24,7 @@ export class SeriesService {
     private readonly seriesRepo: SeriesRepository,
     private readonly bookReadService: BookReadService,
     private readonly libraryService: LibraryService,
+    private readonly coverStore: BookCoverStore,
   ) {}
 
   private assertPaginationWindow(page: number, size: number): void {
@@ -162,6 +164,7 @@ export class SeriesService {
         cardData.tagRows,
         cardData.seriesMembershipRows,
       );
+      await this.coverStore.enrichCardVersions(cards);
       const orderMap = new Map(bookPage.bookIds.map((id, i) => [id, i]));
       items = cards
         .map((card) => {
diff --git a/server/src/modules/upload/upload-processor.service.test.ts b/server/src/modules/upload/upload-processor.service.test.ts
index 023ff8f0e..4f35ecdd9 100644
--- a/server/src/modules/upload/upload-processor.service.test.ts
+++ b/server/src/modules/upload/upload-processor.service.test.ts
@@ -18,6 +18,9 @@ describe('UploadProcessorService', () => {
   const orchestrator = {
     scheduleImportedBooksIfEligible: vi.fn(),
   };
+  const coverStore = {
+    removeCoverDirectory: vi.fn(),
+  };
 
   const insertBooksReturning = vi.fn();
   const insertBooksValues = vi.fn();
@@ -86,11 +89,12 @@ describe('UploadProcessorService', () => {
     updateSessionWhere.mockResolvedValue(undefined);
 
     orchestrator.scheduleImportedBooksIfEligible.mockResolvedValue(0);
+    coverStore.removeCoverDirectory.mockResolvedValue(undefined);
 
     mockStat.mockResolvedValue({ ino: 111n, mtime: new Date('2024-01-01') } as Awaited<ReturnType<typeof stat>>);
     mockComputeFileHash.mockResolvedValue('hash-abc');
 
-    service = new UploadProcessorService(db as any, metadataService as any, orchestrator as any);
+    service = new UploadProcessorService(db as any, metadataService as any, coverStore as any, orchestrator as any);
   });
 
   it('creates book, metadata, and content file rows with fingerprint/stat data in a transaction', async () => {
@@ -329,7 +333,7 @@ describe('UploadProcessorService', () => {
 
     beforeEach(() => {
       metadataService.extractAndSave.mockResolvedValue(undefined);
-      serviceNoOrch = new UploadProcessorService(db as any, metadataService as any, undefined);
+      serviceNoOrch = new UploadProcessorService(db as any, metadataService as any, coverStore as any, undefined);
     });
 
     it('createBookRecord completes without scheduling when orchestrator is undefined', async () => {
@@ -416,5 +420,34 @@ describe('UploadProcessorService', () => {
 
       expect(db.transaction).not.toHaveBeenCalled();
     });
+
+    it('removes covers of the books it created and reconciles the books it only attached to', async () => {
+      const coverReconciler = { enqueue: vi.fn().mockResolvedValue(undefined) };
+      const withCovers = new UploadProcessorService(
+        db as any,
+        metadataService as any,
+        coverStore as any,
+        orchestrator as any,
+        coverReconciler as any,
+      );
+
+      await withCovers.deleteUnitBookRecords({ bookIds: [42, 7], createdBookIds: [42], attachedFileIds: [777] });
+
+      expect(coverStore.removeCoverDirectory).toHaveBeenCalledWith(42);
+      expect(coverStore.removeCoverDirectory).not.toHaveBeenCalledWith(7);
+      expect(coverReconciler.enqueue).toHaveBeenCalledWith([7], { filesChanged: true });
+    });
+  });
+
+  it('reconciles cover slots once metadata extraction has written the file’s own cover', async () => {
+    const coverReconciler = { enqueue: vi.fn().mockResolvedValue(undefined) };
+    const withCovers = new UploadProcessorService(db as any, metadataService as any, coverStore as any, orchestrator as any, coverReconciler as any);
+    metadataService.extractAndSave.mockResolvedValue(undefined);
+    metadataService.extractAndAggregateAudioDuration.mockResolvedValue(undefined);
+
+    await withCovers.extractMetadata(7, '/tmp/book.m4b', 'm4b');
+
+    expect(coverReconciler.enqueue).toHaveBeenCalledWith([7], { filesChanged: true });
+    expect(coverReconciler.enqueue.mock.invocationCallOrder[0]).toBeGreaterThan(metadataService.extractAndSave.mock.invocationCallOrder[0]!);
   });
 });
diff --git a/server/src/modules/upload/upload-processor.service.ts b/server/src/modules/upload/upload-processor.service.ts
index f0d9eb2d8..f1504040e 100644
--- a/server/src/modules/upload/upload-processor.service.ts
+++ b/server/src/modules/upload/upload-processor.service.ts
@@ -11,6 +11,8 @@ import { DB } from '../../db';
 import * as schema from '../../db/schema';
 import { bookFiles, bookMetadata, books, uploadSessions } from '../../db/schema';
 import { BookMetadataFetchOrchestratorService } from '../book-metadata-fetch/book-metadata-fetch-orchestrator.service';
+import { BookCoverStore } from '../book-cover-store/book-cover-store.service';
+import { CoverSlotReconciler } from '../metadata/cover-slot-reconciler.service';
 import { MetadataService } from '../metadata/metadata.service';
 import { computeFileHash } from '../scanner/lib/hash';
 import { inspectEpubMediaOverlayFields } from '../reader/epub/epub-media-overlay-capability';
@@ -76,9 +78,17 @@ export class UploadProcessorService {
   constructor(
     @Inject(DB) private readonly db: Db,
     private readonly metadataService: MetadataService,
+    private readonly coverStore: BookCoverStore,
     @Optional() private readonly autoFetchOrchestrator?: BookMetadataFetchOrchestratorService,
+    @Optional() private readonly coverReconciler?: CoverSlotReconciler,
   ) {}
 
+  /** A file joined or left these books, so their cover slots are brought back in line with it. */
+  reconcileCoversAsync(bookIds: readonly number[]): void {
+    if (!this.coverReconciler || bookIds.length === 0) return;
+    void this.coverReconciler.enqueue(bookIds, { filesChanged: true });
+  }
+
   private async inspectMediaOverlayFields(absolutePath: string, format: string | null) {
     return inspectEpubMediaOverlayFields(absolutePath, format, (err) => {
       const error = err instanceof Error ? err : new Error(String(err));
@@ -175,6 +185,9 @@ export class UploadProcessorService {
         await tx.delete(books).where(inArray(books.id, records.createdBookIds));
       }
     });
+    // Metadata may already have written covers for the books this unit created.
+    await Promise.allSettled(records.createdBookIds.map((bookId) => this.coverStore.removeCoverDirectory(bookId)));
+    this.reconcileCoversAsync(records.bookIds.filter((bookId) => !records.createdBookIds.includes(bookId)));
   }
 
   private async measureFile(absolutePath: string, format: string): Promise<MeasuredFile> {
@@ -289,6 +302,7 @@ export class UploadProcessorService {
       if (isAudioFormat(format)) {
         await this.metadataService.extractAndAggregateAudioDuration(bookId, absolutePath);
       }
+      this.reconcileCoversAsync([bookId]);
       this.logger.debug(`[${event}] [end] bookId=${bookId} format=${format} durationMs=${Date.now() - startedAt} - metadata extraction completed`);
     } catch (err) {
       const error = err as Error;
diff --git a/server/src/modules/upload/upload.module.ts b/server/src/modules/upload/upload.module.ts
index 0efdd4d01..33b47a5b4 100644
--- a/server/src/modules/upload/upload.module.ts
+++ b/server/src/modules/upload/upload.module.ts
@@ -1,6 +1,7 @@
 import { Module } from '@nestjs/common';
 
 import { AppSettingsModule } from '../app-settings/app-settings.module';
+import { BookCoverStoreModule } from '../book-cover-store/book-cover-store.module';
 import { BookMetadataFetchModule } from '../book-metadata-fetch/book-metadata-fetch.module';
 import { FileWriteModule } from '../file-write/file-write.module';
 import { LibraryModule } from '../library/library.module';
@@ -17,7 +18,7 @@ import { UploadSessionRepository } from './upload-session.repository';
 import { UploadSessionService } from './upload-session.service';
 
 @Module({
-  imports: [AppSettingsModule, LibraryModule, MetadataModule, BookMetadataFetchModule, FileWriteModule, PathModule],
+  imports: [AppSettingsModule, BookCoverStoreModule, LibraryModule, MetadataModule, BookMetadataFetchModule, FileWriteModule, PathModule],
   controllers: [UploadController, BookFileUploadController, UploadSessionController],
   providers: [UploadService, UploadValidatorService, UploadStorageService, UploadProcessorService, UploadSessionRepository, UploadSessionService],
   exports: [UploadValidatorService, UploadStorageService, UploadProcessorService, UploadService],
diff --git a/server/src/modules/upload/upload.service.test.ts b/server/src/modules/upload/upload.service.test.ts
index dee94ba61..a625e7d6b 100644
--- a/server/src/modules/upload/upload.service.test.ts
+++ b/server/src/modules/upload/upload.service.test.ts
@@ -102,6 +102,7 @@ describe('UploadService', () => {
     processNewBookImportAsync: vi.fn(),
     extractMetadataAsync: vi.fn(),
     extractAudioDurationAsync: vi.fn(),
+    reconcileCoversAsync: vi.fn(),
   };
 
   const user = { id: 7, isSuperuser: false, permissions: [] } as any;
@@ -1089,6 +1090,7 @@ describe('UploadService', () => {
       await service.addFileToBook(10, 'chapter-02.mp3', {} as any, user);
 
       expect(processor.extractAudioDurationAsync).toHaveBeenCalledWith(10, '/library/Book Title/chapter-02.mp3', 'mp3');
+      expect(processor.reconcileCoversAsync).toHaveBeenCalledWith([10]);
     });
 
     it('delegates duration extraction to the processor regardless of format (processor gates on audio)', async () => {
diff --git a/server/src/modules/upload/upload.service.ts b/server/src/modules/upload/upload.service.ts
index 0ca196a4e..54d7f6bbe 100644
--- a/server/src/modules/upload/upload.service.ts
+++ b/server/src/modules/upload/upload.service.ts
@@ -339,6 +339,7 @@ export class UploadService {
       });
 
       this.processor.extractAudioDurationAsync(bookId, destination, format);
+      this.processor.reconcileCoversAsync([bookId]);
 
       this.logger.log(
         `[${event}] [end] bookId=${bookId} userId=${user.id} fileId=${inserted.id} format=${format} sizeBytes=${sizeBytes} durationMs=${Date.now() - startedAt} - add file to book completed`,
diff --git a/server/src/modules/watch-download/watch-download.controller.ts b/server/src/modules/watch-download/watch-download.controller.ts
index 1677794c7..8c71dd29e 100644
--- a/server/src/modules/watch-download/watch-download.controller.ts
+++ b/server/src/modules/watch-download/watch-download.controller.ts
@@ -92,7 +92,7 @@ export class WatchDownloadController {
     @Res() reply: FastifyReply,
   ) {
     const user = await this.watchDownloads.authorize(authorization, bookId);
-    const path = await this.bookService.getCoverPath(bookId, user);
+    const path = await this.bookService.getCoverPath(bookId, user, { medium: 'audio' });
     if (!path) throw new NotFoundException(`No cover for book ${bookId}`);
     const info = await stat(path);
     reply.header('Content-Length', info.size);
diff --git a/server/src/modules/watch-download/watch-download.service.ts b/server/src/modules/watch-download/watch-download.service.ts
index 418de72e6..c0b7c28ed 100644
--- a/server/src/modules/watch-download/watch-download.service.ts
+++ b/server/src/modules/watch-download/watch-download.service.ts
@@ -79,7 +79,7 @@ export class WatchDownloadService {
       },
     );
     const expiresAt = new Date(Date.now() + WATCH_DOWNLOAD_TTL_SECONDS * 1000).toISOString();
-    const coverPath = await this.bookService.getCoverPath(bookId, user);
+    const coverPath = await this.bookService.getCoverPath(bookId, user, { medium: 'audio' });
 
     return {
       token,
@@ -142,7 +142,7 @@ export class WatchDownloadService {
       },
     );
     const expiresAt = new Date(Date.now() + WATCH_DOWNLOAD_TTL_SECONDS * 1000).toISOString();
-    const coverPath = await this.bookService.getCoverPath(bookId, user);
+    const coverPath = await this.bookService.getCoverPath(bookId, user, { medium: 'audio' });
 
     return {
       token,
diff --git a/server/test/book-api-contract.e2e-spec.ts b/server/test/book-api-contract.e2e-spec.ts
index 50af77367..fc5708b93 100644
--- a/server/test/book-api-contract.e2e-spec.ts
+++ b/server/test/book-api-contract.e2e-spec.ts
@@ -1,13 +1,17 @@
 import { randomUUID } from 'crypto';
 
-import { eq } from 'drizzle-orm';
-import { rm, stat } from 'fs/promises';
+import { and, eq } from 'drizzle-orm';
+import { readdir, rm, stat } from 'fs/promises';
 import { join } from 'path';
 
 import * as unzipper from 'unzipper';
 import { Permission } from '@bookorbit/types';
 
-import { books } from '../src/db/schema/books';
+import { appSettings } from '../src/db/schema/auth';
+import { bookCovers } from '../src/db/schema/book-covers';
+import { bookFiles, books } from '../src/db/schema/books';
+import { bookMetadata } from '../src/db/schema/metadata';
+import { CoverSlotBackfillService } from '../src/modules/cover/cover-slot-backfill.service';
 
 import {
   authHeader,
@@ -23,6 +27,7 @@ import {
   type TestUserSession,
 } from './e2e/metadata-write/metadata-write-harness';
 import { createCbzFixture, createEpubFixture, createPdfFixture, writeFixtureFile } from './e2e/metadata-write/metadata-write-fixture-builder';
+import { createSlotCoverArtifacts } from './e2e/slot-cover-artifacts';
 
 type InjectResponse = Awaited<ReturnType<MetadataWriteE2EContext['app']['inject']>>;
 
@@ -50,28 +55,6 @@ async function listZipEntries(response: InjectResponse): Promise<string[]> {
   return zip.files.map((file) => file.path).sort();
 }
 
-async function createBookCoverArtifacts(
-  ctx: MetadataWriteE2EContext,
-  bookId: number,
-  options: {
-    coverExtension?: 'jpg' | 'png';
-    coverContent?: Buffer;
-    thumbnailContent?: Buffer;
-  } = {},
-): Promise<void> {
-  const coverExtension = options.coverExtension ?? 'jpg';
-  await writeFixtureFile(
-    ctx.fixture.booksPath,
-    `covers/${bookId}/cover_custom.${coverExtension}`,
-    options.coverContent ?? Buffer.from(`cover-${bookId}`, 'utf8'),
-  );
-  await writeFixtureFile(
-    ctx.fixture.booksPath,
-    `covers/${bookId}/thumbnail.jpg`,
-    options.thumbnailContent ?? Buffer.from(`thumbnail-${bookId}`, 'utf8'),
-  );
-}
-
 describe('Book API contract (e2e)', { timeout: SCENARIO_TIMEOUT_MS }, () => {
   let ctx!: MetadataWriteE2EContext;
 
@@ -133,7 +116,7 @@ describe('Book API contract (e2e)', { timeout: SCENARIO_TIMEOUT_MS }, () => {
     await grantLibraryAccess(ctx, crossLibraryUser.userId, hiddenLibrary.libraryId, 'viewer');
     await grantLibraryAccess(ctx, downloadUser.userId, visibleLibrary.libraryId, 'viewer');
 
-    await createBookCoverArtifacts(ctx, visibleEpub.bookId, {
+    await createSlotCoverArtifacts(ctx, visibleEpub.bookId, {
       coverExtension: 'png',
       coverContent: Buffer.from('cover-png', 'utf8'),
       thumbnailContent: Buffer.from('thumbnail-jpg', 'utf8'),
@@ -344,6 +327,59 @@ describe('Book API contract (e2e)', { timeout: SCENARIO_TIMEOUT_MS }, () => {
         items: [{ id: visibleEpub.bookId, files: [{ id: visibleEpub.bookFileId, role: 'primary', sizeBytes: primaryFileSize }] }],
       });
     });
+
+    it('filters books with audiobook media by whether their audio cover slot is filled', async () => {
+      const [pdfFile] = await ctx.db
+        .select({ libraryFolderId: bookFiles.libraryFolderId })
+        .from(bookFiles)
+        .where(eq(bookFiles.id, visiblePdf.bookFileId));
+      const [audioFile] = await ctx.db
+        .insert(bookFiles)
+        .values({
+          bookId: visiblePdf.bookId,
+          libraryFolderId: pdfFile!.libraryFolderId,
+          absolutePath: join(visibleLibrary.folderPath, 'contracts/beta-contract.m4b'),
+          relPath: 'contracts/beta-contract.m4b',
+          ino: 987_654_321n,
+          format: 'm4b',
+          role: 'content',
+        })
+        .returning({ id: bookFiles.id });
+
+      const audioCoverBookIds = async (operator: 'isMissing' | 'isPresent') => {
+        const response = await ctx.app.inject({
+          method: 'POST',
+          url: '/api/v1/books/query',
+          headers: authHeader(limitedUser.accessToken),
+          payload: {
+            filter: { type: 'group', join: 'AND', rules: [{ type: 'rule', field: 'audioCover', operator }] },
+            sort: [{ field: 'title', dir: 'asc' }],
+            pagination: { page: 0, size: 20 },
+          },
+        });
+        expect(response.statusCode).toBe(201);
+        return (response.json() as { items: { id: number }[] }).items.map((item) => item.id);
+      };
+
+      try {
+        expect(await audioCoverBookIds('isMissing')).toEqual([visiblePdf.bookId]);
+        expect(await audioCoverBookIds('isPresent')).toEqual([]);
+
+        await ctx.db.insert(bookCovers).values({ bookId: visiblePdf.bookId, medium: 'audio', source: 'custom', origin: 'upload' });
+        expect(await audioCoverBookIds('isMissing')).toEqual([]);
+        expect(await audioCoverBookIds('isPresent')).toEqual([visiblePdf.bookId]);
+
+        await ctx.db
+          .update(bookCovers)
+          .set({ dormantSince: new Date() })
+          .where(and(eq(bookCovers.bookId, visiblePdf.bookId), eq(bookCovers.medium, 'audio')));
+        expect(await audioCoverBookIds('isMissing')).toEqual([visiblePdf.bookId]);
+        expect(await audioCoverBookIds('isPresent')).toEqual([]);
+      } finally {
+        await ctx.db.delete(bookCovers).where(and(eq(bookCovers.bookId, visiblePdf.bookId), eq(bookCovers.medium, 'audio')));
+        await ctx.db.delete(bookFiles).where(eq(bookFiles.id, audioFile!.id));
+      }
+    });
   });
 
   describe('bulk query selections', () => {
@@ -482,6 +518,12 @@ describe('Book API contract (e2e)', { timeout: SCENARIO_TIMEOUT_MS }, () => {
         koboLocationValue: null,
         koboContentSourceProgressPercent: null,
         koreaderProgress: null,
+        positionSeconds: null,
+        textUpdatedAt: null,
+        narrationPercentage: null,
+        narrationUpdatedAt: null,
+        mediaOverlaySectionIndex: null,
+        mediaOverlayFragment: null,
       });
 
       const limitedBookProgress = await ctx.app.inject({
@@ -518,6 +560,9 @@ describe('Book API contract (e2e)', { timeout: SCENARIO_TIMEOUT_MS }, () => {
           koboLocationValue: null,
           koboContentSourceProgressPercent: null,
           koreaderProgress: null,
+          positionSeconds: null,
+          mediaOverlaySectionIndex: null,
+          mediaOverlayFragment: null,
           updatedAt: null,
         },
       ]);
@@ -534,7 +579,10 @@ describe('Book API contract (e2e)', { timeout: SCENARIO_TIMEOUT_MS }, () => {
         libraryId: visibleLibrary.libraryId,
         libraryName: visibleLibraryName,
         title: 'Alpha Contract EPUB',
-        coverSource: null,
+        coverSource: 'custom',
+        coverMedia: ['ebook'],
+        covers: { ebook: { source: 'custom', updatedAt: expect.any(String), width: null, height: null }, audio: null },
+        coverVersion: expect.stringMatching(/^ebook:/),
         files: [
           {
             id: visibleEpub.bookFileId,
@@ -569,7 +617,7 @@ describe('Book API contract (e2e)', { timeout: SCENARIO_TIMEOUT_MS }, () => {
         headers: authHeader(limitedUser.accessToken),
       });
 
-      expect(inaccessibleDetail.statusCode).toBe(403);
+      expect(inaccessibleDetail.statusCode).toBe(404);
     });
   });
 
@@ -684,6 +732,20 @@ describe('Book API contract (e2e)', { timeout: SCENARIO_TIMEOUT_MS }, () => {
       expect(cover.headers.etag).toBeTruthy();
       expect(cover.headers['cache-control']).toBe('private, max-age=86400');
 
+      const invalidMedium = await ctx.app.inject({
+        method: 'GET',
+        url: `/api/v1/books/${visibleEpub.bookId}/cover?medium=print`,
+        headers: authHeader(limitedUser.accessToken),
+      });
+      expectError(invalidMedium, 400);
+
+      const invalidStrict = await ctx.app.inject({
+        method: 'GET',
+        url: `/api/v1/books/${visibleEpub.bookId}/cover?strict=yes`,
+        headers: authHeader(limitedUser.accessToken),
+      });
+      expectError(invalidStrict, 400);
+
       const cachedCover = await ctx.app.inject({
         method: 'GET',
         url: `/api/v1/books/${visibleEpub.bookId}/cover`,
@@ -740,6 +802,66 @@ describe('Book API contract (e2e)', { timeout: SCENARIO_TIMEOUT_MS }, () => {
 
       expectError(missingThumbnail, 404, `No thumbnail for book ${visibleEpub.bookId}`);
     });
+
+    it('restores a cover summary that disagrees with the slots when the upgrade runs, without moving updated_at', async () => {
+      await ctx.db.insert(bookCovers).values({ bookId: visibleCbz.bookId, medium: 'ebook', source: 'custom', origin: 'upload' });
+      await ctx.db.update(bookMetadata).set({ coverSource: null }).where(eq(bookMetadata.bookId, visibleCbz.bookId));
+      const [before] = await ctx.db
+        .select({ updatedAt: bookMetadata.updatedAt })
+        .from(bookMetadata)
+        .where(eq(bookMetadata.bookId, visibleCbz.bookId));
+      const marker = JSON.stringify({ version: 3, stage: 'c', lastBookId: 0 });
+      await ctx.db
+        .insert(appSettings)
+        .values({ key: 'cover_slots_backfill', value: marker })
+        .onConflictDoUpdate({ target: appSettings.key, set: { value: marker } });
+      try {
+        const result = await ctx.app.get(CoverSlotBackfillService).run();
+
+        expect(result.repaired).toBeGreaterThanOrEqual(1);
+        const [after] = await ctx.db
+          .select({ coverSource: bookMetadata.coverSource, updatedAt: bookMetadata.updatedAt })
+          .from(bookMetadata)
+          .where(eq(bookMetadata.bookId, visibleCbz.bookId));
+        expect(after).toEqual({ coverSource: 'custom', updatedAt: before!.updatedAt });
+        await expect(ctx.app.get(CoverSlotBackfillService).run()).resolves.toMatchObject({ repaired: 0 });
+      } finally {
+        await ctx.db.delete(bookCovers).where(eq(bookCovers.bookId, visibleCbz.bookId));
+        await ctx.db.update(bookMetadata).set({ coverSource: null }).where(eq(bookMetadata.bookId, visibleCbz.bookId));
+      }
+    });
+
+    it('moves a cover left in the old root layout into its slot on first read, with no coverSource needed', async () => {
+      const coverDir = join(ctx.fixture.booksPath, 'covers', String(visibleCbz.bookId));
+      await writeFixtureFile(ctx.fixture.booksPath, `covers/${visibleCbz.bookId}/cover_custom.jpg`, Buffer.from('legacy-cover', 'utf8'));
+      await writeFixtureFile(ctx.fixture.booksPath, `covers/${visibleCbz.bookId}/thumbnail.jpg`, Buffer.from('legacy-thumbnail', 'utf8'));
+      try {
+        const thumbnail = await ctx.app.inject({
+          method: 'GET',
+          url: `/api/v1/books/${visibleCbz.bookId}/thumbnail`,
+          headers: authHeader(limitedUser.accessToken),
+        });
+        expect(thumbnail.statusCode).toBe(200);
+        expect(thumbnail.body).toBe('legacy-thumbnail');
+
+        const slots = await ctx.db.select().from(bookCovers).where(eq(bookCovers.bookId, visibleCbz.bookId));
+        expect(slots).toEqual([expect.objectContaining({ medium: 'ebook', source: 'custom', origin: 'legacy', dormantSince: null })]);
+        expect(await readdir(coverDir)).toEqual(['ebook']);
+        expect((await readdir(join(coverDir, 'ebook'))).sort()).toEqual(['cover_custom.jpg', 'thumbnail.jpg']);
+
+        const cover = await ctx.app.inject({
+          method: 'GET',
+          url: `/api/v1/books/${visibleCbz.bookId}/cover`,
+          headers: authHeader(limitedUser.accessToken),
+        });
+        expect(cover.statusCode).toBe(200);
+        expect(cover.body).toBe('legacy-cover');
+      } finally {
+        await ctx.db.delete(bookCovers).where(eq(bookCovers.bookId, visibleCbz.bookId));
+        await ctx.db.update(bookMetadata).set({ coverSource: null }).where(eq(bookMetadata.bookId, visibleCbz.bookId));
+        await rm(coverDir, { recursive: true, force: true });
+      }
+    });
   });
 
   describe('user-supplied added dates', () => {
diff --git a/server/test/e2e/app-harness.ts b/server/test/e2e/app-harness.ts
index a37ab28fc..5f0f7b8eb 100644
--- a/server/test/e2e/app-harness.ts
+++ b/server/test/e2e/app-harness.ts
@@ -1,4 +1,7 @@
 import { randomUUID } from 'crypto';
+import { mkdtemp, rm } from 'fs/promises';
+import { tmpdir } from 'os';
+import { join } from 'path';
 import { expect, vi } from 'vitest';
 import fastifyCookie from '@fastify/cookie';
 import { count, eq, inArray, isNull, sql } from 'drizzle-orm';
@@ -104,9 +107,20 @@ export interface E2EContext {
   app: NestFastifyApplication;
   db: Db;
   adminToken: string;
+  /** Set when the context owns a throwaway data folder, which close removes again. */
+  isolatedAppData: { path: string; previous: string | undefined } | null;
 }
 
-export async function createE2EContext(): Promise<E2EContext> {
+/**
+ * Scans write and prune covers under APP_DATA_PATH, which `.env` points at the developer's own
+ * data folder. Suites that scan and do not set their own path pass `isolateAppData`.
+ */
+export async function createE2EContext(options: { isolateAppData?: boolean } = {}): Promise<E2EContext> {
+  let isolatedAppData: E2EContext['isolatedAppData'] = null;
+  if (options.isolateAppData) {
+    isolatedAppData = { path: await mkdtemp(join(tmpdir(), 'bookorbit-e2e-data-')), previous: process.env.APP_DATA_PATH };
+    process.env.APP_DATA_PATH = isolatedAppData.path;
+  }
   const moduleFixture = await Test.createTestingModule({
     imports: [AppModule],
   })
@@ -130,11 +144,15 @@ export async function createE2EContext(): Promise<E2EContext> {
 
   const db = app.get<Db>(DB);
   const adminToken = await getAdminToken(app);
-  return { app, db, adminToken };
+  return { app, db, adminToken, isolatedAppData };
 }
 
 export async function closeE2EContext(ctx: E2EContext): Promise<void> {
   await ctx.app.close();
+  if (!ctx.isolatedAppData) return;
+  if (ctx.isolatedAppData.previous === undefined) delete process.env.APP_DATA_PATH;
+  else process.env.APP_DATA_PATH = ctx.isolatedAppData.previous;
+  await rm(ctx.isolatedAppData.path, { recursive: true, force: true });
 }
 
 export interface SeedLibraryInput {
diff --git a/server/test/e2e/authorization-matrix/authorization-matrix-harness.ts b/server/test/e2e/authorization-matrix/authorization-matrix-harness.ts
index 4d31f0b1d..09b2614b8 100644
--- a/server/test/e2e/authorization-matrix/authorization-matrix-harness.ts
+++ b/server/test/e2e/authorization-matrix/authorization-matrix-harness.ts
@@ -17,6 +17,7 @@ import * as schema from '../../../src/db/schema';
 import { MetadataService } from '../../../src/modules/metadata/metadata.service';
 import { BookDockWatcherService } from '../../../src/modules/book-dock/book-dock-watcher.service';
 import { makeMetadataNoopMock, seedLibrary, waitForScanCompletion, type MetadataNoopMock } from '../app-harness';
+import { createSlotCoverArtifacts, type SlotCoverArtifactOptions } from '../slot-cover-artifacts';
 import {
   buildFb2Fixture,
   createAuthorizationFixtureRoot,
@@ -310,18 +311,9 @@ export async function locateBookByAbsolutePath(ctx: AuthorizationMatrixE2EContex
 export async function createBookCoverArtifacts(
   ctx: AuthorizationMatrixE2EContext,
   bookId: number,
-  options: {
-    coverExtension?: 'jpg' | 'png';
-    coverContent?: Buffer;
-    thumbnailContent?: Buffer;
-  } = {},
+  options: SlotCoverArtifactOptions = {},
 ): Promise<void> {
-  const coverExtension = options.coverExtension ?? 'jpg';
-  const coverContent = options.coverContent ?? Buffer.from(`cover-${bookId}`, 'utf8');
-  const thumbnailContent = options.thumbnailContent ?? Buffer.from(`thumbnail-${bookId}`, 'utf8');
-
-  await writeFixtureFile(ctx.fixture.booksPath, `covers/${bookId}/cover.${coverExtension}`, coverContent);
-  await writeFixtureFile(ctx.fixture.booksPath, `covers/${bookId}/thumbnail.jpg`, thumbnailContent);
+  await createSlotCoverArtifacts(ctx, bookId, options);
 }
 
 export async function createBookDockRow(
diff --git a/server/test/e2e/authorization-matrix/route-inventory/manifest.json b/server/test/e2e/authorization-matrix/route-inventory/manifest.json
index e77f53697..479c4b0b3 100644
--- a/server/test/e2e/authorization-matrix/route-inventory/manifest.json
+++ b/server/test/e2e/authorization-matrix/route-inventory/manifest.json
@@ -1,7 +1,7 @@
 {
-  "totalRoutes": 612,
+  "totalRoutes": 614,
   "byPermission": {
-    "(none)": 260,
+    "(none)": 262,
     "Permission.ManageMetadataConfig": 34,
     "Permission.EmailSend": 30,
     "Permission.LibraryEditMetadata": 35,
diff --git a/server/test/e2e/authorization-matrix/route-inventory/routes-05.json b/server/test/e2e/authorization-matrix/route-inventory/routes-05.json
index ff71faf59..07b3187c2 100644
--- a/server/test/e2e/authorization-matrix/route-inventory/routes-05.json
+++ b/server/test/e2e/authorization-matrix/route-inventory/routes-05.json
@@ -515,6 +515,18 @@
     "allowDefault": false,
     "useGuards": []
   },
+  {
+    "file": "server/src/modules/reader-preferences/reader-preferences.controller.ts",
+    "className": "ReaderPreferencesController",
+    "methodName": "patchPreference",
+    "httpMethod": "PATCH",
+    "path": "/reader/preferences/:bookFileId",
+    "permissions": [],
+    "libraryAccess": [],
+    "isPublic": false,
+    "allowDefault": false,
+    "useGuards": []
+  },
   {
     "file": "server/src/modules/reader-preferences/reader-preferences.controller.ts",
     "className": "ReaderPreferencesController",
@@ -551,6 +563,18 @@
     "allowDefault": false,
     "useGuards": []
   },
+  {
+    "file": "server/src/modules/reader-preferences/reader-preferences.controller.ts",
+    "className": "ReaderPreferencesController",
+    "methodName": "patchDefault",
+    "httpMethod": "PATCH",
+    "path": "/reader/defaults/:formatGroup",
+    "permissions": [],
+    "libraryAccess": [],
+    "isPublic": false,
+    "allowDefault": false,
+    "useGuards": []
+  },
   {
     "file": "server/src/modules/reader-preferences/reader-preferences.controller.ts",
     "className": "ReaderPreferencesController",
diff --git a/server/test/e2e/metadata-lock/metadata-lock-harness.ts b/server/test/e2e/metadata-lock/metadata-lock-harness.ts
index ed7a9d464..7abb172ea 100644
--- a/server/test/e2e/metadata-lock/metadata-lock-harness.ts
+++ b/server/test/e2e/metadata-lock/metadata-lock-harness.ts
@@ -339,9 +339,12 @@ export async function findCoverFilePath(
   prefix: string = COVER_EXTRACTED_FILE_PREFIX,
 ): Promise<string | null> {
   const dir = coverDirPath(ctx.fixture.booksPath, bookId);
-  const entries = await readdir(dir).catch(() => [] as string[]);
-  const fileName = entries.find((entry) => entry.startsWith(prefix));
-  return fileName ? join(dir, fileName) : null;
+  for (const candidate of [dir, join(dir, 'ebook'), join(dir, 'audio')]) {
+    const entries = await readdir(candidate).catch(() => [] as string[]);
+    const fileName = entries.find((entry) => entry.startsWith(prefix));
+    if (fileName) return join(candidate, fileName);
+  }
+  return null;
 }
 
 export async function uploadBookCover(
diff --git a/server/test/e2e/opds/opds-harness.ts b/server/test/e2e/opds/opds-harness.ts
index b763c3436..9278fde9a 100644
--- a/server/test/e2e/opds/opds-harness.ts
+++ b/server/test/e2e/opds/opds-harness.ts
@@ -14,7 +14,8 @@ import * as schema from '../../../src/db/schema';
 import { MetadataService } from '../../../src/modules/metadata/metadata.service';
 import { BookDockWatcherService } from '../../../src/modules/book-dock/book-dock-watcher.service';
 import { seedLibrary, waitForScanCompletion } from '../app-harness';
-import { createOpdsFixtureRoot, type OpdsFixtureRoot, writeFixtureFile } from './opds-fixture-builder';
+import { createSlotCoverArtifacts, type SlotCoverArtifactOptions } from '../slot-cover-artifacts';
+import { createOpdsFixtureRoot, type OpdsFixtureRoot } from './opds-fixture-builder';
 
 type Db = NodePgDatabase<typeof schema>;
 
@@ -193,26 +194,8 @@ export async function locateBookByAbsolutePath(ctx: OpdsE2EContext, absolutePath
   return row;
 }
 
-export async function createBookCoverArtifacts(
-  ctx: OpdsE2EContext,
-  bookId: number,
-  options: {
-    coverExtension?: 'jpg' | 'png';
-    coverContent?: Buffer;
-    thumbnailContent?: Buffer;
-  } = {},
-): Promise<void> {
-  const coverExtension = options.coverExtension ?? 'jpg';
-  const coverContent = options.coverContent ?? Buffer.from(`cover-${bookId}`, 'utf8');
-  const thumbnailContent = options.thumbnailContent ?? Buffer.from(`thumbnail-${bookId}`, 'utf8');
-
-  await writeFixtureFile(ctx.fixture.booksPath, `covers/${bookId}/cover.${coverExtension}`, coverContent);
-  await writeFixtureFile(ctx.fixture.booksPath, `covers/${bookId}/thumbnail.jpg`, thumbnailContent);
-
-  await ctx.db
-    .insert(schema.bookMetadata)
-    .values({ bookId, coverSource: 'custom' })
-    .onConflictDoUpdate({ target: schema.bookMetadata.bookId, set: { coverSource: 'custom' } });
+export async function createBookCoverArtifacts(ctx: OpdsE2EContext, bookId: number, options: SlotCoverArtifactOptions = {}): Promise<void> {
+  await createSlotCoverArtifacts(ctx, bookId, options);
 }
 
 export async function createUserAndLogin(
diff --git a/server/test/e2e/scanner/cover-slot-fixtures.ts b/server/test/e2e/scanner/cover-slot-fixtures.ts
new file mode 100644
index 000000000..bff634a44
--- /dev/null
+++ b/server/test/e2e/scanner/cover-slot-fixtures.ts
@@ -0,0 +1,43 @@
+import { ZipArchive } from 'archiver';
+import { createWriteStream } from 'fs';
+import { mkdir, writeFile } from 'fs/promises';
+import { dirname } from 'path';
+import sharp from 'sharp';
+
+export function jpeg(width: number, height: number): Promise<Buffer> {
+  return sharp({ create: { width, height, channels: 3, background: { r: 40, g: 110, b: 180 } } })
+    .jpeg()
+    .toBuffer();
+}
+
+/** A minimal EPUB 3 whose manifest names a cover image, so the scanner extracts real art from it. */
+export async function writeEpubWithCover(path: string, cover: Buffer): Promise<void> {
+  await mkdir(dirname(path), { recursive: true });
+  const opf = `<?xml version="1.0"?><package version="3.0" unique-identifier="uid" xmlns="http://www.idpf.org/2007/opf">
+    <metadata xmlns:dc="http://purl.org/dc/elements/1.1/"><dc:identifier id="uid">urn:e2e:cover-slots</dc:identifier><dc:title>Cover Slots</dc:title><dc:language>en</dc:language></metadata>
+    <manifest><item id="cover" href="cover.jpg" media-type="image/jpeg" properties="cover-image" /><item id="c1" href="c1.xhtml" media-type="application/xhtml+xml" /></manifest>
+    <spine><itemref idref="c1" /></spine></package>`;
+  const output = createWriteStream(path);
+  const archive = new ZipArchive({ zlib: { level: 6 } });
+  await new Promise<void>((resolve, reject) => {
+    output.on('close', resolve);
+    archive.on('error', reject);
+    archive.pipe(output);
+    archive.append(Buffer.from('application/epub+zip'), { name: 'mimetype', store: true });
+    archive.append(
+      Buffer.from(
+        '<?xml version="1.0"?><container xmlns="urn:oasis:names:tc:opendocument:xmlns:container"><rootfiles><rootfile full-path="OPS/content.opf" media-type="application/oebps-package+xml" /></rootfiles></container>',
+      ),
+      { name: 'META-INF/container.xml' },
+    );
+    archive.append(Buffer.from(opf), { name: 'OPS/content.opf' });
+    archive.append(Buffer.from('<html xmlns="http://www.w3.org/1999/xhtml"><body><p>x</p></body></html>'), { name: 'OPS/c1.xhtml' });
+    archive.append(cover, { name: 'OPS/cover.jpg' });
+    void archive.finalize();
+  });
+}
+
+export async function writeImage(path: string, width: number, height: number): Promise<void> {
+  await mkdir(dirname(path), { recursive: true });
+  await writeFile(path, await jpeg(width, height));
+}
diff --git a/server/test/e2e/scanner/scanner-harness.ts b/server/test/e2e/scanner/scanner-harness.ts
index 79cb3ea5c..fd0d111e3 100644
--- a/server/test/e2e/scanner/scanner-harness.ts
+++ b/server/test/e2e/scanner/scanner-harness.ts
@@ -1,7 +1,6 @@
 export {
   assertNoIntegrityViolations,
   closeE2EContext as closeScannerE2EContext,
-  createE2EContext as createScannerE2EContext,
   loadLibraryBookState,
   seedLibrary,
   triggerAndWaitForLibraryScan,
@@ -14,7 +13,12 @@ export {
 } from '../app-harness';
 
 import { FileWatcherService } from '../../../src/modules/scanner/file-watcher.service';
-import type { E2EContext } from '../app-harness';
+import { createE2EContext, type E2EContext } from '../app-harness';
+
+/** Scans write covers, so every scanner suite gets its own data folder. */
+export function createScannerE2EContext(): Promise<E2EContext> {
+  return createE2EContext({ isolateAppData: true });
+}
 
 export async function startLibraryWatcher(ctx: E2EContext, libraryId: number, paths: string[]): Promise<void> {
   const watcher = ctx.app.get(FileWatcherService);
diff --git a/server/test/e2e/slot-cover-artifacts.ts b/server/test/e2e/slot-cover-artifacts.ts
new file mode 100644
index 000000000..6d663f7fb
--- /dev/null
+++ b/server/test/e2e/slot-cover-artifacts.ts
@@ -0,0 +1,44 @@
+import { mkdir, writeFile } from 'fs/promises';
+import { join } from 'path';
+import type { NodePgDatabase } from 'drizzle-orm/node-postgres';
+import type { CoverMedium } from '@bookorbit/types';
+
+import { COVER_THUMBNAIL_FILE_NAME, bookCoverSlotDirPath } from '../../src/common/book-cover-storage';
+import * as schema from '../../src/db/schema';
+
+type SlotCoverContext = {
+  db: NodePgDatabase<typeof schema>;
+  fixture: { booksPath: string };
+};
+
+export type SlotCoverArtifactOptions = {
+  medium?: CoverMedium;
+  source?: 'custom' | 'extracted';
+  coverExtension?: 'jpg' | 'png';
+  coverContent?: Buffer;
+  thumbnailContent?: Buffer;
+};
+
+/**
+ * Lays a cover out the way the cover store does: the files in the slot's directory, the slot row,
+ * and the `cover_source` summary beside it. The bytes need not be an image; the row leaves the
+ * measured size empty, as the store does for anything it cannot read.
+ */
+export async function createSlotCoverArtifacts(ctx: SlotCoverContext, bookId: number, options: SlotCoverArtifactOptions = {}): Promise<void> {
+  const medium = options.medium ?? 'ebook';
+  const source = options.source ?? 'custom';
+  const dir = bookCoverSlotDirPath(ctx.fixture.booksPath, bookId, medium);
+  await mkdir(dir, { recursive: true });
+  await writeFile(join(dir, `cover_${source}.${options.coverExtension ?? 'jpg'}`), options.coverContent ?? Buffer.from(`cover-${bookId}`, 'utf8'));
+  await writeFile(join(dir, COVER_THUMBNAIL_FILE_NAME), options.thumbnailContent ?? Buffer.from(`thumbnail-${bookId}`, 'utf8'));
+
+  const row = { source, origin: source === 'custom' ? 'upload' : 'embedded', width: null, height: null, updatedAt: new Date(), dormantSince: null };
+  await ctx.db
+    .insert(schema.bookCovers)
+    .values({ bookId, medium, ...row })
+    .onConflictDoUpdate({ target: [schema.bookCovers.bookId, schema.bookCovers.medium], set: row });
+  await ctx.db
+    .insert(schema.bookMetadata)
+    .values({ bookId, coverSource: source })
+    .onConflictDoUpdate({ target: schema.bookMetadata.bookId, set: { coverSource: source } });
+}
diff --git a/server/test/email-lifecycle.e2e-spec.ts b/server/test/email-lifecycle.e2e-spec.ts
index 1cb932313..3a026545f 100644
--- a/server/test/email-lifecycle.e2e-spec.ts
+++ b/server/test/email-lifecycle.e2e-spec.ts
@@ -217,8 +217,12 @@ describe('Email lifecycle (e2e)', { timeout: 180_000 }, () => {
       expect(senderListBeforeShare.statusCode).toBe(200);
       expect(senderListBeforeShare.json()).toEqual([]);
 
+      const senderToggleShare = await apiAs(senderOnly, 'PATCH', `/api/v1/email/providers/${createdProvider.id}/share`);
+      expectError(senderToggleShare, 403, Permission.ManageEmail);
+
       const managerToggleShare = await apiAs(managerOnly, 'PATCH', `/api/v1/email/providers/${createdProvider.id}/share`);
-      expectError(managerToggleShare, 403, 'Only superusers can share providers');
+      expect(managerToggleShare.statusCode).toBe(200);
+      expect((managerToggleShare.json() as { isShared: boolean }).isShared).toBe(true);
 
       const superToggleShare = await apiAs(superManager, 'PATCH', `/api/v1/email/providers/${createdProvider.id}/share`);
       expectError(superToggleShare, 403, 'Cannot modify this provider');
diff --git a/server/test/kobo-cover-identity.e2e-spec.ts b/server/test/kobo-cover-identity.e2e-spec.ts
index 49814e92d..e3ec7eac7 100644
--- a/server/test/kobo-cover-identity.e2e-spec.ts
+++ b/server/test/kobo-cover-identity.e2e-spec.ts
@@ -4,6 +4,7 @@ import { join } from 'path';
 import { and, eq } from 'drizzle-orm';
 
 import * as schema from '../src/db/schema';
+import { CoverSlotBackfillService } from '../src/modules/cover/cover-slot-backfill.service';
 import { createEpubFixture } from './e2e/reader-state-isolation/reader-state-isolation-fixture-builder';
 import {
   authHeader,
@@ -179,6 +180,30 @@ describe('Kobo cover image identity (e2e)', { timeout: 180_000 }, () => {
     if (ctx) await closeReaderStateIsolationE2EContext(ctx);
   });
 
+  it('keeps the CoverImageId when Stage A converts the legacy cover', async () => {
+    const coverIdBefore = coverIdHeldByDevice;
+    const [before] = await ctx.db
+      .select({ coverUpdatedAt: schema.bookMetadata.coverUpdatedAt })
+      .from(schema.bookMetadata)
+      .where(eq(schema.bookMetadata.bookId, bookId));
+
+    const result = await ctx.app.get(CoverSlotBackfillService).run();
+
+    expect(result.converted).toBeGreaterThanOrEqual(1);
+    const [after] = await ctx.db
+      .select({ coverUpdatedAt: schema.bookMetadata.coverUpdatedAt })
+      .from(schema.bookMetadata)
+      .where(eq(schema.bookMetadata.bookId, bookId));
+    const [slot] = await ctx.db.select().from(schema.bookCovers).where(eq(schema.bookCovers.bookId, bookId));
+    expect(slot).toMatchObject({ medium: 'ebook', source: 'custom', origin: 'legacy' });
+    expect(after!.coverUpdatedAt!.getTime()).toBe(before!.coverUpdatedAt!.getTime());
+
+    await editMetadata({ title: 'Kobo Cover Identity, Converted' });
+    const delivered = await drainDelivered();
+    expect(delivered).toHaveLength(1);
+    expect(delivered[0]!.CoverImageId).toBe(coverIdBefore);
+  });
+
   it('keeps the CoverImageId across a metadata edit while still delivering the change', async () => {
     const coverIdBefore = coverIdHeldByDevice;
     expect(await thumbnailStatus(coverIdBefore)).toBe(200);
diff --git a/server/test/library-admin-workflows.e2e-spec.ts b/server/test/library-admin-workflows.e2e-spec.ts
index 4155a0bb9..775b3d5f3 100644
--- a/server/test/library-admin-workflows.e2e-spec.ts
+++ b/server/test/library-admin-workflows.e2e-spec.ts
@@ -20,7 +20,8 @@ import {
   type AuthorizationMatrixE2EContext,
   type TestUserSession,
 } from './e2e/authorization-matrix/authorization-matrix-harness';
-import { createEpubFixture, writeFixtureFile } from './e2e/authorization-matrix/authorization-matrix-fixture-builder';
+import { createEpubFixture } from './e2e/authorization-matrix/authorization-matrix-fixture-builder';
+import { createSlotCoverArtifacts } from './e2e/slot-cover-artifacts';
 
 type InjectResponse = Awaited<ReturnType<AuthorizationMatrixE2EContext['app']['inject']>>;
 
@@ -734,7 +735,8 @@ describe('Library admin workflows (e2e)', { timeout: SCENARIO_TIMEOUT_MS }, () =
         format: 'epub',
       });
       expect(uploadedBookFile?.absolutePath).toContain('Uploaded Contract Title.epub');
-      expect(uploadedBookFile?.relPath).toBe('Uploaded Contract Title.epub');
+      // The default upload pattern files a book under its first author, and this fixture names none.
+      expect(uploadedBookFile?.relPath).toBe('Unknown Author/Uploaded Contract Title.epub');
 
       const uploadedMetadataRow = await ctx.db.query.bookMetadata.findFirst({
         where: eq(schema.bookMetadata.bookId, uploadBody.bookId),
@@ -880,8 +882,10 @@ describe('Library admin workflows (e2e)', { timeout: SCENARIO_TIMEOUT_MS }, () =
         },
       ]);
 
-      await writeFixtureFile(ctx.fixture.booksPath, `covers/${uploadedBookId}/cover_custom.jpg`, Buffer.from('cover', 'utf8'));
-      await writeFixtureFile(ctx.fixture.booksPath, `covers/${uploadedBookId}/thumbnail.jpg`, Buffer.from('thumb', 'utf8'));
+      await createSlotCoverArtifacts(ctx, uploadedBookId, {
+        coverContent: Buffer.from('cover', 'utf8'),
+        thumbnailContent: Buffer.from('thumb', 'utf8'),
+      });
 
       const reorderResponse = await ctx.app.inject({
         method: 'POST',
diff --git a/server/test/migration-booklore.e2e-spec.ts b/server/test/migration-booklore.e2e-spec.ts
index 2ef60a77e..aa8362390 100644
--- a/server/test/migration-booklore.e2e-spec.ts
+++ b/server/test/migration-booklore.e2e-spec.ts
@@ -758,12 +758,12 @@ describe('Migration Booklore API to DB (e2e)', { timeout: 240_000 }, () => {
 
     const isbnCoverDir = coverDirectoryForBook(ctx, scenario.books.isbn.bookId);
     const audioCoverDir = coverDirectoryForBook(ctx, scenario.books.audio.bookId);
-    await access(join(isbnCoverDir, 'cover_custom.jpg'));
-    await access(join(isbnCoverDir, 'thumbnail.jpg'));
-    await access(join(audioCoverDir, 'cover_custom.png'));
-    await access(join(audioCoverDir, 'thumbnail.jpg'));
+    await access(join(isbnCoverDir, 'ebook', 'cover_custom.jpg'));
+    await access(join(isbnCoverDir, 'ebook', 'thumbnail.jpg'));
+    await access(join(audioCoverDir, 'audio', 'cover_custom.png'));
+    await access(join(audioCoverDir, 'audio', 'thumbnail.jpg'));
 
-    const audioCoverBytes = await readFile(join(audioCoverDir, 'cover_custom.png'));
+    const audioCoverBytes = await readFile(join(audioCoverDir, 'audio', 'cover_custom.png'));
     expect(audioCoverBytes[0]).toBe(0x89);
     expect(audioCoverBytes[1]).toBe(0x50);
 
diff --git a/server/test/missing-resources.e2e-spec.ts b/server/test/missing-resources.e2e-spec.ts
new file mode 100644
index 000000000..0f1e2fc73
--- /dev/null
+++ b/server/test/missing-resources.e2e-spec.ts
@@ -0,0 +1,205 @@
+import { and, eq, inArray } from 'drizzle-orm';
+import { rm } from 'fs/promises';
+import { join } from 'path';
+
+import * as schema from '../src/db/schema';
+import {
+  authHeader,
+  closeMetadataWriteE2EContext,
+  createLibraryWithFolder,
+  createMetadataWriteE2EContext,
+  locateBookFileByRelPath,
+  triggerAndWaitForLibraryScan,
+  type MetadataWriteE2EContext,
+} from './e2e/metadata-write/metadata-write-harness';
+import { createEpubFixture, createPdfFixture, writeFixtureFile } from './e2e/metadata-write/metadata-write-fixture-builder';
+
+const SCENARIO_TIMEOUT_MS = 120_000;
+
+type Sweep = {
+  status: 'running' | 'completed' | 'failed';
+  brokenCovers: number;
+  orphanedCoverDirs: number;
+};
+
+async function waitForSweep(ctx: MetadataWriteE2EContext): Promise<Sweep> {
+  for (let attempt = 0; attempt < 100; attempt += 1) {
+    const response = await ctx.app.inject({
+      method: 'GET',
+      url: '/api/v1/maintenance/missing-resources/sweep',
+      headers: authHeader(ctx.adminToken),
+    });
+    expect(response.statusCode).toBe(200);
+    const sweep = response.json() as Sweep | null;
+    if (sweep?.status === 'completed') return sweep;
+    if (sweep?.status === 'failed') throw new Error('Missing Resources sweep failed');
+    await new Promise((resolve) => setTimeout(resolve, 25));
+  }
+  throw new Error('Missing Resources sweep did not complete');
+}
+
+describe('Missing Resources slot covers (e2e)', { timeout: SCENARIO_TIMEOUT_MS }, () => {
+  let ctx!: MetadataWriteE2EContext;
+
+  beforeAll(async () => {
+    ctx = await createMetadataWriteE2EContext();
+  }, 60_000);
+
+  afterAll(async () => {
+    await closeMetadataWriteE2EContext(ctx);
+  });
+
+  it('finds, measures, and cleans slot-aware cover resources', async () => {
+    const library = await createLibraryWithFolder(ctx, { name: 'Missing Resources slots' });
+    await createEpubFixture(library.folderPath, 'covers/valid.epub', { title: 'Valid slot cover' });
+    await createPdfFixture(library.folderPath, 'covers/broken.pdf', 'Broken slot cover');
+    await createEpubFixture(library.folderPath, 'covers/half.epub', { title: 'Half broken slot covers' });
+    await triggerAndWaitForLibraryScan(ctx, library.libraryId);
+
+    const valid = await locateBookFileByRelPath(ctx, library.libraryId, 'covers/valid.epub');
+    const broken = await locateBookFileByRelPath(ctx, library.libraryId, 'covers/broken.pdf');
+    const half = await locateBookFileByRelPath(ctx, library.libraryId, 'covers/half.epub');
+    const now = new Date();
+    await ctx.db.delete(schema.bookCovers).where(inArray(schema.bookCovers.bookId, [valid.bookId, broken.bookId, half.bookId]));
+    await ctx.db.insert(schema.bookCovers).values([
+      {
+        bookId: valid.bookId,
+        medium: 'ebook',
+        source: 'extracted',
+        origin: 'embedded',
+        updatedAt: now,
+      },
+      {
+        bookId: broken.bookId,
+        medium: 'ebook',
+        source: 'extracted',
+        origin: 'embedded',
+        updatedAt: now,
+      },
+      { bookId: half.bookId, medium: 'ebook', source: 'extracted', origin: 'embedded', updatedAt: now },
+      { bookId: half.bookId, medium: 'audio', source: 'custom', origin: 'upload', updatedAt: now },
+    ]);
+    await ctx.db
+      .update(schema.bookMetadata)
+      .set({ coverSource: 'extracted', coverUpdatedAt: now, updatedAt: now })
+      .where(eq(schema.bookMetadata.bookId, valid.bookId));
+    await ctx.db
+      .update(schema.bookMetadata)
+      .set({ coverSource: 'extracted', coverUpdatedAt: now, updatedAt: now })
+      .where(eq(schema.bookMetadata.bookId, broken.bookId));
+    await ctx.db
+      .update(schema.bookMetadata)
+      .set({ coverSource: 'custom', coverUpdatedAt: now, updatedAt: now })
+      .where(eq(schema.bookMetadata.bookId, half.bookId));
+
+    await writeFixtureFile(ctx.fixture.booksPath, `covers/${valid.bookId}/ebook/cover_extracted.jpg`, Buffer.from('valid-cover'));
+    await rm(join(ctx.fixture.booksPath, 'covers', String(broken.bookId)), { recursive: true, force: true });
+    await rm(join(ctx.fixture.booksPath, 'covers', String(half.bookId)), { recursive: true, force: true });
+    await writeFixtureFile(ctx.fixture.booksPath, `covers/${half.bookId}/ebook/cover_extracted.jpg`, Buffer.from('half-cover'));
+    const orphanBookId = 2_000_000_000;
+    const orphanCover = Buffer.from('orphan-cover');
+    const orphanThumbnail = Buffer.from('orphan-thumbnail');
+    await writeFixtureFile(ctx.fixture.booksPath, `covers/${orphanBookId}/audio/cover_custom.jpg`, orphanCover);
+    await writeFixtureFile(ctx.fixture.booksPath, `covers/${orphanBookId}/audio/thumbnail.jpg`, orphanThumbnail);
+
+    const detailResponse = await ctx.app.inject({
+      method: 'GET',
+      url: `/api/v1/books/${valid.bookId}`,
+      headers: authHeader(ctx.adminToken),
+    });
+    expect(detailResponse.statusCode).toBe(200);
+    expect(detailResponse.json()).toMatchObject({
+      coverMedia: ['ebook'],
+      covers: {
+        ebook: { source: 'extracted', updatedAt: now.toISOString(), width: null, height: null },
+        audio: null,
+      },
+      coverVersion: `ebook:${now.toISOString()}:-`,
+    });
+
+    const cardsResponse = await ctx.app.inject({
+      method: 'POST',
+      url: '/api/v1/books/query',
+      headers: authHeader(ctx.adminToken),
+      payload: { pagination: { page: 0, size: 50 } },
+    });
+    expect(cardsResponse.statusCode).toBe(201);
+    const cards = (cardsResponse.json() as { items: Array<{ id: number; coverVersion: string }> }).items;
+    expect(cards.find((card) => card.id === valid.bookId)?.coverVersion).toBe(`ebook:${now.toISOString()}:-`);
+
+    const start = await ctx.app.inject({
+      method: 'POST',
+      url: '/api/v1/maintenance/missing-resources/sweep',
+      headers: authHeader(ctx.adminToken),
+    });
+    expect(start.statusCode).toBe(201);
+    const sweep = await waitForSweep(ctx);
+    expect(sweep).toMatchObject({ brokenCovers: 2, orphanedCoverDirs: 1 });
+
+    const brokenResponse = await ctx.app.inject({
+      method: 'GET',
+      url: '/api/v1/maintenance/missing-resources/broken-covers',
+      headers: authHeader(ctx.adminToken),
+    });
+    expect(brokenResponse.statusCode).toBe(200);
+    const brokenPage = brokenResponse.json() as { total: number; items: Array<{ id: number }> };
+    expect(brokenPage.total).toBe(2);
+    expect(brokenPage.items).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ id: broken.bookId, coverSource: 'extracted', slots: [{ medium: 'ebook', source: 'extracted' }] }),
+        expect.objectContaining({ id: half.bookId, coverSource: 'custom', slots: [{ medium: 'audio', source: 'custom' }] }),
+      ]),
+    );
+
+    const orphanResponse = await ctx.app.inject({
+      method: 'GET',
+      url: '/api/v1/maintenance/missing-resources/orphaned-covers',
+      headers: authHeader(ctx.adminToken),
+    });
+    expect(orphanResponse.statusCode).toBe(200);
+    expect(orphanResponse.json()).toMatchObject({
+      total: 1,
+      items: [
+        {
+          bookId: orphanBookId,
+          fileCount: 2,
+          sizeBytes: orphanCover.length + orphanThumbnail.length,
+          media: ['audio'],
+        },
+      ],
+    });
+
+    const cleanup = await ctx.app.inject({
+      method: 'POST',
+      url: '/api/v1/maintenance/missing-resources/broken-covers/clean',
+      headers: authHeader(ctx.adminToken),
+      payload: { bookIds: [broken.bookId, half.bookId] },
+    });
+    expect(cleanup.statusCode).toBe(201);
+    expect(cleanup.json()).toMatchObject({ category: 'broken_covers', requested: 2, cleaned: 2, skipped: 0, remaining: 0 });
+
+    const [removedSlot] = await ctx.db
+      .select()
+      .from(schema.bookCovers)
+      .where(and(eq(schema.bookCovers.bookId, broken.bookId), eq(schema.bookCovers.medium, 'ebook')));
+    const [brokenMetadata] = await ctx.db
+      .select({ coverSource: schema.bookMetadata.coverSource, coverUpdatedAt: schema.bookMetadata.coverUpdatedAt })
+      .from(schema.bookMetadata)
+      .where(eq(schema.bookMetadata.bookId, broken.bookId));
+    const [validSlot] = await ctx.db.select().from(schema.bookCovers).where(eq(schema.bookCovers.bookId, valid.bookId));
+    expect(removedSlot).toBeUndefined();
+    expect(brokenMetadata).toMatchObject({ coverSource: null, coverUpdatedAt: expect.any(Date) });
+    expect(validSlot).toBeDefined();
+
+    const halfSlots = await ctx.db
+      .select({ medium: schema.bookCovers.medium })
+      .from(schema.bookCovers)
+      .where(eq(schema.bookCovers.bookId, half.bookId));
+    const [halfMetadata] = await ctx.db
+      .select({ coverSource: schema.bookMetadata.coverSource })
+      .from(schema.bookMetadata)
+      .where(eq(schema.bookMetadata.bookId, half.bookId));
+    expect(halfSlots).toEqual([{ medium: 'ebook' }]);
+    expect(halfMetadata).toEqual({ coverSource: 'extracted' });
+  });
+});
diff --git a/server/test/scanner-file-operations.e2e-spec.ts b/server/test/scanner-file-operations.e2e-spec.ts
index b733961a2..73539f2f5 100644
--- a/server/test/scanner-file-operations.e2e-spec.ts
+++ b/server/test/scanner-file-operations.e2e-spec.ts
@@ -7,6 +7,7 @@ import { and, count, eq, like } from 'drizzle-orm';
 import * as schema from '../src/db/schema';
 import { WATCHER_DEBOUNCE_MS } from '../src/modules/scanner/file-watcher.service';
 import type { FixtureEntry, FixtureTree } from './e2e/scanner/scanner-fixture-builder';
+import { jpeg, writeEpubWithCover, writeImage } from './e2e/scanner/cover-slot-fixtures';
 import { createFixtureTree, file } from './e2e/scanner/scanner-fixture-builder';
 import {
   assertNoIntegrityViolations,
@@ -623,7 +624,8 @@ const structuralScenarios: StructuralScenario[] = [
     requiresCaseRename: true,
   },
   {
-    id: 'watcher-non-content-file-creates-ignored',
+    // A folder image can fill an empty cover slot, so a new one rescans its book folder.
+    id: 'watcher-folder-image-create-rescans-book',
     trigger: 'watcher',
     libraries: [{ key: 'a', rootDir: 'lib-a', mode: 'book_per_folder' }],
     entries: [file('lib-a/Book/book.epub')],
@@ -631,15 +633,22 @@ const structuralScenarios: StructuralScenario[] = [
       { type: 'writeFile', path: 'lib-a/Book/cover.jpg' },
       { type: 'writeFile', path: 'lib-a/Book/metadata.opf' },
     ],
-    expected: { a: { statusByFolder: { Book: 'present' }, presentCount: 1, missingCount: 0 } },
+    expected: {
+      a: {
+        statusByFolder: { Book: 'present' },
+        fileOwners: { 'Book/book.epub': 'Book', 'Book/cover.jpg': 'Book', 'Book/metadata.opf': 'Book' },
+        presentCount: 1,
+        missingCount: 0,
+      },
+    },
   },
   {
-    id: 'watcher-non-content-file-delete-ignored',
+    id: 'watcher-folder-image-delete-keeps-book',
     trigger: 'watcher',
     libraries: [{ key: 'a', rootDir: 'lib-a', mode: 'book_per_folder' }],
     entries: [file('lib-a/Book/book.epub'), file('lib-a/Book/cover.jpg')],
     operations: [{ type: 'deleteFile', path: 'lib-a/Book/cover.jpg' }],
-    expected: { a: { statusByFolder: { Book: 'present' }, presentCount: 1, missingCount: 0 } },
+    expected: { a: { statusByFolder: { Book: 'present' }, absentFilePaths: ['Book/cover.jpg'], presentCount: 1, missingCount: 0 } },
   },
   {
     id: 'watcher-book-per-file-delete-then-restore',
@@ -1245,6 +1254,50 @@ async function runStatefulScenario(context: ScannerE2EContext, scenario: Statefu
 }
 
 const statefulScenarios: StatefulScenario[] = [
+  {
+    id: 'stateful-mixed-media-cover-slots',
+    trigger: 'manual',
+    fixturePrefix: 'scanner-file-ops-cover-slots-',
+    fixtureEntries: [file('lib-a/Book/01.mp3')],
+    run: async (context, fixture) => {
+      await writeEpubWithCover(join(fixture.rootPath, 'lib-a/Book/book.epub'), await jpeg(200, 300));
+      await writeImage(join(fixture.rootPath, 'lib-a/Book/folder.jpg'), 500, 500);
+      const rootA = await realpath(join(fixture.rootPath, 'lib-a'));
+      const library = await seedLibrary(context.db, {
+        rootPath: rootA,
+        mode: 'book_per_folder',
+        watch: false,
+        name: `scanner-file-ops-cover-slots-${randomUUID()}`,
+      });
+
+      await triggerAndWaitForLibraryScan(context, library.libraryId);
+
+      const book = await getBookByFolderPath(context.db, library.libraryId, join(rootA, 'Book'));
+      const slots = async () =>
+        Object.fromEntries(
+          (await context.db.select().from(schema.bookCovers).where(eq(schema.bookCovers.bookId, book.id))).map((slot) => [slot.medium, slot]),
+        );
+      // The EPUB's own art is the book cover; the mp3 has none, so the square folder image is the audiobook cover.
+      expect(await slots()).toMatchObject({
+        ebook: { origin: 'embedded', source: 'extracted', width: 200, height: 300, dormantSince: null },
+        audio: { origin: 'folder_image', source: 'extracted', width: 500, height: 500, dormantSince: null },
+      });
+      const coverDir = join(context.isolatedAppData!.path, 'covers', String(book.id));
+      await expect(stat(join(coverDir, 'ebook', 'thumbnail.jpg'))).resolves.toBeDefined();
+      await expect(stat(join(coverDir, 'audio', 'thumbnail.jpg'))).resolves.toBeDefined();
+
+      await applyOperation(fixture.rootPath, { type: 'deleteFile', path: 'lib-a/Book/01.mp3' });
+      await triggerAndWaitForLibraryScan(context, library.libraryId);
+      expect((await slots()).audio?.dormantSince).toBeInstanceOf(Date);
+      const [metadata] = await context.db.select().from(schema.bookMetadata).where(eq(schema.bookMetadata.bookId, book.id));
+      expect(metadata?.coverSource).toBe('extracted');
+
+      await applyOperation(fixture.rootPath, { type: 'writeFile', path: 'lib-a/Book/01.mp3' });
+      await triggerAndWaitForLibraryScan(context, library.libraryId);
+      expect((await slots()).audio).toMatchObject({ origin: 'folder_image', dormantSince: null });
+      await assertNoIntegrityViolations(context.db);
+    },
+  },
   {
     id: 'stateful-manual-delete-primary-preserves-data',
     trigger: 'manual',