diff --git a/client/src/features/book-requests/BookRequestsPage.vue b/client/src/features/book-requests/BookRequestsPage.vue
index f92ea99b6..8f15a2a79 100644
--- a/client/src/features/book-requests/BookRequestsPage.vue
+++ b/client/src/features/book-requests/BookRequestsPage.vue
@@ -12,6 +12,7 @@ import { usePermissions } from '@/features/auth/composables/usePermissions'
 import { useAuth } from '@/features/auth/composables/useAuth'
 import { formatCompactNumber, formatNumber } from '@/i18n/formatters'
 import { canBulkActRequest, canDismissRequest, cancelStopsATransfer } from './requestActions'
+import { flattenRequestRows, rowRequests } from './requestPair'
 import RequestDrawer from './components/RequestDrawer.vue'
 import NoRequestSourcesNotice from './components/NoRequestSourcesNotice.vue'
 import RequestEmptyState from './components/RequestEmptyState.vue'
@@ -92,8 +93,10 @@ const isCompact = computed(() => density.value === 'compact')
  * holding the row objects would keep a stale copy of whatever the tick just changed.
  */
 const selectedIds = ref<number[]>([])
-const selectedRows = computed(() => activeList.value.items.value.filter((request) => selectedIds.value.includes(request.id)))
-const selectableRows = computed(() => activeList.value.items.value.filter((request) => canBulkActRequest(request, canManage.value)))
+/** Every request on the page with pairs unfolded, since a selection and a batch act on requests, not rows. */
+const activeRequests = computed(() => flattenRequestRows(activeList.value.items.value))
+const selectedRows = computed(() => activeRequests.value.filter((request) => selectedIds.value.includes(request.id)))
+const selectableRows = computed(() => activeRequests.value.filter((request) => canBulkActRequest(request, canManage.value)))
 
 /**
  * A selection can mix states, so each bulk button owns its own subset and says how big it is.
@@ -116,7 +119,8 @@ provide(REQUEST_DRAWER, {
 
 const STATUS_FILTERS: Array<BookRequestStatus | ''> = ['', ...BOOK_REQUEST_STATUSES]
 
-const confirming = ref<{ request: BookRequestItem; action: 'cancel' | 'delete' } | null>(null)
+/** One request, or both halves of a pair cancelled from their row in one press. */
+const confirming = ref<{ requests: BookRequestItem[]; action: 'cancel' | 'delete' } | null>(null)
 /** Open while the approver is writing the one reason the whole selection is being turned down for. */
 const rejectingSelection = ref(false)
 const rejectNote = ref('')
@@ -128,14 +132,14 @@ const confirmTitle = computed(() =>
 const confirmDescription = computed(() => {
   if (!confirming.value) return ''
   if (confirming.value.action === 'delete') return t('bookRequests.confirm.deleteDescription')
-  return cancelStopsATransfer(confirming.value.request)
+  return confirming.value.requests.some(cancelStopsATransfer)
     ? t('bookRequests.confirm.cancelDescriptionWithDownload')
     : t('bookRequests.confirm.cancelDescription')
 })
 
 const confirmLabel = computed(() => (confirming.value?.action === 'delete' ? t('bookRequests.actions.delete') : t('bookRequests.actions.cancel')))
-/** The dialog acts on one row, so it is busy only while that row's own action is running. */
-const confirmBusy = computed(() => actions.isPending(confirming.value?.request.id))
+/** The dialog acts on one row, so it is busy only while that row's own actions are running. */
+const confirmBusy = computed(() => confirming.value?.requests.some((request) => actions.isPending(request.id)) ?? false)
 
 async function loadActive() {
   if (activeTab.value === 'mine') await mine.fetchRequests()
@@ -176,7 +180,7 @@ watch(() => activeList.value.items.value, onRowsChanged)
 /** A refetch both trims the selection and retires the live ticks the fetched rows have overtaken. */
 function onRowsChanged() {
   pruneSelection()
-  pruneSettledProgress(activeList.value.items.value)
+  pruneSettledProgress(activeRequests.value)
 }
 
 function selectSearchTab() {
@@ -196,10 +200,13 @@ function clearSelection() {
   selectedIds.value = []
 }
 
-function toggleSelect(request: BookRequestItem) {
-  const index = selectedIds.value.indexOf(request.id)
-  if (index === -1) selectedIds.value.push(request.id)
-  else selectedIds.value.splice(index, 1)
+/** A pair row's checkbox stands for every half of it a bulk action can reach. */
+function toggleSelect(row: BookRequestItem) {
+  const ids = rowRequests(row)
+    .filter((request) => canBulkActRequest(request, canManage.value))
+    .map((request) => request.id)
+  const allSelected = ids.every((id) => selectedIds.value.includes(id))
+  selectedIds.value = allSelected ? selectedIds.value.filter((id) => !ids.includes(id)) : [...new Set([...selectedIds.value, ...ids])]
 }
 
 /** Tick-all covers the rows that can actually be approved, not every row on the page. */
@@ -337,10 +344,67 @@ function handleReject(request: BookRequestItem) {
 
 /** Stopping a live transfer and deleting a row both ask first; the rest are one click. */
 function handleCancel(request: BookRequestItem) {
-  if (cancelStopsATransfer(request)) confirming.value = { request, action: 'cancel' }
+  if (cancelStopsATransfer(request)) confirming.value = { requests: [request], action: 'cancel' }
   else void cancelRequest(request)
 }
 
+/**
+ * The halves of a pair, acted on from their row. One half goes through the same path a single
+ * request does; two go through the batch endpoints, which report each half's own outcome.
+ */
+function handlePairApprove(requests: BookRequestItem[]) {
+  if (requests.length === 1) {
+    void approveRequest(requests[0]!)
+    return
+  }
+  void runBulk(
+    requests,
+    actions.approveMany,
+    { failed: 'bookRequests.errors.bulkApproveFailed', done: 'bookRequests.toasts.pairApproved', partial: 'bookRequests.toasts.bulkApprovedPartial' },
+    false,
+  )
+}
+
+function handlePairReject(requests: BookRequestItem[]) {
+  if (requests.length === 1) {
+    void rejectRequest(requests[0]!)
+    return
+  }
+  void runBulk(
+    requests,
+    (ids) => actions.rejectMany(ids),
+    { failed: 'bookRequests.errors.bulkRejectFailed', done: 'bookRequests.toasts.pairRejected', partial: 'bookRequests.toasts.bulkRejectedPartial' },
+    false,
+  )
+}
+
+function handlePairCancel(requests: BookRequestItem[]) {
+  if (requests.some(cancelStopsATransfer)) confirming.value = { requests, action: 'cancel' }
+  else void cancelRequests(requests)
+}
+
+function handlePairDismiss(requests: BookRequestItem[]) {
+  void runBulk(
+    requests,
+    actions.dismissMany,
+    {
+      failed: 'bookRequests.errors.bulkDismissFailed',
+      done: 'bookRequests.toasts.bulkDismissed',
+      partial: 'bookRequests.toasts.bulkDismissedPartial',
+    },
+    !activeList.value.includeDismissed.value,
+  )
+}
+
+function handlePairRestore(requests: BookRequestItem[]) {
+  for (const request of requests) void restoreRequest(request)
+}
+
+/** One at a time, each with its own outcome, so one half refusing does not hide the other succeeding. */
+async function cancelRequests(requests: BookRequestItem[]) {
+  for (const request of requests) await cancelRequest(request)
+}
+
 function handleDismiss(request: BookRequestItem) {
   void dismissRequest(request)
 }
@@ -350,15 +414,16 @@ function handleRestore(request: BookRequestItem) {
 }
 
 function handleRemove(request: BookRequestItem) {
-  confirming.value = { request, action: 'delete' }
+  confirming.value = { requests: [request], action: 'delete' }
 }
 
 /** Open until the action settles, so `busy` has something to render and a second Enter does nothing. */
 async function handleConfirm() {
   const pending = confirming.value
   if (!pending) return
-  if (pending.action === 'delete') await deleteRequest(pending.request)
-  else await cancelRequest(pending.request)
+  if (pending.action === 'delete') {
+    for (const request of pending.requests) await deleteRequest(request)
+  } else await cancelRequests(pending.requests)
   confirming.value = null
 }
 
@@ -736,6 +801,11 @@ function goToNextPage() {
           @restore="handleRestore"
           @remove="handleRemove"
           @grab="openReleases"
+          @pair-approve="handlePairApprove"
+          @pair-reject="handlePairReject"
+          @pair-cancel="handlePairCancel"
+          @pair-dismiss="handlePairDismiss"
+          @pair-restore="handlePairRestore"
           @sort="handleSort"
           @toggle-select="toggleSelect"
           @toggle-select-all="toggleSelectAll"
diff --git a/client/src/features/book-requests/__tests__/BookMissingFormatRequest.spec.ts b/client/src/features/book-requests/__tests__/BookMissingFormatRequest.spec.ts
new file mode 100644
index 000000000..aaef6666a
--- /dev/null
+++ b/client/src/features/book-requests/__tests__/BookMissingFormatRequest.spec.ts
@@ -0,0 +1,120 @@
+import { flushPromises, mount, RouterLinkStub } from '@vue/test-utils'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { computed } from 'vue'
+import type { BookDetail } from '@bookorbit/types'
+
+const state = vi.hoisted(() => ({
+  api: vi.fn<(path: string, init?: RequestInit) => Promise<Response>>(),
+  hasPermission: vi.fn<(permission: string) => boolean>(),
+  showBookRequests: true,
+  toastSuccess: vi.fn<(message: string) => void>(),
+  toastError: vi.fn<(message: string) => void>(),
+}))
+
+vi.mock('@/lib/api', () => ({ api: state.api }))
+vi.mock('vue-sonner', () => ({ toast: { success: state.toastSuccess, error: state.toastError } }))
+vi.mock('@/features/auth/composables/usePermissions', () => ({ usePermissions: () => ({ hasPermission: state.hasPermission }) }))
+vi.mock('../composables/useBookRequestVisibility', () => ({
+  useBookRequestVisibility: () => ({ showBookRequests: computed(() => state.showBookRequests) }),
+}))
+
+import BookMissingFormatRequest from '../components/BookMissingFormatRequest.vue'
+
+function book(formats: string[]): BookDetail {
+  return {
+    id: 42,
+    title: 'Dune',
+    authors: [{ id: 1, name: 'Frank Herbert', sortName: null }],
+    isbn10: null,
+    isbn13: '9780441013593',
+    seriesName: null,
+    publishedYear: 1965,
+    language: 'en',
+    files: formats.map((format, index) => ({ id: index + 1, format, role: 'content', filename: `dune.${format}` })),
+  } as unknown as BookDetail
+}
+
+function json(body: unknown, ok = true): Response {
+  return { ok, json: async () => body } as Response
+}
+
+const NOTHING = { ownedBookId: null, existingRequestId: null, existingRequestStatus: null, alreadySubscribed: false }
+
+async function render(formats: string[]) {
+  const wrapper = mount(BookMissingFormatRequest, { props: { book: book(formats) }, global: { stubs: { RouterLink: RouterLinkStub } } })
+  await flushPromises()
+  return wrapper
+}
+
+describe('BookMissingFormatRequest', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    state.showBookRequests = true
+    state.hasPermission.mockReturnValue(true)
+    state.api.mockResolvedValue(json([NOTHING]))
+  })
+
+  it('offers the audiobook an ebook is missing, and asks whether anybody has it already', async () => {
+    const wrapper = await render(['epub'])
+
+    expect(wrapper.text()).toContain('No audiobook yet')
+    const [path, init] = state.api.mock.calls[0]!
+    expect(path).toBe('/api/v1/book-requests/availability')
+    expect(JSON.parse(init!.body as string).items[0]).toMatchObject({ title: 'Dune', mediaKind: 'audiobook', isbn13: '9780441013593' })
+  })
+
+  it('offers the ebook an audiobook is missing', async () => {
+    const wrapper = await render(['m4b'])
+
+    expect(wrapper.text()).toContain('No e-book yet')
+    expect(wrapper.get('button').attributes('aria-label')).toBe('Request e-book')
+  })
+
+  it('asks for the format against this book, so it joins it rather than becoming another', async () => {
+    const wrapper = await render(['epub'])
+    state.api.mockResolvedValueOnce(json({ request: { id: 77, status: 'pending' }, subscribed: false }))
+
+    await wrapper.get('button').trigger('click')
+    await flushPromises()
+
+    const [path, init] = state.api.mock.calls[1]!
+    expect(path).toBe('/api/v1/book-requests')
+    expect(JSON.parse(init!.body as string)).toMatchObject({ mediaKind: 'audiobook', targetBookId: 42, title: 'Dune', language: 'en' })
+    expect(state.toastSuccess).toHaveBeenCalledWith('Requested. The audiobook will join this book when it arrives')
+    expect(wrapper.text()).toContain('Requested')
+    expect(wrapper.findComponent(RouterLinkStub).props('to')).toMatchObject({ name: 'book-request-detail', params: { id: 77 } })
+  })
+
+  it('says the translated reason when the server refuses', async () => {
+    const wrapper = await render(['epub'])
+    state.api.mockResolvedValueOnce(json({ errorCode: 'SUBMIT_TARGET_BOOK_HAS_MEDIUM', message: 'That book already has a audiobook' }, false))
+
+    await wrapper.get('button').trigger('click')
+    await flushPromises()
+
+    expect(state.toastError).toHaveBeenCalledWith('Could not submit that request', { description: 'That book already has this format' })
+  })
+
+  it('offers to join a request somebody else already made', async () => {
+    state.api.mockResolvedValue(json([{ ...NOTHING, existingRequestId: 9, existingRequestStatus: 'pending' }]))
+    const wrapper = await render(['epub'])
+
+    expect(wrapper.text()).toContain('Requested by someone else')
+    expect(wrapper.get('button').text()).toBe('Add me too')
+  })
+
+  it.each([
+    ['a book holding both formats', ['epub', 'm4b'], true, true],
+    ['a comic', ['cbz'], true, true],
+    ['somebody without request access', ['epub'], false, true],
+    ['somebody who hid requests', ['epub'], true, false],
+  ])('stays out of the way for %s', async (_label, formats, permitted, visible) => {
+    state.hasPermission.mockReturnValue(permitted)
+    state.showBookRequests = visible
+
+    const wrapper = await render(formats)
+
+    expect(wrapper.find('[role="group"]').exists()).toBe(false)
+    expect(state.api).not.toHaveBeenCalled()
+  })
+})
diff --git a/client/src/features/book-requests/__tests__/ReleasePickerPanel.spec.ts b/client/src/features/book-requests/__tests__/ReleasePickerPanel.spec.ts
index eb738ead0..08a21e844 100644
--- a/client/src/features/book-requests/__tests__/ReleasePickerPanel.spec.ts
+++ b/client/src/features/book-requests/__tests__/ReleasePickerPanel.spec.ts
@@ -1,4 +1,5 @@
 import { flushPromises, mount, RouterLinkStub } from '@vue/test-utils'
+import { nextTick } from 'vue'
 import type { DOMWrapper, VueWrapper } from '@vue/test-utils'
 import { beforeEach, describe, expect, it, vi } from 'vitest'
 import { Permission } from '@bookorbit/types'
@@ -13,12 +14,22 @@ const hasPermission = vi.fn<(permission: string) => boolean>()
 vi.mock('@/features/auth/composables/usePermissions', () => ({
   usePermissions: () => ({ hasPermission: (permission: string) => hasPermission(permission) }),
 }))
-vi.mock('vue-router', () => ({
-  useRoute: () => ({ params: { id: '7' }, query: {} }),
-  useRouter: () => ({ push: vi.fn<() => void>() }),
+// A route that can move, so a pair's tabs and the hop after a send can be followed. Pushing to a
+// release picker moves it the way the router would; every other destination is only recorded.
+const nav = vi.hoisted(() => ({
+  route: null as unknown as { params: { id: string }; query: Record<string, string> },
+  push: vi.fn<(to: { name: string; params?: { id: number } }) => void>(),
 }))
+vi.mock('vue-router', async () => {
+  const { reactive } = await import('vue')
+  nav.route = reactive({ params: { id: '7' }, query: {} })
+  return { useRoute: () => nav.route, useRouter: () => ({ push: nav.push }) }
+})
+// The real composable builds the router at module scope.
+vi.mock('@/features/auth/composables/useAuth', () => ({ useAuth: () => ({ user: { value: { id: 1 } } }) }))
 
 import ReleasePickerPanel from '../components/ReleasePickerPanel.vue'
+import { clearReleaseSearchCache } from '../composables/useReleasePicker'
 
 function request(overrides: Partial<BookRequestItem> = {}): BookRequestItem {
   return {
@@ -47,6 +58,8 @@ function request(overrides: Partial<BookRequestItem> = {}): BookRequestItem {
     subscribers: [],
     download: null,
     dismissed: false,
+    companionRequestId: null,
+    targetBookId: null,
     createdAt: '2026-08-01T00:00:00.000Z',
     updatedAt: '2026-08-01T00:00:00.000Z',
     title: 'Spark of the Everflame',
@@ -195,6 +208,13 @@ beforeEach(() => {
   api.mockReset()
   // A moderator by default, which is the path every existing case in this file was written against.
   hasPermission.mockReturnValue(true)
+  clearReleaseSearchCache()
+  nav.push.mockReset()
+  nav.push.mockImplementation((to) => {
+    if (to.name === 'book-request-releases' && to.params) nav.route.params.id = String(to.params.id)
+  })
+  nav.route.params.id = '7'
+  nav.route.query = {}
 })
 
 describe('ReleasePickerPanel', () => {
@@ -863,3 +883,116 @@ describe('ReleasePickerPanel', () => {
     })
   })
 })
+
+describe('ReleasePickerPanel for a pair', () => {
+  const ebookHalf = (overrides: Partial<BookRequestItem> = {}) => request({ id: 7, companionRequestId: 8, ...overrides })
+  const audioHalf = (overrides: Partial<BookRequestItem> = {}) => request({ id: 8, mediaKind: 'audiobook', companionRequestId: 7, ...overrides })
+  const AUDIO_SEARCH = {
+    ...MIXED,
+    releases: [release({ guid: 'audio-1', format: 'm4b', formats: ['m4b'] })],
+    criteria: { ...MIXED.criteria, mediaKind: 'audiobook' },
+    indexers: [status()],
+  }
+
+  async function renderPair(audio: BookRequestItem = audioHalf()) {
+    api.mockImplementation((input: string) => {
+      if (input.includes('/releases/inspect')) return respond(READY_INSPECTION)
+      if (input.includes('/7/releases')) return respond(MIXED)
+      if (input.includes('/8/releases')) return respond(AUDIO_SEARCH)
+      if (input.includes('/7/grab')) return respond(ebookHalf({ status: 'grabbed' }))
+      if (input.includes('download-clients')) return respond([])
+      if (input.endsWith('/book-requests/8')) return respond(audio)
+      return respond(ebookHalf())
+    })
+    const wrapper = mount(ReleasePickerPanel, { global: { stubs: { RouterLink: RouterLinkStub } } })
+    await flushPromises()
+    return wrapper
+  }
+
+  const tabs = (wrapper: VueWrapper) => wrapper.get('nav[aria-label="Formats to pick releases for"]')
+  const searchesFor = (id: number) => api.mock.calls.filter(([input]) => input.endsWith(`/${id}/releases`)).length
+
+  async function sendFirstRelease(wrapper: VueWrapper) {
+    const send = releaseRows(wrapper)[0]!
+      .findAll('button')
+      .find((button) => /Download release|Send/.test(button.text()))!
+    await send.trigger('click')
+    await flushPromises()
+  }
+
+  it('tabs between the halves, each with its release count and what it still needs', async () => {
+    const wrapper = await renderPair()
+
+    expect(wrapper.text()).toContain('Pick releases')
+    const [ebook, audiobook] = tabs(wrapper).findAll('a')
+    expect(ebook!.text()).toContain('E-book')
+    expect(ebook!.text()).toContain('2 releases')
+    expect(ebook!.text()).toContain('To choose')
+    expect(audiobook!.text()).toContain('Audiobook')
+    expect(audiobook!.text()).toContain('1 release')
+    expect(audiobook!.text()).toContain('To choose')
+  })
+
+  it('searches the other half once, as the picker opens, and switches to it without a loading state', async () => {
+    const wrapper = await renderPair()
+    expect(searchesFor(8)).toBe(1)
+
+    nav.route.params.id = '8'
+    await nextTick()
+
+    expect(releaseRows(wrapper)).toHaveLength(1)
+    expect(wrapper.text()).not.toContain('Searching')
+    await flushPromises()
+    expect(searchesFor(8)).toBe(1)
+    expect(searchesFor(7)).toBe(1)
+  })
+
+  it('moves to the other half once a release is sent for this one', async () => {
+    const wrapper = await renderPair()
+
+    await sendFirstRelease(wrapper)
+
+    expect(nav.push).toHaveBeenCalledWith({ name: 'book-request-releases', params: { id: 8 }, query: {} })
+  })
+
+  it('ends on a closing state once neither half needs a release', async () => {
+    const wrapper = await renderPair(audioHalf({ status: 'downloading' }))
+
+    await sendFirstRelease(wrapper)
+
+    expect(wrapper.text()).toContain('Both releases are on their way')
+    expect(releaseRows(wrapper)).toHaveLength(0)
+    expect(tabs(wrapper).text().match(/Sent/g)).toHaveLength(2)
+    await wrapper
+      .findAll('button')
+      .find((button) => button.text() === 'Done')!
+      .trigger('click')
+    expect(nav.push).toHaveBeenLastCalledWith({ name: 'book-requests', query: {} })
+  })
+
+  it('returns to the request when the other half is not waiting on a release', async () => {
+    const wrapper = await renderPair(audioHalf({ status: 'pending' }))
+
+    await sendFirstRelease(wrapper)
+
+    expect(nav.push).toHaveBeenCalledWith({ name: 'book-request-detail', params: { id: 7 }, query: {} })
+    expect(wrapper.text()).not.toContain('Both releases are on their way')
+  })
+
+  it('shows a half nobody can pick a release for yet as a label, not a link, and never searches it', async () => {
+    const wrapper = await renderPair(audioHalf({ status: 'pending' }))
+
+    const audiobook = tabs(wrapper).get('span[aria-disabled="true"]')
+    expect(audiobook.text()).toContain('Pending')
+    expect(searchesFor(8)).toBe(0)
+  })
+
+  it('leaves the ISBN one half was opened with out of the link to the other', async () => {
+    nav.route.query = { tab: 'mine', isbn: '9781234567897' }
+    const wrapper = await renderPair()
+
+    const links = wrapper.findAllComponents(RouterLinkStub)
+    const toAudiobook = links.find((link) => (link.props('to') as { params?: { id: number } }).params?.id === 8)!
+    expect(toAudiobook.props('to')).toEqual({ name: 'book-request-releases', params: { id: 8 }, query: { tab: 'mine' } })
+  })
+})
diff --git a/client/src/features/book-requests/__tests__/RequestListTable.spec.ts b/client/src/features/book-requests/__tests__/RequestListTable.spec.ts
index 4ffc95e6b..373acaceb 100644
--- a/client/src/features/book-requests/__tests__/RequestListTable.spec.ts
+++ b/client/src/features/book-requests/__tests__/RequestListTable.spec.ts
@@ -46,6 +46,8 @@ function request(overrides: Partial<BookRequestItem> = {}): BookRequestItem {
     subscribers: [],
     download: null,
     dismissed: false,
+    companionRequestId: null,
+    targetBookId: null,
     createdAt: '2026-09-29T12:00:00.000Z',
     updatedAt: '2026-09-29T12:00:00.000Z',
     ...overrides,
@@ -105,3 +107,64 @@ describe('RequestListTable', () => {
     expect(titleButton?.text()).toBe(LONG_TITLE)
   })
 })
+
+describe('RequestListTable pairs', () => {
+  const ebook = request({ id: 10, mediaKind: 'ebook', status: 'pending', title: 'Dune', companionRequestId: 11, matchedBookId: null })
+  const audiobook = request({ id: 11, mediaKind: 'audiobook', status: 'downloading', title: 'Dune', companionRequestId: 10, matchedBookId: null })
+
+  function renderPair(selectedIds: number[] = []) {
+    return mount(RequestListTable, {
+      props: {
+        requests: [{ ...ebook, companion: audiobook }],
+        canManage: true,
+        canSelfFulfil: false,
+        currentUserId: 1,
+        busyIds: new Set<number>(),
+        progressByRequest: {},
+        density: 'comfortable',
+        sortBy: 'createdAt',
+        sortDir: 'desc',
+        selectedIds,
+      },
+      global: {
+        stubs: {
+          RouterLink: RouterLinkStub,
+          RequestCover: true,
+          RequestPipeline: true,
+          RequestStatusBadge: { props: ['status'], template: '<span class="status-badge">{{ status }}</span>' },
+          RequestPairRowActions: {
+            props: ['row'],
+            emits: ['approve'],
+            template: '<button class="pair-approve" @click="$emit(\'approve\', [row, row.companion])">approve</button>',
+          },
+        },
+      },
+    })
+  }
+
+  it('renders the pair as one row with a lane per half, the ebook first', () => {
+    const wrapper = renderPair()
+
+    expect(wrapper.findAll('tbody tr')).toHaveLength(1)
+    const lanes = wrapper
+      .get('table')
+      .findAll('.status-badge')
+      .map((badge) => badge.text())
+    expect(lanes).toEqual(['pending', 'downloading'])
+    expect(wrapper.find('table').text()).toContain('E-book and audiobook')
+  })
+
+  it('hands a row press on to the page with exactly the halves it applies to', async () => {
+    const wrapper = renderPair()
+
+    await wrapper.get('table .pair-approve').trigger('click')
+
+    expect(wrapper.emitted('pair-approve')?.[0]?.[0]).toEqual([expect.objectContaining({ id: 10 }), expect.objectContaining({ id: 11 })])
+  })
+
+  it('ticks the row only when every half a bulk action can reach is selected', () => {
+    // Only the pending ebook can be acted on in bulk; the downloading audiobook cannot.
+    expect((renderPair([10]).get('table tbody input[type="checkbox"]').element as HTMLInputElement).checked).toBe(true)
+    expect((renderPair([]).get('table tbody input[type="checkbox"]').element as HTMLInputElement).checked).toBe(false)
+  })
+})
diff --git a/client/src/features/book-requests/__tests__/RequestPairRowActions.spec.ts b/client/src/features/book-requests/__tests__/RequestPairRowActions.spec.ts
new file mode 100644
index 000000000..ba35049fa
--- /dev/null
+++ b/client/src/features/book-requests/__tests__/RequestPairRowActions.spec.ts
@@ -0,0 +1,53 @@
+import { mount } from '@vue/test-utils'
+import { describe, expect, it } from 'vitest'
+import type { BookRequestItem } from '@bookorbit/types'
+import RequestPairRowActions from '../components/RequestPairRowActions.vue'
+
+function request(overrides: Partial<BookRequestItem>): BookRequestItem {
+  return {
+    id: 10,
+    userId: 4,
+    mediaKind: 'ebook',
+    status: 'approved',
+    dismissed: false,
+    download: null,
+    fulfillerUserId: null,
+    title: 'Dune',
+    ...overrides,
+  } as BookRequestItem
+}
+
+function primaryButton(row: BookRequestItem) {
+  const wrapper = mount(RequestPairRowActions, { props: { row, canManage: true, canSelfFulfil: false, currentUserId: 4, busy: false } })
+  return wrapper.findAll('button')[0]!
+}
+
+describe('RequestPairRowActions', () => {
+  it('offers to choose releases while both halves are waiting on one', () => {
+    const button = primaryButton({ ...request({}), companion: request({ id: 11, mediaKind: 'audiobook' }) })
+
+    expect(button.text()).toBe('Choose releases')
+  })
+
+  it('names the one half still waiting once the other is on its way', () => {
+    const button = primaryButton({ ...request({ status: 'downloading' }), companion: request({ id: 11, mediaKind: 'audiobook' }) })
+
+    expect(button.text()).toBe('Find an audiobook release')
+  })
+
+  it('opens the picker on the half that leads the row', async () => {
+    const wrapper = mount(RequestPairRowActions, {
+      props: {
+        row: { ...request({}), companion: request({ id: 11, mediaKind: 'audiobook' }) },
+        canManage: true,
+        canSelfFulfil: false,
+        currentUserId: 4,
+        busy: false,
+      },
+    })
+
+    await wrapper.findAll('button')[0]!.trigger('click')
+
+    expect(wrapper.emitted('grab')?.[0]?.[0]).toEqual(expect.objectContaining({ id: 10 }))
+  })
+})
diff --git a/client/src/features/book-requests/__tests__/RequestSearchPanel.spec.ts b/client/src/features/book-requests/__tests__/RequestSearchPanel.spec.ts
index e0dd2e9ab..59ea3bdcd 100644
--- a/client/src/features/book-requests/__tests__/RequestSearchPanel.spec.ts
+++ b/client/src/features/book-requests/__tests__/RequestSearchPanel.spec.ts
@@ -16,7 +16,10 @@ const state = vi.hoisted(
       hasPermission: vi.fn<(permission: string) => boolean>(),
       defaultFor: vi.fn<(mediaKind: BookRequestMediaKind) => ResolvedRequestDestination>(),
       submit: vi.fn<() => Promise<unknown>>(),
+      submitPair: vi.fn<() => Promise<unknown>>(),
       submitFreeText: vi.fn<() => Promise<unknown>>(),
+      submitPairFreeText: vi.fn<() => Promise<unknown>>(),
+      search: vi.fn<() => void>(),
       checkFreeText: vi.fn<() => Promise<unknown>>(),
       push: vi.fn<() => Promise<void>>(),
       routeQuery: {} as Record<string, string>,
@@ -25,12 +28,16 @@ const state = vi.hoisted(
       hasPermission: ReturnType<typeof vi.fn>
       defaultFor: ReturnType<typeof vi.fn>
       mediaKind: Ref<BookRequestMediaKind>
-      libraries: Ref<{ id: number; name: string; folders: { id: number; path: string }[] }[]>
+      pairMode: Ref<boolean>
+      libraries: Ref<{ id: number; name: string; folders: { id: number; path: string }[]; organizationMode?: string }[]>
       hasSearched: Ref<boolean>
       providers: Ref<MetadataProviderInfo[]>
       groups: Ref<CandidateGroup[]>
       submit: ReturnType<typeof vi.fn>
+      submitPair: ReturnType<typeof vi.fn>
       submitFreeText: ReturnType<typeof vi.fn>
+      submitPairFreeText: ReturnType<typeof vi.fn>
+      search: ReturnType<typeof vi.fn>
       checkFreeText: ReturnType<typeof vi.fn>
       push: ReturnType<typeof vi.fn>
       routeQuery: Record<string, string>
@@ -81,7 +88,7 @@ vi.mock('@/features/book/composables/useMetadataSearch', async () => {
       hasSearched: state.hasSearched,
       providers: state.providers,
       loadProviders: vi.fn<() => Promise<void>>().mockResolvedValue(undefined),
-      search: vi.fn<() => void>(),
+      search: state.search,
     }),
   }
 })
@@ -90,6 +97,7 @@ vi.mock('../composables/useRequestSubmission', async (importOriginal) => {
   const actual = await importOriginal<typeof import('../composables/useRequestSubmission')>()
   const { ref } = await import('vue')
   state.mediaKind = ref<BookRequestMediaKind>('ebook')
+  state.pairMode = ref(false)
   state.lastFailure = ref(null)
   return {
     ...actual,
@@ -97,10 +105,13 @@ vi.mock('../composables/useRequestSubmission', async (importOriginal) => {
       lastFailure: state.lastFailure,
       submitting: ref(null),
       mediaKind: state.mediaKind,
+      pairMode: state.pairMode,
       annotate: vi.fn<() => void>(),
       getAvailability: vi.fn<() => null>().mockReturnValue(null),
       submit: state.submit,
+      submitPair: state.submitPair,
       submitFreeText: state.submitFreeText,
+      submitPairFreeText: state.submitPairFreeText,
       checkFreeText: state.checkFreeText,
       candidateKey: vi.fn<() => string>().mockReturnValue('k'),
     }),
@@ -245,6 +256,8 @@ describe('RequestSearchPanel provider sources', () => {
         publishedYear: 2022,
         providers: [MetadataProviderKey.GOOGLE, MetadataProviderKey.AMAZON, MetadataProviderKey.COMICVINE],
         availability: null,
+        pairAvailability: null,
+        audioCoverUrls: [],
       },
     ]
   })
@@ -811,3 +824,142 @@ describe('RequestSearchPanel free-text fallback', () => {
     expect(state.coverOrder?.value).toEqual(['audible', 'itunes'])
   })
 })
+
+describe('RequestSearchPanel pair mode', () => {
+  const dune: MetadataCandidate = {
+    provider: MetadataProviderKey.GOOGLE,
+    providerId: 'google-dune',
+    title: 'Dune',
+    authors: ['Frank Herbert'],
+    coverUrl: 'https://covers.test/portrait.jpg',
+  }
+  const OWNED = { ownedBookId: 42, existingRequestId: null, existingRequestStatus: null, alreadySubscribed: false }
+
+  function group(pairAvailability: CandidateGroup['pairAvailability']): CandidateGroup {
+    return {
+      key: 'dune',
+      candidate: dune,
+      candidates: [dune],
+      isbns: [],
+      isbnChoices: [],
+      recommendedIsbnChoice: null,
+      title: 'Dune',
+      authors: ['Frank Herbert'],
+      coverUrl: 'https://covers.test/portrait.jpg',
+      coverUrls: ['https://covers.test/portrait.jpg'],
+      publishedYear: 1965,
+      providers: [MetadataProviderKey.GOOGLE],
+      availability: null,
+      pairAvailability,
+      audioCoverUrls: ['https://covers.test/square.jpg'],
+    }
+  }
+
+  function button(wrapper: Awaited<ReturnType<typeof render>>, text: string) {
+    return wrapper.findAll('button').find((candidate) => candidate.text() === text)
+  }
+
+  beforeEach(() => {
+    vi.clearAllMocks()
+    state.mediaKind.value = 'ebook'
+    state.pairMode.value = false
+    state.hasSearched.value = false
+    state.hasPermission.mockReturnValue(false)
+    state.defaultFor.mockReturnValue(NO_DEFAULT)
+    state.providers.value = [{ key: MetadataProviderKey.GOOGLE, label: 'Google Books', identifiable: true }]
+    state.libraries.value = [
+      { id: 1, name: 'Books', folders: [{ id: 11, path: '/books' }], organizationMode: 'book_per_folder' },
+      { id: 2, name: 'Audiobooks', folders: [{ id: 21, path: '/audiobooks' }], organizationMode: 'book_per_folder' },
+    ]
+  })
+
+  it('offers Both beside the two media it combines, and searches both media at once', async () => {
+    state.hasSearched.value = true
+    const wrapper = await render()
+    await wrapper.get('#request-title').setValue('Dune')
+
+    const choices = wrapper
+      .findAll('fieldset')[0]!
+      .findAll('button')
+      .map((choice) => choice.text())
+    // Comics are never offered here; the server only keeps accepting them for released iOS builds.
+    expect(choices).toEqual(['E-book', 'Audiobook', 'Both'])
+
+    await button(wrapper, 'Both')!.trigger('click')
+
+    expect(state.pairMode.value).toBe(true)
+    expect(state.mediaKind.value).toBe('ebook')
+    expect(button(wrapper, 'Both')!.attributes('aria-pressed')).toBe('true')
+    expect(state.search).toHaveBeenLastCalledWith(expect.objectContaining({ mediaKinds: ['ebook', 'audiobook'] }))
+    expect(state.search).toHaveBeenLastCalledWith(expect.not.objectContaining({ mediaKind: expect.anything() }))
+  })
+
+  it('shows where each half stands and submits both, each to its own library', async () => {
+    state.pairMode.value = true
+    state.groups.value = [group({ ebook: null, audiobook: null })]
+    state.submitPair.mockResolvedValue(null)
+    const wrapper = await render()
+
+    await wrapper.get('#request-library').setValue('1')
+    await wrapper.get('#request-audio-library').setValue('2')
+    expect(wrapper.text().match(/Not requested/g)).toHaveLength(2)
+
+    await button(wrapper, 'Request both')!.trigger('click')
+
+    expect(state.submitPair).toHaveBeenCalledWith(
+      dune,
+      expect.objectContaining({
+        ebook: expect.objectContaining({ targetLibraryId: 1, coverUrl: 'https://covers.test/portrait.jpg' }),
+        audiobook: expect.objectContaining({ targetLibraryId: 2, coverUrl: 'https://covers.test/square.jpg' }),
+      }),
+    )
+    expect(state.submit).not.toHaveBeenCalled()
+  })
+
+  it('asks only for the missing format, aimed at the copy already on the shelf', async () => {
+    state.pairMode.value = true
+    state.groups.value = [group({ ebook: OWNED, audiobook: null })]
+    state.submit.mockResolvedValue(null)
+    const wrapper = await render()
+
+    expect(wrapper.text()).toContain('In your library')
+    await button(wrapper, 'Request audiobook')!.trigger('click')
+
+    expect(state.submit).toHaveBeenCalledWith(dune, expect.objectContaining({ mediaKind: 'audiobook', targetBookId: 42 }))
+    expect(state.submitPair).not.toHaveBeenCalled()
+  })
+
+  it('says before submitting whether the pair will arrive as one book or two', async () => {
+    state.pairMode.value = true
+    state.groups.value = [group({ ebook: null, audiobook: null })]
+    const wrapper = await render()
+
+    await wrapper.get('#request-library').setValue('1')
+    await wrapper.get('#request-audio-library').setValue('1')
+    expect(wrapper.text()).toContain('Both formats arrive as one book in Books.')
+
+    await wrapper.get('#request-audio-library').setValue('2')
+    expect(wrapper.text()).toContain('they arrive as two books')
+  })
+
+  it('offers nothing to press once both formats are already in the library', async () => {
+    state.pairMode.value = true
+    state.groups.value = [group({ ebook: OWNED, audiobook: { ...OWNED, ownedBookId: 43 } })]
+    const wrapper = await render()
+
+    const owned = wrapper.findAll('button').find((candidate) => candidate.text() === 'In your library')
+    expect(owned?.attributes('disabled')).toBeDefined()
+  })
+
+  it('offers a format preference row for each half', async () => {
+    state.pairMode.value = true
+    const wrapper = await render()
+
+    await button(wrapper, 'More options')!.trigger('click')
+
+    expect(wrapper.text()).toContain('Preferred e-book formats')
+    expect(wrapper.text()).toContain('Preferred audiobook formats')
+    expect(wrapper.find('button[aria-label="Prefer M4B"]').exists()).toBe(true)
+    expect(wrapper.find('button[aria-label="Prefer EPUB"]').exists()).toBe(true)
+  })
+})
diff --git a/client/src/features/book-requests/__tests__/requestPair.spec.ts b/client/src/features/book-requests/__tests__/requestPair.spec.ts
new file mode 100644
index 000000000..aa795bd81
--- /dev/null
+++ b/client/src/features/book-requests/__tests__/requestPair.spec.ts
@@ -0,0 +1,149 @@
+// @vitest-environment node
+import { describe, expect, it } from 'vitest'
+import type { BookRequestAvailability, BookRequestItem } from '@bookorbit/types'
+import {
+  flattenRequestRows,
+  orderedHalves,
+  pairActionKey,
+  pairHalfState,
+  pairRowActions,
+  pairSubmission,
+  pairSubmissionLabelKey,
+  type PairAvailability,
+} from '../requestPair'
+
+const OWNED: BookRequestAvailability = { ownedBookId: 42, existingRequestId: null, existingRequestStatus: null, alreadySubscribed: false }
+const FOLLOWING: BookRequestAvailability = { ownedBookId: null, existingRequestId: 7, existingRequestStatus: 'pending', alreadySubscribed: true }
+const JOINABLE: BookRequestAvailability = { ownedBookId: null, existingRequestId: 8, existingRequestStatus: 'pending', alreadySubscribed: false }
+
+function pair(ebook: BookRequestAvailability | null, audiobook: BookRequestAvailability | null): PairAvailability {
+  return { ebook, audiobook }
+}
+
+function request(overrides: Partial<BookRequestItem> = {}): BookRequestItem {
+  return {
+    id: 1,
+    userId: 4,
+    mediaKind: 'ebook',
+    status: 'pending',
+    dismissed: false,
+    download: null,
+    fulfillerUserId: null,
+    ...overrides,
+  } as BookRequestItem
+}
+
+describe('pairHalfState', () => {
+  it('reads ownership ahead of any request, and tells a request you follow from one you could join', () => {
+    expect(pairHalfState(null)).toBe('new')
+    expect(pairHalfState(OWNED)).toBe('owned')
+    expect(pairHalfState({ ...OWNED, existingRequestId: 3, alreadySubscribed: true })).toBe('owned')
+    expect(pairHalfState(FOLLOWING)).toBe('following')
+    expect(pairHalfState(JOINABLE)).toBe('joinable')
+  })
+})
+
+describe('pairSubmission', () => {
+  it('sends both halves as a pair when neither has been asked for', () => {
+    expect(pairSubmission(pair(null, null))).toEqual({ kind: 'pair', actionable: ['ebook', 'audiobook'] })
+  })
+
+  /** The new format should become another format of the book already on the shelf, not a second book. */
+  it('sends only the missing half, aimed at the copy on the shelf, when the other is owned', () => {
+    expect(pairSubmission(pair(OWNED, null))).toEqual({ kind: 'single', mediaKind: 'audiobook', joinBookId: 42, state: 'new' })
+    expect(pairSubmission(pair(JOINABLE, OWNED))).toEqual({ kind: 'single', mediaKind: 'ebook', joinBookId: 42, state: 'joinable' })
+  })
+
+  /** The pair route joins the request already followed and links it to the new half. */
+  it('still sends a pair when the other half is a request this person already follows', () => {
+    expect(pairSubmission(pair(FOLLOWING, null))).toEqual({ kind: 'pair', actionable: ['audiobook'] })
+  })
+
+  it('sends nothing once there is nothing left to ask for, and says why', () => {
+    expect(pairSubmission(pair(OWNED, OWNED))).toEqual({ kind: 'none', reason: 'owned' })
+    expect(pairSubmission(pair(OWNED, FOLLOWING))).toEqual({ kind: 'none', reason: 'requested' })
+  })
+})
+
+describe('pairSubmissionLabelKey', () => {
+  it('names both, or the one medium a press will actually touch', () => {
+    const both = pair(null, null)
+    expect(pairSubmissionLabelKey(pairSubmission(both), both, 'request')).toBe('bookRequests.search.pair.requestBoth')
+    expect(pairSubmissionLabelKey(pairSubmission(both), both, 'get')).toBe('bookRequests.search.pair.getBoth')
+    expect(pairSubmissionLabelKey(pairSubmission(both), both, 'choose')).toBe('bookRequests.search.pair.chooseReleases')
+
+    const audioOnly = pair(OWNED, null)
+    expect(pairSubmissionLabelKey(pairSubmission(audioOnly), audioOnly, 'request')).toBe('bookRequests.search.pair.requestAudiobook')
+    expect(pairSubmissionLabelKey(pairSubmission(audioOnly), audioOnly, 'get')).toBe('bookRequests.search.pair.getAudiobook')
+  })
+
+  it('says "add me" when every half it touches is somebody else\'s request', () => {
+    const joinBoth = pair(JOINABLE, JOINABLE)
+    expect(pairSubmissionLabelKey(pairSubmission(joinBoth), joinBoth, 'request')).toBe('bookRequests.search.pair.joinBoth')
+
+    const joinEbook = pair(JOINABLE, OWNED)
+    expect(pairSubmissionLabelKey(pairSubmission(joinEbook), joinEbook, 'get')).toBe('bookRequests.search.pair.joinEbook')
+  })
+
+  it('labels a pair with nothing left to ask for by what is already true', () => {
+    const owned = pair(OWNED, OWNED)
+    expect(pairSubmissionLabelKey(pairSubmission(owned), owned, 'request')).toBe('bookRequests.search.pair.haveBoth')
+    const requested = pair(FOLLOWING, FOLLOWING)
+    expect(pairSubmissionLabelKey(pairSubmission(requested), requested, 'request')).toBe('bookRequests.search.pair.requestedBoth')
+  })
+})
+
+describe('pair rows', () => {
+  const ebook = request({ id: 10, mediaKind: 'ebook' })
+  const audiobook = request({ id: 11, mediaKind: 'audiobook' })
+
+  it('unfolds pairs into their requests for selection and bulk actions', () => {
+    const rows = [{ ...ebook, companion: audiobook }, request({ id: 12 })]
+    expect(flattenRequestRows(rows).map((item) => item.id)).toEqual([10, 11, 12])
+  })
+
+  it('reads the ebook first whichever half leads the row', () => {
+    expect(orderedHalves({ ...audiobook, companion: ebook }).map((item) => item.mediaKind)).toEqual(['ebook', 'audiobook'])
+  })
+
+  it('offers each action only for the halves it applies to', () => {
+    const row = { ...ebook, companion: { ...audiobook, status: 'available' as const } }
+    const actions = pairRowActions(row, { userId: 4, canManage: true, canSelfFulfil: false })
+
+    expect(actions.approve.map((item) => item.id)).toEqual([10])
+    expect(actions.dismiss.map((item) => item.id)).toEqual([11])
+    expect(actions.cancel.map((item) => item.id)).toEqual([10])
+    expect(actions.grab).toBeNull()
+  })
+
+  it('lists every half waiting on a release the viewer can pick, so the row can say "releases"', () => {
+    const row = { ...ebook, status: 'approved' as const, companion: { ...audiobook, status: 'approved' as const } }
+    const both = pairRowActions(row, { userId: 4, canManage: true, canSelfFulfil: false })
+    expect(both.grabHalves.map((item) => item.id)).toEqual([10, 11])
+    expect(both.grab?.id).toBe(10)
+
+    const oneLeft = pairRowActions(
+      { ...row, companion: { ...audiobook, status: 'downloading' as const } },
+      { userId: 4, canManage: true, canSelfFulfil: false },
+    )
+    expect(oneLeft.grabHalves.map((item) => item.id)).toEqual([10])
+  })
+
+  it('only counts the halves a self-fulfiller drives', () => {
+    const row = { ...ebook, status: 'approved' as const, companion: { ...audiobook, status: 'approved' as const, userId: 9 } }
+    const actions = pairRowActions(row, { userId: 4, canManage: false, canSelfFulfil: true })
+    expect(actions.grabHalves.map((item) => item.id)).toEqual([10])
+  })
+
+  it('offers no approval to somebody who does not moderate the queue', () => {
+    const actions = pairRowActions({ ...ebook, companion: audiobook }, { userId: 4, canManage: false, canSelfFulfil: false })
+    expect(actions.approve).toEqual([])
+    expect(actions.cancel.map((item) => item.id)).toEqual([10, 11])
+  })
+
+  it('names both halves, or the one, in every action label', () => {
+    expect(pairActionKey('approve', [ebook, audiobook])).toBe('bookRequests.actions.pair.approveBoth')
+    expect(pairActionKey('cancel', [audiobook])).toBe('bookRequests.actions.pair.cancelAudiobook')
+    expect(pairActionKey('dismiss', [ebook])).toBe('bookRequests.actions.pair.dismissEbook')
+  })
+})
diff --git a/client/src/features/book-requests/__tests__/useBookRequests.spec.ts b/client/src/features/book-requests/__tests__/useBookRequests.spec.ts
index 3272298bf..8a720cfb5 100644
--- a/client/src/features/book-requests/__tests__/useBookRequests.spec.ts
+++ b/client/src/features/book-requests/__tests__/useBookRequests.spec.ts
@@ -230,3 +230,53 @@ describe('useBookRequestActions with more than one row in flight', () => {
     await expect(actions.remove(1)).resolves.toEqual({ ok: false, reason: 'remove the download from its client first' })
   })
 })
+
+describe('useBookRequests pairs', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+  })
+
+  const ebook = { id: 10, mediaKind: 'ebook', status: 'pending', companionRequestId: 11 }
+  const audiobook = { id: 11, mediaKind: 'audiobook', status: 'pending', companionRequestId: 10 }
+
+  it('asks for a pair as one row', async () => {
+    apiMock.mockResolvedValue(response({ items: [], total: 0 }))
+    const requests = await freshRequests('mine')
+
+    await requests.fetchRequests()
+
+    const params = new URLSearchParams(String(apiMock.mock.calls[0]?.[0]).split('?')[1])
+    expect(params.get('groupPairs')).toBe('true')
+  })
+
+  it('updates the half a decision was about, whichever half leads the row', async () => {
+    apiMock.mockResolvedValue(response({ items: [{ ...ebook, companion: audiobook }], total: 1 }))
+    const requests = await freshRequests('mine')
+    await requests.fetchRequests()
+
+    requests.replaceItem({ ...audiobook, status: 'approved' } as never)
+    expect(requests.items.value[0]!.companion?.status).toBe('approved')
+
+    // A single request comes back flat, so the lead keeps the companion it already had.
+    requests.replaceItem({ ...ebook, status: 'approved' } as never)
+    expect(requests.items.value[0]!.status).toBe('approved')
+    expect(requests.items.value[0]!.companion?.id).toBe(11)
+  })
+
+  it('keeps the other half of a pair on the list when one half leaves it', async () => {
+    apiMock.mockResolvedValue(response({ items: [{ ...ebook, companion: audiobook }], total: 1 }))
+    const requests = await freshRequests('mine')
+    await requests.fetchRequests()
+
+    requests.dropItem(10)
+
+    expect(requests.items.value).toHaveLength(1)
+    expect(requests.items.value[0]!.id).toBe(11)
+    expect(requests.items.value[0]!.companion).toBeNull()
+    expect(requests.total.value).toBe(1)
+
+    requests.dropItem(11)
+    expect(requests.items.value).toHaveLength(0)
+    expect(requests.total.value).toBe(0)
+  })
+})
diff --git a/client/src/features/book-requests/__tests__/useCandidateGroups.spec.ts b/client/src/features/book-requests/__tests__/useCandidateGroups.spec.ts
index 132b9ae1f..55fbe3a52 100644
--- a/client/src/features/book-requests/__tests__/useCandidateGroups.spec.ts
+++ b/client/src/features/book-requests/__tests__/useCandidateGroups.spec.ts
@@ -257,3 +257,56 @@ describe('useCandidateGroups', () => {
     expect(groupsFor(results, {}, 'ebook')[0]!.key).not.toBe(groupsFor(results, {}, 'audiobook')[0]!.key)
   })
 })
+
+describe('useCandidateGroups for a pair search', () => {
+  function pairGroups(results: MetadataCandidate[], availability: Record<string, BookRequestAvailability>) {
+    const { groups } = useCandidateGroups(
+      ref(results),
+      ref<BookRequestMediaKind>('ebook'),
+      (item, kind = 'ebook') => availability[`${kind}|${item.provider}:${item.providerId}`] ?? null,
+      ref([MetadataProviderKey.AMAZON]),
+      ref(null),
+      ref([]),
+      { enabled: ref(true), audioCoverProviderOrder: ref([MetadataProviderKey.AUDIBLE]) },
+    )
+    return groups.value
+  }
+
+  /** Owning the ebook says nothing about the audiobook, so each half is answered on its own. */
+  it('answers each medium separately, merged across the records behind the work', () => {
+    const groups = pairGroups(
+      [
+        candidate({ provider: MetadataProviderKey.AMAZON, providerId: 'az1' }),
+        candidate({ provider: MetadataProviderKey.AUDIBLE, providerId: 'au1' }),
+      ],
+      {
+        'ebook|amazon:az1': { ownedBookId: 42, existingRequestId: null, existingRequestStatus: null, alreadySubscribed: false },
+        'audiobook|audible:au1': { ownedBookId: null, existingRequestId: 9, existingRequestStatus: 'pending', alreadySubscribed: false },
+      },
+    )
+
+    expect(groups).toHaveLength(1)
+    expect(groups[0]!.pairAvailability?.ebook?.ownedBookId).toBe(42)
+    expect(groups[0]!.pairAvailability?.audiobook?.existingRequestId).toBe(9)
+  })
+
+  it("orders the audiobook half's covers by the Audiobook cover rule, apart from the ebook's", () => {
+    const groups = pairGroups(
+      [
+        candidate({ provider: MetadataProviderKey.AMAZON, providerId: 'az1', coverUrl: 'https://covers.test/portrait.jpg' }),
+        candidate({ provider: MetadataProviderKey.AUDIBLE, providerId: 'au1', coverUrl: 'https://covers.test/square.jpg' }),
+      ],
+      {},
+    )
+
+    expect(groups[0]!.coverUrl).toBe('https://covers.test/portrait.jpg')
+    expect(groups[0]!.audioCoverUrls[0]).toBe('https://covers.test/square.jpg')
+  })
+
+  it('carries no pair answer at all outside a pair search', () => {
+    const groups = groupsFor([candidate({ provider: MetadataProviderKey.AMAZON, providerId: 'az1' })])
+
+    expect(groups[0]!.pairAvailability).toBeNull()
+    expect(groups[0]!.audioCoverUrls).toEqual([])
+  })
+})
diff --git a/client/src/features/book-requests/__tests__/useReleaseGrab.spec.ts b/client/src/features/book-requests/__tests__/useReleaseGrab.spec.ts
index d5857e9b6..aaa08153c 100644
--- a/client/src/features/book-requests/__tests__/useReleaseGrab.spec.ts
+++ b/client/src/features/book-requests/__tests__/useReleaseGrab.spec.ts
@@ -3,12 +3,13 @@ import { ref } from 'vue'
 import { beforeEach, describe, expect, it, vi } from 'vitest'
 import type { BookRequestItem, DownloadDelivery, ReleaseCandidateItem, ReleaseFileInspection } from '@bookorbit/types'
 
-const { toastMock } = vi.hoisted(() => ({
+const { toastMock, pushMock } = vi.hoisted(() => ({
   toastMock: { error: vi.fn<(title: string, options?: unknown) => void>(), success: vi.fn<(title: string) => void>() },
+  pushMock: vi.fn<(to: unknown) => void>(),
 }))
 vi.mock('vue-sonner', () => ({ toast: toastMock }))
 vi.mock('vue-i18n', () => ({ useI18n: () => ({ t: (key: string) => key }) }))
-vi.mock('vue-router', () => ({ useRoute: () => ({ query: {} }), useRouter: () => ({ push: vi.fn<() => void>() }) }))
+vi.mock('vue-router', () => ({ useRoute: () => ({ query: {} }), useRouter: () => ({ push: pushMock }) }))
 
 import { useReleaseGrab, type ReleaseGrabOutcome } from '../composables/useReleaseGrab'
 
@@ -31,6 +32,7 @@ function makeGrab(
     grab?: ReturnType<typeof vi.fn>
     inspectRelease?: ReturnType<typeof vi.fn>
     deliveryFor?: (release: ReleaseCandidateItem) => DownloadDelivery
+    afterGrab?: (item: BookRequestItem) => void
   } = {},
 ) {
   const grab = overrides.grab ?? vi.fn<() => Promise<ReleaseGrabOutcome>>().mockResolvedValue({ item: request, reason: null, errorCode: null })
@@ -47,6 +49,7 @@ function makeGrab(
       inspectRelease: inspectRelease as never,
       setFilesExpanded,
       deliveryFor: overrides.deliveryFor ?? (() => 'torrent'),
+      afterGrab: overrides.afterGrab,
     }),
     grab,
     inspectRelease,
@@ -60,6 +63,25 @@ describe('useReleaseGrab', () => {
     vi.clearAllMocks()
   })
 
+  it('returns to the request a release was sent for', async () => {
+    const picker = makeGrab()
+
+    await picker.handleGrab(release())
+
+    expect(pushMock).toHaveBeenCalledWith({ name: 'book-request-detail', params: { id: 7 }, query: {} })
+  })
+
+  it('leaves where to go next to the picker when it asks to decide', async () => {
+    const afterGrab = vi.fn<(item: BookRequestItem) => void>()
+    const picker = makeGrab({ afterGrab })
+
+    await picker.handleGrab(release())
+
+    expect(afterGrab).toHaveBeenCalledWith(request)
+    expect(pushMock).not.toHaveBeenCalled()
+    expect(toastMock.success).toHaveBeenCalledWith('bookRequests.toasts.grabbed')
+  })
+
   it('inspects a release and sends it', async () => {
     const picker = makeGrab()
 
diff --git a/client/src/features/book-requests/__tests__/useReleasePicker.spec.ts b/client/src/features/book-requests/__tests__/useReleasePicker.spec.ts
index 406653f3c..d43ff0406 100644
--- a/client/src/features/book-requests/__tests__/useReleasePicker.spec.ts
+++ b/client/src/features/book-requests/__tests__/useReleasePicker.spec.ts
@@ -5,7 +5,13 @@ import type { ReleaseCandidateItem, ReleaseFileInspection } from '@bookorbit/typ
 const { apiMock } = vi.hoisted(() => ({ apiMock: vi.fn<(url: string, init?: RequestInit) => Promise<Response>>() }))
 vi.mock('@/lib/api', () => ({ api: apiMock }))
 
-import { TITLE_AUTHOR_SEARCH_KEY, useReleasePicker } from '../composables/useReleasePicker'
+import {
+  TITLE_AUTHOR_SEARCH_KEY,
+  clearReleaseSearchCache,
+  peekReleaseSearch,
+  prefetchReleaseSearch,
+  useReleasePicker,
+} from '../composables/useReleasePicker'
 
 function ok(body: unknown): Response {
   return { ok: true, status: 200, json: async () => body } as Response
@@ -59,6 +65,7 @@ const inspection: ReleaseFileInspection = {
 describe('useReleasePicker', () => {
   beforeEach(() => {
     vi.clearAllMocks()
+    clearReleaseSearchCache()
     apiMock.mockResolvedValue(ok(inspection))
   })
 
@@ -316,6 +323,8 @@ describe('useReleasePicker', () => {
 describe('useReleasePicker out-of-order searches', () => {
   beforeEach(() => {
     vi.clearAllMocks()
+    apiMock.mockReset()
+    clearReleaseSearchCache()
   })
 
   function deferred() {
@@ -356,4 +365,76 @@ describe('useReleasePicker out-of-order searches', () => {
     expect(picker.releases.value).toEqual([])
     expect(picker.searched.value).toBe(false)
   })
+
+  /** The picker for a pair searches both halves on open, and the trackers must only be asked once. */
+  describe('a default search shared across pickers', () => {
+    it('answers from a search already started ahead of time instead of asking again', async () => {
+      const found = deferred()
+      apiMock.mockImplementationOnce(() => found.pending)
+      prefetchReleaseSearch(true, 11)
+      const picker = useReleasePicker(() => true)
+
+      const loaded = picker.fetchReleases(11)
+      found.release(searchResult({ releases: [release] }))
+
+      await expect(loaded).resolves.toBe(true)
+      expect(apiMock).toHaveBeenCalledTimes(1)
+      expect(apiMock).toHaveBeenCalledWith('/api/v1/admin/book-requests/11/releases')
+      expect(picker.releases.value).toEqual([release])
+    })
+
+    it('shows a search it already has in the same tick, without a loading state', async () => {
+      apiMock.mockResolvedValue(ok(searchResult({ releases: [release, release] })))
+      await useReleasePicker(() => true).fetchReleases(11)
+      const picker = useReleasePicker(() => true)
+
+      void picker.fetchReleases(11)
+
+      expect(picker.releases.value).toHaveLength(2)
+      expect(picker.loading.value).toBe(false)
+      expect(apiMock).toHaveBeenCalledTimes(1)
+    })
+
+    it('asks the trackers again when the search is refreshed', async () => {
+      apiMock.mockResolvedValue(ok(searchResult({ releases: [release] })))
+      const picker = useReleasePicker(() => true)
+      await picker.fetchReleases(11)
+
+      await picker.fetchReleases(11, { refresh: true })
+
+      expect(apiMock).toHaveBeenLastCalledWith('/api/v1/admin/book-requests/11/releases?refresh=true')
+      expect(apiMock).toHaveBeenCalledTimes(2)
+    })
+
+    it('says a search is running, then how many releases it found', async () => {
+      const found = deferred()
+      apiMock.mockImplementationOnce(() => found.pending)
+
+      prefetchReleaseSearch(true, 11)
+      expect(peekReleaseSearch(true, 11)).toEqual({ searching: true, count: null })
+
+      found.release(searchResult({ releases: [release, release, release] }))
+      await new Promise((resolve) => setTimeout(resolve, 0))
+      expect(peekReleaseSearch(true, 11)).toEqual({ searching: false, count: 3 })
+    })
+
+    it('forgets a failed search, so the next look asks again', async () => {
+      apiMock.mockResolvedValueOnce({ ok: false, status: 502, json: async () => ({}) } as Response)
+      prefetchReleaseSearch(true, 11)
+      await new Promise((resolve) => setTimeout(resolve, 0))
+      expect(peekReleaseSearch(true, 11)).toEqual({ searching: false, count: null })
+
+      apiMock.mockResolvedValueOnce(ok(searchResult({ releases: [release] })))
+      await useReleasePicker(() => true).fetchReleases(11)
+      expect(apiMock).toHaveBeenCalledTimes(2)
+    })
+
+    it('keeps a self-fulfiller and a moderator apart, since they search different endpoints', async () => {
+      apiMock.mockResolvedValue(ok(searchResult({ releases: [release] })))
+      prefetchReleaseSearch(true, 11)
+      await new Promise((resolve) => setTimeout(resolve, 0))
+
+      expect(peekReleaseSearch(false, 11)).toEqual({ searching: false, count: null })
+    })
+  })
 })
diff --git a/client/src/features/book-requests/__tests__/useRequestDestinationDefault.spec.ts b/client/src/features/book-requests/__tests__/useRequestDestinationDefault.spec.ts
index ef7881e01..ecb4941b0 100644
--- a/client/src/features/book-requests/__tests__/useRequestDestinationDefault.spec.ts
+++ b/client/src/features/book-requests/__tests__/useRequestDestinationDefault.spec.ts
@@ -60,7 +60,6 @@ describe('useRequestDestinationDefault', () => {
     expect(apiMock).toHaveBeenCalledWith('/api/v1/book-requests/default-destinations')
     expect(preferences.defaultFor('ebook')).toEqual({ libraryId: 4, libraryName: 'Novels', folderId: 9 })
     expect(preferences.defaultFor('audiobook')).toEqual({ libraryId: 5, libraryName: 'Audiobooks', folderId: 10 })
-    expect(preferences.defaultFor('comic')).toEqual({ libraryId: null, libraryName: null, folderId: null })
   })
 
   it('reads a malformed body as no default rather than a half-made destination', async () => {
diff --git a/client/src/features/book-requests/__tests__/useRequestQueue.spec.ts b/client/src/features/book-requests/__tests__/useRequestQueue.spec.ts
new file mode 100644
index 000000000..b70d85329
--- /dev/null
+++ b/client/src/features/book-requests/__tests__/useRequestQueue.spec.ts
@@ -0,0 +1,27 @@
+// @vitest-environment node
+import { describe, expect, it } from 'vitest'
+import { ref } from 'vue'
+import type { BookRequestItem } from '@bookorbit/types'
+import { useRequestQueue } from '../composables/useRequestQueue'
+
+function row(id: number, companionId?: number): BookRequestItem {
+  return { id, companion: companionId === undefined ? null : ({ id: companionId } as BookRequestItem) } as BookRequestItem
+}
+
+describe('useRequestQueue', () => {
+  /** The drawer can be open on the audiobook while the row it belongs to is led by the ebook. */
+  it("places either half of a pair at the pair's row, and steps to the rows around it", () => {
+    const queue = useRequestQueue(ref([row(1), row(10, 11), row(2)]), ref(11))
+
+    expect(queue.position.value).toBe(2)
+    expect(queue.previousId.value).toBe(1)
+    expect(queue.nextId.value).toBe(2)
+  })
+
+  it('hides the position of a request the list is not showing', () => {
+    const queue = useRequestQueue(ref([row(1)]), ref(99))
+
+    expect(queue.position.value).toBe(0)
+    expect(queue.hasNext.value).toBe(false)
+  })
+})
diff --git a/client/src/features/book-requests/__tests__/useRequestSubmission.spec.ts b/client/src/features/book-requests/__tests__/useRequestSubmission.spec.ts
index 17d74261e..4ad1c95d5 100644
--- a/client/src/features/book-requests/__tests__/useRequestSubmission.spec.ts
+++ b/client/src/features/book-requests/__tests__/useRequestSubmission.spec.ts
@@ -189,3 +189,97 @@ describe('submit refusals', () => {
     scope.stop()
   })
 })
+
+describe('useRequestSubmission for a pair', () => {
+  const dune = { provider: MetadataProviderKey.GOOGLE, providerId: 'g1', title: 'Dune', authors: ['Frank Herbert'] } as MetadataCandidate
+
+  beforeEach(() => {
+    api.mockReset()
+  })
+
+  it('asks about both media for every candidate, and files each answer under its own medium', async () => {
+    vi.useFakeTimers()
+    try {
+      api.mockResolvedValueOnce({
+        ok: true,
+        json: async () => [
+          { ownedBookId: 42, existingRequestId: null, existingRequestStatus: null, alreadySubscribed: false },
+          { ownedBookId: null, existingRequestId: 9, existingRequestStatus: 'pending', alreadySubscribed: false },
+        ],
+      } as Response)
+      const scope = effectScope()
+      const state = scope.run(() => useRequestSubmission())!
+      state.pairMode.value = true
+      await Promise.resolve()
+
+      state.annotate([dune])
+      await vi.runAllTimersAsync()
+
+      const body = JSON.parse(api.mock.calls[0]![1]!.body as string) as { items: Array<{ mediaKind: string }> }
+      expect(body.items.map((item) => item.mediaKind)).toEqual(['ebook', 'audiobook'])
+      expect(state.getAvailability(dune, 'ebook')?.ownedBookId).toBe(42)
+      expect(state.getAvailability(dune, 'audiobook')?.existingRequestId).toBe(9)
+      scope.stop()
+    } finally {
+      vi.useRealTimers()
+    }
+  })
+
+  it('submits both halves in one call, each with its own destination, formats and cover', async () => {
+    api.mockResolvedValueOnce({
+      ok: true,
+      json: async () => ({
+        ebook: { request: { id: 10, status: 'pending' }, subscribed: false },
+        audiobook: { request: { id: 11, status: 'pending' }, subscribed: true },
+      }),
+    } as Response)
+    const scope = effectScope()
+    const state = scope.run(() => useRequestSubmission())!
+
+    const result = await state.submitPair(dune, {
+      language: 'en',
+      ebook: { targetLibraryId: 1, preferredFormats: ['epub'] },
+      audiobook: { targetLibraryId: 2, preferredFormats: ['m4b'], coverUrl: 'https://covers.test/square.jpg' },
+    })
+
+    const [path, init] = api.mock.calls[0]!
+    expect(path).toBe('/api/v1/book-requests/pairs')
+    const body = JSON.parse(init!.body as string)
+    expect(body).not.toHaveProperty('mediaKind')
+    expect(body.ebook).toEqual({ targetLibraryId: 1, targetFolderId: null, preferredFormats: ['epub'], coverUrl: null })
+    expect(body.audiobook).toEqual({
+      targetLibraryId: 2,
+      targetFolderId: null,
+      preferredFormats: ['m4b'],
+      coverUrl: 'https://covers.test/square.jpg',
+    })
+    expect(result?.audiobook.subscribed).toBe(true)
+    // What the server just said stands in for both halves until the next annotation.
+    expect(state.getAvailability(dune, 'ebook')?.existingRequestId).toBe(10)
+    expect(state.getAvailability(dune, 'audiobook')?.existingRequestId).toBe(11)
+    scope.stop()
+  })
+
+  it('asks for one medium with the book it should join when only that one is missing', async () => {
+    api.mockResolvedValueOnce({ ok: true, json: async () => ({ request: { id: 12, status: 'pending' }, subscribed: false }) } as Response)
+    const scope = effectScope()
+    const state = scope.run(() => useRequestSubmission())!
+
+    await state.submit(dune, { mediaKind: 'audiobook', targetBookId: 42 })
+
+    const body = JSON.parse(api.mock.calls[0]![1]!.body as string)
+    expect(body).toMatchObject({ mediaKind: 'audiobook', targetBookId: 42 })
+    scope.stop()
+  })
+
+  it('leaves the book field off entirely for an ordinary request, so an older server never sees it', async () => {
+    api.mockResolvedValueOnce({ ok: true, json: async () => ({ request: { id: 12, status: 'pending' }, subscribed: false }) } as Response)
+    const scope = effectScope()
+    const state = scope.run(() => useRequestSubmission())!
+
+    await state.submit(dune, {})
+
+    expect(JSON.parse(api.mock.calls[0]![1]!.body as string)).not.toHaveProperty('targetBookId')
+    scope.stop()
+  })
+})
diff --git a/client/src/features/book-requests/components/BookMissingFormatRequest.vue b/client/src/features/book-requests/components/BookMissingFormatRequest.vue
new file mode 100644
index 000000000..6b2bc1cb1
--- /dev/null
+++ b/client/src/features/book-requests/components/BookMissingFormatRequest.vue
@@ -0,0 +1,110 @@
+<script setup lang="ts">
+import { computed, toRef } from 'vue'
+import { useI18n } from 'vue-i18n'
+import { toast } from 'vue-sonner'
+import { BookOpen, Check, Headphones, Library, Loader2, Users } from '@lucide/vue'
+import { Permission, type BookDetail } from '@bookorbit/types'
+import { usePermissions } from '@/features/auth/composables/usePermissions'
+import { useBookRequestVisibility } from '../composables/useBookRequestVisibility'
+import { useMissingFormatRequest } from '../composables/useMissingFormatRequest'
+import { submitFailureText } from '../composables/useRequestSubmission'
+
+/**
+ * The format a book does not have yet, offered where the book's formats are listed: an ebook's
+ * missing audiobook, or an audiobook's missing ebook. Requesting it here names this book, so when
+ * the new format arrives it joins the book rather than becoming a second one beside it.
+ */
+const props = defineProps<{ book: BookDetail }>()
+
+const { t } = useI18n()
+const { hasPermission } = usePermissions()
+const { showBookRequests } = useBookRequestVisibility()
+
+const enabled = computed(() => hasPermission(Permission.BookRequestAccess) && showBookRequests.value)
+const { missing, state, requestId, ownedBookId, submitting, request } = useMissingFormatRequest(toRef(props, 'book'), enabled)
+
+const visible = computed(() => enabled.value && missing.value !== null)
+const icon = computed(() => (missing.value === 'audiobook' ? Headphones : BookOpen))
+const groupLabel = computed(() =>
+  missing.value === 'audiobook' ? t('bookRequests.missingFormat.labelAudiobook') : t('bookRequests.missingFormat.labelEbook'),
+)
+
+const statusText = computed(() => {
+  if (state.value === 'owned') return t('bookRequests.missingFormat.ownedElsewhere')
+  if (state.value === 'following') return t('bookRequests.missingFormat.requested')
+  if (state.value === 'joinable') return t('bookRequests.missingFormat.requestedBySomeone')
+  return missing.value === 'audiobook' ? t('bookRequests.missingFormat.noAudiobook') : t('bookRequests.missingFormat.noEbook')
+})
+
+/**
+ * The card is a narrow rail column, so the button says only the verb and the line beside it names
+ * the format. A screen reader hears both together in the accessible name.
+ */
+const actionLabel = computed(() => (state.value === 'joinable' ? t('bookRequests.search.joinRequest') : t('bookRequests.search.request')))
+const actionAriaLabel = computed(() => {
+  if (state.value === 'joinable') return t('bookRequests.search.joinRequest')
+  return missing.value === 'audiobook' ? t('bookRequests.missingFormat.requestAudiobook') : t('bookRequests.missingFormat.requestEbook')
+})
+
+const canAct = computed(() => state.value === 'new' || state.value === 'joinable')
+
+async function handleRequest() {
+  const { result, failure } = await request()
+  if (!result) {
+    toast.error(t('bookRequests.search.submitFailed'), { description: submitFailureText(failure, t) ?? undefined })
+    return
+  }
+  if (result.subscribed) toast.success(t('bookRequests.search.joinedExisting'))
+  else
+    toast.success(missing.value === 'audiobook' ? t('bookRequests.missingFormat.submittedAudiobook') : t('bookRequests.missingFormat.submittedEbook'))
+}
+</script>
+
+<template>
+  <!--
+    A dashed placeholder where the missing format's chip would sit, so the row reads as "this one
+    is not here yet" in the same vocabulary as the editions above it.
+  -->
+  <div v-if="visible" class="mt-2 flex min-h-7 items-center gap-2.5" role="group" :aria-label="groupLabel">
+    <span
+      class="inline-flex h-5 min-w-13 shrink-0 items-center justify-center rounded-md border border-dashed border-border text-muted-foreground"
+      aria-hidden="true"
+    >
+      <component :is="icon" :size="12" />
+    </span>
+
+    <span class="min-w-0 flex-1 truncate text-[11px] text-muted-foreground" role="status">
+      <Loader2 v-if="state === 'checking'" :size="11" class="me-1 inline animate-spin align-[-1px]" aria-hidden="true" />
+      <span v-else-if="state === 'owned'" class="inline-flex items-center gap-1"><Library :size="11" aria-hidden="true" />{{ statusText }}</span>
+      <span v-else-if="state === 'following'" class="inline-flex items-center gap-1"><Check :size="11" aria-hidden="true" />{{ statusText }}</span>
+      <span v-else-if="state === 'joinable'" class="inline-flex items-center gap-1"><Users :size="11" aria-hidden="true" />{{ statusText }}</span>
+      <template v-else>{{ statusText }}</template>
+    </span>
+
+    <RouterLink
+      v-if="state === 'owned' && ownedBookId !== null"
+      :to="{ name: 'book-detail', params: { bookId: ownedBookId } }"
+      class="shrink-0 rounded text-[11px] font-medium text-foreground underline-offset-2 hover:underline focus-visible:ring-2 focus-visible:ring-ring focus-visible:outline-none"
+    >
+      {{ t('bookRequests.missingFormat.open') }}
+    </RouterLink>
+    <RouterLink
+      v-else-if="state === 'following' && requestId !== null"
+      :to="{ name: 'book-request-detail', params: { id: requestId }, query: { tab: 'mine' } }"
+      class="shrink-0 rounded text-[11px] font-medium text-foreground underline-offset-2 hover:underline focus-visible:ring-2 focus-visible:ring-ring focus-visible:outline-none"
+    >
+      {{ t('bookRequests.missingFormat.viewRequest') }}
+    </RouterLink>
+    <button
+      v-else-if="canAct"
+      type="button"
+      class="inline-flex h-6 shrink-0 items-center gap-1 rounded-md border border-input bg-card px-2 text-[11px] font-medium text-foreground transition-colors hover:bg-muted focus-visible:ring-2 focus-visible:ring-ring focus-visible:outline-none disabled:opacity-60 motion-reduce:transition-none"
+      :disabled="submitting"
+      :aria-label="actionAriaLabel"
+      @click="handleRequest"
+    >
+      <Loader2 v-if="submitting" :size="11" class="animate-spin" aria-hidden="true" />
+      {{ actionLabel }}
+    </button>
+  </div>
+</template>
diff --git a/client/src/features/book-requests/components/ReleasePairTabs.vue b/client/src/features/book-requests/components/ReleasePairTabs.vue
new file mode 100644
index 000000000..2fe7ef784
--- /dev/null
+++ b/client/src/features/book-requests/components/ReleasePairTabs.vue
@@ -0,0 +1,86 @@
+<script setup lang="ts">
+import { useI18n } from 'vue-i18n'
+import type { LocationQuery } from 'vue-router'
+import { Check, Loader2 } from '@lucide/vue'
+import type { BookRequestItem, BookRequestStatus } from '@bookorbit/types'
+import RequestStatusBadge from './RequestStatusBadge.vue'
+import { requestMediaIcon } from '../requestMedia'
+
+export interface ReleasePairTab {
+  request: BookRequestItem
+  current: boolean
+  /** Whether this viewer can pick a release for it now. Only those, and the open one, are links. */
+  choosable: boolean
+  /** How many releases its search found, or null before it has answered. */
+  count: number | null
+  searching: boolean
+}
+
+/**
+ * The two halves of a pair inside the release picker. Each tab says whether it still needs a
+ * release, so the half you are not looking at cannot be forgotten the way a passing toast was.
+ */
+const props = defineProps<{ tabs: ReleasePairTab[]; query: LocationQuery }>()
+
+const { t } = useI18n()
+
+/** Past the choice and on their way, which from here reads as done, not as three tracker states. */
+const SENT_STATUSES: readonly BookRequestStatus[] = ['grabbed', 'downloading', 'importing']
+
+function linkProps(tab: ReleasePairTab) {
+  if (!tab.current && !tab.choosable) return { 'aria-disabled': 'true' }
+  return {
+    to: { name: 'book-request-releases', params: { id: tab.request.id }, query: props.query },
+    'aria-current': tab.current ? 'page' : undefined,
+  }
+}
+
+function isSent(tab: ReleasePairTab): boolean {
+  return SENT_STATUSES.includes(tab.request.status)
+}
+</script>
+
+<template>
+  <nav class="mt-4 grid grid-cols-2 gap-1 rounded-lg border border-border bg-muted p-1" :aria-label="t('bookRequests.releases.pair.tabsLabel')">
+    <component
+      :is="tab.current || tab.choosable ? 'RouterLink' : 'span'"
+      v-for="tab in tabs"
+      :key="tab.request.id"
+      v-bind="linkProps(tab)"
+      class="flex min-w-0 flex-wrap items-center gap-x-2 gap-y-1 rounded-md px-2.5 py-2 text-sm font-medium transition-colors focus-visible:ring-2 focus-visible:ring-ring focus-visible:outline-none motion-reduce:transition-none"
+      :class="
+        tab.current
+          ? 'bg-background text-foreground shadow-xs'
+          : tab.choosable
+            ? 'text-muted-foreground hover:text-foreground focus-visible:text-foreground'
+            : 'text-muted-foreground'
+      "
+    >
+      <component :is="requestMediaIcon(tab.request.mediaKind)" :size="14" class="shrink-0" aria-hidden="true" />
+      <span class="truncate">{{ t(`bookRequests.mediaKind.${tab.request.mediaKind}`) }}</span>
+      <span v-if="tab.searching" class="flex items-center gap-1 text-xs font-normal text-muted-foreground">
+        <Loader2 class="size-3 animate-spin motion-reduce:animate-none" aria-hidden="true" />
+        {{ t('bookRequests.releases.pair.searching') }}
+      </span>
+      <span v-else-if="tab.choosable && tab.count !== null" class="text-xs font-normal text-muted-foreground tabular-nums">
+        {{ t('bookRequests.releases.pair.releaseCount', { count: tab.count }) }}
+      </span>
+
+      <span
+        v-if="tab.choosable"
+        class="ms-auto inline-flex h-[22px] shrink-0 items-center gap-1.5 rounded-full border border-info/40 bg-info/10 px-2 text-xs font-medium whitespace-nowrap text-info"
+      >
+        <span class="size-1.5 rounded-full bg-current" aria-hidden="true" />
+        {{ t('bookRequests.releases.pair.toChoose') }}
+      </span>
+      <span
+        v-else-if="isSent(tab)"
+        class="ms-auto inline-flex h-[22px] shrink-0 items-center gap-1.5 rounded-full border border-success/40 bg-success/10 px-2 text-xs font-medium whitespace-nowrap text-success"
+      >
+        <Check :size="12" :stroke-width="2.5" aria-hidden="true" />
+        {{ t('bookRequests.releases.pair.sent') }}
+      </span>
+      <RequestStatusBadge v-else :status="tab.request.status" class="ms-auto" />
+    </component>
+  </nav>
+</template>
diff --git a/client/src/features/book-requests/components/ReleasePickerPanel.vue b/client/src/features/book-requests/components/ReleasePickerPanel.vue
index a829ebe3f..60ec13905 100644
--- a/client/src/features/book-requests/components/ReleasePickerPanel.vue
+++ b/client/src/features/book-requests/components/ReleasePickerPanel.vue
@@ -4,6 +4,7 @@ import { useI18n } from 'vue-i18n'
 import { useRoute, useRouter } from 'vue-router'
 import {
   ArrowUpRight,
+  Check,
   ChevronDown,
   ChevronUp,
   CircleCheck,
@@ -23,8 +24,10 @@ import {
   TriangleAlert,
   Zap,
 } from '@lucide/vue'
-import { Permission, releaseInspectionBlocksGrab } from '@bookorbit/types'
+import { isBookRequestFulfiller, isGrabbableBookRequestStatus, Permission, releaseInspectionBlocksGrab } from '@bookorbit/types'
 import type {
+  BookRequestItem,
+  BookRequestStatus,
   DownloadDelivery,
   IndexerSearchFailure,
   ReleaseCandidateItem,
@@ -38,6 +41,8 @@ import { formatDate, formatLanguageName, formatList } from '@/i18n/formatters'
 import { formatBytes } from '@/lib/formatting'
 import GrabReleaseDialog from './GrabReleaseDialog.vue'
 import ReleaseFileInspectionPanel from './ReleaseFileInspectionPanel.vue'
+import ReleasePairTabs from './ReleasePairTabs.vue'
+import type { ReleasePairTab } from './ReleasePairTabs.vue'
 import RequestCover from './RequestCover.vue'
 import RequestDrawerToolbar from './RequestDrawerToolbar.vue'
 import RequestEmptyState from './RequestEmptyState.vue'
@@ -51,8 +56,9 @@ import { useDownloadClientSummaries } from '../composables/useDownloadClients'
 import { useReleaseFacetGroups } from '../composables/useReleaseFacetGroups'
 import { useReleaseFilters } from '../composables/useReleaseFilters'
 import { useReleaseGrab } from '../composables/useReleaseGrab'
-import { useReleasePicker } from '../composables/useReleasePicker'
+import { peekReleaseSearch, prefetchReleaseSearch, useReleasePicker } from '../composables/useReleasePicker'
 import { useReleaseSearchEditor } from '../composables/useReleaseSearchEditor'
+import { useAuth } from '@/features/auth/composables/useAuth'
 import { usePermissions } from '@/features/auth/composables/usePermissions'
 
 const { t } = useI18n()
@@ -84,6 +90,13 @@ const {
   reset,
 } = useReleasePicker(canManage)
 const { request, loading: requestLoading, error: requestError, fetchRequest, setRequest } = useBookRequestDetail()
+const { user } = useAuth()
+const companionDetail = useBookRequestDetail()
+/** The other half of a pair, once both ends of the link agree. */
+const companion = computed(() => {
+  const other = companionDetail.request.value
+  return other && request.value && other.id === request.value.companionRequestId && other.companionRequestId === request.value.id ? other : null
+})
 const { clients, fetchClients } = useDownloadClientSummaries(canManage)
 const torrentClients = computed(() => clients.value.filter((client) => client.delivery === 'torrent'))
 const actions = useBookRequestActions(canManage)
@@ -95,6 +108,37 @@ const MAX_LISTED_SOURCES = 4
 
 const requestId = computed(() => Number(route.params.id))
 
+/** Mirrors `RequestDetailPanel.canFulfilThis`, for whichever half it is asked about. */
+function canDrive(half: BookRequestItem): boolean {
+  return canManage() || (hasPermission(Permission.BookRequestSelfFulfill) && isBookRequestFulfiller(half, user.value?.id))
+}
+
+function isChoosable(half: BookRequestItem): boolean {
+  return canDrive(half) && isGrabbableBookRequestStatus(half.status)
+}
+
+/** A half past choosing: its release is on its way or already in the library. */
+const SETTLED_STATUSES: readonly BookRequestStatus[] = ['grabbed', 'downloading', 'importing', 'needs_review', 'available']
+/** Set by the send that leaves neither half needing a release, and cleared when the picker moves. */
+const finished = ref(false)
+/**
+ * The list the drawer sits on, without what only the first search was opened with. An ISBN picked
+ * for one half's search says nothing about the other's, so switching halves searches afresh.
+ */
+const listQuery = computed(() => Object.fromEntries(Object.entries(route.query).filter(([key]) => key !== 'isbn' && key !== 'search')))
+const pairTabs = computed<ReleasePairTab[] | null>(() => {
+  const current = request.value
+  const partner = companion.value
+  if (!current || !partner) return null
+  return [current, partner]
+    .sort((a, b) => (a.mediaKind === b.mediaKind ? 0 : a.mediaKind === 'ebook' ? -1 : 1))
+    .map((half) => {
+      if (half.id !== current.id) return { request: half, current: false, choosable: isChoosable(half), ...peekReleaseSearch(canManage(), half.id) }
+      const count = searched.value && !loading.value ? releases.value.length : null
+      return { request: half, current: true, choosable: isChoosable(half), count, searching: loading.value }
+    })
+})
+
 const filters = useReleaseFilters(releases)
 const { visibleReleases, hasFilter, showFacets, marksBest, tiedWithBest, clearFilters, resetFilters } = filters
 
@@ -142,6 +186,7 @@ const { manualOpen, grabbing, openManual, closeManual, forgetRefusals, handleGra
   inspectRelease,
   setFilesExpanded,
   deliveryFor,
+  afterGrab,
 })
 
 /**
@@ -346,6 +391,25 @@ onMounted(async () => {
   if (Number.isInteger(requestId.value)) void fetchInitialReleases(requestId.value)
 })
 
+watch(
+  () => request.value?.companionRequestId ?? null,
+  (companionId) => {
+    if (companionId === null) {
+      companionDetail.request.value = null
+      return
+    }
+    void companionDetail.fetchRequest(companionId, { background: companionDetail.request.value?.id === companionId })
+  },
+)
+
+// Both halves are searched once the picker is open on either, so the second never makes anyone wait.
+watch(
+  () => (companion.value && isChoosable(companion.value) ? companion.value.id : null),
+  (companionId) => {
+    if (companionId !== null) prefetchReleaseSearch(canManage(), companionId)
+  },
+)
+
 watch(requestId, (id) => {
   if (!Number.isInteger(id)) return
   reset()
@@ -354,10 +418,41 @@ watch(requestId, (id) => {
   showEachSource.value = false
   expandedFiles.value = new Set()
   resetFilters()
-  void fetchRequest(id)
+  finished.value = false
+  // Switching between the halves of a pair: both are already loaded, so they trade places at once.
+  const partner = companion.value
+  const previous = request.value
+  if (partner && previous && partner.id === id) {
+    setRequest(partner)
+    companionDetail.setRequest(previous)
+    void fetchRequest(id, { background: true })
+  } else {
+    void fetchRequest(id)
+  }
   void fetchInitialReleases(id)
 })
 
+/**
+ * Where a sent release leaves a pair: on the other half while it still needs one, on a closing
+ * state once neither does, and otherwise back on the request as for any single release.
+ */
+function afterGrab(item: BookRequestItem): void {
+  const partner = companion.value
+  if (partner && isChoosable(partner)) {
+    void router.push({ name: 'book-request-releases', params: { id: partner.id }, query: listQuery.value })
+    return
+  }
+  if (partner && SETTLED_STATUSES.includes(partner.status)) {
+    finished.value = true
+    return
+  }
+  void router.push({ name: 'book-request-detail', params: { id: item.id }, query: route.query })
+}
+
+function closeDrawer(): void {
+  void router.push({ name: 'book-requests', query: listQuery.value })
+}
+
 function releaseKey(release: ReleaseCandidateItem): string {
   return `${release.indexerId}:${release.guid}`
 }
@@ -669,10 +764,10 @@ function showEverySource(): void {
     <RequestDrawerToolbar leading="back" @back="goBack">
       <template #title>
         <p class="truncate text-sm font-medium text-foreground">
-          {{ isRetry ? t('bookRequests.releases.retryTitle') : t('bookRequests.releases.title') }}
+          {{ isRetry ? t('bookRequests.releases.retryTitle') : pairTabs ? t('bookRequests.releases.pairTitle') : t('bookRequests.releases.title') }}
         </p>
       </template>
-      <template #actions>
+      <template v-if="!finished" #actions>
         <Button variant="ghost" size="sm" :disabled="loading" @click="handleRefresh">
           <RefreshCw :size="14" aria-hidden="true" />
           {{ t('bookRequests.releases.refresh') }}
@@ -707,6 +802,8 @@ function showEverySource(): void {
           </div>
         </header>
 
+        <ReleasePairTabs v-if="pairTabs" :tabs="pairTabs" :query="listQuery" />
+
         <p v-if="isRetry && failureText" class="mt-3 text-sm text-muted-foreground">
           {{ t('bookRequests.releases.previousFailure', { reason: failureText }) }}
         </p>
@@ -718,7 +815,7 @@ function showEverySource(): void {
           quieter voice. The empty state below says what actually happened.
         -->
         <section
-          v-if="criteria && !noSourcesEnabled"
+          v-if="criteria && !noSourcesEnabled && !finished"
           class="mt-3 rounded-lg border border-border bg-muted/40 p-3"
           :aria-label="t('bookRequests.releases.criteria.label')"
         >
@@ -1028,11 +1125,24 @@ function showEverySource(): void {
         </section>
 
         <!-- Not while nothing was searched: "showing the last search" is the same claim again. -->
-        <p v-if="cached && !loading && !noSourcesEnabled" class="mt-3 text-xs text-muted-foreground">
+        <p v-if="cached && !loading && !noSourcesEnabled && !finished" class="mt-3 text-xs text-muted-foreground">
           {{ t('bookRequests.releases.cached') }}
         </p>
 
-        <p v-if="loading" role="status" class="mt-5 flex items-center gap-2 text-sm text-muted-foreground">
+        <!-- Where a pair ends once neither half needs a release: said here, not left to a passing toast. -->
+        <div v-if="finished" role="status" class="mt-10 flex flex-col items-center gap-3 text-center">
+          <span class="grid size-11 place-items-center rounded-full bg-success/15 text-success">
+            <Check :size="22" aria-hidden="true" />
+          </span>
+          <p class="text-base font-semibold text-foreground">{{ t('bookRequests.releases.pair.finishedTitle') }}</p>
+          <p class="max-w-sm text-sm text-muted-foreground">{{ t('bookRequests.releases.pair.finishedHint') }}</p>
+          <div class="mt-2 flex flex-wrap justify-center gap-2">
+            <Button variant="outline" size="sm" @click="goBack">{{ t('bookRequests.releases.pair.backToRequest') }}</Button>
+            <Button size="sm" @click="closeDrawer">{{ t('bookRequests.releases.pair.done') }}</Button>
+          </div>
+        </div>
+
+        <p v-else-if="loading" role="status" class="mt-5 flex items-center gap-2 text-sm text-muted-foreground">
           <Loader2 class="size-4 animate-spin" aria-hidden="true" />
           {{ t('bookRequests.releases.searching') }}
         </p>
diff --git a/client/src/features/book-requests/components/RequestAttemptsPanel.vue b/client/src/features/book-requests/components/RequestAttemptsPanel.vue
index c10657ded..d24ca42bc 100644
--- a/client/src/features/book-requests/components/RequestAttemptsPanel.vue
+++ b/client/src/features/book-requests/components/RequestAttemptsPanel.vue
@@ -22,8 +22,12 @@ const { attempts, loading, failed, fetchAttempts, reset } = useRequestAttempts((
  */
 const earlier = computed(() => attempts.value.filter((attempt) => attempt.id !== props.request.download?.id))
 
-/** Nothing to say until a request has been sent somewhere more than once. */
-const show = computed(() => loading.value || failed.value || earlier.value.length > 0)
+/**
+ * Nothing to say until a request has been sent somewhere more than once. Not shown merely because
+ * it is loading: most requests have no earlier attempt, and a box that appears to say "loading"
+ * and then vanishes is a flash on every request opened.
+ */
+const show = computed(() => failed.value || earlier.value.length > 0)
 
 watch(
   () => [props.request.id, props.request.download?.id, props.request.status] as const,
diff --git a/client/src/features/book-requests/components/RequestCover.vue b/client/src/features/book-requests/components/RequestCover.vue
index 1e8466688..8339fe8ee 100644
--- a/client/src/features/book-requests/components/RequestCover.vue
+++ b/client/src/features/book-requests/components/RequestCover.vue
@@ -1,14 +1,14 @@
 <script setup lang="ts">
 import { computed, ref, watch } from 'vue'
-import { BookOpen, Headphones, Images } from '@lucide/vue'
-import type { BookRequestMediaKind } from '@bookorbit/types'
+import type { StoredBookRequestMediaKind } from '@bookorbit/types'
+import { requestMediaIcon } from '../requestMedia'
 
 const props = withDefaults(
   defineProps<{
     src: string | null
     fallbackSources?: string[]
     sourceKey?: string
-    mediaKind: BookRequestMediaKind
+    mediaKind: StoredBookRequestMediaKind
     /** Sizing lives with the caller, because a table thumbnail and a page header differ. */
     class?: string
     iconSize?: number
@@ -16,8 +16,6 @@ const props = withDefaults(
   { class: '', iconSize: 18 },
 )
 
-const MEDIA_ICONS = { ebook: BookOpen, audiobook: Headphones, comic: Images } as const
-
 /**
  * Cover URLs come from metadata providers, so they point at hosts BookOrbit does not control and
  * fail routinely. A bare `v-if="coverUrl"` only covers the null case: a URL that is present but
@@ -51,7 +49,7 @@ watch(
 )
 
 const showImage = computed(() => currentSrc.value !== null)
-const icon = computed(() => MEDIA_ICONS[props.mediaKind] ?? BookOpen)
+const icon = computed(() => requestMediaIcon(props.mediaKind))
 
 function handleError() {
   failedIndex.value += 1
diff --git a/client/src/features/book-requests/components/RequestDetailPanel.vue b/client/src/features/book-requests/components/RequestDetailPanel.vue
index 7689d7631..41dbfb313 100644
--- a/client/src/features/book-requests/components/RequestDetailPanel.vue
+++ b/client/src/features/book-requests/components/RequestDetailPanel.vue
@@ -3,22 +3,15 @@ import { computed, inject, onMounted, ref, watch } from 'vue'
 import { useI18n } from 'vue-i18n'
 import { useRoute, useRouter } from 'vue-router'
 import { toast } from 'vue-sonner'
+import { BookHeadphones, ChevronDown, Ellipsis, ExternalLink, EyeOff, FileText, Library, Loader2, Search, TriangleAlert, Users } from '@lucide/vue'
 import {
-  BookOpen,
-  ChevronDown,
-  Ellipsis,
-  ExternalLink,
-  EyeOff,
-  FileText,
-  Headphones,
-  Images,
-  Library,
-  Loader2,
-  Search,
-  TriangleAlert,
-  Users,
-} from '@lucide/vue'
-import { isBookRequestFulfiller, isFulfillableBookRequestStatus, isGrabbableBookRequestStatus, Permission } from '@bookorbit/types'
+  isBookRequestFulfiller,
+  isBookRequestMediaKind,
+  isFulfillableBookRequestStatus,
+  isGrabbableBookRequestStatus,
+  NO_RESOLVED_REQUEST_DESTINATION,
+  Permission,
+} from '@bookorbit/types'
 import type { BookCard, BookDockFile, BookRequestItem } from '@bookorbit/types'
 import { Button } from '@/components/ui/button'
 import ConfirmDialog from '@/components/ui/ConfirmDialog.vue'
@@ -32,6 +25,7 @@ import { useLibraries } from '@/features/library/composables/useLibraries'
 import { formatDateTime } from '@/i18n/formatters'
 import { formatBytes } from '@/lib/formatting'
 import RequestCover from './RequestCover.vue'
+import RequestPairSwitch from './RequestPairSwitch.vue'
 import ReleaseUnitChooser from './ReleaseUnitChooser.vue'
 import RequestReviewPanel from './RequestReviewPanel.vue'
 import RequestDownloadProgress from './RequestDownloadProgress.vue'
@@ -48,8 +42,11 @@ import { useFulfilmentPicker, type FulfilmentSource } from '../composables/useFu
 import { formatLanguageName } from '@/i18n/formatters'
 import { requestLanguageOptions, useRequestDestinationDefault } from '../composables/useRequestDestinationDefault'
 import { useRequestReview } from '../composables/useRequestReview'
+import { prefetchRequestAttempts } from '../composables/useRequestAttempts'
+import { prefetchSeedStatus } from '../composables/useRequestSeedStatus'
 import { REQUEST_DRAWER } from '../requestDrawerContext'
 import { canCancelRequest, canDeleteRequest, canDismissRequest, canLeaveRequest, cancelStopsATransfer } from '../requestActions'
+import { requestMediaIcon } from '../requestMedia'
 import { requestFailureText } from '../requestOutcome'
 import { localizedRequestActionFailure } from '../requestActionFailure'
 import { currentRequestProgress, requestPresentationStatus } from '../requestPipeline'
@@ -61,8 +58,6 @@ const { hasPermission } = usePermissions()
 const { user } = useAuth()
 const drawer = inject(REQUEST_DRAWER, null)
 
-const MEDIA_ICONS = { ebook: BookOpen, audiobook: Headphones, comic: Images } as const
-
 /** The same window the list behind the drawer collapses its own refreshes into. */
 const CHANGE_REFRESH_WINDOW_MS = 400
 
@@ -74,6 +69,15 @@ const CHANGE_REFRESH_WINDOW_MS = 400
 const canManageFn = () => hasPermission(Permission.ManageBookRequests)
 
 const { request, loading, error, fetchRequest, setRequest } = useBookRequestDetail()
+/**
+ * The other half of a pair, read on its own because it is its own request. Only kept when it
+ * really is this request's partner and the viewer may see it; anything else hides the switch.
+ */
+const companionDetail = useBookRequestDetail()
+const companion = computed(() => {
+  const other = companionDetail.request.value
+  return other && request.value && other.id === request.value.companionRequestId && other.companionRequestId === request.value.id ? other : null
+})
 const { libraries, fetchLibraries } = useLibraries()
 const { load: loadDefaultDestination, defaultFor: instanceDefaultFor, resolveDestination } = useRequestDestinationDefault()
 const { progressByRequest, onRequestsChanged, pruneSettledProgress } = useBookRequestProgress()
@@ -111,7 +115,7 @@ const canFulfilThis = computed(
     (hasPermission(Permission.BookRequestSelfFulfill) && request.value != null && isBookRequestFulfiller(request.value, user.value?.id)),
 )
 const busy = computed(() => actions.isPending(request.value?.id))
-const mediaIcon = computed(() => (request.value ? (MEDIA_ICONS[request.value.mediaKind] ?? BookOpen) : BookOpen))
+const mediaIcon = computed(() => requestMediaIcon(request.value?.mediaKind ?? 'ebook'))
 const authorLine = computed(() => request.value?.authors.join(', ') ?? '')
 /** Non-empty only while an attempt is held because its release turned out to hold several books. */
 const releaseUnits = computed(() => request.value?.download?.releaseUnits ?? [])
@@ -146,6 +150,15 @@ const canDelete = computed(() => (request.value ? canDeleteRequest(request.value
 const canLeave = computed(() => (request.value ? canLeaveRequest(request.value, user.value?.id ?? null) : false))
 const hasMenuActions = computed(() => canDismiss.value || canLeave.value || canCancel.value || canDelete.value)
 const canApproveNow = computed(() => canDecide.value && !busy.value && targetLibraryId.value !== null)
+/** Both halves waiting on the same decision, which is the moment one press should cover both. */
+const canApproveBoth = computed(() => canApproveNow.value && companion.value?.status === 'pending' && !actions.isPending(companion.value.id))
+/** In a pair a bare "Approve" could mean either half, so it names the one this drawer is open on. */
+const approveLabel = computed(() => {
+  if (!companion.value) return t('bookRequests.actions.approve')
+  return request.value?.mediaKind === 'audiobook' ? t('bookRequests.actions.pair.approveAudiobook') : t('bookRequests.actions.pair.approveEbook')
+})
+/** A book on the shelf this request's files will join, said until they have. */
+const joinsBookId = computed(() => (request.value && request.value.status !== 'available' ? request.value.targetBookId : null))
 const showFooter = computed(() => canDecide.value || (canGrab.value && !showTransferRetry.value))
 
 const confirming = ref<'cancel' | 'cancelDownload' | 'delete' | 'leave' | 'discardImport' | null>(null)
@@ -185,6 +198,35 @@ onMounted(async () => {
   void syncReview()
 })
 
+/** The companion follows whichever half is open, and goes away when the open request has none. */
+watch(
+  () => request.value?.companionRequestId ?? null,
+  (companionId) => {
+    if (companionId === null) {
+      companionDetail.request.value = null
+      return
+    }
+    void companionDetail.fetchRequest(companionId, { background: companionDetail.request.value?.id === companionId })
+  },
+  { immediate: true },
+)
+
+/**
+ * Warms what the other half's drawer reads for itself, so the first switch to it shows its panels
+ * at once rather than each one loading in turn. Only for somebody who sees those panels at all.
+ */
+watch(
+  () => companion.value?.id ?? null,
+  (companionId) => {
+    const partner = companion.value
+    if (companionId === null || !partner || !canFulfilThis.value) return
+    void prefetchRequestAttempts(canManage.value, companionId)
+    // The same test the seed panel applies: only a torrent has a seed to read.
+    const source = partner.download?.source
+    if (source === 'magnet' || source === 'torrent_file') void prefetchSeedStatus(canManage.value, companionId)
+  },
+)
+
 /** Only a held request has anything to review, and only somebody who can file it may read it. */
 async function syncReview(): Promise<void> {
   if (!canFulfilThis.value || !isHeld.value || !request.value) {
@@ -217,6 +259,8 @@ onRequestsChanged(
   useCoalescedRefresh(() => {
     if (!Number.isInteger(requestId.value)) return
     void fetchRequest(requestId.value, { background: true }).then(syncReview)
+    const companionId = request.value?.companionRequestId
+    if (companionId != null) void companionDetail.fetchRequest(companionId, { background: true })
   }, CHANGE_REFRESH_WINDOW_MS),
 )
 
@@ -231,6 +275,21 @@ watch(requestId, async (id) => {
   picker.reset()
   decisionNote.value = ''
   resetReview()
+
+  // Switching between the halves of a pair: both are already loaded, so they trade places at once
+  // and are refreshed behind the scenes. Fetching from scratch blanked the drawer to a loading line
+  // on every switch.
+  const partner = companion.value
+  const previous = request.value
+  if (partner && previous && partner.id === id) {
+    setRequest(partner)
+    companionDetail.setRequest(previous)
+    resetDestination()
+    void syncReview()
+    void fetchRequest(id, { background: true }).then(syncReview)
+    return
+  }
+
   await fetchRequest(id)
   resetDestination()
   void syncReview()
@@ -243,7 +302,8 @@ watch(libraries, () => {
 
 /** What approving without touching this would do, which is the instance default for its medium. */
 const unpickedDestinationLabel = computed(() => {
-  const fallback = instanceDefaultFor(request.value?.mediaKind ?? 'ebook')
+  const kind = request.value?.mediaKind
+  const fallback = kind && isBookRequestMediaKind(kind) ? instanceDefaultFor(kind) : NO_RESOLVED_REQUEST_DESTINATION
   return fallback.libraryName === null
     ? t('bookRequests.detail.destinationLibraryPlaceholder')
     : t('bookRequests.search.libraryDefault', { library: fallback.libraryName })
@@ -371,6 +431,27 @@ function handleApprove() {
   void approveRequest()
 }
 
+/**
+ * This half with the destination picked here, and its partner with its own: the two media are
+ * often filed into different libraries, so one choice must not be applied to both. The partner is
+ * approved second and reports its own refusal, since this half's approval already stands.
+ */
+async function handleApproveBoth() {
+  const partner = companion.value
+  if (!partner || !(await approveRequest())) return
+
+  const outcome = await actions.approve(partner.id, {})
+  if (!outcome.item) {
+    const localized = localizedRequestActionFailure(outcome)
+    const description = localized ? t(localized.key, localized.params) : outcome.reason
+    const failed =
+      partner.mediaKind === 'audiobook' ? 'bookRequests.errors.approveCompanionFailedAudiobook' : 'bookRequests.errors.approveCompanionFailedEbook'
+    toast.error(t(failed), description ? { description } : undefined)
+    return
+  }
+  companionDetail.setRequest(outcome.item)
+}
+
 /**
  * The decided row stays in the list, so stepping on lands somewhere real. At the end of the queue
  * there is nowhere to go and the drawer stays put rather than closing out from under the approver.
@@ -595,6 +676,8 @@ function dockFileMeta(file: BookDockFile): string {
       </div>
 
       <template v-else-if="request">
+        <RequestPairSwitch v-if="companion" :request="request" :companion="companion" :progress-by-request="progressByRequest" />
+
         <header class="flex items-start gap-4">
           <RequestCover :src="request.coverUrl" :media-kind="request.mediaKind" class="h-[105px] w-[70px] shadow-sm" :icon-size="24" />
 
@@ -615,6 +698,16 @@ function dockFileMeta(file: BookDockFile): string {
                 <Library :size="12" aria-hidden="true" />
                 {{ request.targetLibraryName }}
               </span>
+              <!-- Where the files go matters more than which library, once there is a book to join. -->
+              <RouterLink
+                v-if="joinsBookId !== null"
+                :to="{ name: 'book-detail', params: { bookId: joinsBookId } }"
+                class="inline-flex items-center gap-1 rounded-full border border-border px-2 py-0.5 text-xs text-foreground transition-colors hover:bg-muted focus-visible:ring-2 focus-visible:ring-ring focus-visible:outline-none motion-reduce:transition-none"
+                :title="t('bookRequests.detail.joinsBookHint')"
+              >
+                <BookHeadphones :size="12" aria-hidden="true" />
+                {{ t('bookRequests.detail.joinsBook') }}
+              </RouterLink>
               <Button
                 v-if="request.status === 'available' && request.matchedBookId !== null"
                 as-child
@@ -948,11 +1041,25 @@ function dockFileMeta(file: BookDockFile): string {
     <!-- The action that matters for the stage this request is at, and nothing else. -->
     <footer v-if="request && showFooter" class="flex shrink-0 flex-wrap items-center gap-2 border-t border-border px-4 py-3">
       <template v-if="canDecide">
-        <Button v-if="drawer?.hasNext.value" :disabled="!canApproveNow" @click="handleApproveAndNext">
+        <Button v-if="canApproveBoth" :disabled="!canApproveBoth" @click="handleApproveBoth">
+          <BookHeadphones :size="14" aria-hidden="true" />
+          {{ t('bookRequests.actions.pair.approveBoth') }}
+        </Button>
+        <Button
+          v-if="drawer?.hasNext.value"
+          :variant="canApproveBoth ? 'outline' : 'default'"
+          :disabled="!canApproveNow"
+          @click="handleApproveAndNext"
+        >
           {{ t('bookRequests.actions.approveAndNext') }}
         </Button>
-        <Button :variant="drawer?.hasNext.value ? 'outline' : 'default'" :disabled="!canApproveNow" aria-keyshortcuts="a" @click="handleApprove">
-          {{ t('bookRequests.actions.approve') }}
+        <Button
+          :variant="drawer?.hasNext.value || canApproveBoth ? 'outline' : 'default'"
+          :disabled="!canApproveNow"
+          aria-keyshortcuts="a"
+          @click="handleApprove"
+        >
+          {{ approveLabel }}
         </Button>
         <Button variant="destructive-outline" :disabled="busy" @click="handleReject">{{ t('bookRequests.actions.reject') }}</Button>
       </template>
diff --git a/client/src/features/book-requests/components/RequestListTable.vue b/client/src/features/book-requests/components/RequestListTable.vue
index 8b916763a..9bd0d3c3a 100644
--- a/client/src/features/book-requests/components/RequestListTable.vue
+++ b/client/src/features/book-requests/components/RequestListTable.vue
@@ -1,16 +1,20 @@
 <script setup lang="ts">
 import { computed } from 'vue'
 import { useI18n } from 'vue-i18n'
-import { ArrowDown, ArrowUp, BookOpen, ChevronsUpDown, ExternalLink, EyeOff, Headphones, Images, TriangleAlert, Zap } from '@lucide/vue'
+import { ArrowDown, ArrowUp, ChevronsUpDown, ExternalLink, EyeOff, TriangleAlert, Zap } from '@lucide/vue'
 import { isGrabbableBookRequestStatus } from '@bookorbit/types'
 import type { BookRequestItem, BookRequestProgressEvent, BookRequestSortDirection, BookRequestSortField } from '@bookorbit/types'
 import { formatPercent, formatRelativeFromNow } from '@/i18n/formatters'
 import { formatBytes } from '@/lib/formatting'
 import type { RequestListDensity } from '../composables/useRequestListDensity'
 import { canBulkActRequest } from '../requestActions'
+import { requestMediaColor, requestMediaIcon } from '../requestMedia'
+import { orderedHalves, rowRequests } from '../requestPair'
 import { requestFailureText, requestOutcome } from '../requestOutcome'
 import { currentRequestProgress, requestPresentationStatus } from '../requestPipeline'
 import RequestCover from './RequestCover.vue'
+import RequestPairCover from './RequestPairCover.vue'
+import RequestPairRowActions from './RequestPairRowActions.vue'
 import RequestPipeline from './RequestPipeline.vue'
 import RequestRowActions from './RequestRowActions.vue'
 import RequestStatusBadge from './RequestStatusBadge.vue'
@@ -39,6 +43,12 @@ const emit = defineEmits<{
   restore: [request: BookRequestItem]
   remove: [request: BookRequestItem]
   grab: [request: BookRequestItem]
+  /** One press on a pair row, carrying exactly the halves it applies to. */
+  'pair-approve': [requests: BookRequestItem[]]
+  'pair-reject': [requests: BookRequestItem[]]
+  'pair-cancel': [requests: BookRequestItem[]]
+  'pair-dismiss': [requests: BookRequestItem[]]
+  'pair-restore': [requests: BookRequestItem[]]
   sort: [field: BookRequestSortField]
   'toggle-select': [request: BookRequestItem]
   'toggle-select-all': []
@@ -48,21 +58,12 @@ const { t } = useI18n()
 
 const isCompact = computed(() => props.density === 'compact')
 
-const MEDIA_ICONS = { ebook: BookOpen, audiobook: Headphones, comic: Images } as const
-
-/** Literal classes, because Tailwind reads this file as text and never sees a class built at runtime. */
-const MEDIA_COLORS = {
-  ebook: 'text-[var(--pill-media-ebook)]',
-  audiobook: 'text-[var(--pill-media-audiobook)]',
-  comic: 'text-[var(--pill-media-comic)]',
-} as const
-
 function mediaIcon(request: BookRequestItem) {
-  return MEDIA_ICONS[request.mediaKind] ?? BookOpen
+  return requestMediaIcon(request.mediaKind)
 }
 
 function mediaColor(request: BookRequestItem): string {
-  return MEDIA_COLORS[request.mediaKind] ?? 'text-muted-foreground'
+  return requestMediaColor(request.mediaKind)
 }
 
 /** The icon stands alone in the row, so the medium has to reach assistive tech some other way. */
@@ -131,24 +132,30 @@ function canGrab(request: BookRequestItem): boolean {
 
 /**
  * A row with no destination library is still selectable: the endpoint names it in the failure list,
- * which is more use than a checkbox that silently refuses to tick.
+ * which is more use than a checkbox that silently refuses to tick. A pair row is one checkbox for
+ * whichever of its halves a bulk action can reach.
  */
-function isSelectable(request: BookRequestItem): boolean {
-  return canBulkActRequest(request, props.canManage)
+function selectableHalves(row: BookRequestItem): BookRequestItem[] {
+  return rowRequests(row).filter((request) => canBulkActRequest(request, props.canManage))
 }
 
-function isSelected(request: BookRequestItem): boolean {
-  return props.selectedIds.includes(request.id)
+function isSelectable(row: BookRequestItem): boolean {
+  return selectableHalves(row).length > 0
 }
 
-const selectableIds = computed(() => props.requests.filter(isSelectable).map((request) => request.id))
+function isSelected(row: BookRequestItem): boolean {
+  const halves = selectableHalves(row)
+  return halves.length > 0 && halves.every((request) => props.selectedIds.includes(request.id))
+}
+
+const selectableIds = computed(() => props.requests.flatMap(selectableHalves).map((request) => request.id))
 const hasSelectableRows = computed(() => selectableIds.value.length > 0)
 const allSelected = computed(() => hasSelectableRows.value && selectableIds.value.every((id) => props.selectedIds.includes(id)))
 const someSelected = computed(() => selectableIds.value.some((id) => props.selectedIds.includes(id)))
 
 /** A settled row's actions stay reachable but stop competing with the rows that need a decision. */
 function actionsAreQuiet(request: BookRequestItem): boolean {
-  return !isPending(request) && !canGrab(request)
+  return rowRequests(request).every((half) => !isPending(half) && !canGrab(half))
 }
 
 function ariaSort(field: BookRequestSortField): 'ascending' | 'descending' | 'none' {
@@ -220,6 +227,49 @@ function handleRemove(request: BookRequestItem) {
 function handleGrab(request: BookRequestItem) {
   emit('grab', request)
 }
+
+function handlePairApprove(requests: BookRequestItem[]) {
+  emit('pair-approve', requests)
+}
+
+function handlePairReject(requests: BookRequestItem[]) {
+  emit('pair-reject', requests)
+}
+
+function handlePairCancel(requests: BookRequestItem[]) {
+  emit('pair-cancel', requests)
+}
+
+function handlePairDismiss(requests: BookRequestItem[]) {
+  emit('pair-dismiss', requests)
+}
+
+function handlePairRestore(requests: BookRequestItem[]) {
+  emit('pair-restore', requests)
+}
+
+function isPair(row: BookRequestItem): boolean {
+  return row.companion != null
+}
+
+/** Each half's own art: the ebook's portrait cover and the audiobook's square one. */
+function halfCover(row: BookRequestItem, kind: 'ebook' | 'audiobook'): string | null {
+  return rowRequests(row).find((request) => request.mediaKind === kind)?.coverUrl ?? null
+}
+
+/** The book either half landed as, so a pair that has partly arrived still links somewhere real. */
+function landedBookId(row: BookRequestItem): number | null {
+  return rowRequests(row).find((request) => request.status === 'available' && request.matchedBookId !== null)?.matchedBookId ?? null
+}
+
+/** A pair row is busy while either half has an action in flight. */
+function isRowBusy(row: BookRequestItem): boolean {
+  return rowRequests(row).some((request) => props.busyIds.has(request.id))
+}
+
+function rowDismissed(row: BookRequestItem): boolean {
+  return rowRequests(row).every((request) => request.dismissed)
+}
 </script>
 
 <template>
@@ -319,7 +369,7 @@ function handleGrab(request: BookRequestItem) {
           v-for="request in requests"
           :key="request.id"
           class="border-b border-border/60 hover:bg-muted/40"
-          :class="[isSelected(request) && 'bg-primary/8', request.dismissed && 'opacity-60']"
+          :class="[isSelected(request) && 'bg-primary/8', rowDismissed(request) && 'opacity-60']"
         >
           <td v-if="hasSelectableRows" class="px-3" :class="isCompact ? 'py-1.5' : 'py-2.5'">
             <input
@@ -335,7 +385,15 @@ function handleGrab(request: BookRequestItem) {
           <!-- Auto table layout uses the nowrap title's intrinsic width unless the cell itself is bounded. -->
           <td class="max-w-0 px-3" :class="isCompact ? 'py-1.5' : 'py-2.5'">
             <div class="flex min-w-0 items-center gap-2.5">
+              <RequestPairCover
+                v-if="isPair(request)"
+                :ebook-src="halfCover(request, 'ebook')"
+                :audio-src="halfCover(request, 'audiobook')"
+                :class="isCompact ? 'me-1 h-8 w-[22px]' : 'me-1.5 h-[46px] w-8'"
+                :icon-size="isCompact ? 11 : 14"
+              />
               <RequestCover
+                v-else
                 :src="request.coverUrl"
                 :media-kind="request.mediaKind"
                 :class="isCompact ? 'h-8 w-[22px]' : 'h-[46px] w-8'"
@@ -351,8 +409,8 @@ function handleGrab(request: BookRequestItem) {
                     {{ request.title }}
                   </button>
                   <RouterLink
-                    v-if="request.status === 'available' && request.matchedBookId !== null"
-                    :to="{ name: 'book-detail', params: { bookId: request.matchedBookId } }"
+                    v-if="landedBookId(request) !== null"
+                    :to="{ name: 'book-detail', params: { bookId: landedBookId(request) } }"
                     class="inline-flex shrink-0 rounded-sm text-muted-foreground transition-colors hover:text-foreground focus-visible:ring-2 focus-visible:ring-ring focus-visible:outline-none motion-reduce:transition-none"
                     :title="t('book.actions.bookDetails')"
                   >
@@ -366,7 +424,18 @@ function handleGrab(request: BookRequestItem) {
           </td>
 
           <td class="px-3" :class="isCompact ? 'py-1.5' : 'py-2.5'">
-            <span class="inline-flex" :title="mediaLabel(request)">
+            <span v-if="isPair(request)" class="inline-flex items-center gap-1" :title="t('bookRequests.table.pairMedia')">
+              <component
+                :is="mediaIcon(half)"
+                v-for="half in orderedHalves(request)"
+                :key="half.id"
+                :size="16"
+                :class="mediaColor(half)"
+                aria-hidden="true"
+              />
+              <span class="sr-only">{{ t('bookRequests.table.pairMedia') }}</span>
+            </span>
+            <span v-else class="inline-flex" :title="mediaLabel(request)">
               <component :is="mediaIcon(request)" :size="16" :class="mediaColor(request)" aria-hidden="true" />
               <span class="sr-only">{{ mediaLabel(request) }}</span>
             </span>
@@ -387,7 +456,23 @@ function handleGrab(request: BookRequestItem) {
 
           <!-- Pipeline and State were two columns saying one thing; the stage bar rides the chip. -->
           <td class="px-3" :class="isCompact ? 'py-1.5' : 'py-2.5'">
-            <div class="inline-flex flex-col items-start gap-2">
+            <!--
+              A pair is two lanes, one per half, each on a fixed-height line so the Outcome column's
+              lanes line up beside them. The stage bar is left to the drawer: two of them made every
+              pair row three times the height of the rows around it.
+            -->
+            <div v-if="isPair(request)" class="flex flex-col gap-1">
+              <div v-for="half in orderedHalves(request)" :key="half.id" class="flex h-6 items-center gap-1.5">
+                <component :is="mediaIcon(half)" :size="13" :class="mediaColor(half)" aria-hidden="true" />
+                <span class="sr-only">{{ mediaLabel(half) }}</span>
+                <RequestStatusBadge :status="statusFor(half)" />
+                <span v-if="half.selfServe" class="inline-flex text-muted-foreground" :title="t('bookRequests.selfServeBadgeHint')">
+                  <Zap :size="12" aria-hidden="true" />
+                  <span class="sr-only">{{ t('bookRequests.selfServeBadge') }}</span>
+                </span>
+              </div>
+            </div>
+            <div v-else class="inline-flex flex-col items-start gap-2">
               <!--
                 The self-serve marker rides beside the chip rather than under it. Stacked, it added a
                 line to this cell and left the table ragged: rows carrying it stood 19px taller than
@@ -410,7 +495,36 @@ function handleGrab(request: BookRequestItem) {
           </td>
 
           <td class="px-3 text-xs" :class="isCompact ? 'py-1.5' : 'py-2.5'">
-            <template v-if="outcomeFor(request).kind === 'progress'">
+            <div v-if="isPair(request)" class="flex flex-col gap-1">
+              <div v-for="half in orderedHalves(request)" :key="half.id" class="flex h-6 min-w-0 items-center gap-2">
+                <template v-if="outcomeFor(half).kind === 'progress'">
+                  <div
+                    class="h-1.5 w-full max-w-20 shrink-0 overflow-hidden rounded-full bg-muted"
+                    role="progressbar"
+                    :aria-valuenow="progressFor(half)?.percent ?? 0"
+                    aria-valuemin="0"
+                    aria-valuemax="100"
+                    :aria-label="t('bookRequests.download.progressLabel', { title: `${half.title} (${mediaLabel(half)})` })"
+                  >
+                    <div
+                      class="h-full rounded-full bg-primary transition-[width] duration-500 motion-reduce:transition-none"
+                      :style="{ width: `${progressFor(half)?.percent ?? 0}%` }"
+                    />
+                  </div>
+                  <span class="text-muted-foreground tabular-nums">{{ percentLabel(half) }}</span>
+                </template>
+                <span v-else-if="isFailure(half)" class="truncate text-destructive" :title="failureFor(half) ?? undefined">
+                  {{ failureFor(half) ?? t('bookRequests.outcome.failedUnknown') }}
+                </span>
+                <span v-else-if="failureFor(half)" class="truncate text-muted-foreground" :title="failureFor(half) ?? undefined">
+                  {{ failureFor(half) }}
+                </span>
+                <span v-else class="truncate text-muted-foreground">
+                  {{ t(`bookRequests.outcome.${outcomeFor(half).key}`, outcomeFor(half).params ?? {}) }}
+                </span>
+              </div>
+            </div>
+            <template v-else-if="outcomeFor(request).kind === 'progress'">
               <div
                 class="h-1.5 w-full max-w-24 overflow-hidden rounded-full bg-muted"
                 role="progressbar"
@@ -455,7 +569,23 @@ function handleGrab(request: BookRequestItem) {
                 actionsAreQuiet(request) && 'opacity-60 transition-opacity focus-within:opacity-100 hover:opacity-100 motion-reduce:transition-none'
               "
             >
+              <RequestPairRowActions
+                v-if="isPair(request)"
+                :row="request"
+                :can-manage="canManage"
+                :can-self-fulfil="canSelfFulfil"
+                :current-user-id="currentUserId"
+                :busy="isRowBusy(request)"
+                @open="handleOpen"
+                @grab="handleGrab"
+                @approve="handlePairApprove"
+                @reject="handlePairReject"
+                @cancel="handlePairCancel"
+                @dismiss="handlePairDismiss"
+                @restore="handlePairRestore"
+              />
               <RequestRowActions
+                v-else
                 :request="request"
                 :can-manage="canManage"
                 :can-self-fulfil="canSelfFulfil"
@@ -478,7 +608,7 @@ function handleGrab(request: BookRequestItem) {
 
     <!-- Below `lg` the same rows stack. Same data, same actions, no second component to keep in step. -->
     <ul class="divide-y divide-border/60 lg:hidden">
-      <li v-for="request in requests" :key="request.id" class="p-3" :class="request.dismissed && 'opacity-60'">
+      <li v-for="request in requests" :key="request.id" class="p-3" :class="rowDismissed(request) && 'opacity-60'">
         <div class="flex min-w-0 gap-3">
           <input
             v-if="isSelectable(request)"
@@ -488,7 +618,14 @@ function handleGrab(request: BookRequestItem) {
             :aria-label="t('bookRequests.table.selectRow', { title: request.title })"
             @change="handleToggleSelect(request)"
           />
-          <RequestCover :src="request.coverUrl" :media-kind="request.mediaKind" class="h-[54px] w-9" :icon-size="16" />
+          <RequestPairCover
+            v-if="isPair(request)"
+            :ebook-src="halfCover(request, 'ebook')"
+            :audio-src="halfCover(request, 'audiobook')"
+            class="me-1.5 h-[54px] w-9"
+            :icon-size="16"
+          />
+          <RequestCover v-else :src="request.coverUrl" :media-kind="request.mediaKind" class="h-[54px] w-9" :icon-size="16" />
 
           <div class="min-w-0 flex-1 space-y-1.5">
             <div class="flex min-w-0 items-center gap-2">
@@ -500,8 +637,8 @@ function handleGrab(request: BookRequestItem) {
                 {{ request.title }}
               </button>
               <RouterLink
-                v-if="request.status === 'available' && request.matchedBookId !== null"
-                :to="{ name: 'book-detail', params: { bookId: request.matchedBookId } }"
+                v-if="landedBookId(request) !== null"
+                :to="{ name: 'book-detail', params: { bookId: landedBookId(request) } }"
                 class="inline-flex shrink-0 rounded-sm text-muted-foreground transition-colors hover:text-foreground focus-visible:ring-2 focus-visible:ring-ring focus-visible:outline-none motion-reduce:transition-none"
                 :title="t('book.actions.bookDetails')"
               >
@@ -511,7 +648,27 @@ function handleGrab(request: BookRequestItem) {
             </div>
             <p v-if="authorLine(request)" class="truncate text-xs text-muted-foreground">{{ authorLine(request) }}</p>
 
-            <div class="flex flex-wrap items-center gap-2">
+            <!-- A pair stacks one line per half: the medium, its stage, and what is happening to it. -->
+            <template v-if="isPair(request)">
+              <div v-for="half in orderedHalves(request)" :key="half.id" class="flex min-w-0 flex-wrap items-center gap-2">
+                <component :is="mediaIcon(half)" :size="14" :class="mediaColor(half)" aria-hidden="true" />
+                <span class="sr-only">{{ mediaLabel(half) }}</span>
+                <RequestStatusBadge :status="statusFor(half)" />
+                <span v-if="outcomeFor(half).kind === 'progress'" class="text-xs text-muted-foreground tabular-nums">{{ percentLabel(half) }}</span>
+                <span
+                  v-else-if="failureFor(half)"
+                  class="min-w-0 truncate text-xs"
+                  :class="isFailure(half) ? 'text-destructive' : 'text-muted-foreground'"
+                >
+                  {{ failureFor(half) }}
+                </span>
+              </div>
+              <p class="text-xs text-muted-foreground">
+                {{ t('bookRequests.card.requestedByAt', { name: request.requesterName, time: formatRelativeFromNow(new Date(request.createdAt)) }) }}
+              </p>
+            </template>
+
+            <div v-else class="flex flex-wrap items-center gap-2">
               <RequestStatusBadge :status="statusFor(request)" />
               <span
                 v-if="request.selfServe"
@@ -535,8 +692,9 @@ function handleGrab(request: BookRequestItem) {
               written on it while the row sits at `approved`, and rendering that in alarm red under a
               blue chip says two different things about the same row.
             -->
+            <template v-if="isPair(request)" />
             <p
-              v-if="failureFor(request)"
+              v-else-if="failureFor(request)"
               class="flex items-start gap-1.5 text-xs"
               :class="isFailure(request) ? 'text-destructive' : 'text-muted-foreground'"
             >
@@ -553,7 +711,23 @@ function handleGrab(request: BookRequestItem) {
           </div>
 
           <div class="flex shrink-0 flex-col items-end gap-1.5">
+            <RequestPairRowActions
+              v-if="isPair(request)"
+              :row="request"
+              :can-manage="canManage"
+              :can-self-fulfil="canSelfFulfil"
+              :current-user-id="currentUserId"
+              :busy="isRowBusy(request)"
+              @open="handleOpen"
+              @grab="handleGrab"
+              @approve="handlePairApprove"
+              @reject="handlePairReject"
+              @cancel="handlePairCancel"
+              @dismiss="handlePairDismiss"
+              @restore="handlePairRestore"
+            />
             <RequestRowActions
+              v-else
               :request="request"
               :can-manage="canManage"
               :can-self-fulfil="canSelfFulfil"
diff --git a/client/src/features/book-requests/components/RequestPairCover.vue b/client/src/features/book-requests/components/RequestPairCover.vue
new file mode 100644
index 000000000..09d53a10b
--- /dev/null
+++ b/client/src/features/book-requests/components/RequestPairCover.vue
@@ -0,0 +1,70 @@
+<script setup lang="ts">
+import { computed } from 'vue'
+import { Headphones } from '@lucide/vue'
+import RequestCover from './RequestCover.vue'
+
+/**
+ * Both halves of a pair as one picture: the ebook's portrait cover, with the audiobook's square
+ * art tucked into its lower corner. One glance says "this is both", and each half still shows the
+ * shape it really has, so a square audiobook cover is never cropped into a portrait frame.
+ *
+ * When no audiobook art is known, or it is the same image as the ebook's, the corner carries a
+ * headphones badge instead: the same picture twice says nothing the first one did not.
+ */
+const props = withDefaults(
+  defineProps<{
+    ebookSrc: string | null
+    audioSrc: string | null
+    ebookFallbacks?: string[]
+    audioFallbacks?: string[]
+    sourceKey?: string
+    /** Sizing for the portrait frame lives with the caller, like `RequestCover`. */
+    class?: string
+    iconSize?: number
+  }>(),
+  { ebookFallbacks: () => [], audioFallbacks: () => [], class: '', iconSize: 18 },
+)
+
+const emit = defineEmits<{
+  sourceChange: [payload: { key: string | undefined; src: string | null }]
+}>()
+
+const distinctAudioArt = computed(() => props.audioSrc !== null && props.audioSrc !== props.ebookSrc)
+const insetIconSize = computed(() => Math.max(9, Math.round(props.iconSize * 0.6)))
+
+function handleSourceChange(payload: { key: string | undefined; src: string | null }) {
+  emit('sourceChange', payload)
+}
+</script>
+
+<template>
+  <div class="relative shrink-0" :class="props.class">
+    <RequestCover
+      :src="ebookSrc"
+      :fallback-sources="ebookFallbacks"
+      :source-key="sourceKey"
+      media-kind="ebook"
+      class="h-full w-full"
+      :icon-size="iconSize"
+      @source-change="handleSourceChange"
+    />
+    <!-- The card colour as a ring, so the inset reads as a second object on any cover art. -->
+    <RequestCover
+      v-if="distinctAudioArt"
+      :src="audioSrc"
+      :fallback-sources="audioFallbacks"
+      :source-key="sourceKey === undefined ? undefined : `${sourceKey}|audio`"
+      media-kind="audiobook"
+      class="absolute -end-1.5 -bottom-1.5 aspect-square w-[58%] shadow-sm ring-2 ring-card"
+      :icon-size="insetIconSize"
+      @source-change="handleSourceChange"
+    />
+    <span
+      v-else
+      class="absolute -end-1.5 -bottom-1.5 flex aspect-square w-[46%] items-center justify-center rounded-full border border-border bg-muted text-muted-foreground shadow-sm ring-2 ring-card"
+      aria-hidden="true"
+    >
+      <Headphones :size="insetIconSize" />
+    </span>
+  </div>
+</template>
diff --git a/client/src/features/book-requests/components/RequestPairRowActions.vue b/client/src/features/book-requests/components/RequestPairRowActions.vue
new file mode 100644
index 000000000..4aa9dddd2
--- /dev/null
+++ b/client/src/features/book-requests/components/RequestPairRowActions.vue
@@ -0,0 +1,116 @@
+<script setup lang="ts">
+import { computed } from 'vue'
+import { useI18n } from 'vue-i18n'
+import { Ellipsis } from '@lucide/vue'
+import type { BookRequestItem } from '@bookorbit/types'
+import { Button } from '@/components/ui/button'
+import { DropdownMenu, DropdownMenuContent, DropdownMenuItem, DropdownMenuSeparator, DropdownMenuTrigger } from '@/components/ui/dropdown-menu'
+import { orderedHalves, pairActionKey, pairRowActions } from '../requestPair'
+
+/**
+ * The actions a pair row offers. Every one of them says which half it touches, "both" or the one
+ * medium, because a row holding two requests can no longer let a bare "Approve" stand for either.
+ * Anything that only makes sense for one half at a time - deleting, a release decision, the decision
+ * note - lives in the drawer, which the menu opens on either half.
+ */
+const props = defineProps<{
+  row: BookRequestItem
+  canManage: boolean
+  canSelfFulfil: boolean
+  currentUserId: number | null
+  busy: boolean
+}>()
+
+const emit = defineEmits<{
+  open: [request: BookRequestItem]
+  grab: [request: BookRequestItem]
+  approve: [requests: BookRequestItem[]]
+  reject: [requests: BookRequestItem[]]
+  cancel: [requests: BookRequestItem[]]
+  dismiss: [requests: BookRequestItem[]]
+  restore: [requests: BookRequestItem[]]
+}>()
+
+const { t } = useI18n()
+
+const halves = computed(() => orderedHalves(props.row))
+const actions = computed(() =>
+  pairRowActions(props.row, { userId: props.currentUserId, canManage: props.canManage, canSelfFulfil: props.canSelfFulfil }),
+)
+/** Both halves waiting is one job in the picker, which opens on the e-book and tabs to the other. */
+const grabLabel = computed(() => {
+  if (actions.value.grabHalves.length > 1) return t('bookRequests.actions.pair.chooseReleases')
+  return actions.value.grab?.mediaKind === 'audiobook' ? t('bookRequests.actions.pair.grabAudiobook') : t('bookRequests.actions.pair.grabEbook')
+})
+
+function openLabel(half: BookRequestItem): string {
+  return half.mediaKind === 'audiobook' ? t('bookRequests.actions.pair.openAudiobook') : t('bookRequests.actions.pair.openEbook')
+}
+
+function handleOpenLead() {
+  emit('open', props.row)
+}
+
+function handleOpen(half: BookRequestItem) {
+  emit('open', half)
+}
+
+function handleGrab() {
+  if (actions.value.grab) emit('grab', actions.value.grab)
+}
+
+function handleApprove() {
+  emit('approve', actions.value.approve)
+}
+
+function handleReject() {
+  emit('reject', actions.value.reject)
+}
+
+function handleCancel() {
+  emit('cancel', actions.value.cancel)
+}
+
+function handleDismiss() {
+  emit('dismiss', actions.value.dismiss)
+}
+
+function handleRestore() {
+  emit('restore', actions.value.restore)
+}
+</script>
+
+<template>
+  <Button v-if="actions.approve.length" size="sm" :disabled="busy" @click="handleApprove">
+    {{ t(pairActionKey('approve', actions.approve)) }}
+  </Button>
+  <Button v-else-if="actions.grab && canManage" variant="outline" size="sm" :disabled="busy" @click="handleGrab">{{ grabLabel }}</Button>
+  <Button v-else variant="outline" size="sm" @click="handleOpenLead">{{ t('bookRequests.card.details') }}</Button>
+
+  <DropdownMenu>
+    <DropdownMenuTrigger as-child>
+      <Button variant="ghost" size="icon-sm" :aria-label="t('bookRequests.card.moreActions', { title: row.title })">
+        <Ellipsis :size="15" aria-hidden="true" />
+      </Button>
+    </DropdownMenuTrigger>
+    <DropdownMenuContent align="end">
+      <DropdownMenuItem v-for="half in halves" :key="half.id" @click="handleOpen(half)">{{ openLabel(half) }}</DropdownMenuItem>
+      <DropdownMenuSeparator />
+      <DropdownMenuItem v-if="actions.reject.length" :disabled="busy" @click="handleReject">
+        {{ t(pairActionKey('reject', actions.reject)) }}
+      </DropdownMenuItem>
+      <DropdownMenuItem v-if="actions.grab && canManage && actions.approve.length" :disabled="busy" @click="handleGrab">
+        {{ grabLabel }}
+      </DropdownMenuItem>
+      <DropdownMenuItem v-if="actions.dismiss.length" :disabled="busy" @click="handleDismiss">
+        {{ t(pairActionKey('dismiss', actions.dismiss)) }}
+      </DropdownMenuItem>
+      <DropdownMenuItem v-if="actions.restore.length" :disabled="busy" @click="handleRestore">
+        {{ t(pairActionKey('restore', actions.restore)) }}
+      </DropdownMenuItem>
+      <DropdownMenuItem v-if="actions.cancel.length" variant="destructive" :disabled="busy" @click="handleCancel">
+        {{ t(pairActionKey('cancel', actions.cancel)) }}
+      </DropdownMenuItem>
+    </DropdownMenuContent>
+  </DropdownMenu>
+</template>
diff --git a/client/src/features/book-requests/components/RequestPairSwitch.vue b/client/src/features/book-requests/components/RequestPairSwitch.vue
new file mode 100644
index 000000000..5cd177b4a
--- /dev/null
+++ b/client/src/features/book-requests/components/RequestPairSwitch.vue
@@ -0,0 +1,59 @@
+<script setup lang="ts">
+import { computed } from 'vue'
+import { useI18n } from 'vue-i18n'
+import { useRoute } from 'vue-router'
+import { BookOpen, Headphones } from '@lucide/vue'
+import type { BookRequestItem, BookRequestProgressEvent } from '@bookorbit/types'
+import { orderedHalves } from '../requestPair'
+import { currentRequestProgress, requestPresentationStatus } from '../requestPipeline'
+import RequestStatusBadge from './RequestStatusBadge.vue'
+
+/**
+ * The two halves of a pair, side by side at the top of the drawer, each a link to its own request.
+ *
+ * Links rather than tabs: each half is its own page with its own URL, so a half can be linked to
+ * and hard-loaded, and the browser's back button steps between them the way it steps through the
+ * queue. The current half is marked for assistive technology as the current page.
+ */
+const props = defineProps<{
+  request: BookRequestItem
+  companion: BookRequestItem
+  progressByRequest: Record<number, BookRequestProgressEvent | undefined>
+}>()
+
+const { t } = useI18n()
+const route = useRoute()
+
+const halves = computed(() => orderedHalves({ ...props.request, companion: props.companion }))
+
+function iconFor(half: BookRequestItem) {
+  return half.mediaKind === 'audiobook' ? Headphones : BookOpen
+}
+
+function statusFor(half: BookRequestItem): BookRequestItem['status'] {
+  return requestPresentationStatus(half, currentRequestProgress(half, props.progressByRequest[half.id]))
+}
+
+function isCurrent(half: BookRequestItem): boolean {
+  return half.id === props.request.id
+}
+</script>
+
+<template>
+  <nav class="mb-4 grid grid-cols-2 gap-1 rounded-lg border border-border bg-muted p-1" :aria-label="t('bookRequests.detail.pairSwitchLabel')">
+    <RouterLink
+      v-for="half in halves"
+      :key="half.id"
+      :to="{ name: 'book-request-detail', params: { id: half.id }, query: route.query }"
+      :aria-current="isCurrent(half) ? 'page' : undefined"
+      class="flex min-w-0 flex-wrap items-center gap-x-2 gap-y-1 rounded-md px-2.5 py-2 text-sm font-medium transition-colors focus-visible:ring-2 focus-visible:ring-ring focus-visible:outline-none motion-reduce:transition-none"
+      :class="
+        isCurrent(half) ? 'bg-background text-foreground shadow-xs' : 'text-muted-foreground hover:text-foreground focus-visible:text-foreground'
+      "
+    >
+      <component :is="iconFor(half)" :size="14" class="shrink-0" aria-hidden="true" />
+      <span class="truncate">{{ t(`bookRequests.mediaKind.${half.mediaKind}`) }}</span>
+      <RequestStatusBadge :status="statusFor(half)" class="ms-auto" />
+    </RouterLink>
+  </nav>
+</template>
diff --git a/client/src/features/book-requests/components/RequestSearchPanel.vue b/client/src/features/book-requests/components/RequestSearchPanel.vue
index a6c6b6068..2db1ece5c 100644
--- a/client/src/features/book-requests/components/RequestSearchPanel.vue
+++ b/client/src/features/book-requests/components/RequestSearchPanel.vue
@@ -3,12 +3,12 @@ import { computed, onMounted, onUnmounted, ref, watch } from 'vue'
 import { useI18n } from 'vue-i18n'
 import { useRoute, useRouter, type LocationQuery } from 'vue-router'
 import {
+  BookHeadphones,
   BookOpen,
   Check,
   ChevronDown,
   CircleHelp,
   Headphones,
-  Images,
   Library,
   Loader2,
   Pin,
@@ -21,7 +21,6 @@ import {
   AUDIO_FORMAT_LIST,
   BOOK_REQUEST_MEDIA_KINDS,
   canonicalizeBookRequestIsbn,
-  COMIC_FORMAT_LIST,
   EBOOK_FORMAT_LIST,
   isBookRequestFulfiller,
   isGrabbableBookRequestStatus,
@@ -31,6 +30,7 @@ import {
 import type {
   BookRequestMediaKind,
   BookRequestMetadataSource,
+  BookRequestPairSubmitResult,
   BookRequestSubmitResult,
   MetadataCandidate,
   MetadataProviderKey,
@@ -57,6 +57,9 @@ import { formatLanguageName } from '@/i18n/formatters'
 import { requestLanguageOptions, useRequestDestinationDefault, useRequestLanguageDefault } from '../composables/useRequestDestinationDefault'
 import { submitFailureText, useRequestSubmission } from '../composables/useRequestSubmission'
 import RequestCover from './RequestCover.vue'
+import RequestPairCover from './RequestPairCover.vue'
+import { requestMediaIcon } from '../requestMedia'
+import { pairHalfState, pairSubmission, pairSubmissionLabelKey, type PairHalfState, type PairSubmission } from '../requestPair'
 
 const emit = defineEmits<{ submitted: [] }>()
 
@@ -78,7 +81,20 @@ const { hasPermission } = usePermissions()
 const { user } = useAuth()
 const router = useRouter()
 const route = useRoute()
-const { lastFailure, submitting, mediaKind, annotate, getAvailability, submit, submitFreeText, checkFreeText, candidateKey } = useRequestSubmission()
+const {
+  lastFailure,
+  submitting,
+  mediaKind,
+  pairMode,
+  annotate,
+  getAvailability,
+  submit,
+  submitPair,
+  submitFreeText,
+  submitPairFreeText,
+  checkFreeText,
+  candidateKey,
+} = useRequestSubmission()
 const { load: loadDefaultDestination, defaultFor: instanceDefaultFor, resolveDestination } = useRequestDestinationDefault()
 const {
   defaultLanguage,
@@ -88,7 +104,10 @@ const {
   resolveLanguage,
 } = useRequestLanguageDefault()
 
-const MEDIA_ICONS = { ebook: BookOpen, audiobook: Headphones, comic: Images } as const
+/** What the toggle offers: each medium on its own, then both together beside the two it combines. */
+type SearchChoice = BookRequestMediaKind | 'pair'
+const SEARCH_CHOICES: readonly SearchChoice[] = [...BOOK_REQUEST_MEDIA_KINDS, 'pair']
+const searchChoice = computed<SearchChoice>(() => (pairMode.value ? 'pair' : mediaKind.value))
 
 /**
  * What each medium may be asked for, taken from the shared lists rather than restated here, so the
@@ -97,7 +116,6 @@ const MEDIA_ICONS = { ebook: BookOpen, audiobook: Headphones, comic: Images } as
 const FORMATS_BY_MEDIA: Record<BookRequestMediaKind, readonly string[]> = {
   ebook: EBOOK_FORMAT_LIST,
   audiobook: AUDIO_FORMAT_LIST,
-  comic: COMIC_FORMAT_LIST,
 }
 
 const title = ref('')
@@ -108,17 +126,27 @@ const language = ref<string | null>(null)
  * Kept per medium, because "epub" means nothing to an audiobook search and clearing the whole set
  * on every media-kind press would throw away a choice the requester had just made.
  */
-const preferredFormats = ref<Record<BookRequestMediaKind, string[]>>({ ebook: [], audiobook: [], comic: [] })
+const preferredFormats = ref<Record<BookRequestMediaKind, string[]>>({ ebook: [], audiobook: [] })
 const note = ref('')
 const optionsOpen = ref(false)
 const targetLibraryId = ref<number | null>(null)
 const targetFolderId = ref<number | null>(null)
+/**
+ * Where the audiobook half of a pair lands. The ebook half keeps the select a single request uses,
+ * and this one starts on the audiobook's own instance default, since the two media are often filed
+ * into different libraries.
+ */
+const audioTargetLibraryId = ref<number | null>(null)
+const audioTargetFolderId = ref<number | null>(null)
 const activeCoverUrls = ref<Record<string, string | null>>({})
 const failedProviderIcons = ref(new Set<MetadataProviderKey>())
 const expandedMetadataGroups = ref(new Set<string>())
 // 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)
+const { groups } = useCandidateGroups(filteredResults, mediaKind, getAvailability, requestCoverProviderOrder, language, resultProviderOrder, {
+  enabled: pairMode,
+  audioCoverProviderOrder,
+})
 
 // Nobody approves these requests afterwards, so this is the only chance to say where the book goes.
 const autoApproves = computed(() => hasPermission(Permission.BookRequestAutoApprove))
@@ -135,6 +163,7 @@ const choosesRelease = computed(() => selfFulfils.value && (!autoApproves.value
 const settlesOnCreate = computed(() => autoApproves.value || selfFulfils.value)
 const selectedLibrary = computed(() => libraries.value.find((library) => library.id === targetLibraryId.value) ?? null)
 const folders = computed(() => selectedLibrary.value?.folders ?? [])
+const audioFolders = computed(() => libraries.value.find((library) => library.id === audioTargetLibraryId.value)?.folders ?? [])
 const showDestination = computed(() => settlesOnCreate.value || libraries.value.length > 1)
 /**
  * Nowhere for the book to go, which for an auto-approving requester is fatal: nobody decides on
@@ -148,17 +177,52 @@ const destinationMissing = computed(
   () => settlesOnCreate.value && targetLibraryId.value === null && instanceDefaultFor(mediaKind.value).libraryId === null,
 )
 
+/** The library each half of a pair lands in: the one picked, or the instance default for its medium. */
+function pairLibraryId(kind: BookRequestMediaKind): number | null {
+  const picked = kind === 'ebook' ? targetLibraryId.value : audioTargetLibraryId.value
+  return picked ?? instanceDefaultFor(kind).libraryId
+}
+
+function pairDestinationMissing(kind: BookRequestMediaKind): boolean {
+  return settlesOnCreate.value && pairLibraryId(kind) === null
+}
+
+const pairDestinationsMissing = computed(() => pairMode.value && BOOK_REQUEST_MEDIA_KINDS.some(pairDestinationMissing))
+/** The indexer fallback creates whatever the toggle is on, so it needs every destination that will create. */
+const freeTextDestinationMissing = computed(() => (pairMode.value ? pairDestinationsMissing.value : destinationMissing.value))
+
+/**
+ * What the two destinations add up to, said before anything is submitted: one book holding both
+ * formats, two books in one library that keeps a book per file, or two libraries.
+ */
+const pairLandingHint = computed(() => {
+  if (!pairMode.value) return null
+  const ebookLibraryId = pairLibraryId('ebook')
+  const audioLibraryId = pairLibraryId('audiobook')
+  if (ebookLibraryId === null || audioLibraryId === null) return null
+  if (ebookLibraryId !== audioLibraryId) return t('bookRequests.search.pair.landsApart')
+
+  const library = libraries.value.find((candidate) => candidate.id === ebookLibraryId)
+  const name = library?.name ?? instanceDefaultFor('ebook').libraryName ?? ''
+  return library?.organizationMode === 'book_per_file'
+    ? t('bookRequests.search.pair.landsSeparately', { library: name })
+    : t('bookRequests.search.pair.landsTogether', { library: name })
+})
+
 const canSearch = computed(() => title.value.trim() !== '' || author.value.trim() !== '')
 
 /**
  * What "no library chosen" actually means for this medium. The instance default is applied by the
  * server, so without naming it here the requester submits with no idea where the book lands.
  */
-const unpickedDestinationLabel = computed(() => {
-  const fallback = instanceDefaultFor(mediaKind.value)
+const unpickedDestinationLabel = computed(() => unpickedLabelFor(mediaKind.value))
+const unpickedAudioDestinationLabel = computed(() => unpickedLabelFor('audiobook'))
+
+function unpickedLabelFor(kind: BookRequestMediaKind): string {
+  const fallback = instanceDefaultFor(kind)
   if (fallback.libraryName !== null) return t('bookRequests.search.libraryDefault', { library: fallback.libraryName })
   return settlesOnCreate.value ? t('bookRequests.search.libraryChoose') : t('bookRequests.search.libraryAny')
-})
+}
 
 const isLanguagePinned = computed(() => language.value !== null && defaultLanguage.value === language.value)
 
@@ -171,6 +235,7 @@ onMounted(async () => {
   language.value = resolveLanguage(locale.value)
   // One library is only worth preselecting for the requester who is also the approver.
   targetLibraryId.value = resolveDestination(libraries.value, undefined, settlesOnCreate.value).libraryId
+  audioTargetLibraryId.value = resolveDestination(libraries.value, undefined, settlesOnCreate.value).libraryId
 })
 
 // A folder only means anything inside its own library, so it never outlives the library choice.
@@ -178,6 +243,10 @@ watch(targetLibraryId, () => {
   targetFolderId.value = folders.value[0]?.id ?? null
 })
 
+watch(audioTargetLibraryId, () => {
+  audioTargetFolderId.value = audioFolders.value[0]?.id ?? null
+})
+
 // Results stream in provider by provider, so annotate as they land rather than once at the end.
 watch(filteredResults, (results) => {
   if (results.length) annotate(results)
@@ -189,7 +258,7 @@ async function runSearch() {
   await search({
     title: title.value.trim() || undefined,
     author: author.value.trim() || undefined,
-    mediaKind: mediaKind.value,
+    ...(pairMode.value ? { mediaKinds: [...BOOK_REQUEST_MEDIA_KINDS] } : { mediaKind: mediaKind.value }),
   })
 }
 
@@ -198,11 +267,20 @@ function handleSearchSubmit(event: Event) {
   void runSearch()
 }
 
-function selectMediaKind(kind: BookRequestMediaKind) {
-  mediaKind.value = kind
+function selectSearchChoice(choice: SearchChoice) {
+  pairMode.value = choice === 'pair'
+  mediaKind.value = choice === 'pair' ? 'ebook' : choice
   if (hasSearched.value) void runSearch()
 }
 
+function choiceLabel(choice: SearchChoice): string {
+  return choice === 'pair' ? t('bookRequests.search.pair.choice') : t(`bookRequests.mediaKind.${choice}`)
+}
+
+function choiceIcon(choice: SearchChoice) {
+  return choice === 'pair' ? BookHeadphones : mediaIconFor(choice)
+}
+
 function selectAutomaticFulfillment() {
   fulfillmentMode.value = 'automatic'
 }
@@ -232,12 +310,13 @@ async function toggleLanguageDefault() {
   )
 }
 
-const mediaFormats = computed(() => FORMATS_BY_MEDIA[mediaKind.value])
 const activeFormats = computed(() => preferredFormats.value[mediaKind.value])
+/** The media whose format preferences the options panel offers: one, or both halves of a pair. */
+const formatKinds = computed<BookRequestMediaKind[]>(() => (pairMode.value ? [...BOOK_REQUEST_MEDIA_KINDS] : [mediaKind.value]))
 
 /** What the collapsed row has to say for itself, so a set preference is never silently hidden. */
 const optionsSummary = computed(() => {
-  const formats = activeFormats.value
+  const formats = formatKinds.value.flatMap((kind) => preferredFormats.value[kind])
   const hasNote = note.value.trim() !== ''
   if (formats.length === 0 && !hasNote) return null
   if (formats.length === 0) return t('bookRequests.search.noteLabel')
@@ -245,14 +324,23 @@ const optionsSummary = computed(() => {
   return hasNote ? t('bookRequests.search.optionsSummary', { formats: listed }) : listed
 })
 
-function isPreferredFormat(format: string): boolean {
-  return activeFormats.value.includes(format)
+function formatsFor(kind: BookRequestMediaKind): readonly string[] {
+  return FORMATS_BY_MEDIA[kind]
 }
 
-function togglePreferredFormat(format: string) {
-  const current = activeFormats.value
+function formatLegend(kind: BookRequestMediaKind): string {
+  if (!pairMode.value) return t('bookRequests.search.preferredFormatsLabel')
+  return kind === 'audiobook' ? t('bookRequests.search.pair.preferredAudiobookFormats') : t('bookRequests.search.pair.preferredEbookFormats')
+}
+
+function isPreferredFormat(format: string, kind: BookRequestMediaKind): boolean {
+  return preferredFormats.value[kind].includes(format)
+}
+
+function togglePreferredFormat(format: string, kind: BookRequestMediaKind) {
+  const current = preferredFormats.value[kind]
   const next = current.includes(format) ? current.filter((value) => value !== format) : [...current, format]
-  preferredFormats.value = { ...preferredFormats.value, [mediaKind.value]: next }
+  preferredFormats.value = { ...preferredFormats.value, [kind]: next }
 }
 
 function toggleOptions() {
@@ -274,6 +362,16 @@ function handleFolderChange(event: Event) {
   targetFolderId.value = value === '' ? null : Number(value)
 }
 
+function handleAudioLibraryChange(event: Event) {
+  const value = (event.target as HTMLSelectElement).value
+  audioTargetLibraryId.value = value === '' ? null : Number(value)
+}
+
+function handleAudioFolderChange(event: Event) {
+  const value = (event.target as HTMLSelectElement).value
+  audioTargetFolderId.value = value === '' ? null : Number(value)
+}
+
 const providerLabels = computed(() => new Map(providers.value.map((provider) => [provider.key, provider.label])))
 
 /** A provider that never answered leaves a shorter list, which otherwise reads as a thin catalogue. */
@@ -409,6 +507,57 @@ function isJoinable(group: CandidateGroup): boolean {
   return Boolean(group.availability?.existingRequestId) && !group.availability?.alreadySubscribed
 }
 
+const pairLabelMode = computed<'request' | 'get' | 'choose'>(() => (choosesRelease.value ? 'choose' : autoApproves.value ? 'get' : 'request'))
+
+/** Nothing is known yet for a half the annotation has not answered, which reads as not asked for. */
+function pairAvailabilityOf(group: CandidateGroup) {
+  return group.pairAvailability ?? { ebook: null, audiobook: null }
+}
+
+function pairPlan(group: CandidateGroup): PairSubmission {
+  return pairSubmission(pairAvailabilityOf(group))
+}
+
+function pairState(group: CandidateGroup, kind: BookRequestMediaKind): PairHalfState {
+  return pairHalfState(pairAvailabilityOf(group)[kind])
+}
+
+function pairRequestLabel(group: CandidateGroup): string {
+  return t(pairSubmissionLabelKey(pairPlan(group), pairAvailabilityOf(group), pairLabelMode.value))
+}
+
+/**
+ * Joining needs no destination, and nor does a format aimed at a copy already on the shelf, which
+ * lands beside it. Everything else needs one for each half it creates.
+ */
+function isPairRequestDisabled(group: CandidateGroup): boolean {
+  if (isGroupSubmitting(group)) return true
+  const plan = pairPlan(group)
+  if (plan.kind === 'none') return true
+  if (plan.kind === 'single') return plan.joinBookId === null && plan.state === 'new' && pairDestinationMissing(plan.mediaKind)
+  return plan.actionable.some((kind) => pairState(group, kind) === 'new' && pairDestinationMissing(kind))
+}
+
+/** A joined request reads as such, which is the only part of a half's state worth a colour. */
+const PAIR_STATE_CLASSES: Record<PairHalfState, string> = {
+  owned: 'border-success/40 bg-success/10 text-success',
+  following: 'border-info/40 bg-info/10 text-info',
+  joinable: 'border-info/40 bg-info/10 text-info',
+  new: 'border-border bg-background text-muted-foreground',
+}
+
+function pairStateClass(group: CandidateGroup, kind: BookRequestMediaKind): string {
+  return PAIR_STATE_CLASSES[pairState(group, kind)]
+}
+
+function pairStateLabel(group: CandidateGroup, kind: BookRequestMediaKind): string {
+  return t(`bookRequests.search.pair.state.${pairState(group, kind)}`)
+}
+
+function pairMediumLabel(kind: BookRequestMediaKind): string {
+  return t(`bookRequests.mediaKind.${kind}`)
+}
+
 /**
  * Only once a provider search has come back empty, and only for somebody who will pick the release
  * themselves. An approver handed a row that says nothing but a typed string has no way to tell
@@ -495,6 +644,19 @@ function releasesQuery(searchIsbn?: string | null): LocationQuery {
 async function startFreeTextSearch() {
   freeTextBusy.value = true
   try {
+    if (pairMode.value) {
+      const pair = await submitPairFreeText(
+        { title: title.value, author: author.value },
+        { language: language.value, selfServe: true, note: note.value.trim() || null, ...pairHalves() },
+      )
+      if (!pair) {
+        toast.error(submitFailureText(lastFailure.value, t) ?? t('bookRequests.search.submitFailed'))
+        return
+      }
+      await afterPairSubmit(pair, true)
+      return
+    }
+
     const result = await submitFreeText(
       { title: title.value, author: author.value },
       {
@@ -550,13 +712,116 @@ async function requestGroupChoice(group: CandidateGroup, candidate: MetadataCand
   await afterSubmit(result, openPicker, isbn)
 }
 
+/** Where each half of a pair lands and what it prefers, read off the two halves of the form. */
+function pairHalves(group?: CandidateGroup) {
+  return {
+    ebook: {
+      targetLibraryId: targetLibraryId.value,
+      targetFolderId: targetFolderId.value,
+      preferredFormats: [...preferredFormats.value.ebook],
+      ...(group ? { coverUrl: shownCover(group) } : {}),
+    },
+    audiobook: {
+      targetLibraryId: audioTargetLibraryId.value,
+      targetFolderId: audioTargetFolderId.value,
+      preferredFormats: [...preferredFormats.value.audiobook],
+      ...(group ? { coverUrl: shownAudioCover(group) } : {}),
+    },
+  }
+}
+
+/** The cover the requester is actually looking at, which is not always the first one offered. */
+function shownCover(group: CandidateGroup): string | null {
+  return Object.prototype.hasOwnProperty.call(activeCoverUrls.value, group.key) ? (activeCoverUrls.value[group.key] ?? null) : group.coverUrl
+}
+
+function shownAudioCover(group: CandidateGroup): string | null {
+  const key = `${group.key}|audio`
+  return Object.prototype.hasOwnProperty.call(activeCoverUrls.value, key) ? (activeCoverUrls.value[key] ?? null) : (group.audioCoverUrls[0] ?? null)
+}
+
+/**
+ * A "both" press, sent the way its availability says it should be: as a pair, or as the one
+ * format still missing, aimed at the copy already on the shelf so it joins it.
+ */
+async function requestPairGroup(group: CandidateGroup): Promise<void> {
+  const plan = pairPlan(group)
+  if (plan.kind === 'none') return
+
+  const choice = recommendedSearchChoice(group)
+  const candidate = choice?.candidate ?? group.candidate
+  const isbn = choice?.isbn ?? null
+  const openPicker = choosesRelease.value
+  const work = {
+    language: language.value,
+    selfServe: openPicker,
+    isbn10: null,
+    isbn13: isbn,
+    providerKey: candidate.provider,
+    providerId: candidate.providerId,
+    metadataSources: requestMetadataSources(group),
+    note: note.value.trim() || null,
+  }
+
+  if (plan.kind === 'single') {
+    const half = pairHalves(group)[plan.mediaKind]
+    const result = await submit(candidate, { ...work, ...half, mediaKind: plan.mediaKind, targetBookId: plan.joinBookId })
+    if (!result) {
+      toast.error(submitFailureText(lastFailure.value, t) ?? t('bookRequests.search.submitFailed'))
+      return
+    }
+    if (plan.joinBookId !== null && !result.subscribed && !openPicker) {
+      toast.success(t('bookRequests.search.pair.submittedJoinsBook'))
+      emit('submitted')
+      return
+    }
+    await afterSubmit(result, openPicker, isbn)
+    return
+  }
+
+  const result = await submitPair(candidate, { ...work, coverUrl: shownCover(group), ...pairHalves(group) })
+  if (!result) {
+    toast.error(submitFailureText(lastFailure.value, t) ?? t('bookRequests.search.submitFailed'))
+    return
+  }
+  await afterPairSubmit(result, openPicker, isbn)
+}
+
+/**
+ * Where a submitted pair leaves you. Somebody choosing their own releases goes straight to the
+ * picker for the first half they can drive, whose tabs then carry them to the other.
+ */
+async function afterPairSubmit(result: BookRequestPairSubmitResult, openPicker: boolean, searchIsbn?: string | null): Promise<void> {
+  const halves = BOOK_REQUEST_MEDIA_KINDS.map((kind) => result[kind])
+  if (openPicker) {
+    const drivable = halves.filter(
+      (half) => isBookRequestFulfiller(half.request, user.value?.id) && isGrabbableBookRequestStatus(half.request.status),
+    )
+    const first = drivable[0]
+    if (first) {
+      await router.push({ name: 'book-request-releases', params: { id: first.request.id }, query: releasesQuery(searchIsbn) })
+      return
+    }
+  }
+
+  const joined = halves.filter((half) => half.subscribed).length
+  toast.success(
+    joined === halves.length
+      ? t('bookRequests.search.joinedExisting')
+      : joined > 0
+        ? t('bookRequests.search.pair.submittedPartlyJoined')
+        : t('bookRequests.search.pair.submitted'),
+  )
+  emit('submitted')
+}
+
 function handleCoverSourceChange(payload: { key: string | undefined; src: string | null }) {
   if (!payload.key) return
   activeCoverUrls.value = { ...activeCoverUrls.value, [payload.key]: payload.src }
 }
 
 function mediaIconFor(kind: BookRequestMediaKind) {
-  return MEDIA_ICONS[kind] ?? BookOpen
+  return requestMediaIcon(kind)
 }
 </script>
 
@@ -605,20 +870,21 @@ function mediaIconFor(kind: BookRequestMediaKind) {
         </div>
 
         <div class="flex flex-wrap items-center gap-x-3.5 gap-y-2.5 border-t border-border bg-muted px-3 py-2.5">
-          <!-- A real track, so three buttons read as one control rather than as loose links. -->
-          <fieldset class="inline-flex h-9 items-center gap-0.5 rounded-lg border border-border bg-card p-[3px]">
+          <!-- A real track, so the choices read as one control rather than as loose links. -->
+          <fieldset class="inline-flex h-9 max-w-full items-center gap-0.5 overflow-x-auto rounded-lg border border-border bg-card p-[3px]">
             <legend class="sr-only">{{ t('bookRequests.search.mediaKindLabel') }}</legend>
             <button
-              v-for="kind in BOOK_REQUEST_MEDIA_KINDS"
-              :key="kind"
+              v-for="choice in SEARCH_CHOICES"
+              :key="choice"
               type="button"
-              class="inline-flex h-full items-center gap-1.5 rounded-md px-2.5 text-xs font-medium transition-colors focus-visible:ring-2 focus-visible:ring-ring focus-visible:outline-none motion-reduce:transition-none"
-              :class="mediaKind === kind ? 'bg-primary text-primary-foreground shadow-sm' : 'text-foreground hover:bg-accent'"
-              :aria-pressed="mediaKind === kind"
-              @click="selectMediaKind(kind)"
+              class="inline-flex h-full shrink-0 items-center gap-1.5 rounded-md px-2.5 text-xs font-medium whitespace-nowrap transition-colors focus-visible:ring-2 focus-visible:ring-ring focus-visible:outline-none motion-reduce:transition-none"
+              :class="searchChoice === choice ? 'bg-primary text-primary-foreground shadow-sm' : 'text-foreground hover:bg-accent'"
+              :aria-pressed="searchChoice === choice"
+              :title="choice === 'pair' ? t('bookRequests.search.pair.choiceHint') : undefined"
+              @click="selectSearchChoice(choice)"
             >
-              <component :is="mediaIconFor(kind)" :size="13" aria-hidden="true" />
-              {{ t(`bookRequests.mediaKind.${kind}`) }}
+              <component :is="choiceIcon(choice)" :size="13" aria-hidden="true" />
+              {{ choiceLabel(choice) }}
             </button>
           </fieldset>
 
@@ -649,7 +915,11 @@ function mediaIconFor(kind: BookRequestMediaKind) {
 
           <template v-if="showDestination">
             <div class="flex w-full items-center gap-1.5 sm:w-auto">
-              <label for="request-library" class="sr-only">{{ t('bookRequests.search.libraryLabel') }}</label>
+              <!-- In a pair each select is one medium's, so the medium is said beside it, not only to a screen reader. -->
+              <BookOpen v-if="pairMode" :size="14" class="shrink-0 text-muted-foreground" aria-hidden="true" />
+              <label for="request-library" class="sr-only">
+                {{ pairMode ? t('bookRequests.search.pair.ebookLibraryLabel') : t('bookRequests.search.libraryLabel') }}
+              </label>
               <select
                 id="request-library"
                 :value="targetLibraryId ?? ''"
@@ -674,6 +944,34 @@ function mediaIconFor(kind: BookRequestMediaKind) {
                 <option v-for="folder in folders" :key="folder.id" :value="folder.id">{{ folder.path }}</option>
               </select>
             </template>
+
+            <template v-if="pairMode">
+              <div class="flex w-full items-center gap-1.5 sm:w-auto">
+                <Headphones :size="14" class="shrink-0 text-muted-foreground" aria-hidden="true" />
+                <label for="request-audio-library" class="sr-only">{{ t('bookRequests.search.pair.audiobookLibraryLabel') }}</label>
+                <select
+                  id="request-audio-library"
+                  :value="audioTargetLibraryId ?? ''"
+                  class="h-9 min-w-0 flex-1 rounded-md border border-input bg-card px-3 text-sm text-foreground focus-visible:border-ring focus-visible:ring-[3px] focus-visible:ring-ring/50 focus-visible:outline-none sm:max-w-[15rem] sm:min-w-[11rem] sm:flex-none"
+                  @change="handleAudioLibraryChange"
+                >
+                  <option value="">{{ unpickedAudioDestinationLabel }}</option>
+                  <option v-for="library in libraries" :key="library.id" :value="library.id">{{ library.name }}</option>
+                </select>
+              </div>
+
+              <template v-if="settlesOnCreate && audioFolders.length > 1">
+                <label for="request-audio-folder" class="sr-only">{{ t('bookRequests.search.pair.audiobookFolderLabel') }}</label>
+                <select
+                  id="request-audio-folder"
+                  :value="audioTargetFolderId ?? ''"
+                  class="h-9 w-full rounded-md border border-input bg-card px-3 text-sm text-foreground focus-visible:border-ring focus-visible:ring-[3px] focus-visible:ring-ring/50 focus-visible:outline-none sm:w-auto sm:max-w-[15rem] sm:min-w-[11rem]"
+                  @change="handleAudioFolderChange"
+                >
+                  <option v-for="folder in audioFolders" :key="folder.id" :value="folder.id">{{ folder.path }}</option>
+                </select>
+              </template>
+            </template>
           </template>
 
           <!-- Always offered, unlike the destination: the language decides what gets grabbed. -->
@@ -726,7 +1024,7 @@ function mediaIconFor(kind: BookRequestMediaKind) {
             v-if="showManualSearchOverride"
             type="button"
             class="inline-flex h-9 items-center gap-1.5 rounded-md px-2 text-xs font-medium text-muted-foreground transition-colors hover:text-foreground focus-visible:text-foreground focus-visible:ring-2 focus-visible:ring-ring focus-visible:outline-none disabled:opacity-60 motion-reduce:transition-none"
-            :disabled="freeTextBusy || destinationMissing"
+            :disabled="freeTextBusy || freeTextDestinationMissing"
             @click="startFreeTextSearch"
           >
             <Search :size="13" aria-hidden="true" />
@@ -735,23 +1033,26 @@ function mediaIconFor(kind: BookRequestMediaKind) {
         </div>
 
         <div v-show="optionsOpen" id="request-more-options" class="grid gap-3 border-t border-border bg-muted px-3 py-3">
-          <fieldset class="grid gap-1.5">
-            <legend class="text-xs font-medium text-foreground">{{ t('bookRequests.search.preferredFormatsLabel') }}</legend>
-            <p class="text-xs text-muted-foreground">{{ t('bookRequests.search.preferredFormatsHint') }}</p>
+          <p class="text-xs text-muted-foreground">{{ t('bookRequests.search.preferredFormatsHint') }}</p>
+          <fieldset v-for="kind in formatKinds" :key="kind" class="grid gap-1.5">
+            <legend class="inline-flex items-center gap-1.5 text-xs font-medium text-foreground">
+              <component :is="mediaIconFor(kind)" v-if="pairMode" :size="12" class="text-muted-foreground" aria-hidden="true" />
+              {{ formatLegend(kind) }}
+            </legend>
             <div class="mt-0.5 flex flex-wrap gap-1.5">
               <button
-                v-for="format in mediaFormats"
+                v-for="format in formatsFor(kind)"
                 :key="format"
                 type="button"
                 class="inline-flex h-7 items-center rounded-full border px-2.5 text-xs font-medium transition-colors focus-visible:ring-2 focus-visible:ring-ring focus-visible:outline-none motion-reduce:transition-none"
                 :class="
-                  isPreferredFormat(format)
+                  isPreferredFormat(format, kind)
                     ? 'border-primary bg-primary/12 text-primary'
                     : 'border-input bg-card text-muted-foreground hover:text-foreground focus-visible:text-foreground'
                 "
-                :aria-pressed="isPreferredFormat(format)"
+                :aria-pressed="isPreferredFormat(format, kind)"
                 :aria-label="t('bookRequests.search.formatToggleAria', { format: format.toUpperCase() })"
-                @click="togglePreferredFormat(format)"
+                @click="togglePreferredFormat(format, kind)"
               >
                 {{ format.toUpperCase() }}
               </button>
@@ -773,7 +1074,15 @@ function mediaIconFor(kind: BookRequestMediaKind) {
       </div>
     </form>
 
-    <p v-if="destinationMissing" class="text-sm text-muted-foreground">{{ t('bookRequests.search.libraryRequired') }}</p>
+    <p v-if="pairMode ? pairDestinationsMissing : destinationMissing" class="text-sm text-muted-foreground">
+      {{ t('bookRequests.search.libraryRequired') }}
+    </p>
+
+    <!-- Said before anything is submitted, so nobody discovers afterwards that a pair became two books. -->
+    <p v-else-if="pairLandingHint" class="flex items-center gap-1.5 text-sm text-muted-foreground">
+      <BookHeadphones :size="14" class="shrink-0" aria-hidden="true" />
+      {{ pairLandingHint }}
+    </p>
 
     <p v-if="isStreaming" role="status" class="sr-only">{{ t('bookRequests.search.searching') }}</p>
 
@@ -800,7 +1109,7 @@ function mediaIconFor(kind: BookRequestMediaKind) {
         variant="outline"
         size="sm"
         class="w-full shrink-0 sm:w-auto"
-        :disabled="freeTextBusy || destinationMissing"
+        :disabled="freeTextBusy || freeTextDestinationMissing"
         @click="startFreeTextSearch"
       >
         {{ t('bookRequests.search.freeTextAction') }}
@@ -816,7 +1125,19 @@ function mediaIconFor(kind: BookRequestMediaKind) {
         :key="group.key"
         class="flex flex-wrap items-center gap-3.5 rounded-lg border border-border bg-card p-3 transition-colors hover:border-ring/50 motion-reduce:transition-none"
       >
+        <RequestPairCover
+          v-if="pairMode"
+          :ebook-src="group.coverUrl"
+          :ebook-fallbacks="group.coverUrls.slice(1)"
+          :audio-src="group.audioCoverUrls[0] ?? null"
+          :audio-fallbacks="group.audioCoverUrls.slice(1)"
+          :source-key="group.key"
+          class="h-[74px] w-[50px]"
+          :icon-size="18"
+          @source-change="handleCoverSourceChange"
+        />
         <RequestCover
+          v-else
           :src="group.coverUrl"
           :fallback-sources="group.coverUrls.slice(1)"
           :source-key="group.key"
@@ -876,7 +1197,21 @@ function mediaIconFor(kind: BookRequestMediaKind) {
               />
             </button>
 
-            <template v-if="group.availability?.ownedBookId">
+            <!-- One chip per half, since owning the ebook says nothing about the audiobook. -->
+            <template v-if="pairMode">
+              <span class="size-[3px] rounded-full bg-border" aria-hidden="true"></span>
+              <span
+                v-for="kind in BOOK_REQUEST_MEDIA_KINDS"
+                :key="kind"
+                class="inline-flex items-center gap-1 rounded-full border px-2 py-0.5"
+                :class="pairStateClass(group, kind)"
+              >
+                <component :is="mediaIconFor(kind)" :size="12" aria-hidden="true" />
+                <span class="sr-only">{{ pairMediumLabel(kind) }}:</span>
+                {{ pairStateLabel(group, kind) }}
+              </span>
+            </template>
+            <template v-else-if="group.availability?.ownedBookId">
               <span class="size-[3px] rounded-full bg-border" aria-hidden="true"></span>
               <span class="inline-flex items-center gap-1 rounded-full border border-success/40 bg-success/10 px-2 py-0.5 text-success">
                 <Library :size="12" aria-hidden="true" />
@@ -895,7 +1230,19 @@ function mediaIconFor(kind: BookRequestMediaKind) {
           </div>
         </div>
 
-        <div v-if="choosesRelease && !isJoinable(group)" class="flex shrink-0 items-center gap-1.5">
+        <Button
+          v-if="pairMode"
+          size="sm"
+          class="shrink-0"
+          :variant="pairPlan(group).kind === 'none' ? 'outline' : 'default'"
+          :disabled="isPairRequestDisabled(group)"
+          @click="requestPairGroup(group)"
+        >
+          <BookHeadphones v-if="pairPlan(group).kind === 'pair'" :size="14" aria-hidden="true" />
+          {{ pairRequestLabel(group) }}
+        </Button>
+
+        <div v-else-if="choosesRelease && !isJoinable(group)" class="flex shrink-0 items-center gap-1.5">
           <Popover>
             <PopoverTrigger as-child>
               <Button
@@ -1006,7 +1353,7 @@ function mediaIconFor(kind: BookRequestMediaKind) {
                   <th scope="col" class="px-2 py-1.5 text-start font-medium">{{ t('bookRequests.search.identifiers.isbn') }}</th>
                   <th scope="col" class="px-2 py-1.5 text-start font-medium">{{ t('bookRequests.search.identifiers.year') }}</th>
                   <th scope="col" class="px-2 py-1.5 text-start font-medium">{{ t('bookRequests.search.identifiers.language') }}</th>
-                  <th v-if="choosesRelease && !isJoinable(group)" scope="col" class="px-2 py-1.5 text-end font-medium">
+                  <th v-if="choosesRelease && !isJoinable(group) && !pairMode" scope="col" class="px-2 py-1.5 text-end font-medium">
                     {{ t('bookRequests.search.identifiers.action') }}
                   </th>
                 </tr>
@@ -1024,7 +1371,7 @@ function mediaIconFor(kind: BookRequestMediaKind) {
                   <td class="px-2 py-2 font-mono text-foreground">{{ candidateIsbn(candidate) }}</td>
                   <td class="px-2 py-2 tabular-nums text-muted-foreground">{{ candidateYear(candidate) }}</td>
                   <td class="px-2 py-2 text-muted-foreground">{{ candidateLanguage(candidate) }}</td>
-                  <td v-if="choosesRelease && !isJoinable(group)" class="px-2 py-2 text-end">
+                  <td v-if="choosesRelease && !isJoinable(group) && !pairMode" class="px-2 py-2 text-end">
                     <Button
                       type="button"
                       variant="outline"
diff --git a/client/src/features/book-requests/composables/useBookRequests.ts b/client/src/features/book-requests/composables/useBookRequests.ts
index 9ea32d63f..3ffcde25d 100644
--- a/client/src/features/book-requests/composables/useBookRequests.ts
+++ b/client/src/features/book-requests/composables/useBookRequests.ts
@@ -77,6 +77,8 @@ export function useBookRequests(scope: RequestScope) {
     if (selfServe.value !== '') query.set('selfServe', selfServe.value)
     query.set('sortBy', sortBy.value)
     query.set('sortDir', sortDir.value)
+    // A pair is one row here, led by its ebook, with the audiobook riding along as its companion.
+    query.set('groupPairs', 'true')
 
     try {
       const res = await api(`${basePath}?${query}`)
@@ -154,8 +156,16 @@ export function useBookRequests(scope: RequestScope) {
    */
   function replaceItem(updated: BookRequestItem): void {
     const index = items.value.findIndex((item) => item.id === updated.id)
-    if (index === -1) return
-    items.value.splice(index, 1, updated)
+    if (index !== -1) {
+      // A single request comes back flat, so the half it leads keeps the companion it already had.
+      items.value.splice(index, 1, { ...updated, companion: items.value[index]!.companion ?? null })
+      localEdits++
+      return
+    }
+
+    const pairIndex = items.value.findIndex((item) => item.companion?.id === updated.id)
+    if (pairIndex === -1) return
+    items.value.splice(pairIndex, 1, { ...items.value[pairIndex]!, companion: updated })
     localEdits++
   }
 
@@ -165,9 +175,22 @@ export function useBookRequests(scope: RequestScope) {
    */
   function dropItem(id: number): void {
     const index = items.value.findIndex((item) => item.id === id)
-    if (index === -1) return
-    items.value.splice(index, 1)
-    total.value = Math.max(0, total.value - 1)
+    if (index !== -1) {
+      const companion = items.value[index]!.companion
+      // The other half of a pair is still a request somebody is waiting on, so it stays as a row
+      // of its own rather than leaving with the half that went.
+      if (companion) items.value.splice(index, 1, { ...companion, companion: null })
+      else {
+        items.value.splice(index, 1)
+        total.value = Math.max(0, total.value - 1)
+      }
+      localEdits++
+      return
+    }
+
+    const pairIndex = items.value.findIndex((item) => item.companion?.id === id)
+    if (pairIndex === -1) return
+    items.value.splice(pairIndex, 1, { ...items.value[pairIndex]!, companion: null })
     localEdits++
   }
 
diff --git a/client/src/features/book-requests/composables/useCandidateGroups.ts b/client/src/features/book-requests/composables/useCandidateGroups.ts
index b50f27bd5..a570fc1df 100644
--- a/client/src/features/book-requests/composables/useCandidateGroups.ts
+++ b/client/src/features/book-requests/composables/useCandidateGroups.ts
@@ -1,5 +1,5 @@
 import { computed, type ComputedRef, type Ref } from 'vue'
-import { bookRequestWorkKey, canonicalizeBookRequestIsbn, languagesAgree } from '@bookorbit/types'
+import { BOOK_REQUEST_MEDIA_KINDS, bookRequestWorkKey, canonicalizeBookRequestIsbn, languagesAgree } from '@bookorbit/types'
 import type { BookRequestAvailability, BookRequestMediaKind, MetadataCandidate, MetadataProviderKey } from '@bookorbit/types'
 import { candidateTitle } from './useRequestSubmission'
 
@@ -26,6 +26,19 @@ export interface CandidateGroup {
   publishedYear: number | null
   providers: MetadataProviderKey[]
   availability: BookRequestAvailability | null
+  /**
+   * The same answer for each medium of a pair, present only while the search asks for both. Each
+   * half is its own question: owning the ebook says nothing about the audiobook.
+   */
+  pairAvailability: Record<BookRequestMediaKind, BookRequestAvailability | null> | null
+  /** Covers ordered by the Audiobook cover rule, so the audiobook half of a pair shows square art. */
+  audioCoverUrls: string[]
+}
+
+/** Asking for both media at once, and which providers' art the audiobook half prefers. */
+export interface CandidatePairOptions {
+  enabled: Ref<boolean> | ComputedRef<boolean>
+  audioCoverProviderOrder: Ref<readonly MetadataProviderKey[]> | ComputedRef<readonly MetadataProviderKey[]>
 }
 
 export interface CandidateIsbnChoice {
@@ -62,7 +75,10 @@ function compareText(left: string, right: string): number {
  * The strongest claim any record in the group carries. Requesting one edition of a work claims the
  * work, so an answer about one record answers for its siblings too.
  */
-function mergeAvailability(members: MetadataCandidate[], getAvailability: (candidate: MetadataCandidate) => BookRequestAvailability | null) {
+function mergeAvailability(
+  members: MetadataCandidate[],
+  getAvailability: (candidate: MetadataCandidate) => BookRequestAvailability | null,
+): BookRequestAvailability | null {
   const known = members.map(getAvailability).filter((entry): entry is BookRequestAvailability => entry !== null)
   if (known.length === 0) return null
 
@@ -75,6 +91,19 @@ function mergeAvailability(members: MetadataCandidate[], getAvailability: (candi
   }
 }
 
+/** Every distinct cover the records offer, the rule's providers first and the fullest records next. */
+function orderedCoverUrls(members: MetadataCandidate[], providerOrder: readonly MetadataProviderKey[]): string[] {
+  const priorities = new Map(providerOrder.map((provider, index) => [provider, index]))
+  return [...members]
+    .sort((a, b) => {
+      const aPriority = priorities.get(a.provider) ?? Number.MAX_SAFE_INTEGER
+      const bPriority = priorities.get(b.provider) ?? Number.MAX_SAFE_INTEGER
+      return aPriority - bPriority || completeness(b) - completeness(a)
+    })
+    .flatMap((member) => (member.coverUrl ? [member.coverUrl] : []))
+    .filter((url, index, urls) => urls.indexOf(url) === index)
+}
+
 /**
  * Collapses search results into the works they describe, keyed exactly as the server dedupes a
  * request. Without this a title carried by five providers reads as five different books, and
@@ -83,10 +112,11 @@ function mergeAvailability(members: MetadataCandidate[], getAvailability: (candi
 export function useCandidateGroups(
   results: Ref<MetadataCandidate[]> | ComputedRef<MetadataCandidate[]>,
   mediaKind: Ref<BookRequestMediaKind>,
-  getAvailability: (candidate: MetadataCandidate) => BookRequestAvailability | null,
+  getAvailability: (candidate: MetadataCandidate, kind?: BookRequestMediaKind) => BookRequestAvailability | null,
   coverProviderOrder?: Ref<readonly MetadataProviderKey[]> | ComputedRef<readonly MetadataProviderKey[]>,
   requestedLanguage?: Ref<string | null> | ComputedRef<string | null>,
   resultProviderOrder?: Ref<readonly MetadataProviderKey[]> | ComputedRef<readonly MetadataProviderKey[]>,
+  pair?: CandidatePairOptions,
 ): { groups: ComputedRef<CandidateGroup[]> } {
   const groups = computed<CandidateGroup[]>(() => {
     const providerPriorities = new Map((resultProviderOrder?.value ?? []).map((provider, index) => [provider, index]))
@@ -167,15 +197,8 @@ export function useCandidateGroups(
             a.yearDistance - b.yearDistance ||
             compareText(a.isbn, b.isbn),
         )
-      const coverPriorities = new Map((coverProviderOrder?.value ?? []).map((provider, index) => [provider, index]))
-      const coverUrls = [...members]
-        .sort((a, b) => {
-          const aPriority = coverPriorities.get(a.provider) ?? Number.MAX_SAFE_INTEGER
-          const bPriority = coverPriorities.get(b.provider) ?? Number.MAX_SAFE_INTEGER
-          return aPriority - bPriority || completeness(b) - completeness(a)
-        })
-        .flatMap((member) => (member.coverUrl ? [member.coverUrl] : []))
-        .filter((url, index, urls) => urls.indexOf(url) === index)
+      const coverUrls = orderedCoverUrls(members, coverProviderOrder?.value ?? [])
+      const pairing = pair?.enabled.value === true
 
       return {
         key,
@@ -191,7 +214,13 @@ export function useCandidateGroups(
         // The earliest edition dates the work; a reprint year only says when this record was made.
         publishedYear: workYear,
         providers: [...new Set(members.map((member) => member.provider))],
-        availability: mergeAvailability(members, getAvailability),
+        availability: mergeAvailability(members, (candidate) => getAvailability(candidate)),
+        pairAvailability: pairing
+          ? (Object.fromEntries(
+              BOOK_REQUEST_MEDIA_KINDS.map((kind) => [kind, mergeAvailability(members, (candidate) => getAvailability(candidate, kind))]),
+            ) as Record<BookRequestMediaKind, BookRequestAvailability | null>)
+          : null,
+        audioCoverUrls: pairing ? orderedCoverUrls(members, pair.audioCoverProviderOrder.value) : [],
       }
     })
   })
diff --git a/client/src/features/book-requests/composables/useMissingFormatRequest.ts b/client/src/features/book-requests/composables/useMissingFormatRequest.ts
new file mode 100644
index 000000000..55bab691f
--- /dev/null
+++ b/client/src/features/book-requests/composables/useMissingFormatRequest.ts
@@ -0,0 +1,123 @@
+import { computed, ref, watch, type Ref } from 'vue'
+import { getBookMediaProfile } from '@bookorbit/types'
+import type { BookDetail, BookRequestAvailability, BookRequestMediaKind, BookRequestSubmitResult, CreateBookRequestPayload } from '@bookorbit/types'
+import { api } from '@/lib/api'
+import { pairHalfState, type PairHalfState } from '../requestPair'
+import { submitFailure, type SubmitFailure } from './useRequestSubmission'
+
+/** What the row knows about the missing format: still being asked, or one of the states a search row shows. */
+export type MissingFormatState = 'checking' | PairHalfState
+
+/**
+ * Asking for the format a book does not have yet, from the book itself.
+ *
+ * Only an ebook missing its audiobook, or the other way round: those are the two formats one book
+ * folder holds together. The request names this book, so the server lands the new format beside
+ * the one already here instead of filing it as a second book.
+ */
+export function useMissingFormatRequest(book: Ref<BookDetail | null>, enabled: Ref<boolean>) {
+  const availability = ref<BookRequestAvailability | null>(null)
+  const checking = ref(false)
+  const submitting = ref(false)
+  let generation = 0
+
+  const missing = computed<BookRequestMediaKind | null>(() => {
+    if (!book.value) return null
+    const profile = getBookMediaProfile(book.value.files)
+    if (profile.hasEbook && !profile.hasAudio) return 'audiobook'
+    if (profile.hasAudio && !profile.hasEbook) return 'ebook'
+    return null
+  })
+
+  const state = computed<MissingFormatState>(() => (checking.value && !availability.value ? 'checking' : pairHalfState(availability.value)))
+  const requestId = computed(() => availability.value?.existingRequestId ?? null)
+  const ownedBookId = computed(() => availability.value?.ownedBookId ?? null)
+
+  function workFor(current: BookDetail, mediaKind: BookRequestMediaKind) {
+    return {
+      title: current.title?.trim() || current.files[0]?.filename || '',
+      author: current.authors[0]?.name ?? null,
+      isbn13: current.isbn13,
+      mediaKind,
+    }
+  }
+
+  async function check(): Promise<void> {
+    const current = book.value
+    const mediaKind = missing.value
+    availability.value = null
+    if (!current || !mediaKind || !enabled.value) return
+
+    const asked = ++generation
+    const work = workFor(current, mediaKind)
+    if (!work.title) return
+
+    checking.value = true
+    try {
+      const res = await api('/api/v1/book-requests/availability', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          items: [{ title: work.title, mediaKind, ...(work.author ? { author: work.author } : {}), ...(work.isbn13 ? { isbn13: work.isbn13 } : {}) }],
+        }),
+      })
+      if (asked !== generation || !res.ok) return
+      const [first] = (await res.json()) as BookRequestAvailability[]
+      availability.value = first ?? null
+    } catch {
+      // The row still offers the request; the answer only decorates it.
+    } finally {
+      if (asked === generation) checking.value = false
+    }
+  }
+
+  /**
+   * Files the request, or joins the one somebody already made. Resolves to the server's answer so
+   * the caller can say which happened, or to the refusal body when there was one.
+   */
+  async function request(): Promise<{ result: BookRequestSubmitResult | null; failure: SubmitFailure | null }> {
+    const current = book.value
+    const mediaKind = missing.value
+    if (!current || !mediaKind) return { result: null, failure: null }
+
+    const work = workFor(current, mediaKind)
+    const payload: CreateBookRequestPayload = {
+      title: work.title,
+      mediaKind,
+      authors: current.authors.map((author) => author.name),
+      isbn13: current.isbn13,
+      isbn10: current.isbn10,
+      seriesName: current.seriesName,
+      publishedYear: current.publishedYear,
+      // The book on the shelf says what language it is in, and the other format of it should match.
+      language: current.language,
+      targetBookId: current.id,
+    }
+
+    submitting.value = true
+    try {
+      const res = await api('/api/v1/book-requests', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(payload),
+      })
+      if (!res.ok) return { result: null, failure: await submitFailure(res) }
+      const result = (await res.json()) as BookRequestSubmitResult
+      availability.value = {
+        ownedBookId: null,
+        existingRequestId: result.request.id,
+        existingRequestStatus: result.request.status,
+        alreadySubscribed: true,
+      }
+      return { result, failure: null }
+    } catch {
+      return { result: null, failure: { code: null, meta: null, message: null } }
+    } finally {
+      submitting.value = false
+    }
+  }
+
+  watch([() => book.value?.id, missing, enabled], () => void check(), { immediate: true })
+
+  return { missing, state, requestId, ownedBookId, availability, submitting, check, request }
+}
diff --git a/client/src/features/book-requests/composables/useReleaseGrab.ts b/client/src/features/book-requests/composables/useReleaseGrab.ts
index e2e309b3a..4b80dfe53 100644
--- a/client/src/features/book-requests/composables/useReleaseGrab.ts
+++ b/client/src/features/book-requests/composables/useReleaseGrab.ts
@@ -39,6 +39,8 @@ export interface ReleaseGrabOptions {
   setFilesExpanded: (release: ReleaseCandidateItem, expanded: boolean) => void
   /** Which download path this release uses. */
   deliveryFor: (release: ReleaseCandidateItem) => DownloadDelivery
+  /** Where a sent release leaves the approver, when that is not the request it belongs to. */
+  afterGrab?: (item: BookRequestItem) => void
 }
 
 /**
@@ -51,7 +53,7 @@ export function useReleaseGrab(options: ReleaseGrabOptions) {
   const { t } = useI18n()
   const route = useRoute()
   const router = useRouter()
-  const { request, requestId, grab, setRequest, inspectRelease, setFilesExpanded, deliveryFor } = options
+  const { request, requestId, grab, setRequest, inspectRelease, setFilesExpanded, deliveryFor, afterGrab } = options
 
   const manualOpen = ref(false)
   const refusals = ref<GrabRefusal[]>([])
@@ -79,7 +81,7 @@ export function useReleaseGrab(options: ReleaseGrabOptions) {
     refusals.value = []
   }
 
-  /** A sent release leaves nothing to pick, so the drawer pops back to the request it belongs to. */
+  /** A sent release leaves nothing to pick, so the drawer pops back to the request it belongs to, unless told otherwise. */
   async function sendGrab(body: GrabBookRequestPayload, delivery: DownloadDelivery) {
     if (!request.value) return
     const outcome = await grab(request.value.id, body)
@@ -91,7 +93,8 @@ export function useReleaseGrab(options: ReleaseGrabOptions) {
     setRequest(outcome.item)
     manualOpen.value = false
     toast.success(t('bookRequests.toasts.grabbed'))
-    void router.push({ name: 'book-request-detail', params: { id: request.value.id }, query: route.query })
+    if (afterGrab) afterGrab(outcome.item)
+    else void router.push({ name: 'book-request-detail', params: { id: request.value.id }, query: route.query })
   }
 
   async function submitGrab(body: GrabBookRequestPayload) {
diff --git a/client/src/features/book-requests/composables/useReleasePicker.ts b/client/src/features/book-requests/composables/useReleasePicker.ts
index 38536d59e..070c097de 100644
--- a/client/src/features/book-requests/composables/useReleasePicker.ts
+++ b/client/src/features/book-requests/composables/useReleasePicker.ts
@@ -1,4 +1,4 @@
-import { ref } from 'vue'
+import { ref, shallowReactive } from 'vue'
 import { api } from '@/lib/api'
 import { fulfilmentBase } from '../fulfilmentBase'
 import type {
@@ -19,6 +19,81 @@ export function searchAttemptKey(activeIsbn: string | null): string {
   return activeIsbn ?? TITLE_AUTHOR_SEARCH_KEY
 }
 
+/**
+ * A request's default search, kept for a moment on this side too. The picker for a pair searches
+ * both halves when it opens, and the server neither merges a search still in flight nor keeps one
+ * longer than this, so the half the approver switches to reads its answer here instead of asking
+ * every tracker a second time.
+ */
+interface DefaultSearch {
+  startedAt: number
+  result: ReleaseSearchResult | null
+  pending: Promise<ReleaseSearchResult | null> | null
+}
+
+/** The server's own cache window; past it, a revisit searches again. */
+const SEARCH_CACHE_TTL_MS = 3 * 60 * 1000
+const SEARCH_CACHE_LIMIT = 8
+/** Reactive so a tab can show the other half's count the moment its search lands. */
+const defaultSearches = shallowReactive(new Map<string, DefaultSearch>())
+
+function defaultSearchPath(canManage: boolean, requestId: number): string {
+  return `${fulfilmentBase(canManage)}/${requestId}/releases`
+}
+
+function freshEntry(path: string): DefaultSearch | null {
+  const entry = defaultSearches.get(path)
+  return entry && Date.now() - entry.startedAt <= SEARCH_CACHE_TTL_MS ? entry : null
+}
+
+function rememberSearch(path: string, entry: DefaultSearch): void {
+  defaultSearches.delete(path)
+  defaultSearches.set(path, entry)
+  if (defaultSearches.size > SEARCH_CACHE_LIMIT) defaultSearches.delete(defaultSearches.keys().next().value!)
+}
+
+/** One default search, shared by everything that asks for it while it runs. */
+function loadDefaultSearch(path: string, refresh: boolean): Promise<ReleaseSearchResult | null> {
+  const existing = refresh ? null : freshEntry(path)
+  if (existing?.result) return Promise.resolve(existing.result)
+  if (existing?.pending) return existing.pending
+
+  const startedAt = Date.now()
+  const pending = (async () => {
+    try {
+      const res = await api(refresh ? `${path}?refresh=true` : path)
+      if (!res.ok) return null
+      return (await res.json()) as ReleaseSearchResult
+    } catch {
+      return null
+    }
+  })()
+  rememberSearch(path, { startedAt, result: null, pending })
+  void pending.then((result) => {
+    // Only the search that still owns the slot may settle it: a refresh started meanwhile replaced it.
+    if (defaultSearches.get(path)?.pending !== pending) return
+    if (result) rememberSearch(path, { startedAt, result, pending: null })
+    else defaultSearches.delete(path)
+  })
+  return pending
+}
+
+/** Starts a request's default search ahead of time, so opening it shows the list straight away. */
+export function prefetchReleaseSearch(canManage: boolean, requestId: number): void {
+  void loadDefaultSearch(defaultSearchPath(canManage, requestId), false)
+}
+
+/** What is known about a request's default search without asking for it. */
+export function peekReleaseSearch(canManage: boolean, requestId: number): { searching: boolean; count: number | null } {
+  const entry = freshEntry(defaultSearchPath(canManage, requestId))
+  return { searching: entry?.pending != null, count: entry?.result?.releases.length ?? null }
+}
+
+/** For tests: every module-level answer is forgotten. */
+export function clearReleaseSearchCache(): void {
+  defaultSearches.clear()
+}
+
 /**
  * The ranked cross-indexer release list for one request. The server does the searching, scoring
  * and caching; this only asks, and asks again with `refresh` when the approver wants a fresh hit
@@ -67,38 +142,52 @@ export function useReleasePicker(canManage: () => boolean) {
    */
   let searchGeneration = 0
 
+  function applyResult(result: ReleaseSearchResult): void {
+    releases.value = result.releases
+    criteria.value = result.criteria
+    indexers.value = result.indexers
+    uncoveredIndexerCount.value = result.uncoveredIndexerCount
+    enabledIndexerCount.value = result.enabledIndexerCount
+    configuredIndexerCount.value = result.configuredIndexerCount
+    profileActive.value = result.profileActive
+    cached.value = result.cached
+    searched.value = true
+    attempts.value = new Map(attempts.value).set(searchAttemptKey(result.criteria.activeIsbn), result.releases.length)
+  }
+
   async function fetchReleases(requestId: number, options: { refresh?: boolean; overrides?: ReleaseSearchOverrides } = {}): Promise<boolean> {
     const generation = ++searchGeneration
-    loading.value = true
+    const custom = options.overrides !== undefined
+    const path = defaultSearchPath(canManage(), requestId)
     loadFailed.value = false
     clearInspections()
+    // A search already answered is shown in the same tick, so switching to it never flashes a spinner.
+    const known = custom || options.refresh ? null : freshEntry(path)?.result
+    if (known) {
+      applyResult(known)
+      loading.value = false
+      return true
+    }
+
+    loading.value = true
     try {
-      const custom = options.overrides !== undefined
-      const url = `${basePath()}/${requestId}/releases${custom ? '/search' : options.refresh ? '?refresh=true' : ''}`
-      const res = custom
-        ? await api(url, {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify(options.overrides),
-          })
-        : await api(url)
+      let result: ReleaseSearchResult | null
+      if (custom) {
+        const res = await api(`${path}/search`, {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify(options.overrides),
+        })
+        result = res.ok ? ((await res.json()) as ReleaseSearchResult) : null
+      } else {
+        result = await loadDefaultSearch(path, options.refresh === true)
+      }
       if (generation !== searchGeneration) return false
-      if (!res.ok) {
+      if (!result) {
         loadFailed.value = true
         return false
       }
-      const result = (await res.json()) as ReleaseSearchResult
-      if (generation !== searchGeneration) return false
-      releases.value = result.releases
-      criteria.value = result.criteria
-      indexers.value = result.indexers
-      uncoveredIndexerCount.value = result.uncoveredIndexerCount
-      enabledIndexerCount.value = result.enabledIndexerCount
-      configuredIndexerCount.value = result.configuredIndexerCount
-      profileActive.value = result.profileActive
-      cached.value = result.cached
-      searched.value = true
-      attempts.value = new Map(attempts.value).set(searchAttemptKey(result.criteria.activeIsbn), result.releases.length)
+      applyResult(result)
       return true
     } catch {
       if (generation === searchGeneration) loadFailed.value = true
diff --git a/client/src/features/book-requests/composables/useReleaseSearchEditor.ts b/client/src/features/book-requests/composables/useReleaseSearchEditor.ts
index dc85a80d4..8e804e29d 100644
--- a/client/src/features/book-requests/composables/useReleaseSearchEditor.ts
+++ b/client/src/features/book-requests/composables/useReleaseSearchEditor.ts
@@ -1,6 +1,6 @@
 import { computed, ref, watch, type Ref } from 'vue'
 import { useI18n } from 'vue-i18n'
-import { canonicalizeBookRequestIsbn, MAX_BOOK_REQUEST_SEARCH_ISBNS, normalizeBookRequestIsbn } from '@bookorbit/types'
+import { canonicalizeBookRequestIsbn, isBookRequestMediaKind, MAX_BOOK_REQUEST_SEARCH_ISBNS, normalizeBookRequestIsbn } from '@bookorbit/types'
 import type { BookRequestItem, ReleaseSearchCriteria, ReleaseSearchOverrides } from '@bookorbit/types'
 
 import { searchAttemptKey, TITLE_AUTHOR_SEARCH_KEY } from './useReleasePicker'
@@ -70,7 +70,8 @@ export function useReleaseSearchEditor(options: ReleaseSearchEditorOptions) {
       isbn13: value.isbn13,
       activeIsbn: isbns[0] ?? null,
       isbns: [...new Set(isbns)].slice(0, MAX_BOOK_REQUEST_SEARCH_ISBNS),
-      mediaKind: value.mediaKind,
+      // A retired medium is never searched; the server refuses it, so this only has to type-check.
+      mediaKind: isBookRequestMediaKind(value.mediaKind) ? value.mediaKind : 'ebook',
       language: value.language,
       preferredFormats: [...value.preferredFormats],
     }
diff --git a/client/src/features/book-requests/composables/useRequestAttempts.ts b/client/src/features/book-requests/composables/useRequestAttempts.ts
index 0f39bacff..0cd248d7c 100644
--- a/client/src/features/book-requests/composables/useRequestAttempts.ts
+++ b/client/src/features/book-requests/composables/useRequestAttempts.ts
@@ -11,6 +11,27 @@ import type { BookRequestDownloadItem } from '@bookorbit/types'
  * them worth a call at all is the refusals - a request that downloaded from its second source
  * looks unremarkable on its own row, and nothing else records that the first one said no.
  */
+/** The last answer per request, so returning to one shows its attempts at once. Bounded like the seed cache. */
+const attemptsCache = new Map<string, BookRequestDownloadItem[]>()
+const ATTEMPTS_CACHE_LIMIT = 50
+
+function remember(key: string, value: BookRequestDownloadItem[]): void {
+  attemptsCache.delete(key)
+  attemptsCache.set(key, value)
+  if (attemptsCache.size > ATTEMPTS_CACHE_LIMIT) attemptsCache.delete(attemptsCache.keys().next().value!)
+}
+
+/** Reads one request's attempts ahead of time, so opening it shows them straight away. */
+export async function prefetchRequestAttempts(canManage: boolean, requestId: number): Promise<void> {
+  const path = `${fulfilmentBase(canManage)}/${requestId}/attempts`
+  try {
+    const res = await api(path)
+    if (res.ok) remember(path, (await res.json()) as BookRequestDownloadItem[])
+  } catch {
+    // The panel asks again when it opens.
+  }
+}
+
 export function useRequestAttempts(canManage: () => boolean) {
   const basePath = () => fulfilmentBase(canManage())
   const attempts = ref<BookRequestDownloadItem[]>([])
@@ -21,10 +42,13 @@ export function useRequestAttempts(canManage: () => boolean) {
 
   async function fetchAttempts(requestId: number): Promise<void> {
     const current = ++generation
-    loading.value = true
+    const path = `${basePath()}/${requestId}/attempts`
+    const cached = attemptsCache.get(path)
+    loading.value = cached === undefined
     failed.value = false
+    if (cached) attempts.value = cached
     try {
-      const res = await api(`${basePath()}/${requestId}/attempts`)
+      const res = await api(path)
       if (current !== generation) return
       if (!res.ok) {
         failed.value = true
@@ -33,6 +57,7 @@ export function useRequestAttempts(canManage: () => boolean) {
       }
       const payload = (await res.json()) as BookRequestDownloadItem[]
       if (current !== generation) return
+      remember(path, payload)
       attempts.value = payload
     } catch {
       if (current !== generation) return
diff --git a/client/src/features/book-requests/composables/useRequestQueue.ts b/client/src/features/book-requests/composables/useRequestQueue.ts
index 2c2bbea1e..7fd3c5829 100644
--- a/client/src/features/book-requests/composables/useRequestQueue.ts
+++ b/client/src/features/book-requests/composables/useRequestQueue.ts
@@ -7,7 +7,11 @@ import type { BookRequestItem } from '@bookorbit/types'
  * from the last row back to the first reads as a bug when the count says you are at the end.
  */
 export function useRequestQueue(items: Ref<BookRequestItem[]>, currentId: Ref<number | null>) {
-  const index = computed(() => (currentId.value === null ? -1 : items.value.findIndex((request) => request.id === currentId.value)))
+  // Either half of a pair stands at the pair's place in the list: the drawer can be open on the
+  // audiobook while the row it belongs to is led by the ebook.
+  const index = computed(() =>
+    currentId.value === null ? -1 : items.value.findIndex((request) => request.id === currentId.value || request.companion?.id === currentId.value),
+  )
   const total = computed(() => items.value.length)
 
   /**
diff --git a/client/src/features/book-requests/composables/useRequestSeedStatus.ts b/client/src/features/book-requests/composables/useRequestSeedStatus.ts
index 8497a9f44..a241840dc 100644
--- a/client/src/features/book-requests/composables/useRequestSeedStatus.ts
+++ b/client/src/features/book-requests/composables/useRequestSeedStatus.ts
@@ -8,6 +8,38 @@ import type { BookRequestSeedStatus } from '@bookorbit/types'
  * import by weeks, so polling every finished download to keep a ratio fresh would be an
  * ever-growing number of client calls for a number nobody is reading.
  */
+/**
+ * The last answer per request, so stepping back to one - the other half of a pair, most often - shows
+ * what it said a moment ago while the client is asked again, instead of a loading line. Bounded,
+ * because a long session steps through far more requests than it ever returns to.
+ */
+const seedCache = new Map<string, BookRequestSeedStatus | null>()
+const SEED_CACHE_LIMIT = 50
+
+function remember(key: string, value: BookRequestSeedStatus | null): void {
+  seedCache.delete(key)
+  seedCache.set(key, value)
+  if (seedCache.size > SEED_CACHE_LIMIT) seedCache.delete(seedCache.keys().next().value!)
+}
+
+async function readSeedStatus(path: string): Promise<BookRequestSeedStatus | null | undefined> {
+  const res = await api(path)
+  if (!res.ok) return undefined
+  const body = (await res.text()).trim()
+  return body ? (JSON.parse(body) as BookRequestSeedStatus) : null
+}
+
+/** Reads one request's seed ahead of time, so opening it shows the answer straight away. */
+export async function prefetchSeedStatus(canManage: boolean, requestId: number): Promise<void> {
+  const path = `${fulfilmentBase(canManage)}/${requestId}/seed`
+  try {
+    const value = await readSeedStatus(path)
+    if (value !== undefined) remember(path, value)
+  } catch {
+    // The panel asks again when it opens; a failed warm-up costs nothing.
+  }
+}
+
 export function useRequestSeedStatus(canManage: () => boolean) {
   const basePath = () => fulfilmentBase(canManage())
   const status = ref<BookRequestSeedStatus | null>(null)
@@ -18,19 +50,21 @@ export function useRequestSeedStatus(canManage: () => boolean) {
 
   async function fetchStatus(requestId: number): Promise<void> {
     const current = ++generation
-    loading.value = true
+    const path = `${basePath()}/${requestId}/seed`
+    const cached = seedCache.get(path)
     failed.value = false
-    status.value = null
+    // A known answer stays on screen while it is refreshed; only a first read shows as loading.
+    loading.value = cached === undefined
+    status.value = cached ?? null
     try {
-      const res = await api(`${basePath()}/${requestId}/seed`)
+      const value = await readSeedStatus(path)
       if (current !== generation) return
-      if (!res.ok) {
+      if (value === undefined) {
         failed.value = true
         return
       }
-      const body = (await res.text()).trim()
-      if (current !== generation) return
-      status.value = body ? (JSON.parse(body) as BookRequestSeedStatus) : null
+      remember(path, value)
+      status.value = value
     } catch {
       if (current === generation) failed.value = true
     } finally {
diff --git a/client/src/features/book-requests/composables/useRequestSubmission.ts b/client/src/features/book-requests/composables/useRequestSubmission.ts
index 3aa66804a..1844cd869 100644
--- a/client/src/features/book-requests/composables/useRequestSubmission.ts
+++ b/client/src/features/book-requests/composables/useRequestSubmission.ts
@@ -1,13 +1,16 @@
-import { onUnmounted, ref, watch } from 'vue'
+import { computed, onUnmounted, ref, watch } from 'vue'
 import { api } from '@/lib/api'
-import { bookRequestSubmitErrorCode } from '@bookorbit/types'
+import { BOOK_REQUEST_MEDIA_KINDS, bookRequestSubmitErrorCode } from '@bookorbit/types'
 import type {
   BookRequestAvailability,
   BookRequestFailureMeta,
   BookRequestMediaKind,
   BookRequestMetadataSource,
+  BookRequestPairHalfPayload,
+  BookRequestPairSubmitResult,
   BookRequestSubmitErrorCode,
   BookRequestSubmitResult,
+  CreateBookRequestPairPayload,
   CreateBookRequestPayload,
   MetadataCandidate,
 } from '@bookorbit/types'
@@ -41,7 +44,8 @@ export interface SubmitFailure {
 
 const UNCLASSIFIED_FAILURE: SubmitFailure = { code: null, meta: null, message: null }
 
-async function submitFailure(res: Response): Promise<SubmitFailure> {
+/** Reads a refused submission into the shape the form renders, for every caller that submits. */
+export async function submitFailure(res: Response): Promise<SubmitFailure> {
   try {
     const body = (await res.json()) as { message?: string | string[]; errorCode?: unknown; errorMeta?: BookRequestFailureMeta }
     const message = Array.isArray(body.message) ? body.message[0] : body.message
@@ -85,6 +89,24 @@ function requestSeriesIndex(candidate: MetadataCandidate): number | null {
   return Number.isFinite(parsed) ? Math.trunc(parsed) : null
 }
 
+/** One answer per medium asked about, so a pair search can hold both without one overwriting the other. */
+function availabilityKey(mediaKind: BookRequestMediaKind, candidate: MetadataCandidate): string {
+  return `${mediaKind}|${candidateKey(candidate)}`
+}
+
+/** What every submission path says about the work itself, whichever media it asks for. */
+interface WorkExtras {
+  note?: string | null
+  language?: string | null
+  coverUrl?: string | null
+  selfServe?: boolean
+  isbn10?: string | null
+  isbn13?: string | null
+  providerKey?: string | null
+  providerId?: string | null
+  metadataSources?: BookRequestMetadataSource[]
+}
+
 export function useRequestSubmission() {
   const availability = ref<Record<string, BookRequestAvailability>>({})
   /**
@@ -96,6 +118,12 @@ export function useRequestSubmission() {
   const lastFailure = ref<SubmitFailure | null>(null)
   const submitting = ref<string | null>(null)
   const mediaKind = ref<BookRequestMediaKind>('ebook')
+  /**
+   * Asking for the ebook and the audiobook together. The search then covers both media, every
+   * result is annotated for both, and `mediaKind` stays on the ebook that leads the pair.
+   */
+  const pairMode = ref(false)
+  const annotatedKinds = computed<BookRequestMediaKind[]>(() => (pairMode.value ? [...BOOK_REQUEST_MEDIA_KINDS] : [mediaKind.value]))
 
   /** Claimed keys, in flight or already answered, so a candidate is never asked about twice. */
   let claimed = new Set<string>()
@@ -132,7 +160,8 @@ export function useRequestSubmission() {
       while (queue.length) {
         const batch = queue.splice(0, ANNOTATE_BATCH_LIMIT)
         const asked = generation
-        const answered = await fetchAvailability(batch)
+        const kinds = annotatedKinds.value
+        const answered = await fetchAvailability(batch, kinds)
 
         // The media kind changed while this was in flight, so the answer is to the wrong question.
         if (generation !== asked) return
@@ -140,8 +169,10 @@ export function useRequestSubmission() {
 
         const next = { ...availability.value }
         batch.forEach((candidate, index) => {
-          const result = answered[index]
-          if (result) next[candidateKey(candidate)] = result
+          kinds.forEach((kind, offset) => {
+            const result = answered[index * kinds.length + offset]
+            if (result) next[availabilityKey(kind, candidate)] = result
+          })
         })
         availability.value = next
       }
@@ -150,20 +181,23 @@ export function useRequestSubmission() {
     }
   }
 
-  async function fetchAvailability(batch: MetadataCandidate[]): Promise<BookRequestAvailability[] | null> {
+  async function fetchAvailability(batch: MetadataCandidate[], kinds: BookRequestMediaKind[]): Promise<BookRequestAvailability[] | null> {
     try {
       const res = await api('/api/v1/book-requests/availability', {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
+        // One item per medium asked about, candidate-major, which is the order the answer is read back in.
         body: JSON.stringify({
-          items: batch.map((c) => ({
-            title: candidateTitle(c),
-            author: c.authors?.[0],
-            isbn13: c.isbn13,
-            providerKey: c.provider,
-            providerId: c.providerId,
-            mediaKind: mediaKind.value,
-          })),
+          items: batch.flatMap((c) =>
+            kinds.map((kind) => ({
+              title: candidateTitle(c),
+              author: c.authors?.[0],
+              isbn13: c.isbn13,
+              providerKey: c.provider,
+              providerId: c.providerId,
+              mediaKind: kind,
+            })),
+          ),
         }),
       })
       if (res.ok) return (await res.json()) as BookRequestAvailability[]
@@ -180,7 +214,7 @@ export function useRequestSubmission() {
   }
 
   /** A different medium is a different question, so every annotation is recomputed. */
-  watch(mediaKind, () => {
+  watch([mediaKind, pairMode], () => {
     generation += 1
     availability.value = {}
     claimed = new Set()
@@ -194,30 +228,14 @@ export function useRequestSubmission() {
     coalesceHandle = null
   })
 
-  function getAvailability(candidate: MetadataCandidate): BookRequestAvailability | null {
-    return availability.value[candidateKey(candidate)] ?? null
+  function getAvailability(candidate: MetadataCandidate, kind: BookRequestMediaKind = mediaKind.value): BookRequestAvailability | null {
+    return availability.value[availabilityKey(kind, candidate)] ?? null
   }
 
-  async function submit(
-    candidate: MetadataCandidate,
-    extra: {
-      targetLibraryId?: number | null
-      targetFolderId?: number | null
-      note?: string | null
-      preferredFormats?: string[]
-      language?: string | null
-      coverUrl?: string | null
-      selfServe?: boolean
-      isbn10?: string | null
-      isbn13?: string | null
-      providerKey?: string | null
-      providerId?: string | null
-      metadataSources?: BookRequestMetadataSource[]
-    },
-  ): Promise<BookRequestSubmitResult | null> {
-    const payload: CreateBookRequestPayload = {
+  /** The work as a candidate describes it, shared by a single request and by both halves of a pair. */
+  function workPayload(candidate: MetadataCandidate, extra: WorkExtras) {
+    return {
       title: candidateTitle(candidate),
-      mediaKind: mediaKind.value,
       ...(extra.selfServe ? { selfServe: true } : {}),
       subtitle: candidate.subtitle ?? null,
       authors: candidate.authors ?? [],
@@ -233,16 +251,29 @@ export function useRequestSubmission() {
       providerKey: extra.providerKey !== undefined ? extra.providerKey : candidate.provider,
       providerId: extra.providerId !== undefined ? extra.providerId : candidate.providerId,
       metadataSources: extra.metadataSources ?? [],
-      targetLibraryId: extra.targetLibraryId ?? null,
-      targetFolderId: extra.targetFolderId ?? null,
       note: extra.note ?? null,
-      preferredFormats: extra.preferredFormats ?? [],
     }
+  }
 
-    submitting.value = candidateKey(candidate)
+  /** What is now known for certain about one medium of a candidate, claimed so no queued answer lands on it. */
+  function recordSubmitted(candidate: MetadataCandidate, kind: BookRequestMediaKind, result: BookRequestSubmitResult): void {
+    claimed.add(candidateKey(candidate))
+    availability.value = {
+      ...availability.value,
+      [availabilityKey(kind, candidate)]: {
+        ownedBookId: getAvailability(candidate, kind)?.ownedBookId ?? null,
+        existingRequestId: result.request.id,
+        existingRequestStatus: result.request.status,
+        alreadySubscribed: true,
+      },
+    }
+  }
+
+  async function post<T>(path: string, payload: unknown, key: string): Promise<T | null> {
+    submitting.value = key
     lastFailure.value = null
     try {
-      const res = await api('/api/v1/book-requests', {
+      const res = await api(path, {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
         body: JSON.stringify(payload),
@@ -251,20 +282,7 @@ export function useRequestSubmission() {
         lastFailure.value = await submitFailure(res)
         return null
       }
-
-      const result = (await res.json()) as BookRequestSubmitResult
-      // Claim the key so a queued annotation cannot land on top of what we now know for certain.
-      claimed.add(candidateKey(candidate))
-      availability.value = {
-        ...availability.value,
-        [candidateKey(candidate)]: {
-          ownedBookId: getAvailability(candidate)?.ownedBookId ?? null,
-          existingRequestId: result.request.id,
-          existingRequestStatus: result.request.status,
-          alreadySubscribed: true,
-        },
-      }
-      return result
+      return (await res.json()) as T
     } catch {
       // A network failure never reached the server, so there is no classified refusal to show. The
       // caller falls back to its generic message on a null return; without this the promise
@@ -276,6 +294,51 @@ export function useRequestSubmission() {
     }
   }
 
+  async function submit(
+    candidate: MetadataCandidate,
+    extra: WorkExtras & {
+      targetLibraryId?: number | null
+      targetFolderId?: number | null
+      preferredFormats?: string[]
+      /** The medium to ask for, when it is not the one the search is on: one half of a pair. */
+      mediaKind?: BookRequestMediaKind
+      /** The book on the shelf the new format should join. */
+      targetBookId?: number | null
+    },
+  ): Promise<BookRequestSubmitResult | null> {
+    const kind = extra.mediaKind ?? mediaKind.value
+    const payload: CreateBookRequestPayload = {
+      ...workPayload(candidate, extra),
+      mediaKind: kind,
+      targetLibraryId: extra.targetLibraryId ?? null,
+      targetFolderId: extra.targetFolderId ?? null,
+      preferredFormats: extra.preferredFormats ?? [],
+      ...(extra.targetBookId ? { targetBookId: extra.targetBookId } : {}),
+    }
+
+    const result = await post<BookRequestSubmitResult>('/api/v1/book-requests', payload, candidateKey(candidate))
+    if (result) recordSubmitted(candidate, kind, result)
+    return result
+  }
+
+  /** The ebook and the audiobook of one candidate, in one submission. */
+  async function submitPair(
+    candidate: MetadataCandidate,
+    extra: WorkExtras & { ebook: BookRequestPairHalfPayload; audiobook: BookRequestPairHalfPayload },
+  ): Promise<BookRequestPairSubmitResult | null> {
+    const payload: CreateBookRequestPairPayload = {
+      ...workPayload(candidate, extra),
+      ebook: halfPayload(extra.ebook),
+      audiobook: halfPayload(extra.audiobook),
+    }
+
+    const result = await post<BookRequestPairSubmitResult>('/api/v1/book-requests/pairs', payload, candidateKey(candidate))
+    if (result) {
+      for (const kind of BOOK_REQUEST_MEDIA_KINDS) recordSubmitted(candidate, kind, result[kind])
+    }
+    return result
+  }
+
   /**
    * What the library and the queue already know about a title nobody searched a provider for.
    *
@@ -332,25 +395,34 @@ export function useRequestSubmission() {
       ...(extra.selfServe ? { selfServe: true } : {}),
     }
 
-    submitting.value = FREE_TEXT_KEY
-    lastFailure.value = null
-    try {
-      const res = await api('/api/v1/book-requests', {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify(payload),
-      })
-      if (!res.ok) {
-        lastFailure.value = await submitFailure(res)
-        return null
-      }
-      return (await res.json()) as BookRequestSubmitResult
-    } catch {
-      lastFailure.value = UNCLASSIFIED_FAILURE
-      return null
-    } finally {
-      submitting.value = null
+    return post<BookRequestSubmitResult>('/api/v1/book-requests', payload, FREE_TEXT_KEY)
+  }
+
+  /** The same, for both media at once. */
+  async function submitPairFreeText(
+    work: { title: string; author?: string | null },
+    extra: {
+      language?: string | null
+      selfServe?: boolean
+      note?: string | null
+      ebook: BookRequestPairHalfPayload
+      audiobook: BookRequestPairHalfPayload
+    },
+  ): Promise<BookRequestPairSubmitResult | null> {
+    const title = work.title.trim()
+    if (!title) return null
+
+    const payload: CreateBookRequestPairPayload = {
+      title,
+      authors: work.author?.trim() ? [work.author.trim()] : [],
+      language: extra.language ?? null,
+      note: extra.note ?? null,
+      ...(extra.selfServe ? { selfServe: true } : {}),
+      ebook: halfPayload(extra.ebook),
+      audiobook: halfPayload(extra.audiobook),
     }
+
+    return post<BookRequestPairSubmitResult>('/api/v1/book-requests/pairs', payload, FREE_TEXT_KEY)
   }
 
   return {
@@ -358,16 +430,29 @@ export function useRequestSubmission() {
     lastFailure,
     submitting,
     mediaKind,
+    pairMode,
     annotate,
     getAvailability,
     submit,
+    submitPair,
     submitFreeText,
+    submitPairFreeText,
     checkFreeText,
     candidateKey,
     candidateTitle,
   }
 }
 
+/** Null where a half names nothing, which the server reads the same as leaving the field out. */
+function halfPayload(half: BookRequestPairHalfPayload): BookRequestPairHalfPayload {
+  return {
+    targetLibraryId: half.targetLibraryId ?? null,
+    targetFolderId: half.targetFolderId ?? null,
+    preferredFormats: half.preferredFormats ?? [],
+    coverUrl: normalizeCoverUrl(half.coverUrl),
+  }
+}
+
 function normalizeCoverUrl(value: string | null | undefined): string | null {
   if (!value) return null
   try {
diff --git a/client/src/features/book-requests/requestMedia.ts b/client/src/features/book-requests/requestMedia.ts
new file mode 100644
index 000000000..f1da234a8
--- /dev/null
+++ b/client/src/features/book-requests/requestMedia.ts
@@ -0,0 +1,17 @@
+import { BookOpen, Headphones } from '@lucide/vue'
+import type { StoredBookRequestMediaKind } from '@bookorbit/types'
+
+/**
+ * The icon for a request's medium. An old request can still carry a retired medium, and it reads
+ * as a book: the label beside it says which.
+ */
+export function requestMediaIcon(mediaKind: StoredBookRequestMediaKind) {
+  return mediaKind === 'audiobook' ? Headphones : BookOpen
+}
+
+/** Literal classes, because Tailwind reads this file as text and never sees a class built at runtime. */
+export function requestMediaColor(mediaKind: StoredBookRequestMediaKind): string {
+  if (mediaKind === 'audiobook') return 'text-[var(--pill-media-audiobook)]'
+  if (mediaKind === 'ebook') return 'text-[var(--pill-media-ebook)]'
+  return 'text-muted-foreground'
+}
diff --git a/client/src/features/book-requests/requestPair.ts b/client/src/features/book-requests/requestPair.ts
new file mode 100644
index 000000000..538526497
--- /dev/null
+++ b/client/src/features/book-requests/requestPair.ts
@@ -0,0 +1,144 @@
+import {
+  BOOK_REQUEST_MEDIA_KINDS,
+  isBookRequestFulfiller,
+  isGrabbableBookRequestStatus,
+  type BookRequestAvailability,
+  type BookRequestItem,
+  type BookRequestMediaKind,
+} from '@bookorbit/types'
+import { canCancelRequest, canDismissRequest } from './requestActions'
+
+/**
+ * What one medium of a work looks like from the search list: on the shelf, already asked for by
+ * this person, asked for by somebody else, or not asked for at all.
+ */
+export type PairHalfState = 'owned' | 'following' | 'joinable' | 'new'
+
+export type PairAvailability = Record<BookRequestMediaKind, BookRequestAvailability | null>
+
+export function pairHalfState(availability: BookRequestAvailability | null): PairHalfState {
+  if (availability?.ownedBookId) return 'owned'
+  if (availability?.existingRequestId) return availability.alreadySubscribed ? 'following' : 'joinable'
+  return 'new'
+}
+
+function isActionable(state: PairHalfState): boolean {
+  return state === 'new' || state === 'joinable'
+}
+
+/**
+ * How a "both" press is actually sent.
+ *
+ * Both halves still to ask for, or one still to ask for beside a request this person already
+ * follows, go through the pair route: it joins what exists and links the two. One still to ask for
+ * beside a copy already on the shelf goes alone, aimed at that copy, so the new format joins the
+ * book the requester already has rather than becoming a second one. Nothing left to ask for sends
+ * nothing.
+ */
+export type PairSubmission =
+  | { kind: 'pair'; actionable: BookRequestMediaKind[] }
+  | { kind: 'single'; mediaKind: BookRequestMediaKind; joinBookId: number | null; state: PairHalfState }
+  | { kind: 'none'; reason: 'owned' | 'requested' }
+
+export function pairSubmission(availability: PairAvailability): PairSubmission {
+  const states = { ebook: pairHalfState(availability.ebook), audiobook: pairHalfState(availability.audiobook) }
+  const actionable = BOOK_REQUEST_MEDIA_KINDS.filter((kind) => isActionable(states[kind]))
+
+  if (actionable.length === 0) {
+    return { kind: 'none', reason: BOOK_REQUEST_MEDIA_KINDS.every((kind) => states[kind] === 'owned') ? 'owned' : 'requested' }
+  }
+  if (actionable.length === 2) return { kind: 'pair', actionable }
+
+  const mediaKind = actionable[0]!
+  const other = mediaKind === 'ebook' ? 'audiobook' : 'ebook'
+  if (states[other] === 'owned') {
+    return { kind: 'single', mediaKind, joinBookId: availability[other]?.ownedBookId ?? null, state: states[mediaKind] }
+  }
+  return { kind: 'pair', actionable }
+}
+
+/**
+ * The key for the button a pair row wears, so it always says which media the press will touch.
+ * Kept here rather than in the component because the rules are the submission's, not the layout's.
+ */
+export function pairSubmissionLabelKey(submission: PairSubmission, availability: PairAvailability, mode: 'request' | 'get' | 'choose'): string {
+  if (submission.kind === 'none') {
+    return submission.reason === 'owned' ? 'bookRequests.search.pair.haveBoth' : 'bookRequests.search.pair.requestedBoth'
+  }
+
+  const actionable = submission.kind === 'pair' ? submission.actionable : [submission.mediaKind]
+  const joinsOnly = actionable.every((kind) => pairHalfState(availability[kind]) === 'joinable')
+
+  if (actionable.length === 2) {
+    if (joinsOnly) return 'bookRequests.search.pair.joinBoth'
+    return mode === 'get'
+      ? 'bookRequests.search.pair.getBoth'
+      : mode === 'choose'
+        ? 'bookRequests.search.pair.chooseReleases'
+        : 'bookRequests.search.pair.requestBoth'
+  }
+
+  const medium = actionable[0] === 'ebook' ? 'Ebook' : 'Audiobook'
+  if (joinsOnly) return `bookRequests.search.pair.join${medium}`
+  return mode === 'get'
+    ? `bookRequests.search.pair.get${medium}`
+    : mode === 'choose'
+      ? 'bookRequests.search.chooseRelease'
+      : `bookRequests.search.pair.request${medium}`
+}
+
+/** Every request a list row stands for: one, or the two halves of a pair. */
+export function rowRequests(row: BookRequestItem): BookRequestItem[] {
+  return row.companion ? [row, row.companion] : [row]
+}
+
+/** Every request on a page of rows, pairs unfolded, for selection and bulk actions. */
+export function flattenRequestRows(rows: readonly BookRequestItem[]): BookRequestItem[] {
+  return rows.flatMap(rowRequests)
+}
+
+/** The halves of a row in a stable reading order: the ebook first, whichever half leads it. */
+export function orderedHalves(row: BookRequestItem): BookRequestItem[] {
+  return rowRequests(row).sort((a, b) => (a.mediaKind === b.mediaKind ? 0 : a.mediaKind === 'ebook' ? -1 : 1))
+}
+
+/**
+ * What a pair row can do to its halves in one press. Each entry is the subset that action applies
+ * to, so the label can say "both" or name the one medium, and nothing is offered for a half the
+ * endpoint would refuse.
+ */
+export interface PairRowActions {
+  approve: BookRequestItem[]
+  reject: BookRequestItem[]
+  cancel: BookRequestItem[]
+  dismiss: BookRequestItem[]
+  restore: BookRequestItem[]
+  /** The half a release would be found for next, if any half is waiting on one. */
+  grab: BookRequestItem | null
+  /** Every half waiting on a release this viewer can pick, so the button can say "releases". */
+  grabHalves: BookRequestItem[]
+}
+
+export function pairRowActions(row: BookRequestItem, viewer: { userId: number | null; canManage: boolean; canSelfFulfil: boolean }): PairRowActions {
+  const halves = orderedHalves(row)
+  const pending = halves.filter((half) => viewer.canManage && half.status === 'pending')
+  const grabHalves = halves.filter(
+    (half) =>
+      isGrabbableBookRequestStatus(half.status) && (viewer.canManage || (viewer.canSelfFulfil && isBookRequestFulfiller(half, viewer.userId))),
+  )
+  return {
+    approve: pending,
+    reject: pending,
+    cancel: halves.filter((half) => canCancelRequest(half, viewer.userId, viewer.canManage, viewer.canSelfFulfil)),
+    dismiss: halves.filter((half) => canDismissRequest(half) && !half.dismissed),
+    restore: halves.filter((half) => canDismissRequest(half) && half.dismissed),
+    grab: grabHalves[0] ?? null,
+    grabHalves,
+  }
+}
+
+/** The locale key naming one medium of a pair inside an action, as in "Approve ebook". */
+export function pairActionKey(action: 'approve' | 'reject' | 'cancel' | 'dismiss' | 'restore', halves: readonly BookRequestItem[]): string {
+  if (halves.length > 1) return `bookRequests.actions.pair.${action}Both`
+  return `bookRequests.actions.pair.${action}${halves[0]?.mediaKind === 'audiobook' ? 'Audiobook' : 'Ebook'}`
+}
diff --git a/client/src/features/book/components/detail/details/BookEditionsCard.vue b/client/src/features/book/components/detail/details/BookEditionsCard.vue
index 903fbc037..f97ba6e6b 100644
--- a/client/src/features/book/components/detail/details/BookEditionsCard.vue
+++ b/client/src/features/book/components/detail/details/BookEditionsCard.vue
@@ -126,6 +126,9 @@ function rowMeasure(row: BookFormatEntry): string {
       {{ t('book.detail.details.moreFormats', { count: hiddenCount }) }}
     </p>
 
+    <!-- What this book could still have: a format another feature can offer to fetch. -->
+    <slot name="missing" />
+
     <div class="mt-2.5 flex items-baseline gap-2 border-t border-border pt-2">
       <p class="text-[11px] text-muted-foreground">{{ t('book.detail.details.filesOnDisk') }}</p>
       <p class="ml-auto text-[11px] font-semibold tabular-nums">{{ formatNumber(book.files.length) }}</p>
diff --git a/client/src/features/book/components/detail/tabs/DetailsTab.vue b/client/src/features/book/components/detail/tabs/DetailsTab.vue
index 56619f65e..2c6b88653 100644
--- a/client/src/features/book/components/detail/tabs/DetailsTab.vue
+++ b/client/src/features/book/components/detail/tabs/DetailsTab.vue
@@ -67,6 +67,7 @@ import HardcoverBookSyncGridItem from '@/features/hardcover/components/Hardcover
 import StorygraphBookSyncGridItem from '@/features/storygraph/components/StorygraphBookSyncGridItem.vue'
 import BookEditionsCard, { type EditionProgress } from '@/features/book/components/detail/details/BookEditionsCard.vue'
 import BookReadingActivityCard from '@/features/book/components/detail/details/BookReadingActivityCard.vue'
+import BookMissingFormatRequest from '@/features/book-requests/components/BookMissingFormatRequest.vue'
 import { useBookReadingLog } from '@/features/book/composables/useBookReadingLog'
 import { useProviderLinkSettings } from '@/features/book/composables/useProviderLinkSettings'
 import { hasReadAlong } from '@/features/book/lib/file-capabilities'
@@ -2180,7 +2181,11 @@ watch(
         </dl>
       </section>
 
-      <BookEditionsCard :book="book" :progress="editionProgress" :resetting-file-ids="resettingFileIds" @reset-progress="handleEditionReset" />
+      <BookEditionsCard :book="book" :progress="editionProgress" :resetting-file-ids="resettingFileIds" @reset-progress="handleEditionReset">
+        <template #missing>
+          <BookMissingFormatRequest :book="book" />
+        </template>
+      </BookEditionsCard>
 
       <div v-if="filledCustomMetadata.length > 0" class="mt-6 pt-5 border-t border-border">
         <p class="text-[11px] font-semibold uppercase tracking-widest text-muted-foreground mb-3">{{ t('book.detail.details.customMetadata') }}</p>
diff --git a/client/src/features/book/composables/useMetadataSearch.ts b/client/src/features/book/composables/useMetadataSearch.ts
index 79bc2f7b0..0e71cedcf 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
+  /** Several media at once, ranked as for the first: the providers of every medium named are asked. */
+  mediaKinds?: ConcreteBookMediaKind[]
   /** Asks exactly these providers, whatever the provider filter holds. */
   providers?: MetadataProviderKey[]
 }
@@ -67,6 +69,7 @@ export function useMetadataSearch() {
     if (params.bookId != null) query.set('bookId', String(params.bookId))
     if (params.isAudiobook != null) query.set('isAudiobook', String(params.isAudiobook))
     if (params.mediaKind) query.set('mediaKind', params.mediaKind)
+    if (params.mediaKinds?.length) query.set('mediaKinds', params.mediaKinds.join(','))
     const onlyProvider = providers.value.length === 1 ? providers.value[0] : undefined
     const requestedProviders = params.providers ?? (selectedProviders.value.length ? selectedProviders.value : onlyProvider ? [onlyProvider.key] : [])
     if (requestedProviders.length) query.set('providers', requestedProviders.join(','))
diff --git a/client/src/features/settings/RequestAutomationPanel.vue b/client/src/features/settings/RequestAutomationPanel.vue
index 09ffb986d..d0fd731d1 100644
--- a/client/src/features/settings/RequestAutomationPanel.vue
+++ b/client/src/features/settings/RequestAutomationPanel.vue
@@ -116,7 +116,7 @@ onMounted(fetchIndexers)
 onMounted(fetchManagedIndexers)
 
 watch(loading, async (isLoading) => {
-  if (isLoading || !/^#release-profile-(ebook|audiobook|comic)$/.test(window.location.hash)) return
+  if (isLoading || !/^#release-profile-(ebook|audiobook)$/.test(window.location.hash)) return
   await nextTick()
   document.getElementById(window.location.hash.slice(1))?.scrollIntoView({ block: 'start' })
 })
diff --git a/client/src/features/settings/__tests__/RequestAutomationPanel.spec.ts b/client/src/features/settings/__tests__/RequestAutomationPanel.spec.ts
index 994f19899..d6f692186 100644
--- a/client/src/features/settings/__tests__/RequestAutomationPanel.spec.ts
+++ b/client/src/features/settings/__tests__/RequestAutomationPanel.spec.ts
@@ -326,7 +326,7 @@ describe('RequestAutomationPanel', () => {
    */
   describe('release profiles', () => {
     async function profilePanel(conditions: BookRequestAutomationSettings['profiles']['ebook'][number]['conditions'] = {}) {
-      const wrapper = await mountPanel(settings({ profiles: { ebook: [{ id: 'tier-1', name: 'Retail', conditions }], audiobook: [], comic: [] } }))
+      const wrapper = await mountPanel(settings({ profiles: { ebook: [{ id: 'tier-1', name: 'Retail', conditions }], audiobook: [] } }))
       apiMock.mockClear()
       apiMock.mockResolvedValue(response(settings()))
       return wrapper
diff --git a/client/src/features/settings/__tests__/RequestIndexersPanel.spec.ts b/client/src/features/settings/__tests__/RequestIndexersPanel.spec.ts
index 0d4b49848..725d87feb 100644
--- a/client/src/features/settings/__tests__/RequestIndexersPanel.spec.ts
+++ b/client/src/features/settings/__tests__/RequestIndexersPanel.spec.ts
@@ -41,12 +41,12 @@ function descriptor(overrides: Partial<IndexerAdapterDescriptor> = {}): IndexerA
     builtIn: true,
     requiresCredential: false,
     credentialKind: 'apiKey',
-    mediaKinds: ['ebook', 'audiobook', 'comic'],
+    mediaKinds: ['ebook', 'audiobook'],
     usesCategories: true,
     seedsBack: true,
     delivery: 'torrent',
     supportsIsbnSearch: false,
-    defaultCategories: { ebook: [7020], audiobook: [3030], comic: [7030] },
+    defaultCategories: { ebook: [7020], audiobook: [3030] },
     settingsFields: [],
     ...overrides,
   }
@@ -66,7 +66,7 @@ const OPEN_LIBRARY = descriptor({
   usesCategories: false,
   seedsBack: false,
   delivery: 'file',
-  defaultCategories: { ebook: [], audiobook: [], comic: [] },
+  defaultCategories: { ebook: [], audiobook: [] },
   defaultBaseUrl: 'https://openlibrary.example',
 })
 
@@ -107,7 +107,7 @@ function indexer(overrides: Partial<IndexerItem> = {}): IndexerItem {
     applyTrackerSeedGoals: true,
     seedRatioGoal: null,
     seedTimeMinutes: null,
-    categories: { ebook: [7020], audiobook: [3030], comic: [7030] },
+    categories: { ebook: [7020], audiobook: [3030] },
     disabledMediaKinds: [],
     isbnSearchDisabled: false,
     settings: {},
diff --git a/client/src/features/settings/components/ReleaseProfileEditor.vue b/client/src/features/settings/components/ReleaseProfileEditor.vue
index aa07f4238..25f74273c 100644
--- a/client/src/features/settings/components/ReleaseProfileEditor.vue
+++ b/client/src/features/settings/components/ReleaseProfileEditor.vue
@@ -2,14 +2,7 @@
 import { computed, ref, watch } from 'vue'
 import { useI18n } from 'vue-i18n'
 import { ArrowDown, ArrowUp, Plus, X } from '@lucide/vue'
-import {
-  AUDIO_FORMAT_LIST,
-  COMIC_FORMAT_LIST,
-  EBOOK_FORMAT_LIST,
-  MAX_RELEASE_TIER_NAME_LENGTH,
-  MAX_RELEASE_TIERS,
-  REQUEST_LANGUAGE_CODES,
-} from '@bookorbit/types'
+import { AUDIO_FORMAT_LIST, EBOOK_FORMAT_LIST, MAX_RELEASE_TIER_NAME_LENGTH, MAX_RELEASE_TIERS, REQUEST_LANGUAGE_CODES } from '@bookorbit/types'
 import type {
   BookRequestMediaKind,
   IndexerAdapterDescriptor,
@@ -76,10 +69,9 @@ function clone(list: ReleaseTier[]): ReleaseTier[] {
 const FORMATS: Record<BookRequestMediaKind, readonly string[]> = {
   ebook: EBOOK_FORMAT_LIST,
   audiobook: AUDIO_FORMAT_LIST,
-  comic: [...COMIC_FORMAT_LIST, 'pdf'],
 }
 
-/** Bitrate and channels describe an encode, which an ebook or a comic does not have. */
+/** Bitrate and channels describe an encode, which an ebook does not have. */
 const isAudio = computed(() => props.mediaKind === 'audiobook')
 const formats = computed(() => FORMATS[props.mediaKind])
 const languageOptions = computed(() =>
diff --git a/client/src/features/settings/composables/useIndexerDraft.ts b/client/src/features/settings/composables/useIndexerDraft.ts
index 2d1d13f33..4918964ac 100644
--- a/client/src/features/settings/composables/useIndexerDraft.ts
+++ b/client/src/features/settings/composables/useIndexerDraft.ts
@@ -131,7 +131,6 @@ export function useIndexerDraft(options: IndexerDraftOptions) {
     return {
       ebook: categories.ebook.map(String),
       audiobook: categories.audiobook.map(String),
-      comic: categories.comic.map(String),
     }
   }
 
@@ -162,7 +161,7 @@ export function useIndexerDraft(options: IndexerDraftOptions) {
       seedTimeMinutes: '',
       seedRatioBadInput: false,
       seedTimeBadInput: false,
-      categories: toCategoryDraft(adapter?.defaultCategories ?? { ebook: [], audiobook: [], comic: [] }),
+      categories: toCategoryDraft(adapter?.defaultCategories ?? { ebook: [], audiobook: [] }),
       searchedMediaKinds: [...BOOK_REQUEST_MEDIA_KINDS],
       searchByIsbn: true,
       settings: defaultSettings(adapter),
@@ -468,7 +467,6 @@ export function useIndexerDraft(options: IndexerDraftOptions) {
       categories: {
         ebook: parseCategories(current.categories.ebook),
         audiobook: parseCategories(current.categories.audiobook),
-        comic: parseCategories(current.categories.comic),
       },
       disabledMediaKinds: BOOK_REQUEST_MEDIA_KINDS.filter((mediaKind) => !current.searchedMediaKinds.includes(mediaKind)),
       isbnSearchDisabled: !current.searchByIsbn,
diff --git a/client/src/locales/en.json b/client/src/locales/en.json
index 4cff9af8f..090d6b357 100644
--- a/client/src/locales/en.json
+++ b/client/src/locales/en.json
@@ -7127,7 +7127,40 @@
       "moreOptions": "More options",
       "fewerOptions": "Fewer options",
       "optionsSummary": "{formats} · note added",
-      "formatToggleAria": "Prefer {format}"
+      "formatToggleAria": "Prefer {format}",
+      "pair": {
+        "choice": "Both",
+        "choiceHint": "Ask for the e-book and the audiobook together",
+        "ebookLibraryLabel": "E-book library",
+        "audiobookLibraryLabel": "Audiobook library",
+        "audiobookFolderLabel": "Audiobook folder",
+        "landsTogether": "Both formats arrive as one book in {library}.",
+        "landsSeparately": "{library} keeps one book per file, so each format arrives as a book of its own.",
+        "landsApart": "The e-book and the audiobook go to different libraries, so they arrive as two books.",
+        "preferredEbookFormats": "Preferred e-book formats",
+        "preferredAudiobookFormats": "Preferred audiobook formats",
+        "state": {
+          "owned": "In your library",
+          "following": "You requested this",
+          "joinable": "Requested",
+          "new": "Not requested"
+        },
+        "requestBoth": "Request both",
+        "getBoth": "Get both",
+        "chooseReleases": "Choose releases",
+        "joinBoth": "Add me to both",
+        "requestEbook": "Request e-book",
+        "requestAudiobook": "Request audiobook",
+        "getEbook": "Get e-book",
+        "getAudiobook": "Get audiobook",
+        "joinEbook": "Add me to the e-book request",
+        "joinAudiobook": "Add me to the audiobook request",
+        "haveBoth": "In your library",
+        "requestedBoth": "Requested",
+        "submitted": "Requested the e-book and the audiobook",
+        "submittedPartlyJoined": "Requested both. One was already on its way, so you were added to that request",
+        "submittedJoinsBook": "Requested. It will join the copy already in your library"
+      }
     },
     "card": {
       "details": "Details",
@@ -7186,7 +7219,10 @@
         "forbidden": "That request belongs to someone else.",
         "loadFailed": "Could not load that request"
       },
-      "entityName": "Request"
+      "entityName": "Request",
+      "pairSwitchLabel": "Formats in this request",
+      "joinsBook": "Joins a book you have",
+      "joinsBookHint": "When this arrives it is added to the book already in your library"
     },
     "actions": {
       "approve": "Approve",
@@ -7201,7 +7237,29 @@
       "grab": "Find a release",
       "goToBook": "Go to book",
       "retryRelease": "Try another release",
-      "leave": "Leave request"
+      "leave": "Leave request",
+      "pair": {
+        "approveBoth": "Approve both",
+        "approveEbook": "Approve e-book",
+        "approveAudiobook": "Approve audiobook",
+        "rejectBoth": "Reject both",
+        "rejectEbook": "Reject e-book",
+        "rejectAudiobook": "Reject audiobook",
+        "cancelBoth": "Cancel both",
+        "cancelEbook": "Cancel e-book",
+        "cancelAudiobook": "Cancel audiobook",
+        "dismissBoth": "Dismiss both",
+        "dismissEbook": "Dismiss e-book",
+        "dismissAudiobook": "Dismiss audiobook",
+        "restoreBoth": "Restore both",
+        "restoreEbook": "Restore e-book",
+        "restoreAudiobook": "Restore audiobook",
+        "grabEbook": "Find an e-book release",
+        "grabAudiobook": "Find an audiobook release",
+        "chooseReleases": "Choose releases",
+        "openEbook": "Open the e-book request",
+        "openAudiobook": "Open the audiobook request"
+      }
     },
     "filters": {
       "status": "Status",
@@ -7244,7 +7302,9 @@
       "left": "You have left this request",
       "bulkRejected": "{count, plural, one {# request rejected} other {# requests rejected}}",
       "bulkRejectedPartial": "{done} rejected, {failed} could not be",
-      "importDiscarded": "The imported file was discarded"
+      "importDiscarded": "The imported file was discarded",
+      "pairApproved": "Approved both",
+      "pairRejected": "Rejected both"
     },
     "errors": {
       "loadFailed": "Could not load requests",
@@ -7264,7 +7324,9 @@
       "languageChangeFailed": "Could not change the request language",
       "leaveFailed": "That request could not be left",
       "bulkRejectFailed": "That selection could not be rejected",
-      "discardImportFailed": "That import could not be discarded"
+      "discardImportFailed": "That import could not be discarded",
+      "approveCompanionFailedEbook": "Approved this one, but the e-book could not be approved",
+      "approveCompanionFailedAudiobook": "Approved this one, but the audiobook could not be approved"
     },
     "grab": {
       "title": "Send to a download client",
@@ -7310,6 +7372,18 @@
     "releases": {
       "title": "Pick a release",
       "retryTitle": "Try another release",
+      "pairTitle": "Pick releases",
+      "pair": {
+        "tabsLabel": "Formats to pick releases for",
+        "releaseCount": "{count, plural, one {# release} other {# releases}}",
+        "searching": "Searching",
+        "toChoose": "To choose",
+        "sent": "Sent",
+        "finishedTitle": "Both releases are on their way",
+        "finishedHint": "Each one files into your library when its download finishes. You can follow both from the request.",
+        "backToRequest": "Back to the request",
+        "done": "Done"
+      },
       "subtitle": "Ranked across every enabled indexer.",
       "summaryCount": "{count, plural, one {# release} other {# releases}}",
       "allFreeleech": "all freeleech",
@@ -7599,7 +7673,8 @@
       "decidedBy": "Decided by",
       "decisionNote": "Decision note",
       "requestNote": "Request note",
-      "openDetail": "Open full detail"
+      "openDetail": "Open full detail",
+      "pairMedia": "E-book and audiobook"
     },
     "confirm": {
       "cancelDownloadTitle": "Cancel this download?",
@@ -7655,7 +7730,9 @@
       "SUBMIT_DESTINATION_REQUIRED": "Your requests are approved as soon as you make them, so pick the library the book should land in",
       "SUBMIT_SELF_SERVE_LIMIT": "Finish or cancel some downloads first: you can have {limit} in flight at once",
       "SUBMIT_ON_BEHALF_FORBIDDEN": "You are not allowed to request books for other people",
-      "SUBMIT_ON_BEHALF_UNKNOWN_USER": "That user cannot have a book request made for them"
+      "SUBMIT_ON_BEHALF_UNKNOWN_USER": "That user cannot have a book request made for them",
+      "SUBMIT_TARGET_BOOK_NOT_FOUND": "That book is not in a library you can reach",
+      "SUBMIT_TARGET_BOOK_HAS_MEDIUM": "That book already has this format"
     },
     "actionError": {
       "BOOK_REQUEST_NOT_PENDING": "Only a pending request supports this action; this request is currently {status}",
@@ -7741,7 +7818,22 @@
       "reviewSources": "Review sources"
     },
     "selfServeBadge": "Self-served",
-    "selfServeBadgeHint": "Downloaded directly by the requester, with no approval step"
+    "selfServeBadgeHint": "Downloaded directly by the requester, with no approval step",
+    "missingFormat": {
+      "labelAudiobook": "Audiobook for this book",
+      "labelEbook": "E-book for this book",
+      "noAudiobook": "No audiobook yet",
+      "noEbook": "No e-book yet",
+      "requestAudiobook": "Request audiobook",
+      "requestEbook": "Request e-book",
+      "requested": "Requested",
+      "requestedBySomeone": "Requested by someone else",
+      "ownedElsewhere": "In your library as a separate book",
+      "open": "Open",
+      "viewRequest": "View request",
+      "submittedAudiobook": "Requested. The audiobook will join this book when it arrives",
+      "submittedEbook": "Requested. The e-book will join this book when it arrives"
+    }
   },
   "collection": {
     "visibleToAll": "Visible to all users",
diff --git a/packages/plugin-api/src/index.ts b/packages/plugin-api/src/index.ts
index fe0ab8a49..5c618bceb 100644
--- a/packages/plugin-api/src/index.ts
+++ b/packages/plugin-api/src/index.ts
@@ -14,7 +14,12 @@
 /** Bumped when a change to this contract would break a plugin written against the old one. */
 export const PLUGIN_API_VERSION = 1;
 
-export type PluginMediaKind = "ebook" | "audiobook" | "comic";
+/**
+ * What BookOrbit asks a plugin to search for. Comics are no longer requested: a plugin written
+ * before they were retired may still declare `comic` and its categories, and the loader accepts
+ * and ignores them, so nothing has to change for that plugin to keep working.
+ */
+export type PluginMediaKind = "ebook" | "audiobook";
 
 /** Distinct enough to act on: a rejected credential must not look like "nothing found". */
 export type PluginSearchFailure = "unauthorized" | "throttled" | "timeout" | "unreachable" | "unsupportedMedium" | "error";
@@ -25,7 +30,6 @@ export type PluginCredentialKind = "apiKey" | "sessionId" | null;
 export interface PluginCategoryMap {
   ebook: number[];
   audiobook: number[];
-  comic: number[];
 }
 
 /** A signed update feed controlled by the plugin publisher. */
diff --git a/packages/types/src/app-info.ts b/packages/types/src/app-info.ts
index e2ef5c268..c777f39b9 100644
--- a/packages/types/src/app-info.ts
+++ b/packages/types/src/app-info.ts
@@ -5,7 +5,15 @@
  *
  * Named apart from `APP_FEATURES` in app-features.ts, which holds the build-time feature flags.
  */
-export const SERVER_FEATURES = ["annotation-stars", "annotation-color-names", "annotation-trash", "book-journal", "bookmark-edit", "notebook-hub"] as const;
+export const SERVER_FEATURES = [
+  "annotation-stars",
+  "annotation-color-names",
+  "annotation-trash",
+  "book-journal",
+  "bookmark-edit",
+  "notebook-hub",
+  "book-request-pairs",
+] as const;
 
 export type ServerFeature = (typeof SERVER_FEATURES)[number];
 
diff --git a/packages/types/src/book-request-automation.ts b/packages/types/src/book-request-automation.ts
index 7a940ee42..c6ef4719f 100644
--- a/packages/types/src/book-request-automation.ts
+++ b/packages/types/src/book-request-automation.ts
@@ -27,7 +27,7 @@ export const BOOK_REQUEST_AUTOMATION_SETTING_KEYS = {
  * The instance default destination for one medium, as two flat rows rather than a JSON blob, so
  * the destinations follow the same one-row-per-knob rule as the settings above.
  *
- * Derived from the medium rather than spelled out three times: `BOOK_REQUEST_MEDIA_KINDS` is what
+ * Derived from the medium rather than spelled out per medium: `BOOK_REQUEST_MEDIA_KINDS` is what
  * decides how many there are, and a medium added later should not need six more literals here.
  */
 export function bookRequestDefaultLibraryKey(mediaKind: BookRequestMediaKind): string {
diff --git a/packages/types/src/book-request.ts b/packages/types/src/book-request.ts
index 354b96973..f68a0b4f6 100644
--- a/packages/types/src/book-request.ts
+++ b/packages/types/src/book-request.ts
@@ -1,8 +1,22 @@
-import { CONCRETE_BOOK_MEDIA_KINDS, type ConcreteBookMediaKind } from "./book";
 import type { BookRequestDownloadItem } from "./download-client";
 
-export const BOOK_REQUEST_MEDIA_KINDS = CONCRETE_BOOK_MEDIA_KINDS;
-export type BookRequestMediaKind = ConcreteBookMediaKind;
+/** What a book can be requested as: an ebook or an audiobook, alone or as a pair. */
+export const BOOK_REQUEST_MEDIA_KINDS = ["ebook", "audiobook"] as const;
+export type BookRequestMediaKind = (typeof BOOK_REQUEST_MEDIA_KINDS)[number];
+
+/**
+ * A medium requests no longer offer, still carried by requests made before it was retired. Those
+ * rows keep loading, and can be cancelled, hidden or deleted; nothing creates one any more, and
+ * nothing fetches a release for one.
+ */
+export type LegacyBookRequestMediaKind = "comic";
+
+/** Every medium a stored request can carry, including the retired one. */
+export type StoredBookRequestMediaKind = BookRequestMediaKind | LegacyBookRequestMediaKind;
+
+export function isBookRequestMediaKind(value: string): value is BookRequestMediaKind {
+  return (BOOK_REQUEST_MEDIA_KINDS as readonly string[]).includes(value);
+}
 
 /** Bounds exact indexer passes before the title-and-author fallback. */
 export const MAX_BOOK_REQUEST_SEARCH_ISBNS = 8;
@@ -289,6 +303,10 @@ export const BOOK_REQUEST_SUBMIT_ERROR_CODES = [
   "SUBMIT_ON_BEHALF_FORBIDDEN",
   /** The named requester does not exist, or is not an account that could file this itself. */
   "SUBMIT_ON_BEHALF_UNKNOWN_USER",
+  /** The book a request was asked to join is gone, or sits in a library the requester cannot reach. */
+  "SUBMIT_TARGET_BOOK_NOT_FOUND",
+  /** The book a request was asked to join already has the requested medium. Carries `mediaKind`. */
+  "SUBMIT_TARGET_BOOK_HAS_MEDIUM",
 ] as const;
 
 export type BookRequestSubmitErrorCode = (typeof BOOK_REQUEST_SUBMIT_ERROR_CODES)[number];
@@ -402,7 +420,8 @@ export interface BookRequestItem extends BookRequestWorkSnapshot {
   userId: number;
   requesterUsername: string;
   requesterName: string;
-  mediaKind: BookRequestMediaKind;
+  /** A retired medium only on a request made before it was retired; see `LegacyBookRequestMediaKind`. */
+  mediaKind: StoredBookRequestMediaKind;
   status: BookRequestStatus;
   preferredFormats: string[];
   note: string | null;
@@ -438,10 +457,31 @@ export interface BookRequestItem extends BookRequestWorkSnapshot {
   download: BookRequestDownloadItem | null;
   /** Whether the signed-in user has hidden this from their own list. Never shared between users. */
   dismissed: boolean;
+  /**
+   * The other half of an ebook and audiobook pair. Set on both halves, so either one names the
+   * other; null on every request made on its own.
+   */
+  companionRequestId: number | null;
+  /**
+   * The book this request's files join when they arrive, rather than becoming a book of their own.
+   * Set when a missing format was requested from a book's page, and on the second half of a pair
+   * once the first half has landed.
+   */
+  targetBookId: number | null;
+  /**
+   * The companion itself, present only on a list asked for with `groupPairs`, and only when the
+   * caller can see it. A pair is then one entry, led by its ebook half.
+   */
+  companion?: BookRequestItem | null;
   createdAt: string;
   updatedAt: string;
 }
 
+/** The medium on the other side of a pair. */
+export function bookRequestCompanionKind(mediaKind: BookRequestMediaKind): BookRequestMediaKind {
+  return mediaKind === "ebook" ? "audiobook" : "ebook";
+}
+
 export interface BookRequestPage {
   items: BookRequestItem[];
   total: number;
@@ -471,6 +511,39 @@ export interface CreateBookRequestPayload extends Partial<BookRequestWorkSnapsho
    * ordinary case: the caller is the requester.
    */
   userId?: number;
+  /**
+   * The book the arriving files should join, for a format that book is missing. Advertised by the
+   * `book-request-pairs` server feature.
+   */
+  targetBookId?: number;
+}
+
+/** What one half of a pair may set for itself; everything else about the work is shared. */
+export interface BookRequestPairHalfPayload {
+  targetLibraryId?: number | null;
+  targetFolderId?: number | null;
+  preferredFormats?: string[];
+  /** The cover this half shows, when it differs from the pair's: audiobook art is square. */
+  coverUrl?: string | null;
+}
+
+/**
+ * An ebook and an audiobook of one work, asked for together. Each half is submitted under the same
+ * rules a single request is, so either one may join a request that already exists or arrive
+ * already available, and the two are linked whichever way each one went.
+ */
+export interface CreateBookRequestPairPayload extends Partial<BookRequestWorkSnapshot> {
+  title: string;
+  note?: string | null;
+  selfServe?: boolean;
+  userId?: number;
+  ebook?: BookRequestPairHalfPayload;
+  audiobook?: BookRequestPairHalfPayload;
+}
+
+export interface BookRequestPairSubmitResult {
+  ebook: BookRequestSubmitResult;
+  audiobook: BookRequestSubmitResult;
 }
 
 /**
diff --git a/packages/types/src/indexer.ts b/packages/types/src/indexer.ts
index c8b4e3b11..2fa278a57 100644
--- a/packages/types/src/indexer.ts
+++ b/packages/types/src/indexer.ts
@@ -49,12 +49,12 @@ export type IndexerCategoryMap = Record<BookRequestMediaKind, number[]>;
 
 /**
  * Starting points, not constraints. Torznab follows the Newznab category numbering (7020 ebooks,
- * 7030 comics, 3030 audiobooks). A source with no categories at all declares an empty map, and
+ * 3030 audiobooks). A source with no categories at all declares an empty map, and
  * `INDEXER_USES_CATEGORIES` hides the editor rather than showing boxes that do nothing.
  */
 export const DEFAULT_INDEXER_CATEGORIES: Record<IndexerAdapterType, IndexerCategoryMap> = {
-  torznab: { ebook: [7020], audiobook: [3030], comic: [7030] },
-  newznab: { ebook: [7020], audiobook: [3030], comic: [7030] },
+  torznab: { ebook: [7020], audiobook: [3030] },
+  newznab: { ebook: [7020], audiobook: [3030] },
 };
 
 /** What the credential field holds. Null where the source needs none, as an open library does. */
@@ -93,8 +93,8 @@ export const INDEXER_DELIVERY: Record<IndexerAdapterType, DownloadDelivery> = {
  * as such in the picker rather than contributing an empty result that reads as "not available".
  */
 export const INDEXER_MEDIA_KINDS: Record<IndexerAdapterType, readonly BookRequestMediaKind[]> = {
-  torznab: ["ebook", "audiobook", "comic"],
-  newznab: ["ebook", "audiobook", "comic"],
+  torznab: ["ebook", "audiobook"],
+  newznab: ["ebook", "audiobook"],
 };
 
 /**
diff --git a/server/src/db/migrations/0106_add_book_request_pairs.sql b/server/src/db/migrations/0106_add_book_request_pairs.sql
new file mode 100644
index 000000000..b114066cb
--- /dev/null
+++ b/server/src/db/migrations/0106_add_book_request_pairs.sql
@@ -0,0 +1,6 @@
+ALTER TABLE "book_requests" ADD COLUMN "companion_request_id" integer;--> statement-breakpoint
+ALTER TABLE "book_requests" ADD COLUMN "target_book_id" integer;--> statement-breakpoint
+ALTER TABLE "book_requests" ADD CONSTRAINT "book_requests_companion_request_id_book_requests_id_fk" FOREIGN KEY ("companion_request_id") REFERENCES "public"."book_requests"("id") ON DELETE set null ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "book_requests" ADD CONSTRAINT "book_requests_target_book_id_books_id_fk" FOREIGN KEY ("target_book_id") REFERENCES "public"."books"("id") ON DELETE set null ON UPDATE no action;--> statement-breakpoint
+CREATE INDEX "book_requests_companion_request_id_idx" ON "book_requests" USING btree ("companion_request_id") WHERE "book_requests"."companion_request_id" is not null;--> statement-breakpoint
+CREATE INDEX "book_requests_target_book_id_idx" ON "book_requests" USING btree ("target_book_id") WHERE "book_requests"."target_book_id" is not null;
\ No newline at end of file
diff --git a/server/src/db/migrations/meta/0106_snapshot.json b/server/src/db/migrations/meta/0106_snapshot.json
new file mode 100644
index 000000000..5f9f6d55a
--- /dev/null
+++ b/server/src/db/migrations/meta/0106_snapshot.json
@@ -0,0 +1,22800 @@
+{
+  "id": "7dbd0aa9-fd8f-4586-9ee2-a8430487f6f8",
+  "prevId": "82a84f81-6595-480c-81ee-d1e378b5851a",
+  "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": "double precision",
+          "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_write_all_files": {
+          "name": "file_write_all_files",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "file_write_read_along_enabled": {
+          "name": "file_write_read_along_enabled",
+          "type": "boolean",
+          "primaryKey": false,
+          "notNull": true,
+          "default": false
+        },
+        "file_write_read_along_max_file_size_mb": {
+          "name": "file_write_read_along_max_file_size_mb",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "default": 1000
+        },
+        "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
+        },
+        "koreader_hash_revision": {
+          "name": "koreader_hash_revision",
+          "type": "bigint",
+          "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": {
+        "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_change_timestamp_idx": {
+          "name": "book_files_change_timestamp_idx",
+          "columns": [
+            {
+              "expression": "greatest(\"created_at\", \"updated_at\") desc",
+              "asc": true,
+              "isExpression": 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_subtitle_unaccent_trgm_idx": {
+          "name": "bm_subtitle_unaccent_trgm_idx",
+          "columns": [
+            {
+              "expression": "public.bookorbit_unaccent(\"subtitle\") gin_trgm_ops",
+              "asc": true,
+              "isExpression": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "gin",
+          "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
+        },
+        "starred_at": {
+          "name": "starred_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.book_journal_entries": {
+      "name": "book_journal_entries",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "serial",
+          "primaryKey": true,
+          "notNull": true
+        },
+        "client_id": {
+          "name": "client_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "book_id": {
+          "name": "book_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "body": {
+          "name": "body",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "quote": {
+          "name": "quote",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "chapter_title": {
+          "name": "chapter_title",
+          "type": "varchar(500)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "position_percent": {
+          "name": "position_percent",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "cfi": {
+          "name": "cfi",
+          "type": "varchar(2000)",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "position_seconds": {
+          "name": "position_seconds",
+          "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()"
+        },
+        "deleted_at": {
+          "name": "deleted_at",
+          "type": "timestamp with time zone",
+          "primaryKey": false,
+          "notNull": false
+        }
+      },
+      "indexes": {
+        "book_journal_entries_user_client_id_uidx": {
+          "name": "book_journal_entries_user_client_id_uidx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "client_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": true,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "book_journal_entries_user_book_created_active_idx": {
+          "name": "book_journal_entries_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": "created_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "where": "\"book_journal_entries\".\"deleted_at\" is null",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "book_journal_entries_book_id_idx": {
+          "name": "book_journal_entries_book_id_idx",
+          "columns": [
+            {
+              "expression": "book_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "book_journal_entries_user_id_users_id_fk": {
+          "name": "book_journal_entries_user_id_users_id_fk",
+          "tableFrom": "book_journal_entries",
+          "tableTo": "users",
+          "columnsFrom": ["user_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "book_journal_entries_book_id_books_id_fk": {
+          "name": "book_journal_entries_book_id_books_id_fk",
+          "tableFrom": "book_journal_entries",
+          "tableTo": "books",
+          "columnsFrom": ["book_id"],
+          "columnsTo": ["id"],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {
+        "book_journal_entries_body_length_chk": {
+          "name": "book_journal_entries_body_length_chk",
+          "value": "char_length(\"book_journal_entries\".\"body\") between 1 and 10000"
+        },
+        "book_journal_entries_quote_length_chk": {
+          "name": "book_journal_entries_quote_length_chk",
+          "value": "\"book_journal_entries\".\"quote\" is null or char_length(\"book_journal_entries\".\"quote\") <= 5000"
+        },
+        "book_journal_entries_position_percent_range_chk": {
+          "name": "book_journal_entries_position_percent_range_chk",
+          "value": "\"book_journal_entries\".\"position_percent\" is null or (\"book_journal_entries\".\"position_percent\" >= 0 and \"book_journal_entries\".\"position_percent\" <= 100)"
+        },
+        "book_journal_entries_position_seconds_nonnegative_chk": {
+          "name": "book_journal_entries_position_seconds_nonnegative_chk",
+          "value": "\"book_journal_entries\".\"position_seconds\" is null or \"book_journal_entries\".\"position_seconds\" >= 0"
+        }
+      },
+      "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 and \"bookmarks\".\"deleted_at\" 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
+        },
+        "companion_request_id": {
+          "name": "companion_request_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "target_book_id": {
+          "name": "target_book_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_companion_request_id_idx": {
+          "name": "book_requests_companion_request_id_idx",
+          "columns": [
+            {
+              "expression": "companion_request_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "where": "\"book_requests\".\"companion_request_id\" is not null",
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "book_requests_target_book_id_idx": {
+          "name": "book_requests_target_book_id_idx",
+          "columns": [
+            {
+              "expression": "target_book_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "where": "\"book_requests\".\"target_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"
+        },
+        "book_requests_companion_request_id_book_requests_id_fk": {
+          "name": "book_requests_companion_request_id_book_requests_id_fk",
+          "tableFrom": "book_requests",
+          "tableTo": "book_requests",
+          "columnsFrom": ["companion_request_id"],
+          "columnsTo": ["id"],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "book_requests_target_book_id_books_id_fk": {
+          "name": "book_requests_target_book_id_books_id_fk",
+          "tableFrom": "book_requests",
+          "tableTo": "books",
+          "columnsFrom": ["target_book_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', 'kobo_download')"
+        }
+      },
+      "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
+        },
+        "manual_link_requested": {
+          "name": "manual_link_requested",
+          "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 d1dd4c9df..6adac129c 100644
--- a/server/src/db/migrations/meta/_journal.json
+++ b/server/src/db/migrations/meta/_journal.json
@@ -743,6 +743,13 @@
       "when": 1791388600818,
       "tag": "0105_add_library_file_write_read_along",
       "breakpoints": true
+    },
+    {
+      "idx": 106,
+      "version": "7",
+      "when": 1791429899868,
+      "tag": "0106_add_book_request_pairs",
+      "breakpoints": true
     }
   ]
 }
diff --git a/server/src/db/schema/book-requests.schema.test.ts b/server/src/db/schema/book-requests.schema.test.ts
index 56e37d0f8..9cc36acc7 100644
--- a/server/src/db/schema/book-requests.schema.test.ts
+++ b/server/src/db/schema/book-requests.schema.test.ts
@@ -49,7 +49,11 @@ describe('book_requests status SQL matches the shared constants', () => {
     }
   });
 
-  it('declares the media kind enum from the shared constant', () => {
-    expect(config.columns.find((c) => c.name === 'media_kind')?.enumValues).toEqual([...BOOK_REQUEST_MEDIA_KINDS]);
+  /**
+   * The live media from the shared constant, then the retired `comic` after them. Dropping it from
+   * the stored type would fail every upgrade of a server that still holds a comic request.
+   */
+  it('declares the media kind enum from the shared constant, keeping the retired comic last', () => {
+    expect(config.columns.find((c) => c.name === 'media_kind')?.enumValues).toEqual([...BOOK_REQUEST_MEDIA_KINDS, 'comic']);
   });
 });
diff --git a/server/src/db/schema/book-requests.ts b/server/src/db/schema/book-requests.ts
index 06ac370f8..0357ff594 100644
--- a/server/src/db/schema/book-requests.ts
+++ b/server/src/db/schema/book-requests.ts
@@ -13,16 +13,26 @@ import {
   timestamp,
   uniqueIndex,
   varchar,
+  type AnyPgColumn,
 } from 'drizzle-orm/pg-core';
 import { BOOK_REQUEST_MEDIA_KINDS } from '@bookorbit/types';
-import type { BookRequestMetadataSource } from '@bookorbit/types';
+import type { BookRequestMetadataSource, LegacyBookRequestMediaKind } from '@bookorbit/types';
 
 import { books } from './books';
 import { bookDockFiles } from './book-dock';
 import { libraries, libraryFolders } from './libraries';
 import { users } from './auth';
 
-export const bookRequestMediaKindEnum = pgEnum('book_request_media_kind', BOOK_REQUEST_MEDIA_KINDS);
+/**
+ * The stored type still lists the retired `comic`, after the media a request can ask for. Requests
+ * made before comics were retired keep it, and dropping the value would fail every upgrade of a
+ * server holding one. Nothing writes it any more: the request DTOs only accept the live media.
+ */
+const LEGACY_MEDIA_KINDS: readonly LegacyBookRequestMediaKind[] = ['comic'];
+export const bookRequestMediaKindEnum = pgEnum('book_request_media_kind', [...BOOK_REQUEST_MEDIA_KINDS, ...LEGACY_MEDIA_KINDS] as [
+  ...typeof BOOK_REQUEST_MEDIA_KINDS,
+  LegacyBookRequestMediaKind,
+]);
 
 /**
  * Status lists are spelled out rather than interpolated from the shared constants. A CHECK body
@@ -109,6 +119,25 @@ export const bookRequests = pgTable(
      */
     fulfillerUserId: integer('fulfiller_user_id').references(() => users.id, { onDelete: 'set null' }),
 
+    /**
+     * The other half of an ebook and audiobook pair, written on both rows so either one finds the
+     * other. A pair is two ordinary requests rather than one request for two media: everything
+     * after submission runs per medium, and the halves really do part ways - one is in the library
+     * a minute later while the other waits days for a seeder, or is rejected outright.
+     *
+     * Set null on delete, so deleting one half leaves the other as a request made on its own.
+     */
+    companionRequestId: integer('companion_request_id').references((): AnyPgColumn => bookRequests.id, { onDelete: 'set null' }),
+
+    /**
+     * The book the arriving files join, rather than becoming a book of their own. Without it the
+     * second format of a work is filed wherever the naming pattern puts it, and an m4b tagged
+     * "Dune (Unabridged)" resolves to a different folder than the epub called "Dune".
+     *
+     * Set null on delete: the files then land the way any other request's do.
+     */
+    targetBookId: integer('target_book_id').references(() => books.id, { onDelete: 'set null' }),
+
     dedupeKey: varchar('dedupe_key', { length: 500 }).notNull(),
 
     createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
@@ -134,6 +163,13 @@ export const bookRequests = pgTable(
     // Partial on purpose. The sweeper asks for self-serve rows of a given status and age every ten
     // minutes, which is selective enough to scan a long way at library scale without it, and the
     // predicate keeps every ordinary request out of the index entirely.
+    // Both set-null cascades walk these, and a deleted book or request must not scan the table.
+    index('book_requests_companion_request_id_idx')
+      .on(t.companionRequestId)
+      .where(sql`${t.companionRequestId} is not null`),
+    index('book_requests_target_book_id_idx')
+      .on(t.targetBookId)
+      .where(sql`${t.targetBookId} is not null`),
     index('book_requests_self_serve_idx')
       .on(t.selfServe, t.status, t.createdAt)
       .where(sql`${t.selfServe}`),
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 461a02768..263476d11 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
@@ -18,6 +18,7 @@ import {
   NotificationType,
   type BookDockMetadata,
 } from '@bookorbit/types';
+import type { BookDockFileRow } from '../../db/schema/book-dock';
 import { BookDockFinalizeService } from './book-dock-finalize.service';
 
 const mockAccess = vi.mocked(access);
@@ -693,6 +694,131 @@ describe('BookDockFinalizeService', () => {
       ]);
     });
 
+    describe('as another format of an existing book', () => {
+      const joinBook = { bookId: 42, folderPath: '/library/Frank Herbert/Dune' };
+
+      function stubFolderLibrary(service: BookDockFinalizeService, organizationMode = 'book_per_folder') {
+        vi.spyOn(service as never, 'findLibraryOrFail').mockResolvedValue({
+          id: 5,
+          allowedFormats: [],
+          fileNamingPattern: null,
+          organizationMode,
+        } as never);
+        vi.spyOn(service as never, 'findFolderOrFail').mockResolvedValue({ id: 9, libraryId: 5, path: '/library' } as never);
+        vi.spyOn(service as never, 'resolveDestination').mockResolvedValue('/library/Frank Herbert/Dune (Unabridged)/Dune (Unabridged).m4b' as never);
+        vi.spyOn(service as never, 'cleanupBookDockRecord').mockResolvedValue(undefined as never);
+      }
+
+      const audioRow = () => makeRow({ fileName: 'dune.m4b', absolutePath: '/tmp/dune.m4b', format: 'm4b', targetLibraryId: 5, targetFolderId: 9 });
+
+      it("lands in the book's own folder under the pattern's file name, so the two formats are one book", async () => {
+        const { service, processor, storage } = makeService();
+        stubFolderLibrary(service);
+        const applyMetadata = vi.spyOn(service as never, 'applyMetadata').mockResolvedValue(undefined as never);
+        const applyJoined = vi.spyOn(service as never, 'applyJoinedMetadata').mockResolvedValue(undefined as never);
+        mockAccess.mockRejectedValueOnce(Object.assign(new Error('not found'), { code: 'ENOENT' }));
+        mockStat.mockResolvedValueOnce({ size: 100 } as never);
+        processor.createUnitBookRecords.mockResolvedValueOnce({ bookIds: [42], createdBookIds: [], attachedFileIds: [900] });
+
+        await expect((service as any).finalizeFile(audioRow(), undefined, undefined, new Map([[1, { joinBook }]]), 1, true)).resolves.toMatchObject({
+          success: true,
+          bookId: 42,
+        });
+
+        expect(storage.moveToPath).toHaveBeenCalledWith('/tmp/dune.m4b', '/library/Frank Herbert/Dune/Dune (Unabridged).m4b');
+        expect(processor.createUnitBookRecords).toHaveBeenCalledWith(5, 9, [
+          expect.objectContaining({ folderPath: '/library/Frank Herbert/Dune', absolutePath: '/library/Frank Herbert/Dune/Dune (Unabridged).m4b' }),
+        ]);
+        // The book keeps the title and authors it already had.
+        expect(applyJoined).toHaveBeenCalledWith(42, expect.objectContaining({ id: 1 }), null, null);
+        expect(applyMetadata).not.toHaveBeenCalled();
+      });
+
+      it('files the ordinary way in a library where a book is a single file', async () => {
+        const { service, storage } = makeService();
+        stubFolderLibrary(service, 'book_per_file');
+        vi.spyOn(service as never, 'applyMetadata').mockResolvedValue(undefined as never);
+        mockAccess.mockRejectedValueOnce(Object.assign(new Error('not found'), { code: 'ENOENT' }));
+        mockStat.mockResolvedValueOnce({ size: 100 } as never);
+
+        await (service as any).finalizeFile(audioRow(), undefined, undefined, new Map([[1, { joinBook }]]), 1, true);
+
+        expect(storage.moveToPath).toHaveBeenCalledWith('/tmp/dune.m4b', '/library/Frank Herbert/Dune (Unabridged)/Dune (Unabridged).m4b');
+      });
+
+      it('refuses to place anything outside the folder being filed into', async () => {
+        const { service, storage } = makeService();
+        stubFolderLibrary(service);
+        vi.spyOn(service as never, 'applyMetadata').mockResolvedValue(undefined as never);
+        mockAccess.mockRejectedValueOnce(Object.assign(new Error('not found'), { code: 'ENOENT' }));
+        mockStat.mockResolvedValueOnce({ size: 100 } as never);
+
+        await (service as any).finalizeFile(
+          audioRow(),
+          undefined,
+          undefined,
+          new Map([[1, { joinBook: { bookId: 42, folderPath: '/elsewhere/Dune' } }]]),
+          1,
+          true,
+        );
+
+        expect(storage.moveToPath).toHaveBeenCalledWith('/tmp/dune.m4b', '/library/Frank Herbert/Dune (Unabridged)/Dune (Unabridged).m4b');
+      });
+
+      it('adds identifiers and audio facts the book lacks without overwriting what it already says', async () => {
+        const { service, db, metadataService } = makeService();
+        const set = vi.fn().mockReturnValue({ where: vi.fn().mockResolvedValue(undefined) });
+        db.update.mockReturnValue({ set });
+        const row = makeRow({
+          format: 'm4b',
+          selectedMetadata: { title: 'Dune (Unabridged)', authors: ['Simon Vance'], audibleId: 'B002V1OF70' } as BookDockMetadata,
+        });
+
+        await (service as any).applyJoinedMetadata(42, row, null);
+
+        const patch = set.mock.calls[0]![0] as Record<string, unknown>;
+        expect(patch).toHaveProperty('audibleId');
+        expect(patch).not.toHaveProperty('title');
+        expect(metadataService.replaceAuthors).not.toHaveBeenCalled();
+      });
+
+      /**
+       * The dock's own provider lookup does not know the file is the other format of a book it
+       * already has, so for an audiobook it answers with the ebook's portrait jacket. The audio slot
+       * takes the file's own art instead.
+       */
+      it("fills the new format's cover slot from the file's own art, never from the dock's lookup", async () => {
+        const { service, db, metadataService } = makeService();
+        db.update.mockReturnValue({ set: vi.fn().mockReturnValue({ where: vi.fn().mockResolvedValue(undefined) }) });
+        mockReadFile.mockResolvedValueOnce(Buffer.from('square-art') as never);
+        const row = makeRow({
+          format: 'm4b',
+          coverPath: '/dock/covers/1.jpg',
+          selectedMetadata: { title: 'Dune', coverUrl: 'https://covers.example/portrait.jpg' } as BookDockMetadata,
+        });
+
+        await (service as any).applyJoinedMetadata(42, row, 'https://covers.example/requested-square.jpg');
+
+        expect(metadataService.saveExtractedCoverBytes).toHaveBeenCalledWith(42, Buffer.from('square-art'), 'audio');
+        expect(metadataService.downloadAndSaveCover).not.toHaveBeenCalled();
+      });
+
+      it("falls back to the cover chosen when the format was requested, held to the slot's shape", async () => {
+        const { service, db, metadataService } = makeService();
+        db.update.mockReturnValue({ set: vi.fn().mockReturnValue({ where: vi.fn().mockResolvedValue(undefined) }) });
+        const row = makeRow({
+          format: 'm4b',
+          coverPath: null,
+          selectedMetadata: { title: 'Dune', coverUrl: 'https://covers.example/portrait.jpg' } as BookDockMetadata,
+        });
+
+        await (service as any).applyJoinedMetadata(42, row, 'https://covers.example/requested-square.jpg');
+
+        expect(metadataService.downloadAndSaveCover).toHaveBeenCalledTimes(1);
+        expect(metadataService.downloadAndSaveCover).toHaveBeenCalledWith([{ url: 'https://covers.example/requested-square.jpg' }], 42, 'audio');
+      });
+    });
+
     it('files a book_per_file book under the pattern folders instead of the library root', async () => {
       const { service, appSettings, processor, storage } = makeService();
       appSettings.getUploadPattern.mockResolvedValue(DEFAULT_UPLOAD_PATTERN_BOOK_PER_FILE);
@@ -793,7 +919,7 @@ describe('BookDockFinalizeService', () => {
         expect(processor.createUnitBookRecords).toHaveBeenNthCalledWith(index + 1, 5, 9, [
           expect.objectContaining({ folderPath: destPath, absolutePath: destPath }),
         ]);
-        expect(applyMetadata).toHaveBeenNthCalledWith(index + 1, 101 + index, row, true);
+        expect(applyMetadata).toHaveBeenNthCalledWith(index + 1, 101 + index, row, true, null);
       }
     });
 
@@ -1738,6 +1864,135 @@ describe('BookDockFinalizeService', () => {
     expect(metadataService.saveExtractedCoverBytes).toHaveBeenCalledWith(21, Buffer.from('cover-bytes'), 'ebook');
   });
 
+  describe('a cover the metadata lookup found by itself', () => {
+    function stubMetadataWrites(db: ReturnType<typeof makeService>['db']) {
+      const updateChain = { set: vi.fn(), where: vi.fn().mockResolvedValue(undefined) };
+      updateChain.set.mockReturnValue(updateChain);
+      db.update.mockReturnValue(updateChain);
+    }
+
+    it("puts an audiobook's own art in first, and lets the field rules' cover replace it only if it fits", async () => {
+      const { service, db, metadataService } = makeService();
+      stubMetadataWrites(db);
+      mockReadFile.mockResolvedValue(Buffer.from('square-art'));
+
+      await (service as any).applyMetadata(
+        40,
+        makeRow({ coverPath: '/tmp/cover.jpg', format: 'm4b', selectedMetadata: { title: 'Dear Debbie' } as BookDockMetadata }),
+        true,
+        'https://covers.example/print-jacket.jpg',
+      );
+
+      expect(metadataService.saveExtractedCoverBytes).toHaveBeenCalledWith(40, Buffer.from('square-art'), 'audio');
+      // Not `userChosen`: the shape check is what keeps a portrait jacket out of a filled square slot.
+      expect(metadataService.downloadAndSaveCover).toHaveBeenCalledWith([{ url: 'https://covers.example/print-jacket.jpg' }], 40, 'audio');
+      expect(metadataService.saveExtractedCoverBytes.mock.invocationCallOrder[0]).toBeLessThan(
+        metadataService.downloadAndSaveCover.mock.invocationCallOrder[0]!,
+      );
+    });
+
+    it('checks the shape of a looked-up cover an audiobook falls back to, since nobody chose it', async () => {
+      const { service, db, metadataService } = makeService();
+      stubMetadataWrites(db);
+
+      await (service as any).applyMetadata(
+        41,
+        makeRow({ coverPath: null, format: 'm4b', selectedMetadata: { title: 'Dear Debbie' } as BookDockMetadata }),
+        true,
+        'https://covers.example/print-jacket.jpg',
+      );
+
+      expect(metadataService.downloadAndSaveCover).toHaveBeenCalledWith([{ url: 'https://covers.example/print-jacket.jpg' }], 41, 'audio');
+    });
+
+    it("files an e-book by the same rule: its own art, then the field rules' cover if it fits", async () => {
+      const { service, db, metadataService } = makeService();
+      stubMetadataWrites(db);
+      mockReadFile.mockResolvedValue(Buffer.from('epub-art'));
+
+      await (service as any).applyMetadata(
+        42,
+        makeRow({ coverPath: '/tmp/cover.jpg', selectedMetadata: { title: 'Dear Debbie' } as BookDockMetadata }),
+        true,
+        'https://covers.example/jacket.jpg',
+      );
+
+      expect(metadataService.downloadAndSaveCover).toHaveBeenCalledWith([{ url: 'https://covers.example/jacket.jpg' }], 42, 'ebook');
+      expect(metadataService.saveExtractedCoverBytes).toHaveBeenCalledWith(42, Buffer.from('epub-art'), 'ebook');
+    });
+
+    it('files a managed row with the looked-up cover kept apart from what it was told to file with', async () => {
+      const { service, repo } = makeService();
+      repo.findById.mockResolvedValue(
+        makeRow({
+          id: 9,
+          format: 'm4b',
+          embeddedMetadata: { title: 'Dear Debbie' } as BookDockMetadata,
+          fetchedMetadata: { title: 'Dear Debbie', coverUrl: 'https://covers.example/print-jacket.jpg' } as BookDockMetadata,
+          selectedMetadata: null,
+        }),
+      );
+      const finalizeFile = vi.spyOn(service as any, 'finalizeFile').mockResolvedValue({ fileId: 9, fileName: 'f', success: false, message: 'x' });
+
+      await service.finalizeManagedFile(9, { libraryId: 3, folderId: 4 });
+
+      const [row, , , overrides] = finalizeFile.mock.calls[0] as [
+        BookDockFileRow,
+        unknown,
+        unknown,
+        Map<number, { lookedUpCoverUrl?: string | null }>,
+      ];
+      expect(row.selectedMetadata?.coverUrl).toBeUndefined();
+      expect(row.selectedMetadata?.title).toBe('Dear Debbie');
+      expect(overrides.get(9)?.lookedUpCoverUrl).toBe('https://covers.example/print-jacket.jpg');
+    });
+
+    it('tries the requested art for a joined format only while its slot would otherwise stay empty', async () => {
+      const { service, db, metadataService } = makeService();
+      stubMetadataWrites(db);
+      mockReadFile.mockResolvedValue(Buffer.from('square-art'));
+      const row = makeRow({ coverPath: '/tmp/cover.jpg', format: 'm4b', selectedMetadata: { title: 'Dune' } as BookDockMetadata });
+
+      await (service as any).applyJoinedMetadata(43, row, 'https://covers.example/requested.jpg', 'https://covers.example/looked-up.jpg');
+      expect(metadataService.downloadAndSaveCover).toHaveBeenLastCalledWith([{ url: 'https://covers.example/looked-up.jpg' }], 43, 'audio');
+
+      await (service as any).applyJoinedMetadata(
+        44,
+        { ...row, coverPath: null },
+        'https://covers.example/requested.jpg',
+        'https://covers.example/looked-up.jpg',
+      );
+      expect(metadataService.downloadAndSaveCover).toHaveBeenLastCalledWith(
+        [{ url: 'https://covers.example/looked-up.jpg' }, { url: 'https://covers.example/requested.jpg' }],
+        44,
+        'audio',
+      );
+    });
+
+    it('treats a cover picked in the Book Dock as chosen, whatever the lookup found', async () => {
+      const { service, repo } = makeService();
+      repo.findById.mockResolvedValue(
+        makeRow({
+          id: 9,
+          fetchedMetadata: { title: 'Dune', coverUrl: 'https://covers.example/looked-up.jpg' } as BookDockMetadata,
+          selectedMetadata: { title: 'Dune', coverUrl: 'https://covers.example/picked.jpg' } as BookDockMetadata,
+        }),
+      );
+      const finalizeFile = vi.spyOn(service as any, 'finalizeFile').mockResolvedValue({ fileId: 9, fileName: 'f', success: false, message: 'x' });
+
+      await service.finalizeManagedFile(9, {});
+
+      const [row, , , overrides] = finalizeFile.mock.calls[0] as [
+        BookDockFileRow,
+        unknown,
+        unknown,
+        Map<number, { lookedUpCoverUrl?: string | null }>,
+      ];
+      expect(row.selectedMetadata?.coverUrl).toBe('https://covers.example/picked.jpg');
+      expect(overrides.get(9)?.lookedUpCoverUrl).toBeNull();
+    });
+  });
+
   describe('multi-file units', () => {
     const UNIT_DIR = '/dock/request-7-Neuromancer';
 
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 f70e1d48a..1d7c761cc 100644
--- a/server/src/modules/book-dock/book-dock-finalize.service.ts
+++ b/server/src/modules/book-dock/book-dock-finalize.service.ts
@@ -12,7 +12,7 @@ import {
 } from '@nestjs/common';
 import { basename, dirname, extname, isAbsolute, join, relative, resolve, sep } from 'path';
 import { access as fsAccess, readFile, rmdir, stat, unlink } from 'fs/promises';
-import { eq, inArray } from 'drizzle-orm';
+import { eq, inArray, sql, type SQL } from 'drizzle-orm';
 import { NodePgDatabase } from 'drizzle-orm/node-postgres';
 import { DatabaseError } from 'pg';
 
@@ -39,7 +39,7 @@ import {
   Permission,
   resolveUploadPath,
 } from '@bookorbit/types';
-import type { BookRequestImportFormats } from '@bookorbit/types';
+import type { BookRequestImportFormats, CoverMedium } from '@bookorbit/types';
 import type { FileRole } from '../scanner/lib/classify';
 import { BookReadService } from '../book/book-read.service';
 import { NotificationService } from '../notification/notification.service';
@@ -75,10 +75,21 @@ type LibraryRow = typeof libraries.$inferSelect;
 type LibraryFolderRow = typeof libraryFolders.$inferSelect;
 type NamingLibrary = { name?: string | null; fileNamingPattern?: string | null; organizationMode?: string | null };
 
+type JoinBook = { bookId: number; folderPath: string; coverUrl?: string | null };
+
 type FinalizeOverrideEntry = {
   libraryId?: number;
   folderId?: number;
   targetFileName?: string;
+  /**
+   * An existing book this file should become another format of, by landing in that book's own
+   * folder. Honoured only where a folder is a book; anywhere else the file is filed as usual.
+   * `coverUrl` is the art chosen for this format when it was asked for, used only when the arriving
+   * files carry none of their own.
+   */
+  joinBook?: JoinBook;
+  /** A cover the metadata lookup found by itself, rather than one a person picked. See `applyMetadata`. */
+  lookedUpCoverUrl?: string | null;
 };
 
 const BATCH_SIZE = 100;
@@ -155,6 +166,9 @@ type FinalizeCandidateAnalysis = {
    * dirname there would file the book under the disc rather than under the book.
    */
   bookFolderPath?: string;
+  /** The existing book this file was placed into the folder of, when it was asked to join one. */
+  joinBook?: JoinBook;
+  lookedUpCoverUrl?: string | null;
 };
 
 /**
@@ -411,7 +425,13 @@ 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, created === bookId);
+        for (const created of written.bookIds) {
+          // A book this file was asked to join keeps the metadata it already has; the new format
+          // brings only what belongs to that format.
+          if (created === analysis.joinBook?.bookId && !written.createdBookIds.includes(created)) {
+            await this.applyJoinedMetadata(created, row, analysis.joinBook.coverUrl ?? null, analysis.lookedUpCoverUrl ?? null);
+          } else await this.applyMetadata(created, row, created === bookId, analysis.lookedUpCoverUrl ?? null);
+        }
       } 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
@@ -607,6 +627,13 @@ export class BookDockFinalizeService implements OnModuleInit, OnApplicationBoots
         destPath = candidate;
       }
 
+      // Another format of a book already on the shelf goes into that book's folder under the name
+      // the pattern gave it, so the scan and the importer agree it is one book. The pattern's own
+      // folder would follow this file's metadata, and an m4b tagged "Dune (Unabridged)" names a
+      // different folder from the epub called "Dune".
+      const joinBook = this.resolveJoinBook(override?.joinBook, library, folder);
+      if (joinBook) destPath = join(joinBook.folderPath, basename(destPath));
+
       const { files: placement, bookFolderPath } = this.resolvePlacement(row, reduced.files, destPath, folder.path, library);
       // The primary's own destination follows the placement, which for a unit means it sits inside
       // the unit folder rather than at the path the naming pattern produced directly.
@@ -614,7 +641,21 @@ export class BookDockFinalizeService implements OnModuleInit, OnApplicationBoots
 
       const newName = destPath.substring(folder.path.length + 1);
 
-      return { fileId: row.id, fileName: row.fileName, row, status: 'ready', newName, library, folder, format, destPath, placement, bookFolderPath };
+      return {
+        fileId: row.id,
+        fileName: row.fileName,
+        row,
+        status: 'ready',
+        newName,
+        library,
+        folder,
+        format,
+        destPath,
+        placement,
+        bookFolderPath,
+        ...(joinBook ? { joinBook } : {}),
+        ...(override?.lookedUpCoverUrl ? { lookedUpCoverUrl: override.lookedUpCoverUrl } : {}),
+      };
     } catch (error) {
       const status = classifyFinalizePreviewError(error);
       if (status === 'error') this.logFinalizeFailure(row.id, 'target_resolution', error);
@@ -650,6 +691,19 @@ export class BookDockFinalizeService implements OnModuleInit, OnApplicationBoots
     return { analyses, existingDestinations };
   }
 
+  /**
+   * The book to join, when joining one is possible: the library keeps one book per folder, and the
+   * book's folder is a real folder inside the one being filed into. A book sitting loose at the
+   * folder root is its own file, so another format placed beside it would be a book of its own.
+   */
+  private resolveJoinBook(joinBook: FinalizeOverrideEntry['joinBook'], library: LibraryRow, folder: LibraryFolderRow): JoinBook | null {
+    if (!joinBook || library.organizationMode !== 'book_per_folder') return null;
+    const root = resolve(folder.path);
+    const bookFolder = resolve(joinBook.folderPath);
+    if (bookFolder === root || !bookFolder.startsWith(root + sep)) return null;
+    return joinBook;
+  }
+
   /**
    * Where each file of the unit lands. A single-file row keeps today's rename-by-pattern exactly,
    * so nothing about an ordinary upload changes. A unit takes the **directory** of the pattern
@@ -926,7 +980,10 @@ export class BookDockFinalizeService implements OnModuleInit, OnApplicationBoots
     if (row.autoFinalizeSuppressed) return;
     if (!shouldAutoFinalize(row, settings.metadataMode, settings.threshold)) return;
 
-    const autoFinalizeMetadata = resolveAutoFinalizeMetadata(settings.metadataMode, row.embeddedMetadata, row.fetchedMetadata, row.selectedMetadata);
+    const { metadata: autoFinalizeMetadata, lookedUpCoverUrl } = separateLookedUpCover(
+      resolveAutoFinalizeMetadata(settings.metadataMode, row.embeddedMetadata, row.fetchedMetadata, row.selectedMetadata),
+      row.selectedMetadata,
+    );
     const rowForFinalize = autoFinalizeMetadata
       ? {
           ...row,
@@ -934,7 +991,8 @@ export class BookDockFinalizeService implements OnModuleInit, OnApplicationBoots
         }
       : row;
 
-    const result = await this.finalizeFile(rowForFinalize, settings.libraryId, settings.folderId, new Map(), 0, true);
+    const overrideMap = new Map<number, FinalizeOverrideEntry>(lookedUpCoverUrl ? [[row.id, { lookedUpCoverUrl }]] : []);
+    const result = await this.finalizeFile(rowForFinalize, settings.libraryId, settings.folderId, overrideMap, 0, true);
     if (result.success) {
       this.logger.log(`Auto-finalized Book Dock file ${fileId} -> book ${result.bookId} (confidence ${row.confidence}%)`);
       this.emitChange();
@@ -963,19 +1021,24 @@ export class BookDockFinalizeService implements OnModuleInit, OnApplicationBoots
    * Dock's auto-finalize metadata mode: that mode is an operator preference about unattended dock
    * files, and it does not govern a file another module vouched for.
    */
-  async finalizeManagedFile(fileId: number, override: { libraryId?: number; folderId?: number }): Promise<BookDockFinalizeFileResult> {
+  async finalizeManagedFile(
+    fileId: number,
+    override: { libraryId?: number; folderId?: number; joinBook?: JoinBook },
+  ): Promise<BookDockFinalizeFileResult> {
     const row = await this.repo.findById(fileId);
     if (!row) {
       return { fileId, fileName: `book-dock-file-${fileId}`, success: false, message: 'Book Dock file not found' };
     }
 
-    const merged = mergeBookDockMetadata(row.embeddedMetadata, row.fetchedMetadata, row.selectedMetadata);
+    const { metadata: merged, lookedUpCoverUrl } = separateLookedUpCover(
+      mergeBookDockMetadata(row.embeddedMetadata, row.fetchedMetadata, row.selectedMetadata),
+      row.selectedMetadata,
+    );
     const rowForFinalize = merged ? { ...row, selectedMetadata: merged } : row;
 
-    const overrideMap = new Map<number, FinalizeOverrideEntry>();
-    if (override.libraryId !== undefined || override.folderId !== undefined) {
-      overrideMap.set(fileId, { libraryId: override.libraryId, folderId: override.folderId });
-    }
+    const overrideMap = new Map<number, FinalizeOverrideEntry>([
+      [fileId, { libraryId: override.libraryId, folderId: override.folderId, joinBook: override.joinBook, lookedUpCoverUrl }],
+    ]);
 
     const result = await this.finalizeFile(rowForFinalize, undefined, undefined, overrideMap, 0, true);
     if (result.success) this.emitChange();
@@ -1147,25 +1210,103 @@ export class BookDockFinalizeService implements OnModuleInit, OnApplicationBoots
    * 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> {
+  /**
+   * What a new format adds to a book that already exists: its own cover slot, the audio facts only
+   * an audio file carries, and identifiers the book does not have yet. Nothing the book already
+   * says is overwritten - the title, authors and description were settled before this file arrived,
+   * and an audiobook's tags routinely disagree with them ("Unabridged", the narrator as author).
+   */
+  private async applyJoinedMetadata(
+    bookId: number,
+    row: BookDockFileRow,
+    requestedCoverUrl: string | null,
+    lookedUpCoverUrl: string | null,
+  ): 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([{ url: selectedCoverUrl }], bookId, medium, { userChosen: true });
+
+    // Only the new format's own slot, and the art chosen for it when it was requested only where
+    // nothing else fills it.
+    await this.applyUnpickedCover(bookId, row, medium, true, lookedUpCoverUrl, requestedCoverUrl);
+
+    const identifiers = {
+      googleBooksId: meta.googleBooksId,
+      goodreadsId: meta.goodreadsId,
+      amazonId: meta.amazonId,
+      hardcoverId: meta.hardcoverId,
+      openLibraryId: meta.openLibraryId,
+      itunesId: meta.itunesId,
+      audibleId: meta.audibleId,
+      librofmId: meta.librofmId,
+      koboId: meta.koboId,
+    } as const;
+    const fillMissing: Record<string, SQL> = {};
+    for (const [field, value] of Object.entries(identifiers)) {
+      if (value) fillMissing[field] = sql`coalesce(${bookMetadata[field as keyof typeof identifiers]}, ${value})`;
     }
 
-    if (!selectedCoverApplied && ownsStagedCover && row.coverPath) {
+    const audioPatch = medium === 'audio' ? buildAudioMetadataPatch(audio) : {};
+    if (Object.keys(fillMissing).length > 0 || Object.keys(audioPatch).length > 0) {
+      await this.db
+        .update(bookMetadata)
+        .set({ ...fillMissing, ...audioPatch, updatedAt: new Date() })
+        .where(eq(bookMetadata.bookId, bookId));
+    }
+
+    if (medium === 'audio' && audio.narrators.length > 0) {
+      await this.metadataService.replaceNarrators(
+        bookId,
+        audio.narrators.map((name) => ({ name, sortName: null })),
+      );
+    }
+
+    await this.metadataScoreService.calculateAndSave(bookId);
+  }
+
+  /**
+   * One cover slot for a file nobody picked a cover for, filled the way a metadata refresh fills it.
+   * The file's own art goes in first. The cover the field rules chose in the metadata lookup then
+   * replaces it only if it fits the slot, so the rules decide between providers while a portrait
+   * jacket can never displace the square art an m4b carries. `fallbackUrl` is tried only while the
+   * slot is still empty.
+   */
+  private async applyUnpickedCover(
+    bookId: number,
+    row: BookDockFileRow,
+    medium: CoverMedium,
+    ownsStagedCover: boolean,
+    lookedUpCoverUrl: string | null,
+    fallbackUrl: string | null,
+  ): Promise<void> {
+    let staged = false;
+    if (ownsStagedCover && row.coverPath) {
       try {
-        const bytes = await readFile(row.coverPath);
-        await this.metadataService.saveExtractedCoverBytes(bookId, bytes, medium);
+        await this.metadataService.saveExtractedCoverBytes(bookId, await readFile(row.coverPath), medium);
+        staged = true;
       } catch (err) {
         this.logger.warn(`Failed to copy Book Dock cover to book ${bookId}: ${err instanceof Error ? err.message : String(err)}`);
       }
     }
+    const urls = [lookedUpCoverUrl, staged ? null : fallbackUrl].filter((url, index, all): url is string => !!url && all.indexOf(url) === index);
+    if (urls.length > 0)
+      await this.metadataService.downloadAndSaveCover(
+        urls.map((url) => ({ url })),
+        bookId,
+        medium,
+      );
+  }
+
+  /** `lookedUpCoverUrl`: see `applyUnpickedCover`. A cover picked in the Book Dock is used as it is. */
+  private async applyMetadata(bookId: number, row: BookDockFileRow, ownsStagedCover = true, lookedUpCoverUrl: string | null = null): Promise<void> {
+    const meta = normalizeFinalizeMetadata(row.selectedMetadata ?? row.embeddedMetadata);
+    const audio = resolveAudioFinalizeFields(row.embeddedMetadata, row.selectedMetadata);
+
+    const medium = row.format && isAudioFormat(row.format) ? 'audio' : 'ebook';
+    const picked = meta.coverUrl
+      ? await this.metadataService.downloadAndSaveCover([{ url: meta.coverUrl }], bookId, medium, { userChosen: true })
+      : false;
+    if (!picked) await this.applyUnpickedCover(bookId, row, medium, ownsStagedCover, lookedUpCoverUrl, null);
 
     const scalarFields = {
       title: meta.title ?? null,
@@ -1649,6 +1790,20 @@ function mergeBookDockMetadata(
   return Object.keys(merged).length > 0 ? merged : null;
 }
 
+/**
+ * Splits off a cover the merge took from the metadata lookup. A cover in the row's own selection
+ * was picked by a person and stays; anything else the merge carried was found unattended.
+ */
+function separateLookedUpCover(
+  metadata: BookDockMetadata | null,
+  selected: BookDockMetadata | null | undefined,
+): { metadata: BookDockMetadata | null; lookedUpCoverUrl: string | null } {
+  const picked = normalizeBookDockMetadata(selected)?.coverUrl ?? null;
+  if (!metadata?.coverUrl || metadata.coverUrl === picked) return { metadata, lookedUpCoverUrl: null };
+  const { coverUrl, ...rest } = metadata;
+  return { metadata: Object.keys(rest).length > 0 ? rest : null, lookedUpCoverUrl: coverUrl };
+}
+
 function resolveAutoFinalizeMetadata(
   mode: BookDockAutoFinalizeMetadataMode,
   embedded: BookDockMetadata | null | undefined,
diff --git a/server/src/modules/book-move/book-move.repository.ts b/server/src/modules/book-move/book-move.repository.ts
index 6f988a2bf..a90928637 100644
--- a/server/src/modules/book-move/book-move.repository.ts
+++ b/server/src/modules/book-move/book-move.repository.ts
@@ -1,5 +1,6 @@
 import { deleteBooksWithHashInvalidation } from '../../db/book-file-hash-history';
 import { Inject, Injectable } from '@nestjs/common';
+import { DEFAULT_FORMAT_PRIORITY } from '@bookorbit/types';
 import { and, asc, eq, inArray, sql } from 'drizzle-orm';
 import { NodePgDatabase } from 'drizzle-orm/node-postgres';
 
@@ -20,8 +21,10 @@ import {
   userLibraryAccess,
   users,
 } from '../../db/schema';
+import { selectPrimaryFile } from '../../common/utils/primary-file-selection.utils';
 
 type Db = NodePgDatabase<typeof schema>;
+type Tx = Parameters<Parameters<Db['transaction']>[0]>[0];
 
 const ID_BATCH_SIZE = 500;
 
@@ -401,6 +404,8 @@ export class BookMoveRepository {
           .where(eq(bookFiles.id, update.fileId));
       }
 
+      await reselectPrimaryFile(tx, input.bookId, input.targetLibraryId);
+
       return { moved: true, mergedBookId };
     });
   }
@@ -498,3 +503,23 @@ export class BookMoveRepository {
     return rows.map((row) => row.id);
   }
 }
+
+/**
+ * Re-picks a moved book's primary by the library it now belongs to, the way a scan of that library
+ * would. Leaving the old library's choice in place kept an EPUB primary in a library that ranks
+ * audiobooks first, until something happened to rescan it.
+ */
+async function reselectPrimaryFile(tx: Tx, bookId: number, libraryId: number): Promise<void> {
+  const [library] = await tx.select({ formatPriority: libraries.formatPriority }).from(libraries).where(eq(libraries.id, libraryId)).limit(1);
+  const contentFiles = await tx
+    .select({ id: bookFiles.id, format: bookFiles.format, sizeBytes: bookFiles.sizeBytes, mediaOverlayAvailable: bookFiles.mediaOverlayAvailable })
+    .from(bookFiles)
+    .where(and(eq(bookFiles.bookId, bookId), eq(bookFiles.role, 'content')))
+    .orderBy(asc(bookFiles.sortOrder), asc(bookFiles.id));
+  const winner = selectPrimaryFile(contentFiles, library?.formatPriority ?? DEFAULT_FORMAT_PRIORITY);
+  if (!winner) return;
+  await tx
+    .update(books)
+    .set({ primaryFileId: winner.id })
+    .where(and(eq(books.id, bookId), sql`${books.primaryFileId} IS DISTINCT FROM ${winner.id}`));
+}
diff --git a/server/src/modules/book-request/book-request-dedupe.service.test.ts b/server/src/modules/book-request/book-request-dedupe.service.test.ts
index dd566795d..f513fd4fb 100644
--- a/server/src/modules/book-request/book-request-dedupe.service.test.ts
+++ b/server/src/modules/book-request/book-request-dedupe.service.test.ts
@@ -307,7 +307,7 @@ describe('BookRequestDedupeService.checkAvailability', () => {
     const results = await service.checkAvailability(
       [
         { title: 'Dune', isbn13: '9780441013593', mediaKind: 'ebook' },
-        { title: 'Dune', isbn13: '9780441013593', mediaKind: 'comic' },
+        { title: 'Dune', isbn13: '9780441013593', mediaKind: 'audiobook' },
       ],
       1,
       null,
@@ -315,7 +315,7 @@ describe('BookRequestDedupeService.checkAvailability', () => {
 
     expect(results.map((result) => result.ownedBookId)).toEqual([42, null]);
     expect(findOwnedMatches).toHaveBeenCalledWith(['9780441013593'], ['dune'], null, 'ebook');
-    expect(findOwnedMatches).toHaveBeenCalledWith(['9780441013593'], ['dune'], null, 'comic');
+    expect(findOwnedMatches).toHaveBeenCalledWith(['9780441013593'], ['dune'], null, 'audiobook');
   });
 
   it('falls back to a title match when the candidate has no ISBN', async () => {
diff --git a/server/src/modules/book-request/book-request.controller.ts b/server/src/modules/book-request/book-request.controller.ts
index a5994b4dc..1f57e94b4 100644
--- a/server/src/modules/book-request/book-request.controller.ts
+++ b/server/src/modules/book-request/book-request.controller.ts
@@ -9,6 +9,7 @@ import type { RequestUser } from '../../common/types/request-user';
 import { BookRequestService } from './book-request.service';
 import { CheckAvailabilityDto } from './dto/check-availability.dto';
 import { CreateBookRequestDto } from './dto/create-book-request.dto';
+import { CreateBookRequestPairDto } from './dto/create-book-request-pair.dto';
 import { BulkBookRequestsDto } from './dto/bulk-book-requests.dto';
 import { ListBookRequestsDto } from './dto/list-book-requests.dto';
 import { UpdateBookRequestLanguageDto } from './dto/update-book-request-language.dto';
@@ -29,6 +30,25 @@ export class BookRequestController {
     return this.service.submit(dto, user);
   }
 
+  /**
+   * An ebook and an audiobook of one work in one submission. A separate route rather than a flag on
+   * the one above, because the answer is two requests and a released client reads that route's
+   * answer as exactly one. Advertised by the `book-request-pairs` server feature.
+   */
+  @Post('pairs')
+  @Auditable({
+    action: AuditAction.BookRequestCreate,
+    resource: AuditResource.BookRequest,
+    getResourceId: (_req, body) => {
+      const pair = body as { ebook?: { request?: { id?: number } }; audiobook?: { request?: { id?: number } } } | undefined;
+      return pair?.ebook?.request?.id ?? pair?.audiobook?.request?.id;
+    },
+    description: 'Created an ebook and audiobook book request pair',
+  })
+  submitPair(@Body() dto: CreateBookRequestPairDto, @CurrentUser() user: RequestUser) {
+    return this.service.submitPair(dto, user);
+  }
+
   @Get()
   listMine(@Query() query: ListBookRequestsDto, @CurrentUser() user: RequestUser) {
     return this.service.listMine(query, user);
diff --git a/server/src/modules/book-request/book-request.mapper.ts b/server/src/modules/book-request/book-request.mapper.ts
index 11fc3a17e..02dd7ce60 100644
--- a/server/src/modules/book-request/book-request.mapper.ts
+++ b/server/src/modules/book-request/book-request.mapper.ts
@@ -63,6 +63,8 @@ export function mapBookRequestRow(
     subscribers,
     download: download ? mapBookRequestDownload(download) : null,
     dismissed,
+    companionRequestId: r.companionRequestId ?? null,
+    targetBookId: r.targetBookId ?? null,
     createdAt: r.createdAt.toISOString(),
     updatedAt: r.updatedAt.toISOString(),
   };
diff --git a/server/src/modules/book-request/book-request.module.ts b/server/src/modules/book-request/book-request.module.ts
index 24e48d01d..3a2327977 100644
--- a/server/src/modules/book-request/book-request.module.ts
+++ b/server/src/modules/book-request/book-request.module.ts
@@ -64,6 +64,7 @@ import { RequestFulfillmentService } from './fulfillment/request-fulfillment.ser
 import { RequestImportService } from './fulfillment/request-import.service';
 import { RequestSeedService } from './fulfillment/request-seed.service';
 import { RequestUserCleanupService } from './fulfillment/request-user-cleanup.service';
+import { RequestCompanionService } from './fulfillment/request-companion.service';
 import { RequestVerificationService } from './fulfillment/request-verification.service';
 import { RequestWatchdogService } from './fulfillment/request-watchdog.service';
 
@@ -156,6 +157,7 @@ import { RequestWatchdogService } from './fulfillment/request-watchdog.service';
     DownloadRemovalService,
     RequestFulfillmentService,
     RequestImportService,
+    RequestCompanionService,
     RequestVerificationService,
     RequestSeedService,
     RequestUserCleanupService,
diff --git a/server/src/modules/book-request/book-request.repository.ts b/server/src/modules/book-request/book-request.repository.ts
index 0cddc0084..962d1b005 100644
--- a/server/src/modules/book-request/book-request.repository.ts
+++ b/server/src/modules/book-request/book-request.repository.ts
@@ -1,7 +1,33 @@
 import { Inject, Injectable } from '@nestjs/common';
-import { and, asc, count, desc, eq, exists, ilike, inArray, isNull, lt, notExists, notInArray, or, sql, type SQL } from 'drizzle-orm';
+import {
+  and,
+  asc,
+  count,
+  desc,
+  eq,
+  exists,
+  ilike,
+  inArray,
+  isNotNull,
+  isNull,
+  lt,
+  ne,
+  not,
+  notExists,
+  notInArray,
+  or,
+  sql,
+  type SQL,
+} from 'drizzle-orm';
 import { NodePgDatabase } from 'drizzle-orm/node-postgres';
-import { ACTIVE_BOOK_REQUEST_STATUSES, AUDIO_FORMAT_LIST, COMIC_FORMAT_LIST, EBOOK_FORMAT_LIST } from '@bookorbit/types';
+import { alias } from 'drizzle-orm/pg-core';
+import {
+  ACTIVE_BOOK_REQUEST_STATUSES,
+  AUDIO_FORMAT_LIST,
+  BOOK_REQUEST_MEDIA_KINDS,
+  EBOOK_FORMAT_LIST,
+  WORKER_WRITABLE_BOOK_REQUEST_STATUSES,
+} from '@bookorbit/types';
 import type {
   BookRequestMediaKind,
   BookRequestRequesterOption,
@@ -89,7 +115,6 @@ const SELF_SERVE_CAP_LOCK_NAMESPACE = 248_001;
 const OWNED_FORMATS_BY_MEDIA_KIND: Record<BookRequestMediaKind, readonly string[]> = {
   ebook: EBOOK_FORMAT_LIST,
   audiobook: AUDIO_FORMAT_LIST,
-  comic: COMIC_FORMAT_LIST,
 };
 
 export interface ListRequestsOptions {
@@ -107,8 +132,32 @@ export interface ListRequestsOptions {
   selfServe?: boolean;
   sortBy?: BookRequestSortField;
   sortDir?: BookRequestSortDirection;
+  /**
+   * One row per visible pair, led by its ebook half. The other half is folded away and named in
+   * `visibleCompanionId` instead, and the pair matches a filter when either half does.
+   */
+  groupPairs?: boolean;
 }
 
+/** A list row, plus the companion folded into it when the list groups pairs. */
+export type BookRequestListRow = BookRequestJoinedRow & { visibleCompanionId: number | null };
+
+/** Where a book lives, which is everything filing a second format into it has to agree with. */
+export interface BookPlacement {
+  bookId: number;
+  libraryId: number;
+  libraryFolderId: number;
+  folderPath: string;
+  status: string;
+  organizationMode: string;
+}
+
+/** The other half of a pair, joined back onto the same table. */
+const companionRequests = alias(bookRequests, 'companion');
+
+/** The visibility and filter rules are asked of a request and of its companion alike. */
+type RequestTable = typeof bookRequests | typeof companionRequests;
+
 export interface BookRequestJoinedRow {
   request: BookRequestRow;
   requesterUsername: string;
@@ -132,28 +181,41 @@ export interface OwnedMatchLookup {
 export class BookRequestRepository {
   constructor(@Inject(DB) private readonly db: Db) {}
 
-  async findAll(opts: ListRequestsOptions): Promise<{ items: BookRequestJoinedRow[]; total: number }> {
+  /**
+   * Who may see a row on this list: the requester or a subscriber when the list is personal, and
+   * never a row this viewer hid. Built against a table rather than `bookRequests` itself, so the
+   * same rule can be asked of a pair's other half.
+   */
+  private visibilityConditions(table: RequestTable, opts: ListRequestsOptions): SQL[] {
     const conditions: SQL[] = [];
-    if (opts.status) conditions.push(eq(bookRequests.status, opts.status));
-    if (opts.mediaKind) conditions.push(eq(bookRequests.mediaKind, opts.mediaKind));
-    if (opts.requesterUserId !== undefined) conditions.push(eq(bookRequests.userId, opts.requesterUserId));
-    if (opts.selfServe !== undefined) conditions.push(eq(bookRequests.selfServe, opts.selfServe));
     if (opts.userId !== undefined) {
       const subscribed = this.db
         .select({ id: bookRequestSubscribers.requestId })
         .from(bookRequestSubscribers)
         .where(eq(bookRequestSubscribers.userId, opts.userId));
-      conditions.push(or(eq(bookRequests.userId, opts.userId), inArray(bookRequests.id, subscribed)) as SQL);
+      conditions.push(or(eq(table.userId, opts.userId), inArray(table.id, subscribed)) as SQL);
     }
     if (opts.excludeDismissedFor !== undefined) {
       const dismissed = this.db
         .select({ id: bookRequestDismissals.requestId })
         .from(bookRequestDismissals)
         .where(eq(bookRequestDismissals.userId, opts.excludeDismissedFor));
-      conditions.push(notInArray(bookRequests.id, dismissed));
+      conditions.push(notInArray(table.id, dismissed));
     }
+    return conditions;
+  }
 
-    const where = conditions.length ? and(...conditions) : undefined;
+  /** What the viewer narrowed the list to, as opposed to what they are allowed to see. */
+  private filterConditions(table: RequestTable, opts: ListRequestsOptions): SQL[] {
+    const conditions: SQL[] = [];
+    if (opts.status) conditions.push(eq(table.status, opts.status));
+    if (opts.mediaKind) conditions.push(eq(table.mediaKind, opts.mediaKind));
+    if (opts.requesterUserId !== undefined) conditions.push(eq(table.userId, opts.requesterUserId));
+    if (opts.selfServe !== undefined) conditions.push(eq(table.selfServe, opts.selfServe));
+    return conditions;
+  }
+
+  async findAll(opts: ListRequestsOptions): Promise<{ items: BookRequestListRow[]; total: number }> {
     const direction = opts.sortDir === 'asc' ? asc : desc;
     const SORT_COLUMNS = {
       createdAt: bookRequests.createdAt,
@@ -166,6 +228,50 @@ export class BookRequestRepository {
     // boundary when two requests share a title or a timestamp.
     const orderBy = [direction(SORT_COLUMNS[opts.sortBy ?? 'createdAt']), direction(bookRequests.id)];
 
+    const visible = this.visibilityConditions(bookRequests, opts);
+    const filters = this.filterConditions(bookRequests, opts);
+
+    if (!opts.groupPairs) {
+      const conditions = [...visible, ...filters];
+      const where = conditions.length ? and(...conditions) : undefined;
+      const [rows, [totals]] = await Promise.all([
+        this.db
+          .select({
+            request: bookRequests,
+            requesterUsername: users.username,
+            requesterName: users.name,
+            targetLibraryName: libraries.name,
+          })
+          .from(bookRequests)
+          .innerJoin(users, eq(users.id, bookRequests.userId))
+          .leftJoin(libraries, eq(libraries.id, bookRequests.targetLibraryId))
+          .where(where)
+          .orderBy(...orderBy)
+          .limit(opts.limit)
+          .offset((opts.page - 1) * opts.limit),
+        this.db.select({ total: count() }).from(bookRequests).where(where),
+      ]);
+      return { items: await this.withDecidedBy(rows.map((row) => ({ ...row, visibleCompanionId: null }))), total: totals?.total ?? 0 };
+    }
+
+    // Both pointers have to agree, so a half-written link can never fold a row away.
+    const companion = companionRequests;
+    const pairJoin = and(
+      eq(companion.id, bookRequests.companionRequestId),
+      eq(companion.companionRequestId, bookRequests.id),
+      ne(companion.mediaKind, bookRequests.mediaKind),
+    );
+    const companionVisible = and(isNotNull(companion.id), ...this.visibilityConditions(companion, opts)) as SQL;
+    const companionFilters = this.filterConditions(companion, opts);
+    const companionMatches = companionFilters.length ? (and(companionVisible, ...companionFilters) as SQL) : companionVisible;
+
+    const conditions: SQL[] = [...visible];
+    // The pair is one row, so it stays on the list when either half is what the viewer asked for.
+    if (filters.length) conditions.push(or(and(...filters), companionMatches) as SQL);
+    // The audiobook half folds into its ebook whenever the viewer can see both.
+    conditions.push(not(and(companionVisible, eq(bookRequests.mediaKind, 'audiobook')) as SQL));
+    const where = and(...conditions);
+
     const [rows, [totals]] = await Promise.all([
       this.db
         .select({
@@ -173,26 +279,46 @@ export class BookRequestRepository {
           requesterUsername: users.username,
           requesterName: users.name,
           targetLibraryName: libraries.name,
+          visibleCompanionId: sql<number | null>`case when ${companionVisible} then ${companion.id} else null end`,
         })
         .from(bookRequests)
         .innerJoin(users, eq(users.id, bookRequests.userId))
         .leftJoin(libraries, eq(libraries.id, bookRequests.targetLibraryId))
+        .leftJoin(companion, pairJoin)
         .where(where)
         .orderBy(...orderBy)
         .limit(opts.limit)
         .offset((opts.page - 1) * opts.limit),
-      this.db.select({ total: count() }).from(bookRequests).where(where),
+      this.db.select({ total: count() }).from(bookRequests).leftJoin(companion, pairJoin).where(where),
     ]);
 
-    const decidedByNames = await this.findUsernames(rows.map((r) => r.request.decidedByUserId));
+    return { items: await this.withDecidedBy(rows), total: totals?.total ?? 0 };
+  }
 
-    return {
-      items: rows.map((row) => ({
-        ...row,
-        decidedByUsername: row.request.decidedByUserId != null ? (decidedByNames.get(row.request.decidedByUserId) ?? null) : null,
-      })),
-      total: totals?.total ?? 0,
-    };
+  /** The joined form of a set of requests, in no particular order, for a pair's folded-away halves. */
+  async findByIds(ids: number[]): Promise<BookRequestJoinedRow[]> {
+    const unique = [...new Set(ids)];
+    if (unique.length === 0) return [];
+    const rows = await this.db
+      .select({
+        request: bookRequests,
+        requesterUsername: users.username,
+        requesterName: users.name,
+        targetLibraryName: libraries.name,
+      })
+      .from(bookRequests)
+      .innerJoin(users, eq(users.id, bookRequests.userId))
+      .leftJoin(libraries, eq(libraries.id, bookRequests.targetLibraryId))
+      .where(inArray(bookRequests.id, unique));
+    return this.withDecidedBy(rows);
+  }
+
+  private async withDecidedBy<T extends { request: BookRequestRow }>(rows: T[]): Promise<Array<T & { decidedByUsername: string | null }>> {
+    const decidedByNames = await this.findUsernames(rows.map((r) => r.request.decidedByUserId));
+    return rows.map((row) => ({
+      ...row,
+      decidedByUsername: row.request.decidedByUserId != null ? (decidedByNames.get(row.request.decidedByUserId) ?? null) : null,
+    }));
   }
 
   /**
@@ -269,6 +395,121 @@ export class BookRequestRepository {
     });
   }
 
+  /**
+   * Both new halves of a pair in one transaction, linked to each other before it commits.
+   *
+   * One transaction rather than two creates, because a pair that half exists is worse than either
+   * outcome: the cap could refuse the second half after the first was already queued, and a unique
+   * violation on the second would leave the first behind for the caller to retry into a fold.
+   * Rolling both back makes the retry see the world exactly as it was. Null means the cap refused.
+   */
+  async createPair(
+    entries: Array<{ data: NewBookRequestRow; aliasKeys: string[] }>,
+    selfServeCap: { userId: number; maxLive: number; newRows: number } | null,
+  ): Promise<BookRequestRow[] | null> {
+    return this.db.transaction(async (tx) => {
+      if (selfServeCap && selfServeCap.newRows > 0) {
+        await tx.execute(sql`select pg_advisory_xact_lock(${SELF_SERVE_CAP_LOCK_NAMESPACE}, ${selfServeCap.userId})`);
+        if ((await countLiveSelfServe(tx, selfServeCap.userId)) + selfServeCap.newRows > selfServeCap.maxLive) return null;
+      }
+
+      const rows: BookRequestRow[] = [];
+      for (const entry of entries) rows.push(await this.insertWithAliases(tx, entry.data, entry.aliasKeys));
+
+      if (rows.length === 2) {
+        const [first, second] = rows as [BookRequestRow, BookRequestRow];
+        await tx.update(bookRequests).set({ companionRequestId: second.id }).where(eq(bookRequests.id, first.id));
+        await tx.update(bookRequests).set({ companionRequestId: first.id }).where(eq(bookRequests.id, second.id));
+        first.companionRequestId = second.id;
+        second.companionRequestId = first.id;
+      }
+      return rows;
+    });
+  }
+
+  /**
+   * Points two requests at each other, when neither is already paired with something still live.
+   *
+   * Used when a half of a pair joined a request that already existed. That request may have been
+   * paired before; a partner that is still live is the one the dedupe claim says this pair should
+   * have joined anyway, so the link is refused rather than stolen, and a settled partner is let go
+   * so it stops pointing at a request that no longer points back. Locked, because two pairs for the
+   * same work can be submitted at the same moment.
+   */
+  async linkCompanions(firstId: number, secondId: number): Promise<boolean> {
+    if (firstId === secondId) return false;
+    return this.db.transaction(async (tx) => {
+      const rows = await tx
+        .select({ id: bookRequests.id, mediaKind: bookRequests.mediaKind, companionRequestId: bookRequests.companionRequestId })
+        .from(bookRequests)
+        .where(inArray(bookRequests.id, [firstId, secondId]))
+        .for('update');
+      if (rows.length !== 2 || rows[0]!.mediaKind === rows[1]!.mediaKind) return false;
+      if (rows.every((row) => row.companionRequestId === (row.id === firstId ? secondId : firstId))) return true;
+
+      const previous = rows.map((row) => row.companionRequestId).filter((id): id is number => id !== null && id !== firstId && id !== secondId);
+      if (previous.length > 0) {
+        const partners = await tx
+          .select({ id: bookRequests.id, status: bookRequests.status })
+          .from(bookRequests)
+          .where(inArray(bookRequests.id, previous))
+          .for('update');
+        if (partners.some((partner) => ACTIVE_BOOK_REQUEST_STATUSES.includes(partner.status as BookRequestStatus))) return false;
+        await tx
+          .update(bookRequests)
+          .set({ companionRequestId: null })
+          .where(and(inArray(bookRequests.id, previous), inArray(bookRequests.companionRequestId, [firstId, secondId])));
+      }
+
+      await tx.update(bookRequests).set({ companionRequestId: secondId }).where(eq(bookRequests.id, firstId));
+      await tx.update(bookRequests).set({ companionRequestId: firstId }).where(eq(bookRequests.id, secondId));
+      return true;
+    });
+  }
+
+  /**
+   * Names the book a request's files should join, unless one is already named or the request has
+   * already landed. A request somebody pointed at a book on purpose keeps that book.
+   */
+  async setTargetBookIfUnset(id: number, bookId: number): Promise<boolean> {
+    const rows = await this.db
+      .update(bookRequests)
+      .set({ targetBookId: bookId })
+      .where(
+        and(eq(bookRequests.id, id), isNull(bookRequests.targetBookId), inArray(bookRequests.status, [...WORKER_WRITABLE_BOOK_REQUEST_STATUSES])),
+      )
+      .returning({ id: bookRequests.id });
+    return rows.length > 0;
+  }
+
+  /** Where a book lives, or undefined when it is gone. */
+  async findBookPlacement(bookId: number): Promise<BookPlacement | undefined> {
+    const [row] = await this.db
+      .select({
+        bookId: books.id,
+        libraryId: books.libraryId,
+        libraryFolderId: books.libraryFolderId,
+        folderPath: books.folderPath,
+        status: books.status,
+        organizationMode: libraries.organizationMode,
+      })
+      .from(books)
+      .innerJoin(libraries, eq(libraries.id, books.libraryId))
+      .where(eq(books.id, bookId))
+      .limit(1);
+    return row;
+  }
+
+  /** Which media a book already holds, judged by its content files the way ownership is. */
+  async findBookMediaKinds(bookId: number): Promise<Set<BookRequestMediaKind>> {
+    const rows = await this.db
+      .selectDistinct({ format: bookFiles.format })
+      .from(bookFiles)
+      .where(and(eq(bookFiles.bookId, bookId), eq(bookFiles.role, 'content')));
+    const formats = new Set(rows.map((row) => row.format?.toLowerCase()).filter((format): format is string => Boolean(format)));
+    return new Set(BOOK_REQUEST_MEDIA_KINDS.filter((kind) => OWNED_FORMATS_BY_MEDIA_KIND[kind].some((format) => formats.has(format))));
+  }
+
   private async insertWithAliases(tx: RequestWriteExecutor, data: NewBookRequestRow, aliasKeys: string[]): Promise<BookRequestRow> {
     const [row] = await tx.insert(bookRequests).values(data).returning();
 
@@ -608,6 +849,8 @@ export class BookRequestRepository {
       .where(
         and(
           eq(bookRequests.status, 'approved'),
+          // A request for a retired medium is never searched, so it is never due either.
+          inArray(bookRequests.mediaKind, [...BOOK_REQUEST_MEDIA_KINDS]),
           sql`${bookRequests.targetLibraryId} is not null`,
           sql`${bookRequests.createdAt} > now() - make_interval(days => ${maxAgeDays})`,
           sql`now() - ${bookRequests.updatedAt} >= make_interval(hours => ${baseIntervalHours}) * least(
diff --git a/server/src/modules/book-request/book-request.service.test.ts b/server/src/modules/book-request/book-request.service.test.ts
index c060a56cb..d2c50aee6 100644
--- a/server/src/modules/book-request/book-request.service.test.ts
+++ b/server/src/modules/book-request/book-request.service.test.ts
@@ -89,6 +89,7 @@ function makeService(
     downloads?: Record<string, unknown>;
     automationSettings?: Record<string, unknown>;
     libraryService?: Record<string, unknown>;
+    companions?: Record<string, unknown>;
     /** The user a delegated submission names, as `AuthService` would resolve them. */
     actingUser?: RequestUser | null;
   } = {},
@@ -119,6 +120,12 @@ function makeService(
     findLibraryNames: vi.fn().mockResolvedValue(new Map([[7, 'Audiobooks']])),
     bookDockFileExists: vi.fn().mockResolvedValue(true),
     folderBelongsToLibrary: vi.fn().mockResolvedValue(true),
+    createPair: vi.fn().mockResolvedValue([]),
+    linkCompanions: vi.fn().mockResolvedValue(true),
+    setTargetBookIfUnset: vi.fn().mockResolvedValue(true),
+    findByIds: vi.fn().mockResolvedValue([]),
+    findBookPlacement: vi.fn().mockResolvedValue(undefined),
+    findBookMediaKinds: vi.fn().mockResolvedValue(new Set()),
     ...overrides.repo,
   };
   const dedupe = {
@@ -168,6 +175,8 @@ function makeService(
   const auth = { findActingUser: vi.fn().mockResolvedValue(overrides.actingUser ?? null) };
   const attribution = new BookRequestAttributionService(auth as never);
 
+  const companions = { handOn: vi.fn().mockResolvedValue(false), ...overrides.companions };
+
   const service = new BookRequestService(
     repo as never,
     dedupe as never,
@@ -179,9 +188,11 @@ function makeService(
     removal as never,
     gateway as never,
     attribution,
+    {} as never,
+    companions as never,
   );
 
-  return { service, repo, dedupe, libraryService, notifications, downloads, automation, automationSettings, removal, gateway, auth };
+  return { service, repo, dedupe, libraryService, notifications, downloads, automation, automationSettings, removal, gateway, auth, companions };
 }
 
 const dto = { title: 'Dune', mediaKind: 'ebook' as const, authors: ['Frank Herbert'] };
@@ -1996,6 +2007,7 @@ describe('BookRequestService.getDefaultDestinations', () => {
     await expect(service.getDefaultDestinations()).resolves.toEqual({
       ebook: { libraryId: null, libraryName: null, folderId: null },
       audiobook: { libraryId: 7, libraryName: 'Audiobooks', folderId: 21 },
+      // Retired, but released iOS builds decode it as a required field, so it is always answered empty.
       comic: { libraryId: null, libraryName: null, folderId: null },
     });
   });
@@ -2018,7 +2030,7 @@ describe('BookRequestService.getDefaultDestinations', () => {
     await service.getDefaultDestinations();
 
     expect(repo.findLibraryNames).toHaveBeenCalledTimes(1);
-    expect(repo.findLibraryNames).toHaveBeenCalledWith([7, 7, 7]);
+    expect(repo.findLibraryNames).toHaveBeenCalledWith([7, 7]);
   });
 
   /**
@@ -2094,3 +2106,337 @@ describe('BookRequestService.assertCanFulfil', () => {
     await expect(service.assertCanFulfil(10, owner())).rejects.toThrow(NotFoundException);
   });
 });
+
+describe('BookRequestService with a request for the retired comic medium', () => {
+  /** It still loads and can be closed, but nothing may send it looking for a release. */
+  it('refuses to approve it, leaving the request untouched', async () => {
+    const { service, repo, automation } = makeService();
+    repo.findById.mockResolvedValue(joined({ mediaKind: 'comic', targetLibraryId: 3 }));
+
+    await expect(service.approve(10, {}, moderator())).rejects.toThrow('Comic requests are no longer supported');
+    expect(repo.updateIf).not.toHaveBeenCalled();
+    expect(automation.considerRequest).not.toHaveBeenCalled();
+  });
+
+  it('still lets it be rejected', async () => {
+    const { service, repo } = makeService();
+    repo.findById.mockResolvedValue(joined({ mediaKind: 'comic' }));
+
+    await service.reject(10, {}, moderator());
+
+    expect(repo.updateIf).toHaveBeenCalledWith(10, ['pending'], expect.objectContaining({ status: 'rejected' }));
+  });
+});
+
+describe('BookRequestService.submitPair', () => {
+  const pairDto = {
+    title: 'Dune',
+    authors: ['Frank Herbert'],
+    ebook: { targetLibraryId: 3 },
+    audiobook: { targetLibraryId: 3, coverUrl: 'https://covers.example/dune-square.jpg', preferredFormats: ['m4b'] },
+  };
+
+  /** The repository answers a pair insert the way the real one does: both rows, already linked. */
+  function pairRows(overrides: { ebook?: Record<string, unknown>; audiobook?: Record<string, unknown> } = {}) {
+    const ebook = row({ id: 10, mediaKind: 'ebook', companionRequestId: 11, ...overrides.ebook });
+    const audiobook = row({ id: 11, mediaKind: 'audiobook', companionRequestId: 10, ...overrides.audiobook });
+    return { ebook, audiobook };
+  }
+
+  function findByIdFor(rows: Array<ReturnType<typeof row>>) {
+    return vi.fn().mockImplementation((id: number) => {
+      const found = rows.find((candidate) => candidate.id === id);
+      return Promise.resolve(found ? { ...joined(), request: found } : undefined);
+    });
+  }
+
+  it('creates both halves in one insert, each carrying its own medium, destination and formats', async () => {
+    const { ebook, audiobook } = pairRows();
+    const { service, repo } = makeService({
+      repo: { createPair: vi.fn().mockResolvedValue([ebook, audiobook]), findById: findByIdFor([ebook, audiobook]) },
+    });
+
+    const result = await service.submitPair(pairDto, user());
+
+    expect(repo.createPair).toHaveBeenCalledTimes(1);
+    const [entries, cap] = repo.createPair.mock.calls[0] as [Array<{ data: Record<string, unknown>; aliasKeys: string[] }>, unknown];
+    expect(entries.map((entry) => entry.data.mediaKind)).toEqual(['ebook', 'audiobook']);
+    expect(entries[0]!.data).toMatchObject({
+      status: 'pending',
+      targetLibraryId: 3,
+      dedupeKey: 'work:dune:frankherbert:ebook',
+      preferredFormats: [],
+    });
+    expect(entries[1]!.data).toMatchObject({
+      status: 'pending',
+      dedupeKey: 'work:dune:frankherbert:audiobook',
+      coverUrl: 'https://covers.example/dune-square.jpg',
+      preferredFormats: ['m4b'],
+    });
+    expect(cap).toBeNull();
+    expect(repo.createPair).toHaveBeenCalledWith(expect.any(Array), null);
+    expect(result.ebook.request.companionRequestId).toBe(11);
+    expect(result.audiobook.request.companionRequestId).toBe(10);
+    expect(result.ebook.subscribed).toBe(false);
+  });
+
+  it('tells the approvers once, naming both media, rather than once per half', async () => {
+    const { ebook, audiobook } = pairRows();
+    const { service, notifications } = makeService({
+      repo: { createPair: vi.fn().mockResolvedValue([ebook, audiobook]), findById: findByIdFor([ebook, audiobook]) },
+    });
+
+    await service.submitPair(pairDto, user());
+
+    const submitted = notifications.notify.mock.calls.filter(([payload]) => payload.type === NotificationType.BookRequestSubmitted);
+    expect(submitted).toHaveLength(1);
+    expect(submitted[0]![0]).toMatchObject({ message: 'Reader requested "Dune" as an ebook and an audiobook', meta: { requestId: 10 } });
+  });
+
+  it('joins a half somebody already asked for, creates the other, and links the two', async () => {
+    const existingEbook = row({ id: 7, userId: 2, mediaKind: 'ebook' });
+    const created = row({ id: 11, mediaKind: 'audiobook' });
+    const findActiveRequestFor = vi
+      .fn()
+      .mockImplementation((work: { mediaKind: string }) => Promise.resolve(work.mediaKind === 'ebook' ? existingEbook : undefined));
+    const { service, repo } = makeService({
+      dedupe: { findActiveRequestFor },
+      repo: {
+        createPair: vi.fn().mockResolvedValue([created]),
+        linkCompanions: vi.fn().mockResolvedValue(true),
+        findById: findByIdFor([existingEbook, created]),
+      },
+    });
+
+    const result = await service.submitPair(pairDto, user());
+
+    expect(repo.createPair).toHaveBeenCalledWith([expect.objectContaining({ data: expect.objectContaining({ mediaKind: 'audiobook' }) })], null);
+    expect(repo.addSubscriber).toHaveBeenCalledWith(7, 1);
+    expect(repo.linkCompanions).toHaveBeenCalledWith(7, 11);
+    expect(result.ebook.subscribed).toBe(true);
+    expect(result.audiobook.subscribed).toBe(false);
+  });
+
+  it('refuses the whole pair before writing either half when one half is refused', async () => {
+    const verifyUserAccess = vi
+      .fn()
+      .mockImplementation((_userId: number, libraryId: number) =>
+        libraryId === 9 ? Promise.reject(new ForbiddenException('No access to that library')) : Promise.resolve(undefined),
+      );
+    const { service, repo } = makeService({ libraryService: { verifyUserAccess }, repo: { createPair: vi.fn() } });
+
+    await expect(service.submitPair({ ...pairDto, audiobook: { targetLibraryId: 9 } }, user())).rejects.toMatchObject({
+      response: expect.objectContaining({ errorCode: 'SUBMIT_LIBRARY_FORBIDDEN' }),
+    });
+    expect(repo.createPair).not.toHaveBeenCalled();
+    expect(repo.addSubscriber).not.toHaveBeenCalled();
+  });
+
+  it('counts both new self-serve halves against the cap in one go, and refuses when they would overrun it', async () => {
+    const { service, repo } = makeService({ repo: { createPair: vi.fn().mockResolvedValue(null) } });
+
+    await expect(
+      service.submitPair({ ...pairDto, selfServe: true }, user({ permissions: [Permission.BookRequestAccess, Permission.BookRequestSelfFulfill] })),
+    ).rejects.toMatchObject({ response: expect.objectContaining({ errorCode: 'SUBMIT_SELF_SERVE_LIMIT' }) });
+    expect(repo.createPair).toHaveBeenCalledWith(expect.any(Array), { userId: 1, maxLive: 10, newRows: 2 });
+  });
+
+  it('points the half still to come at the book the other half is already on the shelf as', async () => {
+    const findOwnedBookFor = vi.fn().mockImplementation((work: { mediaKind: string }) => Promise.resolve(work.mediaKind === 'ebook' ? 42 : null));
+    const { ebook, audiobook } = pairRows({ ebook: { status: 'available', matchedBookId: 42 } });
+    const { service, repo } = makeService({
+      dedupe: { findOwnedBookFor },
+      repo: {
+        createPair: vi.fn().mockResolvedValue([ebook, audiobook]),
+        findById: findByIdFor([ebook, audiobook]),
+        findBookPlacement: vi.fn().mockResolvedValue({
+          bookId: 42,
+          libraryId: 3,
+          libraryFolderId: 4,
+          folderPath: '/lib/Dune',
+          status: 'present',
+          organizationMode: 'book_per_folder',
+        }),
+      },
+    });
+
+    await service.submitPair(
+      pairDto,
+      user({ contentFilters: { includeTagIds: [], excludeTagIds: [], includeGenreIds: [], excludeGenreIds: [], exemptRequestsFromUserId: 1 } }),
+    );
+
+    const [entries] = repo.createPair.mock.calls[0] as [Array<{ data: Record<string, unknown> }>];
+    expect(entries[0]!.data).toMatchObject({ status: 'available', matchedBookId: 42, targetBookId: null });
+    expect(entries[1]!.data).toMatchObject({ status: 'pending', targetBookId: 42 });
+  });
+
+  it('leaves the half still to come alone when it is headed for a different library than the shelved half', async () => {
+    const findOwnedBookFor = vi.fn().mockImplementation((work: { mediaKind: string }) => Promise.resolve(work.mediaKind === 'ebook' ? 42 : null));
+    const { ebook, audiobook } = pairRows({ ebook: { status: 'available', matchedBookId: 42 } });
+    const { service, repo } = makeService({
+      dedupe: { findOwnedBookFor },
+      repo: {
+        createPair: vi.fn().mockResolvedValue([ebook, audiobook]),
+        findById: findByIdFor([ebook, audiobook]),
+        findBookPlacement: vi.fn().mockResolvedValue({
+          bookId: 42,
+          libraryId: 5,
+          libraryFolderId: 6,
+          folderPath: '/other/Dune',
+          status: 'present',
+          organizationMode: 'book_per_folder',
+        }),
+      },
+    });
+
+    await service.submitPair(
+      pairDto,
+      user({ contentFilters: { includeTagIds: [], excludeTagIds: [], includeGenreIds: [], excludeGenreIds: [], exemptRequestsFromUserId: 1 } }),
+    );
+
+    const [entries] = repo.createPair.mock.calls[0] as [Array<{ data: Record<string, unknown> }>];
+    expect(entries[1]!.data).toMatchObject({ targetBookId: null });
+  });
+
+  it('plans again after losing an insert race, and joins whichever half the winner claimed', async () => {
+    const violation = Object.assign(new Error('duplicate key'), { code: '23505' });
+    const winner = row({ id: 7, userId: 2, mediaKind: 'audiobook' });
+    const created = row({ id: 10, mediaKind: 'ebook' });
+    const findActiveRequestFor = vi
+      .fn()
+      // First plan: nothing claimed either half.
+      .mockResolvedValueOnce(undefined)
+      .mockResolvedValueOnce(undefined)
+      // Second plan: somebody claimed the audiobook in between.
+      .mockResolvedValueOnce(undefined)
+      .mockResolvedValueOnce(winner);
+    const createPair = vi.fn().mockRejectedValueOnce(violation).mockResolvedValueOnce([created]);
+    const { service, repo } = makeService({
+      dedupe: { findActiveRequestFor },
+      repo: { createPair, linkCompanions: vi.fn().mockResolvedValue(true), findById: findByIdFor([winner, created]) },
+    });
+
+    const result = await service.submitPair(pairDto, user());
+
+    expect(createPair).toHaveBeenCalledTimes(2);
+    expect(repo.linkCompanions).toHaveBeenCalledWith(10, 7);
+    expect(result.audiobook.subscribed).toBe(true);
+  });
+});
+
+describe('BookRequestService.submit for a book that is missing a format', () => {
+  const folderBook = {
+    bookId: 42,
+    libraryId: 3,
+    libraryFolderId: 4,
+    folderPath: '/lib/Dune',
+    status: 'present',
+    organizationMode: 'book_per_folder',
+  };
+
+  it("pins the request to the book, landing it in the book's own library and folder", async () => {
+    const { service, repo } = makeService({
+      repo: { findBookPlacement: vi.fn().mockResolvedValue(folderBook), findBookMediaKinds: vi.fn().mockResolvedValue(new Set(['ebook'])) },
+    });
+
+    await service.submit({ ...dto, mediaKind: 'audiobook', targetBookId: 42, targetLibraryId: 8 }, user({ isSuperuser: true }));
+
+    expect(repo.create).toHaveBeenCalledWith(expect.objectContaining({ targetBookId: 42, targetLibraryId: 3, targetFolderId: 4 }), expect.any(Array));
+  });
+
+  it('files into a loose-file library the ordinary way, since a single file cannot hold a second format', async () => {
+    const { service, repo } = makeService({
+      repo: {
+        findBookPlacement: vi.fn().mockResolvedValue({ ...folderBook, organizationMode: 'book_per_file' }),
+        findBookMediaKinds: vi.fn().mockResolvedValue(new Set(['ebook'])),
+      },
+    });
+
+    await service.submit({ ...dto, mediaKind: 'audiobook', targetBookId: 42, targetLibraryId: 8 }, user({ isSuperuser: true }));
+
+    expect(repo.create).toHaveBeenCalledWith(expect.objectContaining({ targetBookId: null, targetLibraryId: 8 }), expect.any(Array));
+  });
+
+  it('refuses a book in a library the requester cannot reach as if it did not exist', async () => {
+    const { service, repo } = makeService({
+      repo: { findBookPlacement: vi.fn().mockResolvedValue({ ...folderBook, libraryId: 99 }), findBookMediaKinds: vi.fn() },
+    });
+
+    await expect(service.submit({ ...dto, mediaKind: 'audiobook', targetBookId: 42 }, user())).rejects.toMatchObject({
+      response: expect.objectContaining({ errorCode: 'SUBMIT_TARGET_BOOK_NOT_FOUND' }),
+    });
+    expect(repo.findBookMediaKinds).not.toHaveBeenCalled();
+    expect(repo.create).not.toHaveBeenCalled();
+  });
+
+  it('refuses a format the book already has', async () => {
+    const { service, repo } = makeService({
+      repo: { findBookPlacement: vi.fn().mockResolvedValue(folderBook), findBookMediaKinds: vi.fn().mockResolvedValue(new Set(['ebook'])) },
+    });
+
+    await expect(service.submit({ ...dto, targetBookId: 42 }, user({ isSuperuser: true }))).rejects.toMatchObject({
+      response: expect.objectContaining({ errorCode: 'SUBMIT_TARGET_BOOK_HAS_MEDIUM', errorMeta: { mediaKind: 'ebook' } }),
+    });
+    expect(repo.create).not.toHaveBeenCalled();
+  });
+
+  it('points a request it joins at the book, when that request lands in the same library', async () => {
+    const existing = row({ id: 7, userId: 2, mediaKind: 'audiobook', targetLibraryId: 3 });
+    const { service, repo } = makeService({
+      dedupe: { findActiveRequestFor: vi.fn().mockResolvedValue(existing) },
+      repo: {
+        findBookPlacement: vi.fn().mockResolvedValue(folderBook),
+        findBookMediaKinds: vi.fn().mockResolvedValue(new Set(['ebook'])),
+        setTargetBookIfUnset: vi.fn().mockResolvedValue(true),
+        findById: vi.fn().mockResolvedValue(joined({ id: 7, userId: 2, mediaKind: 'audiobook' })),
+      },
+    });
+
+    const result = await service.submit({ ...dto, mediaKind: 'audiobook', targetBookId: 42 }, user({ isSuperuser: true }));
+
+    expect(result.subscribed).toBe(true);
+    expect(repo.setTargetBookIfUnset).toHaveBeenCalledWith(7, 42);
+  });
+});
+
+describe('BookRequestService grouped lists', () => {
+  it("attaches each pair's folded-away half to the half that leads it, read in one batch", async () => {
+    const lead = { ...joined({ id: 10, mediaKind: 'ebook', companionRequestId: 11 }), visibleCompanionId: 11 };
+    const single = { ...joined({ id: 12 }), visibleCompanionId: null };
+    const { service, repo } = makeService({
+      repo: {
+        findAll: vi.fn().mockResolvedValue({ items: [lead, single], total: 2 }),
+        findByIds: vi.fn().mockResolvedValue([joined({ id: 11, mediaKind: 'audiobook', companionRequestId: 10 })]),
+      },
+    });
+
+    const page = await service.listMine({ groupPairs: true }, user());
+
+    expect(repo.findAll).toHaveBeenCalledWith(expect.objectContaining({ groupPairs: true }));
+    expect(repo.findByIds).toHaveBeenCalledTimes(1);
+    expect(repo.findByIds).toHaveBeenCalledWith([11]);
+    expect(page.items[0]!.companion?.id).toBe(11);
+    expect(page.items[1]!.companion).toBeNull();
+  });
+
+  it('leaves the shape alone for a caller that did not ask to group', async () => {
+    const { service, repo } = makeService({
+      repo: { findAll: vi.fn().mockResolvedValue({ items: [{ ...joined({ id: 10 }), visibleCompanionId: null }], total: 1 }), findByIds: vi.fn() },
+    });
+
+    const page = await service.listMine({}, user());
+
+    expect(repo.findByIds).not.toHaveBeenCalled();
+    expect(page.items[0]).not.toHaveProperty('companion');
+  });
+});
+
+describe('BookRequestService.markFulfilled for one half of a pair', () => {
+  it('hands the book on to the companion so the other half lands beside it', async () => {
+    const { service, companions } = makeService({ companions: { handOn: vi.fn().mockResolvedValue(false) } });
+
+    await service.markFulfilled(10, { matchedBookId: 42 }, moderator());
+
+    expect(companions.handOn).toHaveBeenCalledWith(expect.objectContaining({ id: 10 }), 42);
+  });
+});
diff --git a/server/src/modules/book-request/book-request.service.ts b/server/src/modules/book-request/book-request.service.ts
index 81daa6543..72590e973 100644
--- a/server/src/modules/book-request/book-request.service.ts
+++ b/server/src/modules/book-request/book-request.service.ts
@@ -8,9 +8,11 @@ import {
   BOOK_REQUEST_SUBMIT_ERROR_CODES,
   CANCELLABLE_BOOK_REQUEST_STATUSES,
   emptyResolvedRequestDestinations,
+  NO_RESOLVED_REQUEST_DESTINATION,
   FULFILLABLE_BOOK_REQUEST_STATUSES,
   isBookRequestFulfiller,
   isCancellableBookRequestStatus,
+  isBookRequestMediaKind,
   isFulfillableBookRequestStatus,
   isSettledBookRequestStatus,
   NotificationType,
@@ -26,8 +28,10 @@ import type {
   BookRequestFailureMeta,
   BookRequestSubmitErrorCode,
   BookRequestItem,
+  BookRequestMediaKind,
   BookRequestMetadataSource,
   BookRequestPage,
+  BookRequestPairSubmitResult,
   BookRequestRequesterOption,
   BookRequestStatus,
   BookRequestSubmitResult,
@@ -35,6 +39,8 @@ import type {
   BookRequestBulkResult,
   BookRequestSourceStatus,
   BookRequestSummary,
+  LegacyBookRequestMediaKind,
+  ResolvedRequestDestination,
   ResolvedRequestDestinations,
 } from '@bookorbit/types';
 
@@ -42,20 +48,23 @@ import { StatsCache } from '../../common/cache/stats-cache';
 import { isUniqueViolation } from '../../common/utils/db-error.utils';
 import { sanitizeLogValue } from '../../common/utils/log-sanitize.utils';
 import type { RequestUser } from '../../common/types/request-user';
-import type { BookRequestRow } from '../../db/schema';
+import type { BookRequestRow, NewBookRequestRow } from '../../db/schema';
 import { LibraryService } from '../library/library.service';
 import { BookRequestAttributionService } from './book-request-attribution.service';
-import { BookRequestDedupeService, dedupeKeyCandidates, primaryDedupeKey } from './book-request-dedupe.service';
+import { BookRequestDedupeService, dedupeKeyCandidates, primaryDedupeKey, type WorkIdentity } from './book-request-dedupe.service';
 import { BookRequestGateway } from './book-request.gateway';
 import { BookRequestNotifier } from './book-request-notifier.service';
 import { mapBookRequestRow } from './book-request.mapper';
 import { BookRequestDownloadRepository } from './fulfillment/book-request-download.repository';
 import { DownloadRemovalService } from './fulfillment/download-removal.service';
-import { BookRequestRepository, type BookRequestJoinedRow } from './book-request.repository';
+import { BookRequestRepository, type BookPlacement, type BookRequestJoinedRow, type BookRequestListRow } from './book-request.repository';
 import { RequestAutomationService } from './fulfillment/request-automation.service';
+import { RequestCompanionService } from './fulfillment/request-companion.service';
+import { RETIRED_MEDIUM_REFUSAL } from './retired-media';
 import { RequestAutomationSettingsService } from './fulfillment/request-automation-settings.service';
 import { IndexerConfigService } from './indexers/indexer-config.service';
-import type { CreateBookRequestDto } from './dto/create-book-request.dto';
+import type { BookRequestWorkDto, CreateBookRequestDto } from './dto/create-book-request.dto';
+import type { CreateBookRequestPairDto } from './dto/create-book-request-pair.dto';
 import type { DecideBookRequestDto } from './dto/decide-book-request.dto';
 import type { FulfillBookRequestDto } from './dto/fulfill-book-request.dto';
 import type { BulkBookRequestsDto, BulkRejectBookRequestsDto } from './dto/bulk-book-requests.dto';
@@ -138,6 +147,42 @@ function actionForbidden(errorCode: BookRequestActionErrorCode, message: string,
   return new ForbiddenException({ message, errorCode, ...(errorMeta ? { errorMeta } : {}), statusCode: HttpStatus.FORBIDDEN });
 }
 
+/** What one medium of a submission decides for itself; the work is shared. */
+interface SubmitHalf {
+  mediaKind: BookRequestMediaKind;
+  targetLibraryId: number | null;
+  targetFolderId: number | null;
+  preferredFormats: string[];
+  coverUrl: string | null;
+  /** The book a missing format was requested from, already checked against the requester. */
+  targetBook: BookPlacement | null;
+}
+
+interface PlanBase {
+  work: WorkIdentity;
+  selfServe: boolean;
+  /** The book this half's files should join when they arrive, when there is one to join. */
+  joinsBook: BookPlacement | null;
+}
+
+/** A submission that folds into a request somebody already made. */
+interface JoinPlan extends PlanBase {
+  kind: 'join';
+  existing: BookRequestRow;
+}
+
+/** A submission that becomes a row of its own. */
+interface CreatePlan extends PlanBase {
+  kind: 'create';
+  insert: NewBookRequestRow;
+  aliasKeys: string[];
+  autoApproved: boolean;
+  availableOnCreate: boolean;
+  settledOnCreate: boolean;
+}
+
+type SubmitPlan = JoinPlan | CreatePlan;
+
 function normalizeMetadataSources(sources: CreateBookRequestDto['metadataSources']): BookRequestMetadataSource[] {
   const seen = new Set<string>();
   const normalized: BookRequestMetadataSource[] = [];
@@ -176,6 +221,7 @@ export class BookRequestService {
     private readonly gateway: BookRequestGateway,
     private readonly attribution: BookRequestAttributionService,
     private readonly indexers: IndexerConfigService,
+    private readonly companions: RequestCompanionService,
   ) {}
 
   canManageAll(user: RequestUser): boolean {
@@ -232,32 +278,225 @@ export class BookRequestService {
     // Everything below asks about the subject and never about the actor: their permissions, their
     // libraries, their cap, their notifications. The actor stays the actor in the audit log.
     const subject = await this.attribution.resolveSubject(actor, dto.userId);
+    const selfServe = this.resolveSelfServe(dto, subject);
 
+    const half: SubmitHalf = {
+      mediaKind: dto.mediaKind,
+      targetLibraryId: dto.targetLibraryId ?? null,
+      targetFolderId: dto.targetFolderId ?? null,
+      preferredFormats: dto.preferredFormats ?? [],
+      coverUrl: dto.coverUrl ?? null,
+      targetBook: dto.targetBookId === undefined ? null : await this.resolveTargetBook(dto.targetBookId, dto.mediaKind, subject),
+    };
+
+    const plan = await this.planSubmission(dto, half, subject, actor, selfServe);
+    if (plan.kind === 'join') return this.joinPlanned(plan, subject);
+
+    let row: BookRequestRow | undefined;
+    // Two people hitting Request on the same book at once: the loser of the insert race is folded
+    // into the winner rather than shown a 500. The winner can be gone by the time we look for it -
+    // cancelled, rejected or deleted in that same instant - and then the claim it held is free
+    // again, so the insert that just lost would now succeed. One retry is the whole difference
+    // between that submission going through and a requester being told a book they can have does
+    // not exist.
+    for (let attempt = 0; row === undefined; attempt++) {
+      const lastAttempt = attempt >= SUBMIT_INSERT_ATTEMPTS - 1;
+      try {
+        row = await this.createRequest(plan.selfServe && !plan.availableOnCreate, plan.insert, plan.aliasKeys);
+      } catch (error: unknown) {
+        if (!isUniqueViolation(error)) throw error;
+        const winner = await this.dedupe.findActiveRequestFor(plan.work);
+        if (!winner) {
+          if (lastAttempt) throw error;
+          continue;
+        }
+        try {
+          return await this.joinPlanned(
+            { kind: 'join', existing: winner, work: plan.work, selfServe: plan.selfServe, joinsBook: plan.joinsBook },
+            subject,
+          );
+        } catch (joinError: unknown) {
+          // The winner was deleted between finding it and reading it back. Same recovery.
+          if (!(joinError instanceof NotFoundException)) throw joinError;
+          if (lastAttempt) throw error;
+        }
+      }
+    }
+
+    this.afterCreate(row, plan);
+    this.gateway.emitChanged();
+
+    if (!plan.settledOnCreate) {
+      await this.notifier.notifyApprovers(NotificationType.BookRequestSubmitted, {
+        title: 'New book request',
+        message: `${subject.name} requested "${row.title}"`,
+        actionUrl: '/requests?tab=all',
+        meta: { requestId: row.id },
+      });
+    }
+
+    const joined = await this.repo.findById(row.id);
+    if (!joined) throw new NotFoundException('Book request not found');
+    return { request: await this.toItem(joined, subject.id), subscribed: false };
+  }
+
+  /**
+   * An ebook and an audiobook of one work, asked for together.
+   *
+   * Each half goes through exactly the rules a single request does - it may join a request that
+   * already exists, arrive already available, or be created - and both are worked out before
+   * either is written, so a half the rules refuse never leaves the other one behind. What the pair
+   * adds is the link between the halves, one announcement for the approvers rather than two, and
+   * the book the second half should join when the first is already on the shelf.
+   */
+  async submitPair(dto: CreateBookRequestPairDto, actor: RequestUser): Promise<BookRequestPairSubmitResult> {
+    const subject = await this.attribution.resolveSubject(actor, dto.userId);
+    const selfServe = this.resolveSelfServe(dto, subject);
+    const halves = BOOK_REQUEST_MEDIA_KINDS.map((mediaKind): SubmitHalf => {
+      const half = dto[mediaKind];
+      return {
+        mediaKind,
+        targetLibraryId: half?.targetLibraryId ?? null,
+        targetFolderId: half?.targetFolderId ?? null,
+        preferredFormats: half?.preferredFormats ?? [],
+        coverUrl: half?.coverUrl ?? dto.coverUrl ?? null,
+        targetBook: null,
+      };
+    });
+
+    for (let attempt = 0; ; attempt++) {
+      const lastAttempt = attempt >= SUBMIT_INSERT_ATTEMPTS - 1;
+      // Sequential on purpose: the second half's ownership probe is the same query as the first's,
+      // and a refusal on the ebook should not have spent the audiobook's lookups.
+      const plans: SubmitPlan[] = [];
+      for (const half of halves) plans.push(await this.planSubmission(dto, half, subject, actor, selfServe));
+      await this.pointAtOwnedCompanion(plans);
+
+      const creates = plans.filter((plan): plan is CreatePlan => plan.kind === 'create');
+      let created: BookRequestRow[] = [];
+      if (creates.length > 0) {
+        const newSelfServe = creates.filter((plan) => plan.selfServe && !plan.availableOnCreate).length;
+        try {
+          const rows = await this.repo.createPair(
+            creates.map((plan) => ({ data: plan.insert, aliasKeys: plan.aliasKeys })),
+            newSelfServe > 0 ? { userId: subject.id, maxLive: MAX_LIVE_SELF_SERVE_REQUESTS, newRows: newSelfServe } : null,
+          );
+          if (!rows) throw this.selfServeLimitRefusal();
+          created = rows;
+        } catch (error: unknown) {
+          // Somebody claimed one of these works between planning and inserting. Both inserts rolled
+          // back together, so planning again sees that request and joins it instead.
+          if (!isUniqueViolation(error) || lastAttempt) throw error;
+          continue;
+        }
+      }
+
+      const results = new Map<BookRequestMediaKind, BookRequestSubmitResult>();
+      const rowIds = new Map<BookRequestMediaKind, number>();
+      for (const plan of plans) {
+        const mediaKind = plan.work.mediaKind as BookRequestMediaKind;
+        if (plan.kind === 'join') {
+          const result = await this.joinPlanned(plan, subject);
+          results.set(mediaKind, result);
+          rowIds.set(mediaKind, result.request.id);
+          continue;
+        }
+        const row = created.find((candidate) => candidate.mediaKind === mediaKind);
+        if (!row) throw new NotFoundException('Book request not found');
+        rowIds.set(mediaKind, row.id);
+        this.afterCreate(row, plan);
+      }
+
+      // Two new halves were linked inside their own transaction; anything that joined an existing
+      // request is linked to its partner here, against whatever that request is paired with now.
+      const ebookId = rowIds.get('ebook')!;
+      const audiobookId = rowIds.get('audiobook')!;
+      if (created.length < 2) await this.repo.linkCompanions(ebookId, audiobookId);
+
+      this.gateway.emitChanged();
+      await this.announcePair(subject, creates, created);
+
+      for (const mediaKind of BOOK_REQUEST_MEDIA_KINDS) {
+        if (results.has(mediaKind)) {
+          // Re-read after linking, so the joined half reports the companion it now has.
+          const joined = await this.repo.findById(rowIds.get(mediaKind)!);
+          if (joined) results.set(mediaKind, { ...results.get(mediaKind)!, request: await this.toItem(joined, subject.id) });
+          continue;
+        }
+        const joined = await this.repo.findById(rowIds.get(mediaKind)!);
+        if (!joined) throw new NotFoundException('Book request not found');
+        results.set(mediaKind, { request: await this.toItem(joined, subject.id), subscribed: false });
+      }
+
+      this.logger.log(
+        `[book_request.create_pair] [end] userId=${subject.id} ebookRequestId=${ebookId} audiobookRequestId=${audiobookId} created=${created.length} - book request pair submitted`,
+      );
+      return { ebook: results.get('ebook')!, audiobook: results.get('audiobook')! };
+    }
+  }
+
+  /**
+   * Explicit rather than inferred from the permission. Inferring it would silently turn
+   * `BookRequestSelfFulfill` into auto-approval for every ordinary request its holder makes.
+   */
+  private resolveSelfServe(dto: { selfServe?: boolean }, subject: RequestUser): boolean {
+    const selfServe = dto.selfServe === true;
+    if (selfServe && !this.canSelfFulfil(subject)) {
+      throw submitForbidden('SUBMIT_SELF_FULFIL_FORBIDDEN', 'You cannot fulfil your own book requests');
+    }
+    return selfServe;
+  }
+
+  /**
+   * The book a missing format was asked for from, checked the way any other reference to a book is:
+   * it has to be somewhere the requester can reach, and it has to actually be missing that format.
+   */
+  private async resolveTargetBook(bookId: number, mediaKind: BookRequestMediaKind, subject: RequestUser): Promise<BookPlacement> {
+    const [placement, reachable] = await Promise.all([this.repo.findBookPlacement(bookId), this.reachableLibraryIds(subject)]);
+    if (!placement || placement.status !== 'present' || (reachable !== null && !reachable.includes(placement.libraryId))) {
+      throw submitRefusal('SUBMIT_TARGET_BOOK_NOT_FOUND', 'That book is not in a library you can reach');
+    }
+    if ((await this.repo.findBookMediaKinds(bookId)).has(mediaKind)) {
+      throw submitRefusal('SUBMIT_TARGET_BOOK_HAS_MEDIUM', `That book already has a ${mediaKind}`, { mediaKind });
+    }
+    return placement;
+  }
+
+  /**
+   * One medium's submission, worked out but not yet written: either the live request it joins, or
+   * the row it would insert. Every refusal a submission can raise is raised here, before anything
+   * is written, which is what lets a pair refuse both halves cleanly.
+   */
+  private async planSubmission(
+    dto: BookRequestWorkDto,
+    half: SubmitHalf,
+    subject: RequestUser,
+    actor: RequestUser,
+    selfServe: boolean,
+  ): Promise<SubmitPlan> {
     const metadataSources = normalizeMetadataSources(dto.metadataSources);
-    const work = {
+    const work: WorkIdentity = {
       title: dto.title.trim(),
       authors: dto.authors ?? [],
       isbn13: dto.isbn13 ?? null,
       providerKey: dto.providerKey ?? null,
       providerId: dto.providerId ?? null,
       metadataSources,
-      mediaKind: dto.mediaKind,
+      mediaKind: half.mediaKind,
     };
 
     if (!work.title) throw submitRefusal('SUBMIT_TITLE_REQUIRED', 'A title is required');
 
-    // Explicit rather than inferred from the permission. Inferring it would silently turn
-    // `BookRequestSelfFulfill` into auto-approval for every ordinary request its holder makes.
-    const selfServe = dto.selfServe === true;
-    if (selfServe && !this.canSelfFulfil(subject)) {
-      throw submitForbidden('SUBMIT_SELF_FULFIL_FORBIDDEN', 'You cannot fulfil your own book requests');
-    }
+    // A book that can hold another format pins where this one lands: next to the format it has.
+    // A loose-file library cannot hold two formats as one book, so there the request lands the way
+    // any other does and becomes a book of its own.
+    const joinsBook = half.targetBook !== null && half.targetBook.organizationMode === 'book_per_folder' ? half.targetBook : null;
 
     // Fold into an existing live request rather than opening a second one. A second grab of the
     // same torrent is exactly what the dedupe claim exists to prevent, so even a self-server is
     // folded - but folded as the person who is going to fulfil it, not as a bystander.
     const existing = await this.dedupe.findActiveRequestFor(work);
-    if (existing) return selfServe ? this.takeOnOrAttach(existing, subject) : this.attachTo(existing.id, subject);
+    if (existing) return { kind: 'join', existing, selfServe, work, joinsBook };
 
     const maySeeRequestedBooks = subject.contentFilters.exemptRequestsFromUserId === subject.id;
     const existingBookId = maySeeRequestedBooks ? await this.dedupe.findOwnedBookFor(work, await this.reachableLibraryIds(subject)) : null;
@@ -265,9 +504,12 @@ export class BookRequestService {
     let targetLibraryId: number | null = null;
     let targetFolderId: number | null = null;
 
-    if (existingBookId === null) {
-      targetLibraryId = await this.resolveRequestedLibrary(dto.targetLibraryId ?? null, subject);
-      targetFolderId = await this.resolveDestinationFolder(dto.targetFolderId ?? null, targetLibraryId);
+    if (existingBookId === null && joinsBook) {
+      targetLibraryId = joinsBook.libraryId;
+      targetFolderId = joinsBook.libraryFolderId;
+    } else if (existingBookId === null) {
+      targetLibraryId = await this.resolveRequestedLibrary(half.targetLibraryId, subject);
+      targetFolderId = await this.resolveDestinationFolder(half.targetFolderId, targetLibraryId);
 
       // The instance default for this medium, which is the last rung: the requester named nowhere,
       // and the medium is the only thing about the eventual file that is known this early.
@@ -276,7 +518,7 @@ export class BookRequestService {
       // operator chose it for the whole instance, and a requester who cannot see that library is
       // exactly who the default exists for.
       if (targetLibraryId === null) {
-        const fallback = await this.automationSettings.resolveDestinationFor(dto.mediaKind);
+        const fallback = await this.automationSettings.resolveDestinationFor(half.mediaKind);
 
         // The one exception to "the operator chose it for the instance". A self-server is the person
         // filing the book, with nobody reviewing where it lands, so an unreachable default would let
@@ -309,15 +551,15 @@ export class BookRequestService {
       throw submitRefusal('SUBMIT_DESTINATION_REQUIRED', 'Pick a destination library: your own requests are approved without a second pair of eyes');
     }
 
-    const insert = {
+    const insert: NewBookRequestRow = {
       userId: subject.id,
       createdByUserId: this.attribution.createdByUserIdFor(actor, subject),
-      mediaKind: dto.mediaKind,
-      status: availableOnCreate ? ('available' as const) : approvedOnCreate ? ('approved' as const) : ('pending' as const),
+      mediaKind: half.mediaKind,
+      status: availableOnCreate ? 'available' : approvedOnCreate ? 'approved' : 'pending',
       selfServe,
       title: work.title,
       subtitle: dto.subtitle ?? null,
-      authors: work.authors,
+      authors: work.authors ?? [],
       seriesName: dto.seriesName ?? null,
       seriesIndex: dto.seriesIndex ?? null,
       isbn10: dto.isbn10 ?? null,
@@ -327,53 +569,70 @@ export class BookRequestService {
       // or nothing at all. The matcher compares codes, so anything else is a filter that either
       // rejects everything or agrees by accident.
       language: toRequestLanguage(dto.language),
-      coverUrl: dto.coverUrl ?? null,
+      coverUrl: half.coverUrl,
       providerKey: dto.providerKey ?? null,
       providerId: dto.providerId ?? null,
       metadataSources,
-      preferredFormats: dto.preferredFormats ?? [],
+      preferredFormats: half.preferredFormats,
       note: dto.note ?? null,
       targetLibraryId,
       targetFolderId,
       matchedBookId: existingBookId,
+      targetBookId: availableOnCreate ? null : (joinsBook?.bookId ?? null),
       dedupeKey: primaryDedupeKey(work),
       decidedByUserId: approvedOnCreate ? subject.id : null,
       decidedAt: approvedOnCreate ? new Date() : null,
     };
-    // Every other key this work could have hashed to, so a later requester who reaches it a
-    // different way still collides with this row rather than opening a second one.
-    const aliasKeys = dedupeKeyCandidates(work);
 
-    let row: BookRequestRow | undefined;
-    // Two people hitting Request on the same book at once: the loser of the insert race is folded
-    // into the winner rather than shown a 500. The winner can be gone by the time we look for it -
-    // cancelled, rejected or deleted in that same instant - and then the claim it held is free
-    // again, so the insert that just lost would now succeed. One retry is the whole difference
-    // between that submission going through and a requester being told a book they can have does
-    // not exist.
-    for (let attempt = 0; row === undefined; attempt++) {
-      const lastAttempt = attempt >= SUBMIT_INSERT_ATTEMPTS - 1;
-      try {
-        row = await this.createRequest(selfServe && !availableOnCreate, insert, aliasKeys);
-      } catch (error: unknown) {
-        if (!isUniqueViolation(error)) throw error;
-        const winner = await this.dedupe.findActiveRequestFor(work);
-        if (!winner) {
-          if (lastAttempt) throw error;
-          continue;
-        }
-        try {
-          return selfServe ? await this.takeOnOrAttach(winner, subject) : await this.attachTo(winner.id, subject);
-        } catch (joinError: unknown) {
-          // The winner was deleted between finding it and reading it back. Same recovery.
-          if (!(joinError instanceof NotFoundException)) throw joinError;
-          if (lastAttempt) throw error;
-        }
-      }
+    return {
+      kind: 'create',
+      work,
+      insert,
+      // Every other key this work could have hashed to, so a later requester who reaches it a
+      // different way still collides with this row rather than opening a second one.
+      aliasKeys: dedupeKeyCandidates(work),
+      selfServe,
+      autoApproved,
+      availableOnCreate,
+      settledOnCreate,
+      joinsBook,
+    };
+  }
+
+  /**
+   * Joining a live request, as the person who is going to fulfil it when they asked to. A request
+   * made from a book's page also tells the joined request which book to land in, unless that
+   * request already lands somewhere else.
+   */
+  private async joinPlanned(plan: JoinPlan, subject: RequestUser): Promise<BookRequestSubmitResult> {
+    const result = plan.selfServe ? await this.takeOnOrAttach(plan.existing, subject) : await this.attachTo(plan.existing.id, subject);
+    if (plan.joinsBook && plan.existing.targetLibraryId === plan.joinsBook.libraryId) {
+      await this.repo.setTargetBookIfUnset(plan.existing.id, plan.joinsBook.bookId);
     }
+    return result;
+  }
 
+  /**
+   * When one half of a pair is already on the shelf, the half still to come should land beside it
+   * rather than wherever its own metadata would file it. Only within one library that keeps a book
+   * per folder: a pair asked for into two different libraries is two books by the requester's own
+   * choice, and a loose-file library cannot hold two formats as one book.
+   */
+  private async pointAtOwnedCompanion(plans: SubmitPlan[]): Promise<void> {
+    const owned = plans.find((plan): plan is CreatePlan => plan.kind === 'create' && plan.availableOnCreate);
+    const pending = plans.find((plan): plan is CreatePlan => plan.kind === 'create' && !plan.availableOnCreate);
+    if (!owned?.insert.matchedBookId || !pending || pending.insert.targetBookId) return;
+
+    const placement = await this.repo.findBookPlacement(owned.insert.matchedBookId);
+    if (!placement || placement.status !== 'present' || placement.organizationMode !== 'book_per_folder') return;
+    if (pending.insert.targetLibraryId !== placement.libraryId) return;
+    pending.insert.targetBookId = placement.bookId;
+  }
+
+  /** Everything a freshly inserted request sets in motion besides the announcement. */
+  private afterCreate(row: BookRequestRow, plan: CreatePlan): void {
     this.logger.log(
-      `[book_request.create] [end] requestId=${row.id} userId=${row.userId} createdByUserId=${row.createdByUserId ?? '-'} mediaKind=${row.mediaKind} autoApproved=${autoApproved} selfServe=${selfServe} availableOnCreate=${availableOnCreate} title="${sanitizeLogValue(row.title)}" - book request created`,
+      `[book_request.create] [end] requestId=${row.id} userId=${row.userId} createdByUserId=${row.createdByUserId ?? '-'} mediaKind=${row.mediaKind} autoApproved=${plan.autoApproved} selfServe=${plan.selfServe} availableOnCreate=${plan.availableOnCreate} title="${sanitizeLogValue(row.title)}" - book request created`,
     );
 
     // An auto-approving user never waits for a decision, so there is nobody to open the picker:
@@ -383,25 +642,35 @@ export class BookRequestService {
     //
     // Never for a self-server, who is on their way to the picker right now. Automation would race
     // them onto a release they did not choose, which is the opposite of what they asked for.
-    if (!availableOnCreate && autoApproved && !selfServe) this.automation.considerRequest(row.id, 'auto_approval');
+    if (!plan.availableOnCreate && plan.autoApproved && !plan.selfServe) this.automation.considerRequest(row.id, 'auto_approval');
+  }
 
-    // Every page answers this with a fetch, so it is what puts a new submission in front of the
-    // approvers without them reloading. After the create rather than after the notification: an
-    // approver whose queue is already open sees the row arrive whether or not they are notified.
-    this.gateway.emitChanged();
+  /**
+   * One announcement for a pair, naming both media when both are waiting. Two notifications for
+   * one ask is the queue counting the same person twice.
+   */
+  private async announcePair(subject: RequestUser, plans: CreatePlan[], rows: BookRequestRow[]): Promise<void> {
+    const waiting = rows.filter((row) => plans.some((plan) => plan.insert.mediaKind === row.mediaKind && !plan.settledOnCreate));
+    if (waiting.length === 0) return;
 
-    if (!settledOnCreate) {
-      await this.notifier.notifyApprovers(NotificationType.BookRequestSubmitted, {
-        title: 'New book request',
-        message: `${subject.name} requested "${row.title}"`,
-        actionUrl: '/requests?tab=all',
-        meta: { requestId: row.id },
-      });
-    }
+    const lead = waiting.find((row) => row.mediaKind === 'ebook') ?? waiting[0]!;
+    await this.notifier.notifyApprovers(NotificationType.BookRequestSubmitted, {
+      title: 'New book request',
+      message:
+        waiting.length > 1 ? `${subject.name} requested "${lead.title}" as an ebook and an audiobook` : `${subject.name} requested "${lead.title}"`,
+      actionUrl: '/requests?tab=all',
+      meta: { requestId: lead.id },
+    });
+  }
 
-    const joined = await this.repo.findById(row.id);
-    if (!joined) throw new NotFoundException('Book request not found');
-    return { request: await this.toItem(joined, subject.id), subscribed: false };
+  private selfServeLimitRefusal(): ForbiddenException {
+    return submitForbidden(
+      'SUBMIT_SELF_SERVE_LIMIT',
+      `Finish or cancel some downloads first: ${MAX_LIVE_SELF_SERVE_REQUESTS} can be in flight at once`,
+      {
+        limit: MAX_LIVE_SELF_SERVE_REQUESTS,
+      },
+    );
   }
 
   /**
@@ -417,13 +686,7 @@ export class BookRequestService {
     if (!selfServe) return this.repo.create(data, aliasKeys);
 
     const row = await this.repo.createWithinSelfServeCap(data, aliasKeys, MAX_LIVE_SELF_SERVE_REQUESTS);
-    if (!row) {
-      throw submitForbidden(
-        'SUBMIT_SELF_SERVE_LIMIT',
-        `Finish or cancel some downloads first: ${MAX_LIVE_SELF_SERVE_REQUESTS} can be in flight at once`,
-        { limit: MAX_LIVE_SELF_SERVE_REQUESTS },
-      );
-    }
+    if (!row) throw this.selfServeLimitRefusal();
     return row;
   }
 
@@ -548,8 +811,11 @@ export class BookRequestService {
    * requester submits with no idea where the book goes. Not filtered by what this user can browse,
    * for the same reason the default itself is not: the operator chose it for the instance, and a
    * requester who cannot see that library is exactly who is looking at an empty select.
+   *
+   * The retired `comic` is still answered, always with no destination: released iOS builds decode
+   * it as a required field, and without it their whole request screen fails to load.
    */
-  async getDefaultDestinations(): Promise<ResolvedRequestDestinations> {
+  async getDefaultDestinations(): Promise<ResolvedRequestDestinations & Record<LegacyBookRequestMediaKind, ResolvedRequestDestination>> {
     const resolved = await Promise.all(
       BOOK_REQUEST_MEDIA_KINDS.map(async (mediaKind) => [mediaKind, await this.automationSettings.resolveDestinationFor(mediaKind)] as const),
     );
@@ -564,7 +830,7 @@ export class BookRequestService {
         folderId: destination.folderId,
       };
     }
-    return destinations;
+    return { ...destinations, comic: { ...NO_RESOLVED_REQUEST_DESTINATION } };
   }
 
   async listMine(dto: ListBookRequestsDto, user: RequestUser): Promise<BookRequestPage> {
@@ -578,8 +844,9 @@ export class BookRequestService {
       excludeDismissedFor: dto.includeDismissed ? undefined : user.id,
       sortBy: dto.sortBy,
       sortDir: dto.sortDir,
+      groupPairs: dto.groupPairs,
     });
-    return { items: await this.toItems(items, user.id), total };
+    return { items: await this.toListItems(items, user.id, dto.groupPairs === true), total };
   }
 
   async listAll(dto: ListAllBookRequestsDto, user: RequestUser): Promise<BookRequestPage> {
@@ -594,8 +861,9 @@ export class BookRequestService {
       excludeDismissedFor: dto.includeDismissed ? undefined : user.id,
       sortBy: dto.sortBy,
       sortDir: dto.sortDir,
+      groupPairs: dto.groupPairs,
     });
-    return { items: await this.toItems(items, user.id), total };
+    return { items: await this.toListItems(items, user.id, dto.groupPairs === true), total };
   }
 
   listRequesterOptions(dto: ListRequesterOptionsDto): Promise<BookRequestRequesterOption[]> {
@@ -842,6 +1110,10 @@ export class BookRequestService {
   async approve(id: number, dto: DecideBookRequestDto, user: RequestUser): Promise<BookRequestItem> {
     const joined = await this.repo.findById(id);
     if (!joined) throw new NotFoundException('Book request not found');
+    const mediaKind = joined.request.mediaKind;
+    // A request for a retired medium can still be rejected, cancelled or deleted, but approving it
+    // would hand automation a search for something no source is configured to look for.
+    if (!isBookRequestMediaKind(mediaKind)) throw new BadRequestException(RETIRED_MEDIUM_REFUSAL);
     if (joined.request.status !== 'pending') {
       throw actionRefusal('BOOK_REQUEST_NOT_PENDING', `Only a pending request can be approved; this one is ${joined.request.status}`, {
         action: 'approve',
@@ -860,7 +1132,7 @@ export class BookRequestService {
     // no reason to make the approver retype one the operator has since set.
     let carriedFolderId = dto.targetFolderId ?? joined.request.targetFolderId;
     if (targetLibraryId === null) {
-      const fallback = await this.automationSettings.resolveDestinationFor(joined.request.mediaKind);
+      const fallback = await this.automationSettings.resolveDestinationFor(mediaKind);
       targetLibraryId = fallback.libraryId;
       carriedFolderId ??= fallback.folderId;
     }
@@ -1097,6 +1369,8 @@ export class BookRequestService {
       message: `"${joined.request.title}" is ready`,
       meta: { requestId: id, bookId: dto.matchedBookId ?? null },
     });
+    // Closing one half of a pair by hand still tells the other half where it belongs.
+    if (dto.matchedBookId != null && (await this.companions.handOn(joined.request, dto.matchedBookId))) this.gateway.emitChanged();
 
     return this.getOne(id, user);
   }
@@ -1134,6 +1408,23 @@ export class BookRequestService {
     );
   }
 
+  /**
+   * A page of the list, with each pair's folded-away half attached to the half that leads it. The
+   * companions are read in one batch for the page, never one at a time.
+   */
+  private async toListItems(rows: BookRequestListRow[], viewerId: number, groupPairs: boolean): Promise<BookRequestItem[]> {
+    const items = await this.toItems(rows, viewerId);
+    if (!groupPairs) return items;
+
+    const companionIds = rows.map((row) => row.visibleCompanionId).filter((id): id is number => id !== null);
+    const companions = companionIds.length ? await this.toItems(await this.repo.findByIds(companionIds), viewerId) : [];
+    const byId = new Map(companions.map((item) => [item.id, item]));
+    return items.map((item, index) => {
+      const companionId = rows[index]!.visibleCompanionId;
+      return { ...item, companion: companionId === null ? null : (byId.get(companionId) ?? null) };
+    });
+  }
+
   private async toItem(row: BookRequestJoinedRow, viewerId: number): Promise<BookRequestItem> {
     const [item] = await this.toItems([row], viewerId);
     return item;
diff --git a/server/src/modules/book-request/dto/automation-settings.dto.ts b/server/src/modules/book-request/dto/automation-settings.dto.ts
index 288a4d7ae..9c701863b 100644
--- a/server/src/modules/book-request/dto/automation-settings.dto.ts
+++ b/server/src/modules/book-request/dto/automation-settings.dto.ts
@@ -59,11 +59,6 @@ class RequestDestinationDefaultsDto {
   @ValidateNested()
   @Type(() => RequestDestinationDto)
   audiobook?: RequestDestinationDto;
-
-  @IsOptional()
-  @ValidateNested()
-  @Type(() => RequestDestinationDto)
-  comic?: RequestDestinationDto;
 }
 
 /**
@@ -162,13 +157,6 @@ class ReleaseProfilesDto {
   @ValidateNested({ each: true })
   @Type(() => ReleaseTierDto)
   audiobook?: ReleaseTierDto[];
-
-  @IsOptional()
-  @IsArray()
-  @ArrayMaxSize(MAX_RELEASE_TIERS)
-  @ValidateNested({ each: true })
-  @Type(() => ReleaseTierDto)
-  comic?: ReleaseTierDto[];
 }
 
 /**
diff --git a/server/src/modules/book-request/dto/create-book-request-pair.dto.ts b/server/src/modules/book-request/dto/create-book-request-pair.dto.ts
new file mode 100644
index 000000000..6a077984b
--- /dev/null
+++ b/server/src/modules/book-request/dto/create-book-request-pair.dto.ts
@@ -0,0 +1,45 @@
+import { Type } from 'class-transformer';
+import { ArrayMaxSize, IsArray, IsInt, IsOptional, IsString, IsUrl, MaxLength, Min, ValidateNested } from 'class-validator';
+import type { BookRequestPairHalfPayload } from '@bookorbit/types';
+
+import { BookRequestWorkDto } from './create-book-request.dto';
+
+/** The part of a pair one medium decides for itself. */
+export class BookRequestPairHalfDto implements BookRequestPairHalfPayload {
+  @IsOptional()
+  @Type(() => Number)
+  @IsInt()
+  @Min(1)
+  targetLibraryId?: number;
+
+  @IsOptional()
+  @Type(() => Number)
+  @IsInt()
+  @Min(1)
+  targetFolderId?: number;
+
+  @IsOptional()
+  @IsArray()
+  @ArrayMaxSize(20)
+  @IsString({ each: true })
+  @MaxLength(20, { each: true })
+  preferredFormats?: string[];
+
+  @IsOptional()
+  @IsString()
+  @MaxLength(2048)
+  @IsUrl({ protocols: ['http', 'https'], require_protocol: true, require_tld: false }, { message: 'coverUrl must be an http or https address' })
+  coverUrl?: string;
+}
+
+export class CreateBookRequestPairDto extends BookRequestWorkDto {
+  @IsOptional()
+  @ValidateNested()
+  @Type(() => BookRequestPairHalfDto)
+  ebook?: BookRequestPairHalfDto;
+
+  @IsOptional()
+  @ValidateNested()
+  @Type(() => BookRequestPairHalfDto)
+  audiobook?: BookRequestPairHalfDto;
+}
diff --git a/server/src/modules/book-request/dto/create-book-request.dto.ts b/server/src/modules/book-request/dto/create-book-request.dto.ts
index aeba03e7c..0ee7a3cef 100644
--- a/server/src/modules/book-request/dto/create-book-request.dto.ts
+++ b/server/src/modules/book-request/dto/create-book-request.dto.ts
@@ -35,7 +35,12 @@ export class BookRequestMetadataSourceDto {
   isbn13?: string | null;
 }
 
-export class CreateBookRequestDto {
+/**
+ * Everything that describes the work and who is asking for it, shared by a single request and by
+ * an ebook and audiobook pair. What differs per medium - the medium itself, where it lands and
+ * which formats are preferred - is declared by each subclass.
+ */
+export class BookRequestWorkDto {
   /**
    * File this as somebody else, for a front end that its users sign into instead of this one.
    *
@@ -53,9 +58,6 @@ export class CreateBookRequestDto {
   @MaxLength(500)
   title!: string;
 
-  @IsIn(BOOK_REQUEST_MEDIA_KINDS)
-  mediaKind!: BookRequestMediaKind;
-
   @IsOptional()
   @IsString()
   @MaxLength(500)
@@ -133,6 +135,16 @@ export class CreateBookRequestDto {
   @Type(() => BookRequestMetadataSourceDto)
   metadataSources?: BookRequestMetadataSourceDto[];
 
+  @IsOptional()
+  @IsString()
+  @MaxLength(2000)
+  note?: string;
+}
+
+export class CreateBookRequestDto extends BookRequestWorkDto {
+  @IsIn(BOOK_REQUEST_MEDIA_KINDS)
+  mediaKind!: BookRequestMediaKind;
+
   @IsOptional()
   @IsArray()
   @ArrayMaxSize(20)
@@ -140,11 +152,6 @@ export class CreateBookRequestDto {
   @MaxLength(20, { each: true })
   preferredFormats?: string[];
 
-  @IsOptional()
-  @IsString()
-  @MaxLength(2000)
-  note?: string;
-
   @IsOptional()
   @Type(() => Number)
   @IsInt()
@@ -156,4 +163,14 @@ export class CreateBookRequestDto {
   @IsInt()
   @Min(1)
   targetFolderId?: number;
+
+  /**
+   * The book the arriving files should join, for a format that book does not have yet. Optional
+   * and new, so a client only sends it to a server advertising `book-request-pairs`.
+   */
+  @IsOptional()
+  @Type(() => Number)
+  @IsInt()
+  @Min(1)
+  targetBookId?: number;
 }
diff --git a/server/src/modules/book-request/dto/list-book-requests.dto.ts b/server/src/modules/book-request/dto/list-book-requests.dto.ts
index 0de3bb0fd..e75348771 100644
--- a/server/src/modules/book-request/dto/list-book-requests.dto.ts
+++ b/server/src/modules/book-request/dto/list-book-requests.dto.ts
@@ -52,6 +52,16 @@ export class ListBookRequestsDto {
   @IsOptional()
   @IsIn(BOOK_REQUEST_SORT_DIRECTIONS)
   sortDir?: BookRequestSortDirection;
+
+  /**
+   * One entry per ebook and audiobook pair, led by the ebook half with the audiobook embedded as
+   * its companion, rather than one entry per request. Opt-in, because a client that keys its rows
+   * by request id needs every request as an entry of its own.
+   */
+  @IsOptional()
+  @Transform(({ value }) => (value === true || value === 'true' ? true : value === false || value === 'false' ? false : value))
+  @IsBoolean()
+  groupPairs?: boolean;
 }
 
 /**
diff --git a/server/src/modules/book-request/fulfillment/request-automation-settings.service.test.ts b/server/src/modules/book-request/fulfillment/request-automation-settings.service.test.ts
index d4eebea18..87a9a37da 100644
--- a/server/src/modules/book-request/fulfillment/request-automation-settings.service.test.ts
+++ b/server/src/modules/book-request/fulfillment/request-automation-settings.service.test.ts
@@ -28,7 +28,6 @@ function makeService(stored: Record<string, string> = {}, repoOverrides: Record<
 const NO_DESTINATIONS = {
   ebook: { libraryId: null, folderId: null },
   audiobook: { libraryId: null, folderId: null },
-  comic: { libraryId: null, folderId: null },
 };
 
 describe('RequestAutomationSettingsService.get', () => {
@@ -133,12 +132,21 @@ describe('RequestAutomationSettingsService destinations', () => {
 
     expect(destinations.ebook).toEqual({ libraryId: 4, folderId: 9 });
     expect(destinations.audiobook).toEqual({ libraryId: 5, folderId: 12 });
-    expect(destinations.comic).toEqual({ libraryId: null, folderId: null });
+  });
+
+  /** A server that set one before comics were retired still holds the rows; nothing reads them. */
+  it('leaves a destination stored for the retired comic medium out entirely', async () => {
+    const { service } = makeService({ book_request_default_library_comic: '6', book_request_default_folder_comic: '7' });
+
+    const { destinations } = await service.get();
+
+    expect(destinations).toEqual(NO_DESTINATIONS);
+    expect(destinations).not.toHaveProperty('comic');
   });
 
   /** A folder on its own files into whichever library that folder belongs to, which nobody chose. */
   it('drops a stored folder whose library is unset', async () => {
-    const { service } = makeService({ [bookRequestDefaultFolderKey('comic')]: '12' });
+    const { service } = makeService({ [bookRequestDefaultFolderKey('ebook')]: '12' });
 
     await expect(service.get()).resolves.toMatchObject({ destinations: NO_DESTINATIONS });
   });
@@ -177,10 +185,10 @@ describe('RequestAutomationSettingsService destinations', () => {
   it('clears a medium when its library is set to null', async () => {
     const { service, appSettings } = makeService();
 
-    await service.update({ destinations: { comic: { libraryId: null, folderId: null } } });
+    await service.update({ destinations: { audiobook: { libraryId: null, folderId: null } } });
 
-    expect(appSettings.setValue).toHaveBeenCalledWith(bookRequestDefaultLibraryKey('comic'), '');
-    expect(appSettings.setValue).toHaveBeenCalledWith(bookRequestDefaultFolderKey('comic'), '');
+    expect(appSettings.setValue).toHaveBeenCalledWith(bookRequestDefaultLibraryKey('audiobook'), '');
+    expect(appSettings.setValue).toHaveBeenCalledWith(bookRequestDefaultFolderKey('audiobook'), '');
   });
 });
 
@@ -250,9 +258,9 @@ describe('RequestAutomationSettingsService.resolveDestinationFor', () => {
     it('clears a profile with an empty list', async () => {
       const { service, appSettings } = makeService();
 
-      await service.update({ profiles: { comic: [] } });
+      await service.update({ profiles: { ebook: [] } });
 
-      expect(appSettings.setValue).toHaveBeenCalledWith(bookRequestReleaseProfileKey('comic'), '[]');
+      expect(appSettings.setValue).toHaveBeenCalledWith(bookRequestReleaseProfileKey('ebook'), '[]');
     });
 
     it('refuses a tier with no name, since the release row has nothing to show', async () => {
diff --git a/server/src/modules/book-request/fulfillment/request-automation.service.test.ts b/server/src/modules/book-request/fulfillment/request-automation.service.test.ts
index 94674a021..29989da5c 100644
--- a/server/src/modules/book-request/fulfillment/request-automation.service.test.ts
+++ b/server/src/modules/book-request/fulfillment/request-automation.service.test.ts
@@ -187,6 +187,17 @@ describe('RequestAutomationService.considerRequest', () => {
     expect(notifier.notifyApprovers).not.toHaveBeenCalled();
   });
 
+  /** A request for the retired comic medium has nothing to search for, so automation leaves it be. */
+  it('never searches for a request made for the retired comic medium', async () => {
+    const { service, releases, fulfillment } = makeService({ request: { status: 'approved', mediaKind: 'comic' } });
+
+    service.considerRequest(7);
+    await settle();
+
+    expect(releases.search).not.toHaveBeenCalled();
+    expect(fulfillment.setRequestStatus).not.toHaveBeenCalled();
+  });
+
   /** Every other hand-back already wrote a reason; what none of them did was tell anybody. */
   it('tells the approvers when an auto-approved request is handed back for any other reason', async () => {
     const { service, notifier } = makeService({ releases: [release({ score: 61 })], settings: { autoGrabMinScore: 80 } });
diff --git a/server/src/modules/book-request/fulfillment/request-automation.service.ts b/server/src/modules/book-request/fulfillment/request-automation.service.ts
index f67ca3a60..cdb1ff211 100644
--- a/server/src/modules/book-request/fulfillment/request-automation.service.ts
+++ b/server/src/modules/book-request/fulfillment/request-automation.service.ts
@@ -8,6 +8,7 @@ import {
   MAX_AUTO_SEARCH_BACKOFF_FACTOR,
   NotificationType,
   releaseProfileIsActive,
+  isBookRequestMediaKind,
 } from '@bookorbit/types';
 import type {
   BookRequestAutomationSettings,
@@ -214,6 +215,8 @@ export class RequestAutomationService implements OnModuleInit {
     if (!joined) return;
     const request = joined.request;
     if (!isGrabbableBookRequestStatus(request.status as BookRequestStatus)) return;
+    // A retired medium has nothing to search for; the request waits for a person to close it.
+    if (!isBookRequestMediaKind(request.mediaKind)) return;
 
     // What the guards below are reasoning about, and therefore the only status any of them may
     // write a decision from. Every one of them runs before this pass has claimed anything, so a
diff --git a/server/src/modules/book-request/fulfillment/request-companion.service.test.ts b/server/src/modules/book-request/fulfillment/request-companion.service.test.ts
new file mode 100644
index 000000000..655d5329c
--- /dev/null
+++ b/server/src/modules/book-request/fulfillment/request-companion.service.test.ts
@@ -0,0 +1,156 @@
+import { RequestCompanionService } from './request-companion.service';
+
+function request(overrides: Record<string, unknown> = {}) {
+  return {
+    id: 10,
+    mediaKind: 'audiobook',
+    status: 'importing',
+    title: 'Dune',
+    targetLibraryId: 3,
+    targetBookId: null,
+    companionRequestId: null,
+    matchedBookId: null,
+    ...overrides,
+  } as never;
+}
+
+const folderBook = { bookId: 42, libraryId: 3, libraryFolderId: 4, folderPath: '/lib/Dune', status: 'present', organizationMode: 'book_per_folder' };
+
+function makeService(repoOverrides: Record<string, unknown> = {}) {
+  const repo = {
+    findById: vi.fn().mockResolvedValue(undefined),
+    findBookPlacement: vi.fn().mockResolvedValue(folderBook),
+    findBookMediaKinds: vi.fn().mockResolvedValue(new Set(['ebook'])),
+    updateIf: vi.fn().mockResolvedValue({ id: 11 }),
+    setTargetBookIfUnset: vi.fn().mockResolvedValue(true),
+    ...repoOverrides,
+  };
+  const notifier = { notifyBookAvailable: vi.fn().mockResolvedValue(undefined) };
+  return { service: new RequestCompanionService(repo as never, notifier as never), repo, notifier };
+}
+
+describe('RequestCompanionService.resolveJoin', () => {
+  it('joins the book a request names, following that book into whatever library it now lives in', async () => {
+    const { service } = makeService({ findBookPlacement: vi.fn().mockResolvedValue({ ...folderBook, libraryId: 8, libraryFolderId: 9 }) });
+
+    await expect(service.resolveJoin(request({ targetBookId: 42, coverUrl: 'https://covers.example/square.jpg' }))).resolves.toEqual({
+      libraryId: 8,
+      folderId: 9,
+      // The art the request chose travels with it, for when the arriving files carry none.
+      joinBook: { bookId: 42, folderPath: '/lib/Dune', coverUrl: 'https://covers.example/square.jpg' },
+    });
+  });
+
+  it('joins the book its companion landed as, when both are headed for the same library', async () => {
+    const { service } = makeService({
+      findById: vi.fn().mockResolvedValue({ request: { id: 11, companionRequestId: 10, status: 'available', matchedBookId: 42 } }),
+    });
+
+    const join = await service.resolveJoin(request({ companionRequestId: 11 }));
+
+    expect(join?.joinBook.bookId).toBe(42);
+  });
+
+  it('files on its own when the companion landed in a different library', async () => {
+    const { service } = makeService({
+      findById: vi.fn().mockResolvedValue({ request: { id: 11, companionRequestId: 10, status: 'available', matchedBookId: 42 } }),
+      findBookPlacement: vi.fn().mockResolvedValue({ ...folderBook, libraryId: 5 }),
+    });
+
+    await expect(service.resolveJoin(request({ companionRequestId: 11 }))).resolves.toBeNull();
+  });
+
+  it('ignores a companion that has not landed yet', async () => {
+    const { service, repo } = makeService({
+      findById: vi.fn().mockResolvedValue({ request: { id: 11, companionRequestId: 10, status: 'downloading', matchedBookId: null } }),
+    });
+
+    await expect(service.resolveJoin(request({ companionRequestId: 11 }))).resolves.toBeNull();
+    expect(repo.findBookPlacement).not.toHaveBeenCalled();
+  });
+
+  it('never trusts a link only one side of the pair still holds', async () => {
+    const { service } = makeService({
+      findById: vi.fn().mockResolvedValue({ request: { id: 11, companionRequestId: 99, status: 'available', matchedBookId: 42 } }),
+    });
+
+    await expect(service.resolveJoin(request({ companionRequestId: 11 }))).resolves.toBeNull();
+  });
+
+  it('refuses a library where a book is one file, because there is no folder to share', async () => {
+    const { service } = makeService({ findBookPlacement: vi.fn().mockResolvedValue({ ...folderBook, organizationMode: 'book_per_file' }) });
+
+    await expect(service.resolveJoin(request({ targetBookId: 42 }))).resolves.toBeNull();
+  });
+
+  it('refuses a book that already has this format, which would be a second copy rather than a second format', async () => {
+    const { service } = makeService({ findBookMediaKinds: vi.fn().mockResolvedValue(new Set(['ebook', 'audiobook'])) });
+
+    await expect(service.resolveJoin(request({ targetBookId: 42 }))).resolves.toBeNull();
+  });
+
+  it('refuses a book that is no longer present', async () => {
+    const { service } = makeService({ findBookPlacement: vi.fn().mockResolvedValue({ ...folderBook, status: 'missing' }) });
+
+    await expect(service.resolveJoin(request({ targetBookId: 42 }))).resolves.toBeNull();
+  });
+});
+
+describe('RequestCompanionService.handOn', () => {
+  const landed = request({ id: 10, mediaKind: 'ebook', companionRequestId: 11 });
+
+  it('settles a companion whose format arrived in the same release, and tells the people waiting on it', async () => {
+    const { service, repo, notifier } = makeService({
+      findById: vi.fn().mockResolvedValue({ request: { id: 11, companionRequestId: 10, mediaKind: 'audiobook', title: 'Dune', targetLibraryId: 3 } }),
+      findBookMediaKinds: vi.fn().mockResolvedValue(new Set(['ebook', 'audiobook'])),
+    });
+
+    await expect(service.handOn(landed, 42)).resolves.toBe(true);
+
+    expect(repo.updateIf).toHaveBeenCalledWith(
+      11,
+      ['pending', 'approved', 'searching'],
+      expect.objectContaining({ status: 'available', matchedBookId: 42 }),
+    );
+    expect(notifier.notifyBookAvailable).toHaveBeenCalledWith(11, 42, expect.objectContaining({ meta: { requestId: 11, bookId: 42 } }));
+  });
+
+  it('leaves a companion with a grab of its own in flight to finish it', async () => {
+    const { service, notifier } = makeService({
+      findById: vi.fn().mockResolvedValue({ request: { id: 11, companionRequestId: 10, mediaKind: 'audiobook', title: 'Dune', targetLibraryId: 3 } }),
+      findBookMediaKinds: vi.fn().mockResolvedValue(new Set(['ebook', 'audiobook'])),
+      updateIf: vi.fn().mockResolvedValue(undefined),
+    });
+
+    await expect(service.handOn(landed, 42)).resolves.toBe(false);
+    expect(notifier.notifyBookAvailable).not.toHaveBeenCalled();
+  });
+
+  it('points a companion still to come at the book, so it joins it when it arrives', async () => {
+    const { service, repo } = makeService({
+      findById: vi.fn().mockResolvedValue({ request: { id: 11, companionRequestId: 10, mediaKind: 'audiobook', title: 'Dune', targetLibraryId: 3 } }),
+    });
+
+    await service.handOn(landed, 42);
+
+    expect(repo.updateIf).not.toHaveBeenCalled();
+    expect(repo.setTargetBookIfUnset).toHaveBeenCalledWith(11, 42);
+  });
+
+  it('leaves a companion bound for another library to land there as a book of its own', async () => {
+    const { service, repo } = makeService({
+      findById: vi.fn().mockResolvedValue({ request: { id: 11, companionRequestId: 10, mediaKind: 'audiobook', title: 'Dune', targetLibraryId: 7 } }),
+    });
+
+    await service.handOn(landed, 42);
+
+    expect(repo.setTargetBookIfUnset).not.toHaveBeenCalled();
+  });
+
+  it('does nothing for a request made on its own', async () => {
+    const { service, repo } = makeService();
+
+    await expect(service.handOn(request({ companionRequestId: null }), 42)).resolves.toBe(false);
+    expect(repo.findById).not.toHaveBeenCalled();
+  });
+});
diff --git a/server/src/modules/book-request/fulfillment/request-companion.service.ts b/server/src/modules/book-request/fulfillment/request-companion.service.ts
new file mode 100644
index 000000000..70318297f
--- /dev/null
+++ b/server/src/modules/book-request/fulfillment/request-companion.service.ts
@@ -0,0 +1,108 @@
+import { Injectable, Logger } from '@nestjs/common';
+import type { BookRequestMediaKind, BookRequestStatus } from '@bookorbit/types';
+
+import type { BookRequestRow } from '../../../db/schema';
+import { BookRequestNotifier } from '../book-request-notifier.service';
+import { BookRequestRepository } from '../book-request.repository';
+
+/**
+ * Where a companion can be settled from when the half that just landed brought its format too:
+ * anywhere before a release was grabbed for it. A grab in flight is somebody's decision about which
+ * copy to fetch, and it keeps running.
+ */
+const COMPANION_SETTLEABLE_STATUSES: readonly BookRequestStatus[] = ['pending', 'approved', 'searching'];
+
+/** The existing book a request's files become another format of, and where that book lives. */
+export interface BookJoin {
+  libraryId: number;
+  folderId: number;
+  /** `coverUrl` is the art the request chose for its format, for when the files carry none. */
+  joinBook: { bookId: number; folderPath: string; coverUrl: string | null };
+}
+
+/**
+ * What ties the two halves of an ebook and audiobook pair together once they start arriving: the
+ * book the second half should join, and what the first half landing means for the second.
+ *
+ * Also answers for a request made from a book's page, which names the book it should join directly.
+ */
+@Injectable()
+export class RequestCompanionService {
+  private readonly logger = new Logger(RequestCompanionService.name);
+
+  constructor(
+    private readonly requests: BookRequestRepository,
+    private readonly notifier: BookRequestNotifier,
+  ) {}
+
+  /**
+   * The existing book this request's files should become another format of, if there is one to join.
+   *
+   * Either the book the request names, which it follows wherever that book now lives, or the book
+   * its companion already landed as, when that is in the library this request is headed for. Never
+   * a book that already has this format - that would be a second copy of it, not a second format -
+   * and never in a library where a book is a single file, because there is no folder to share.
+   */
+  async resolveJoin(request: BookRequestRow): Promise<BookJoin | null> {
+    let bookId = request.targetBookId;
+    const followsBook = bookId !== null;
+
+    if (bookId === null && request.companionRequestId !== null) {
+      const companion = (await this.requests.findById(request.companionRequestId))?.request;
+      if (companion?.companionRequestId === request.id && companion.status === 'available') bookId = companion.matchedBookId;
+    }
+    if (bookId === null) return null;
+
+    const placement = await this.requests.findBookPlacement(bookId);
+    if (!placement || placement.status !== 'present' || placement.organizationMode !== 'book_per_folder') return null;
+    if (!followsBook && placement.libraryId !== request.targetLibraryId) return null;
+    if ((await this.requests.findBookMediaKinds(bookId)).has(request.mediaKind as BookRequestMediaKind)) return null;
+
+    return {
+      libraryId: placement.libraryId,
+      folderId: placement.libraryFolderId,
+      joinBook: { bookId, folderPath: placement.folderPath, coverUrl: request.coverUrl },
+    };
+  }
+
+  /**
+   * What one half of a pair landing as `bookId` means for the other half.
+   *
+   * A release can carry both formats, and with "all available" both were just filed together. A
+   * companion that has not started downloading is then already satisfied, so it is settled here
+   * rather than left to fetch a second copy. Otherwise the companion is pointed at this book, so
+   * when it does arrive it joins it instead of landing wherever its own metadata would file it.
+   *
+   * Returns whether the companion was settled, so the caller knows a second request changed.
+   */
+  async handOn(request: BookRequestRow, bookId: number): Promise<boolean> {
+    if (request.companionRequestId === null) return false;
+    const companion = (await this.requests.findById(request.companionRequestId))?.request;
+    if (!companion || companion.companionRequestId !== request.id) return false;
+
+    const media = await this.requests.findBookMediaKinds(bookId);
+    if (media.has(companion.mediaKind as BookRequestMediaKind)) {
+      const settled = await this.requests.updateIf(companion.id, COMPANION_SETTLEABLE_STATUSES, {
+        status: 'available',
+        matchedBookId: bookId,
+        targetBookId: null,
+        statusReason: null,
+      });
+      if (!settled) return false;
+      this.logger.log(
+        `[book_request.companion_settled] [end] requestId=${companion.id} bookId=${bookId} companionOf=${request.id} - the other half of a pair arrived with this one`,
+      );
+      await this.notifier.notifyBookAvailable(companion.id, bookId, {
+        title: 'Your requested book is available',
+        message: `"${companion.title}" is ready`,
+        meta: { requestId: companion.id, bookId },
+      });
+      return true;
+    }
+
+    const placement = await this.requests.findBookPlacement(bookId);
+    if (!placement || placement.organizationMode !== 'book_per_folder' || placement.libraryId !== companion.targetLibraryId) return false;
+    await this.requests.setTargetBookIfUnset(companion.id, bookId);
+    return false;
+  }
+}
diff --git a/server/src/modules/book-request/fulfillment/request-verification.service.test.ts b/server/src/modules/book-request/fulfillment/request-verification.service.test.ts
index 397ac5522..70207a588 100644
--- a/server/src/modules/book-request/fulfillment/request-verification.service.test.ts
+++ b/server/src/modules/book-request/fulfillment/request-verification.service.test.ts
@@ -153,6 +153,7 @@ describe('RequestVerificationService against the configured threshold', () => {
     };
     const gateway = { emitChanged: vi.fn() };
     const settings = { get: vi.fn().mockResolvedValue({ verificationEnabled, verificationThreshold: threshold }) };
+    const companions = { resolveJoin: vi.fn().mockResolvedValue(null), handOn: vi.fn().mockResolvedValue(false) };
 
     const service = new RequestVerificationService(
       events as never,
@@ -165,6 +166,7 @@ describe('RequestVerificationService against the configured threshold', () => {
       notifier as never,
       gateway as never,
       settings as never,
+      companions as never,
     );
 
     service.onModuleInit();
@@ -345,6 +347,7 @@ describe('RequestVerificationService review surface', () => {
         verificationThreshold: overrides.threshold ?? 70,
       }),
     };
+    const companions = { resolveJoin: vi.fn().mockResolvedValue(null), handOn: vi.fn().mockResolvedValue(false) };
 
     const service = new RequestVerificationService(
       { on: vi.fn() } as never,
@@ -357,9 +360,10 @@ describe('RequestVerificationService review surface', () => {
       notifier as never,
       gateway as never,
       settings as never,
+      companions as never,
     );
 
-    return { service, dock, dockRepo, finalizeService, downloads, requests, notifier, gateway, fulfillment };
+    return { service, dock, dockRepo, finalizeService, downloads, requests, notifier, gateway, fulfillment, companions };
   }
 
   it('describes a loose single file from the anchor row, which already describes it fully', async () => {
@@ -505,6 +509,57 @@ describe('RequestVerificationService review surface', () => {
     expect(notifier.notifyBookAvailable).toHaveBeenCalled();
   });
 
+  it("files a half of a pair into the book it joins, in that book's own library and folder", async () => {
+    const { service, finalizeService, companions } = makeService();
+    const join = { libraryId: 8, folderId: 9, joinBook: { bookId: 42, folderPath: '/lib/Dune' } };
+    companions.resolveJoin.mockResolvedValue(join);
+
+    await service.fileHeldImport(7, { id: 9 } as never);
+
+    expect(finalizeService.finalizeManagedFile).toHaveBeenCalledWith(100, { libraryId: 8, folderId: 9, joinBook: join.joinBook });
+  });
+
+  it('hands the book that landed on to the other half of the pair', async () => {
+    const { service, companions } = makeService();
+
+    await service.fileHeldImport(7, { id: 9 } as never);
+
+    expect(companions.handOn).toHaveBeenCalledWith(expect.objectContaining({ id: 7 }), 55);
+  });
+
+  /**
+   * Filed side by side, each half would find the other not yet landed and both would become books
+   * of their own. The second has to start only once the first has finished.
+   */
+  it('files the two halves of a pair one after the other rather than side by side', async () => {
+    const { service, finalizeService, requests, downloads } = makeService();
+    const halves = new Map([
+      [7, { ...heldRequest, id: 7, companionRequestId: 8, bookDockFileId: 100 }],
+      [8, { ...heldRequest, id: 8, mediaKind: 'audiobook', companionRequestId: 7, bookDockFileId: 101 }],
+    ]);
+    requests.findById.mockImplementation((id: number) => Promise.resolve({ request: halves.get(id) }));
+    downloads.findLatestForRequests.mockImplementation((ids: number[]) =>
+      Promise.resolve(new Map(ids.map((id) => [id, { download: { id: id + 100, requestId: id, status: 'needs_review', bookDockFileId: null } }]))),
+    );
+
+    let releaseFirst!: () => void;
+    finalizeService.finalizeManagedFile
+      .mockImplementationOnce(() => new Promise((resolve) => (releaseFirst = () => resolve({ success: true, bookId: 55 }))))
+      .mockResolvedValueOnce({ success: true, bookId: 55 });
+
+    const first = service.fileHeldImport(7, { id: 9 } as never);
+    const second = service.fileHeldImport(8, { id: 9 } as never);
+    await vi.waitFor(() => expect(finalizeService.finalizeManagedFile).toHaveBeenCalledTimes(1));
+    // Give the second half every chance to jump the queue before the first is let go.
+    await new Promise((resolve) => setTimeout(resolve, 10));
+    expect(finalizeService.finalizeManagedFile).toHaveBeenCalledTimes(1);
+
+    releaseFirst();
+    await Promise.all([first, second]);
+    expect(finalizeService.finalizeManagedFile).toHaveBeenCalledTimes(2);
+    expect(finalizeService.finalizeManagedFile.mock.calls.map(([fileId]) => fileId)).toEqual([100, 101]);
+  });
+
   /** A failure here is the approver's to see, not another silent hold they have to come back to. */
   it('throws the dock message back at the approver instead of holding the import again', async () => {
     const { service, fulfillment } = makeService({ finalizeResult: { success: false, message: 'a book with that path already exists' } });
diff --git a/server/src/modules/book-request/fulfillment/request-verification.service.ts b/server/src/modules/book-request/fulfillment/request-verification.service.ts
index 8d74503b4..da9d2e385 100644
--- a/server/src/modules/book-request/fulfillment/request-verification.service.ts
+++ b/server/src/modules/book-request/fulfillment/request-verification.service.ts
@@ -33,6 +33,7 @@ import { BookRequestNotifier } from '../book-request-notifier.service';
 import { BookRequestRepository } from '../book-request.repository';
 import { BookRequestDownloadRepository } from './book-request-download.repository';
 import { RequestAutomationSettingsService } from './request-automation-settings.service';
+import { RequestCompanionService } from './request-companion.service';
 import { RequestFulfillmentService } from './request-fulfillment.service';
 
 /**
@@ -77,6 +78,8 @@ export interface VerificationOutcome {
 @Injectable()
 export class RequestVerificationService implements OnModuleInit {
   private readonly logger = new Logger(RequestVerificationService.name);
+  /** The tail of each pair's filing turns, so the two halves never file at the same time. */
+  private readonly pairFilings = new Map<number, Promise<void>>();
 
   constructor(
     private readonly events: BookDockEventsService,
@@ -89,6 +92,7 @@ export class RequestVerificationService implements OnModuleInit {
     private readonly notifier: BookRequestNotifier,
     private readonly gateway: BookRequestGateway,
     private readonly settings: RequestAutomationSettingsService,
+    private readonly companions: RequestCompanionService,
   ) {}
 
   onModuleInit(): void {
@@ -156,16 +160,39 @@ export class RequestVerificationService implements OnModuleInit {
     request: BookRequestRow,
     fileId: number,
   ): Promise<{ ok: true; bookId: number | null } | { ok: false; reason: string }> {
+    // The two halves of a pair can finish within moments of each other. Filed side by side, each
+    // would find the other not yet landed and both would become books of their own; one after the
+    // other, the second finds the first's book and joins it.
+    return this.serializeByPair(request, async () => {
+      // Read again inside the turn: the half that filed first may have just pointed this one at its book.
+      const current = (await this.requests.findById(request.id))?.request ?? request;
+      return this.fileIntoLibraryNow(download, current, fileId);
+    });
+  }
+
+  private async fileIntoLibraryNow(
+    download: BookRequestDownloadRow,
+    request: BookRequestRow,
+    fileId: number,
+  ): Promise<{ ok: true; bookId: number | null } | { ok: false; reason: string }> {
+    const join = await this.companions.resolveJoin(request);
+
     // A request with no folder still has a library; take its first folder rather than falling
     // through to the Book Dock's global default, which is usually unset and never the point here.
-    const folderId = request.targetFolderId ?? (await this.resolveFolder(request.targetLibraryId));
+    const folderId = join?.folderId ?? request.targetFolderId ?? (await this.resolveFolder(request.targetLibraryId));
     if (folderId === null) return { ok: false, reason: 'the destination library has no folder to file the book into' };
 
     const result = await this.finalizeService.finalizeManagedFile(fileId, {
-      libraryId: request.targetLibraryId ?? undefined,
+      libraryId: join?.libraryId ?? request.targetLibraryId ?? undefined,
       folderId,
+      ...(join ? { joinBook: join.joinBook } : {}),
     });
     if (!result.success) return { ok: false, reason: result.message ?? 'the Book Dock could not file this book' };
+    if (join) {
+      this.logger.log(
+        `[book_request.join_book] [end] requestId=${request.id} bookId=${join.joinBook.bookId} landedBookId=${result.bookId ?? 'none'} - filed as another format of an existing book`,
+      );
+    }
 
     // Conditional, like every other write in the pipeline. Scoring an import and handing it to the
     // Book Dock takes long enough for somebody to cancel the request underneath it, and an
@@ -200,11 +227,34 @@ export class RequestVerificationService implements OnModuleInit {
       message: `"${request.title}" is ready`,
       meta: { requestId: request.id, bookId: result.bookId ?? null },
     });
+    if (result.bookId != null) await this.companions.handOn(request, result.bookId);
     this.gateway.emitChanged();
 
     return { ok: true, bookId: result.bookId ?? null };
   }
 
+  /**
+   * Runs one filing at a time per pair, keyed on the pair rather than on either request so both
+   * halves queue behind the same turn. A request made on its own is never held up by anything.
+   */
+  private async serializeByPair<T>(request: BookRequestRow, run: () => Promise<T>): Promise<T> {
+    if (request.companionRequestId === null) return run();
+    const key = Math.min(request.id, request.companionRequestId);
+
+    const previous = this.pairFilings.get(key) ?? Promise.resolve();
+    const turn = previous.then(run, run);
+    const settled = turn.then(
+      () => undefined,
+      () => undefined,
+    );
+    this.pairFilings.set(key, settled);
+    try {
+      return await turn;
+    } finally {
+      if (this.pairFilings.get(key) === settled) this.pairFilings.delete(key);
+    }
+  }
+
   /**
    * What the drawer shows an approver about a held import: the files that actually landed, and
    * the field-by-field comparison behind the score.
diff --git a/server/src/modules/book-request/indexers/adapters/newznab.adapter.ts b/server/src/modules/book-request/indexers/adapters/newznab.adapter.ts
index 80a7d6052..d93219490 100644
--- a/server/src/modules/book-request/indexers/adapters/newznab.adapter.ts
+++ b/server/src/modules/book-request/indexers/adapters/newznab.adapter.ts
@@ -49,7 +49,7 @@ interface NewznabItem {
 export class NewznabAdapter implements IndexerAdapter {
   readonly type = 'newznab' as const;
   readonly label = 'Newznab';
-  readonly mediaKinds: readonly BookRequestMediaKind[] = ['ebook', 'audiobook', 'comic'];
+  readonly mediaKinds: readonly BookRequestMediaKind[] = ['ebook', 'audiobook'];
   readonly supportsIsbnSearch = true;
   readonly requiresCredential = true;
 
diff --git a/server/src/modules/book-request/indexers/adapters/torznab.adapter.ts b/server/src/modules/book-request/indexers/adapters/torznab.adapter.ts
index 6605d47bf..310e4ede2 100644
--- a/server/src/modules/book-request/indexers/adapters/torznab.adapter.ts
+++ b/server/src/modules/book-request/indexers/adapters/torznab.adapter.ts
@@ -64,7 +64,7 @@ export class TorznabAdapter implements IndexerAdapter {
   readonly type = 'torznab' as const;
   readonly label = 'Torznab';
   /** Whatever the proxy behind it indexes, which is every medium a request can ask for. */
-  readonly mediaKinds: readonly BookRequestMediaKind[] = ['ebook', 'audiobook', 'comic'];
+  readonly mediaKinds: readonly BookRequestMediaKind[] = ['ebook', 'audiobook'];
   readonly supportsIsbnSearch = false;
   /** Jackett and Prowlarr want an API key, but a self-hosted proxy may be left open. */
   readonly requiresCredential = false;
diff --git a/server/src/modules/book-request/indexers/dto/indexer.dto.ts b/server/src/modules/book-request/indexers/dto/indexer.dto.ts
index f28530a3e..9abf759fd 100644
--- a/server/src/modules/book-request/indexers/dto/indexer.dto.ts
+++ b/server/src/modules/book-request/indexers/dto/indexer.dto.ts
@@ -57,13 +57,6 @@ class IndexerCategoriesDto {
   @IsInt({ each: true })
   @Min(0, { each: true })
   audiobook?: number[];
-
-  @IsOptional()
-  @IsArray()
-  @ArrayMaxSize(30)
-  @IsInt({ each: true })
-  @Min(0, { each: true })
-  comic?: number[];
 }
 
 /**
diff --git a/server/src/modules/book-request/indexers/indexer-config.service.test.ts b/server/src/modules/book-request/indexers/indexer-config.service.test.ts
index 0884f4e46..8c59da773 100644
--- a/server/src/modules/book-request/indexers/indexer-config.service.test.ts
+++ b/server/src/modules/book-request/indexers/indexer-config.service.test.ts
@@ -400,7 +400,7 @@ describe('IndexerConfigService', () => {
 
     await service.create({ ...createDto, categories: { ebook: [8010] } });
 
-    expect(repo.create).toHaveBeenCalledWith(expect.objectContaining({ categories: { ebook: [8010], audiobook: [3030], comic: [7030] } }));
+    expect(repo.create).toHaveBeenCalledWith(expect.objectContaining({ categories: { ebook: [8010], audiobook: [3030] } }));
   });
 
   /** A key for one tracker is not a key for another, and its settings are the old adapter's. */
@@ -440,12 +440,12 @@ describe('IndexerConfigService', () => {
   /** A plugin declares its own; the compile-time map only knows the built-ins. */
   it('falls back to a plugin adapter default categories rather than to nothing', async () => {
     const { service, repo } = makeService({
-      registry: { defaultCategories: vi.fn().mockReturnValue({ ebook: [4040], audiobook: [4050], comic: [] }) },
+      registry: { defaultCategories: vi.fn().mockReturnValue({ ebook: [4040], audiobook: [4050] }) },
     });
 
     await service.create({ ...createDto, adapterType: 'librivox' as never, categories: undefined });
 
-    expect(repo.create).toHaveBeenCalledWith(expect.objectContaining({ categories: { ebook: [4040], audiobook: [4050], comic: [] } }));
+    expect(repo.create).toHaveBeenCalledWith(expect.objectContaining({ categories: { ebook: [4040], audiobook: [4050] } }));
   });
 
   it('reports a duplicate name as a conflict rather than a 500', async () => {
diff --git a/server/src/modules/book-request/indexers/indexer-config.service.ts b/server/src/modules/book-request/indexers/indexer-config.service.ts
index 9c9e14c1d..e0bffb0df 100644
--- a/server/src/modules/book-request/indexers/indexer-config.service.ts
+++ b/server/src/modules/book-request/indexers/indexer-config.service.ts
@@ -416,7 +416,6 @@ function mergeCategories(defaults: IndexerCategoryMap, categories: Partial<Index
   return {
     ebook: categories?.ebook ?? defaults.ebook,
     audiobook: categories?.audiobook ?? defaults.audiobook,
-    comic: categories?.comic ?? defaults.comic,
   };
 }
 
diff --git a/server/src/modules/book-request/indexers/indexer-keepalive.service.test.ts b/server/src/modules/book-request/indexers/indexer-keepalive.service.test.ts
index 351dd4f69..250a571d5 100644
--- a/server/src/modules/book-request/indexers/indexer-keepalive.service.test.ts
+++ b/server/src/modules/book-request/indexers/indexer-keepalive.service.test.ts
@@ -14,7 +14,7 @@ function config(overrides: Partial<ResolvedIndexerConfig> = {}): ResolvedIndexer
     applyTrackerSeedGoals: true,
     seedRatioGoal: null,
     seedTimeMinutes: null,
-    categories: { ebook: [], audiobook: [], comic: [] },
+    categories: { ebook: [], audiobook: [] },
     disabledMediaKinds: [],
     isbnSearchDisabled: false,
     settings: null,
diff --git a/server/src/modules/book-request/indexers/indexer-manager.repository.test.ts b/server/src/modules/book-request/indexers/indexer-manager.repository.test.ts
index 0e91d8162..fbc2064ae 100644
--- a/server/src/modules/book-request/indexers/indexer-manager.repository.test.ts
+++ b/server/src/modules/book-request/indexers/indexer-manager.repository.test.ts
@@ -4,8 +4,8 @@ import { IndexerManagerRepository } from './indexer-manager.repository';
 import type { ProwlarrIndexer } from './prowlarr.client';
 
 const categories: Record<'torrent' | 'usenet', IndexerCategoryMap> = {
-  torrent: { ebook: [7020], audiobook: [3030], comic: [7030] },
-  usenet: { ebook: [7020], audiobook: [3030], comic: [7030] },
+  torrent: { ebook: [7020], audiobook: [3030] },
+  usenet: { ebook: [7020], audiobook: [3030] },
 };
 
 function source(id: number, color: RequestIndexerRow['color']): RequestIndexerRow {
diff --git a/server/src/modules/book-request/indexers/indexer-registry.test.ts b/server/src/modules/book-request/indexers/indexer-registry.test.ts
index c55c6f632..d115b9108 100644
--- a/server/src/modules/book-request/indexers/indexer-registry.test.ts
+++ b/server/src/modules/book-request/indexers/indexer-registry.test.ts
@@ -28,4 +28,23 @@ describe('IndexerRegistry', () => {
 
     expect(registry.describe()).toContainEqual(expect.objectContaining({ type: 'example-tracker', version: '2.4.1', updateable: true }));
   });
+
+  /** An older plugin still lists comics; none of that may reach a descriptor or an indexer row. */
+  it('drops the retired comic medium and its categories from a plugin that still declares them', () => {
+    const older = {
+      ...plugin(),
+      usesCategories: true,
+      mediaKinds: ['ebook', 'comic'],
+      defaultCategories: { ebook: [7020], audiobook: [3030], comic: [7030] },
+    } as unknown as IndexerPlugin;
+    const registry = new IndexerRegistry([], { load: vi.fn() } as never);
+    const adapter = new PluginIndexerAdapter(older, { rotate: vi.fn() } as never);
+    registry.register(adapter);
+
+    const descriptor = registry.describe().find((entry) => entry.type === 'example-tracker');
+    expect(descriptor?.mediaKinds).toEqual(['ebook']);
+    expect(descriptor?.defaultCategories).toEqual({ ebook: [7020], audiobook: [3030] });
+    expect(registry.defaultCategories('example-tracker')).toEqual({ ebook: [7020], audiobook: [3030] });
+    expect(adapter.mediaKinds).toEqual(['ebook']);
+  });
 });
diff --git a/server/src/modules/book-request/indexers/indexer-registry.ts b/server/src/modules/book-request/indexers/indexer-registry.ts
index d5f1b15cf..db1619b67 100644
--- a/server/src/modules/book-request/indexers/indexer-registry.ts
+++ b/server/src/modules/book-request/indexers/indexer-registry.ts
@@ -7,6 +7,7 @@ import {
   INDEXER_MEDIA_KINDS,
   INDEXER_SEEDS_BACK,
   INDEXER_USES_CATEGORIES,
+  isBookRequestMediaKind,
   type IndexerAdapterDescriptor,
   type IndexerAdapterType,
   type IndexerCategoryMap,
@@ -17,7 +18,16 @@ import { PluginIndexerAdapter } from './plugins/plugin-host';
 import { PluginLoaderService } from './plugins/plugin-loader.service';
 
 /** What an adapter this build no longer has, or one that declares none, searches with. */
-const EMPTY_CATEGORIES: IndexerCategoryMap = { ebook: [], audiobook: [], comic: [] };
+const EMPTY_CATEGORIES: IndexerCategoryMap = { ebook: [], audiobook: [] };
+
+/**
+ * A plugin's categories for the media BookOrbit requests. Read field by field rather than taken
+ * whole, because a plugin written before comics were retired still declares a `comic` list, and
+ * that list must never reach an indexer row.
+ */
+function pluginCategories(plugin: PluginIndexerAdapter['plugin']): IndexerCategoryMap {
+  return { ebook: [...(plugin.defaultCategories?.ebook ?? [])], audiobook: [...(plugin.defaultCategories?.audiobook ?? [])] };
+}
 
 /**
  * Every adapter this install can use, built-in or loaded from disk.
@@ -110,7 +120,7 @@ export class IndexerRegistry implements OnModuleInit {
    */
   defaultCategories(type: IndexerAdapterType | string): IndexerCategoryMap {
     const adapter = this.find(type);
-    if (adapter instanceof PluginIndexerAdapter) return adapter.plugin.defaultCategories ?? EMPTY_CATEGORIES;
+    if (adapter instanceof PluginIndexerAdapter) return pluginCategories(adapter.plugin);
     if (adapter) return DEFAULT_INDEXER_CATEGORIES[adapter.type];
     return EMPTY_CATEGORIES;
   }
@@ -161,13 +171,13 @@ function describePlugin(adapter: PluginIndexerAdapter): IndexerAdapterDescriptor
     ...(plugin.update ? { updateable: true } : {}),
     requiresCredential: plugin.requiresCredential,
     credentialKind: plugin.credentialKind,
-    mediaKinds: [...plugin.mediaKinds],
+    mediaKinds: plugin.mediaKinds.filter(isBookRequestMediaKind),
     usesCategories: plugin.usesCategories,
     seedsBack: plugin.seedsBack,
     delivery: plugin.seedsBack ? 'torrent' : 'file',
     // The adapter's, not the plugin's: a plugin may leave the field off entirely.
     supportsIsbnSearch: adapter.supportsIsbnSearch,
-    defaultCategories: plugin.defaultCategories ?? { ebook: [], audiobook: [], comic: [] },
+    defaultCategories: pluginCategories(plugin),
     ...(plugin.defaultBaseUrl ? { defaultBaseUrl: plugin.defaultBaseUrl } : {}),
     ...(plugin.baseUrlHint ? { baseUrlHint: plugin.baseUrlHint } : {}),
     settingsFields: [...(plugin.settingsFields ?? [])],
diff --git a/server/src/modules/book-request/indexers/indexer-search.service.test.ts b/server/src/modules/book-request/indexers/indexer-search.service.test.ts
index 2bf4e647e..ed9f57593 100644
--- a/server/src/modules/book-request/indexers/indexer-search.service.test.ts
+++ b/server/src/modules/book-request/indexers/indexer-search.service.test.ts
@@ -41,7 +41,7 @@ function indexer(overrides: Partial<ResolvedIndexerConfig> = {}): ResolvedIndexe
     applyTrackerSeedGoals: true,
     seedRatioGoal: null,
     seedTimeMinutes: null,
-    categories: { ebook: [7020], audiobook: [3030], comic: [7030] },
+    categories: { ebook: [7020], audiobook: [3030] },
     disabledMediaKinds: [],
     isbnSearchDisabled: false,
     settings: null,
@@ -98,7 +98,7 @@ function makeService(
   const registry = {
     find: vi.fn((type: string) => {
       const adapter = adapters[type];
-      return adapter ? { mediaKinds: ['ebook', 'audiobook', 'comic'], supportsIsbnSearch: false, ...adapter } : undefined;
+      return adapter ? { mediaKinds: ['ebook', 'audiobook'], supportsIsbnSearch: false, ...adapter } : undefined;
     }),
     seedsBack: vi.fn((type: string) => adapters[type]?.seedsBack ?? true),
     delivery: vi.fn((type: string) => adapters[type]?.delivery ?? (adapters[type]?.seedsBack === false ? 'file' : 'torrent')),
@@ -114,6 +114,15 @@ function makeService(
 }
 
 describe('IndexerSearchService', () => {
+  /** The picker for an old comic request says why, rather than asking every tracker for nothing. */
+  it('refuses to search for a request made for the retired comic medium', async () => {
+    const search = vi.fn();
+    const { service } = makeService([indexer()], { [indexer().adapterType]: { search } });
+
+    await expect(service.search(request({ mediaKind: 'comic' }))).rejects.toThrow('Comic requests are no longer supported');
+    expect(search).not.toHaveBeenCalled();
+  });
+
   /**
    * A rotated or unset encryption key leaves stored credentials unreadable. Decrypting the whole
    * enabled list up front meant one such row threw out of the resolve and took every other source
diff --git a/server/src/modules/book-request/indexers/indexer-search.service.ts b/server/src/modules/book-request/indexers/indexer-search.service.ts
index 49ede6c79..c2dad7bd1 100644
--- a/server/src/modules/book-request/indexers/indexer-search.service.ts
+++ b/server/src/modules/book-request/indexers/indexer-search.service.ts
@@ -1,5 +1,11 @@
-import { Injectable, Logger } from '@nestjs/common';
-import { canonicalizeBookRequestIsbn, compareByTier, MAX_BOOK_REQUEST_SEARCH_ISBNS, releaseProfileIsActive } from '@bookorbit/types';
+import { BadRequestException, Injectable, Logger } from '@nestjs/common';
+import {
+  canonicalizeBookRequestIsbn,
+  compareByTier,
+  isBookRequestMediaKind,
+  MAX_BOOK_REQUEST_SEARCH_ISBNS,
+  releaseProfileIsActive,
+} from '@bookorbit/types';
 import type {
   BookRequestMediaKind,
   IndexerSearchQuery,
@@ -15,6 +21,7 @@ import { sanitizeLogValue } from '../../../common/utils/log-sanitize.utils';
 import { withDeadline } from '../../../common/utils/with-deadline.utils';
 import type { BookRequestRow } from '../../../db/schema';
 import { RequestAutomationSettingsService } from '../fulfillment/request-automation-settings.service';
+import { RETIRED_MEDIUM_REFUSAL } from '../retired-media';
 import { IndexerSearchException, type ReleaseCandidate, type ReleaseQuery, type ResolvedIndexerConfig } from './indexer-adapter';
 import { IndexerConfigService } from './indexer-config.service';
 import { IndexerOperationLock } from './indexer-operation-lock';
@@ -68,6 +75,9 @@ export class IndexerSearchService {
   ) {}
 
   async search(request: BookRequestRow, options: IndexerSearchOptions = {}): Promise<ReleaseSearchResult> {
+    const mediaKind = request.mediaKind;
+    if (!isBookRequestMediaKind(mediaKind)) throw new BadRequestException(RETIRED_MEDIUM_REFUSAL);
+
     const searchKey = JSON.stringify({ overrides: options.overrides ?? null, indexerMode: options.indexerMode ?? 'all' });
     const cacheKey = `${request.id}:${searchKey}`;
     const cached = this.cache.get(cacheKey);
@@ -80,8 +90,8 @@ export class IndexerSearchService {
     // source switched off" need opposite fixes.
     const [configs, sources] = await Promise.all([this.indexers.resolveEnabledConfigs(), this.indexers.countSources()]);
     const { profiles } = await this.automationSettings.get();
-    const tiers = profiles[request.mediaKind] ?? [];
-    const { scoringRequest, availableIsbns } = prepareScoringRequest(request, tiers, options.overrides);
+    const tiers = profiles[mediaKind] ?? [];
+    const { scoringRequest, availableIsbns } = prepareScoringRequest({ ...request, mediaKind }, tiers, options.overrides);
     const query = toQuery(scoringRequest);
 
     // A source that does not carry the requested medium is left out of the search rather than
@@ -481,7 +491,7 @@ function toQuery(request: ScoringRequest): ReleaseQuery {
 }
 
 function prepareScoringRequest(
-  request: BookRequestRow,
+  request: BookRequestRow & { mediaKind: BookRequestMediaKind },
   tiers: readonly ReleaseTier[],
   overrides?: ReleaseSearchOverrides,
 ): { scoringRequest: ScoringRequest; availableIsbns: string[] } {
diff --git a/server/src/modules/book-request/indexers/plugins/plugin-host.test.ts b/server/src/modules/book-request/indexers/plugins/plugin-host.test.ts
index 2cbed70be..9c14d4894 100644
--- a/server/src/modules/book-request/indexers/plugins/plugin-host.test.ts
+++ b/server/src/modules/book-request/indexers/plugins/plugin-host.test.ts
@@ -35,7 +35,7 @@ function config(overrides: Partial<ResolvedIndexerConfig> = {}): ResolvedIndexer
     applyTrackerSeedGoals: true,
     seedRatioGoal: null,
     seedTimeMinutes: null,
-    categories: { ebook: [7020], audiobook: [3030], comic: [7030] },
+    categories: { ebook: [7020], audiobook: [3030] },
     disabledMediaKinds: [],
     isbnSearchDisabled: false,
     settings: null,
diff --git a/server/src/modules/book-request/indexers/plugins/plugin-host.ts b/server/src/modules/book-request/indexers/plugins/plugin-host.ts
index bffdf62b4..59e5f8ebf 100644
--- a/server/src/modules/book-request/indexers/plugins/plugin-host.ts
+++ b/server/src/modules/book-request/indexers/plugins/plugin-host.ts
@@ -8,6 +8,7 @@ import type {
   PluginRequestInit,
   PluginSearchFailure,
 } from '@bookorbit/plugin-api';
+import { isBookRequestMediaKind } from '@bookorbit/types';
 import type { BookRequestMediaKind, IndexerAdapterType, IndexerSettingsField, ReleaseAudioInfo } from '@bookorbit/types';
 
 import { boundedResponse } from '../../../../common/utils/bounded-response';
@@ -87,7 +88,8 @@ export class PluginIndexerAdapter implements IndexerAdapter {
     this.type = plugin.type as IndexerAdapterType;
     this.label = plugin.label;
     this.requiresCredential = plugin.requiresCredential;
-    this.mediaKinds = plugin.mediaKinds as readonly BookRequestMediaKind[];
+    // An older plugin can still list the retired `comic`; it is never searched for, so it is dropped.
+    this.mediaKinds = plugin.mediaKinds.filter(isBookRequestMediaKind);
     this.supportsIsbnSearch = plugin.supportsIsbnSearch === true;
     this.settingsFields = plugin.settingsFields ?? [];
     this.logger = new Logger(`plugin:${plugin.type}`);
@@ -398,7 +400,6 @@ function toPluginConfig(config: ResolvedIndexerConfig): PluginIndexerConfig {
     categories: {
       ebook: [...config.categories.ebook],
       audiobook: [...config.categories.audiobook],
-      comic: [...config.categories.comic],
     },
     settings: config.settings ? structuredClone(config.settings as Record<string, unknown>) : null,
   };
diff --git a/server/src/modules/book-request/indexers/plugins/plugin-loader.service.test.ts b/server/src/modules/book-request/indexers/plugins/plugin-loader.service.test.ts
index c1d88594c..d063de8df 100644
--- a/server/src/modules/book-request/indexers/plugins/plugin-loader.service.test.ts
+++ b/server/src/modules/book-request/indexers/plugins/plugin-loader.service.test.ts
@@ -140,6 +140,26 @@ describe('PluginLoaderService', () => {
     expect(loader.loadFailures()[0].reason).toContain('newspaper');
   });
 
+  /**
+   * Plugins are released apart from BookOrbit, so one written before comics were retired still
+   * lists them. It has to keep loading; the retired medium is simply never searched.
+   */
+  it('keeps loading a plugin that still declares the retired comic medium, and drops it', async () => {
+    await writePlugin('older', pluginSource({ mediaKinds: "['ebook', 'comic']" }));
+
+    await loader.load();
+
+    expect(loader.loadFailures()).toEqual([]);
+  });
+
+  it('refuses a plugin that serves only the retired comic medium, since it has nothing to search', async () => {
+    await writePlugin('comics-only', pluginSource({ mediaKinds: "['comic']" }));
+
+    await loader.load();
+
+    expect(loader.loadFailures()[0].reason).toContain('no longer requests');
+  });
+
   /** A release is a torrent or a file. Declaring both leaves the grab path guessing. */
   it('refuses a plugin that declares both a torrent fetch and a file resolve', async () => {
     await writePlugin('both', pluginSource({ resolveFile: 'async () => ({})' }));
diff --git a/server/src/modules/book-request/indexers/plugins/plugin-shape.ts b/server/src/modules/book-request/indexers/plugins/plugin-shape.ts
index edb8f8779..95b6661a3 100644
--- a/server/src/modules/book-request/indexers/plugins/plugin-shape.ts
+++ b/server/src/modules/book-request/indexers/plugins/plugin-shape.ts
@@ -1,4 +1,7 @@
-import { BOOK_REQUEST_MEDIA_KINDS } from '@bookorbit/types';
+import { BOOK_REQUEST_MEDIA_KINDS, type LegacyBookRequestMediaKind } from '@bookorbit/types';
+
+/** What a plugin may declare: today's media, plus the retired one older plugins still list. */
+const PLUGIN_DECLARABLE_MEDIA_KINDS: readonly string[] = [...BOOK_REQUEST_MEDIA_KINDS, 'comic' satisfies LegacyBookRequestMediaKind];
 import type { PluginSettingsField, PluginUpdateChannel } from '@bookorbit/plugin-api';
 
 /** Bumped when a change to the contract would break a plugin written against the old one. */
@@ -61,7 +64,12 @@ export function assertPluginShape(plugin: DeclaredPluginShape): void {
     throw new Error('it declares no media kinds');
   }
   for (const kind of plugin.mediaKinds) {
-    if (!(BOOK_REQUEST_MEDIA_KINDS as readonly string[]).includes(kind as string)) throw new Error(`"${String(kind)}" is not a media kind`);
+    if (!(PLUGIN_DECLARABLE_MEDIA_KINDS as readonly string[]).includes(kind as string)) throw new Error(`"${String(kind)}" is not a media kind`);
+  }
+  // Plugins are released apart from BookOrbit, so one written before comics were retired still
+  // declares them. That is accepted and ignored; a plugin left with nothing else serves nothing.
+  if (!plugin.mediaKinds.some((kind) => (BOOK_REQUEST_MEDIA_KINDS as readonly string[]).includes(kind as string))) {
+    throw new Error('it only serves media BookOrbit no longer requests');
   }
 
   // Declaring both would leave the grab path guessing which one a release meant.
diff --git a/server/src/modules/book-request/indexers/release-scoring.test.ts b/server/src/modules/book-request/indexers/release-scoring.test.ts
index b40a47999..39982818d 100644
--- a/server/src/modules/book-request/indexers/release-scoring.test.ts
+++ b/server/src/modules/book-request/indexers/release-scoring.test.ts
@@ -42,9 +42,8 @@ describe('rejectRelease', () => {
     expect(rejectRelease(release({ format: 'epub' }), request({ mediaKind: 'audiobook' }))).toContain('not a audiobook format');
   });
 
-  it('accepts pdf for both ebooks and comics', () => {
+  it('accepts pdf as an ebook format', () => {
     expect(rejectRelease(release({ format: 'pdf' }), request({ mediaKind: 'ebook' }))).toBeNull();
-    expect(rejectRelease(release({ format: 'pdf' }), request({ mediaKind: 'comic' }))).toBeNull();
   });
 
   it('compares only the language subtag, so eng and en agree', () => {
diff --git a/server/src/modules/book-request/indexers/release-scoring.ts b/server/src/modules/book-request/indexers/release-scoring.ts
index 5f718b4b9..ed99caabe 100644
--- a/server/src/modules/book-request/indexers/release-scoring.ts
+++ b/server/src/modules/book-request/indexers/release-scoring.ts
@@ -6,7 +6,6 @@ import {
   explainReleaseProfileMismatch,
   ISO_639_2_TO_1,
   isAudioFormat,
-  isComicFormat,
   isValidBookRequestIsbn10,
   languagesAgree,
   matchReleaseTier,
@@ -74,14 +73,12 @@ const MEGABYTE = 1024 * 1024;
 const SIZE_RANGES: Record<BookRequestMediaKind, { min: number; max: number }> = {
   ebook: { min: 20 * 1024, max: 400 * MEGABYTE },
   audiobook: { min: 20 * MEGABYTE, max: 8 * 1024 * MEGABYTE },
-  comic: { min: 1 * MEGABYTE, max: 4 * 1024 * MEGABYTE },
 };
 
 /** Whether a format is a usable one for the requested medium. */
 const FORMATS_BY_MEDIA_KIND: Record<BookRequestMediaKind, (format: string) => boolean> = {
   ebook: (format) => (EBOOK_FORMAT_LIST as readonly string[]).includes(format),
   audiobook: (format) => isAudioFormat(format),
-  comic: (format) => isComicFormat(format) || format === 'pdf',
 };
 
 /**
diff --git a/server/src/modules/book-request/retired-media.ts b/server/src/modules/book-request/retired-media.ts
new file mode 100644
index 000000000..97c6743aa
--- /dev/null
+++ b/server/src/modules/book-request/retired-media.ts
@@ -0,0 +1,5 @@
+/**
+ * Said for anything that would fetch a release for a request whose medium has been retired. Such a
+ * request still loads, and can be rejected, cancelled, hidden or deleted; it just goes no further.
+ */
+export const RETIRED_MEDIUM_REFUSAL = 'Comic requests are no longer supported: reject, cancel or delete this one';
diff --git a/server/src/modules/metadata-fetch/dto/metadata-search.dto.ts b/server/src/modules/metadata-fetch/dto/metadata-search.dto.ts
index f1224269e..8b253dd4b 100644
--- a/server/src/modules/metadata-fetch/dto/metadata-search.dto.ts
+++ b/server/src/modules/metadata-fetch/dto/metadata-search.dto.ts
@@ -1,5 +1,7 @@
 import { Transform, Type } from 'class-transformer';
 import {
+  ArrayMaxSize,
+  IsArray,
   IsBoolean,
   IsEnum,
   IsIn,
@@ -86,6 +88,21 @@ export class MetadataSearchDto {
   @IsIn(CONCRETE_BOOK_MEDIA_KINDS)
   mediaKind?: ConcreteBookMediaKind;
 
+  /**
+   * Several media at once, for a search that asks for an ebook and an audiobook of the same work.
+   * The providers are the union of the ones serving each medium; results are ranked as for the
+   * first medium named, with audiobook-only providers still asked.
+   */
+  @IsOptional()
+  @Transform(({ value }: { value: unknown }) => {
+    const items = typeof value === 'string' ? value.split(',') : Array.isArray(value) ? value : undefined;
+    return items?.map((item) => (typeof item === 'string' ? item.trim() : item)).filter((item) => item !== '');
+  })
+  @IsArray()
+  @ArrayMaxSize(CONCRETE_BOOK_MEDIA_KINDS.length)
+  @IsIn(CONCRETE_BOOK_MEDIA_KINDS, { each: true })
+  mediaKinds?: ConcreteBookMediaKind[];
+
   @IsOptional()
   @Transform(({ value }: { value: unknown }) => {
     if (typeof value === 'string') {
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 0523ae83e..c18558a35 100644
--- a/server/src/modules/metadata-fetch/metadata-fetch.controller.test.ts
+++ b/server/src/modules/metadata-fetch/metadata-fetch.controller.test.ts
@@ -500,6 +500,23 @@ describe('MetadataFetchController', () => {
     ]);
   });
 
+  it('asks the providers of every medium named, ranked as for the first one, for a paired search', async () => {
+    registry.keysForMediaKind.mockImplementation((_keys: MetadataProviderKey[], mediaKind: string) =>
+      mediaKind === 'audiobook' ? [MetadataProviderKey.GOOGLE, MetadataProviderKey.AUDIBLE] : [MetadataProviderKey.GOOGLE],
+    );
+    service.search.mockReturnValue(of({ provider: MetadataProviderKey.GOOGLE, providerId: 'g3', title: 'Dune' }));
+
+    const stream = await controller.stream({ title: 'Dune', mediaKinds: ['ebook', 'audiobook'] }, user);
+    await firstValueFrom(stream.pipe(toArray()));
+
+    expect(registry.keysForMediaKind).toHaveBeenCalledWith(expect.any(Array), 'ebook');
+    expect(registry.keysForMediaKind).toHaveBeenCalledWith(expect.any(Array), 'audiobook');
+    expect(service.search).toHaveBeenCalledWith(expect.objectContaining({ isAudiobook: false, includeAudiobookProviders: true }), [
+      MetadataProviderKey.GOOGLE,
+      MetadataProviderKey.AUDIBLE,
+    ]);
+  });
+
   it('keeps an explicit isAudiobook flag ahead of the medium it was sent with', async () => {
     registry.keysForMediaKind.mockReturnValue([MetadataProviderKey.GOOGLE]);
     service.search.mockReturnValue(of({ provider: MetadataProviderKey.GOOGLE, providerId: 'g2', title: 'Dune' }));
diff --git a/server/src/modules/metadata-fetch/metadata-fetch.controller.ts b/server/src/modules/metadata-fetch/metadata-fetch.controller.ts
index 91d8259e7..0631d435f 100644
--- a/server/src/modules/metadata-fetch/metadata-fetch.controller.ts
+++ b/server/src/modules/metadata-fetch/metadata-fetch.controller.ts
@@ -89,7 +89,11 @@ export class MetadataFetchController {
     ]);
     // 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 media = [...new Set([...(dto.mediaKind ? [dto.mediaKind] : []), ...(dto.mediaKinds ?? [])])];
+    const providerKeys = media.length
+      ? [...new Set(media.flatMap((mediaKind) => this.registry.keysForMediaKind(enabledProviderKeys, mediaKind)))]
+      : enabledProviderKeys;
+    const leadMediaKind = media[0];
     const servesOnlyAudiobooks = (providerKey: MetadataProviderKey) => this.registry.servesOnlyAudiobooks(providerKey);
     const requestedAudiobookProvider = (dto.providers ?? []).some(servesOnlyAudiobooks);
     const onlyAudiobookProviders = providerKeys.length > 0 && providerKeys.every(servesOnlyAudiobooks);
@@ -97,7 +101,7 @@ export class MetadataFetchController {
       requestedAudiobookProvider ||
       onlyAudiobookProviders ||
       Boolean(existingProviderIds[MetadataProviderKey.AUDIBLE] || existingProviderIds[MetadataProviderKey.LIBROFM]);
-    const isAudiobook = dto.isAudiobook ?? (dto.mediaKind ? dto.mediaKind === 'audiobook' : inferredIsAudiobook);
+    const isAudiobook = dto.isAudiobook ?? (leadMediaKind ? leadMediaKind === 'audiobook' : inferredIsAudiobook);
 
     const searchTitle = normalizeSearchTitle(dto.title);
     const params: MetadataSearchParams = {
diff --git a/server/test/book-move.e2e-spec.ts b/server/test/book-move.e2e-spec.ts
index 1c4199ad7..7df5c99b5 100644
--- a/server/test/book-move.e2e-spec.ts
+++ b/server/test/book-move.e2e-spec.ts
@@ -31,7 +31,7 @@ import type { BookMovePreviewResult, BookMoveProgressEvent, BookMoveSummary } fr
 import { Permission } from '@bookorbit/types';
 
 import { annotations, bookFiles, bookMoveJobs, books, collectionBooks, collections, libraries, userBookStatus } from '../src/db/schema';
-import { createEpubFixture, createPdfFixture } from './e2e/metadata-write/metadata-write-fixture-builder';
+import { createEpubFixture, createM4bFixture, createPdfFixture } from './e2e/metadata-write/metadata-write-fixture-builder';
 import {
   authHeader,
   closeMetadataWriteE2EContext,
@@ -716,6 +716,37 @@ describe('Cross-library book move (e2e)', () => {
       SCENARIO_TIMEOUT_MS,
     );
 
+    it(
+      'picks the primary file by the format priority of the library the book moved into',
+      async () => {
+        const src = await createSource({ mode: 'book_per_folder' });
+        const dst = await createTarget({ mode: 'book_per_folder' });
+        await ctx.db
+          .update(libraries)
+          .set({ formatPriority: ['m4b', 'epub'] })
+          .where(eq(libraries.id, dst.libraryId));
+        const title = `Both formats ${randomUUID().slice(0, 8)}`;
+        await createM4bFixture(src.folderPath, `${title}/${title}.m4b`, { title });
+        const book = await seedEpub(src, `${title}/${title}.epub`, title);
+
+        const formatOf = async (fileId: number | null) => (await readFileRows(book.bookId)).find((file) => file.id === fileId)?.relPath ?? null;
+        const primaryOf = async () =>
+          (await ctx.db.select({ primaryFileId: books.primaryFileId }).from(books).where(eq(books.id, book.bookId)))[0]?.primaryFileId ?? null;
+        expect(await formatOf(await primaryOf())).toMatch(/\.epub$/);
+
+        const summary = await moveAndSummarize({
+          selection: { bookIds: [book.bookId] },
+          targetLibraryId: dst.libraryId,
+          targetFolderId: dst.libraryFolderId,
+          collisionPolicy: 'suggested',
+        });
+
+        expect(summary.succeeded).toBe(1);
+        expect(await formatOf(await primaryOf())).toMatch(/\.m4b$/);
+      },
+      SCENARIO_TIMEOUT_MS,
+    );
+
     it(
       'streams one progress frame per book before the done summary',
       async () => {
diff --git a/server/test/book-requests.e2e-spec.ts b/server/test/book-requests.e2e-spec.ts
index 033408d71..014cbb67d 100644
--- a/server/test/book-requests.e2e-spec.ts
+++ b/server/test/book-requests.e2e-spec.ts
@@ -2,7 +2,14 @@ import { randomUUID } from 'crypto';
 
 import { and, eq } from 'drizzle-orm';
 import { Permission } from '@bookorbit/types';
-import type { BookRequestBulkResult, BookRequestItem, BookRequestPage, BookRequestSubmitResult, IndexerItem } from '@bookorbit/types';
+import type {
+  BookRequestBulkResult,
+  BookRequestItem,
+  BookRequestPage,
+  BookRequestPairSubmitResult,
+  BookRequestSubmitResult,
+  IndexerItem,
+} from '@bookorbit/types';
 
 import * as schema from '../src/db/schema';
 import {
@@ -40,7 +47,7 @@ const SELF_FULFIL_PERMISSIONS = [Permission.BookRequestAccess, Permission.BookRe
 
 interface SubmitOptions {
   title?: string;
-  mediaKind?: 'ebook' | 'audiobook' | 'comic';
+  mediaKind?: 'ebook' | 'audiobook';
   targetLibraryId?: number | null;
   selfServe?: boolean;
   userId?: number;
@@ -517,6 +524,224 @@ describe('Book requests (e2e)', () => {
     );
   });
 
+  describe('ebook and audiobook pairs', () => {
+    function submitPair(session: TestUserSession, title: string, overrides: Record<string, unknown> = {}) {
+      return inject('POST', '/book-requests/pairs', session, {
+        title,
+        authors: ['Fixture Author'],
+        ebook: { targetLibraryId: library.libraryId },
+        audiobook: { targetLibraryId: library.libraryId },
+        ...overrides,
+      });
+    }
+
+    async function submitPairOk(
+      session: TestUserSession,
+      title: string,
+      overrides: Record<string, unknown> = {},
+    ): Promise<BookRequestPairSubmitResult> {
+      const response = await submitPair(session, title, overrides);
+      expect(response.statusCode).toBe(201);
+      return response.json() as BookRequestPairSubmitResult;
+    }
+
+    /** A book holding one ebook file, in a library that keeps one book per folder. */
+    async function seedEbookBook(target: CreatedLibrary): Promise<number> {
+      const folderPath = `${target.folderPath}/${randomUUID()}`;
+      const [book] = await ctx.db
+        .insert(schema.books)
+        .values({ libraryId: target.libraryId, libraryFolderId: target.libraryFolderId, folderPath })
+        .returning({ id: schema.books.id });
+      await ctx.db.insert(schema.bookFiles).values({
+        bookId: book!.id,
+        libraryFolderId: target.libraryFolderId,
+        absolutePath: `${folderPath}/book.epub`,
+        ino: BigInt(Math.floor(Math.random() * 1_000_000_000)),
+        format: 'epub',
+        role: 'content',
+      });
+      return book!.id;
+    }
+
+    it(
+      'files both halves as requests of their own that name each other',
+      async () => {
+        const { ebook, audiobook } = await submitPairOk(requester, `Pair ${randomUUID()}`);
+
+        expect(ebook.subscribed).toBe(false);
+        expect(audiobook.subscribed).toBe(false);
+        expect(ebook.request.mediaKind).toBe('ebook');
+        expect(audiobook.request.mediaKind).toBe('audiobook');
+        expect(ebook.request.status).toBe('pending');
+        expect(audiobook.request.status).toBe('pending');
+        expect(ebook.request.companionRequestId).toBe(audiobook.request.id);
+        expect(audiobook.request.companionRequestId).toBe(ebook.request.id);
+      },
+      SCENARIO_TIMEOUT_MS,
+    );
+
+    it(
+      'lists a pair as one entry led by its ebook when asked to group, and as two entries otherwise',
+      async () => {
+        const { ebook, audiobook } = await submitPairOk(requester, `Pair ${randomUUID()}`);
+
+        const grouped = (await inject('GET', '/book-requests?groupPairs=true&limit=100', requester)).json() as BookRequestPage;
+        const lead = grouped.items.find((item) => item.id === ebook.request.id);
+        expect(lead?.companion?.id).toBe(audiobook.request.id);
+        expect(grouped.items.some((item) => item.id === audiobook.request.id)).toBe(false);
+
+        const flat = (await inject('GET', '/book-requests?limit=100', requester)).json() as BookRequestPage;
+        const ids = flat.items.map((item) => item.id);
+        expect(ids).toEqual(expect.arrayContaining([ebook.request.id, audiobook.request.id]));
+        // A client that never asked to group must not be handed the nested shape.
+        expect(flat.items.find((item) => item.id === ebook.request.id)).not.toHaveProperty('companion');
+      },
+      SCENARIO_TIMEOUT_MS,
+    );
+
+    it(
+      'keeps a grouped pair on a filtered queue when only one half matches the filter',
+      async () => {
+        const { ebook, audiobook } = await submitPairOk(requester, `Pair ${randomUUID()}`);
+        const approved = await inject('POST', `/admin/book-requests/${audiobook.request.id}/approve`, moderator, {});
+        expect(approved.statusCode).toBe(200);
+
+        const queue = (await inject('GET', '/admin/book-requests?groupPairs=true&status=approved&limit=100', moderator)).json() as BookRequestPage;
+        const lead = queue.items.find((item) => item.id === ebook.request.id);
+        expect(lead?.status).toBe('pending');
+        expect(lead?.companion?.status).toBe('approved');
+      },
+      SCENARIO_TIMEOUT_MS,
+    );
+
+    it(
+      'joins a half somebody already asked for and links it to the half it created',
+      async () => {
+        const title = `Pair ${randomUUID()}`;
+        const existing = await submitOk(secondRequester, { title });
+
+        const { ebook, audiobook } = await submitPairOk(requester, title);
+
+        expect(ebook.subscribed).toBe(true);
+        expect(ebook.request.id).toBe(existing.request.id);
+        expect(audiobook.subscribed).toBe(false);
+        expect(ebook.request.companionRequestId).toBe(audiobook.request.id);
+        expect(audiobook.request.companionRequestId).toBe(existing.request.id);
+      },
+      SCENARIO_TIMEOUT_MS,
+    );
+
+    it(
+      'refuses the whole pair, writing neither half, when the rules refuse one of them',
+      async () => {
+        const title = `Pair ${randomUUID()}`;
+        const response = await submitPair(requester, title, { audiobook: { targetLibraryId: otherLibrary.libraryId } });
+
+        expect(response.statusCode).toBe(403);
+        expect((response.json() as { errorCode?: string }).errorCode).toBe('SUBMIT_LIBRARY_FORBIDDEN');
+        const rows = await ctx.db.select({ id: schema.bookRequests.id }).from(schema.bookRequests).where(eq(schema.bookRequests.title, title));
+        expect(rows).toHaveLength(0);
+      },
+      SCENARIO_TIMEOUT_MS,
+    );
+
+    it(
+      'files a missing format against the book it was asked from, and refuses a format the book already has',
+      async () => {
+        const folderLibrary = await createLibraryWithFolder(ctx, { mode: 'book_per_folder', name: `book-requests-folder-${randomUUID()}` });
+        await grantLibraryAccess(ctx, requester.userId, folderLibrary.libraryId, 'viewer');
+        const bookId = await seedEbookBook(folderLibrary);
+
+        const added = await inject('POST', '/book-requests', requester, {
+          title: `Joined ${randomUUID()}`,
+          mediaKind: 'audiobook',
+          authors: ['Fixture Author'],
+          targetBookId: bookId,
+          targetLibraryId: library.libraryId,
+        });
+        expect(added.statusCode).toBe(201);
+        const { request } = added.json() as BookRequestSubmitResult;
+        expect(request.targetBookId).toBe(bookId);
+        // The book decides where the format lands, whatever library the form had selected.
+        expect(request.targetLibraryId).toBe(folderLibrary.libraryId);
+
+        const duplicate = await inject('POST', '/book-requests', requester, {
+          title: `Joined ${randomUUID()}`,
+          mediaKind: 'ebook',
+          targetBookId: bookId,
+        });
+        expect(duplicate.statusCode).toBe(400);
+        expect((duplicate.json() as { errorCode?: string }).errorCode).toBe('SUBMIT_TARGET_BOOK_HAS_MEDIUM');
+      },
+      SCENARIO_TIMEOUT_MS,
+    );
+
+    it(
+      'treats a book in a library the requester cannot reach as one that does not exist',
+      async () => {
+        const hidden = await createLibraryWithFolder(ctx, { mode: 'book_per_folder', name: `book-requests-hidden-${randomUUID()}` });
+        const bookId = await seedEbookBook(hidden);
+
+        const response = await inject('POST', '/book-requests', requester, {
+          title: `Joined ${randomUUID()}`,
+          mediaKind: 'audiobook',
+          targetBookId: bookId,
+        });
+
+        expect(response.statusCode).toBe(400);
+        expect((response.json() as { errorCode?: string }).errorCode).toBe('SUBMIT_TARGET_BOOK_NOT_FOUND');
+      },
+      SCENARIO_TIMEOUT_MS,
+    );
+  });
+
+  describe('the retired comic medium', () => {
+    it(
+      'refuses a new comic request, writing nothing',
+      async () => {
+        const title = `Retired ${randomUUID()}`;
+        const response = await inject('POST', '/book-requests', requester, { title, mediaKind: 'comic', targetLibraryId: library.libraryId });
+
+        expect(response.statusCode).toBe(400);
+        const rows = await ctx.db.select({ id: schema.bookRequests.id }).from(schema.bookRequests).where(eq(schema.bookRequests.title, title));
+        expect(rows).toHaveLength(0);
+      },
+      SCENARIO_TIMEOUT_MS,
+    );
+
+    /** Released iOS builds decode `comic` here as required; leaving it out breaks their whole request screen. */
+    it(
+      'still answers comic, with no destination, among the default destinations',
+      async () => {
+        const response = await inject('GET', '/book-requests/default-destinations', requester);
+
+        expect(response.statusCode).toBe(200);
+        expect(response.json()).toMatchObject({ comic: { libraryId: null, libraryName: null, folderId: null } });
+      },
+      SCENARIO_TIMEOUT_MS,
+    );
+
+    it(
+      'keeps an existing comic request readable and closable, but will not approve it',
+      async () => {
+        const created = await submitOk(requester);
+        await ctx.db.update(schema.bookRequests).set({ mediaKind: 'comic' }).where(eq(schema.bookRequests.id, created.request.id));
+
+        const read = await inject('GET', `/book-requests/${created.request.id}`, requester);
+        expect((read.json() as BookRequestItem).mediaKind).toBe('comic');
+
+        const approve = await inject('POST', `/admin/book-requests/${created.request.id}/approve`, moderator, {});
+        expect(approve.statusCode).toBe(400);
+        expect(await statusOf(created.request.id)).toBe('pending');
+
+        const cancel = await inject('POST', `/book-requests/${created.request.id}/cancel`, requester, {});
+        expect(cancel.statusCode).toBe(200);
+        expect(await statusOf(created.request.id)).toBe('cancelled');
+      },
+      SCENARIO_TIMEOUT_MS,
+    );
+  });
+
   describe('held imports', () => {
     it(
       'discards a held import, removing the dock entry and failing the request',
diff --git a/server/test/e2e/authorization-matrix/route-inventory/manifest.json b/server/test/e2e/authorization-matrix/route-inventory/manifest.json
index 06b5fd052..0ac71b8ae 100644
--- a/server/test/e2e/authorization-matrix/route-inventory/manifest.json
+++ b/server/test/e2e/authorization-matrix/route-inventory/manifest.json
@@ -1,5 +1,5 @@
 {
-  "totalRoutes": 630,
+  "totalRoutes": 631,
   "byPermission": {
     "(none)": 278,
     "Permission.ManageMetadataConfig": 34,
@@ -25,7 +25,7 @@
     "Permission.HardcoverSync": 1,
     "Permission.ReadwiseSync": 1,
     "Permission.StorygraphSync": 1,
-    "Permission.BookRequestAccess": 25,
+    "Permission.BookRequestAccess": 26,
     "Permission.ManageBookRequests": 20,
     "Permission.BookRequestSelfFulfill": 11,
     "Permission.PodcastManageFeeds": 16,
diff --git a/server/test/e2e/authorization-matrix/route-inventory/routes-08.json b/server/test/e2e/authorization-matrix/route-inventory/routes-08.json
index 1219f4507..80976f7c5 100644
--- a/server/test/e2e/authorization-matrix/route-inventory/routes-08.json
+++ b/server/test/e2e/authorization-matrix/route-inventory/routes-08.json
@@ -203,6 +203,18 @@
     "allowDefault": false,
     "useGuards": []
   },
+  {
+    "file": "server/src/modules/book-request/book-request.controller.ts",
+    "className": "BookRequestController",
+    "methodName": "submitPair",
+    "httpMethod": "POST",
+    "path": "/book-requests/pairs",
+    "permissions": ["Permission.BookRequestAccess"],
+    "libraryAccess": [],
+    "isPublic": false,
+    "allowDefault": false,
+    "useGuards": []
+  },
   {
     "file": "server/src/modules/book-request/book-request.controller.ts",
     "className": "BookRequestController",