diff --git a/client/src/features/book-requests/__tests__/BookMissingFormatRequest.spec.ts b/client/src/features/book-requests/__tests__/BookMissingFormatRequest.spec.ts
index db6b6f9d6..e33301c5d 100644
--- a/client/src/features/book-requests/__tests__/BookMissingFormatRequest.spec.ts
+++ b/client/src/features/book-requests/__tests__/BookMissingFormatRequest.spec.ts
@@ -20,7 +20,7 @@ vi.mock('../composables/useBookRequestVisibility', () => ({
 
 import BookMissingFormatRequest from '../components/BookMissingFormatRequest.vue'
 
-function book(formats: string[]): BookDetail {
+function book(formats: string[], readAlong = false): BookDetail {
   return {
     id: 42,
     title: 'Dune',
@@ -30,7 +30,13 @@ function book(formats: string[]): BookDetail {
     seriesName: null,
     publishedYear: 1965,
     language: 'en',
-    files: formats.map((format, index) => ({ id: index + 1, format, role: 'content', filename: `dune.${format}` })),
+    files: formats.map((format, index) => ({
+      id: index + 1,
+      format,
+      role: 'content',
+      filename: `dune.${format}`,
+      ...(readAlong && format === 'epub' ? { mediaOverlay: { available: true, durationSeconds: 3600 } } : {}),
+    })),
   } as unknown as BookDetail
 }
 
@@ -40,8 +46,8 @@ function json(body: unknown, ok = true): 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 } } })
+async function render(formats: string[], readAlong = false) {
+  const wrapper = mount(BookMissingFormatRequest, { props: { book: book(formats, readAlong) }, global: { stubs: { RouterLink: RouterLinkStub } } })
   await flushPromises()
   return wrapper
 }
@@ -63,6 +69,19 @@ describe('BookMissingFormatRequest', () => {
     expect(JSON.parse(init!.body as string).items[0]).toMatchObject({ title: 'Dune', mediaKind: 'audiobook', isbn13: '9780441013593' })
   })
 
+  it('does not ask for an audiobook when the EPUB already carries its narration', async () => {
+    const wrapper = await render(['epub'], true)
+
+    expect(wrapper.find('[role="group"]').exists()).toBe(false)
+    expect(state.api).not.toHaveBeenCalled()
+  })
+
+  it('still asks for an audiobook beside a plain EPUB', async () => {
+    const wrapper = await render(['epub', 'pdf'], false)
+
+    expect(wrapper.get('button').attributes('aria-label')).toBe('Request audiobook')
+  })
+
   it('offers the ebook an audiobook is missing', async () => {
     const wrapper = await render(['m4b'])
 
diff --git a/client/src/features/book-requests/composables/useMissingFormatRequest.ts b/client/src/features/book-requests/composables/useMissingFormatRequest.ts
index 66c9ddc2e..897ac72cc 100644
--- a/client/src/features/book-requests/composables/useMissingFormatRequest.ts
+++ b/client/src/features/book-requests/composables/useMissingFormatRequest.ts
@@ -2,6 +2,7 @@ import { computed, ref, watch, type Ref } from 'vue'
 import { BOOK_REQUEST_FORMATS_BY_MEDIA_KIND } from '@bookorbit/types'
 import type { BookDetail, BookRequestAvailability, BookRequestMediaKind, BookRequestSubmitResult, CreateBookRequestPayload } from '@bookorbit/types'
 import { api } from '@/lib/api'
+import { hasReadAlong } from '@/features/book/lib/file-capabilities'
 import { pairHalfState, type PairHalfState } from '../requestPair'
 import { submitFailure, type SubmitFailure } from './useRequestSubmission'
 
@@ -23,11 +24,11 @@ export function useMissingFormatRequest(book: Ref<BookDetail | null>, enabled: R
 
   const missing = computed<BookRequestMediaKind | null>(() => {
     if (!book.value) return null
-    const formats = book.value.files
-      .filter((file) => file.role === 'content' || file.role === 'primary')
-      .map((file) => file.format?.toLowerCase() ?? '')
+    const files = book.value.files.filter((file) => file.role === 'content' || file.role === 'primary')
+    const formats = files.map((file) => file.format?.toLowerCase() ?? '')
     const hasReadable = formats.some((format) => BOOK_REQUEST_FORMATS_BY_MEDIA_KIND.ebook.includes(format))
-    const hasAudio = formats.some((format) => BOOK_REQUEST_FORMATS_BY_MEDIA_KIND.audiobook.includes(format))
+    // A read-along EPUB carries its narration, so the book already has the audio half.
+    const hasAudio = formats.some((format) => BOOK_REQUEST_FORMATS_BY_MEDIA_KIND.audiobook.includes(format)) || files.some(hasReadAlong)
     if (hasReadable && !hasAudio) return 'audiobook'
     if (hasAudio && !hasReadable) return 'ebook'
     return null
diff --git a/client/src/features/book/components/detail/BookDetailHeader.vue b/client/src/features/book/components/detail/BookDetailHeader.vue
index d4f0db3c5..ccc19e085 100644
--- a/client/src/features/book/components/detail/BookDetailHeader.vue
+++ b/client/src/features/book/components/detail/BookDetailHeader.vue
@@ -6,7 +6,7 @@ import { useI18n } from 'vue-i18n'
 import BookDetailTabs from './BookDetailTabs.vue'
 import { useBookNavigation } from '../../composables/useBookNavigation'
 
-const props = defineProps<{ bookId: number; canEditMetadata?: boolean; hasAudio?: boolean; parentLibrary?: { id: number; name: string } | null }>()
+const props = defineProps<{ bookId: number; canEditMetadata?: boolean; hasChapters?: boolean; parentLibrary?: { id: number; name: string } | null }>()
 
 const { t } = useI18n()
 const route = useRoute()
@@ -48,7 +48,7 @@ async function navigateToBook(id: number) {
       </RouterLink>
       <span class="me-2 h-4 w-px shrink-0 self-center bg-border" aria-hidden="true" />
     </template>
-    <BookDetailTabs :book-id="bookId" :can-edit-metadata="canEditMetadata" :has-audio="hasAudio" />
+    <BookDetailTabs :book-id="bookId" :can-edit-metadata="canEditMetadata" :has-chapters="hasChapters" />
 
     <div v-if="hasContext" class="hidden sm:flex items-center gap-1 ml-4 border-l pl-4">
       <span v-if="index !== -1" class="text-xs text-muted-foreground mr-2 font-medium tabular-nums">
diff --git a/client/src/features/book/components/detail/BookDetailLayout.vue b/client/src/features/book/components/detail/BookDetailLayout.vue
index 570485ed0..2cdf9f0d2 100644
--- a/client/src/features/book/components/detail/BookDetailLayout.vue
+++ b/client/src/features/book/components/detail/BookDetailLayout.vue
@@ -8,10 +8,10 @@ const props = withDefaults(
     bookId: number
     canEditMetadata?: boolean
     coverTint?: CoverTint | null
-    hasAudio?: boolean
+    hasChapters?: boolean
     parentLibrary?: { id: number; name: string } | null
   }>(),
-  { coverTint: null, hasAudio: false, parentLibrary: null },
+  { coverTint: null, hasChapters: false, parentLibrary: null },
 )
 
 const tintVars = computed(() => coverTintVars(props.coverTint))
@@ -25,7 +25,7 @@ const tintVars = computed(() => coverTintVars(props.coverTint))
     ]"
     :style="tintVars"
   >
-    <BookDetailHeader :book-id="bookId" :can-edit-metadata="canEditMetadata" :has-audio="hasAudio" :parent-library="parentLibrary" />
+    <BookDetailHeader :book-id="bookId" :can-edit-metadata="canEditMetadata" :has-chapters="hasChapters" :parent-library="parentLibrary" />
     <main class="flex-1 overflow-y-auto overflow-x-hidden p-4 sm:px-6 sm:py-4">
       <slot />
     </main>
diff --git a/client/src/features/book/components/detail/BookDetailTabs.vue b/client/src/features/book/components/detail/BookDetailTabs.vue
index 2b60cd788..08caa49e1 100644
--- a/client/src/features/book/components/detail/BookDetailTabs.vue
+++ b/client/src/features/book/components/detail/BookDetailTabs.vue
@@ -4,7 +4,7 @@ import { useRoute, useRouter } from 'vue-router'
 import { useI18n } from 'vue-i18n'
 import { normalizeBookDetailTab, type BookDetailTab } from '@/features/book/lib/book-detail-tabs'
 
-const props = defineProps<{ bookId: number; canEditMetadata?: boolean; hasAudio?: boolean }>()
+const props = defineProps<{ bookId: number; canEditMetadata?: boolean; hasChapters?: boolean }>()
 const route = useRoute()
 const router = useRouter()
 const { t } = useI18n()
@@ -20,7 +20,7 @@ const tabs = computed<{ label: string; tab: BookDetailTab }[]>(() => {
     result.push({ label: t('book.detail.tabs.editMetadata'), tab: 'edit' })
   }
   result.push({ label: t('book.detail.tabs.files'), tab: 'files' })
-  if (props.hasAudio) result.push({ label: t('book.detail.tabs.chapters'), tab: 'chapters' })
+  if (props.hasChapters) result.push({ label: t('book.detail.tabs.chapters'), tab: 'chapters' })
   result.push({ label: t('book.detail.tabs.readingLog'), tab: 'reading-log' })
   result.push({ label: t('book.detail.tabs.highlights'), tab: 'highlights' })
   return result
diff --git a/client/src/features/book/components/detail/chapters/ChapterListCard.vue b/client/src/features/book/components/detail/chapters/ChapterListCard.vue
index e8ddee67f..06f7173fe 100644
--- a/client/src/features/book/components/detail/chapters/ChapterListCard.vue
+++ b/client/src/features/book/components/detail/chapters/ChapterListCard.vue
@@ -17,6 +17,8 @@ const props = defineProps<{
   totalDurationMs: number | null
   /** Where the reader last listened, for the "you are here" marker. */
   listeningMs: number | null
+  /** True when a row can only open the reader where the book stands, because its start cannot be played from. */
+  openOnly?: boolean
 }>()
 
 const emit = defineEmits<{
@@ -251,7 +253,7 @@ defineExpose({ scrollToKey, commitPendingStarts })
             type="button"
             class="listen-grid listen-row h-9 w-full items-center rounded-[10px] px-2.5 text-start transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-inset focus-visible:ring-ring"
             :class="listenState(virtual.index) === 'now' ? 'bg-primary/15 shadow-[inset_2px_0_0_var(--primary)]' : 'hover:bg-muted/55'"
-            :aria-label="t('book.detail.chapters.playFrom', { title: row(virtual.index).title })"
+            :aria-label="t(openOnly ? 'book.detail.chapters.openInReader' : 'book.detail.chapters.playFrom', { title: row(virtual.index).title })"
             :aria-current="listenState(virtual.index) === 'now' ? 'true' : undefined"
             @click="handleListen(row(virtual.index).startMs)"
           >
diff --git a/client/src/features/book/components/detail/chapters/ChaptersHeroBar.vue b/client/src/features/book/components/detail/chapters/ChaptersHeroBar.vue
index 8db392591..99a5a8076 100644
--- a/client/src/features/book/components/detail/chapters/ChaptersHeroBar.vue
+++ b/client/src/features/book/components/detail/chapters/ChaptersHeroBar.vue
@@ -49,6 +49,7 @@ function slotRatio(slot: BookCoverSlot): number | null {
 
 const sourceLine = computed(() => {
   const { source, updatedBy, updatedAt } = props.state
+  if (props.state.readAlong) return t('book.detail.chapters.source.readAlong')
   if (source === 'manual') {
     const when = updatedAt ? formatRelativeTimeFromNow(updatedAt) : null
     if (updatedBy && when) return t('book.detail.chapters.source.manualBy', { name: updatedBy.name, when })
@@ -113,6 +114,7 @@ function handleDone() {
 
     <div class="hero-actions flex shrink-0 items-center gap-2 border-s border-border ps-4">
       <span
+        v-if="!state.readAlong"
         class="inline-flex h-[18px] items-center gap-1 rounded px-1.5 text-[9.5px] font-bold uppercase tracking-wider"
         :class="state.locked ? 'bg-primary/15 text-primary' : 'bg-muted text-muted-foreground'"
         :title="state.locked ? t('book.detail.chapters.protectedHint') : t('book.detail.chapters.unprotectedHint')"
diff --git a/client/src/features/book/components/detail/chapters/__tests__/ChaptersHeroBar.spec.ts b/client/src/features/book/components/detail/chapters/__tests__/ChaptersHeroBar.spec.ts
index 57fee3b93..3912a688d 100644
--- a/client/src/features/book/components/detail/chapters/__tests__/ChaptersHeroBar.spec.ts
+++ b/client/src/features/book/components/detail/chapters/__tests__/ChaptersHeroBar.spec.ts
@@ -66,4 +66,16 @@ describe('ChaptersHeroBar', () => {
 
     expect(cover.attributes('style')).toContain('aspect-ratio: 1')
   })
+
+  it('says a read-along list is view only and offers no protection to switch', async () => {
+    await setI18nLocale('en')
+    const state = { ...STATE, source: null, readAlong: true } as unknown as BookChaptersState
+    wrapper = mount(ChaptersHeroBar, { props: { book: book({}), state, editing: false, canEdit: false, chapterCount: 1 } })
+    await flushPromises()
+
+    expect(wrapper.text()).toContain('From the read-along narration in the EPUB, view only')
+    expect(wrapper.text()).not.toContain('Not protected')
+    expect(wrapper.text()).not.toContain('Protected')
+    expect(wrapper.find('button').exists()).toBe(false)
+  })
 })
diff --git a/client/src/features/book/components/detail/tabs/ChaptersTab.vue b/client/src/features/book/components/detail/tabs/ChaptersTab.vue
index 2af0bf86f..2ee295b65 100644
--- a/client/src/features/book/components/detail/tabs/ChaptersTab.vue
+++ b/client/src/features/book/components/detail/tabs/ChaptersTab.vue
@@ -76,7 +76,9 @@ const TOOLS: { tool: ChapterTool; key: string }[] = [
 ]
 
 const bookId = computed(() => props.book.id)
-const canEdit = computed(() => hasLibraryPermission(Permission.LibraryEditMetadata, props.book.libraryId, 'editor'))
+// A book with only a read-along EPUB has narration to list but no audio files to cut.
+const hasAudioFiles = computed(() => props.book.audioMetadata != null)
+const canEdit = computed(() => hasAudioFiles.value && hasLibraryPermission(Permission.LibraryEditMetadata, props.book.libraryId, 'editor'))
 
 const store = useBookChapters(bookId)
 const { state, loading, loadError, busy } = store
@@ -93,6 +95,7 @@ const listeningMs = ref<number | null>(null)
 
 const showSkeleton = useDeferredLoading(computed(() => loading.value && state.value === null))
 const trackChapters = computed(() => (state.value ? chaptersFromTracks(state.value.tracks) : null))
+const readAlong = computed(() => state.value?.readAlong === true)
 
 // ── Loading ──────────────────────────────────────────────────────────────────
 
@@ -117,6 +120,10 @@ async function refresh(options: { silent?: boolean } = {}) {
 
 /** The listener's place in the book, for the "you are here" marker. Derived from the saved percentage. */
 async function loadListening() {
+  if (!hasAudioFiles.value) {
+    listeningMs.value = null
+    return
+  }
   try {
     const response = await api(`/api/v1/audiobooks/${bookId.value}/playback-state`)
     if (!response.ok) return
@@ -400,6 +407,12 @@ function handleSettle() {
 }
 
 function openInReader(startMs: number) {
+  if (readAlong.value) {
+    const readAlongFileId = state.value?.sources.readAlongFileId
+    if (readAlongFileId != null)
+      void router.push({ name: 'reader', params: { bookId: bookId.value, fileId: readAlongFileId }, query: { format: 'epub' } })
+    return
+  }
   const fileId = state.value?.tracks[0]?.fileId
   const format = props.book.files.find((file) => file.id === fileId)?.format
   if (fileId === undefined || !format) return
@@ -921,6 +934,7 @@ function handleKeydown(event: KeyboardEvent) {
           :issues-by-key="issuesByKey"
           :total-duration-ms="totalDurationMs"
           :listening-ms="editing ? null : listeningMs"
+          :open-only="readAlong"
           @activate="handleActivate"
           @toggle-select="handleToggleSelect"
           @update-title="handleUpdateTitle"
@@ -1037,7 +1051,7 @@ function handleKeydown(event: KeyboardEvent) {
           </template>
           <template #band>
             <ChapterListenBand
-              v-if="!editing && totalDurationMs && rows.length"
+              v-if="!editing && !readAlong && totalDurationMs && rows.length"
               :rows="rows"
               :total-duration-ms="totalDurationMs"
               :listening-ms="listeningMs"
diff --git a/client/src/features/book/lib/__tests__/book-detail-tabs.spec.ts b/client/src/features/book/lib/__tests__/book-detail-tabs.spec.ts
new file mode 100644
index 000000000..9da2f44c9
--- /dev/null
+++ b/client/src/features/book/lib/__tests__/book-detail-tabs.spec.ts
@@ -0,0 +1,36 @@
+import { describe, expect, it } from 'vitest'
+import type { BookDetail } from '@bookorbit/types'
+import { hasChaptersTab } from '../book-detail-tabs'
+
+type TabBook = Pick<BookDetail, 'audioMetadata' | 'files'>
+
+function book(files: Array<Record<string, unknown>>, audioMetadata: unknown = null): TabBook {
+  return { audioMetadata, files } as unknown as TabBook
+}
+
+const READ_ALONG = { id: 1, format: 'epub', role: 'content', mediaOverlay: { available: true, durationSeconds: 3600 } }
+
+describe('hasChaptersTab', () => {
+  it('is off until there is a book', () => {
+    expect(hasChaptersTab(null)).toBe(false)
+    expect(hasChaptersTab(undefined)).toBe(false)
+  })
+
+  it('is on for a book with audio files', () => {
+    expect(hasChaptersTab(book([{ id: 1, format: 'm4b', role: 'content' }], { narrators: [] }))).toBe(true)
+  })
+
+  it('is on for an EPUB that carries read-along narration', () => {
+    expect(hasChaptersTab(book([READ_ALONG]))).toBe(true)
+    expect(hasChaptersTab(book([{ ...READ_ALONG, role: 'primary' }]))).toBe(true)
+  })
+
+  it.each([
+    ['a plain EPUB', [{ id: 1, format: 'epub', role: 'content', mediaOverlay: { available: false, durationSeconds: null } }]],
+    ['an EPUB never checked for narration', [{ id: 1, format: 'epub', role: 'content' }]],
+    ['a supplementary read-along EPUB', [{ ...READ_ALONG, role: 'supplement' }]],
+    ['a book with neither', [{ id: 1, format: 'pdf', role: 'content' }]],
+  ])('is off for %s', (_label, files) => {
+    expect(hasChaptersTab(book(files))).toBe(false)
+  })
+})
diff --git a/client/src/features/book/lib/book-detail-tabs.ts b/client/src/features/book/lib/book-detail-tabs.ts
index 52b73ab3f..fdcd1b33e 100644
--- a/client/src/features/book/lib/book-detail-tabs.ts
+++ b/client/src/features/book/lib/book-detail-tabs.ts
@@ -1,3 +1,6 @@
+import { isContentBookFile, type BookDetail } from '@bookorbit/types'
+import { hasReadAlong } from './file-capabilities'
+
 export const BOOK_DETAIL_TABS = ['details', 'edit', 'files', 'chapters', 'reading-log', 'highlights'] as const
 
 export type BookDetailTab = (typeof BOOK_DETAIL_TABS)[number]
@@ -8,3 +11,10 @@ export function normalizeBookDetailTab(value: unknown): BookDetailTab {
   }
   return 'details'
 }
+
+/** The Chapters tab has audio files to lay out, or a read-along EPUB whose narration it can list. */
+export function hasChaptersTab(book: Pick<BookDetail, 'audioMetadata' | 'files'> | null | undefined): boolean {
+  if (!book) return false
+  if (book.audioMetadata != null) return true
+  return book.files.some((file) => isContentBookFile(file) && hasReadAlong(file))
+}
diff --git a/client/src/locales/en.json b/client/src/locales/en.json
index 2b378fd0c..912615596 100644
--- a/client/src/locales/en.json
+++ b/client/src/locales/en.json
@@ -7696,10 +7696,12 @@
           "migration": "Imported from Audiobookshelf",
           "manual": "Edited in BookOrbit",
           "manualBy": "Edited by {name} {when}",
+          "readAlong": "From the read-along narration in the EPUB, view only",
           "none": "No chapters yet"
         },
         "youAreHere": "You are here",
         "playFrom": "Listen from {title}",
+        "openInReader": "Open {title} in the reader",
         "selectRow": "Select chapter {index}",
         "selectedCount": "{count, plural, one {# selected} other {# selected}}",
         "selectAll": "Select all",
diff --git a/client/src/views/BookDetailView.vue b/client/src/views/BookDetailView.vue
index 4c93bb7a3..bd0b8556c 100644
--- a/client/src/views/BookDetailView.vue
+++ b/client/src/views/BookDetailView.vue
@@ -11,7 +11,7 @@ import { useBookDetail } from '@/features/book/composables/useBookDetail'
 import { useBookEvents } from '@/features/book/composables/useBookEvents'
 import { useScanProgress } from '@/features/scanner/composables/useScanProgress'
 import { usePageTitle } from '@/composables/usePageTitle'
-import { normalizeBookDetailTab } from '@/features/book/lib/book-detail-tabs'
+import { hasChaptersTab, normalizeBookDetailTab } from '@/features/book/lib/book-detail-tabs'
 import { useLibraryPermissions } from '@/features/library/composables/useLibraryPermissions'
 import { useLibraries } from '@/features/library/composables/useLibraries'
 import { COVER_ASPECT_RATIO_KEY, DEFAULT_COVER_ASPECT_RATIO } from '@/features/book/lib/cover-aspect-ratio'
@@ -56,11 +56,11 @@ const canEditMetadata = computed(() => hasLibraryPermission('library_edit_metada
 const parentLibrary = computed(() =>
   detail.value?.libraryId != null && detail.value.libraryName ? { id: detail.value.libraryId, name: detail.value.libraryName } : null,
 )
-const hasAudio = computed(() => detail.value?.audioMetadata != null)
+const hasChapters = computed(() => hasChaptersTab(detail.value))
 
-// A chapters link to a book without audio (or one whose audio was removed) lands on the details.
+// A chapters link to a book without audio or read-along narration (or one whose audio was removed) lands on the details.
 watch([tab, detail], ([current, book]) => {
-  if (current === 'chapters' && book && book.id === bookId.value && !hasAudio.value) {
+  if (current === 'chapters' && book && book.id === bookId.value && !hasChapters.value) {
     void router.replace({ name: 'book-detail', params: { bookId: book.id }, query: { ...route.query, tab: 'details' } })
   }
 })
@@ -127,7 +127,7 @@ onMounted(() => {
   const warm = () => {
     void loadReadingLogTab()
     void loadHighlightsTab()
-    if (hasAudio.value) void loadChaptersTab()
+    if (hasChapters.value) void loadChaptersTab()
   }
   if (typeof requestIdleCallback === 'function') requestIdleCallback(warm, { timeout: 2000 })
   else setTimeout(warm, 500)
@@ -167,7 +167,7 @@ function onChaptersChanged() {
     :cover-tint="coverTint"
     :can-edit-metadata="canEditMetadata"
     :parent-library="parentLibrary"
-    :has-audio="hasAudio"
+    :has-chapters="hasChapters"
   >
     <Transition name="content" mode="out-in">
       <div v-if="detail" key="detail" class="@container/book-detail h-full">
@@ -186,7 +186,7 @@ function onChaptersChanged() {
             @cover-changed="onCoverChanged"
           />
           <FilesTab v-else-if="tab === 'files'" :book="detail" @refetch="fetch(detail.id)" />
-          <ChaptersTab v-else-if="tab === 'chapters' && hasAudio" :book="detail" @changed="onChaptersChanged" />
+          <ChaptersTab v-else-if="tab === 'chapters' && hasChapters" :book="detail" @changed="onChaptersChanged" />
           <ReadingLogTab v-else-if="tab === 'reading-log'" :book="detail" @saved="onMetadataSaved" @refetch="handleBookRefetch" />
           <HighlightsTab v-else-if="tab === 'highlights'" :book="detail" />
         </KeepAlive>
diff --git a/packages/types/src/audiobook.ts b/packages/types/src/audiobook.ts
index 44f658ed4..b3a1b8421 100644
--- a/packages/types/src/audiobook.ts
+++ b/packages/types/src/audiobook.ts
@@ -68,6 +68,11 @@ export interface BookChaptersState {
   audibleRegion: AudibleRegion;
   sources: BookChapterSources;
   writeBack: BookChapterWriteBack;
+  /**
+   * True when the book has no audio files and the chapters are read off a read-along EPUB's
+   * narration instead. That list can be shown but not edited, saved or written.
+   */
+  readAlong?: boolean;
 }
 
 export interface SaveBookChaptersRequest {
diff --git a/server/src/modules/chapter-editor/chapter-editor.service.test.ts b/server/src/modules/chapter-editor/chapter-editor.service.test.ts
index 75c0a9da0..11ee95488 100644
--- a/server/src/modules/chapter-editor/chapter-editor.service.test.ts
+++ b/server/src/modules/chapter-editor/chapter-editor.service.test.ts
@@ -291,6 +291,60 @@ describe('ChapterEditorService.getState', () => {
     await expect(service.getState(BOOK_ID, USER)).rejects.toThrow(NotFoundException);
   });
 
+  it('refuses a book whose only EPUB has no narration', async () => {
+    const { service, epubService } = makeService({ tracks: [], ebookFiles: [ebookFile(30, false)] });
+
+    await expect(service.getState(BOOK_ID, USER)).rejects.toThrow(NotFoundException);
+    expect(epubService.getMediaOverlayPlaylist).not.toHaveBeenCalled();
+  });
+
+  it('shows the narration of a read-along EPUB with no audio files as chapters that cannot be edited', async () => {
+    const { service, epubService, bookService } = makeService({ tracks: [], row: null, ebookFiles: [ebookFile(31, true)] });
+    epubService.getMediaOverlayPlaylist.mockResolvedValue({
+      durationSeconds: 3_600.4,
+      sections: [
+        { index: 0, label: null, startSeconds: 0 },
+        { index: 1, label: ' Chapter One ', startSeconds: 12.3456 },
+        { index: 2, label: 'Chapter Two', startSeconds: 1_800 },
+      ],
+    });
+
+    const state = await service.getState(BOOK_ID, USER);
+
+    expect(bookService.verifyBookAccess).toHaveBeenCalledWith(BOOK_ID, USER);
+    expect(epubService.getMediaOverlayPlaylist).toHaveBeenCalledWith(BOOK_ID, 31, USER);
+    expect(state).toMatchObject({
+      readAlong: true,
+      chapters: [
+        { title: 'Chapter One', startMs: 12_346 },
+        { title: 'Chapter Two', startMs: 1_800_000 },
+      ],
+      source: null,
+      derived: false,
+      locked: false,
+      totalDurationMs: 3_600_400,
+      tracks: [],
+      versionCount: 0,
+      sources: { ebookFileId: 31, readAlongFileId: 31 },
+      writeBack: { available: false, reason: null, fileCount: 0 },
+    });
+  });
+
+  it('keeps the audio files as the source of chapters when the book has both', async () => {
+    const { service, epubService } = makeService({ ebookFiles: [ebookFile(31, true)] });
+
+    const state = await service.getState(BOOK_ID, USER);
+
+    expect(state.readAlong).toBeUndefined();
+    expect(epubService.getMediaOverlayPlaylist).not.toHaveBeenCalled();
+  });
+
+  it('still refuses to edit a read-along EPUB, which has no audio tracks to cut', async () => {
+    const { service } = makeService({ tracks: [], ebookFiles: [ebookFile(31, true)] });
+
+    await expect(service.save(BOOK_ID, { chapters: [{ title: 'One', startMs: 0 }], baseRevision: '' }, USER)).rejects.toThrow(NotFoundException);
+  });
+
   it('changes the revision whenever the stored list, its source or its save time changes', async () => {
     const base = await currentRevision(makeService().service);
 
diff --git a/server/src/modules/chapter-editor/chapter-editor.service.ts b/server/src/modules/chapter-editor/chapter-editor.service.ts
index e17411045..a20e64640 100644
--- a/server/src/modules/chapter-editor/chapter-editor.service.ts
+++ b/server/src/modules/chapter-editor/chapter-editor.service.ts
@@ -35,6 +35,7 @@ import {
   type BookChapterVersion,
   type BookChapterVersionSummary,
   type EmbeddedBookChapters,
+  type EpubMediaOverlayPlaylist,
 } from '@bookorbit/types';
 
 import type { RequestUser } from '../../common/types/request-user';
@@ -120,7 +121,8 @@ export class ChapterEditorService {
 
   async getState(bookId: number, user: RequestUser): Promise<BookChaptersState> {
     await this.bookService.verifyBookAccess(bookId, user);
-    return this.buildState(bookId, await this.loadContext(bookId));
+    const context = await this.findContext(bookId);
+    return context ? this.buildState(bookId, context) : this.buildReadAlongState(bookId, user);
   }
 
   async save(bookId: number, dto: SaveBookChaptersDto, user: RequestUser): Promise<BookChaptersState> {
@@ -243,20 +245,22 @@ export class ChapterEditorService {
     }
 
     const playlist = await this.epubService.getMediaOverlayPlaylist(bookId, fileId, user);
-    const chapters = normalizeAudiobookChapters(
+    const chapters = this.readAlongChapters(playlist);
+    if (chapters.length === 0)
+      throw this.coded(ConflictException, BOOK_CHAPTERS_ERROR_CODES.ebookUnavailable, 'The read-along EPUB names no sections');
+    return { source, fileId, chapters, titlesOnly: false, runtimeMs: this.readAlongRuntimeMs(playlist) };
+  }
+
+  private readAlongChapters(playlist: EpubMediaOverlayPlaylist): AudiobookChapter[] {
+    return normalizeAudiobookChapters(
       playlist.sections
         .filter((section) => section.label?.trim())
         .map((section) => ({ title: section.label!.trim(), startMs: Math.round(section.startSeconds * 1000) })),
     );
-    if (chapters.length === 0)
-      throw this.coded(ConflictException, BOOK_CHAPTERS_ERROR_CODES.ebookUnavailable, 'The read-along EPUB names no sections');
-    return {
-      source,
-      fileId,
-      chapters,
-      titlesOnly: false,
-      runtimeMs: playlist.durationSeconds === null ? null : Math.round(playlist.durationSeconds * 1000),
-    };
+  }
+
+  private readAlongRuntimeMs(playlist: EpubMediaOverlayPlaylist): number | null {
+    return playlist.durationSeconds === null ? null : Math.round(playlist.durationSeconds * 1000);
   }
 
   /** Pauses near each point, for snapping chapter starts. A window whose audio will not decode is marked failed. */
@@ -387,14 +391,50 @@ export class ChapterEditorService {
     return { ...this.mapVersion(row), chapters: row.chapters };
   }
 
-  private async loadContext(bookId: number): Promise<EditorContext> {
+  private async findContext(bookId: number): Promise<EditorContext | null> {
     const [row, rows] = await Promise.all([this.repo.findChapterRow(bookId), this.repo.findTrackRows(bookId)]);
     const tracks = orderAudiobookTracks(rows);
-    if (tracks.length === 0) throw new NotFoundException('Book has no audio tracks');
+    if (tracks.length === 0) return null;
     const revision = computeChapterEditorRevision(row, rows);
     return { bookId, row, rows, tracks, revision };
   }
 
+  private async loadContext(bookId: number): Promise<EditorContext> {
+    const context = await this.findContext(bookId);
+    if (!context) throw new NotFoundException('Book has no audio tracks');
+    return context;
+  }
+
+  /**
+   * A book with a read-along EPUB and no audio files has narration but nothing to cut, so its
+   * chapters are read off the EPUB for display. Every editing route still needs audio tracks.
+   */
+  private async buildReadAlongState(bookId: number, user: RequestUser): Promise<BookChaptersState> {
+    const sources = this.ebookSources(await this.repo.findEbookFiles(bookId));
+    if (sources.readAlongFileId === null) throw new NotFoundException('Book has no audio tracks');
+    const [playlist, audibleRegion] = await Promise.all([
+      this.epubService.getMediaOverlayPlaylist(bookId, sources.readAlongFileId, user),
+      this.defaultAudibleRegion(),
+    ]);
+    return {
+      chapters: this.readAlongChapters(playlist),
+      source: null,
+      derived: false,
+      locked: false,
+      revision: '',
+      updatedAt: null,
+      updatedBy: null,
+      totalDurationMs: this.readAlongRuntimeMs(playlist),
+      tracks: [],
+      audibleId: null,
+      versionCount: 0,
+      audibleRegion,
+      sources,
+      writeBack: { available: false, reason: null, fileCount: 0 },
+      readAlong: true,
+    };
+  }
+
   private async buildState(bookId: number, context: EditorContext): Promise<BookChaptersState> {
     const [locked, versionCount, ebookFiles, audibleRegion, writeBack] = await Promise.all([
       this.lockService.isFieldLocked(bookId, 'chapters'),