feat(ui): add Rescan button to Edit Metadata dialog

Adds a Rescan button to the MetadataEditorModal footer that POSTs to the
new per-book rescan endpoint, with rescanning state (disabled + spinner,
matching the existing Mark Read pattern), success/error toasts, and a
page reload to pick up the refreshed cover and metadata.

Dockerfile

@@ -43,7 +43,7 @@ RUN --mount=type=cache,target=/root/go/pkg/mod \
 # 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
+RUN apk --no-cache add ca-certificates curl poppler-utils
 
 WORKDIR /app
 
@@ -65,7 +65,7 @@ CMD ["go", "test", "./cmd/server/tests", "-v", "-timeout", "5m", "-parallel=1",
 # Final stage
 FROM alpine:latest
 
-RUN apk --no-cache add ca-certificates curl
+RUN apk --no-cache add ca-certificates curl poppler-utils
 
 # Install kepubify for EPUB→KEPUB conversion
 RUN wget -O /usr/bin/kepubify https://github.com/pgaskin/kepubify/releases/latest/download/kepubify-linux-64bit \

bruno/media-items/Rescan Media Item.yml

@@ -0,0 +1,35 @@
+info:
+  name: Rescan Media Item
+  type: http
+  seq: 9
+
+http:
+  method: POST
+  url: "{{base_url}}/api/media-items/{{media_item_id}}/rescan"
+  headers:
+    - name: ""
+      value: application/json
+  auth: inherit
+
+runtime:
+  scripts:
+    - type: tests
+      code: |-
+        test_rescan_media_item_success(status, headers, body) {
+            if (status !== 200) {
+              throw new Error("Expected status 200, got " + status);
+
+settings:
+  encodeUrl: true
+  timeout: 0
+  followRedirects: true
+  maxRedirects: 5
+
+docs: |-
+  ## Rescan Media Item
+
+    Re-extracts metadata and cover art for a single media item from the file on disk.
+
+    **Method:** POST
+
+    **Endpoint:** /api/media-items/{id}/rescan

internal/handlers/koreader.go

@@ -81,28 +81,39 @@ func (h *KOReaderHandler) loadAnnotationEpub(ctx context.Context, mediaItemID pg
 
 // convertHighlightPositions resolves a device annotation's pos0/pos1
 // locators to canonical CFIs through the shared facade. contextText is the
-// selection's own text — the ideal anchor for the converter's verification
-// and text-search rungs. percentage anchors the last-resort fallback so a
-// failed conversion degrades to the neighborhood of the true position
-// rather than the document start.
+// selection's own text — a quote of the document, so the converter can
+// verify structural landings against it and, when it must search, anchor a
+// range end that spans block boundaries. percentage anchors the
+// last-resort fallback. Only structural/exact landings are returned: a
+// low-confidence conversion yields "" so an echo preserves the row's
+// existing web CFIs (applyLWW coalesces empty) instead of clobbering them
+// with a guess, and a new device highlight paints nowhere rather than in
+// the wrong place.
 func (h *KOReaderHandler) convertHighlightPositions(ec annotationEpub, pos0, pos1, contextText string, percentage float64) (string, string) {
 	if pos0 == "" || !ec.convertible() {
 		return "", ""
 	}
 	startLoc := wsync.ConvertToCanonical(wsync.LocatorSourceKOReader, pos0, percentage, contextText, ec.mediaItem.FormatGroup, ec.epubPath, "")
-	endLoc := wsync.ConvertToCanonical(wsync.LocatorSourceKOReader, pos1, percentage, "", ec.mediaItem.FormatGroup, ec.epubPath, "")
-	endCFI := endLoc.CFI
-	// The end conversion carries no context text, so unless it resolved
-	// exactly it degenerates to a percentage fallback anchored at the
-	// document start — useless as a range end. When the START resolved
-	// structurally/exactly, derive the end from it: same node, character
-	// offset advanced by the selection's UTF-16 length (the CFI offset
-	// unit).
-	if endLoc.Precision != "exact" && endLoc.Precision != "structural" &&
-		(startLoc.Precision == "exact" || startLoc.Precision == "structural") && contextText != "" {
-		endCFI = extendCFIByLength(startLoc.CFI, contextText)
+	startCFI := webUsableCFI(startLoc)
+	endCFI := ""
+	// A text-search start matched the selection text itself: its extent
+	// is the selection's true end, even across blocks.
+	if startCFI != "" && startLoc.EndCFI != "" {
+		endCFI = startLoc.EndCFI
 	}
-	return startLoc.CFI, endCFI
+	if endCFI == "" && pos1 != "" {
+		endLoc := wsync.ConvertToCanonical(wsync.LocatorSourceKOReader, pos1, percentage, "", ec.mediaItem.FormatGroup, ec.epubPath, "")
+		endCFI = webUsableCFI(endLoc)
+	}
+	// The end conversion carries no context text; when neither resolved
+	// confidently, derive the end from the start advanced by the
+	// selection's UTF-16 length (the CFI offset unit). Multi-node
+	// selections produce an out-of-range offset — harmless: resolution
+	// clamps or fails, and consumers fall back to the start.
+	if endCFI == "" && startCFI != "" && contextText != "" {
+		endCFI = extendCFIByLength(startCFI, contextText)
+	}
+	return startCFI, endCFI
 }
 
 // convertBookmarkPosition resolves a device bookmark's locator to the
@@ -866,10 +877,26 @@ func (h *KOReaderHandler) updateProgressForBook(c *echo.Context, deviceID pgtype
 					contextText = *book.ContextText
 				}
 				loc := wsync.ConvertToCanonical(wsync.LocatorSourceKOReader, *epubcfi, pct, contextText, ec.mediaItem.FormatGroup, ec.epubPath, "")
-				if loc.CFI != "" && loc.CFI != *epubcfi {
+				switch {
+				case strings.HasPrefix(loc.CFI, "epubcfi(") &&
+					(loc.Precision == "structural" || loc.Precision == "exact"):
 					converted := loc.CFI
 					epubcfi = &converted
 					log.Printf("Bookhoard: CRE→CFI converted progress (%s) to %s", loc.Precision, converted)
+				case loc.CFI != "" && loc.CFI != *epubcfi &&
+					(loc.Precision == "element" || loc.Precision == "section"):
+					// Fragment-ID positions resolve to a section href: keep
+					// serving it (legacy behavior).
+					converted := loc.CFI
+					epubcfi = &converted
+					log.Printf("Bookhoard: CRE→CFI converted progress (%s) to href %s", loc.Precision, converted)
+				default:
+					// Low-confidence (percentage/fallback): store no
+					// canonical locator — the row's percentage restores
+					// approximately instead of a confidently-wrong CFI,
+					// and the device keeps its own native position.
+					log.Printf("Bookhoard: CRE→CFI conversion low-confidence (%s) for %s; storing percentage only", loc.Precision, *epubcfi)
+					epubcfi = nil
 				}
 			}
 		}

internal/handlers/media.go

@@ -1309,6 +1309,42 @@ func (mh *MediaHandler) UpdateMediaItem(c *echo.Context) error {
 	return c.JSON(http.StatusOK, item)
 }
 
+// RescanMediaItem handles POST /api/media-items/:id/rescan (admin only)
+func (mh *MediaHandler) RescanMediaItem(c *echo.Context) error {
+	user := MustGetAuthenticatedUser(c)
+
+	if user.Role != "admin" {
+		return c.JSON(http.StatusForbidden, map[string]string{"error": "admin access required"})
+	}
+
+	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"})
+	}
+
+	if _, err := mh.db.GetMediaItem(c.Request().Context(), pgtype.UUID{Bytes: mediaUUID, Valid: true}); err != nil {
+		if errors.Is(err, pgx.ErrNoRows) {
+			return c.JSON(http.StatusNotFound, map[string]string{"error": "media item not found"})
+		}
+		return c.JSON(http.StatusInternalServerError, map[string]string{"error": err.Error()})
+	}
+
+	scanner := services.NewMediaScanner(mh.db)
+	defer scanner.Close()
+
+	if err := scanner.RescanMediaItem(c.Request().Context(), pgtype.UUID{Bytes: mediaUUID, Valid: true}); err != nil {
+		return c.JSON(http.StatusInternalServerError, map[string]string{"error": err.Error()})
+	}
+
+	item, err := mh.db.GetMediaItem(c.Request().Context(), pgtype.UUID{Bytes: mediaUUID, Valid: true})
+	if err != nil {
+		return c.JSON(http.StatusInternalServerError, map[string]string{"error": err.Error()})
+	}
+
+	return c.JSON(http.StatusOK, item)
+}
+
 // DeleteMediaItem handles DELETE /api/media-items/:id (admin only)
 func (mh *MediaHandler) DeleteMediaItem(c *echo.Context) error {
 	user := MustGetAuthenticatedUser(c)
@@ -1656,6 +1692,11 @@ func (mh *MediaHandler) UpdateMediaHighlight(c *echo.Context) error {
 			ChapterReference: req.ChapterReference,
 			Source:           "web",
 			ModifiedAt:       time.Now(),
+			// The PUT targets this exact row (from the URL): identity must
+			// not be re-derived from content — a device echo has usually
+			// rewritten the stored CFI to point shape, so the computed key
+			// would miss and mint a duplicate beside the edited row.
+			HighlightID: pgtype.UUID{Bytes: highlightUUID, Valid: true},
 		})
 		if err != nil {
 			return c.JSON(http.StatusInternalServerError, map[string]string{"error": err.Error()})

internal/router/media.go

@@ -60,6 +60,7 @@ func registerMediaRoutes(cfg *Config) {
 	// Admin-only media routes
 	admin.POST("/media-items", cfg.MediaHandler.CreateMediaItem)
 	admin.PUT("/media-items/:id", cfg.MediaHandler.UpdateMediaItem)
+	admin.POST("/media-items/:id/rescan", cfg.MediaHandler.RescanMediaItem)
 	admin.DELETE("/media-items/:id", cfg.MediaHandler.DeleteMediaItem)
 
 	// Shelf management (protected)

internal/router/reader.go

@@ -1,18 +1,15 @@
 package router
 
 import (
-	"bookhoard/internal/database"
 	"bookhoard/internal/handlers"
 	"bookhoard/internal/services"
 	"bookhoard/internal/sync"
 	"bookhoard/internal/utils"
 	"bookhoard/templates"
 	"bytes"
-	"errors"
 	"net/http"
 
 	"github.com/google/uuid"
-	"github.com/jackc/pgx/v5"
 	"github.com/jackc/pgx/v5/pgtype"
 	"github.com/labstack/echo/v5"
 )
@@ -69,21 +66,10 @@ func registerReaderRoutes(cfg *Config) {
 		if !visible {
 			return renderErrorPage(c, "Access denied", "access_denied")
 		}
-		// Get reading progress
-		var progress database.ReadingProgress
-		progress, err = cfg.Queries.GetReadingProgress(c.Request().Context(), database.GetReadingProgressParams{
-			MediaItemID: pgtype.UUID{Bytes: parsedUUID, Valid: true},
-			UserID:      uuidToPGType(userUUID),
-		})
-		if err != nil && !errors.Is(err, pgx.ErrNoRows) {
-			progress = database.ReadingProgress{}
-		}
-		// Get bookmarks
-		bookmarks, _ := cfg.Queries.GetMediaBookmarks(c.Request().Context(), database.GetMediaBookmarksParams{
-			MediaItemID: pgtype.UUID{Bytes: parsedUUID, Valid: true},
-			UserID:      uuidToPGType(userUUID),
-		})
-		// Convert to template types
+		// Convert to template types. Reading state is deliberately NOT
+		// fetched or embedded: the reader pulls position, bookmarks, and
+		// annotations from the APIs at open time so the page can never
+		// carry (nor write back) a stale snapshot.
 		mediaUUID, _ := uuid.FromBytes(mediaItem.ID.Bytes[0:16])
 		libUUID, _ := uuid.FromBytes(mediaItem.LibraryID.Bytes[0:16])
 		metadata := templates.ReaderMetadata{
@@ -104,58 +90,9 @@ func registerReaderRoutes(cfg *Config) {
 			TotalCharacters:  mediaItem.TotalCharacters.Int64,
 			EstimatedPages:   sync.EstimatedPages(mediaItem.TotalCharacters.Int64),
 		}
-		// Progress conversion (inline)
-		progressUUID, _ := uuid.FromBytes(progress.ID.Bytes[0:16])
-		progressMediaUUID, _ := uuid.FromBytes(progress.MediaItemID.Bytes[0:16])
-		progressUserUUID, _ := uuid.FromBytes(progress.UserID.Bytes[0:16])
-		templateProgress := templates.ReadingProgress{
-			ID:              progressUUID.String(),
-			MediaItemID:     progressMediaUUID.String(),
-			UserID:          progressUserUUID.String(),
-			CurrentPage:     int(progress.CurrentPage.Int32),
-			TotalPages:      int(progress.TotalPages.Int32),
-			Percentage:      progress.Percentage.Float64 * 100,
-			EpubCfi:         textToString(progress.Epubcfi),
-			LastReadAt:      progress.LastReadAt.Time,
-			Chapter:         int(progress.Chapter.Int32),
-			ChapterProgress: progress.ChapterProgress.Float64 * 100,
-			FormatGroup:     mediaItem.FormatGroup,
-		}
-		// Bookmarks conversion (inline, with loop)
-		templateBookmarks := make([]templates.Bookmark, len(bookmarks))
-		for i, b := range bookmarks {
-			bookmarkUUID, _ := uuid.FromBytes(b.ID.Bytes[0:16])
-			bookmarkMediaUUID, _ := uuid.FromBytes(b.MediaItemID.Bytes[0:16])
-			bookmarkUserUUID, _ := uuid.FromBytes(b.UserID.Bytes[0:16])
-
-			var pageNumber *int
-			if b.PageNumber.Valid {
-				val := int(b.PageNumber.Int32)
-				pageNumber = &val
-			}
-
-			var chapterNumber *int
-			if b.ChapterNumber.Valid {
-				val := int(b.ChapterNumber.Int32)
-				chapterNumber = &val
-			}
-
-			templateBookmarks[i] = templates.Bookmark{
-				ID:            bookmarkUUID.String(),
-				MediaItemID:   bookmarkMediaUUID.String(),
-				UserID:        bookmarkUserUUID.String(),
-				PageNumber:    pageNumber,
-				ChapterNumber: chapterNumber,
-				CfiPosition:   textToString(b.CfiPosition),
-				Title:         b.Title,
-				Position:      textToString(b.Position),
-				Notes:         textToString(b.Notes),
-				CreatedAt:     b.CreatedAt.Time,
-			}
-		}
-		// 8. Render template
+		// Render template
 		var buf bytes.Buffer
-		err = templates.Reader(user, metadata, templateProgress, templateBookmarks).Render(c.Request().Context(), &buf)
+		err = templates.Reader(user, metadata).Render(c.Request().Context(), &buf)
 		if err != nil {
 			return renderErrorPage(c, "Error rendering reader", "render_error")
 		}

internal/services/media_scanner.go

@@ -23,6 +23,7 @@ import (
 	"io"
 	"io/fs"
 	"os"
+	"os/exec"
 	"path/filepath"
 	"regexp"
 	"strconv"
@@ -2078,17 +2079,10 @@ func (s *MediaScanner) extractPDFCover(pdfPath string) (string, error) {
 	// Use pdfcpu API to extract images from first page
 	// ExtractImagesFile(inFile, outDir string, selectedPages []string, conf *model.Configuration) error
 	err = pdfcpuapi.ExtractImagesFile(pdfPath, tmpDir, []string{"1"}, nil)
-	if err != nil {
-		// No images found or extraction failed - this is OK, just return empty
-		return "", nil
-	}
-
+	if err == nil {
 		// Check for extracted images in the temp directory
 		entries, err := os.ReadDir(tmpDir)
-	if err != nil || len(entries) == 0 {
-		return "", nil
-	}
-
+		if err == nil && len(entries) > 0 {
 			// Find the largest image (likely the cover)
 			var largestImage string
 			var largestSize int64
@@ -2111,16 +2105,10 @@ func (s *MediaScanner) extractPDFCover(pdfPath string) (string, error) {
 				}
 			}
 
-	if largestImage == "" {
-		return "", nil
-	}
-
+			if largestImage != "" {
 				// Read the image
 				imageData, err := os.ReadFile(largestImage)
-	if err != nil || len(imageData) == 0 {
-		return "", nil
-	}
-
+				if err == nil && len(imageData) > 0 {
 					// Save cover to disk (same pattern as comics: {pdf_path}.cover.jpg)
 					coverPath := pdfPath + ".cover.jpg"
 					if err := os.WriteFile(coverPath, imageData, 0644); err != nil {
@@ -2128,6 +2116,57 @@ func (s *MediaScanner) extractPDFCover(pdfPath string) (string, error) {
 					}
 
 					return coverPath, nil
+				}
+			}
+		}
+	}
+
+	// No embedded raster cover found (e.g. vector/text first page) - fall back
+	// to rendering the first page with pdftoppm (poppler-utils).
+	return s.renderPDFCoverPage(pdfPath), nil
+}
+
+// renderPDFCoverPage renders the first page of a PDF file to a JPEG image
+// using pdftoppm. It saves the cover next to the PDF ({pdf_path}.cover.jpg).
+// Returns the path to the saved cover, or empty string if rendering failed.
+func (s *MediaScanner) renderPDFCoverPage(pdfPath string) string {
+	if _, err := exec.LookPath("pdftoppm"); err != nil {
+		fmt.Printf("Warning: pdftoppm not available, skipping PDF cover render for %s\n", pdfPath)
+		return ""
+	}
+
+	tmpDir, err := os.MkdirTemp("", "pdf-render-")
+	if err != nil {
+		fmt.Printf("Warning: failed to create temp dir for PDF cover render %s: %v\n", pdfPath, err)
+		return ""
+	}
+	defer func() {
+		if err := os.RemoveAll(tmpDir); err != nil {
+			fmt.Printf("Warning: failed to remove temp directory %s: %v\n", tmpDir, err)
+		}
+	}()
+
+	outPrefix := filepath.Join(tmpDir, "cover")
+	cmd := exec.Command("pdftoppm", "-jpeg", "-f", "1", "-l", "1", "-singlefile", "-r", "150", pdfPath, outPrefix)
+	if output, err := cmd.CombinedOutput(); err != nil {
+		fmt.Printf("Warning: failed to render PDF cover from %s: %v, output: %s\n", pdfPath, err, string(output))
+		return ""
+	}
+
+	imageData, err := os.ReadFile(outPrefix + ".jpg")
+	if err != nil || len(imageData) < 1000 {
+		fmt.Printf("Warning: PDF cover render produced no usable image for %s\n", pdfPath)
+		return ""
+	}
+
+	// Save cover to disk (same pattern as comics: {pdf_path}.cover.jpg)
+	coverPath := pdfPath + ".cover.jpg"
+	if err := os.WriteFile(coverPath, imageData, 0644); err != nil {
+		fmt.Printf("Warning: failed to write rendered PDF cover for %s: %v\n", pdfPath, err)
+		return ""
+	}
+
+	return coverPath
 }
 
 // ComicInfo represents metadata from ComicInfo.xml
@@ -2618,6 +2657,51 @@ func (s *MediaScanner) updateMediaItem(ctx context.Context, mediaItemID pgtype.U
 	return err
 }
 
+// RescanMediaItem re-extracts metadata for a single media item and updates it.
+// It is the per-book rescan used by the Edit Metadata dialog and backfills
+// covers for items imported before the PDF render fallback existed.
+func (s *MediaScanner) RescanMediaItem(ctx context.Context, mediaItemID pgtype.UUID) error {
+	item, err := s.db.GetMediaItem(ctx, mediaItemID)
+	if err != nil {
+		return fmt.Errorf("media item not found: %w", err)
+	}
+
+	folders, err := s.db.GetLibraryFolders(ctx, item.LibraryID)
+	if err != nil || len(folders) == 0 {
+		return fmt.Errorf("no library folders found for library")
+	}
+
+	folderPaths := make([]string, 0, len(folders))
+	for _, folder := range folders {
+		folderPaths = append(folderPaths, folder.FolderPath)
+	}
+	s.folders = folderPaths
+
+	var fullPath string
+	for _, folder := range folders {
+		candidate := filepath.Join(folder.FolderPath, item.FilePath)
+		if _, err := os.Stat(candidate); err == nil {
+			fullPath = candidate
+			break
+		}
+	}
+	if fullPath == "" {
+		return fmt.Errorf("media file not found on disk: %s", item.FilePath)
+	}
+
+	info, err := os.Stat(fullPath)
+	if err != nil {
+		return fmt.Errorf("failed to stat media file: %w", err)
+	}
+
+	if err := s.updateMediaItem(ctx, mediaItemID, fullPath, info); err != nil {
+		return fmt.Errorf("failed to update media item: %w", err)
+	}
+	s.recomputeHashInfo(ctx, mediaItemID, item.LibraryID, fullPath)
+
+	return nil
+}
+
 func (s *MediaScanner) getMediaItemByFilePath(ctx context.Context, filePath string, libraryID pgtype.UUID) (database.MediaItems, error) {
 	return s.db.GetMediaItemByFilePath(ctx, database.GetMediaItemByFilePathParams{
 		FilePath:  s.getRelativePath(filePath),

internal/sync/annotations.go

@@ -67,6 +67,13 @@ type SaveHighlightRequest struct {
 	EndPosition   string
 	Color         string
 	NoteText      string
+	// HighlightID, when valid, targets that exact row (web PUTs edit by
+	// id): the save LWWs against it directly under its stored dedup key.
+	// The computed key depends on fields that legitimately change — the
+	// stored CFI drifts range→point shape after device echoes, and the
+	// user can edit the selection text — so a key-based upsert would mint
+	// a duplicate beside the very row being edited.
+	HighlightID       pgtype.UUID
 	PercentageStart   float64
 	PercentageEnd     float64
 	EpubcfiStart      string
@@ -90,6 +97,35 @@ type SaveHighlightResult struct {
 
 func (s *AnnotationService) SaveHighlight(ctx context.Context, req SaveHighlightRequest) (*SaveHighlightResult, error) {
 	dedupKey := req.DedupKey
+
+	// Web edits arrive with the row id from the URL: resolve by id first
+	// and LWW against that row under its stored key. Content-derived keys
+	// are for lookups by identity (device pushes carry no row ids); an
+	// edit must never re-derive identity from (possibly edited) content.
+	if req.HighlightID.Valid {
+		byID, idErr := s.db.GetMediaHighlight(ctx, req.HighlightID)
+		if idErr != nil && !errors.Is(idErr, pgx.ErrNoRows) {
+			return nil, fmt.Errorf("query highlight by id: %w", idErr)
+		}
+		if idErr == nil {
+			if byID.UserID != req.UserID || byID.MediaItemID != req.MediaItemID {
+				return nil, fmt.Errorf("highlight %s belongs to another user or media item", req.HighlightID)
+			}
+			if dedupKey == "" {
+				dedupKey = byID.DedupKey.String
+			}
+			if byID.Deleted.Bool {
+				if !incomingNewerThanTombstone(req.ModifiedAt, byID.DeletedAt, byID.LastModifiedAt) {
+					return &SaveHighlightResult{Highlight: byID, Outcome: SaveOutcomeDeleted}, nil
+				}
+				// Newer than the tombstone: a deliberate re-create. Resurrect
+				// via the LWW update (which clears deleted/deleted_at).
+			}
+			return s.applyLWW(ctx, req, byID, dedupKey)
+		}
+		// No row with that id: fall through to identity-based resolution.
+	}
+
 	if dedupKey == "" {
 		dedupKey = ComputeDedupKey(req.SelectionText, req.EpubcfiStart, req.StartPosition)
 	}
@@ -186,17 +222,38 @@ func (s *AnnotationService) applyLWW(
 
 	deviceData := mergeDeviceSyncData(existing.DeviceSyncData, req.Source, req.DeviceSyncData)
 
+	// Web edits carry no device locators (the web reader never had a CRE
+	// xpointer) and may carry no CFI either: keep the stored ones so
+	// device-native serve-back and round-trip identity survive a web-side
+	// note/color edit instead of being wiped to empty.
+	startPosition := req.StartPosition
+	if startPosition == "" {
+		startPosition = existing.StartPosition.String
+	}
+	endPosition := req.EndPosition
+	if endPosition == "" {
+		endPosition = existing.EndPosition.String
+	}
+	epubcfiStart := req.EpubcfiStart
+	if epubcfiStart == "" {
+		epubcfiStart = existing.EpubcfiStart.String
+	}
+	epubcfiEnd := req.EpubcfiEnd
+	if epubcfiEnd == "" {
+		epubcfiEnd = existing.EpubcfiEnd.String
+	}
+
 	highlight, err := s.db.UpdateMediaHighlightForSync(ctx, database.UpdateMediaHighlightForSyncParams{
 		ID:                 existing.ID,
 		SelectionText:      req.SelectionText,
-		StartPosition:      pgText(req.StartPosition),
-		EndPosition:        pgText(req.EndPosition),
+		StartPosition:      pgText(startPosition),
+		EndPosition:        pgText(endPosition),
 		Color:              pgText(req.Color),
 		NoteText:           pgText(req.NoteText),
 		PercentageStart:    pgFloat8(req.PercentageStart),
 		PercentageEnd:      pgFloat8(req.PercentageEnd),
-		EpubcfiStart:       pgText(req.EpubcfiStart),
-		EpubcfiEnd:         pgText(req.EpubcfiEnd),
+		EpubcfiStart:       pgText(epubcfiStart),
+		EpubcfiEnd:         pgText(epubcfiEnd),
 		ChapterReference:   pgInt4(req.ChapterReference),
 		LastModifiedAt:     pgtype.Timestamptz{Time: modifiedAt, Valid: true},
 		LastModifiedSource: pgtype.Text{String: req.Source, Valid: req.Source != ""},
@@ -222,7 +279,9 @@ func (s *AnnotationService) compareIncoming(req SaveHighlightRequest, existing d
 			textEq(req.Color, existing.Color) &&
 			textEq(req.NoteText, existing.NoteText) &&
 			floatEq(req.PercentageStart, existing.PercentageStart) &&
-			floatEq(req.PercentageEnd, existing.PercentageEnd)
+			floatEq(req.PercentageEnd, existing.PercentageEnd) &&
+			locatorRefresher(req.EpubcfiStart, existing.EpubcfiStart) &&
+			locatorRefresher(req.EpubcfiEnd, existing.EpubcfiEnd)
 		return !contentSame, !contentSame
 	}
 
@@ -233,6 +292,22 @@ func (s *AnnotationService) compareIncoming(req SaveHighlightRequest, existing d
 	return req.ModifiedAt.After(existingMod.Time), true
 }
 
+// locatorRefresher reports whether an incoming locator leaves the stored
+// one untouched: either the push carried none (empty coalesces to the
+// stored value in applyLWW) or it matches what is stored. A non-empty
+// incoming locator that DIFFERS is a deliberate refresh: device echoes
+// re-derive their canonical CFIs on every push, and an improvement (a
+// converter fix re-landing a corrupted anchor, drift repair) must reach
+// the row even when the annotation content is otherwise identical —
+// without this, content-equal echoes resolve to "skip" and a bad stored
+// locator can never heal.
+func locatorRefresher(incoming string, existing pgtype.Text) bool {
+	if incoming == "" {
+		return true
+	}
+	return textEq(incoming, existing)
+}
+
 func (s *AnnotationService) TombstoneHighlight(
 	ctx context.Context,
 	userID, mediaItemID pgtype.UUID,
@@ -687,13 +762,25 @@ func (s *AnnotationService) applyBookmarkLWW(ctx context.Context, req SaveBookma
 	}
 	deviceData := mergeDeviceSyncData(existing.DeviceSyncData, req.Source, req.DeviceSyncData)
 
+	// Web saves carry no device locators: keep the stored ones so a web
+	// title/note edit never wipes the device-native position (mirrors the
+	// highlight path's coalescing).
+	cfiPosition := req.CFIPosition
+	if cfiPosition == "" {
+		cfiPosition = existing.CfiPosition.String
+	}
+	position := req.Position
+	if position == "" {
+		position = existing.Position.String
+	}
+
 	bm, err := s.db.UpdateMediaBookmarkForSync(ctx, database.UpdateMediaBookmarkForSyncParams{
 		ID:                 existing.ID,
 		PageNumber:         pgInt4(req.PageNumber),
 		ChapterNumber:      pgInt4(req.ChapterNumber),
-		CfiPosition:        pgText(req.CFIPosition),
+		CfiPosition:        pgText(cfiPosition),
 		Title:              req.Title,
-		Position:           pgText(req.Position),
+		Position:           pgText(position),
 		Notes:              pgText(req.Notes),
 		PercentageLocation: pgFloat8(req.PercentageLoc),
 		EpubcfiLocation:    pgText(req.EpubcfiLocation),
@@ -718,7 +805,9 @@ func (s *AnnotationService) applyBookmarkLWW(ctx context.Context, req SaveBookma
 func (s *AnnotationService) compareIncomingBookmark(req SaveBookmarkRequest, existing database.MediaBookmarks) (incomingNewer bool, contentChanged bool) {
 	if req.ModifiedAt.IsZero() {
 		contentSame := strings.EqualFold(req.Title, existing.Title) &&
-			textEq(req.Notes, existing.Notes)
+			textEq(req.Notes, existing.Notes) &&
+			locatorRefresher(req.CFIPosition, existing.CfiPosition) &&
+			locatorRefresher(req.Position, existing.Position)
 		return !contentSame, !contentSame
 	}
 	existingMod := existing.LastModifiedAt

internal/sync/annotations_test.go

@@ -369,3 +369,82 @@ func TestIncomingNewerThanTombstone(t *testing.T) {
 		})
 	}
 }
+
+// Content-equal device echoes must still count as changed when they carry
+// a locator that differs from the stored one: echoes re-derive canonical
+// CFIs on every push, and a better conversion (or a repair of a corrupted
+// anchor) has to reach the row — otherwise the skip path discards it and
+// the bad locator can never heal.
+func TestCompareIncomingLocatorDriftRefreshes(t *testing.T) {
+	svc := &AnnotationService{}
+	existing := database.MediaHighlights{
+		SelectionText: "CHAPTER IV. “What a pity it is, Elinor,”",
+		Color:         pgtype.Text{String: "#90caf9", Valid: true},
+		EpubcfiStart:  pgtype.Text{String: "epubcfi(/6/12!/4/2[x]/32/3:576)", Valid: true},
+		EpubcfiEnd:    pgtype.Text{String: "epubcfi(/6/12!/4/2[x]/4/1:93)", Valid: true},
+	}
+	base := SaveHighlightRequest{
+		SelectionText: existing.SelectionText,
+		Color:         "#90caf9",
+	}
+
+	t.Run("identical content and locators skip", func(t *testing.T) {
+		req := base
+		req.EpubcfiStart = existing.EpubcfiStart.String
+		req.EpubcfiEnd = existing.EpubcfiEnd.String
+		_, changed := svc.compareIncoming(req, existing)
+		if changed {
+			t.Error("identical echo must not rewrite the row")
+		}
+	})
+
+	t.Run("better start locator refreshes despite identical content", func(t *testing.T) {
+		req := base
+		req.EpubcfiStart = "epubcfi(/6/12!/4/2[x]/2/3:0)"
+		req.EpubcfiEnd = existing.EpubcfiEnd.String
+		_, changed := svc.compareIncoming(req, existing)
+		if !changed {
+			t.Error("locator drift on a content-equal echo must trigger an update")
+		}
+	})
+
+	t.Run("empty incoming locators leave the row alone", func(t *testing.T) {
+		req := base // no CFIs: applyLWW coalesces empty to stored
+		_, changed := svc.compareIncoming(req, existing)
+		if changed {
+			t.Error("empty locators coalesce; must not count as drift")
+		}
+	})
+}
+
+// Bookmarks share the echo-refresh rule for their locators.
+func TestCompareIncomingBookmarkLocatorDrift(t *testing.T) {
+	svc := &AnnotationService{}
+	existing := database.MediaBookmarks{
+		Title:       "in CHAPTER IV.",
+		CfiPosition: pgtype.Text{String: "epubcfi(/6/12!/4/2[x]/2/3:0)", Valid: true},
+		Position:    pgtype.Text{String: "/body/DocFragment[6]/body/div[1]/h2[1]/text().0", Valid: true},
+	}
+
+	t.Run("same locators skip", func(t *testing.T) {
+		req := SaveBookmarkRequest{
+			Title:       existing.Title,
+			CFIPosition: existing.CfiPosition.String,
+			Position:    existing.Position.String,
+		}
+		if _, changed := svc.compareIncomingBookmark(req, existing); changed {
+			t.Error("identical bookmark echo must not rewrite the row")
+		}
+	})
+
+	t.Run("new CFI refreshes despite same title", func(t *testing.T) {
+		req := SaveBookmarkRequest{
+			Title:       existing.Title,
+			CFIPosition: "epubcfi(/6/12!/4/2[x]/2/3:5)",
+			Position:    existing.Position.String,
+		}
+		if _, changed := svc.compareIncomingBookmark(req, existing); !changed {
+			t.Error("bookmark locator drift must trigger an update")
+		}
+	})
+}

internal/sync/cfi_converter.go

@@ -12,6 +12,7 @@ import (
 	"strconv"
 	"strings"
 	"sync"
+	"unicode"
 	"unicode/utf8"
 
 	"golang.org/x/net/html"
@@ -246,6 +247,11 @@ func parseElementPart(part string) (string, int) {
 
 type ConversionResult struct {
 	EPUBCFI string
+	// EndEPUBCFI is set when the conversion matched a context that is a
+	// quote of the document (text search): the range end anchor of the
+	// quoted text, valid across block boundaries. Selections use it as
+	// the highlight end; point positions ignore it.
+	EndEPUBCFI string
 	Href       string
 	Percentage float64
 	Precision  string
@@ -510,25 +516,24 @@ func (c *CFIConverter) convertByStructuralPath(body *html.Node, xp *CREXPointer,
 		return nil
 	}
 
-	// Text is the final verification: when the device sent usable words and
-	// they disagree with this structural landing, reject it and let text
-	// search / percentage decide rather than storing a confident-but-wrong CFI.
+	// Text is the final verification, in quote form: a usable context must
+	// be a prefix of the document as read forward from this landing point.
+	// Device captures are exactly that shape — a position's context is the
+	// text from the position onward (the plugin's walk-up may concatenate
+	// the heading with the paragraphs below), and a selection is the
+	// document text between its two anchors. The single-block containment
+	// checks stay as secondary acceptance for reverse shapes.
 	if usable, normalized := usableContextText(contextText); usable {
+		doc := documentTextFrom(body, textNode, localOffset, utf8.RuneCountInString(normalized)+64)
 		flat := blockFlattenedText(textNode)
-		if flat != "" && !strings.Contains(flat, normalized) && !strings.Contains(normalized, flat) {
-			// Compare a prefix too: device sends ~100 chars from the reader
-			// position while the block may be longer.
-			prefix := normalized
-			if utf8.RuneCountInString(prefix) > 40 {
-				runes := []rune(prefix)
-				prefix = string(runes[:40])
-			}
-			if !strings.Contains(flat, prefix) {
-				log.Printf("Bookhoard: structural landing disagrees with context in %s (block %q vs ctx %q)", href, truncateForLog(flat, 80), truncateForLog(normalized, 80))
+		if !(strings.HasPrefix(doc, normalized) ||
+			strings.Contains(flat, normalized) ||
+			strings.Contains(normalized, flat)) {
+			log.Printf("Bookhoard: structural landing disagrees with context in %s (reads %q vs ctx %q)",
+				href, truncateForLog(doc, 80), truncateForLog(normalized, 80))
 			return nil
 		}
 	}
-	}
 
 	spineIndex := xp.FragmentIndex - 1
 	cfi, err := buildCFI(spineIndex, textNode, localOffset)
@@ -592,28 +597,149 @@ func (c *CFIConverter) convertFragmentID(s string, storedPercentage float64) (*C
 	}, nil
 }
 
+// docRunePos records which text node (and rune offset within it) produced
+// each rune of the flattened document text.
+type docRunePos struct {
+	node *html.Node
+	off  int
+}
+
+// flattenDocumentForSearch renders the document's text as a
+// whitespace-normalized rune stream in document order, crossing block
+// boundaries: a single space separates blocks, while inline spans join
+// directly (drop-cap splits like <span>C</span>onvergence read as one
+// word). Every emitted rune carries its source (node, rune offset) so
+// matches map back to CFIs.
+func flattenDocumentForSearch(body *html.Node) ([]rune, []docRunePos) {
+	var runes []rune
+	var poss []docRunePos
+	pendingSpace := false
+	var lastBlock *html.Node
+
+	appendNode := func(n *html.Node) {
+		block := findBlockParent(n)
+		if lastBlock != nil && block != lastBlock {
+			pendingSpace = true
+		}
+		lastBlock = block
+		off := 0
+		for _, r := range n.Data {
+			if unicode.IsSpace(r) {
+				pendingSpace = true
+			} else {
+				if pendingSpace && len(runes) > 0 {
+					runes = append(runes, ' ')
+					poss = append(poss, docRunePos{node: n, off: off})
+				}
+				pendingSpace = false
+				runes = append(runes, r)
+				poss = append(poss, docRunePos{node: n, off: off})
+			}
+			off++
+		}
+	}
+
+	var walk func(n *html.Node)
+	walk = func(n *html.Node) {
+		if n.Type == html.TextNode {
+			if strings.TrimSpace(n.Data) != "" {
+				appendNode(n)
+			}
+			return
+		}
+		for c := n.FirstChild; c != nil; c = c.NextSibling {
+			walk(c)
+		}
+	}
+	walk(body)
+	return runes, poss
+}
+
+// documentTextFrom reads the whitespace-normalized document text starting
+// at rune `offset` in `start` (typically a structural landing point),
+// crossing block boundaries — the document "as read" from that position.
+// Capped at maxRunes.
+func documentTextFrom(body *html.Node, start *html.Node, offset, maxRunes int) string {
+	runes, poss := flattenDocumentForSearch(body)
+	begin := -1
+	for i := range poss {
+		if poss[i].node == start && poss[i].off >= offset {
+			begin = i
+			break
+		}
+	}
+	if begin < 0 {
+		return ""
+	}
+	// The separator space before a block's first content rune shares its
+	// (node, offset) — skip it so the read starts on real text.
+	if runes[begin] == ' ' && begin+1 < len(runes) {
+		begin++
+	}
+	end := len(runes)
+	if begin+maxRunes < end {
+		end = begin + maxRunes
+	}
+	return string(runes[begin:end])
+}
+
 func (c *CFIConverter) convertByTextSearch(body *html.Node, xp *CREXPointer, spine *spineCache, href string, storedPercentage float64, contextText string) *ConversionResult {
 	normalizedCtx := normalizeWhitespace(contextText)
 	if normalizedCtx == "" {
 		return nil
 	}
 
-	match, matchOffset := findTextInNode(body, normalizedCtx)
-	if match == nil {
-		log.Printf("Bookhoard: text search no match for %q in %s", normalizedCtx, href)
+	// Match against the whole document flattened in reading order — the
+	// context may span block boundaries (a selection covering several
+	// paragraphs, a walk-up capture joining a heading with what follows).
+	runes, poss := flattenDocumentForSearch(body)
+	text := string(runes)
+
+	words := strings.Fields(normalizedCtx)
+	quoted := make([]string, len(words))
+	for i, w := range words {
+		quoted[i] = regexp.QuoteMeta(w)
+	}
+	pattern := strings.Join(quoted, `\s+`)
+	re, err := regexp.Compile(pattern)
+	if err != nil {
+		return nil
+	}
+	loc := re.FindStringIndex(text)
+	if loc == nil {
+		log.Printf("Bookhoard: text search no match for %q in %s", truncateForLog(normalizedCtx, 60), href)
 		return nil
 	}
 
+	startRune := utf8.RuneCountInString(text[:loc[0]])
+	endRune := utf8.RuneCountInString(text[:loc[1]]) // exclusive
 	spineIndex := xp.FragmentIndex - 1
-	cfi, err := buildCFI(spineIndex, match, matchOffset)
-	if err != nil || cfi == "" {
+
+	startPos := poss[startRune]
+	startCFI, err := buildCFI(spineIndex, startPos.node, startPos.off)
+	if err != nil || startCFI == "" {
 		log.Printf("Bookhoard: text search found match but buildCFI failed: %v", err)
 		return nil
 	}
 
-	log.Printf("Bookhoard: text search matched %q → %s (precision: exact)", normalizedCtx, cfi)
+	// The matched context is a quote of the document: its extent gives
+	// selections a true range end, across block boundaries.
+	endCFI := ""
+	if endRune > startRune && endRune <= len(poss) {
+		endPos := poss[endRune-1]
+		endOff := endPos.off + 1
+		if nRunes := utf8.RuneCountInString(endPos.node.Data); endOff > nRunes {
+			endOff = nRunes
+		}
+		if ec, err := buildCFI(spineIndex, endPos.node, endOff); err == nil && ec != "" {
+			endCFI = ec
+		}
+	}
+
+	log.Printf("Bookhoard: text search matched %q → %s (precision: exact)", truncateForLog(normalizedCtx, 60), startCFI)
 	return &ConversionResult{
-		EPUBCFI:    cfi,
+		EPUBCFI:    startCFI,
+		EndEPUBCFI: endCFI,
 		Href:       href,
 		Percentage: storedPercentage,
 		Precision:  "exact",
@@ -780,7 +906,10 @@ func (c *CFIConverter) convertByPercentageOffset(body *html.Node, xp *CREXPointe
 				EPUBCFI:    cfi,
 				Href:       href,
 				Percentage: storedPercentage,
-				Precision:  "exact",
+				// This is a char-count estimate, not an exact landing: say
+				// so. Callers gate storage on precision, and a guess must
+				// never masquerade as an exact anchor.
+				Precision: "percentage",
 			}, nil
 		}
 	}

internal/sync/cfi_converter_test.go

@@ -667,6 +667,96 @@ func TestReverseIgnoresSingleCharContext(t *testing.T) {
 	}
 }
 
+// A position at a chapter heading sends walk-up context: the heading text
+// concatenated with the paragraphs below (block walk-up in the plugin).
+// The structural landing at the heading is correct and must verify — the
+// context is a prefix of the document as read from the landing.
+func TestWalkUpContextVerifiesAtHeading(t *testing.T) {
+	c := NewCFIConverter(writeDropCapEPUB(t))
+
+	// ch10: h1[1] "Chapter 10", h1[2] "The Three C's of the New Covenant",
+	// then paragraphs. Position at h1[2]'s text start; the device captured
+	// the heading plus the following paragraph.
+	xp := "/body/DocFragment[2]/body/h1[2]/text().0"
+	ctx := "The Three C's of the New Covenant The Cleansing Life of Christ"
+
+	result, err := c.ConvertCREToStandard(xp, 0.52, ctx)
+	if err != nil {
+		t.Fatalf("ConvertCREToStandard error: %v", err)
+	}
+	t.Logf("walk-up heading → %s (%s)", result.EPUBCFI, result.Precision)
+	if result.Precision != "structural" {
+		t.Fatalf("expected structural precision (quote verification), got %s (%s)", result.Precision, result.EPUBCFI)
+	}
+	if strings.HasSuffix(result.EPUBCFI, "/4/2/1:0)") {
+		t.Errorf("collapsed to doc start: %s", result.EPUBCFI)
+	}
+	// The landing must be the heading, not a paragraph below it.
+	reverse, rerr := c.ConvertStandardToCRE(result.EPUBCFI, result.Percentage, "")
+	if rerr != nil {
+		t.Fatalf("reverse conversion error: %v", rerr)
+	}
+	if !strings.Contains(reverse.XPointer, "h1[2]") {
+		t.Errorf("expected landing in h1[2], got %s", reverse.XPointer)
+	}
+}
+
+// A selection spanning blocks (heading tail into the next paragraph) must
+// be findable by text search across block boundaries, and the matched
+// quote's extent gives a true range end.
+func TestCrossBlockSearchSpansBlocks(t *testing.T) {
+	c := NewCFIConverter(writeDropCapEPUB(t))
+
+	// No element path → structural rung skipped, text search runs.
+	xp := "/body/DocFragment[2]/body"
+	ctx := "New Covenant The Cleansing Life of Christ"
+
+	result, err := c.ConvertCREToStandard(xp, 0.52, ctx)
+	if err != nil {
+		t.Fatalf("ConvertCREToStandard error: %v", err)
+	}
+	t.Logf("cross-block search → %s … %s (%s)", result.EPUBCFI, result.EndEPUBCFI, result.Precision)
+	if result.Precision != "exact" {
+		t.Fatalf("expected exact text-search precision, got %s", result.Precision)
+	}
+	if result.EPUBCFI == "" || result.EndEPUBCFI == "" {
+		t.Fatalf("expected range anchors, got %q…%q", result.EPUBCFI, result.EndEPUBCFI)
+	}
+	if result.EPUBCFI == result.EndEPUBCFI {
+		t.Fatalf("range collapsed: %s", result.EPUBCFI)
+	}
+
+	// The start lands in the heading, the end in the following paragraph.
+	startRev, err1 := c.ConvertStandardToCRE(result.EPUBCFI, result.Percentage, "")
+	endRev, err2 := c.ConvertStandardToCRE(result.EndEPUBCFI, result.Percentage, "")
+	if err1 != nil || err2 != nil {
+		t.Fatalf("reverse conversions failed: %v %v", err1, err2)
+	}
+	if !strings.Contains(startRev.XPointer, "h1[2]") {
+		t.Errorf("expected start in h1[2], got %s", startRev.XPointer)
+	}
+	if !strings.Contains(endRev.XPointer, "p[1]") {
+		t.Errorf("expected end in p[1] (following paragraph), got %s", endRev.XPointer)
+	}
+}
+
+// The percentage rung is a char-count estimate: it must never label its
+// landing "exact". Feed it an unmatchable context so the ladder falls all
+// the way through.
+func TestPercentageFallbackIsHonestlyLabeled(t *testing.T) {
+	c := NewCFIConverter(writeDropCapEPUB(t))
+
+	xp := "/body/DocFragment[2]/body/p[3]/span[1]/text().0"
+	result, err := c.ConvertCREToStandard(xp, 0.52, "zzz qqq vvv uuu www")
+	if err != nil {
+		t.Fatalf("ConvertCREToStandard error: %v", err)
+	}
+	t.Logf("unmatchable context → %s (%s)", result.EPUBCFI, result.Precision)
+	if result.Precision != "percentage" {
+		t.Errorf("percentage rung must not claim exact, got %s", result.Precision)
+	}
+}
+
 // The bookmark route supplies no context (bookmark text is a display
 // label, never book text), so the facade must still resolve the drop-cap
 // xpointer structurally instead of collapsing to the document start.

internal/sync/locators.go

@@ -15,6 +15,10 @@ const (
 
 type CanonicalLocator struct {
 	CFI string
+	// EndCFI carries the matched context's range end (text-search
+	// conversions of selections) so callers can anchor a true highlight
+	// range across block boundaries.
+	EndCFI     string
 	Precision  string
 	Percentage float64
 }
@@ -94,7 +98,7 @@ func ConvertToCanonical(
 			return CanonicalLocator{CFI: devicePos, Precision: "fallback", Percentage: percentage}
 		}
 		if result.EPUBCFI != "" {
-			return CanonicalLocator{CFI: result.EPUBCFI, Precision: result.Precision, Percentage: result.Percentage}
+			return CanonicalLocator{CFI: result.EPUBCFI, EndCFI: result.EndEPUBCFI, Precision: result.Precision, Percentage: result.Percentage}
 		}
 		if result.Href != "" {
 			return CanonicalLocator{CFI: result.Href, Precision: result.Precision, Percentage: result.Percentage}

templates/book_detail_modals.templ

@@ -609,7 +609,19 @@ templ MetadataEditorModal(book handlers.MediaDetail) {
 					</div>
 				</div>
 			</div>
-			<div class="flex justify-end space-x-3 p-6 border-t flex-shrink-0" style="border-color: var(--border);">
+		<div class="flex items-center justify-between p-6 border-t flex-shrink-0" style="border-color: var(--border);">
+			<button
+				@click="rescanBook()"
+				:disabled="rescanning"
+				class="btn btn-secondary"
+			>
+				<span x-show="!rescanning" class="inline-flex items-center gap-2">@Icon("sync", "h-4 w-4")<span>Rescan</span></span>
+				<svg x-show="rescanning" class="animate-spin inline-block h-5 w-5" viewBox="0 0 24 24" fill="none">
+					<circle class="opacity-25" cx="12" cy="12" r="10" stroke="currentColor" stroke-width="4"></circle>
+					<path class="opacity-75" fill="currentColor" d="M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4z"></path>
+				</svg>
+			</button>
+			<div class="flex space-x-3">
 				<button
 					@click="hideMetadataEditor()"
 					class="btn btn-secondary"
@@ -626,4 +638,5 @@ templ MetadataEditorModal(book handlers.MediaDetail) {
 			</div>
 		</div>
 		</div>
+	</div>
 }

templates/book_detail_modals_templ.go

@@ -1336,7 +1336,15 @@ func MetadataEditorModal(book handlers.MediaDetail) templ.Component {
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 126, "\" readonly class=\"input opacity-60\"></div></div></div></div></div></div><div class=\"flex justify-end space-x-3 p-6 border-t flex-shrink-0\" style=\"border-color: var(--border);\"><button @click=\"hideMetadataEditor()\" class=\"btn btn-secondary\">Cancel</button> <button @click=\"saveMetadata()\" class=\"btn btn-primary\">")
+		templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 126, "\" readonly class=\"input opacity-60\"></div></div></div></div></div></div><div class=\"flex items-center justify-between p-6 border-t flex-shrink-0\" style=\"border-color: var(--border);\"><button @click=\"rescanBook()\" :disabled=\"rescanning\" class=\"btn btn-secondary\"><span x-show=\"!rescanning\" class=\"inline-flex items-center gap-2\">")
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		templ_7745c5c3_Err = Icon("sync", "h-4 w-4").Render(ctx, templ_7745c5c3_Buffer)
+		if templ_7745c5c3_Err != nil {
+			return templ_7745c5c3_Err
+		}
+		templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 127, "<span>Rescan</span></span> <svg x-show=\"rescanning\" class=\"animate-spin inline-block h-5 w-5\" viewBox=\"0 0 24 24\" fill=\"none\"><circle class=\"opacity-25\" cx=\"12\" cy=\"12\" r=\"10\" stroke=\"currentColor\" stroke-width=\"4\"></circle> <path class=\"opacity-75\" fill=\"currentColor\" d=\"M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4z\"></path></svg></button><div class=\"flex space-x-3\"><button @click=\"hideMetadataEditor()\" class=\"btn btn-secondary\">Cancel</button> <button @click=\"saveMetadata()\" class=\"btn btn-primary\">")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
@@ -1344,7 +1352,7 @@ func MetadataEditorModal(book handlers.MediaDetail) templ.Component {
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}
-		templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 127, "Save</button></div></div></div>")
+		templ_7745c5c3_Err = templruntime.WriteString(templ_7745c5c3_Buffer, 128, "Save</button></div></div></div></div>")
 		if templ_7745c5c3_Err != nil {
 			return templ_7745c5c3_Err
 		}

templates/reader.templ

@@ -5,7 +5,11 @@ import (
 	"fmt"
 )
 
-func readerInitExpr(metadata ReaderMetadata, progress ReadingProgress, bookmarks []Bookmark) string {
+// The init config carries only immutable book metadata. Reading state
+// (position, bookmarks, annotations) is never embedded: the reader fetches
+// it from the APIs at open time, so the page can never carry — nor write
+// back — a stale snapshot of it.
+func readerInitExpr(metadata ReaderMetadata) string {
 	config := map[string]interface{}{
 		"mediaItemId":      metadata.MediaItemID,
 		"fileUrl":          metadata.FileURL,
@@ -13,42 +17,11 @@ func readerInitExpr(metadata ReaderMetadata, progress ReadingProgress, bookmarks
 		"readingDirection": metadata.ReadingDirection,
 		"mangaType":        metadata.MangaType,
 	}
-	if progress.Percentage > 0 {
-		config["savedPercentage"] = progress.Percentage / 100
-	}
-	if progress.EpubCfi != "" {
-		config["savedCfi"] = progress.EpubCfi
-	}
-	// Fixed-layout & comic formats: the page index is the canonical, exact
-	// locator (pages are fixed images). Pass it so the reader restores by page.
-	if (metadata.FormatGroup == "fixed_layout" || metadata.FormatGroup == "comic_archive") && progress.CurrentPage > 0 {
-		config["savedPage"] = progress.CurrentPage
-		if progress.TotalPages > 0 {
-			config["savedTotalPages"] = progress.TotalPages
-		}
-	}
-	if len(bookmarks) > 0 {
-		items := make([]map[string]interface{}, 0, len(bookmarks))
-		for _, b := range bookmarks {
-			var page any
-			if b.PageNumber != nil {
-				page = *b.PageNumber
-			}
-			items = append(items, map[string]interface{}{
-				"id":            b.ID,
-				"title":         b.Title,
-				"positionLabel": b.Position,
-				"cfi":           b.CfiPosition,
-				"page":          page,
-			})
-		}
-		config["bookmarks"] = items
-	}
 	jsonBytes, _ := json.Marshal(config)
 	return fmt.Sprintf("initReader(%s)", string(jsonBytes))
 }
 
-templ Reader(user User, metadata ReaderMetadata, progress ReadingProgress, bookmarks []Bookmark) {
+templ Reader(user User, metadata ReaderMetadata) {
 	<!DOCTYPE html>
 	<html lang="en">
 		<head>
@@ -64,7 +37,7 @@ templ Reader(user User, metadata ReaderMetadata, progress ReadingProgress, bookm
 		</head>
 		<body
 			x-data="readerShell"
-			x-init={ readerInitExpr(metadata, progress, bookmarks) }
+			x-init={ readerInitExpr(metadata) }
 			class={ "theme-" + user.Theme + " h-screen overflow-hidden" }
 		>
 			<!-- Reading surface: edge-to-edge. Chrome overlays translucently;
@@ -96,7 +69,7 @@ templ Reader(user User, metadata ReaderMetadata, progress ReadingProgress, bookm
 				</div>
 			</div>
 
-			@ReaderChrome(metadata, progress)
+			@ReaderChrome(metadata)
 
 			<!-- Drawer scrim -->
 			<div
@@ -311,7 +284,7 @@ templ Reader(user User, metadata ReaderMetadata, progress ReadingProgress, bookm
 	</html>
 }
 
-templ ReaderChrome(metadata ReaderMetadata, progress ReadingProgress) {
+templ ReaderChrome(metadata ReaderMetadata) {
 	<div id="reader-chrome" class="transition-opacity duration-300" :class="chromeVisible ? 'opacity-100' : 'chrome-hidden opacity-0 pointer-events-none'">
 		<!-- Top bar -->
 		<div id="reader-topbar" class="fixed top-0 left-0 right-0 border-b z-40 pt-[env(safe-area-inset-top)] reader-glass">
@@ -365,17 +338,7 @@ templ ReaderChrome(metadata ReaderMetadata, progress ReadingProgress) {
 				<div class="flex items-center gap-1">
 					<div class="w-px h-6 reader-sep"></div>
 					<div id="progress-display" @click="cycleProgressMode()" :title="progressTooltip()" class="text-sm min-w-[4rem] max-w-[5rem] sm:max-w-none text-center cursor-pointer truncate whitespace-nowrap overflow-hidden">
-						<span class="hidden sm:inline" x-text="progressLabel"></span><span x-text="progressMain">
-							if progress.FormatGroup == "reflowable" {
-								if metadata.EstimatedPages > 0 {
-									{ fmt.Sprintf("%.0f%% · Page %d/%d", progress.Percentage, progress.CurrentPage, metadata.EstimatedPages) }
-								} else {
-									{ fmt.Sprintf("%.0f%%", progress.Percentage) }
-								}
-							} else {
-								{ fmt.Sprintf("%d/%d", progress.CurrentPage, progress.TotalPages) }
-							}
-						</span>
+					<span class="hidden sm:inline" x-text="progressLabel"></span><span x-text="progressMain">—</span>
 					</div>
 					<div class="w-px h-6 reader-sep"></div>
 					<button @click="toggleTOC()" class="p-1.5 sm:p-2 rounded-lg hover:bg-gray-700" title="Table of Contents (t)">📖</button>
@@ -467,13 +430,7 @@ templ ReaderChrome(metadata ReaderMetadata, progress ReadingProgress) {
 				<!-- Progress + TOC -->
 				<div class="flex items-center gap-1">
 					<div id="progress-display-fx" @click="cycleProgressMode()" :title="progressTooltip()" class="text-sm min-w-[3.5rem] text-center cursor-pointer truncate whitespace-nowrap overflow-hidden">
-						<span x-text="progressMain">
-							if progress.FormatGroup == "reflowable" {
-								{ fmt.Sprintf("%.0f%%", progress.Percentage) }
-							} else {
-								{ fmt.Sprintf("%d/%d", progress.CurrentPage, progress.TotalPages) }
-							}
-						</span>
+						<span x-text="progressMain">—</span>
 					</div>
 					<button @click="toggleTOC()" class="p-1.5 sm:p-2 rounded-lg hover:bg-gray-700" title="Table of Contents (t)">📖</button>
 				</div>

web/src/book-detail.ts

@@ -97,6 +97,7 @@ interface MetadataEditorState {
   coverFile: Blob | null;
   coverAction: string;
   saving: boolean;
+  rescanning: boolean;
   userRating: number;
   ratingHover: number;
   ratingSaving: boolean;
@@ -110,6 +111,7 @@ interface MetadataEditorState {
   generateCover(): Promise<void>;
   removeCover(): void;
   saveMetadata(): Promise<void>;
+  rescanBook(): Promise<void>;
   starFill(i: number): string;
   ratingText(): string;
   setRating(value: number): Promise<void>;
@@ -149,6 +151,7 @@ Alpine.data("bookDetail", () => {
     coverFile: null as Blob | null,
     coverAction: "keep",
     saving: false,
+    rescanning: false,
     userRating: 0,
     ratingHover: 0,
     ratingSaving: false,
@@ -559,6 +562,31 @@ Alpine.data("bookDetail", () => {
       }
     },
 
+    async rescanBook() {
+      if (this.rescanning) return;
+      this.rescanning = true;
+      const mediaId = getMediaId();
+      try {
+        const resp = await fetch(`/api/media-items/${mediaId}/rescan`, {
+          method: "POST",
+          headers: { Authorization: getAuthHeader() },
+        });
+        if (!resp.ok) {
+          const err = await resp.json().catch(() => ({}));
+          throw new Error(err.error || "Failed to rescan book");
+        }
+        showToast("Book rescanned successfully", "success");
+        setTimeout(() => window.location.reload(), 500);
+      } catch (e) {
+        showToast(
+          e instanceof Error ? e.message : "Failed to rescan book",
+          "error",
+        );
+      } finally {
+        this.rescanning = false;
+      }
+    },
+
     async searchEditorTags() {
       const libraryId = document.body.getAttribute("data-library-id") || "";
       if (!this.tagSearch || this.tagSearch.length < 2 || !libraryId) {

web/src/reader/reader.ts

@@ -406,6 +406,10 @@ document.addEventListener("alpine:init", () => {
     tapZonesEnabled: true as boolean,
     tapZoneSize: 30 as number,
     tapZoneTimer: null as ReturnType<typeof setTimeout> | null,
+    // Any live text selection, host document or content iframe. Fed by
+    // selectionchange listeners (touch devices); tap zones stand down
+    // while one exists.
+    anySelection: false as boolean,
     highlightItems: [] as {
       id: string;
       text: string;
@@ -478,7 +482,14 @@ document.addEventListener("alpine:init", () => {
     tocItems: [] as any[],
     mediaItemId: "" as string,
     saveTimeout: null as ReturnType<typeof setTimeout> | null,
-    initTime: 0 as number,
+    // Position last known to be stored (the restore at open time, or the
+    // last successful save). Relocations that don't move from it are never
+    // written back, so a restored position can't clobber a newer device
+    // push — while swipe/scroll paging (handled inside foliate, with no
+    // wrapper method to flag) still saves normally.
+    lastSyncedCfi: "" as string,
+    lastSyncedFraction: -1 as number,
+    lastCfi: "" as string,
     contextText: "" as string,
     readingTheme: "light" as string,
     readingMode: "light" as string,
@@ -560,20 +571,13 @@ document.addEventListener("alpine:init", () => {
       formatGroup: string;
       readingDirection: string;
       mangaType: string;
-      savedPercentage?: number;
-      savedCfi?: string;
-      savedPage?: number;
-      savedTotalPages?: number;
-      bookmarks?: {
-        id: string;
-        title: string;
-        positionLabel: string;
-        cfi: string;
-        page: number | null;
-      }[];
     }) {
       this.mediaItemId = config.mediaItemId;
-      this.bookmarkItems = config.bookmarks ?? [];
+      // Reading state (position, bookmarks, annotations) is never baked
+      // into the rendered page: the web reader is intrinsically tied to
+      // the server, so it reads all of it from the APIs at open time —
+      // a device sync between render and open can never be shadowed by a
+      // stale snapshot.
       this.isComic = config.formatGroup === "comic_archive";
       // Reading flow for comics is a per-book preference (a webtoon title
       // vs. a paged manga volume); read before the renderer is chosen.
@@ -691,6 +695,14 @@ document.addEventListener("alpine:init", () => {
         // out to the host document, so the viewport listeners miss them).
         if (window.matchMedia("(pointer: coarse)").matches) {
           this.attachTapZoneListeners(doc as unknown as HTMLElement, true);
+          // Same for selectionchange: a selection inside the iframe must
+          // cancel armed tap actions and feed the host-surface guard.
+          doc.addEventListener("selectionchange", () => {
+            const sel = doc.getSelection();
+            this.noteSelectionActivity(
+              !!sel && !sel.isCollapsed && !!sel.toString(),
+            );
+          });
         }
         // Text selection → highlight popover (reflowable EPUB only;
         // fixed-layout highlight overlays are a later milestone).
@@ -735,6 +747,21 @@ document.addEventListener("alpine:init", () => {
             () => setTimeout(checkSelection, 0),
             { passive: true },
           );
+          // Clicks in the book dismiss the popover in ANY mode: iframe
+          // events never bubble to the host document (so the host
+          // outside-click dismiss never sees them), and the collapsed
+          // check above only covers create mode — edit mode had no
+          // outside-click path at all, leaving Esc as the only way out.
+          // Clicking a painted highlight still works: this hides, then
+          // foliate's show-annotation re-opens it in edit mode.
+          doc.addEventListener(
+            "pointerdown",
+            () => {
+              if (this.selectionPopover.open)
+                this.hideSelectionPopover();
+            },
+            { passive: true },
+          );
           doc.addEventListener(
             "keyup",
             (ev: KeyboardEvent) => {
@@ -826,7 +853,13 @@ document.addEventListener("alpine:init", () => {
       });
       this.view.addEventListener("show-annotation", (e: any) => {
         const { value, index, range } = e.detail;
-        const h = this.highlightItems.find((x) => x.cfi === value);
+        // Device-synced highlights are painted with a synthesized range
+        // CFI (renderCfi) while the stored locator stays a point CFI, so a
+        // click reports the render value — match either or editing
+        // device highlights is impossible.
+        const h = this.highlightItems.find(
+          (x) => x.cfi === value || x.renderCfi === value,
+        );
         if (!h) return;
         const doc = this.renderer
           ?.getContents?.()
@@ -853,6 +886,7 @@ document.addEventListener("alpine:init", () => {
         const { fraction, location, pageItem, cfi, tocItem, section } =
           e.detail;
         this.hideSelectionPopover();
+        this.lastCfi = cfi || "";
         this.lastRelocateDetail = {
           fraction,
           location,
@@ -898,19 +932,27 @@ document.addEventListener("alpine:init", () => {
       document.addEventListener("keydown", (ev: KeyboardEvent) =>
         this.handleKeydown(ev),
       );
-      if (this.isFixedLayout && config.savedPage != null && config.savedPage > 0) {
+      // Reading position comes from the database, fetched fresh at open
+      // (the rendered page carries no snapshot of it).
+      const saved = await this.fetchSavedLocation();
+      if (this.isFixedLayout && saved.page != null && saved.page > 0) {
         // Fixed-layout & comics: a page index is the exact, universal locator.
         // A bare number navigates directly to the section index in foliate.
-        await this.view.init({ lastLocation: config.savedPage - 1 })
-      } else if (config.savedCfi) {
-        await this.view.init({ lastLocation: config.savedCfi })
-      } else if (config.savedPercentage && config.savedPercentage > 0) {
+        await this.view.init({ lastLocation: saved.page - 1 })
+      } else if (saved.cfi) {
+        await this.view.init({ lastLocation: saved.cfi })
+      } else if (saved.percentage != null && saved.percentage > 0) {
         await this.view.init({
-          lastLocation: { fraction: config.savedPercentage },
+          lastLocation: { fraction: saved.percentage },
         })
       } else {
         await this.view.init({})
       }
+      // The position restored above (or the start of the book on a fresh
+      // open) is the baseline: only relocations that actually move from
+      // it may write progress.
+      this.lastSyncedCfi = this.lastCfi;
+      this.lastSyncedFraction = this.lastRelocateDetail?.fraction ?? -1;
       // The renderer only knows it's a PDF once frames exist (they carry
       // pdf.js onZoom), i.e. after init has rendered the first spread.
       // Read it now and apply the saved pointer mode — this also makes the
@@ -920,9 +962,19 @@ document.addEventListener("alpine:init", () => {
         this.renderer.setAttribute("interaction-mode", this.interactionMode);
       }
       this.fxZoomed = this.isFixedLayout && this.renderer?.zoom != null;
-      this.initTime = Date.now();
+      // A bfcache-resurrected page is stale by definition: re-baseline to
+      // its frozen position so it can't write that back until the user
+      // actually navigates again.
+      window.addEventListener("pageshow", (e: PageTransitionEvent) => {
+        if (e.persisted) {
+          this.lastSyncedCfi = this.lastCfi;
+          this.lastSyncedFraction =
+            this.lastRelocateDetail?.fraction ?? -1;
+        }
+      });
       this.fetchReadingSpeed();
       this.refreshAnnotations();
+      this.refreshBookmarks();
       this.setupChrome();
       this.setupTapZones();
     },
@@ -985,6 +1037,26 @@ document.addEventListener("alpine:init", () => {
       if (!window.matchMedia("(pointer: coarse)").matches) return;
       const vp = document.getElementById("reader-viewport");
       if (vp) this.attachTapZoneListeners(vp as HTMLElement, false);
+      // Host-document selections (fixed-layout/PDF text layers, margins):
+      // selectionchange never crosses iframe boundaries, so register per
+      // surface.
+      document.addEventListener("selectionchange", () => {
+        const sel = document.getSelection();
+        this.noteSelectionActivity(
+          !!sel && !sel.isCollapsed && !!sel.toString(),
+        );
+      });
+    },
+    // Record selection state and abort any armed tap action: a selection
+    // appearing right after finger-lift means the "tap" was actually a
+    // long-press selection engaging, and paging away would destroy the
+    // gesture the user just made.
+    noteSelectionActivity(hasSelection: boolean) {
+      this.anySelection = hasSelection;
+      if (hasSelection && this.tapZoneTimer) {
+        clearTimeout(this.tapZoneTimer);
+        this.tapZoneTimer = null;
+      }
     },
     attachTapZoneListeners(surface: HTMLElement, isDoc: boolean) {
       let downX = 0;
@@ -992,6 +1064,12 @@ document.addEventListener("alpine:init", () => {
       let downT = 0;
       let downId = -1;
       let moved = false;
+      // Android fires contextmenu when a long-press engages text
+      // selection: that press must never resolve into a tap action, even
+      // when it was released inside the 500ms tap window (the selection
+      // engaging and the guard racing is exactly how corner selections
+      // used to page back instead).
+      let longPressed = false;
       surface.addEventListener(
         "pointerdown",
         (e: PointerEvent) => {
@@ -1001,6 +1079,21 @@ document.addEventListener("alpine:init", () => {
           downT = Date.now();
           downId = e.pointerId;
           moved = false;
+          longPressed = false;
+        },
+        { passive: true },
+      );
+      surface.addEventListener("contextmenu", () => {
+        longPressed = true;
+      }, { passive: true });
+      // The browser takes over the gesture (text selection, scroll) with
+      // pointercancel — no pointerup will follow. Drop the tracked
+      // pointer so stale state can never match a later touch.
+      surface.addEventListener(
+        "pointercancel",
+        () => {
+          downId = -1;
+          moved = false;
         },
         { passive: true },
       );
@@ -1018,7 +1111,7 @@ document.addEventListener("alpine:init", () => {
         (e: PointerEvent) => {
           if (e.pointerId !== downId) return;
           downId = -1;
-          if (moved || Date.now() - downT > 500) return;
+          if (moved || longPressed || Date.now() - downT > 500) return;
           if (!this.tapZonesEnabled) return;
           const target = e.target as HTMLElement | null;
           if (
@@ -1029,6 +1122,10 @@ document.addEventListener("alpine:init", () => {
             return;
           const sel = isDoc ? (surface as any).getSelection?.() : null;
           if (sel?.toString?.()) return;
+          // Host-surface blind spot: selections living in content iframes
+          // (or the host's own fixed-layout text layer) never show in a
+          // per-surface check — the tracked flag covers them.
+          if (!isDoc && this.anySelection) return;
           // No tap actions while a fixed-layout page is zoomed — taps then
           // belong to the content (and double-tap zoom).
           if (this.isFixedLayout && this.renderer?.zoom != null) return;
@@ -1343,7 +1440,23 @@ document.addEventListener("alpine:init", () => {
         if (!resp.ok) return;
         const row = await resp.json();
         const idx = this.highlightItems.findIndex((h) => h.id === p.id);
+        // The overlay is keyed by the value it was added with; an edit can
+        // change it (note/text edits change the synthesized range), so
+        // remove the old paint before re-adding or it ghosts.
+        const oldValue =
+          idx !== -1
+            ? this.highlightItems[idx].renderCfi ||
+              this.highlightItems[idx].cfi
+            : "";
         if (idx !== -1) this.highlightItems[idx] = this.mapHighlightRow(row);
+        const newValue =
+          idx !== -1
+            ? this.highlightItems[idx].renderCfi ||
+              this.highlightItems[idx].cfi
+            : "";
+        if (p.pdfPage < 0 && oldValue && oldValue !== newValue) {
+          this.view?.deleteAnnotation({ value: oldValue });
+        }
         // Re-add so the overlay redraws with the new color.
         if (p.pdfPage >= 0) {
           this.renderer?.addRectAnnotation?.({
@@ -1379,7 +1492,11 @@ document.addEventListener("alpine:init", () => {
         if (hl?.pdfPage >= 0) {
           this.renderer?.removeRectAnnotation?.(id);
         } else if (hl?.cfi) {
-          this.view?.deleteAnnotation({ value: hl.cfi });
+          // Delete with the value the overlay was added by: device-synced
+          // highlights paint a synthesized range, not the stored point CFI.
+          this.view?.deleteAnnotation({
+            value: hl.renderCfi || hl.cfi,
+          });
         }
         this.hideSelectionPopover();
       } catch (_e) {
@@ -1453,8 +1570,52 @@ document.addEventListener("alpine:init", () => {
         /* ignore note errors */
       }
     },
+    // Fresh reading position from the database — the single source of
+    // truth at open time. Fails soft to a fresh start: change detection
+    // against the restored baseline guarantees merely opening (even at
+    // the wrong spot) can never overwrite the stored position.
+    async fetchSavedLocation(): Promise<{
+      cfi?: string;
+      page?: number;
+      percentage?: number;
+    }> {
+      const token = getToken();
+      if (!token || !this.mediaItemId) return {};
+      try {
+        const resp = await fetch(
+          `/api/media-items/${this.mediaItemId}/progress`,
+          {
+            headers: { Authorization: `Bearer ${token}` },
+            cache: "no-store",
+          },
+        );
+        if (!resp.ok) return {};
+        const row: any = await resp.json();
+        const cfi: string = row?.epubcfi?.String ?? row?.epubcfi ?? "";
+        const page: number = row?.current_page?.Int32 ?? row?.current_page ?? 0;
+        // The stored percentage is a 0-1 fraction.
+        const pct: number = row?.percentage?.Float64 ?? row?.percentage ?? 0;
+        return {
+          cfi: typeof cfi === "string" ? cfi : "",
+          page: typeof page === "number" ? page : 0,
+          percentage: typeof pct === "number" ? pct : 0,
+        };
+      } catch (_e) {
+        return {};
+      }
+    },
     debouncedSaveProgress(fraction: number, location: any, cfi: string) {
-      if (Date.now() - this.initTime < 5000) return;
+      // Only an actual change from the last stored position writes
+      // progress: displaying a restored position must never overwrite a
+      // newer device push. Swipes and scrolls are handled inside foliate
+      // with no wrapper method to flag, so position — not intent — is the
+      // signal. Books without CFIs (fixed layout, PDF) compare fraction.
+      const currentCfi = cfi || "";
+      const changed =
+        currentCfi || this.lastSyncedCfi
+          ? currentCfi !== this.lastSyncedCfi
+          : Math.abs(fraction - this.lastSyncedFraction) > 1e-4;
+      if (!changed) return;
       if (this.saveTimeout) clearTimeout(this.saveTimeout);
       this.saveTimeout = setTimeout(() => {
         this.saveProgress(fraction, location, cfi);
@@ -1505,6 +1666,8 @@ document.addEventListener("alpine:init", () => {
           },
           body: JSON.stringify(body),
         });
+        this.lastSyncedCfi = cfi || "";
+        this.lastSyncedFraction = fraction;
       } catch (_e) {
         // silent fail — progress save is non-critical
       }
@@ -2467,11 +2630,18 @@ document.addEventListener("alpine:init", () => {
     },
     handleKeydown(event: KeyboardEvent) {
       const k = event.key;
-      // Never hijack keys while the user is typing in a form control.
-      const tag = (event.target as HTMLElement)?.tagName;
+      // Never hijack keys while the user is typing in a form control: the
+      // field must receive h/l page turns, +/− zoom, and caret arrows.
+      // Escape stays live so popovers/drawers can still be dismissed from
+      // the keyboard even mid-note.
+      const t = event.target as HTMLElement | null;
       const typing =
-        tag === "INPUT" || tag === "SELECT" || tag === "TEXTAREA";
+        t?.tagName === "INPUT" ||
+        t?.tagName === "SELECT" ||
+        t?.tagName === "TEXTAREA" ||
+        !!t?.isContentEditable;
       this.pokeChrome();
+      if (typing && k !== "Escape") return;
       if (k === "ArrowLeft" || k === "h") {
         if (event.altKey) {
           event.preventDefault();
@@ -2500,7 +2670,7 @@ document.addEventListener("alpine:init", () => {
       } else if (k === "F1") {
         event.preventDefault();
         this.toggleHelp();
-      } else if (!typing) {
+      } else {
         if (k === "t") this.toggleTOC();
         else if (k === "s") this.toggleSettings();
         else if (k === "b") this.addBookmark();