feat(audiobooks): Batch A — foundation, m4b ingest, playback sync, web player

Phase 1 (foundation): 'audiobooks' library type seeded (schema + DB);
audio_metadata JSONB on media_items (the kobo_metadata precedent —
only audio paths read it); reading_progress.audio_offset_seconds for
the honest {chapter, offset} locator; extensions/mimes registered for
ALL breadth formats (m4b/m4a/mp3/flac — deliberate per the DOC/LIT
doctrine, m4b scans richly first); classifyFormatGroup 'audiobook'
case (gotcha 39 recomputes on rescan); Go mime table extended at boot
so media elements accept the streams; ffmpeg/ffprobe in the image
(8.1.2 — also the xHE-AAC identification tripwire).

Phase 2 (ingest): sidecar-first (Libation/ABS metadata.json —
narrators/ASIN/curated chapters), ffprobe fallback/filler (duration,
bitrate, codec/profile, embedded chapters). Fixed three real
parser brittlenesses the Libation sidecar exposed: series accepts
string OR array-of-objects, publishedYear accepts number OR string,
ffprobe chapter timings accept number OR string (flexFloat). Folder-
structure fallback now runs on the UPDATE path too (rescans were
clearing sidecar-absent series/author); audio facts re-derive on
every rescan (gotcha 39).

Phase 3 (playback + sync): GET /api/media-items/:id/chapters (the
format-abstraction list); streaming rides the existing cookie-authed
Range /uploads path; PUT progress carries audio_offset_seconds +
elapsed_seconds (honest wall-clock playing time) — the reading-
history capture prefers player-reported elapsed over the inter-push
delta, same 2h ceiling; reading_mode='audio' marks the row.

Phase 4 (web player): dedicated audio reader page (foliate not
involved) — cover, chapter title, whole-book scrubber, skip ± (chips
1/5/10/15/30s, default 10s), speed (0.75×–2×), chapter list with
jump-to, Media Session lockscreen/notification transport, periodic
playing-only progress pushes, position restore on open.

Verified live: ingest of the Libation sample (Gardens of the Moon —
title/author/series/cover/date from sidecar+folders, 34 chapters,
26h duration, aac/LC); chapters endpoint; the reader route serving
the player; playback with position restore (0:57 round-trip);
progress rows in audio mode; wall-clock session rows in
reading_history.

internal/handlers/media.go

@@ -1237,7 +1237,6 @@ func (mh *MediaHandler) UpdateMediaReadingProgress(c *echo.Context) error {
 		}
 	}
 
-
 	var req struct {
 		CurrentPage     *int32   `json:"current_page"`
 		TotalPages      *int32   `json:"total_pages"`
@@ -1251,6 +1250,11 @@ func (mh *MediaHandler) UpdateMediaReadingProgress(c *echo.Context) error {
 		ZoomLevel       *float64 `json:"zoom_level"`
 		ScrollX         *float64 `json:"scroll_position_x"`
 		ScrollY         *float64 `json:"scroll_position_y"`
+		// Audiobook locator: seconds into the current chapter
+		AudioOffsetSeconds *int `json:"audio_offset_seconds"`
+		// Honest wall-clock playing seconds since the last push (audio
+		// pushes fire while playing; pauses don't count)
+		ElapsedSeconds *int32 `json:"elapsed_seconds"`
 	}
 	if err := c.Bind(&req); err != nil {
 		return c.JSON(http.StatusBadRequest, map[string]string{"error": "invalid request"})
@@ -1258,25 +1262,27 @@ func (mh *MediaHandler) UpdateMediaReadingProgress(c *echo.Context) error {
 
 	if mh.progressSvc != nil {
 		saveReq := wsync.SaveProgressRequest{
-			MediaItemID:     pgtype.UUID{Bytes: mediaUUID, Valid: true},
-			UserID:          pgtype.UUID{Bytes: userUUID, Valid: true},
-			Source:          deviceSource,
-			DeviceID:        deviceID,
-			DeviceType:      deviceType,
-			DeviceName:      deviceLabel,
-			Percentage:      req.Percentage,
-			Epubcfi:         req.Epubcfi,
-			ContextText:     req.ContextText,
-			CharacterOffset: req.CharacterOffset,
-			Chapter:         req.Chapter,
-			ChapterProgress: req.ChapterProgress,
-			CurrentPage:     nil,
-			TotalPages:      nil,
-			ZoomLevel:       req.ZoomLevel,
-			ScrollX:         req.ScrollX,
-			ScrollY:         req.ScrollY,
-			ReadingMode:     req.ReadingMode,
-			Broadcast:       true,
+			MediaItemID:         pgtype.UUID{Bytes: mediaUUID, Valid: true},
+			UserID:              pgtype.UUID{Bytes: userUUID, Valid: true},
+			Source:              deviceSource,
+			DeviceID:            deviceID,
+			DeviceType:          deviceType,
+			DeviceName:          deviceLabel,
+			Percentage:          req.Percentage,
+			Epubcfi:             req.Epubcfi,
+			ContextText:         req.ContextText,
+			CharacterOffset:     req.CharacterOffset,
+			Chapter:             req.Chapter,
+			ChapterProgress:     req.ChapterProgress,
+			AudioOffsetSeconds:  req.AudioOffsetSeconds,
+			AudioElapsedSeconds: req.ElapsedSeconds,
+			CurrentPage:         nil,
+			TotalPages:          nil,
+			ZoomLevel:           req.ZoomLevel,
+			ScrollX:             req.ScrollX,
+			ScrollY:             req.ScrollY,
+			ReadingMode:         req.ReadingMode,
+			Broadcast:           true,
 		}
 		if req.CurrentPage != nil {
 			cp := int(*req.CurrentPage)
@@ -2759,3 +2765,35 @@ func (mh *MediaHandler) saveCoverImage(c echo.Context, mediaUUID uuid.UUID, file
 
 	return coverRelPath, nil
 }
+
+// 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.
+func (mh *MediaHandler) GetAudioChapters(c *echo.Context) error {
+	mediaID := c.Param("id")
+	mediaUUID, err := uuid.Parse(mediaID)
+	if err != nil {
+		return c.JSON(http.StatusBadRequest, map[string]string{"error": "invalid media item id"})
+	}
+
+	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"})
+	}
+
+	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"})
+		}
+	}
+
+	return c.JSON(http.StatusOK, map[string]interface{}{
+		"media_item_id":    item.ID,
+		"chapters":         payload.Chapters,
+		"duration_seconds": payload.DurationSeconds,
+		"codec_profile":    payload.CodecProfile,
+	})
+}