diff --git a/Dockerfile b/Dockerfile
index cc45ca17..916f9657 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -59,7 +59,10 @@ RUN cp -r /go/pkg/mod /app/go-module-cache
 # This stage is ONLY used for running tests, never deployed to production
 FROM golang:1.26-alpine AS test-runner
 
-RUN apk --no-cache add ca-certificates curl poppler-utils
+# ffmpeg/ffprobe match the runtime stage: the audio ingestion (tag
+# fallbacks, embedded covers, cue probing) must be exercised in tests
+# exactly as it runs in production.
+RUN apk --no-cache add ca-certificates curl poppler-utils ffmpeg
 
 WORKDIR /app
 
diff --git a/bruno/media-items/Get Audio Chapters.yml b/bruno/media-items/Get Audio Chapters.yml
new file mode 100644
index 00000000..e998bdbf
--- /dev/null
+++ b/bruno/media-items/Get Audio Chapters.yml	
@@ -0,0 +1,31 @@
+info:
+  name: Get Audio Chapters
+  type: http
+  seq: 30
+
+http:
+  method: GET
+  url: "{{base_url}}/api/media-items/{{media_item_id}}/chapters"
+  headers:
+    - name: ""
+      value: application/json
+  auth: inherit
+
+settings:
+  encodeUrl: true
+  timeout: 0
+  followRedirects: true
+  maxRedirects: 5
+
+docs: |-
+  ## Get Audio Chapters
+
+  The format-abstraction chapter list for audiobooks
+  (media_items.audio_metadata). Single-file books return `layout: ""` and
+  an empty `tracks` array; folder-of-tracks books return `layout:
+  "folder"` and zip books `layout: "zip"`, each with one `tracks` entry
+  per playable file (global-seconds start/end plus the per-track `url`).
+
+  **Method:** GET
+
+  **Endpoint:** /api/media-items/{id}/chapters
diff --git a/bruno/media-items/Get Audio Track.yml b/bruno/media-items/Get Audio Track.yml
new file mode 100644
index 00000000..0e4f608e
--- /dev/null
+++ b/bruno/media-items/Get Audio Track.yml	
@@ -0,0 +1,31 @@
+info:
+  name: Get Audio Track
+  type: http
+  seq: 31
+
+http:
+  method: GET
+  url: "{{base_url}}/api/media-items/{{media_item_id}}/audio/0"
+  headers:
+    - name: Range
+      value: bytes=0-1023
+  auth: inherit
+
+settings:
+  encodeUrl: true
+  timeout: 0
+  followRedirects: true
+  maxRedirects: 5
+
+docs: |-
+  ## Get Audio Track
+
+  Streams one track of a multi-file audiobook (folder or zip layout).
+  Range requests are honored: folder tracks are served from the real
+  file; zip tracks are extracted in place (backward seeks re-open the
+  entry). Requires the item's library to be visible to the requester
+  (403 otherwise). Single-file books have no track manifest — 404.
+
+  **Method:** GET
+
+  **Endpoint:** /api/media-items/{id}/audio/{trackIndex}
diff --git a/cmd/server/tests/audiobook_multifile_test.go b/cmd/server/tests/audiobook_multifile_test.go
new file mode 100644
index 00000000..27d29039
--- /dev/null
+++ b/cmd/server/tests/audiobook_multifile_test.go
@@ -0,0 +1,571 @@
+package main
+
+// Multi-file audiobook integration tests: folder-of-tracks and zip-of-
+// audio books must ingest as ONE item each (never per-track items), the
+// /chapters manifest must expose the track list, the per-track streaming
+// endpoint must serve bytes behind the library-visibility gate, and
+// rescans must be idempotent while absorbing pre-grouping one-track
+// strays. Live dev DB — all fixtures use test-named libraries under
+// t.TempDir() folders and cascade away with the library delete.
+
+import (
+	"archive/zip"
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"testing"
+	"time"
+
+	"bookhoard/internal/database"
+
+	"github.com/google/uuid"
+	"github.com/jackc/pgx/v5/pgtype"
+	"github.com/stretchr/testify/require"
+)
+
+// writeTestTrack renders a short silent mp3 via ffmpeg when available so
+// ffprobe can produce real durations; otherwise falls back to dummy bytes
+// (ingest is ffprobe-optional by design — structure assertions don't need
+// real audio).
+func writeTestTrack(t *testing.T, path string) {
+	t.Helper()
+	require.NoError(t, os.MkdirAll(filepath.Dir(path), 0o755))
+	if ffmpeg, err := exec.LookPath("ffmpeg"); err == nil {
+		cmd := exec.Command(ffmpeg, "-y", "-v", "error", "-f", "lavfi",
+			"-i", "sine=frequency=440:duration=0.3", "-codec:a", "libmp3lame", "-b:a", "32k", path)
+		if out, err := cmd.CombinedOutput(); err == nil {
+			return
+		} else {
+			t.Logf("ffmpeg track render failed (%s), falling back to dummy bytes: %s", err, out)
+		}
+	}
+	require.NoError(t, os.WriteFile(path, []byte("ID3 dummy audio"), 0o644))
+}
+
+// audioTestLibrary builds an audiobooks-type library with a fresh temp
+// folder, returning its UUID and the folder path.
+func audioTestLibrary(t *testing.T, setup *TestServerSetup, name string) (pgtype.UUID, string) {
+	t.Helper()
+	libID, folder := createTypedTestLibrary(t, setup, name, "audiobooks")
+	return libID, folder
+}
+
+// listLibraryAudioItems returns every media item row of the library.
+func listLibraryAudioItems(t *testing.T, setup *TestServerSetup, libID pgtype.UUID) []database.ListMediaItemsByLibraryIncludingArchivedRow {
+	t.Helper()
+	items, err := setup.DB.ListMediaItemsByLibraryIncludingArchived(context.Background(), libID)
+	require.NoError(t, err)
+	return items
+}
+
+// findAudioItemByPath returns the item with the given file_path.
+func findAudioItemByPath(t *testing.T, setup *TestServerSetup, libID pgtype.UUID, filePath string) (database.ListMediaItemsByLibraryIncludingArchivedRow, bool) {
+	t.Helper()
+	for _, item := range listLibraryAudioItems(t, setup, libID) {
+		if item.FilePath == filePath {
+			return item, true
+		}
+	}
+	return database.ListMediaItemsByLibraryIncludingArchivedRow{}, false
+}
+
+// decodeAudioPayload parses the audio_metadata JSONB of an item.
+func decodeAudioPayload(t *testing.T, item database.ListMediaItemsByLibraryIncludingArchivedRow) (layout string, trackCount, chapterCount int, duration float64) {
+	t.Helper()
+	require.NotNil(t, item.AudioMetadata, "audio_metadata must be present")
+	var payload struct {
+		Layout          string  `json:"layout"`
+		DurationSeconds float64 `json:"duration_seconds"`
+		Tracks          []struct {
+			Index int    `json:"index"`
+			Path  string `json:"path"`
+		} `json:"tracks"`
+		Chapters []json.RawMessage `json:"chapters"`
+	}
+	require.NoError(t, json.Unmarshal(item.AudioMetadata, &payload))
+	return payload.Layout, len(payload.Tracks), len(payload.Chapters), payload.DurationSeconds
+}
+
+func TestAudiobookFolderOfTracks(t *testing.T) {
+	setup := setupTestServer(t)
+	t.Cleanup(func() { _ = setup.Close() })
+
+	admin, _ := moveTestAdminID(t, setup)
+	libID, folder := audioTestLibrary(t, setup, fmt.Sprintf("Test Audio Folder %d", time.Now().UnixNano()))
+	t.Cleanup(func() { deleteLibraries(t, setup, libID) })
+
+	// Author/Title/01.mp3, 02.mp3 — the canonical folder book.
+	writeTestTrack(t, filepath.Join(folder, "Test Author", "Test Title", "02 Second.mp3"))
+	writeTestTrack(t, filepath.Join(folder, "Test Author", "Test Title", "01 First.mp3"))
+	// A lone single-file book in a sibling folder must stay single-file.
+	writeTestTrack(t, filepath.Join(folder, "Test Author", "Lone Book", "lonely.mp3"))
+
+	scanTestFolder(t, setup, admin, folder)
+
+	// The folder is ONE item whose file_path is the directory.
+	book, found := findAudioItemByPath(t, setup, libID, filepath.ToSlash("Test Author/Test Title"))
+	require.True(t, found, "folder book item must exist at the directory path")
+	layout, tracks, chapters, duration := decodeAudioPayload(t, book)
+	require.Equal(t, "folder", layout)
+	require.Equal(t, 2, tracks)
+	require.Equal(t, 2, chapters)
+	if duration <= 0 {
+		t.Log("no ffprobe durations available in this environment (degraded ingest)")
+	}
+
+	// The lone mp3 keeps the single-file model.
+	_, loneFound := findAudioItemByPath(t, setup, libID, filepath.ToSlash("Test Author/Lone Book/lonely.mp3"))
+	require.True(t, loneFound, "lone mp3 must stay its own single-file item")
+	require.Len(t, listLibraryAudioItems(t, setup, libID), 2, "exactly two items: one folder book + one single-file book")
+
+	// Rescan idempotency: nothing duplicates, manifest unchanged.
+	scanTestFolder(t, setup, admin, folder)
+	require.Len(t, listLibraryAudioItems(t, setup, libID), 2)
+	again, found := findAudioItemByPath(t, setup, libID, filepath.ToSlash("Test Author/Test Title"))
+	require.True(t, found)
+	require.JSONEq(t, string(book.AudioMetadata), string(again.AudioMetadata))
+}
+
+func TestAudiobookAbsorbsOneTrackStrays(t *testing.T) {
+	setup := setupTestServer(t)
+	t.Cleanup(func() { _ = setup.Close() })
+
+	admin, _ := moveTestAdminID(t, setup)
+	libID, folder := audioTestLibrary(t, setup, fmt.Sprintf("Test Audio Merge %d", time.Now().UnixNano()))
+	t.Cleanup(func() { deleteLibraries(t, setup, libID) })
+
+	// First scan: a single mp3 → single-file item (the pre-grouping model).
+	writeTestTrack(t, filepath.Join(folder, "Merge Book", "01 only.mp3"))
+	scanTestFolder(t, setup, admin, folder)
+	_, found := findAudioItemByPath(t, setup, libID, filepath.ToSlash("Merge Book/01 only.mp3"))
+	require.True(t, found, "single track ingests as its own item first")
+
+	// Second track arrives; rescan must create the folder book and delete
+	// the stray one-track item.
+	writeTestTrack(t, filepath.Join(folder, "Merge Book", "02 and.mp3"))
+	scanTestFolder(t, setup, admin, folder)
+
+	book, found := findAudioItemByPath(t, setup, libID, filepath.ToSlash("Merge Book"))
+	require.True(t, found, "folder book must exist after rescan")
+	layout, tracks, _, _ := decodeAudioPayload(t, book)
+	require.Equal(t, "folder", layout)
+	require.Equal(t, 2, tracks)
+
+	items := listLibraryAudioItems(t, setup, libID)
+	require.Len(t, items, 1, "the one-track stray must be absorbed into the folder book")
+}
+
+func TestAudiobookZipBook(t *testing.T) {
+	setup := setupTestServer(t)
+	t.Cleanup(func() { _ = setup.Close() })
+
+	admin, _ := moveTestAdminID(t, setup)
+	libID, folder := audioTestLibrary(t, setup, fmt.Sprintf("Test Audio Zip %d", time.Now().UnixNano()))
+	t.Cleanup(func() { deleteLibraries(t, setup, libID) })
+
+	// Build a zip of mp3s via ffmpeg-rendered tracks.
+	dir := t.TempDir()
+	writeTestTrack(t, filepath.Join(dir, "a.mp3"))
+	writeTestTrack(t, filepath.Join(dir, "b.mp3"))
+	zipPath := filepath.Join(folder, "Zipped Book.zip")
+	zipFiles(t, zipPath, map[string]string{
+		"01 first.mp3":  filepath.Join(dir, "a.mp3"),
+		"02 second.mp3": filepath.Join(dir, "b.mp3"),
+	})
+
+	scanTestFolder(t, setup, admin, folder)
+
+	book, found := findAudioItemByPath(t, setup, libID, filepath.ToSlash("Zipped Book.zip"))
+	require.True(t, found, "zip book item must exist at the zip path")
+	layout, tracks, chapters, _ := decodeAudioPayload(t, book)
+	require.Equal(t, "zip", layout)
+	require.Equal(t, 2, tracks)
+	require.Equal(t, 2, chapters)
+
+	// Rescan idempotency.
+	scanTestFolder(t, setup, admin, folder)
+	require.Len(t, listLibraryAudioItems(t, setup, libID), 1)
+}
+
+func TestAudiobookTrackEndpoints(t *testing.T) {
+	setup := setupTestServer(t)
+	t.Cleanup(func() { _ = setup.Close() })
+
+	admin, _ := moveTestAdminID(t, setup)
+	regularID := getRegularUserID(t, setup.DB)
+	libID, folder := audioTestLibrary(t, setup, fmt.Sprintf("Test Audio Serve %d", time.Now().UnixNano()))
+	t.Cleanup(func() { deleteLibraries(t, setup, libID) })
+
+	writeTestTrack(t, filepath.Join(folder, "Serve Book", "01 one.mp3"))
+	writeTestTrack(t, filepath.Join(folder, "Serve Book", "02 two.mp3"))
+	scanTestFolder(t, setup, admin, folder)
+
+	book, found := findAudioItemByPath(t, setup, libID, filepath.ToSlash("Serve Book"))
+	require.True(t, found)
+	bookID := uuid.UUID(book.ID.Bytes)
+
+	client := &http.Client{}
+
+	t.Run("chapters manifest exposes tracks", func(t *testing.T) {
+		req, _ := http.NewRequest("GET", setup.Server.URL+"/api/media-items/"+bookID.String()+"/chapters", nil)
+		req.Header.Set("Authorization", "Bearer "+setup.Token)
+		resp, err := client.Do(req)
+		require.NoError(t, err)
+		defer func() { _ = resp.Body.Close() }()
+		require.Equal(t, http.StatusOK, resp.StatusCode)
+
+		var data struct {
+			Layout string `json:"layout"`
+			Tracks []struct {
+				Index int     `json:"index"`
+				URL   string  `json:"url"`
+				Path  string  `json:"path"`
+				Start float64 `json:"start"`
+			} `json:"tracks"`
+		}
+		require.NoError(t, json.NewDecoder(resp.Body).Decode(&data))
+		require.Equal(t, "folder", data.Layout)
+		require.Len(t, data.Tracks, 2)
+		require.Equal(t, "/api/media-items/"+bookID.String()+"/audio/0", data.Tracks[0].URL)
+	})
+
+	t.Run("track streams with range support", func(t *testing.T) {
+		req, _ := http.NewRequest("GET", setup.Server.URL+"/api/media-items/"+bookID.String()+"/audio/0", nil)
+		req.Header.Set("Authorization", "Bearer "+setup.Token)
+		req.Header.Set("Range", "bytes=0-99")
+		resp, err := client.Do(req)
+		require.NoError(t, err)
+		defer func() { _ = resp.Body.Close() }()
+		require.Equal(t, http.StatusPartialContent, resp.StatusCode)
+	})
+
+	t.Run("out-of-range track index is 404", func(t *testing.T) {
+		req, _ := http.NewRequest("GET", setup.Server.URL+"/api/media-items/"+bookID.String()+"/audio/9", nil)
+		req.Header.Set("Authorization", "Bearer "+setup.Token)
+		resp, err := client.Do(req)
+		require.NoError(t, err)
+		defer func() { _ = resp.Body.Close() }()
+		require.Equal(t, http.StatusNotFound, resp.StatusCode)
+	})
+
+	t.Run("hidden library is 403 on chapters and tracks", func(t *testing.T) {
+		_, err := setup.DB.SetLibraryVisibility(context.Background(), database.SetLibraryVisibilityParams{
+			UserID:    pgtype.UUID{Bytes: regularID, Valid: true},
+			LibraryID: libID,
+			IsVisible: false,
+		})
+		require.NoError(t, err)
+
+		for _, path := range []string{
+			"/api/media-items/" + bookID.String() + "/chapters",
+			"/api/media-items/" + bookID.String() + "/audio/0",
+		} {
+			req, _ := http.NewRequest("GET", setup.Server.URL+path, nil)
+			req.Header.Set("Authorization", "Bearer "+setup.RegularToken)
+			resp, err := client.Do(req)
+			require.NoError(t, err)
+			_ = resp.Body.Close()
+			require.Equal(t, http.StatusForbidden, resp.StatusCode, "%s must be gated", path)
+		}
+
+		// Restore visibility so harness cleanup ordering never sees a
+		// stale hidden row for a deleted library's user.
+		_, err = setup.DB.SetLibraryVisibility(context.Background(), database.SetLibraryVisibilityParams{
+			UserID:    pgtype.UUID{Bytes: regularID, Valid: true},
+			LibraryID: libID,
+			IsVisible: true,
+		})
+		require.NoError(t, err)
+	})
+}
+
+// zipFiles builds a zip archive at zipPath mapping entry names to source
+// file paths on disk.
+func zipFiles(t *testing.T, zipPath string, entries map[string]string) {
+	t.Helper()
+	out, err := os.Create(zipPath)
+	require.NoError(t, err)
+	defer func() { _ = out.Close() }()
+	w := zip.NewWriter(out)
+	for name, src := range entries {
+		data, err := os.ReadFile(src)
+		require.NoError(t, err)
+		f, err := w.Create(name)
+		require.NoError(t, err)
+		_, err = f.Write(data)
+		require.NoError(t, err)
+	}
+	require.NoError(t, w.Close())
+}
+
+// fixtureAudio copies a committed binary fixture (real tagged media —
+// the test container has no way to generate it) into a library folder.
+// Path is relative from cmd/server/tests (three deep) to the services
+// testdata tree.
+func fixtureAudio(t *testing.T, name, dest string) {
+	t.Helper()
+	src := filepath.Join("..", "..", "..", "internal", "services", "testdata", "audio", name)
+	data, err := os.ReadFile(src)
+	require.NoError(t, err, "fixture %s must exist in the repo", name)
+	require.NoError(t, os.MkdirAll(filepath.Dir(dest), 0o755))
+	require.NoError(t, os.WriteFile(dest, data, 0o644))
+}
+
+// getJSONWithAuth fetches an API endpoint with the admin token and
+// decodes the body into dst.
+func getJSONWithAuth(t *testing.T, setup *TestServerSetup, path string, dst interface{}) int {
+	t.Helper()
+	req, _ := http.NewRequest("GET", setup.Server.URL+path, nil)
+	req.Header.Set("Authorization", "Bearer "+setup.Token)
+	resp, err := http.DefaultClient.Do(req)
+	require.NoError(t, err)
+	defer func() { _ = resp.Body.Close() }()
+	if dst != nil {
+		require.NoError(t, json.NewDecoder(resp.Body).Decode(dst))
+	}
+	return resp.StatusCode
+}
+
+func TestAudiobookNewContainerFormats(t *testing.T) {
+	setup := setupTestServer(t)
+	t.Cleanup(func() { _ = setup.Close() })
+	admin, _ := moveTestAdminID(t, setup)
+	libID, folder := audioTestLibrary(t, setup, fmt.Sprintf("Test Audio Formats %d", time.Now().UnixNano()))
+	t.Cleanup(func() { deleteLibraries(t, setup, libID) })
+
+	for _, name := range []string{"book.opus", "book.ogg", "book.oga", "book.aac", "book.wav"} {
+		// one book per folder — a directory with ≥2 audio files is ONE
+		// book by the grouping doctrine
+		fixtureAudio(t, name, filepath.Join(folder, "Formats "+name, name))
+	}
+	scanTestFolder(t, setup, admin, folder)
+
+	items := listLibraryAudioItems(t, setup, libID)
+	require.Len(t, items, 5, "each new container ingests as its own single-file book")
+	mimes := map[string]string{}
+	for _, item := range items {
+		require.Equal(t, "audiobook", item.FormatGroup, "%s must classify as audiobook", item.FilePath)
+		mimes[filepath.Ext(item.FilePath)] = item.MimeType.String
+	}
+	require.Equal(t, map[string]string{
+		".opus": "audio/ogg", ".ogg": "audio/ogg", ".oga": "audio/ogg",
+		".aac": "audio/aac", ".wav": "audio/wav",
+	}, mimes)
+
+	// The download endpoint must serve the REAL content types — a wrong
+	// audio/mpeg fallback makes browsers refuse the stream.
+	for _, name := range []string{"book.opus", "book.aac", "book.wav"} {
+		item, found := findAudioItemByPath(t, setup, libID, filepath.ToSlash("Formats "+name+"/"+name))
+		require.True(t, found, name)
+		bookID := uuid.UUID(item.ID.Bytes)
+		req, _ := http.NewRequest("GET", setup.Server.URL+"/api/media-items/"+bookID.String()+"/download", nil)
+		req.Header.Set("Authorization", "Bearer "+setup.Token)
+		resp, err := http.DefaultClient.Do(req)
+		require.NoError(t, err)
+		// Drain but discard: a 0.3s sine is a few KB — nothing to save.
+		_, _ = io.Copy(io.Discard, resp.Body)
+		_ = resp.Body.Close()
+		require.Equal(t, http.StatusOK, resp.StatusCode)
+		require.Equal(t, item.MimeType.String, resp.Header.Get("Content-Type"), "%s content type", name)
+	}
+}
+
+func TestAudiobookTagFallbacks(t *testing.T) {
+	setup := setupTestServer(t)
+	t.Cleanup(func() { _ = setup.Close() })
+	admin, _ := moveTestAdminID(t, setup)
+	libID, folder := audioTestLibrary(t, setup, fmt.Sprintf("Test Audio Tags %d", time.Now().UnixNano()))
+	t.Cleanup(func() { deleteLibraries(t, setup, libID) })
+
+	// No sidecars anywhere: the file's own tags are the only source.
+	fixtureAudio(t, "tagged.mp3", filepath.Join(folder, "Tag Author", "The Tagged Album", "tagged.mp3"))
+	scanTestFolder(t, setup, admin, folder)
+
+	item, found := findAudioItemByPath(t, setup, libID, filepath.ToSlash("Tag Author/The Tagged Album/tagged.mp3"))
+	require.True(t, found)
+	require.Equal(t, "The Tagged Album", item.Title, "album tag names the book")
+	require.Equal(t, "Tag Author", item.Author.String, "album_artist tag names the author")
+	require.Len(t, item.Narrators, 1, "composer tag fills narrators (Audible convention)")
+	require.Equal(t, "Tag Narrator", item.Narrators[0])
+	require.Equal(t, "Tag Series", item.Series.String, "grouping tag fills series")
+	require.Equal(t, "Audiobook", item.Genre.String, "genre tag fills genre")
+	require.False(t, item.DatePublished.Time.IsZero(), "date tag fills publish date")
+	require.Equal(t, 2020, item.DatePublished.Time.Year())
+	// ASIN/abridged/subtitle arrive only through Audible freeform atoms,
+	// which ffmpeg cannot write into a fixture — those fallbacks are
+	// pinned by TestApplyAudioTagFallbacks (synthetic reports).
+}
+
+func TestAudiobookCueSheetChapters(t *testing.T) {
+	setup := setupTestServer(t)
+	t.Cleanup(func() { _ = setup.Close() })
+	admin, _ := moveTestAdminID(t, setup)
+	libID, folder := audioTestLibrary(t, setup, fmt.Sprintf("Test Audio Cue %d", time.Now().UnixNano()))
+	t.Cleanup(func() { deleteLibraries(t, setup, libID) })
+
+	fixtureAudio(t, "cuebook.flac", filepath.Join(folder, "Cue Book", "cuebook.flac"))
+	fixtureAudio(t, "cuebook.cue", filepath.Join(folder, "Cue Book", "cuebook.cue"))
+	scanTestFolder(t, setup, admin, folder)
+
+	item, found := findAudioItemByPath(t, setup, libID, filepath.ToSlash("Cue Book/cuebook.flac"))
+	require.True(t, found)
+	bookID := uuid.UUID(item.ID.Bytes)
+
+	var data struct {
+		Chapters []struct {
+			Index int     `json:"index"`
+			Title string  `json:"title"`
+			Start float64 `json:"start"`
+			End   float64 `json:"end"`
+		} `json:"chapters"`
+	}
+	status := getJSONWithAuth(t, setup, "/api/media-items/"+bookID.String()+"/chapters", &data)
+	require.Equal(t, http.StatusOK, status)
+	require.Len(t, data.Chapters, 3, "cue tracks become chapters")
+	require.Equal(t, "Opening", data.Chapters[0].Title)
+	require.Equal(t, "The Middle Bit", data.Chapters[1].Title)
+	require.InDelta(t, 20.0, data.Chapters[1].Start, 0.01)
+	require.Equal(t, "Closing", data.Chapters[2].Title)
+}
+
+func TestAudiobookEmbeddedM4BChapters(t *testing.T) {
+	setup := setupTestServer(t)
+	t.Cleanup(func() { _ = setup.Close() })
+	admin, _ := moveTestAdminID(t, setup)
+	libID, folder := audioTestLibrary(t, setup, fmt.Sprintf("Test Audio M4B %d", time.Now().UnixNano()))
+	t.Cleanup(func() { deleteLibraries(t, setup, libID) })
+
+	fixtureAudio(t, "chaptered.m4b", filepath.Join(folder, "Chaptered Book.m4b"))
+	scanTestFolder(t, setup, admin, folder)
+
+	item, found := findAudioItemByPath(t, setup, libID, filepath.ToSlash("Chaptered Book.m4b"))
+	require.True(t, found)
+	bookID := uuid.UUID(item.ID.Bytes)
+
+	var data struct {
+		Chapters []struct {
+			Title string `json:"title"`
+		} `json:"chapters"`
+		DurationSeconds float64 `json:"duration_seconds"`
+	}
+	status := getJSONWithAuth(t, setup, "/api/media-items/"+bookID.String()+"/chapters", &data)
+	require.Equal(t, http.StatusOK, status)
+	require.Len(t, data.Chapters, 2, "embedded m4b chapters parse")
+	require.Equal(t, "Part One", data.Chapters[0].Title)
+	require.Equal(t, "Part Two", data.Chapters[1].Title)
+	require.Greater(t, data.DurationSeconds, float64(0))
+}
+
+func TestAudiobookPlaylistOrdering(t *testing.T) {
+	setup := setupTestServer(t)
+	t.Cleanup(func() { _ = setup.Close() })
+	admin, _ := moveTestAdminID(t, setup)
+	libID, folder := audioTestLibrary(t, setup, fmt.Sprintf("Test Audio M3U %d", time.Now().UnixNano()))
+	t.Cleanup(func() { deleteLibraries(t, setup, libID) })
+
+	// Three tag-less tracks (natural order 01,02,10) plus a playlist
+	// imposing a DIFFERENT order and names.
+	fixtureAudio(t, "plain.mp3", filepath.Join(folder, "Playlist Book", "01_one.mp3"))
+	fixtureAudio(t, "plain.mp3", filepath.Join(folder, "Playlist Book", "02_two.mp3"))
+	fixtureAudio(t, "plain.mp3", filepath.Join(folder, "Playlist Book", "10_ten.mp3"))
+	playlist := "#EXTM3U\n#EXTINF:60,Epilogue\n./10_ten.mp3\n#EXTINF:60,Prologue\n01_one.mp3\n"
+	require.NoError(t, os.WriteFile(filepath.Join(folder, "Playlist Book", "book.m3u"), []byte(playlist), 0o644))
+	scanTestFolder(t, setup, admin, folder)
+
+	item, found := findAudioItemByPath(t, setup, libID, filepath.ToSlash("Playlist Book"))
+	require.True(t, found, "folder book created")
+	require.NotNil(t, item.AudioMetadata)
+	var payload struct {
+		Tracks []struct {
+			Index int    `json:"index"`
+			Path  string `json:"path"`
+			Title string `json:"title"`
+		} `json:"tracks"`
+	}
+	require.NoError(t, json.Unmarshal(item.AudioMetadata, &payload))
+	require.Len(t, payload.Tracks, 3)
+	require.Equal(t, "Playlist Book/10_ten.mp3", payload.Tracks[0].Path, "playlist order beats natural sort")
+	require.Equal(t, "Epilogue", payload.Tracks[0].Title)
+	require.Equal(t, "Playlist Book/01_one.mp3", payload.Tracks[1].Path)
+	require.Equal(t, "Prologue", payload.Tracks[1].Title)
+	require.Equal(t, "Playlist Book/02_two.mp3", payload.Tracks[2].Path, "unlisted track appended in natural order")
+}
+
+func TestAudiobookEmbeddedCoverArt(t *testing.T) {
+	setup := setupTestServer(t)
+	t.Cleanup(func() { _ = setup.Close() })
+	admin, _ := moveTestAdminID(t, setup)
+	libID, folder := audioTestLibrary(t, setup, fmt.Sprintf("Test Audio Cover %d", time.Now().UnixNano()))
+	t.Cleanup(func() { deleteLibraries(t, setup, libID) })
+
+	// Single file: embedded APIC → "<file>.cover.jpg" sibling.
+	fixtureAudio(t, "tagged.mp3", filepath.Join(folder, "Cover Book", "tagged.mp3"))
+	// Folder book: sidecar cover.jpg must WIN over the embedded art.
+	fixtureAudio(t, "tagged.mp3", filepath.Join(folder, "Sidecar Book", "01 track.mp3"))
+	fixtureAudio(t, "tagged.mp3", filepath.Join(folder, "Sidecar Book", "02 track.mp3"))
+	// A real (if tiny) sidecar cover next to the folder book:
+	fixtureAudio(t, "tagged.mp3", filepath.Join(folder, "Sidecar Book", "cover.jpg"))
+	scanTestFolder(t, setup, admin, folder)
+
+	single, found := findAudioItemByPath(t, setup, libID, filepath.ToSlash("Cover Book/tagged.mp3"))
+	require.True(t, found)
+	if !ffmpegAvailableForTest() {
+		t.Skip("ffmpeg unavailable in this environment; embedded covers degrade gracefully")
+	}
+	require.NotEmpty(t, single.CoverImagePath.String, "embedded APIC becomes the cover")
+	coverRel := single.CoverImagePath.String
+	_, err := os.Stat(filepath.Join(folder, coverRel))
+	require.NoError(t, err, "cover sibling file exists on disk")
+
+	folder_, found := findAudioItemByPath(t, setup, libID, filepath.ToSlash("Sidecar Book"))
+	require.True(t, found)
+	require.Equal(t, filepath.ToSlash("Sidecar Book/cover.jpg"), folder_.CoverImagePath.String,
+		"sidecar cover wins over embedded art")
+}
+
+func ffmpegAvailableForTest() bool {
+	_, err := os.Stat("/usr/bin/ffmpeg")
+	if err == nil {
+		return true
+	}
+	_, err = exec.LookPath("ffmpeg")
+	return err == nil
+}
+
+func TestRescanKeepsFilenameTitle(t *testing.T) {
+	// Regression pin: extractMetadata's default branch (.mobi/.azw/.pdb
+	// and unknown types) no longer pre-fills the filename as title, so
+	// the rescan path MUST apply the final filename fallback itself —
+	// a sidecar-less, tag-less book at a library root keeps its title
+	// instead of being blanked by a rescan.
+	setup := setupTestServer(t)
+	t.Cleanup(func() { _ = setup.Close() })
+	admin, _ := moveTestAdminID(t, setup)
+	libID, folder := createTypedTestLibrary(t, setup, fmt.Sprintf("Test Rescan Title %d", time.Now().UnixNano()), "ebooks")
+	t.Cleanup(func() { deleteLibraries(t, setup, libID) })
+
+	// Library-root .mobi with no sidecars, no tags, no folder structure.
+	require.NoError(t, os.WriteFile(filepath.Join(folder, "Plain Book.mobi"), []byte("dummy mobi bytes"), 0o644))
+	scanTestFolder(t, setup, admin, folder)
+
+	item, found := findAudioItemByPath(t, setup, libID, "Plain Book.mobi")
+	require.True(t, found)
+	require.Equal(t, "Plain Book", item.Title, "create path falls back to filename")
+
+	bookID := uuid.UUID(item.ID.Bytes)
+	req, _ := http.NewRequest("POST", setup.Server.URL+"/api/media-items/"+bookID.String()+"/rescan", nil)
+	req.Header.Set("Authorization", "Bearer "+setup.Token)
+	resp, err := http.DefaultClient.Do(req)
+	require.NoError(t, err)
+	_ = resp.Body.Close()
+	require.Equal(t, http.StatusOK, resp.StatusCode)
+
+	rescanned, err := setup.DB.GetMediaItem(context.Background(), item.ID)
+	require.NoError(t, err)
+	require.Equal(t, "Plain Book", rescanned.Title, "rescan must not blank the filename-derived title")
+}
diff --git a/database/schema/schema.sql b/database/schema/schema.sql
index 4cb8e799..423afd90 100644
--- a/database/schema/schema.sql
+++ b/database/schema/schema.sql
@@ -244,8 +244,12 @@ CREATE TABLE IF NOT EXISTS media_items (
     -- { "narrators": [], "duration_seconds": N, "codec_profile": "LC",
     --   "bit_rate": N, "asin": "...", "chapters": [
     --     { "index": 0, "title": "...", "start": 0.0, "end": 168.0 } ] }
-    -- The chapters array IS the format abstraction: embedded m4b chapters
-    -- and (later) folder-as-book files both write this exact shape.
+    -- The chapters array IS the format abstraction: embedded m4b chapters,
+    -- folder-of-tracks books and zip-of-audio books all write this exact
+    -- shape. Multi-file books add additive keys: "layout"
+    -- ("folder" | "zip"; absent = single file) and "tracks" (one entry
+    -- per playable file with global-seconds start/end plus the path the
+    -- /audio/:trackIndex endpoint resolves).
     audio_metadata JSONB
 );
 
diff --git a/docs/contract_pins.md b/docs/contract_pins.md
index 727d8a82..421e857a 100644
--- a/docs/contract_pins.md
+++ b/docs/contract_pins.md
@@ -102,3 +102,20 @@ cover_image_path, has_conflict, format_group, badge`.
   origin — its rows are unchanged. Request-parse widening documented per
   rule 2; response shapes untouched; locked by
   TestOriginWriterAttribution.
+
+## Changelog entry — multi-file audiobooks (2026-10-18)
+
+- `GET /api/media-items/:id/chapters` gained ADDITIVE response keys
+  `layout` ("" for single-file books, `"folder"` or `"zip"` for
+  multi-file books) and `tracks[]` (`index, url, title, path, start,
+  end, duration_seconds, size_bytes`; empty for single-file books).
+  Existing keys (`media_item_id, chapters, duration_seconds,
+  codec_profile`) unchanged — no pin existed on this endpoint, so no
+  pin widened; recorded here per rule 2's spirit.
+- New sibling endpoint `GET /api/media-items/:id/audio/:trackIndex`
+  streams one track of a multi-file book (Range-capable). New surface,
+  not a modification; gated by library visibility like `ServeFile`
+  (403 on hidden libraries).
+- `media_items.audio_metadata` payload gained additive JSON keys
+  `layout` and `tracks` (see schema.sql comment). Consumers parse
+  additively; stored single-file payloads are unchanged.
diff --git a/docs/developer/api/media-items/get_audio_chapters.md b/docs/developer/api/media-items/get_audio_chapters.md
new file mode 100644
index 00000000..a63e2d05
--- /dev/null
+++ b/docs/developer/api/media-items/get_audio_chapters.md
@@ -0,0 +1,53 @@
+# Get Audio Chapters
+
+The format-abstraction chapter list for audiobooks, sourced from
+`media_items.audio_metadata`. Embedded m4b chapters, folder-of-tracks
+books and zip-of-audio books all write the same chapter shape; the
+locator `{chapter, audio_offset_seconds}` and this endpoint never learn
+which file model produced them.
+
+**Endpoint**: `GET /api/media-items/{id}/chapters`
+**Auth**: Required (JWT)
+
+## Response
+
+```json
+{
+  "media_item_id": "…",
+  "chapters": [
+    { "index": 0, "title": "Chapter One", "start": 0.0, "end": 168.0 }
+  ],
+  "duration_seconds": 36000.0,
+  "codec_profile": "mp3",
+  "layout": "folder",
+  "tracks": [
+    {
+      "index": 0,
+      "url": "/api/media-items/{id}/audio/0",
+      "title": "01 First",
+      "path": "Author/Title/01 First.mp3",
+      "start": 0.0,
+      "end": 168.0,
+      "duration_seconds": 168.0,
+      "size_bytes": 2700000
+    }
+  ]
+}
+```
+
+- `layout` is `""` for single-file books (the Batch A model — the whole
+  file streams through the `/uploads` path), `"folder"` for a directory
+  of track files and `"zip"` for a zip-of-audio book.
+- `tracks` is empty for single-file books and carries one entry per
+  playable file otherwise. `start`/`end` are cumulative GLOBAL seconds —
+  the same coordinate system chapters, bookmarks and
+  `audio_offset_seconds` use.
+
+## Error Responses
+
+| Code | Description                     |
+| ---- | ------------------------------- |
+| 400  | Invalid media item id           |
+| 401  | Missing/invalid token           |
+| 404  | Book not found                  |
+| 500  | audio_metadata failed to parse  |
diff --git a/docs/developer/api/media-items/get_audio_track.md b/docs/developer/api/media-items/get_audio_track.md
new file mode 100644
index 00000000..11d72e7c
--- /dev/null
+++ b/docs/developer/api/media-items/get_audio_track.md
@@ -0,0 +1,44 @@
+# Get Audio Track
+
+Streams one playable track of a multi-file audiobook (folder-of-tracks
+or zip-of-audio book). Track indexes and bounds come from the track
+manifest on [Get Audio Chapters](get_audio_chapters.md).
+
+**Endpoint**: `GET /api/media-items/{id}/audio/{trackIndex}`
+**Auth**: Required (JWT — Bearer header or session cookie; the web
+player's `<audio>` element authenticates by cookie)
+
+## Serving
+
+- **Folder books**: the track is served straight from its real file
+  (`http.ServeContent`) — full `Range` support.
+- **Zip books**: the entry is extracted in place. Forward seeks discard
+  bytes in the open stream; backward seeks re-open the entry and skip
+  (deflate has no random access — cheap at audio bitrates). `Range`
+  requests are honored.
+
+Single-file books have no track manifest — they stream through the
+`/uploads` path exactly as before and this endpoint answers 404.
+
+## Library visibility
+
+The item's library must be visible to the requester; a hidden library
+answers **403** on every track (same gate as the download endpoint).
+
+## Error Responses
+
+| Code | Description                                  |
+| ---- | -------------------------------------------- |
+| 400  | Invalid media item id or track index         |
+| 401  | Missing/invalid token                        |
+| 403  | Library not visible to the requester         |
+| 404  | Book/track not found, or single-file book    |
+| 500  | audio_metadata failed to parse               |
+
+## Example
+
+```bash
+curl -H "Authorization: Bearer $TOKEN" \
+  -H "Range: bytes=0-1023" \
+  "http://localhost:8765/api/media-items/550e8400-.../audio/0"
+```
diff --git a/docs/developer/api/stats/get_library_usage.md b/docs/developer/api/stats/get_library_usage.md
index 7d838098..f7adb00b 100644
--- a/docs/developer/api/stats/get_library_usage.md
+++ b/docs/developer/api/stats/get_library_usage.md
@@ -90,8 +90,11 @@ Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...
 ### Absent data
 
 `Audio Tracks` (Audiobookshelf's per-file count) is deliberately absent:
-Bookhoard audiobooks are one file per book until multi-file support
-lands, so a file count would just equal `items`. See HANDOFF item 9.
+multi-file audiobooks (folder-of-tracks / zip books) now ingest as ONE
+item whose track list lives in `audio_metadata.tracks`, so a file count
+would still not equal a per-book "tracks" metric without a new query.
+Add it by aggregating `jsonb_array_length(audio_metadata->'tracks')` if
+the panel is ever wanted.
 
 ## Error Responses
 
diff --git a/docs/developer/scanner/audio-metadata.md b/docs/developer/scanner/audio-metadata.md
new file mode 100644
index 00000000..6cf8655f
--- /dev/null
+++ b/docs/developer/scanner/audio-metadata.md
@@ -0,0 +1,83 @@
+# Audiobook metadata: sources & precedence
+
+Every audiobook ingestion path (single-file, folder-of-tracks, zip-of-
+audio) fills the same fields from the same ranked sources. Each source
+**only fills fields the earlier ones left empty** — curated data always
+outranks guesses — and every source is optional: a book still ingests
+(title from the filename) when all of them are absent. Admin edits made
+after ingest are protected by the metadata-override mechanism on
+rescans, regardless of source quality.
+
+## Book-level metadata (title, author, narrators, series, …)
+
+| Rank | Source | Feeds |
+|---|---|---|
+| 1 | **Sidecars** — `metadata.opf` (Calibre), `metadata.json` (Audiobookshelf/Libation, array-or-string tolerant) | title (+subtitle join), author, series + index, narrators, abridged, ASIN, tags/genres, dates, publisher, description |
+| 2 | **Folder structure** — `Author/Title`, `Author/Series, Book #N - Title`, `Author/Series/Title` | title, author, series + index |
+| 3 | **Embedded tags** (via ffprobe) | `album` → title; `album_artist` → author (`artist` fallback); `composer` → **narrators** (Audible's own convention); `grouping` → series; `date` → publish date; `genre` → genre; Audible freeform atoms `----:com.apple.iTunes:SERIES`/`:SERIES-PART`/`:SUBTITLE`/`:ASIN`/`:ABRIDGED` |
+| 4 | **Filename/folder name** | title last of all (created only — never lets a rescan blank a title) |
+
+Abridged is the one guarded field: an explicit sidecar `false` wins even
+when a tag says `true` (the sidecar's presence is tracked, not just its
+value). Narrators from the composer tag stay ONE string — composer
+values have no reliable multi-narrator delimiter, and splitting
+"Vance, Simon" would manufacture fake people.
+
+## Chapters (the `{index, title, start, end}` array)
+
+| Rank | Source |
+|---|---|
+| 1 | Sidecar `metadata.json` `chapters[]` (curated, global seconds) |
+| 2 | Embedded m4b chapter atoms (`chpl` / QuickTime text track, read by ffprobe) |
+| 3 | **CUE sheet** — `.cue` next to the audio file (FILE-directive matched, `INDEX 01 MM:SS:FF` at 75 fps); the classic one-big-flac + cue rip shape |
+| 4 | Track boundaries — for folder/zip books, each file is a chapter |
+
+## Track ordering (multi-file books)
+
+| Rank | Source |
+|---|---|
+| 1 | **Playlist** — exactly one `.m3u`/`.m3u8` among the book root's direct children; its entry order wins and `#EXTINF` names the tracks |
+| 2 | **Tags** — `(disc, track)` sort when *every* track carries a track number (fixes flat `01.mp3` dumps from multi-disc rips) |
+| 3 | **Natural sort** of relative paths (`02` before `10`), recursive — the default |
+
+Track display titles, highest first: `movement_name` → `title` tag →
+playlist `#EXTINF` → cleaned filename (leading ordinals/separators
+stripped).
+
+## Book grouping (which files form one book)
+
+- The book root is the nearest ancestor holding audio files DIRECTLY,
+  merged upward through disc-part directories (`CD1`, `Disc 2`, `Part 3`,
+  `05`) when the parent has no audio of its own.
+- Sibling directories are NEVER merged (two books under one author stay
+  two books); a root with a single track falls back to the single-file
+  model.
+- A lone `.zip` of audio files is its own book (layout "zip"); a folder
+  of tracks is one book with `file_path` = the directory (layout
+  "folder"); a single audio file is the Batch A model (no layout key).
+- Rescans take a fast path (track count + total size + known durations
+  unchanged → no re-probe) and absorb pre-grouping one-track strays.
+
+## Covers
+
+| Rank | Source |
+|---|---|
+| 1 | Sidecar `cover.jpg` / `folder.jpg` / … next to the book |
+| 2 | **Embedded art** (`APIC` mp3, `covr` m4b, flac picture) — one optional ffmpeg call, written as a `<book>.cover.jpg` sibling following the EPUB convention |
+
+## Accepted containers (audiobook libraries)
+
+`.m4b` `.m4a` `.mp3` `.flac` `.zip` (book container) `.opus` `.ogg`
+`.oga` `.aac` `.wav` — all browser-playable; served with their real
+media types (`audio/ogg` per RFC 7845 for Opus-in-Ogg, etc.).
+
+## Documented non-goals
+
+- **ID3v2 CHAP/CTOC chapter frames** — the written MP3 standard for
+  embedded chapters, near-zero audiobook adoption; would need a
+  hand-rolled ID3v2.4 parser. Revisit only if real files show up.
+- **NFO sidecars** — no genuine audiobook NFO standard exists (Jellyfin's
+  Bookshelf uses Calibre OPF, which we read).
+- **ReplayGain / EBU R128 loudness tags** — a playback feature, not
+  ingestion; separate plan if ever wanted.
+- **`.wma`** — browsers cannot play it; excluded deliberately.
diff --git a/internal/database/querier.go b/internal/database/querier.go
index 6cdf8063..0720684e 100644
--- a/internal/database/querier.go
+++ b/internal/database/querier.go
@@ -574,6 +574,11 @@ type Querier interface {
 	UpdateMediaBookmarkForSync(ctx context.Context, arg UpdateMediaBookmarkForSyncParams) (MediaBookmarks, error)
 	UpdateMediaHighlightForSync(ctx context.Context, arg UpdateMediaHighlightForSyncParams) (MediaHighlights, error)
 	UpdateMediaItem(ctx context.Context, arg UpdateMediaItemParams) (MediaItems, error)
+	// Focused refresh for multi-file audiobooks (folder-of-tracks / zip
+	// books): rescans recompute the track manifest and the aggregate facts
+	// that follow from it. Editorial fields stay untouched — admins may have
+	// edited title/narrators after ingest.
+	UpdateMediaItemAudioBookPayload(ctx context.Context, arg UpdateMediaItemAudioBookPayloadParams) (MediaItems, error)
 	UpdateMediaItemChapterMetadata(ctx context.Context, arg UpdateMediaItemChapterMetadataParams) (MediaItems, error)
 	// Update media item format
 	UpdateMediaItemFormat(ctx context.Context, arg UpdateMediaItemFormatParams) (MediaItemFormats, error)
diff --git a/internal/database/queries.sql.go b/internal/database/queries.sql.go
index 6d62bc73..17ed040f 100644
--- a/internal/database/queries.sql.go
+++ b/internal/database/queries.sql.go
@@ -14297,6 +14297,111 @@ func (q *Queries) UpdateMediaItem(ctx context.Context, arg UpdateMediaItemParams
 	return i, err
 }
 
+const UpdateMediaItemAudioBookPayload = `-- name: UpdateMediaItemAudioBookPayload :one
+UPDATE media_items
+SET file_size = $2,
+    mime_type = $3,
+    audio_metadata = $4,
+    chapter_count = $5,
+    updated_at = NOW()
+WHERE id = $1
+RETURNING id, library_id, title, author, isbn, description, file_path, file_size, mime_type, cover_image_path, series, series_number, tags, narrators, abridged, asin, date_published, publisher, contributors, language, edition, page_count, genre, copyright_year, goodreads_id, openlibrary_id, google_books_id, added_by_admin_id, created_at, imported_at, updated_at, format_group, format_mimetype, is_reflowable, has_fixed_layout, total_characters, chapter_count, entitlement_id, revision_number, kobo_content_id, kobo_metadata, manga_type, reading_direction, series_count, volume, imprint, age_rating, web_url, story_arc, is_black_and_white, metadata_notes, community_rating, alternate_info, scan_information, summary, metadata_overrides, missing_scan_count, archived_at, chapter_metadata, library_type_name, audio_metadata, tags_search, contributors_search, narrators_search, file_sha256, opf_identifier, opf_uuid, hash_confidence
+`
+
+type UpdateMediaItemAudioBookPayloadParams struct {
+	ID            pgtype.UUID `db:"id" json:"id"`
+	FileSize      pgtype.Int8 `db:"file_size" json:"file_size"`
+	MimeType      pgtype.Text `db:"mime_type" json:"mime_type"`
+	AudioMetadata []byte      `db:"audio_metadata" json:"audio_metadata"`
+	ChapterCount  pgtype.Int4 `db:"chapter_count" json:"chapter_count"`
+}
+
+// Focused refresh for multi-file audiobooks (folder-of-tracks / zip
+// books): rescans recompute the track manifest and the aggregate facts
+// that follow from it. Editorial fields stay untouched — admins may have
+// edited title/narrators after ingest.
+func (q *Queries) UpdateMediaItemAudioBookPayload(ctx context.Context, arg UpdateMediaItemAudioBookPayloadParams) (MediaItems, error) {
+	row := q.db.QueryRow(ctx, UpdateMediaItemAudioBookPayload,
+		arg.ID,
+		arg.FileSize,
+		arg.MimeType,
+		arg.AudioMetadata,
+		arg.ChapterCount,
+	)
+	var i MediaItems
+	err := row.Scan(
+		&i.ID,
+		&i.LibraryID,
+		&i.Title,
+		&i.Author,
+		&i.Isbn,
+		&i.Description,
+		&i.FilePath,
+		&i.FileSize,
+		&i.MimeType,
+		&i.CoverImagePath,
+		&i.Series,
+		&i.SeriesNumber,
+		&i.Tags,
+		&i.Narrators,
+		&i.Abridged,
+		&i.Asin,
+		&i.DatePublished,
+		&i.Publisher,
+		&i.Contributors,
+		&i.Language,
+		&i.Edition,
+		&i.PageCount,
+		&i.Genre,
+		&i.CopyrightYear,
+		&i.GoodreadsID,
+		&i.OpenlibraryID,
+		&i.GoogleBooksID,
+		&i.AddedByAdminID,
+		&i.CreatedAt,
+		&i.ImportedAt,
+		&i.UpdatedAt,
+		&i.FormatGroup,
+		&i.FormatMimetype,
+		&i.IsReflowable,
+		&i.HasFixedLayout,
+		&i.TotalCharacters,
+		&i.ChapterCount,
+		&i.EntitlementID,
+		&i.RevisionNumber,
+		&i.KoboContentID,
+		&i.KoboMetadata,
+		&i.MangaType,
+		&i.ReadingDirection,
+		&i.SeriesCount,
+		&i.Volume,
+		&i.Imprint,
+		&i.AgeRating,
+		&i.WebUrl,
+		&i.StoryArc,
+		&i.IsBlackAndWhite,
+		&i.MetadataNotes,
+		&i.CommunityRating,
+		&i.AlternateInfo,
+		&i.ScanInformation,
+		&i.Summary,
+		&i.MetadataOverrides,
+		&i.MissingScanCount,
+		&i.ArchivedAt,
+		&i.ChapterMetadata,
+		&i.LibraryTypeName,
+		&i.AudioMetadata,
+		&i.TagsSearch,
+		&i.ContributorsSearch,
+		&i.NarratorsSearch,
+		&i.FileSha256,
+		&i.OpfIdentifier,
+		&i.OpfUuid,
+		&i.HashConfidence,
+	)
+	return i, err
+}
+
 const UpdateMediaItemChapterMetadata = `-- name: UpdateMediaItemChapterMetadata :one
 UPDATE media_items
 SET chapter_metadata = $2, updated_at = NOW()
diff --git a/internal/database/queries/queries.sql b/internal/database/queries/queries.sql
index 37c0d344..6c66801c 100644
--- a/internal/database/queries/queries.sql
+++ b/internal/database/queries/queries.sql
@@ -3229,3 +3229,17 @@ WHERE mi.archived_at IS NULL
   AND ($2::uuid[] IS NULL OR mi.library_id = ANY($2::uuid[]))
 ORDER BY mi.file_size DESC, mi.title ASC
 LIMIT 5;
+
+-- name: UpdateMediaItemAudioBookPayload :one
+-- Focused refresh for multi-file audiobooks (folder-of-tracks / zip
+-- books): rescans recompute the track manifest and the aggregate facts
+-- that follow from it. Editorial fields stay untouched — admins may have
+-- edited title/narrators after ingest.
+UPDATE media_items
+SET file_size = $2,
+    mime_type = $3,
+    audio_metadata = $4,
+    chapter_count = $5,
+    updated_at = NOW()
+WHERE id = $1
+RETURNING id, library_id, title, author, isbn, description, file_path, file_size, mime_type, cover_image_path, series, series_number, tags, narrators, abridged, asin, date_published, publisher, contributors, language, edition, page_count, genre, copyright_year, goodreads_id, openlibrary_id, google_books_id, added_by_admin_id, created_at, imported_at, updated_at, format_group, format_mimetype, is_reflowable, has_fixed_layout, total_characters, chapter_count, entitlement_id, revision_number, kobo_content_id, kobo_metadata, manga_type, reading_direction, series_count, volume, imprint, age_rating, web_url, story_arc, is_black_and_white, metadata_notes, community_rating, alternate_info, scan_information, summary, metadata_overrides, missing_scan_count, archived_at, chapter_metadata, library_type_name, audio_metadata, tags_search, contributors_search, narrators_search, file_sha256, opf_identifier, opf_uuid, hash_confidence;
diff --git a/internal/handlers/media.go b/internal/handlers/media.go
index 189fb7e2..2fc46495 100644
--- a/internal/handlers/media.go
+++ b/internal/handlers/media.go
@@ -1,6 +1,7 @@
 package handlers
 
 import (
+	"archive/zip"
 	"bookhoard/internal/database"
 	"bookhoard/internal/services"
 	wsync "bookhoard/internal/sync"
@@ -2550,9 +2551,16 @@ func (mh *MediaHandler) ServeFile(c *echo.Context) error {
 	}
 
 	// Check if file exists
-	if _, err := os.Stat(fullPath); os.IsNotExist(err) {
+	fullInfo, err := os.Stat(fullPath)
+	if err != nil {
 		return c.JSON(http.StatusNotFound, map[string]string{"error": "file not found"})
 	}
+	// Folder-of-tracks audiobooks store their book root DIRECTORY in
+	// file_path; there is no single file to serve and ServeFile must not
+	// fall through to directory listing behavior.
+	if fullInfo.IsDir() {
+		return c.JSON(http.StatusNotFound, map[string]string{"error": "multi-file books have no single download"})
+	}
 
 	ext := strings.ToLower(filepath.Ext(fullPath))
 	contentType := services.MimeTypes[ext]
@@ -2648,9 +2656,12 @@ func (mh *MediaHandler) saveCoverImage(c echo.Context, mediaUUID uuid.UUID, file
 
 // GetAudioChapters handles GET /api/media-items/:id/chapters — the
 // format-abstraction chapter list for audiobooks (media_items
-// .audio_metadata). Embedded m4b chapters and folder-as-book files write
-// the same shape. Empty list when the item isn't audio or hasn't been
-// probed.
+// .audio_metadata). Embedded m4b chapters, folder-of-tracks books and zip
+// books write the same shape. Multi-file books additionally carry
+// `layout` and a `tracks` manifest whose URLs point at the per-track
+// streaming endpoint; single-file books keep the empty layout their
+// existing consumers expect. Empty list when the item isn't audio or
+// hasn't been probed.
 func (mh *MediaHandler) GetAudioChapters(c *echo.Context) error {
 	mediaID := c.Param("id")
 	mediaUUID, err := uuid.Parse(mediaID)
@@ -2662,6 +2673,20 @@ func (mh *MediaHandler) GetAudioChapters(c *echo.Context) error {
 	if err != nil {
 		return c.JSON(http.StatusNotFound, map[string]string{"error": "book not found"})
 	}
+	if !item.LibraryID.Valid {
+		return c.JSON(http.StatusNotFound, map[string]string{"error": "book has no library"})
+	}
+
+	// Library visibility gate (family-lens rule): chapter lists are media
+	// metadata — a hidden library must not leak them any more than its
+	// file bytes.
+	visibleSet, _, err := mh.visibleLibrarySet(c)
+	if err != nil {
+		return c.JSON(http.StatusInternalServerError, map[string]string{"error": "failed to check library access"})
+	}
+	if !visibleSet[uuid.UUID(item.LibraryID.Bytes).String()] {
+		return c.JSON(http.StatusForbidden, map[string]string{"error": "library not accessible"})
+	}
 
 	var payload services.AudioMetadataPayload
 	if len(item.AudioMetadata) > 0 {
@@ -2670,10 +2695,212 @@ func (mh *MediaHandler) GetAudioChapters(c *echo.Context) error {
 		}
 	}
 
+	tracks := make([]map[string]interface{}, 0, len(payload.Tracks))
+	for _, tr := range payload.Tracks {
+		tracks = append(tracks, map[string]interface{}{
+			"index":            tr.Index,
+			"url":              fmt.Sprintf("/api/media-items/%s/audio/%d", mediaID, tr.Index),
+			"title":            tr.Title,
+			"path":             tr.Path,
+			"start":            tr.Start,
+			"end":              tr.End,
+			"duration_seconds": tr.DurationSeconds,
+			"size_bytes":       tr.SizeBytes,
+		})
+	}
+
 	return c.JSON(http.StatusOK, map[string]interface{}{
 		"media_item_id":    item.ID,
 		"chapters":         payload.Chapters,
 		"duration_seconds": payload.DurationSeconds,
 		"codec_profile":    payload.CodecProfile,
+		"layout":           payload.Layout,
+		"tracks":           tracks,
 	})
 }
+
+// GetAudioTrack handles GET /api/media-items/:id/audio/:trackIndex — the
+// per-track byte stream for multi-file audiobooks (folder books serve the
+// real file; zip books extract the entry in place). Library visibility is
+// the permission gate, same as ServeFile.
+func (mh *MediaHandler) GetAudioTrack(c *echo.Context) error {
+	mediaUUID, err := uuid.Parse(c.Param("id"))
+	if err != nil {
+		return c.JSON(http.StatusBadRequest, map[string]string{"error": "invalid media item id"})
+	}
+	trackIndex, err := strconv.Atoi(c.Param("trackIndex"))
+	if err != nil || trackIndex < 0 {
+		return c.JSON(http.StatusBadRequest, map[string]string{"error": "invalid track index"})
+	}
+
+	item, err := mh.db.GetMediaItem(c.Request().Context(), pgtype.UUID{Bytes: mediaUUID, Valid: true})
+	if err != nil {
+		return c.JSON(http.StatusNotFound, map[string]string{"error": "book not found"})
+	}
+	if !item.LibraryID.Valid {
+		return c.JSON(http.StatusNotFound, map[string]string{"error": "book has no library"})
+	}
+
+	// Library visibility gate (family-lens rule): a hidden library means
+	// its audiobooks' bytes are not reachable either.
+	visibleSet, _, err := mh.visibleLibrarySet(c)
+	if err != nil {
+		return c.JSON(http.StatusInternalServerError, map[string]string{"error": "failed to check library access"})
+	}
+	if !visibleSet[uuid.UUID(item.LibraryID.Bytes).String()] {
+		return c.JSON(http.StatusForbidden, map[string]string{"error": "library not accessible"})
+	}
+
+	var payload services.AudioMetadataPayload
+	if len(item.AudioMetadata) > 0 {
+		if err := json.Unmarshal(item.AudioMetadata, &payload); err != nil {
+			return c.JSON(http.StatusInternalServerError, map[string]string{"error": "failed to parse audio metadata"})
+		}
+	}
+	if trackIndex >= len(payload.Tracks) {
+		return c.JSON(http.StatusNotFound, map[string]string{"error": "track not found"})
+	}
+	track := payload.Tracks[trackIndex]
+
+	switch payload.Layout {
+	case "folder":
+		fullPath, err := mh.getFullFilePath(c.Request().Context(), item.LibraryID, track.Path)
+		if err != nil {
+			return c.JSON(http.StatusNotFound, map[string]string{"error": "track file not found"})
+		}
+		f, err := os.Open(fullPath)
+		if err != nil {
+			return c.JSON(http.StatusNotFound, map[string]string{"error": "track file not found"})
+		}
+		defer func() { _ = f.Close() }()
+		info, err := f.Stat()
+		if err != nil || info.IsDir() {
+			return c.JSON(http.StatusNotFound, map[string]string{"error": "track file not found"})
+		}
+		c.Response().Header().Set("Content-Type", audioTrackContentType(track.Path))
+		c.Response().Header().Set("Cache-Control", "private, max-age=86400")
+		// http.ServeContent wants a ReadSeeker for Range support; the os
+		// file provides both.
+		http.ServeContent(c.Response(), c.Request(), filepath.Base(fullPath), info.ModTime(), f)
+		return nil
+
+	case "zip":
+		zipPath, err := mh.getFullFilePath(c.Request().Context(), item.LibraryID, item.FilePath)
+		if err != nil {
+			return c.JSON(http.StatusNotFound, map[string]string{"error": "archive not found"})
+		}
+		seeker, err := newZipEntrySeeker(zipPath, track.Path)
+		if err != nil {
+			return c.JSON(http.StatusNotFound, map[string]string{"error": "track not found in archive"})
+		}
+		defer func() { _ = seeker.Close() }()
+		c.Response().Header().Set("Content-Type", audioTrackContentType(track.Path))
+		c.Response().Header().Set("Cache-Control", "private, max-age=86400")
+		// Zip entries re-open+skip for backward seeks (deflate has no
+		// random access), which audio bitrates make cheap enough.
+		http.ServeContent(c.Response(), c.Request(), filepath.Base(track.Path), time.Time{}, seeker)
+		return nil
+
+	default:
+		// Single-file books stream through the /uploads path; the track
+		// endpoint has nothing to slice.
+		return c.JSON(http.StatusNotFound, map[string]string{"error": "book has no track manifest"})
+	}
+}
+
+// audioTrackContentType maps a track path/entry name to its mime type.
+func audioTrackContentType(name string) string {
+	if m := services.MimeTypes[strings.ToLower(filepath.Ext(name))]; m != "" {
+		return m
+	}
+	return "audio/mpeg"
+}
+
+// zipEntrySeeker is an io.ReadSeeker over one zip entry. Forward seeks
+// discard bytes in the open stream; backward seeks re-open the entry and
+// skip — the only option over a deflate stream, and cheap at audio
+// bitrates. Owns the archive reader for the life of the request.
+type zipEntrySeeker struct {
+	zrc     *zip.ReadCloser
+	rc      io.ReadCloser
+	pos     int64
+	size    int64
+	entryFn func() (io.ReadCloser, error)
+}
+
+func newZipEntrySeeker(zipPath, entryName string) (*zipEntrySeeker, error) {
+	zrc, err := zip.OpenReader(zipPath)
+	if err != nil {
+		return nil, err
+	}
+	var entry *zip.File
+	for _, f := range zrc.File {
+		if filepath.ToSlash(f.Name) == filepath.ToSlash(entryName) {
+			entry = f
+			break
+		}
+	}
+	if entry == nil {
+		_ = zrc.Close()
+		return nil, fmt.Errorf("entry %q not found", entryName)
+	}
+	open := func() (io.ReadCloser, error) { return entry.Open() }
+	rc, err := open()
+	if err != nil {
+		_ = zrc.Close()
+		return nil, err
+	}
+	return &zipEntrySeeker{
+		zrc:     zrc,
+		rc:      rc,
+		size:    int64(entry.UncompressedSize64),
+		entryFn: open,
+	}, nil
+}
+
+func (z *zipEntrySeeker) Read(p []byte) (int, error) {
+	n, err := z.rc.Read(p)
+	z.pos += int64(n)
+	return n, err
+}
+
+func (z *zipEntrySeeker) Seek(offset int64, whence int) (int64, error) {
+	var target int64
+	switch whence {
+	case io.SeekStart:
+		target = offset
+	case io.SeekCurrent:
+		target = z.pos + offset
+	case io.SeekEnd:
+		target = z.size + offset
+	default:
+		return z.pos, fmt.Errorf("invalid whence %d", whence)
+	}
+	if target < 0 {
+		return z.pos, fmt.Errorf("negative seek target %d", target)
+	}
+	if target < z.pos {
+		// Deflate streams can't rewind: restart the entry and skip.
+		if err := z.rc.Close(); err != nil {
+			return z.pos, err
+		}
+		rc, err := z.entryFn()
+		if err != nil {
+			return z.pos, err
+		}
+		z.rc = rc
+		z.pos = 0
+	}
+	if remaining := target - z.pos; remaining > 0 {
+		if _, err := io.CopyN(io.Discard, z.rc, remaining); err != nil {
+			return z.pos, err
+		}
+		z.pos = target
+	}
+	return z.pos, nil
+}
+
+func (z *zipEntrySeeker) Close() error {
+	_ = z.rc.Close()
+	return z.zrc.Close()
+}
diff --git a/internal/handlers/opds.go b/internal/handlers/opds.go
index 23d9daa6..56a2000b 100644
--- a/internal/handlers/opds.go
+++ b/internal/handlers/opds.go
@@ -916,9 +916,16 @@ func (h *OPDSHandler) DownloadBook(c *echo.Context) error {
 	}
 
 	// Check if file exists
-	if _, err := os.Stat(filePath); os.IsNotExist(err) {
+	fileInfo, err := os.Stat(filePath)
+	if err != nil {
 		return c.JSON(http.StatusNotFound, map[string]string{"error": "file not found"})
 	}
+	// Folder-of-tracks audiobooks point at a book root DIRECTORY: there
+	// is no single file to stream for OPDS clients (a directory fd reads
+	// EISDIR). Zip books are real files and keep working.
+	if fileInfo.IsDir() {
+		return c.JSON(http.StatusNotFound, map[string]string{"error": "multi-file books have no single download"})
+	}
 
 	// Open file
 	file, err := os.Open(filePath)
@@ -927,11 +934,7 @@ func (h *OPDSHandler) DownloadBook(c *echo.Context) error {
 	}
 	defer file.Close()
 
-	// Get file info
-	fileInfo, err := file.Stat()
-	if err != nil {
-		return c.JSON(http.StatusInternalServerError, map[string]string{"error": "failed to get file info"})
-	}
+	// Get file info (fileInfo already statted above)
 
 	// Set headers
 	filename := filepath.Base(filePath)
diff --git a/internal/router/media.go b/internal/router/media.go
index cdf29716..7b24ae98 100644
--- a/internal/router/media.go
+++ b/internal/router/media.go
@@ -18,10 +18,11 @@ func registerMediaRoutes(cfg *Config) {
 	// Book download endpoint - same ServeFile flow as /uploads/library-:id/*
 	// (JWT + library-visibility gated), addressed by media item ID.
 	protected.GET("/media-items/:id/download", cfg.MediaHandler.ServeFile)
-	// The format-abstraction chapter list (audio_metadata). Streaming
-	// itself rides the existing /uploads Range-serving path with cookie
-	// auth — no separate endpoint.
+	// The format-abstraction chapter list (audio_metadata). Single-file
+	// books stream through the existing /uploads Range-serving path;
+	// multi-file books additionally expose per-track streaming.
 	protected.GET("/media-items/:id/chapters", cfg.MediaHandler.GetAudioChapters)
+	protected.GET("/media-items/:id/audio/:trackIndex", cfg.MediaHandler.GetAudioTrack)
 
 	// Media rating routes (all authenticated users)
 	protected.POST("/media-items/:id/rating", cfg.MediaHandler.CreateMediaRating)
diff --git a/internal/router/router.go b/internal/router/router.go
index fef890a9..9b2b0908 100644
--- a/internal/router/router.go
+++ b/internal/router/router.go
@@ -217,6 +217,11 @@ func RegisterRoutes(cfg *Config) *handlers.Handler {
 	mime.AddExtensionType(".m4a", "audio/mp4")
 	mime.AddExtensionType(".mp3", "audio/mpeg")
 	mime.AddExtensionType(".flac", "audio/flac")
+	mime.AddExtensionType(".opus", "audio/ogg")
+	mime.AddExtensionType(".ogg", "audio/ogg")
+	mime.AddExtensionType(".oga", "audio/ogg")
+	mime.AddExtensionType(".aac", "audio/aac")
+	mime.AddExtensionType(".wav", "audio/wav")
 	e := cfg.Echo
 
 	// Set up validator
diff --git a/internal/services/library_service.go b/internal/services/library_service.go
index 45daa21b..05fc6a60 100644
--- a/internal/services/library_service.go
+++ b/internal/services/library_service.go
@@ -38,7 +38,11 @@ var AllowedExtensions = map[string][]string{
 	// All four decided breadth formats registered from day one (the
 	// DOC/LIT doctrine: extensions are a deliberate list); only m4b
 	// scans richly in Batch A — the chapter abstraction carries the rest.
-	LibraryTypeAudiobooks: {".m4b", ".m4a", ".mp3", ".flac"},
+	// .zip joins as the zip-of-audio book container (multi-file ingest);
+	// comics libraries keep using .cbz so the two never collide. The
+	// browser-playable lossless/next-gen containers join for Batch B
+	// metadata parity (.wma deliberately absent: browsers can't play it).
+	LibraryTypeAudiobooks: {".m4b", ".m4a", ".mp3", ".flac", ".zip", ".opus", ".ogg", ".oga", ".aac", ".wav"},
 }
 
 var MimeTypes = map[string]string{
@@ -74,6 +78,15 @@ var MimeTypes = map[string]string{
 	".m4a":  "audio/mp4",
 	".mp3":  "audio/mpeg",
 	".flac": "audio/flac",
+	// Opus is registered as audio/ogg per RFC 7845 (Ogg encapsulation);
+	// every browser <audio> element accepts it that way.
+	".opus": "audio/ogg",
+	".ogg":  "audio/ogg",
+	".oga":  "audio/ogg",
+	".aac":  "audio/aac",
+	".wav":  "audio/wav",
+	// Zip-of-audio book container (audiobooks libraries only).
+	".zip": "application/zip",
 }
 
 // GetLibraryTypes retrieves all available library types
diff --git a/internal/services/media_scanner.go b/internal/services/media_scanner.go
index cd0bf8c9..f4cab34b 100644
--- a/internal/services/media_scanner.go
+++ b/internal/services/media_scanner.go
@@ -140,6 +140,12 @@ type MediaScanner struct {
 	newItems   int
 	errors     int
 	job        *Job
+
+	// audioBookRoots tracks the folder-book roots (absolute paths)
+	// already ingested during THIS scan walk, so per-track walk visits
+	// skip instead of reprocessing. Reset at the top of ScanFolders; the
+	// archive pass reuses it to keep book roots off the missing list.
+	audioBookRoots map[string]bool
 }
 
 // CalibreOPFMetadata represents intermediate parsed metadata from Calibre metadata.opf files
@@ -434,6 +440,7 @@ func (s *MediaScanner) ScanFolders(ctx context.Context) error {
 	s.totalFiles = 0
 	s.newItems = 0
 	s.errors = 0
+	s.audioBookRoots = make(map[string]bool)
 
 	for _, folder := range s.folders {
 		if ctx.Err() != nil {
@@ -499,6 +506,19 @@ func (s *MediaScanner) ScanFolders(ctx context.Context) error {
 					}
 				}
 
+				// Multi-file audiobooks first: zip-of-audio books and
+				// folder-of-tracks books ingest as whole units, and tracks
+				// inside an already-ingested root skip entirely. Everything
+				// else (lone audio files, all non-audio media) falls
+				// through to the single-file path below.
+				if handled, err := s.maybeProcessAudioBook(ctx, path); handled {
+					if err != nil {
+						fmt.Printf("Error processing audio book %s: %v\n", path, err)
+						s.errors++
+					}
+					return nil
+				}
+
 				wasNew, err := s.processMediaFile(ctx, path)
 				if err != nil {
 					fmt.Printf("Error processing media file %s: %v\n", path, err)
@@ -569,6 +589,14 @@ func (s *MediaScanner) ScanFolders(ctx context.Context) error {
 			continue // Skip to next folder to avoid false archivals
 		}
 
+		// Folder-book roots count as present: the item's file_path is the
+		// DIRECTORY, which the file walk above never emits.
+		for root := range s.audioBookRoots {
+			if strings.HasPrefix(root, folder) {
+				scannedPaths[s.getRelativePath(root)] = true
+			}
+		}
+
 		for _, item := range dbItems {
 			if item.FilePath == "" || scannedPaths[item.FilePath] {
 				continue // File present; unarchive is handled in processMediaFile
@@ -827,16 +855,6 @@ func (s *MediaScanner) processMediaFile(ctx context.Context, path string) (bool,
 		metadata = &MediaMetadata{}
 	}
 
-	// Audiobooks: sidecar narrators/chapters + ffprobe facts into the
-	// audio_metadata JSONB (sidecar-first, ffprobe-fills; the payload's
-	// shape is the chapter abstraction every format writes).
-	if isAudioFile(path) {
-		if metadata.AudioMeta == nil {
-			metadata.AudioMeta = readSidecarAudio(path)
-		}
-		s.enrichAudioMetadata(path, metadata)
-	}
-
 	// Extract hash information during metadata extraction
 	hashInfo, formatInfo, err := s.extractHashInfo(path)
 	if err != nil {
@@ -953,6 +971,21 @@ func (s *MediaScanner) processMediaFile(ctx context.Context, path string) (bool,
 		}
 	}
 
+	// Audiobooks: sidecar narrators/chapters + ffprobe facts (incl. the
+	// full tag fallbacks) into the audio_metadata JSONB. Runs AFTER the
+	// folder-structure pass so the precedence chain holds: sidecars →
+	// folder structure → tags → filename. The payload's shape is the
+	// chapter abstraction every format writes.
+	if isAudioFile(path) {
+		if metadata.AudioMeta == nil {
+			metadata.AudioMeta = readSidecarAudio(path)
+		}
+		s.enrichAudioMetadata(path, metadata)
+		if metadata.CoverPath == "" {
+			s.applyEmbeddedCoverFallback(path, metadata)
+		}
+	}
+
 	// Final fallback if still missing essential metadata
 	if metadata.Title == "" {
 		metadata.Title = strings.TrimSuffix(filepath.Base(path), filepath.Ext(path))
@@ -988,6 +1021,7 @@ func (s *MediaScanner) processMediaFile(ctx context.Context, path string) (bool,
 		SeriesNumber:       pgtype.Int4{Int32: metadata.SeriesNumber, Valid: metadata.SeriesNumber > 0},
 		Publisher:          pgtype.Text{String: metadata.Publisher, Valid: metadata.Publisher != ""},
 		DatePublished:      pgtype.Date{Time: metadata.PublishDate, Valid: !metadata.PublishDate.IsZero()},
+		Genre:              pgtype.Text{String: metadata.Genre, Valid: metadata.Genre != ""},
 		Contributors:       metadata.Contributors,
 		ContributorsSearch: contributorsSearch,
 		Narrators:          nilToEmpty(metadata.Narrators),
@@ -1118,6 +1152,16 @@ func (s *MediaScanner) applyEmbeddedCoverFallback(path string, metadata *MediaMe
 		if coverPath, err := s.extractEPUBCover(path); err == nil && coverPath != "" {
 			metadata.CoverPath = s.getRelativePath(coverPath)
 		}
+	default:
+		// Audio containers (mp3 APIC, m4b/flac embedded picture): one
+		// ffmpeg call, written as a "<file>.cover.jpg" sibling — the
+		// same convention the EPUB path uses. Purely optional: absent
+		// ffmpeg or no embedded art simply leaves the cover empty.
+		if isAudioFile(path) && !strings.EqualFold(filepath.Ext(path), ".zip") {
+			if cover := extractEmbeddedAudioCover(path, path); cover != "" {
+				metadata.CoverPath = s.getRelativePath(cover)
+			}
+		}
 	}
 }
 
@@ -1712,10 +1756,10 @@ func (s *MediaScanner) extractMetadata(path string) (*MediaMetadata, error) {
 		}
 		return metadata, nil
 	default:
-		// For other formats, return basic metadata
-		return &MediaMetadata{
-			Title: strings.TrimSuffix(filepath.Base(path), ext),
-		}, nil
+		// Audio containers and other unknown types: NO filename title
+		// here — processMediaFile's final fallback applies the filename
+		// LAST, after the audio tag-fallback chain has had its turn.
+		return &MediaMetadata{}, nil
 	}
 }
 
@@ -3193,20 +3237,29 @@ func countArchiveImages(filePath string) (int, error) {
 // from the existing row so rescans never clobber user customizations; only
 // reset-to-scanned-defaults (RescanMediaItem with reset) clears them.
 func (s *MediaScanner) updateMediaItem(ctx context.Context, existing database.MediaItems, path string) error {
-	// Re-extract metadata for the update
-	metadata, err := s.extractMetadata(path)
-	if err != nil {
-		fmt.Printf("Warning: failed to extract metadata for force rescan %s: %v\n", path, err)
-		metadata = &MediaMetadata{}
-	}
+	return s.updateMediaItemWithMetadata(ctx, existing, path, nil)
+}
 
-	// Rescans must RE-DERIVE audio facts, never preserve stale ones
-	// (gotcha 39's principle applied to audio_metadata).
-	if isAudioFile(path) {
-		if metadata.AudioMeta == nil {
-			metadata.AudioMeta = readSidecarAudio(path)
+// updateMediaItemWithMetadata is updateMediaItem with an optional
+// pre-extracted metadata set. Multi-file audiobooks arrive through
+// RescanMediaItem with book-level metadata (sidecars, folder structure,
+// first-track tags) because the generic per-file extraction would read
+// the book ROOT/CONTAINER as if it were the book file.
+func (s *MediaScanner) updateMediaItemWithMetadata(ctx context.Context, existing database.MediaItems, path string, preExtracted *MediaMetadata) error {
+	var metadata *MediaMetadata
+	if preExtracted != nil {
+		metadata = preExtracted
+	} else {
+		// Re-extract metadata for the update
+		extracted, err := s.extractMetadata(path)
+		if err != nil {
+			fmt.Printf("Warning: failed to extract metadata for force rescan %s: %v\n", path, err)
+			metadata = &MediaMetadata{}
+		} else if extracted == nil {
+			metadata = &MediaMetadata{}
+		} else {
+			metadata = extracted
 		}
-		s.enrichAudioMetadata(path, metadata)
 	}
 
 	// Folder-structure fallback, mirroring the CREATE path
@@ -3233,6 +3286,35 @@ func (s *MediaScanner) updateMediaItem(ctx context.Context, existing database.Me
 		}
 	}
 
+	// Audiobooks (single-file): re-derive the audio facts + tag fallbacks
+	// AFTER the folder-structure pass — the precedence chain (sidecars →
+	// folder structure → tags → filename) must hold on rescans too.
+	// Multi-file books arrive with preExtracted metadata already carrying
+	// their enriched payload.
+	// Rescans must RE-DERIVE audio facts, never preserve stale ones
+	// (gotcha 39's principle applied to audio_metadata).
+	if preExtracted == nil && isAudioFile(path) {
+		if metadata.AudioMeta == nil {
+			metadata.AudioMeta = readSidecarAudio(path)
+		}
+		s.enrichAudioMetadata(path, metadata)
+		if metadata.CoverPath == "" {
+			s.applyEmbeddedCoverFallback(path, metadata)
+		}
+	}
+
+	// Final filename fallback, mirroring processMediaFile's create path:
+	// extractMetadata's default branch no longer pre-fills the filename
+	// as title (embedded tags must outrank it), so the update path needs
+	// the same last rung — a sidecar-less, tag-less book at a library
+	// root (no folder structure to match) keeps its filename-derived
+	// title instead of being blanked. Guarded to single-file updates:
+	// multi-file representatives are sentinels/containers whose names
+	// must never leak as titles.
+	if preExtracted == nil && metadata.Title == "" {
+		metadata.Title = strings.TrimSuffix(filepath.Base(path), filepath.Ext(path))
+	}
+
 	// Normalize metadata fields
 	metadata.Contributors = utils.NormalizeContributors(metadata.Contributors)
 	metadata.Tags = utils.NormalizeTags(metadata.Tags)
@@ -3289,21 +3371,26 @@ func (s *MediaScanner) updateMediaItem(ctx context.Context, existing database.Me
 	utils.ApplyMetadataOverrides(&params, existing)
 	params.MetadataOverrides = utils.MergeOverrides(existing.MetadataOverrides)
 
-	if _, err = s.db.UpdateMediaItem(ctx, params); err != nil {
+	if _, err := s.db.UpdateMediaItem(ctx, params); err != nil {
 		return err
 	}
 
 	// Format flags are file-derived facts, not user metadata: refresh them on
 	// every update so a force rescan (the admin's backfill tool) can
 	// reclassify rows created before a classifyFormatGroup arm existed.
-	// Mirrors the creation path above.
-	ext := strings.ToLower(filepath.Ext(path))
-	var epubIsFixedLayout bool
-	if ext == ".epub" {
-		isFixed, fixedErr := s.DetectFixedLayoutEPUB(path)
-		epubIsFixedLayout = fixedErr == nil && isFixed
+	// Mirrors the creation path above. Multi-file audiobooks keep the
+	// "audiobook" group: their representative path is a directory or a zip
+	// container, which no classify arm could name.
+	formatGroup, isReflowable, hasFixedLayout := "audiobook", false, false
+	if preExtracted == nil || preExtracted.AudioMeta == nil || preExtracted.AudioMeta.Layout == "" {
+		ext := strings.ToLower(filepath.Ext(path))
+		var epubIsFixedLayout bool
+		if ext == ".epub" {
+			isFixed, fixedErr := s.DetectFixedLayoutEPUB(path)
+			epubIsFixedLayout = fixedErr == nil && isFixed
+		}
+		formatGroup, isReflowable, hasFixedLayout = classifyFormatGroup(ext, epubIsFixedLayout)
 	}
-	formatGroup, isReflowable, hasFixedLayout := classifyFormatGroup(ext, epubIsFixedLayout)
 	mimeType := s.getMimeType(path)
 	if err := s.db.UpdateMediaItemFormatGroup(ctx, database.UpdateMediaItemFormatGroupParams{
 		ID:              existing.ID,
@@ -3367,6 +3454,16 @@ func (s *MediaScanner) RescanMediaItem(ctx context.Context, mediaItemID pgtype.U
 		return fmt.Errorf("failed to stat media file: %w", err)
 	}
 
+	// Multi-file audiobooks (folder/zip layout) must NOT go through the
+	// generic per-file updater: it would read the book ROOT directory (or
+	// the zip container) as if it were the book file — deriving a filename
+	// title and classifying format_group "unknown", which drops the item
+	// out of the audio reader. The book-level path rebuilds the track
+	// manifest and re-derives metadata from sidecars/tags instead.
+	if item.FormatGroup == "audiobook" && audioLayoutOf(item.AudioMetadata) != "" {
+		return s.rescanMultiFileAudioBook(ctx, item, fullPath)
+	}
+
 	if err := s.updateMediaItem(ctx, item, fullPath); err != nil {
 		return fmt.Errorf("failed to update media item: %w", err)
 	}
@@ -4012,6 +4109,8 @@ func (s *MediaScanner) detectFormatType(filePath string) string {
 		return "pdf"
 	case ".cbz", ".cbr", ".cb7", ".cbt":
 		return "comic_archive"
+	case ".m4b", ".m4a", ".mp3", ".flac", ".opus", ".ogg", ".oga", ".aac", ".wav":
+		return "audiobook"
 	case ".mobi":
 		return "mobi"
 	case ".azw", ".azw3":
@@ -4042,7 +4141,7 @@ func classifyFormatGroup(ext string, epubIsFixedLayout bool) (formatGroup string
 		return "fixed_layout", false, true
 	case ".cbz", ".cbr", ".cb7", ".cbt":
 		return "comic_archive", false, true
-	case ".m4b", ".m4a", ".mp3", ".flac":
+	case ".m4b", ".m4a", ".mp3", ".flac", ".opus", ".ogg", ".oga", ".aac", ".wav":
 		// Audio is neither reflowable text nor fixed-layout pages; the
 		// "audiobook" group routes readers to the audio player instead
 		// of any document engine.
diff --git a/internal/services/media_scanner_audio.go b/internal/services/media_scanner_audio.go
index 012000e3..bf89ab55 100644
--- a/internal/services/media_scanner_audio.go
+++ b/internal/services/media_scanner_audio.go
@@ -9,10 +9,17 @@ package services
 // until a rescan runs with ffprobe present).
 //
 // The chapters array written into media_items.audio_metadata IS the
-// format abstraction: embedded m4b chapters and (later) folder-as-book
-// files both produce {index, title, start, end} entries, so the locator
-// {chapter, offset_seconds} and the /chapters endpoint never learn which
-// file model produced them.
+// format abstraction: embedded m4b chapters, folder-as-book files and
+// zip-of-audio books all produce {index, title, start, end} entries, so
+// the locator {chapter, offset_seconds} and the /chapters endpoint never
+// learn which file model produced them.
+//
+// Multi-file books (layout "folder" | "zip", see
+// media_scanner_audio_multifile.go) additionally carry a tracks array:
+// one entry per playable file, with its global-seconds start/end and the
+// path the /audio/:trackIndex streaming endpoint resolves. Single-file
+// books leave layout and tracks empty — the <audio> element streams the
+// whole file exactly as before.
 
 import (
 	"encoding/json"
@@ -33,6 +40,21 @@ type AudioChapter struct {
 	End   float64 `json:"end"`
 }
 
+// AudioTrack is one playable file of a multi-file audiobook. Path is the
+// library-relative file path (layout "folder") or the in-zip entry name
+// (layout "zip"); the /audio/:trackIndex endpoint resolves it to bytes.
+// Start/End are cumulative global seconds across the book — the same
+// coordinate system chapters, bookmarks and audio_offset_seconds use.
+type AudioTrack struct {
+	Index           int     `json:"index"`
+	Path            string  `json:"path"`
+	Title           string  `json:"title,omitempty"`
+	Start           float64 `json:"start"`
+	End             float64 `json:"end"`
+	DurationSeconds float64 `json:"duration_seconds,omitempty"`
+	SizeBytes       int64   `json:"size_bytes,omitempty"`
+}
+
 // AudioMetadataPayload is the JSONB stored in media_items.audio_metadata.
 // Only the audio paths read it — ebook paths never do (the kobo_metadata
 // precedent).
@@ -44,16 +66,33 @@ type AudioMetadataPayload struct {
 	ASIN            string         `json:"asin,omitempty"`
 	Abridged        *bool          `json:"abridged,omitempty"`
 	Chapters        []AudioChapter `json:"chapters,omitempty"`
+	// Layout: "" = single file (the Batch A model), "folder" = a
+	// directory of track files, "zip" = a zip archive of tracks.
+	Layout string `json:"layout,omitempty"`
+	// Tracks: one entry per playable file for multi-file layouts. Empty
+	// for single-file books (the whole file IS the track).
+	Tracks []AudioTrack `json:"tracks,omitempty"`
 }
 
 func isAudioFile(path string) bool {
 	switch strings.ToLower(filepath.Ext(path)) {
-	case ".m4b", ".m4a", ".mp3", ".flac":
+	case ".m4b", ".m4a", ".mp3", ".flac", ".zip", ".opus", ".ogg", ".oga", ".aac", ".wav":
 		return true
 	}
 	return false
 }
 
+// isAudioTrackFile reports whether a path is a PLAYABLE track of a
+// multi-file book. Zips are book CONTAINERS (layout "zip"), never tracks
+// of a folder book — a nested zip inside a book root must not join the
+// track list, and pre-grouping one-track strays were never zips.
+func isAudioTrackFile(path string) bool {
+	if strings.EqualFold(filepath.Ext(path), ".zip") {
+		return false
+	}
+	return isAudioFile(path)
+}
+
 // ffprobeAvailable is resolved once per scan process; a missing binary is
 // a degradation, not an error.
 var ffprobeAvailable = func() bool {
@@ -61,10 +100,55 @@ var ffprobeAvailable = func() bool {
 	return err == nil
 }()
 
+// ffmpegAvailable mirrors ffprobeAvailable for the embedded-cover
+// extractor (ffprobe cannot write image streams; ffmpeg can).
+var ffmpegAvailable = func() bool {
+	_, err := exec.LookPath("ffmpeg")
+	return err == nil
+}()
+
+// extractEmbeddedAudioCover pulls the embedded cover art (mp3 APIC /
+// m4b covr / flac picture) out of an audio file with one ffmpeg call —
+// the attached picture presents itself as the file's only video stream.
+// Writes outputBase+".cover.jpg" following the EPUB sidecar convention
+// ("<book>.cover.jpg"). Returns "" when ffmpeg is absent, the file
+// carries no picture, or anything fails — purely optional enrichment.
+func extractEmbeddedAudioCover(inputPath, outputBase string) string {
+	if !ffmpegAvailable {
+		return ""
+	}
+	outPath := outputBase + ".cover.jpg"
+	cmd := exec.Command("ffmpeg",
+		"-y", "-v", "error",
+		"-i", inputPath,
+		"-map", "0:v:0",
+		"-frames:v", "1",
+		outPath,
+	)
+	if out, err := cmd.CombinedOutput(); err != nil {
+		// "matches no streams" is the no-embedded-art case; stay quiet
+		// about it, log anything unexpected.
+		if len(out) > 0 && !strings.Contains(string(out), "matches no streams") {
+			fmt.Printf("ffmpeg cover extraction note for %s: %s\n", inputPath, strings.TrimSpace(string(out)))
+		}
+		return ""
+	}
+	if info, err := os.Stat(outPath); err != nil || info.Size() == 0 {
+		_ = os.Remove(outPath)
+		return ""
+	}
+	return outPath
+}
+
 type ffprobeReport struct {
 	Format struct {
 		Duration flexFloat `json:"duration"`
 		BitRate  flexFloat `json:"bit_rate"`
+		// Tags: ffprobe normalizes well-known atoms to lowercase keys but
+		// passes freeform keys (Audible's `----:com.apple.iTunes:*`)
+		// through verbatim — a map with case-insensitive lookup is the
+		// only honest shape. See tag().
+		Tags map[string]string `json:"tags"`
 	} `json:"format"`
 	Streams []struct {
 		CodecName  string `json:"codec_name"`
@@ -134,6 +218,24 @@ func runFFProbe(path string) *ffprobeReport {
 	return &report
 }
 
+// tag returns the first non-empty ffprobe tag among the candidate keys,
+// matched case-insensitively and trimmed. Empty string when none match.
+func (r *ffprobeReport) tag(keys ...string) string {
+	if r == nil {
+		return ""
+	}
+	for _, key := range keys {
+		for k, v := range r.Format.Tags {
+			if strings.EqualFold(k, key) {
+				if trimmed := strings.TrimSpace(v); trimmed != "" {
+					return trimmed
+				}
+			}
+		}
+	}
+	return ""
+}
+
 // enrichAudioMetadata merges ffprobe facts into the (possibly sidecar-
 // seeded) audio payload, creating it when no sidecar existed. Sidecar
 // narrators/chapters win (curated); ffprobe fills duration, codec,
@@ -192,6 +294,24 @@ func (s *MediaScanner) enrichAudioMetadata(path string, metadata *MediaMetadata)
 	if payload.Abridged != nil {
 		metadata.Abridged = *payload.Abridged
 	}
+
+	// Tag fallbacks run LAST in the single-file chain (sidecars → folder
+	// structure handled by the caller → tags → filename): they only fill
+	// fields the earlier sources left empty.
+	applyAudioTagFallbacks(metadata, report)
+
+	// CUE sheets are the last chapter source: sidecar chapters and
+	// embedded container chapters (m4b) outrank them.
+	if len(payload.Chapters) == 0 {
+		if cueChapters := readCueChapters(path); len(cueChapters) > 0 {
+			payload.Chapters = cueChapters
+			if payload.DurationSeconds == 0 {
+				if last := cueChapters[len(cueChapters)-1]; last.End > 0 {
+					payload.DurationSeconds = last.End
+				}
+			}
+		}
+	}
 }
 
 // parseSidecarAudioFields extracts the audio-only fields from a
@@ -261,6 +381,103 @@ func marshalAudioMetadata(payload *AudioMetadataPayload) []byte {
 	return out
 }
 
+// applyAudioTagFallbacks fills EMPTY media metadata from the file's own
+// tags — the last rung of the ingestion precedence chain (curated
+// sidecars → folder structure → embedded tags → filename). Field map:
+//
+//	album / album_artist / artist        → title / author
+//	composer                             → narrators (Audible's own
+//	  convention: the narrator lives in the composer tag)
+//	grouping                             → series
+//	----:com.apple.iTunes:SERIES[-PART]  → series + index (Libation
+//	  preserves these Audible freeform atoms)
+//	----:com.apple.iTunes:SUBTITLE       → joined into the title
+//	  ("Title: Subtitle"), mirroring the ABS sidecar path
+//	----:com.apple.iTunes:ASIN / ABRIDGED → asin / abridged flag
+//	date → publish date; genre → genre
+//
+// Abridged is the one field where an explicit sidecar false must not be
+// overridden by a tag — the payload pointer marks sidecar presence.
+func applyAudioTagFallbacks(metadata *MediaMetadata, report *ffprobeReport) {
+	if metadata == nil || report == nil {
+		return
+	}
+
+	if metadata.Title == "" {
+		if album := report.tag("album"); album != "" {
+			metadata.Title = album
+		}
+	}
+	// Subtitle joins the title Calibre-style, mirroring the ABS sidecar
+	// path — there is no separate subtitle column. Skip when the title
+	// already contains it (tools sometimes pre-join).
+	if subtitle := report.tag("----:com.apple.itunes:subtitle", "subtitle"); subtitle != "" && metadata.Title != "" &&
+		!strings.Contains(strings.ToLower(metadata.Title), strings.ToLower(subtitle)) {
+		metadata.Title = metadata.Title + ": " + subtitle
+	}
+	if metadata.Author == "" {
+		if artist := report.tag("album_artist"); artist != "" {
+			metadata.Author = artist
+		} else if artist := report.tag("artist"); artist != "" {
+			metadata.Author = artist
+		}
+	}
+	if len(metadata.Narrators) == 0 {
+		// Kept as ONE narrator string: composer values have no reliable
+		// multi-narrator delimiter, and splitting "Vance, Simon" would
+		// manufacture two fake people. Admins can edit the column.
+		if composer := report.tag("composer"); composer != "" {
+			metadata.Narrators = []string{composer}
+			if metadata.AudioMeta != nil && len(metadata.AudioMeta.Narrators) == 0 {
+				metadata.AudioMeta.Narrators = []string{composer}
+			}
+		}
+	}
+	if metadata.Series == "" {
+		if series := report.tag("grouping", "----:com.apple.itunes:series"); series != "" {
+			metadata.Series = series
+			if part := report.tag("----:com.apple.itunes:series-part"); part != "" {
+				if idx, err := strconv.ParseFloat(strings.TrimSpace(part), 32); err == nil {
+					metadata.SeriesNumber = int32(idx)
+				}
+			}
+		}
+	}
+	if metadata.ASIN == "" {
+		if asin := report.tag("----:com.apple.itunes:asin", "asin"); asin != "" {
+			metadata.ASIN = asin
+			if metadata.AudioMeta != nil && metadata.AudioMeta.ASIN == "" {
+				metadata.AudioMeta.ASIN = asin
+			}
+		}
+	}
+	if metadata.AudioMeta == nil || metadata.AudioMeta.Abridged == nil {
+		if !metadata.Abridged {
+			switch strings.ToLower(report.tag("----:com.apple.itunes:abridged")) {
+			case "1", "true", "yes":
+				metadata.Abridged = true
+				if metadata.AudioMeta != nil {
+					abridged := true
+					metadata.AudioMeta.Abridged = &abridged
+				}
+			}
+		}
+	}
+	if metadata.PublishDate.IsZero() {
+		if date := report.tag("date"); date != "" {
+			for _, layout := range []string{"2006-01-02", "2006-01", "2006"} {
+				if t, err := time.Parse(layout, strings.TrimSpace(date)); err == nil {
+					metadata.PublishDate = t
+					break
+				}
+			}
+		}
+	}
+	if metadata.Genre == "" {
+		metadata.Genre = report.tag("genre")
+	}
+}
+
 // audioDurationLabel renders the duration for logs/detail surfaces.
 func audioDurationLabel(seconds float64) string {
 	if seconds <= 0 {
diff --git a/internal/services/media_scanner_audio_cue.go b/internal/services/media_scanner_audio_cue.go
new file mode 100644
index 00000000..4517875a
--- /dev/null
+++ b/internal/services/media_scanner_audio_cue.go
@@ -0,0 +1,173 @@
+package services
+
+// CUE sheet support: a `.cue` sidecar describing the chapter marks of a
+// single big audio file (the classic CD-rip shape: one flac/mp3 + one
+// cue). CUE is the LOWEST-priority chapter source — curated sidecar
+// chapters and embedded m4b chapters outrank it — and a purely optional
+// one: no cue, no chapters, no error.
+
+import (
+	"bufio"
+	"os"
+	"path/filepath"
+	"strconv"
+	"strings"
+)
+
+// cueFramesPerSecond is the CD framing CUE INDEX timestamps use
+// (MM:SS:FF with 75 frames per second).
+const cueFramesPerSecond = 75.0
+
+// cueTimeToSeconds converts a CUE INDEX timestamp ("03:25:12") to
+// seconds. Minutes may exceed 59 and hours are folded into the minutes
+// field per the spec (MM:SS:FF, MM unbounded).
+func cueTimeToSeconds(v string) float64 {
+	parts := strings.Split(strings.TrimSpace(v), ":")
+	if len(parts) != 3 {
+		return 0
+	}
+	minutes, err1 := strconv.ParseFloat(strings.TrimSpace(parts[0]), 64)
+	seconds, err2 := strconv.ParseFloat(strings.TrimSpace(parts[1]), 64)
+	frames, err3 := strconv.ParseFloat(strings.TrimSpace(parts[2]), 64)
+	if err1 != nil || err2 != nil || err3 != nil {
+		return 0
+	}
+	return minutes*60 + seconds + frames/cueFramesPerSecond
+}
+
+// readCueChapters finds a CUE sheet describing the given audio file and
+// returns its tracks as chapters (global seconds, ends derived from the
+// next start; the last end stays 0 = unknown). A cue matches when its
+// FILE directive names the audio file (basename, case-insensitive), or
+// — for single-cue directories — when the directory holds exactly one.
+func readCueChapters(path string) []AudioChapter {
+	dir := filepath.Dir(path)
+	base := strings.ToLower(filepath.Base(path))
+
+	cuePaths, err := filepath.Glob(filepath.Join(dir, "*.cue"))
+	if err != nil || len(cuePaths) == 0 {
+		return nil
+	}
+
+	var matched string
+	for _, cuePath := range cuePaths {
+		if referencedByCue(cuePath, base) {
+			matched = cuePath
+			break
+		}
+	}
+	if matched == "" && len(cuePaths) == 1 {
+		// Single-cue directory: the cue almost certainly describes the
+		// only audio file next to it.
+		matched = cuePaths[0]
+	}
+	if matched == "" {
+		return nil
+	}
+	return parseCueSheet(matched, base)
+}
+
+// referencedByCue reports whether the cue's FILE directive names the
+// given audio basename.
+func referencedByCue(cuePath, audioBase string) bool {
+	f, err := os.Open(cuePath)
+	if err != nil {
+		return false
+	}
+	defer func() { _ = f.Close() }()
+
+	scanner := bufio.NewScanner(f)
+	for scanner.Scan() {
+		line := strings.TrimSpace(scanner.Text())
+		if len(line) >= 4 && strings.EqualFold(line[:4], "FILE") {
+			rest := strings.TrimSpace(line[4:])
+			rest = strings.Trim(rest, "\"")
+			// FILE "name" WAVE / FILE name MP3 — drop the type word.
+			if idx := strings.LastIndexAny(rest, " \t"); idx != -1 {
+				rest = strings.TrimSpace(rest[:idx])
+			}
+			rest = strings.Trim(rest, "\"")
+			return strings.EqualFold(filepath.Base(rest), audioBase)
+		}
+	}
+	return false
+}
+
+// parseCueSheet extracts TRACK/TITLE/INDEX 01 entries as chapters.
+// INDEX timestamps are absolute from the file start per the spec; the
+// pregap (INDEX 00) is ignored. Multi-file cues contribute only the
+// TRACK blocks under the FILE directive naming our audio file (or all
+// blocks when the cue declares no FILE at all).
+func parseCueSheet(cuePath, audioBase string) []AudioChapter {
+	f, err := os.Open(cuePath)
+	if err != nil {
+		return nil
+	}
+	defer func() { _ = f.Close() }()
+
+	var chapters []AudioChapter
+	var current *AudioChapter
+	title := ""
+	inOurFile := true
+
+	flush := func() {
+		if current != nil && current.Start >= 0 {
+			current.Title = strings.TrimSpace(title)
+			if current.Title == "" {
+				current.Title = "Chapter " + strconv.Itoa(current.Index+1)
+			}
+			if n := len(chapters); n > 0 && current.Start >= chapters[n-1].Start {
+				chapters[n-1].End = current.Start
+			}
+			chapters = append(chapters, *current)
+		}
+		current = nil
+		title = ""
+	}
+
+	scanner := bufio.NewScanner(f)
+	for scanner.Scan() {
+		line := strings.TrimSpace(scanner.Text())
+		upper := strings.ToUpper(line)
+		switch {
+		case strings.HasPrefix(upper, "FILE"):
+			flush()
+			rest := strings.Trim(strings.TrimSpace(line[4:]), "\"")
+			if idx := strings.LastIndexAny(rest, " \t"); idx != -1 {
+				rest = strings.TrimSpace(rest[:idx])
+			}
+			rest = strings.Trim(rest, "\"")
+			inOurFile = strings.EqualFold(filepath.Base(rest), audioBase)
+		case strings.HasPrefix(upper, "TRACK"):
+			flush()
+			if !inOurFile {
+				continue
+			}
+			current = &AudioChapter{Index: len(chapters)}
+			if fields := strings.Fields(line); len(fields) >= 2 {
+				if n, err := strconv.Atoi(fields[1]); err == nil && n > 0 {
+					current.Index = n - 1
+				}
+			}
+		case strings.HasPrefix(upper, "TITLE") && current != nil:
+			if q1 := strings.Index(line, "\""); q1 != -1 {
+				if q2 := strings.LastIndex(line, "\""); q2 > q1 {
+					title = line[q1+1 : q2]
+				}
+			}
+		case strings.HasPrefix(upper, "INDEX"):
+			if current == nil || !inOurFile {
+				continue
+			}
+			if fields := strings.Fields(line); len(fields) >= 3 && fields[1] == "01" {
+				current.Start = cueTimeToSeconds(fields[2])
+			}
+		}
+	}
+	flush()
+
+	if len(chapters) == 0 {
+		return nil
+	}
+	return chapters
+}
diff --git a/internal/services/media_scanner_audio_metadata_test.go b/internal/services/media_scanner_audio_metadata_test.go
new file mode 100644
index 00000000..bea14b8d
--- /dev/null
+++ b/internal/services/media_scanner_audio_metadata_test.go
@@ -0,0 +1,277 @@
+package services
+
+// Unit tests for the exhaustive audiobook metadata ingestion: CUE
+// sheets, m3u playlists, tag fallbacks (incl. Audible freeform atoms)
+// and tag-based track ordering.
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestCueTimeToSeconds(t *testing.T) {
+	cases := map[string]float64{
+		"00:00:00":   0,
+		"01:00:00":   60,
+		"03:25:12":   3*60 + 25 + 12.0/75.0,
+		"75:00:37":   75*60 + 37.0/75.0, // minutes exceed 59 per spec
+		"not-a-time": 0,
+		"1:2":        0,
+	}
+	for in, want := range cases {
+		if got := cueTimeToSeconds(in); (got-want) > 0.001 || (want-got) > 0.001 {
+			t.Errorf("cueTimeToSeconds(%q) = %v, want %v", in, got, want)
+		}
+	}
+}
+
+func TestParseCueSheet(t *testing.T) {
+	dir := t.TempDir()
+	cuePath := filepath.Join(dir, "book.cue")
+	cue := `TITLE "Cue Book"
+FILE "book.flac" WAVE
+  TRACK 01 AUDIO
+    TITLE "Opening"
+    INDEX 01 00:00:00
+  TRACK 02 AUDIO
+    TITLE "The Middle Bit"
+    INDEX 01 00:01:30
+  TRACK 03 AUDIO
+    TITLE "Closing"
+    INDEX 01 00:03:00
+FILE "other.flac" WAVE
+  TRACK 01 AUDIO
+    TITLE "Foreign Track"
+    INDEX 01 00:00:00
+`
+	if err := os.WriteFile(cuePath, []byte(cue), 0o644); err != nil {
+		t.Fatal(err)
+	}
+
+	chapters := parseCueSheet(cuePath, "book.flac")
+	if len(chapters) != 3 {
+		t.Fatalf("chapters = %d (%+v), want 3 (foreign FILE block excluded)", len(chapters), chapters)
+	}
+	if chapters[0].Title != "Opening" || chapters[0].Start != 0 {
+		t.Fatalf("first = %+v", chapters[0])
+	}
+	// MM:SS:FF: "00:01:30" = 1 second + 30/75 frames = 1.4s
+	if chapters[1].Start != 1.4 || chapters[1].End != 3.0 {
+		t.Fatalf("second = %+v", chapters[1])
+	}
+	if chapters[2].End != 0 {
+		t.Fatalf("last end must stay 0 (unknown): %+v", chapters[2])
+	}
+}
+
+func TestReadCueChaptersMatched(t *testing.T) {
+	dir := t.TempDir()
+	cue := "FILE \"audio.mp3\" WAVE\n  TRACK 01 AUDIO\n    TITLE \"One\"\n    INDEX 01 00:00:00\n  TRACK 02 AUDIO\n    TITLE \"Two\"\n    INDEX 01 00:00:10\n"
+	if err := os.WriteFile(filepath.Join(dir, "audio.cue"), []byte(cue), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	chapters := readCueChapters(filepath.Join(dir, "audio.mp3"))
+	if len(chapters) != 2 {
+		t.Fatalf("chapters = %d", len(chapters))
+	}
+
+	// No cue at all → nil, never an error.
+	if chapters := readCueChapters(filepath.Join(dir, "other.mp3")); chapters != nil {
+		t.Fatalf("expected nil for missing cue, got %+v", chapters)
+	}
+}
+
+func TestFindAndApplyPlaylistHint(t *testing.T) {
+	dir := t.TempDir()
+	playlist := "#EXTM3U\n#EXTINF:120,Chapter Zero\n02_Second.mp3\n#EXTINF:60,Chapter One\n./01_First.mp3\nmissing.mp3\n"
+	if err := os.WriteFile(filepath.Join(dir, "book.m3u"), []byte(playlist), 0o644); err != nil {
+		t.Fatal(err)
+	}
+
+	// Exactly one playlist → hint; two → none.
+	hint := findPlaylistHint(dir)
+	if hint == nil {
+		t.Fatal("expected hint")
+	}
+	if err := os.WriteFile(filepath.Join(dir, "other.m3u8"), []byte("#EXTM3U\n"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	if findPlaylistHint(dir) != nil {
+		t.Fatal("multiple playlists must produce no hint")
+	}
+
+	abs := []string{
+		filepath.Join(dir, "01_First.mp3"),
+		filepath.Join(dir, "02_Second.mp3"),
+		filepath.Join(dir, "10_Later.mp3"), // not in playlist → appended last
+	}
+	ordered := hint.reorder(abs)
+	if len(ordered) != 3 || ordered[0] != abs[1] || ordered[1] != abs[0] || ordered[2] != abs[2] {
+		t.Fatalf("playlist order not applied: %v", ordered)
+	}
+	if got := hint.titleFor(abs[0]); got != "Chapter One" {
+		t.Fatalf("titleFor(./01_First.mp3) = %q", got)
+	}
+	if got := hint.titleFor(abs[1]); got != "Chapter Zero" {
+		t.Fatalf("titleFor(02_Second.mp3) = %q", got)
+	}
+	if got := hint.titleFor(abs[2]); got != "" {
+		t.Fatalf("unlisted track must have no title, got %q", got)
+	}
+	if h := (*playlistHint)(nil); h.titleFor(abs[0]) != "" {
+		t.Fatal("nil hint must be safe")
+	}
+}
+
+func syntheticReport(tags map[string]string) *ffprobeReport {
+	r := &ffprobeReport{}
+	r.Format.Tags = tags
+	return r
+}
+
+func TestApplyAudioTagFallbacks(t *testing.T) {
+	t.Run("full fill", func(t *testing.T) {
+		meta := &MediaMetadata{}
+		applyAudioTagFallbacks(meta, syntheticReport(map[string]string{
+			"album":                             "The Tagged Album",
+			"album_artist":                      "Tag Author",
+			"artist":                            "Wrong Author",
+			"composer":                          "Tag Narrator",
+			"grouping":                          "Tag Series",
+			"genre":                             "Audiobook",
+			"date":                              "2020",
+			"----:com.apple.iTunes:SUBTITLE":    "Or, A Life",
+			"----:com.apple.iTunes:SERIES":      "Freeform Series",
+			"----:com.apple.iTunes:SERIES-PART": "4",
+			"----:com.apple.iTunes:ASIN":        "B0ASIN1234",
+			"----:com.apple.iTunes:ABRIDGED":    "1",
+		}))
+		if meta.Title != "The Tagged Album: Or, A Life" {
+			t.Fatalf("title = %q", meta.Title)
+		}
+		if meta.Author != "Tag Author" {
+			t.Fatalf("author = %q", meta.Author)
+		}
+		if len(meta.Narrators) != 1 || meta.Narrators[0] != "Tag Narrator" {
+			t.Fatalf("narrators = %v", meta.Narrators)
+		}
+		// grouping outranks freeform SERIES for the series name only
+		// because it is checked first; both are tag-level fallbacks.
+		if meta.Series == "" {
+			t.Fatal("series not filled from tags")
+		}
+		if meta.SeriesNumber != 4 {
+			t.Fatalf("series number = %d", meta.SeriesNumber)
+		}
+		if meta.ASIN != "B0ASIN1234" {
+			t.Fatalf("asin = %q", meta.ASIN)
+		}
+		if !meta.Abridged {
+			t.Fatal("abridged not filled")
+		}
+		if meta.PublishDate.Year() != 2020 {
+			t.Fatalf("publish date = %v", meta.PublishDate)
+		}
+		if meta.Genre != "Audiobook" {
+			t.Fatalf("genre = %q", meta.Genre)
+		}
+	})
+
+	t.Run("fills only empty fields", func(t *testing.T) {
+		meta := &MediaMetadata{Title: "Sidecar Title", Author: "Sidecar Author", Narrators: []string{"Sidecar Narrator"}}
+		applyAudioTagFallbacks(meta, syntheticReport(map[string]string{
+			"album": "Tag Album", "artist": "Tag Artist", "composer": "Tag Narrator",
+		}))
+		if meta.Title != "Sidecar Title" || meta.Author != "Sidecar Author" {
+			t.Fatalf("tags must not override earlier sources: %+v", meta)
+		}
+		if len(meta.Narrators) != 1 || meta.Narrators[0] != "Sidecar Narrator" {
+			t.Fatalf("narrators = %v", meta.Narrators)
+		}
+	})
+
+	t.Run("explicit sidecar false survives abridged tag", func(t *testing.T) {
+		abridgedFalse := false
+		meta := &MediaMetadata{AudioMeta: &AudioMetadataPayload{Abridged: &abridgedFalse}}
+		applyAudioTagFallbacks(meta, syntheticReport(map[string]string{
+			"----:com.apple.iTunes:ABRIDGED": "1",
+		}))
+		if meta.Abridged {
+			t.Fatal("explicit sidecar false must not be overridden")
+		}
+	})
+
+	t.Run("nil report is a no-op", func(t *testing.T) {
+		meta := &MediaMetadata{}
+		applyAudioTagFallbacks(meta, nil)
+		if meta.Title != "" {
+			t.Fatal("nil report must change nothing")
+		}
+	})
+}
+
+func TestParseTagOrdinal(t *testing.T) {
+	cases := map[string]int{
+		"2":    2,
+		"3/9":  3,
+		" 12 ": 12,
+		"":     0,
+		"x":    0,
+		"0":    0,
+		"2/":   2,
+		"-1":   0,
+	}
+	for in, want := range cases {
+		if got := parseTagOrdinal(in); got != want {
+			t.Errorf("parseTagOrdinal(%q) = %d, want %d", in, got, want)
+		}
+	}
+}
+
+func TestOrderTracksByTags(t *testing.T) {
+	mk := func(disc, track int, rel string) audioTrackInfo {
+		return audioTrackInfo{disc: disc, trackNum: track, relPath: rel}
+	}
+
+	t.Run("tag order wins when complete", func(t *testing.T) {
+		probed := []audioTrackInfo{
+			mk(2, 1, "b/01.mp3"), mk(1, 2, "a/02.mp3"), mk(1, 10, "a/10.mp3"),
+		}
+		orderTracksByTags(probed)
+		want := []string{"a/02.mp3", "a/10.mp3", "b/01.mp3"}
+		for i, tr := range probed {
+			if tr.relPath != want[i] {
+				t.Fatalf("order = %v", probed)
+			}
+		}
+	})
+
+	t.Run("incomplete coverage keeps natural order", func(t *testing.T) {
+		probed := []audioTrackInfo{mk(1, 1, "a/01.mp3"), mk(0, 0, "a/02.mp3")}
+		orderTracksByTags(probed)
+		if probed[0].relPath != "a/01.mp3" || probed[1].relPath != "a/02.mp3" {
+			t.Fatalf("order = %v", probed)
+		}
+	})
+}
+
+func TestTagLookupCaseInsensitive(t *testing.T) {
+	r := syntheticReport(map[string]string{
+		"ALBUM":                      "Cased Album",
+		"----:com.apple.iTunes:ASIN": "B0CASE",
+	})
+	if got := r.tag("album"); got != "Cased Album" {
+		t.Fatalf("tag(album) = %q", got)
+	}
+	if got := r.tag("album", "title"); got != "Cased Album" {
+		t.Fatalf("multi-key lookup = %q", got)
+	}
+	if got := r.tag("----:COM.APPLE.ITUNES:asin"); !strings.EqualFold(got, "B0CASE") {
+		t.Fatalf("freeform case-insensitive lookup = %q", got)
+	}
+	if got := r.tag("missing"); got != "" {
+		t.Fatalf("missing key = %q", got)
+	}
+}
diff --git a/internal/services/media_scanner_audio_multifile.go b/internal/services/media_scanner_audio_multifile.go
new file mode 100644
index 00000000..43630d11
--- /dev/null
+++ b/internal/services/media_scanner_audio_multifile.go
@@ -0,0 +1,1167 @@
+package services
+
+// Multi-file audiobook ingestion: folder-of-tracks books and zip-of-audio
+// books. Both produce the SAME payload shape single-file books write into
+// media_items.audio_metadata — the chapters array stays the format
+// abstraction — plus a tracks array naming one playable file per track
+// (see media_scanner_audio.go). The /audio/:trackIndex endpoint resolves
+// those paths to bytes; the web player maps global seconds ⇄ track/local
+// offset, so progress/bookmarks keep their existing coordinates.
+//
+// Grouping rule (folder books): the book root is the nearest ancestor of
+// the track file that holds audio files DIRECTLY, merged upward through
+// disc/part-style directories ("CD1", "Disc 2", "Part 3", "05") whose
+// parent has no audio of its own. So
+//
+//	Author/Title/01.mp3, 02.mp3            → book at Author/Title
+//	Author/Title/CD1/*.mp3, CD2/*.mp3      → one book at Author/Title
+//	Author/BookA/*.mp3, Author/BookB/*.mp3 → two books (siblings never merge)
+//
+// A root holding fewer than two tracks falls back to the single-file path.
+
+import (
+	"archive/zip"
+	"bufio"
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+	"regexp"
+	"sort"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/jackc/pgx/v5"
+	"github.com/jackc/pgx/v5/pgtype"
+
+	"bookhoard/internal/database"
+	"bookhoard/internal/utils"
+)
+
+// discPartPattern matches directory names that group discs/parts of one
+// book rather than naming a standalone book: "CD1", "disc 2", "Part3",
+// "pt. 1", "Vol 2", or a bare two-digit ordering number ("01").
+var discPartPattern = regexp.MustCompile(`(?i)^(disc|cd|part|pt|vol|volume)\s*\.?\s*\d{0,3}$|^\d{1,2}$`)
+
+// naturalLess orders strings with embedded numbers numerically, so
+// "02 Track" sorts before "10 Track". Digit runs compare by value; other
+// bytes compare bytewise.
+func naturalLess(a, b string) bool {
+	i, j := 0, 0
+	for i < len(a) && j < len(b) {
+		ca, cb := a[i], b[j]
+		da, db := ca >= '0' && ca <= '9', cb >= '0' && cb <= '9'
+		switch {
+		case da && db:
+			si, sj := i, j
+			for i < len(a) && a[i] >= '0' && a[i] <= '9' {
+				i++
+			}
+			for j < len(b) && b[j] >= '0' && b[j] <= '9' {
+				j++
+			}
+			na, nb := strings.TrimLeft(a[si:i], "0"), strings.TrimLeft(b[sj:j], "0")
+			if len(na) != len(nb) {
+				return len(na) < len(nb)
+			}
+			if c := strings.Compare(na, nb); c != 0 {
+				return c < 0
+			}
+		default:
+			if ca != cb {
+				return ca < cb
+			}
+			i++
+			j++
+		}
+	}
+	return len(a)-i < len(b)-j
+}
+
+// sortTracksNatural orders full paths by natural comparison.
+func sortTracksNatural(paths []string) {
+	sort.Slice(paths, func(x, y int) bool { return naturalLess(paths[x], paths[y]) })
+}
+
+// subtreeAudioTracks collects playable audio tracks under dir
+// recursively, natural-sorted by path. Zips don't count (containers,
+// never tracks — see isAudioTrackFile).
+func subtreeAudioTracks(dir string) []string {
+	var tracks []string
+	_ = filepath.WalkDir(dir, func(path string, d os.DirEntry, err error) error {
+		if err != nil || d.IsDir() {
+			return nil // unreadable subtree: skip silently, best effort
+		}
+		if isAudioTrackFile(path) {
+			tracks = append(tracks, path)
+		}
+		return nil
+	})
+	sortTracksNatural(tracks)
+	return tracks
+}
+
+// directAudioCount counts playable audio files directly inside dir (not
+// recursive).
+func directAudioCount(dir string) int {
+	entries, err := os.ReadDir(dir)
+	if err != nil {
+		return 0
+	}
+	n := 0
+	for _, e := range entries {
+		if !e.IsDir() && isAudioTrackFile(e.Name()) {
+			n++
+		}
+	}
+	return n
+}
+
+// bookRootDirForTrackFile resolves the folder-book root DIRECTORY for an
+// audio file without walking its subtree (cheap enough to call for every
+// track visit). ok is false when no ancestor holds audio directly.
+func bookRootDirForTrackFile(path, libraryRoot string) (root string, ok bool) {
+	dir := filepath.Dir(path)
+
+	// Climb to the nearest ancestor holding audio files directly.
+	candidate := dir
+	for directAudioCount(candidate) == 0 {
+		parent := filepath.Dir(candidate)
+		if parent == candidate || candidate == libraryRoot || !strings.HasPrefix(candidate, libraryRoot) {
+			return "", false
+		}
+		candidate = parent
+	}
+
+	// Merge upward through disc/part groupings. Stop at the first
+	// directory that doesn't look like a disc marker, or whose parent
+	// holds audio of its own (that would swallow sibling books).
+	for discPartPattern.MatchString(strings.ToLower(filepath.Base(candidate))) {
+		parent := filepath.Dir(candidate)
+		if parent == candidate || candidate == libraryRoot || !strings.HasPrefix(candidate, libraryRoot) {
+			break
+		}
+		if directAudioCount(parent) > 0 {
+			break
+		}
+		candidate = parent
+	}
+
+	return candidate, true
+}
+
+// bookRootForTrackFile resolves the folder-book root for an audio file.
+// ok is false when the resolved root holds fewer than two tracks — the
+// caller falls back to the single-file ingestion path.
+func bookRootForTrackFile(path, libraryRoot string) (root string, tracks []string, ok bool) {
+	candidate, ok := bookRootDirForTrackFile(path, libraryRoot)
+	if !ok {
+		return "", nil, false
+	}
+	tracks = subtreeAudioTracks(candidate)
+	return candidate, tracks, len(tracks) >= 2
+}
+
+// maybeProcessAudioBook resolves the owning library + root folder and
+// hands an audio file to processAudioBookFile. Called from the scan walk
+// BEFORE the single-file path; handled=true consumes the file.
+func (s *MediaScanner) maybeProcessAudioBook(ctx context.Context, path string) (bool, error) {
+	if !isAudioFile(path) {
+		return false, nil
+	}
+	// Extension allowlisting already scopes audio to audiobook libraries,
+	// so any scannable audio file belongs to one.
+	rootFolder := ""
+	for _, folder := range s.folders {
+		if strings.HasPrefix(path, folder) {
+			rootFolder = folder
+			break
+		}
+	}
+	if rootFolder == "" {
+		return false, nil
+	}
+
+	libraryID := s.defaultLibraryID
+	if !libraryID.Valid {
+		lib, err := s.db.GetLibraryByFolder(ctx, rootFolder)
+		if err != nil {
+			return false, fmt.Errorf("failed to find library for audio file %s: %w", path, err)
+		}
+		libraryID = lib.LibraryID
+	}
+	return s.processAudioBookFile(ctx, path, libraryID, rootFolder)
+}
+
+// processAudioBookFile dispatches one audio file: zips become zip books,
+// other audio resolves its folder-book root (falls back to the caller's
+// single-file path when the root holds fewer than two tracks).
+func (s *MediaScanner) processAudioBookFile(ctx context.Context, path string, libraryID pgtype.UUID, rootFolder string) (bool, error) {
+	if strings.EqualFold(filepath.Ext(path), ".zip") {
+		if err := s.processZipAudioBook(ctx, path, libraryID, rootFolder); err != nil {
+			return true, err
+		}
+		return true, nil
+	}
+
+	root, ok := bookRootDirForTrackFile(path, rootFolder)
+	if !ok {
+		return false, nil // no audio-bearing ancestor: shouldn't happen
+	}
+	if s.audioBookRoots[root] {
+		return true, nil // already ingested this walk (≥2 verified then)
+	}
+
+	tracks := subtreeAudioTracks(root)
+	if len(tracks) < 2 {
+		return false, nil // lone file: single-file book, existing path
+	}
+	s.audioBookRoots[root] = true
+
+	if err := s.processAudioFolderBook(ctx, root, tracks, libraryID, rootFolder); err != nil {
+		return true, err
+	}
+	return true, nil
+}
+
+// audioTrackInfo is the probed fact set for one track file.
+type audioTrackInfo struct {
+	relPath  string // library-relative (folder books) or entry name (zip books)
+	title    string
+	duration float64
+	size     int64
+	disc     int // tag disc number (TPOS/disk); 0 = absent
+	trackNum int // tag track number (TRCK/trkn); 0 = absent
+}
+
+// parseTagOrdinal reads "N" or "N/M" tag values (disc, track) into N.
+func parseTagOrdinal(v string) int {
+	v = strings.TrimSpace(v)
+	if idx := strings.Index(v, "/"); idx != -1 {
+		v = v[:idx]
+	}
+	n, err := strconv.Atoi(strings.TrimSpace(v))
+	if err != nil || n < 0 {
+		return 0
+	}
+	return n
+}
+
+// applyTrackProbe fills one track's probed facts from its ffprobe
+// report: duration, disc/track ordering keys, and the display title per
+// the precedence chain (movement_name → title → caller's fallback).
+func applyTrackProbe(report *ffprobeReport, info *audioTrackInfo) {
+	if report == nil {
+		return
+	}
+	info.duration = float64(report.Format.Duration)
+	info.disc = parseTagOrdinal(report.tag("disc"))
+	info.trackNum = parseTagOrdinal(report.tag("track"))
+	if t := report.tag("movement_name"); t != "" {
+		info.title = t
+	} else if t := report.tag("title"); t != "" {
+		info.title = t
+	}
+}
+
+// orderTracksByTags reorders probed tracks by (disc, track) when EVERY
+// track carries a track number — tag order then outranks filename
+// guesses for multi-disc rips whose files are flat `01.mp3` dumps. Any
+// gap in coverage falls back to the natural-sorted discovery order.
+func orderTracksByTags(probed []audioTrackInfo) {
+	if len(probed) < 2 {
+		return
+	}
+	for _, tr := range probed {
+		if tr.trackNum <= 0 {
+			return
+		}
+	}
+	sort.SliceStable(probed, func(x, y int) bool {
+		if probed[x].disc != probed[y].disc {
+			return probed[x].disc < probed[y].disc
+		}
+		if probed[x].trackNum != probed[y].trackNum {
+			return probed[x].trackNum < probed[y].trackNum
+		}
+		return naturalLess(probed[x].relPath, probed[y].relPath)
+	})
+}
+
+// playlistHint is the ordering/title intent of an m3u/m3u8 playlist in a
+// book root — a curator's explicit track order and names.
+type playlistHint struct {
+	refs   []string          // entry refs in playlist order (slash-normalized)
+	titles map[string]string // normalized ref → #EXTINF title
+}
+
+// findPlaylistHint parses THE playlist of a book root (exactly one
+// .m3u/.m3u8 among its direct children); zero or several → no hint.
+func findPlaylistHint(rootDir string) *playlistHint {
+	matches, err := filepath.Glob(filepath.Join(rootDir, "*.m3u"))
+	if err != nil {
+		matches = nil
+	}
+	m8, err := filepath.Glob(filepath.Join(rootDir, "*.m3u8"))
+	if err == nil {
+		matches = append(matches, m8...)
+	}
+	if len(matches) != 1 {
+		return nil
+	}
+
+	f, err := os.Open(matches[0])
+	if err != nil {
+		return nil
+	}
+	defer func() { _ = f.Close() }()
+
+	hint := &playlistHint{titles: map[string]string{}}
+	pendingTitle := ""
+	scanner := bufio.NewScanner(f)
+	for scanner.Scan() {
+		line := strings.TrimSpace(scanner.Text())
+		if line == "" {
+			continue
+		}
+		if strings.HasPrefix(line, "#") {
+			if strings.HasPrefix(strings.ToUpper(line), "#EXTINF:") {
+				if idx := strings.Index(line, ","); idx != -1 {
+					pendingTitle = strings.TrimSpace(line[idx+1:])
+				}
+			}
+			continue
+		}
+		ref := filepath.ToSlash(line)
+		ref = strings.TrimPrefix(ref, "./")
+		hint.refs = append(hint.refs, ref)
+		if pendingTitle != "" {
+			hint.titles[strings.ToLower(ref)] = pendingTitle
+		}
+		pendingTitle = ""
+	}
+	if len(hint.refs) == 0 {
+		return nil
+	}
+	return hint
+}
+
+// reorder returns the absolute track paths in playlist order (refs
+// matched by relative path first, then by basename), with any tracks
+// the playlist didn't mention appended in their natural order.
+func (h *playlistHint) reorder(absTracks []string) []string {
+	byRel := make(map[string]string, len(absTracks))
+	byBase := make(map[string][]string, len(absTracks))
+	for _, abs := range absTracks {
+		rel := filepath.ToSlash(abs)
+		byRel[strings.ToLower(rel)] = abs
+		byBase[strings.ToLower(filepath.Base(abs))] = append(byBase[strings.ToLower(filepath.Base(abs))], abs)
+	}
+
+	ordered := make([]string, 0, len(absTracks))
+	used := make(map[string]bool, len(absTracks))
+	for _, ref := range h.refs {
+		abs, ok := byRel[strings.ToLower(ref)]
+		if !ok {
+			if candidates := byBase[strings.ToLower(filepath.Base(ref))]; len(candidates) > 0 {
+				abs = candidates[0]
+				ok = true
+			}
+		}
+		if ok && !used[abs] {
+			ordered = append(ordered, abs)
+			used[abs] = true
+		}
+	}
+	for _, abs := range absTracks {
+		if !used[abs] {
+			ordered = append(ordered, abs)
+		}
+	}
+	return ordered
+}
+
+// titleFor returns the playlist's #EXTINF title for an absolute track
+// path (matched by relative path, then basename); "" when none.
+func (h *playlistHint) titleFor(abs string) string {
+	if h == nil {
+		return ""
+	}
+	if t, ok := h.titles[strings.ToLower(filepath.ToSlash(abs))]; ok {
+		return t
+	}
+	return h.titles[strings.ToLower(filepath.Base(abs))]
+}
+
+// cleanTrackTitle derives a display title from a filename when the track
+// carries no tag: strips extension, leading track numbers and separators.
+func cleanTrackTitle(path string) string {
+	base := filepath.Base(path)
+	title := strings.TrimSpace(strings.TrimSuffix(base, filepath.Ext(base)))
+	trimmed := strings.TrimLeft(title, "0123456789")
+	if trimmed != title && trimmed != "" {
+		title = strings.TrimLeft(trimmed, " -_.")
+	}
+	if title == "" {
+		title = base
+	}
+	return title
+}
+
+// buildMultiFileAudioPayload assembles the audio_metadata payload for a
+// multi-file book: layout, cumulative track start/end, chapters (sidecar
+// chapters win; otherwise the track boundaries ARE the chapters) and the
+// aggregate duration.
+func buildMultiFileAudioPayload(layout string, payload *AudioMetadataPayload, tracks []audioTrackInfo) *AudioMetadataPayload {
+	if payload == nil {
+		payload = &AudioMetadataPayload{}
+	}
+	payload.Layout = layout
+	payload.Tracks = nil
+	clock := 0.0
+	for i, tr := range tracks {
+		end := clock + tr.duration
+		payload.Tracks = append(payload.Tracks, AudioTrack{
+			Index:           i,
+			Path:            tr.relPath,
+			Title:           tr.title,
+			Start:           clock,
+			End:             end,
+			DurationSeconds: tr.duration,
+			SizeBytes:       tr.size,
+		})
+		clock = end
+	}
+	payload.DurationSeconds = clock
+
+	// Curated sidecar chapters describe the whole book in global seconds
+	// and keep priority; otherwise tracks are the chapters (the
+	// documented folder-as-book shape: same {index,title,start,end}).
+	if len(payload.Chapters) == 0 && len(payload.Tracks) > 0 {
+		for _, tr := range payload.Tracks {
+			payload.Chapters = append(payload.Chapters, AudioChapter{
+				Index: tr.Index,
+				Title: tr.Title,
+				Start: tr.Start,
+				End:   tr.End,
+			})
+		}
+	}
+	return payload
+}
+
+// extractAudioBookMetadata gathers book-level metadata for a multi-file
+// book: sidecars next to the representative path (a sentinel inside the
+// book root for folders, the zip itself for archives — the sidecar checks
+// all look at Dir(representative)), then folder-structure patterns, then
+// the first track's tags (album/artist/composer/grouping/freeform atoms
+// via applyAudioTagFallbacks), then fallbackTitle (the book directory
+// name for folder books, the zip name for zip books — passed explicitly
+// because Dir(representative) means different things per layout).
+// Embedded cover art is the cover fallback of last resort: sidecar
+// covers win. firstTrackAbs is the first track's absolute path for
+// folder books ("" for zip books — their first entry is temp-extracted
+// on demand).
+func (s *MediaScanner) extractAudioBookMetadata(representative, rootFolder string, firstReport *ffprobeReport, firstTrackAbs, fallbackTitle string) *MediaMetadata {
+	extracted, err := s.extractMetadata(representative)
+	var metadata *MediaMetadata
+	if err != nil || extracted == nil {
+		metadata = &MediaMetadata{}
+	} else {
+		metadata = extracted
+	}
+	// The folder-book representative is a sentinel INSIDE the root (the
+	// sidecar checks all look at Dir(representative)). The generic
+	// extractor's filename-title fallback would name the book
+	// ".audiobook-root" and every real source below would see a non-empty
+	// title — strip it so sidecars, folder structure, tags and finally
+	// the directory name get their turn.
+	if metadata.Title != "" && strings.HasPrefix(filepath.Base(representative), ".") &&
+		metadata.Title == strings.TrimSuffix(filepath.Base(representative), filepath.Ext(representative)) {
+		metadata.Title = ""
+	}
+	if metadata.AudioMeta == nil {
+		metadata.AudioMeta = readSidecarAudio(representative)
+	}
+
+	if folderMetadata := s.extractFolderStructureMetadata(representative, rootFolder); folderMetadata != nil {
+		if metadata.Title == "" && folderMetadata.Title != "" {
+			metadata.Title = folderMetadata.Title
+		}
+		if metadata.Author == "" && folderMetadata.Author != "" {
+			metadata.Author = folderMetadata.Author
+		}
+		if metadata.Series == "" && folderMetadata.Series != "" {
+			metadata.Series = folderMetadata.Series
+		}
+		if metadata.SeriesNumber == 0 && folderMetadata.SeriesNumber > 0 {
+			metadata.SeriesNumber = folderMetadata.SeriesNumber
+		}
+	}
+
+	// Tag fallbacks run after sidecars and folder structure — the shared
+	// helper fills title/author/narrators/series/date/genre from the
+	// first track's tags (album/artist/composer/grouping/date/genre plus
+	// Audible freeform atoms), then embedded cover art as the cover
+	// fallback of last resort.
+	applyAudioTagFallbacks(metadata, firstReport)
+
+	if metadata.Title == "" && fallbackTitle != "" {
+		metadata.Title = strings.ReplaceAll(fallbackTitle, "_", " ")
+	}
+	if metadata.Author == "" {
+		metadata.Author = "Unknown"
+	}
+	if metadata.CoverPath == "" {
+		if cover := findSidecarCover(representative); cover != "" {
+			metadata.CoverPath = s.getRelativePath(cover)
+		}
+	}
+	if metadata.CoverPath == "" && firstTrackAbs != "" {
+		if cover := extractEmbeddedAudioCover(firstTrackAbs, representative); cover != "" {
+			metadata.CoverPath = s.getRelativePath(cover)
+		}
+	}
+	return metadata
+}
+
+// createAudioBookItem inserts the media_items row shared by folder and
+// zip books. The hash columns stay NULL — content dedup is path-based for
+// multi-file books (there is no single byte stream to hash).
+func (s *MediaScanner) createAudioBookItem(ctx context.Context, libraryID pgtype.UUID, metadata *MediaMetadata, relPath string, totalSize int64, mimeType string, modTime pgtype.Timestamptz) (database.MediaItems, error) {
+	return s.db.CreateMediaItem(ctx, database.CreateMediaItemParams{
+		LibraryID:       libraryID,
+		Title:           metadata.Title,
+		Author:          pgtype.Text{String: metadata.Author, Valid: metadata.Author != ""},
+		Isbn:            pgtype.Text{String: utils.NormalizeISBNSafe(metadata.ISBN), Valid: metadata.ISBN != ""},
+		Asin:            pgtype.Text{String: metadata.ASIN, Valid: metadata.ASIN != ""},
+		Description:     pgtype.Text{String: metadata.Description, Valid: metadata.Description != ""},
+		FilePath:        relPath,
+		FileSize:        pgtype.Int8{Int64: totalSize, Valid: true},
+		MimeType:        pgtype.Text{String: mimeType, Valid: mimeType != ""},
+		CoverImagePath:  pgtype.Text{String: metadata.CoverPath, Valid: metadata.CoverPath != ""},
+		Series:          pgtype.Text{String: metadata.Series, Valid: metadata.Series != ""},
+		SeriesNumber:    pgtype.Int4{Int32: metadata.SeriesNumber, Valid: metadata.SeriesNumber > 0},
+		Publisher:       pgtype.Text{String: metadata.Publisher, Valid: metadata.Publisher != ""},
+		DatePublished:   pgtype.Date{Time: metadata.PublishDate, Valid: !metadata.PublishDate.IsZero()},
+		Genre:           pgtype.Text{String: metadata.Genre, Valid: metadata.Genre != ""},
+		Contributors:    utils.NormalizeContributors(metadata.Contributors),
+		Narrators:       nilToEmpty(metadata.Narrators),
+		NarratorsSearch: utils.NormalizeNarratorsSearch(metadata.Narrators),
+		Abridged:        metadata.Abridged,
+		Tags:            utils.NormalizeTags(metadata.Tags),
+		AddedByAdminID:  s.adminID,
+		CreatedAt:       modTime,
+		ImportedAt:      pgtype.Timestamptz{Time: time.Now(), Valid: true},
+		AudioMetadata:   marshalAudioMetadata(metadata.AudioMeta),
+	})
+}
+
+// setAudioFormatGroup writes the audiobook format facts after create.
+func (s *MediaScanner) setAudioFormatGroup(ctx context.Context, itemID pgtype.UUID, mimeType string, chapterCount int) error {
+	return s.db.UpdateMediaItemFormatGroup(ctx, database.UpdateMediaItemFormatGroupParams{
+		ID:             itemID,
+		FormatGroup:    "audiobook",
+		FormatMimetype: pgtype.Text{String: mimeType, Valid: mimeType != ""},
+		IsReflowable:   pgtype.Bool{Bool: false, Valid: true},
+		HasFixedLayout: pgtype.Bool{Bool: false, Valid: true},
+		ChapterCount:   pgtype.Int4{Int32: int32(chapterCount), Valid: chapterCount > 0},
+	})
+}
+
+// audioPayloadTracksEqual reports whether the stored audio_metadata
+// already describes exactly the given track manifest (paths + sizes).
+// Timestamp-free manifests make rescans idempotent.
+func audioPayloadTracksEqual(stored []byte, payload *AudioMetadataPayload) bool {
+	if len(stored) == 0 {
+		return false
+	}
+	var storedPayload AudioMetadataPayload
+	if err := json.Unmarshal(stored, &storedPayload); err != nil {
+		return false
+	}
+	if storedPayload.Layout != payload.Layout || len(storedPayload.Tracks) != len(payload.Tracks) {
+		return false
+	}
+	for i, tr := range storedPayload.Tracks {
+		if tr.Path != payload.Tracks[i].Path || tr.SizeBytes != payload.Tracks[i].SizeBytes {
+			return false
+		}
+	}
+	return true
+}
+
+// absorbOneTrackItems removes the one-track audiobook items a previous
+// scan ingested individually from the tracks now grouped under a folder
+// book root. Annotations/progress cascade with the rows, and multi-file
+// sources never carried listening progress — nothing real is lost. Only
+// audio files under the root are deleted; real books and the folder book
+// row itself are never touched.
+func (s *MediaScanner) absorbOneTrackItems(ctx context.Context, libraryID pgtype.UUID, rootRel string) {
+	items, err := s.db.ListMediaItemsByLibraryIncludingArchived(ctx, libraryID)
+	if err != nil {
+		fmt.Printf("Warning: absorb pass could not list library items for %s: %v\n", rootRel, err)
+		return
+	}
+	prefix := rootRel + "/"
+	removed := 0
+	for _, item := range items {
+		if !strings.HasPrefix(item.FilePath, prefix) || !isAudioTrackFile(item.FilePath) {
+			continue
+		}
+		if err := s.db.DeleteMediaItem(ctx, item.ID); err != nil {
+			fmt.Printf("Warning: failed to absorb one-track item %s into folder book: %v\n", item.FilePath, err)
+			continue
+		}
+		fmt.Printf("[AUDIO-MERGE] Absorbed one-track item '%s' into folder book %s\n", item.Title, rootRel)
+		s.logger.LogDelete(fmt.Sprintf("[AUDIO-MERGE] Absorbed one-track item '%s' into folder book '%s'", item.Title, rootRel))
+		removed++
+	}
+	if removed > 0 {
+		fmt.Printf("[AUDIO-MERGE] %d one-track item(s) absorbed into %s\n", removed, rootRel)
+	}
+}
+
+// audioLayoutOf reads the layout key from a stored audio_metadata
+// payload; "" when absent (single-file book or not audio).
+func audioLayoutOf(stored []byte) string {
+	if len(stored) == 0 {
+		return ""
+	}
+	var probe struct {
+		Layout string `json:"layout"`
+	}
+	if err := json.Unmarshal(stored, &probe); err != nil {
+		return ""
+	}
+	return probe.Layout
+}
+
+// rescanMultiFileAudioBook is the per-item rescan for folder/zip books:
+// rebuild the track manifest from disk and re-derive book metadata
+// (sidecars, folder structure, first-track tags), then write through the
+// shared editorial updater so override semantics match single-file
+// books. The generic per-file updater is bypassed by the caller — see
+// RescanMediaItem.
+func (s *MediaScanner) rescanMultiFileAudioBook(ctx context.Context, item database.MediaItems, fullPath string) error {
+	layout := audioLayoutOf(item.AudioMetadata)
+
+	var representative string
+	var probed []audioTrackInfo
+	switch layout {
+	case "folder":
+		tracks := subtreeAudioTracks(fullPath)
+		if len(tracks) == 0 {
+			return fmt.Errorf("folder book %s has no tracks on disk", item.FilePath)
+		}
+		// Sentinel INSIDE the root: sidecar checks look at Dir().
+		representative = filepath.Join(fullPath, ".audiobook-root")
+		for _, abs := range tracks {
+			info := audioTrackInfo{
+				relPath: s.getRelativePath(abs),
+				title:   cleanTrackTitle(abs),
+			}
+			if st, err := os.Stat(abs); err == nil {
+				info.size = st.Size()
+			}
+			if report := runFFProbe(abs); report != nil {
+				applyTrackProbe(report, &info)
+			}
+			probed = append(probed, info)
+		}
+	case "zip":
+		representative = fullPath
+		entries, err := zipAudioEntries(fullPath)
+		if err != nil {
+			return fmt.Errorf("failed to read audio zip %s: %w", fullPath, err)
+		}
+		for _, e := range entries {
+			info := audioTrackInfo{
+				relPath: e.name,
+				title:   cleanTrackTitle(e.name),
+				size:    e.size,
+			}
+			if report := probeZipEntry(fullPath, e.name); report != nil {
+				applyTrackProbe(report, &info)
+			}
+			probed = append(probed, info)
+		}
+	default:
+		return fmt.Errorf("unknown audio layout %q for %s", layout, item.FilePath)
+	}
+	if len(probed) == 0 {
+		return fmt.Errorf("multi-file book %s has no tracks", item.FilePath)
+	}
+	orderTracksByTags(probed)
+
+	// First track's tags name the book when sidecars/folders don't.
+	var firstReport *ffprobeReport
+	switch layout {
+	case "folder":
+		firstReport = runFFProbe(fullPath + string(filepath.Separator) + probed[0].relPath)
+	case "zip":
+		firstReport = probeZipEntry(fullPath, probed[0].relPath)
+	}
+
+	rootFolder := ""
+	for _, folder := range s.folders {
+		if strings.HasPrefix(fullPath, folder) {
+			rootFolder = folder
+			break
+		}
+	}
+
+	metadata := s.extractAudioBookMetadata(representative, rootFolder, firstReport, firstTrackAbsFor(layout, fullPath, probed), layoutFallbackTitle(layout, fullPath))
+	payload := buildMultiFileAudioPayload(layout, metadata.AudioMeta, probed)
+	metadata.AudioMeta = payload
+	if len(payload.Narrators) > 0 && len(metadata.Narrators) == 0 {
+		metadata.Narrators = payload.Narrators
+	}
+	if payload.ASIN != "" && metadata.ASIN == "" {
+		metadata.ASIN = payload.ASIN
+	}
+	metadata.Contributors = utils.NormalizeContributors(metadata.Contributors)
+	metadata.Tags = utils.NormalizeTags(metadata.Tags)
+
+	if err := s.updateMediaItemWithMetadata(ctx, item, representative, metadata); err != nil {
+		return fmt.Errorf("failed to update multi-file book %s: %w", item.FilePath, err)
+	}
+
+	// file_size/chapter_count ride the focused payload query (the generic
+	// update doesn't carry file_size).
+	var totalSize int64
+	for _, tr := range probed {
+		totalSize += tr.size
+	}
+	firstMime := mimeForAudioEntry(probed[0].relPath)
+	if layout == "folder" {
+		firstMime = s.getMimeType(fullPath + string(filepath.Separator) + probed[0].relPath)
+	}
+	if _, err := s.db.UpdateMediaItemAudioBookPayload(ctx, database.UpdateMediaItemAudioBookPayloadParams{
+		ID:            item.ID,
+		FileSize:      pgtype.Int8{Int64: totalSize, Valid: true},
+		MimeType:      pgtype.Text{String: firstMime, Valid: firstMime != ""},
+		AudioMetadata: marshalAudioMetadata(payload),
+		ChapterCount:  pgtype.Int4{Int32: int32(len(payload.Chapters)), Valid: len(payload.Chapters) > 0},
+	}); err != nil {
+		return fmt.Errorf("failed to refresh audio book payload %s: %w", item.FilePath, err)
+	}
+
+	fmt.Printf("[AUDIO] Rescanned %s book '%s' (%d tracks)\n", layout, item.Title, len(probed))
+	return nil
+}
+
+// layoutFallbackTitle is the last-resort book title per layout: the book
+// directory name for folder books, the zip's own name (extension
+// stripped) for zip books.
+func layoutFallbackTitle(layout, fullPath string) string {
+	if layout == "zip" {
+		return strings.TrimSuffix(filepath.Base(fullPath), filepath.Ext(fullPath))
+	}
+	return filepath.Base(fullPath)
+}
+
+// firstTrackAbsFor returns the first track's absolute path for folder
+// books (zip books carry in-archive entries — no absolute path).
+func firstTrackAbsFor(layout, rootPath string, probed []audioTrackInfo) string {
+	if layout == "folder" && len(probed) > 0 {
+		return filepath.Join(rootPath, probed[0].relPath)
+	}
+	return ""
+}
+
+// audioTrackCountOf reads the stored tracks-array length from an
+// audio_metadata payload; -1 when absent/unparseable.
+func audioTrackCountOf(stored []byte) int {
+	if len(stored) == 0 {
+		return -1
+	}
+	var probe struct {
+		Tracks []json.RawMessage `json:"tracks"`
+	}
+	if err := json.Unmarshal(stored, &probe); err != nil {
+		return -1
+	}
+	return len(probe.Tracks)
+}
+
+// multiFileBookUnchanged is the rescan fast path: track count and total
+// size match the stored row AND the stored manifest carries real
+// durations, so the (expensive) per-track ffprobe pass is skipped. A
+// zero book duration means the last scan ran without ffprobe — treat it
+// as changed so a ffprobe-equipped rescan can fill durations in (the
+// probe pass is nearly free in ffprobe-less environments anyway).
+// Book-level metadata is not re-derived on unchanged scans — a
+// metadata.json edit needs a force rescan or a track change to pick up,
+// same tradeoff the single-file path makes on size-unchanged skips.
+func multiFileBookUnchanged(existing database.MediaItems, totalSize int64, trackCount int) bool {
+	if existing.FileSize.Int64 != totalSize {
+		return false
+	}
+	if audioTrackCountOf(existing.AudioMetadata) != trackCount {
+		return false
+	}
+	var probe struct {
+		DurationSeconds float64 `json:"duration_seconds"`
+	}
+	if len(existing.AudioMetadata) > 0 {
+		_ = json.Unmarshal(existing.AudioMetadata, &probe)
+	}
+	return probe.DurationSeconds > 0
+}
+
+// processAudioFolderBook ingests or refreshes one folder-of-tracks book.
+// The item's file_path is the book root directory (library-relative);
+// file_size is the track-size sum; audio_metadata carries layout "folder"
+// plus the track manifest.
+func (s *MediaScanner) processAudioFolderBook(ctx context.Context, rootDir string, tracks []string, libraryID pgtype.UUID, rootFolder string) error {
+	rootRel := s.getRelativePath(rootDir)
+	fmt.Printf("[AUDIO] Folder book at %s (%d tracks)\n", rootRel, len(tracks))
+
+	// Cheap pass first: track sizes only. The per-track ffprobe pass
+	// below is expensive (a 1000-track book must not re-probe on every
+	// auto-scan), so the existence check runs before it.
+	var totalSize int64
+	for _, abs := range tracks {
+		if st, err := os.Stat(abs); err == nil {
+			totalSize += st.Size()
+		}
+	}
+
+	existing, existingErr := s.getMediaItemByFilePath(ctx, rootRel, libraryID)
+	if existingErr == nil && !s.forceRescan && multiFileBookUnchanged(existing, totalSize, len(tracks)) {
+		if existing.ArchivedAt.Valid || existing.MissingScanCount > 0 {
+			if err := s.db.ClearMediaItemArchive(ctx, existing.ID); err != nil {
+				fmt.Printf("Warning: failed to unarchive folder book %s: %v\n", rootRel, err)
+			} else {
+				fmt.Printf("[AUDIO] Restored folder book '%s' (root is back)\n", existing.Title)
+			}
+		}
+		// One-track strays from pre-grouping scans go away either way.
+		s.absorbOneTrackItems(ctx, libraryID, rootRel)
+		return nil
+	}
+
+	// Playlist hint: a lone m3u/m3u8 in the root is a curator's explicit
+	// order (and #EXTINF names) for the track list.
+	hint := findPlaylistHint(rootDir)
+	if hint != nil {
+		tracks = hint.reorder(tracks)
+		fmt.Printf("[AUDIO] Playlist ordering applied to %s (%d refs)\n", rootRel, len(hint.refs))
+	}
+
+	probed := make([]audioTrackInfo, 0, len(tracks))
+	var firstReport *ffprobeReport
+	for i, abs := range tracks {
+		info := audioTrackInfo{
+			relPath: s.getRelativePath(abs),
+			title:   cleanTrackTitle(abs),
+		}
+		if t := hint.titleFor(abs); t != "" {
+			info.title = t
+		}
+		if st, err := os.Stat(abs); err == nil {
+			info.size = st.Size()
+		}
+		report := runFFProbe(abs)
+		if report != nil {
+			applyTrackProbe(report, &info)
+			if i == 0 {
+				firstReport = report
+			}
+		}
+		probed = append(probed, info)
+	}
+	if len(probed) == 0 {
+		return fmt.Errorf("folder book %s has no probeable tracks", rootRel)
+	}
+	orderTracksByTags(probed)
+
+	// The representative path drives the sidecar/folder-structure checks;
+	// they all look at Dir(representative), so a sentinel INSIDE the root
+	// resolves covers and metadata.json living there (including disc-
+	// layout roots where track zero sits deeper).
+	sentinel := filepath.Join(rootDir, ".audiobook-root")
+	metadata := s.extractAudioBookMetadata(sentinel, rootFolder, firstReport, tracks[0], filepath.Base(rootDir))
+	payload := buildMultiFileAudioPayload("folder", metadata.AudioMeta, probed)
+	metadata.AudioMeta = payload
+	if len(payload.Narrators) > 0 && len(metadata.Narrators) == 0 {
+		metadata.Narrators = payload.Narrators
+	}
+	if payload.ASIN != "" && metadata.ASIN == "" {
+		metadata.ASIN = payload.ASIN
+	}
+	metadata.Contributors = utils.NormalizeContributors(metadata.Contributors)
+	metadata.Tags = utils.NormalizeTags(metadata.Tags)
+
+	firstMime := s.getMimeType(tracks[0])
+	var modTime pgtype.Timestamptz
+	if rootInfo, err := os.Stat(rootDir); err == nil {
+		modTime = pgtype.Timestamptz{Time: rootInfo.ModTime(), Valid: true}
+	}
+
+	err := existingErr
+	switch {
+	case err == nil:
+		changed := existing.FileSize.Int64 != totalSize || !audioPayloadTracksEqual(existing.AudioMetadata, payload)
+		if changed || s.forceRescan {
+			if err := s.updateAudioBookItem(ctx, existing, payload, firstMime, totalSize, len(payload.Chapters)); err != nil {
+				return err
+			}
+		} else if existing.ArchivedAt.Valid || existing.MissingScanCount > 0 {
+			// Unchanged content that was archived while the root was gone.
+			if err := s.db.ClearMediaItemArchive(ctx, existing.ID); err != nil {
+				fmt.Printf("Warning: failed to unarchive folder book %s: %v\n", rootRel, err)
+			} else {
+				fmt.Printf("[AUDIO] Restored folder book '%s' (root is back)\n", existing.Title)
+			}
+		}
+	case errors.Is(err, pgx.ErrNoRows):
+		created, err := s.createAudioBookItem(ctx, libraryID, metadata, rootRel, totalSize, firstMime, modTime)
+		if err != nil {
+			return fmt.Errorf("failed to create folder book %s: %w", rootRel, err)
+		}
+		if err := s.setAudioFormatGroup(ctx, created.ID, firstMime, len(payload.Chapters)); err != nil {
+			fmt.Printf("Warning: failed to set format group for folder book %s: %v\n", rootRel, err)
+		}
+		fmt.Printf("[AUDIO] Created folder book '%s' (%d tracks) at %s\n", metadata.Title, len(tracks), rootRel)
+		s.newItems++
+	default:
+		return fmt.Errorf("failed to check folder book existence %s: %w", rootRel, err)
+	}
+
+	// One-track strays from pre-grouping scans go away either way.
+	s.absorbOneTrackItems(ctx, libraryID, rootRel)
+	return nil
+}
+
+// updateAudioBookItem refreshes an existing folder/zip book row after a
+// rescan saw the track set change (or the admin forced a rescan). Only
+// scan-derived fields move — editorial columns keep admin edits.
+func (s *MediaScanner) updateAudioBookItem(ctx context.Context, existing database.MediaItems, payload *AudioMetadataPayload, mimeType string, totalSize int64, chapterCount int) error {
+	if _, err := s.db.UpdateMediaItemAudioBookPayload(ctx, database.UpdateMediaItemAudioBookPayloadParams{
+		ID:            existing.ID,
+		FileSize:      pgtype.Int8{Int64: totalSize, Valid: true},
+		MimeType:      pgtype.Text{String: mimeType, Valid: mimeType != ""},
+		AudioMetadata: marshalAudioMetadata(payload),
+		ChapterCount:  pgtype.Int4{Int32: int32(chapterCount), Valid: chapterCount > 0},
+	}); err != nil {
+		return fmt.Errorf("failed to update audio book %s: %w", existing.FilePath, err)
+	}
+	fmt.Printf("[AUDIO] Refreshed multi-file book '%s' (%d tracks)\n", existing.Title, len(payload.Tracks))
+	return nil
+}
+
+// processZipAudioBook ingests a zip archive of audio tracks as ONE book.
+// The zip is the item's file (downloadable like any single file);
+// audio_metadata carries layout "zip" and per-entry track paths the
+// streaming endpoint extracts on demand.
+func (s *MediaScanner) processZipAudioBook(ctx context.Context, zipPath string, libraryID pgtype.UUID, rootFolder string) error {
+	entries, err := zipAudioEntries(zipPath)
+	if err != nil {
+		return fmt.Errorf("failed to read audio zip %s: %w", zipPath, err)
+	}
+	if len(entries) == 0 {
+		fmt.Printf("[AUDIO] Skipping %s: zip contains no audio tracks\n", zipPath)
+		return nil
+	}
+
+	zipRel := s.getRelativePath(zipPath)
+	fmt.Printf("[AUDIO] Zip book at %s (%d tracks)\n", zipRel, len(entries))
+
+	// Cheap pass first: central-directory sizes only. The per-entry
+	// extract+ffprobe pass is expensive and skipped when the manifest is
+	// unchanged (see multiFileBookUnchanged).
+	var totalSize int64
+	for _, entry := range entries {
+		totalSize += entry.size
+	}
+
+	existing, existingErr := s.getMediaItemByFilePath(ctx, zipRel, libraryID)
+	if existingErr == nil && !s.forceRescan && multiFileBookUnchanged(existing, totalSize, len(entries)) {
+		return nil
+	}
+
+	probed := make([]audioTrackInfo, 0, len(entries))
+	var firstReport *ffprobeReport
+	for i, entry := range entries {
+		info := audioTrackInfo{
+			relPath: entry.name,
+			title:   cleanTrackTitle(entry.name),
+			size:    entry.size,
+		}
+		report := probeZipEntry(zipPath, entry.name)
+		if report != nil {
+			applyTrackProbe(report, &info)
+			if i == 0 {
+				firstReport = report
+			}
+		}
+		probed = append(probed, info)
+	}
+	orderTracksByTags(probed)
+
+	metadata := s.extractAudioBookMetadata(zipPath, rootFolder, firstReport, "", layoutFallbackTitle("zip", zipPath))
+	if metadata.CoverPath == "" && len(entries) > 0 {
+		// Zip books keep their art as the zip's sibling "<zip>.cover.jpg";
+		// the first entry is temp-extracted for ffmpeg to read.
+		if tmp, cleanup, err := zipEntryToTemp(zipPath, entries[0].name); err == nil {
+			if cover := extractEmbeddedAudioCover(tmp, zipPath); cover != "" {
+				metadata.CoverPath = s.getRelativePath(cover)
+			}
+			cleanup()
+		}
+	}
+	payload := buildMultiFileAudioPayload("zip", metadata.AudioMeta, probed)
+	metadata.AudioMeta = payload
+	if len(payload.Narrators) > 0 && len(metadata.Narrators) == 0 {
+		metadata.Narrators = payload.Narrators
+	}
+	if payload.ASIN != "" && metadata.ASIN == "" {
+		metadata.ASIN = payload.ASIN
+	}
+	metadata.Contributors = utils.NormalizeContributors(metadata.Contributors)
+	metadata.Tags = utils.NormalizeTags(metadata.Tags)
+
+	firstMime := mimeForAudioEntry(entries[0].name)
+	var modTime pgtype.Timestamptz
+	if info, err := os.Stat(zipPath); err == nil {
+		modTime = pgtype.Timestamptz{Time: info.ModTime(), Valid: true}
+	}
+
+	err = existingErr
+	switch {
+	case err == nil:
+		changed := existing.FileSize.Int64 != totalSize || !audioPayloadTracksEqual(existing.AudioMetadata, payload)
+		if changed || s.forceRescan {
+			if err := s.updateAudioBookItem(ctx, existing, payload, firstMime, totalSize, len(payload.Chapters)); err != nil {
+				return err
+			}
+		}
+	case errors.Is(err, pgx.ErrNoRows):
+		created, err := s.createAudioBookItem(ctx, libraryID, metadata, zipRel, totalSize, firstMime, modTime)
+		if err != nil {
+			return fmt.Errorf("failed to create zip book %s: %w", zipRel, err)
+		}
+		if err := s.setAudioFormatGroup(ctx, created.ID, firstMime, len(payload.Chapters)); err != nil {
+			fmt.Printf("Warning: failed to set format group for zip book %s: %v\n", zipRel, err)
+		}
+		fmt.Printf("[AUDIO] Created zip book '%s' (%d tracks) at %s\n", metadata.Title, len(entries), zipRel)
+		s.newItems++
+	default:
+		return fmt.Errorf("failed to check zip book existence %s: %w", zipRel, err)
+	}
+	return nil
+}
+
+// zipAudioEntry is one audio track inside a zip book.
+type zipAudioEntry struct {
+	name string
+	size int64
+}
+
+// zipAudioEntries lists the audio entries of a zip, natural-sorted,
+// skipping directories and macOS/hidden cruft.
+func zipAudioEntries(zipPath string) ([]zipAudioEntry, error) {
+	r, err := zip.OpenReader(zipPath)
+	if err != nil {
+		return nil, err
+	}
+	defer func() { _ = r.Close() }()
+
+	var entries []zipAudioEntry
+	for _, f := range r.File {
+		if f.FileInfo().IsDir() {
+			continue
+		}
+		name := filepath.ToSlash(f.Name)
+		base := strings.ToLower(filepath.Base(name))
+		if strings.HasPrefix(base, ".") || strings.Contains(name, "__MACOSX") {
+			continue
+		}
+		if !isAudioFile(name) {
+			continue
+		}
+		entries = append(entries, zipAudioEntry{name: name, size: int64(f.UncompressedSize64)})
+	}
+	sort.Slice(entries, func(x, y int) bool { return naturalLess(entries[x].name, entries[y].name) })
+	return entries, nil
+}
+
+// zipEntryToTemp extracts one zip entry to a temp file (seekable input
+// for ffprobe/ffmpeg). The caller MUST run the returned cleanup.
+func zipEntryToTemp(zipPath, entryName string) (string, func(), error) {
+	r, err := zip.OpenReader(zipPath)
+	if err != nil {
+		return "", nil, err
+	}
+
+	var entry *zip.File
+	for _, f := range r.File {
+		if filepath.ToSlash(f.Name) == filepath.ToSlash(entryName) {
+			entry = f
+			break
+		}
+	}
+	if entry == nil {
+		_ = r.Close()
+		return "", nil, fmt.Errorf("entry %q not found", entryName)
+	}
+
+	src, err := entry.Open()
+	if err != nil {
+		_ = r.Close()
+		return "", nil, err
+	}
+
+	tmp, err := os.CreateTemp("", "bookhoard-zipentry-*"+filepath.Ext(entryName))
+	if err != nil {
+		_ = src.Close()
+		_ = r.Close()
+		return "", nil, err
+	}
+	if _, err := io.Copy(tmp, src); err != nil {
+		_ = tmp.Close()
+		_ = src.Close()
+		_ = r.Close()
+		_ = os.Remove(tmp.Name())
+		return "", nil, err
+	}
+	if err := tmp.Close(); err != nil {
+		_ = src.Close()
+		_ = r.Close()
+		_ = os.Remove(tmp.Name())
+		return "", nil, err
+	}
+	_ = src.Close()
+	tmpName := tmp.Name()
+	cleanup := func() {
+		_ = r.Close()
+		_ = os.Remove(tmpName)
+	}
+	return tmpName, cleanup, nil
+}
+
+// probeZipEntry ffprobes one zip entry by extracting it to a temp file
+// (ffprobe wants a seekable path). The temp file is always removed.
+func probeZipEntry(zipPath, entryName string) *ffprobeReport {
+	tmp, cleanup, err := zipEntryToTemp(zipPath, entryName)
+	if err != nil {
+		fmt.Printf("Warning: zip entry probe failed for %s/%s: %v\n", zipPath, entryName, err)
+		return nil
+	}
+	defer cleanup()
+	return runFFProbe(tmp)
+}
+
+// mimeForAudioEntry maps an in-zip track name to its mime type.
+func mimeForAudioEntry(name string) string {
+	if m := MimeTypes[strings.ToLower(filepath.Ext(name))]; m != "" {
+		return m
+	}
+	return "audio/mpeg"
+}
diff --git a/internal/services/media_scanner_audio_multifile_test.go b/internal/services/media_scanner_audio_multifile_test.go
new file mode 100644
index 00000000..bcb99b2b
--- /dev/null
+++ b/internal/services/media_scanner_audio_multifile_test.go
@@ -0,0 +1,203 @@
+package services
+
+// Unit tests for the multi-file audiobook grouping/manifest helpers
+// (media_scanner_audio_multifile.go). Pure filesystem logic — no DB.
+
+import (
+	"archive/zip"
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestNaturalLess(t *testing.T) {
+	cases := []struct {
+		a, b string
+		less bool
+	}{
+		{"01 Track.mp3", "02 Track.mp3", true},
+		{"02 Track.mp3", "10 Track.mp3", true}, // numeric, not lexicographic
+		{"10 Track.mp3", "9 Track.mp3", false},
+		{"Track 2", "Track 10", true},
+		{"abc", "abd", true},
+		{"01", "1", false}, // leading zeros compare equal → strict-less false
+		{"a1b", "a1c", true},
+		{"Disc 1", "Disc 2", true},
+	}
+	for _, tc := range cases {
+		if got := naturalLess(tc.a, tc.b); got != tc.less {
+			t.Errorf("naturalLess(%q, %q) = %v, want %v", tc.a, tc.b, got, tc.less)
+		}
+	}
+}
+
+func TestSortTracksNatural(t *testing.T) {
+	in := []string{"/x/10.mp3", "/x/2.mp3", "/x/1.mp3"}
+	sortTracksNatural(in)
+	want := []string{"/x/1.mp3", "/x/2.mp3", "/x/10.mp3"}
+	for i := range want {
+		if in[i] != want[i] {
+			t.Fatalf("sorted = %v, want %v", in, want)
+		}
+	}
+}
+
+// writeDummyTrack creates a file with plausible audio bytes (never probed
+// in these tests — only structure matters).
+func writeDummyTrack(t *testing.T, path string) {
+	t.Helper()
+	if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(path, []byte("ID3 fake audio bytes"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestBookRootForTrackFile(t *testing.T) {
+	root := t.TempDir()
+
+	// Layout:
+	//   root/Author/Title/01.mp3, 02.mp3            → one book at Title
+	//   root/Author/Parts/CD1/01.mp3, CD2/01.mp3    → one book at Parts
+	//   root/Author/Lone/book.mp3                    → no folder book
+	writeDummyTrack(t, filepath.Join(root, "Author", "Title", "01.mp3"))
+	writeDummyTrack(t, filepath.Join(root, "Author", "Title", "02.mp3"))
+	writeDummyTrack(t, filepath.Join(root, "Author", "Parts", "CD1", "01.mp3"))
+	writeDummyTrack(t, filepath.Join(root, "Author", "Parts", "CD2", "01.mp3"))
+	writeDummyTrack(t, filepath.Join(root, "Author", "Lone", "book.mp3"))
+
+	t.Run("simple track folder", func(t *testing.T) {
+		got, tracks, ok := bookRootForTrackFile(filepath.Join(root, "Author", "Title", "02.mp3"), root)
+		if !ok {
+			t.Fatalf("expected folder book, got none")
+		}
+		if got != filepath.Join(root, "Author", "Title") {
+			t.Fatalf("root = %q", got)
+		}
+		if len(tracks) != 2 {
+			t.Fatalf("tracks = %v", tracks)
+		}
+	})
+
+	t.Run("disc folders merge into parent", func(t *testing.T) {
+		got, tracks, ok := bookRootForTrackFile(filepath.Join(root, "Author", "Parts", "CD1", "01.mp3"), root)
+		if !ok {
+			t.Fatalf("expected folder book")
+		}
+		if got != filepath.Join(root, "Author", "Parts") {
+			t.Fatalf("root = %q (disc folders must merge up)", got)
+		}
+		if len(tracks) != 2 {
+			t.Fatalf("tracks = %v", tracks)
+		}
+	})
+
+	t.Run("lone file is not a folder book", func(t *testing.T) {
+		_, _, ok := bookRootForTrackFile(filepath.Join(root, "Author", "Lone", "book.mp3"), root)
+		if ok {
+			t.Fatalf("single track must not form a folder book")
+		}
+	})
+
+	t.Run("sibling books never merge at author level", func(t *testing.T) {
+		writeDummyTrack(t, filepath.Join(root, "Author", "BookB", "01.mp3"))
+		writeDummyTrack(t, filepath.Join(root, "Author", "BookB", "02.mp3"))
+		got, _, ok := bookRootForTrackFile(filepath.Join(root, "Author", "Title", "01.mp3"), root)
+		if !ok || got != filepath.Join(root, "Author", "Title") {
+			t.Fatalf("root = %q, ok = %v; Title/BookB must stay separate", got, ok)
+		}
+	})
+}
+
+func TestBuildMultiFileAudioPayload(t *testing.T) {
+	tracks := []audioTrackInfo{
+		{relPath: "Author/Title/01.mp3", title: "Chapter One", duration: 100, size: 10},
+		{relPath: "Author/Title/02.mp3", title: "Chapter Two", duration: 50, size: 5},
+	}
+	payload := buildMultiFileAudioPayload("folder", nil, tracks)
+	if payload.Layout != "folder" {
+		t.Fatalf("layout = %q", payload.Layout)
+	}
+	if payload.DurationSeconds != 150 {
+		t.Fatalf("duration = %v", payload.DurationSeconds)
+	}
+	if len(payload.Tracks) != 2 {
+		t.Fatalf("tracks = %d", len(payload.Tracks))
+	}
+	if payload.Tracks[1].Start != 100 || payload.Tracks[1].End != 150 {
+		t.Fatalf("cumulative bounds wrong: %+v", payload.Tracks[1])
+	}
+	// No sidecar chapters: tracks ARE the chapters.
+	if len(payload.Chapters) != 2 || payload.Chapters[0].Start != 0 || payload.Chapters[1].Start != 100 {
+		t.Fatalf("chapters = %+v", payload.Chapters)
+	}
+
+	// Curated sidecar chapters keep priority; tracks still carry bounds.
+	sidecar := &AudioMetadataPayload{
+		Chapters: []AudioChapter{{Index: 0, Title: "Part I", Start: 0, End: 150}},
+	}
+	payload2 := buildMultiFileAudioPayload("zip", sidecar, tracks)
+	if len(payload2.Chapters) != 1 || payload2.Chapters[0].Title != "Part I" {
+		t.Fatalf("sidecar chapters must win: %+v", payload2.Chapters)
+	}
+	if len(payload2.Tracks) != 2 {
+		t.Fatalf("tracks lost: %+v", payload2.Tracks)
+	}
+}
+
+func TestZipAudioEntries(t *testing.T) {
+	zipPath := filepath.Join(t.TempDir(), "book.zip")
+	f, err := os.Create(zipPath)
+	if err != nil {
+		t.Fatal(err)
+	}
+	w := zip.NewWriter(f)
+	for _, name := range []string{
+		"__MACOSX/._junk.mp3",
+		".hidden.mp3",
+		"02 second.mp3",
+		"10 tenth.mp3",
+		"01 first.mp3",
+		"cover.jpg",
+		"notes.txt",
+	} {
+		if _, err := w.Create(name); err != nil {
+			t.Fatal(err)
+		}
+	}
+	if err := w.Close(); err != nil {
+		t.Fatal(err)
+	}
+	_ = f.Close()
+
+	entries, err := zipAudioEntries(zipPath)
+	if err != nil {
+		t.Fatal(err)
+	}
+	want := []string{"01 first.mp3", "02 second.mp3", "10 tenth.mp3"}
+	if len(entries) != len(want) {
+		t.Fatalf("entries = %v", entries)
+	}
+	for i, e := range entries {
+		if e.name != want[i] {
+			t.Fatalf("entry[%d] = %q, want %q", i, e.name, want[i])
+		}
+	}
+}
+
+func TestCleanTrackTitle(t *testing.T) {
+	cases := map[string]string{
+		"/x/01_Genesis001.mp3": "Genesis001",
+		"/x/01 - Track.mp3":    "Track",
+		"/x/12_.Intro.mp3":     "Intro",
+		"/x/Chapter 3.mp3":     "Chapter 3",
+		"/x/JustTitle.m4b":     "JustTitle",
+		"/x/01.mp3":            "01", // number-only name: number stays the title
+	}
+	for in, want := range cases {
+		if got := cleanTrackTitle(in); got != want {
+			t.Errorf("cleanTrackTitle(%q) = %q, want %q", in, got, want)
+		}
+	}
+}
diff --git a/internal/sync/format.go b/internal/sync/format.go
index ecd8a830..97e5e3a9 100644
--- a/internal/sync/format.go
+++ b/internal/sync/format.go
@@ -12,6 +12,7 @@ const (
 	FormatGroupReflowable   FormatGroup = "reflowable"
 	FormatGroupFixedLayout  FormatGroup = "fixed_layout"
 	FormatGroupComicArchive FormatGroup = "comic_archive"
+	FormatGroupAudiobook    FormatGroup = "audiobook"
 	FormatGroupUnknown      FormatGroup = "unknown"
 )
 
diff --git a/internal/sync/progress.go b/internal/sync/progress.go
index cd1e533d..4610e000 100644
--- a/internal/sync/progress.go
+++ b/internal/sync/progress.go
@@ -87,6 +87,15 @@ func ConvertProgress(sourceFormat, targetFormat FormatGroup, sourceData map[stri
 			result["panel"] = panel
 		}
 
+	case FormatGroupAudiobook:
+		// Audio progress is percentage + global seconds; there is no page
+		// grid to re-derive, so the percentage carries across as-is and
+		// the second-based locator follows when present.
+		result["percentage"] = percentage
+		if offset, ok := sourceData["audio_offset_seconds"].(int); ok {
+			result["audio_offset_seconds"] = offset
+		}
+
 	default:
 		return nil, fmt.Errorf("unsupported target format: %s", targetFormat)
 	}
@@ -108,7 +117,7 @@ func extractPercentage(sourceFormat FormatGroup, sourceData map[string]interface
 			}
 		}
 
-	case FormatGroupFixedLayout, FormatGroupComicArchive:
+	case FormatGroupFixedLayout, FormatGroupComicArchive, FormatGroupAudiobook:
 		if page, ok := sourceData["page"].(int); ok {
 			if total, ok := sourceData["total_pages"].(int); ok && total > 0 {
 				return float64(page) / float64(total)