feat: add PDF OCR reader support

app.py

@@ -35,7 +35,8 @@ from search_indexes import (
     resolve_postings,
 )
 from reader_assets import (
-    READER_ASSET_FILENAMES, READER_BUCKET_PATH_RE, decode_reader_assets,
+    READER_ASSET_FILENAMES, READER_BUCKET_PATH_RE, READER_PDF_RANGE_BUCKET,
+    READER_PDF_RANGE_PATH_RE, decode_reader_assets,
 )
 from data_formats import (
     decode_browser_entry, decode_folder_browser_data, decode_folder_tree_data,
@@ -1461,12 +1462,14 @@ READER_ISOLATION_HEADERS = {
 }
 READER_DOCUMENT_MAX_BYTES = 512 * 1024 * 1024
 READER_RESOURCE_MAX_ARCHIVE_BYTES = 512 * 1024 * 1024
-READER_RESOURCE_MAX_BYTES = 16 * 1024 * 1024
+READER_RESOURCE_MAX_BYTES = 64 * 1024 * 1024
 READER_BUCKET_CACHE_TTL_SECONDS = 3600
 READER_BUCKET_CACHE_MAX_BYTES = 32 * 1024 * 1024
 READER_BUCKET_CACHE_MAX_ITEM_BYTES = 8 * 1024 * 1024
 READER_BUCKET_MAX_CONCURRENT_READS = 8
 READER_BUCKET_MAX_INFLIGHT = 32
+READER_OCR_CACHE_MAX_BYTES = 32 * 1024 * 1024
+READER_OCR_CACHE_MAX_ITEMS = 4
 READER_ARCHIVE_MAX_ENTRIES = 20_000
 READER_ARCHIVE_MAX_EXPANDED_BYTES = 1536 * 1024 * 1024
 READER_ARCHIVE_MAX_COMPRESSION_RATIO = 200
@@ -1608,15 +1611,17 @@ def validate_reader_archive(archive: bytes) -> None:
 READER_RESOURCE_TYPES = {
     "json": "application/json",
     "css": "text/css", "jpg": "image/jpeg", "jpeg": "image/jpeg", "png": "image/png",
-    "gif": "image/gif", "webp": "image/webp", "svg": "image/svg+xml", "ttf": "font/ttf",
+    "gif": "image/gif", "webp": "image/webp", "jxl": "image/jxl", "svg": "image/svg+xml", "ttf": "font/ttf",
     "otf": "font/otf", "woff": "font/woff", "woff2": "font/woff2", "mp3": "audio/mpeg",
-    "mp4": "video/mp4",
+    "mp4": "video/mp4", "gz": "application/gzip",
 }
 def initialize_reader_bucket_state(target_app: FastAPI) -> None:
     target_app.state.reader_bucket_cache = OrderedDict()
     target_app.state.reader_bucket_cache_bytes = 0
     target_app.state.reader_bucket_inflight = {}
     target_app.state.reader_bucket_semaphore = asyncio.Semaphore(READER_BUCKET_MAX_CONCURRENT_READS)
+    target_app.state.reader_ocr_cache = OrderedDict()
+    target_app.state.reader_ocr_cache_bytes = 0
 
 
 async def shutdown_reader_bucket_state(target_app: FastAPI) -> None:
@@ -1628,14 +1633,24 @@ async def shutdown_reader_bucket_state(target_app: FastAPI) -> None:
         await asyncio.gather(*tasks, return_exceptions=True)
     target_app.state.reader_bucket_cache.clear()
     target_app.state.reader_bucket_cache_bytes = 0
+    target_app.state.reader_ocr_cache.clear()
+    target_app.state.reader_ocr_cache_bytes = 0
 
 
-def is_reader_bucket_cacheable(path: str) -> bool:
-    return path.endswith("/page-manifest.json") or path.endswith("/pages/page-000001.webp")
+def is_reader_bucket_cacheable(bucket: str, path: str) -> bool:
+    return (bucket == "vomebook/pdf-pages" and
+            (path.endswith("/page-manifest.json") or path.endswith("/ocr-manifest.json")
+             or path.endswith("/ocr/book-text.json.gz") or path.endswith("/pages/page-000001.webp")))
 
 
-def read_reader_bucket_resource(path: str) -> bytes:
-    uri = f"hf://buckets/vomebook/pdf-pages/{path}"
+def reader_bucket_cache_key(bucket: str, path: str):
+    # Keep the default bucket namespace compatible with the existing cache;
+    # isolate the optional optimized-PDF bucket by namespace.
+    return path if bucket == "vomebook/pdf-pages" else (bucket, path)
+
+
+def read_reader_bucket_resource(path: str, bucket: str = "vomebook/pdf-pages") -> bytes:
+    uri = f"hf://buckets/{bucket}/{path}"
     with HfFileSystem().open(uri, "rb") as stream:
         payload = stream.read(READER_RESOURCE_MAX_BYTES + 1)
     if len(payload) > READER_RESOURCE_MAX_BYTES:
@@ -1643,54 +1658,116 @@ def read_reader_bucket_resource(path: str) -> bytes:
     return payload
 
 
-async def get_reader_bucket_resource(path: str) -> bytes:
+async def get_reader_bucket_resource(path: str, bucket: str = "vomebook/pdf-pages") -> bytes:
     state = app.state
-    if is_reader_bucket_cacheable(path):
-        cached = state.reader_bucket_cache.get(path)
+    cache_key = path if bucket == "vomebook/pdf-pages" else (bucket, path)
+    if is_reader_bucket_cacheable(bucket, path):
+        cached = state.reader_bucket_cache.get(cache_key)
         if cached:
             cached_at, payload = cached
             if time.monotonic() - cached_at < READER_BUCKET_CACHE_TTL_SECONDS:
-                state.reader_bucket_cache.move_to_end(path)
+                state.reader_bucket_cache.move_to_end(cache_key)
                 return payload
-            state.reader_bucket_cache.pop(path)
+            state.reader_bucket_cache.pop(cache_key)
             state.reader_bucket_cache_bytes -= len(payload)
 
-    task = state.reader_bucket_inflight.get(path)
+    task = state.reader_bucket_inflight.get(cache_key)
     if task is None:
         if len(state.reader_bucket_inflight) >= READER_BUCKET_MAX_INFLIGHT:
             raise RuntimeError("too many reader bucket requests")
         async def load() -> bytes:
             try:
                 async with state.reader_bucket_semaphore:
-                    payload = await asyncio.to_thread(read_reader_bucket_resource, path)
-                if is_reader_bucket_cacheable(path) and len(payload) <= READER_BUCKET_CACHE_MAX_ITEM_BYTES:
-                    previous = state.reader_bucket_cache.pop(path, None)
+                    loader = (lambda: read_reader_bucket_resource(path)
+                              if bucket == "vomebook/pdf-pages"
+                              else read_reader_bucket_resource(path, bucket))
+                    payload = await asyncio.to_thread(loader)
+                if is_reader_bucket_cacheable(bucket, path) and len(payload) <= READER_BUCKET_CACHE_MAX_ITEM_BYTES:
+                    previous = state.reader_bucket_cache.pop(cache_key, None)
                     if previous:
                         state.reader_bucket_cache_bytes -= len(previous[1])
-                    state.reader_bucket_cache[path] = (time.monotonic(), payload)
+                    state.reader_bucket_cache[cache_key] = (time.monotonic(), payload)
                     state.reader_bucket_cache_bytes += len(payload)
                     while state.reader_bucket_cache_bytes > READER_BUCKET_CACHE_MAX_BYTES:
                         _, (_, evicted) = state.reader_bucket_cache.popitem(last=False)
                         state.reader_bucket_cache_bytes -= len(evicted)
                 return payload
             finally:
-                if state.reader_bucket_inflight.get(path) is asyncio.current_task():
-                    state.reader_bucket_inflight.pop(path, None)
+                if state.reader_bucket_inflight.get(cache_key) is asyncio.current_task():
+                    state.reader_bucket_inflight.pop(cache_key, None)
 
         task = asyncio.create_task(load())
         task.add_done_callback(lambda done: None if done.cancelled() else done.exception())
-        state.reader_bucket_inflight[path] = task
+        state.reader_bucket_inflight[cache_key] = task
     return await asyncio.shield(task)
 
 
+def parse_reader_ocr_book(raw: bytes) -> tuple[list[tuple[int, str, str]], int]:
+    """Decode and validate the compact per-page OCR text cache off the event loop."""
+    with gzip.GzipFile(fileobj=io.BytesIO(raw)) as stream:
+        decoded = stream.read(READER_RESOURCE_MAX_BYTES + 1)
+    if len(decoded) > READER_RESOURCE_MAX_BYTES:
+        raise ValueError("PDF OCR text index is too large")
+    payload = json.loads(decoded)
+    pages = payload.get("pages") if isinstance(payload, dict) else None
+    if (not isinstance(pages, list) or len(pages) > 200000
+            or payload.get("version") != 1 or payload.get("kind") != "pdf-ocr-book-text"):
+        raise ValueError("invalid PDF OCR text index")
+    output = []
+    total_bytes = 0
+    previous = 0
+    for item in pages:
+        if (not isinstance(item, dict) or not isinstance(item.get("page"), int)
+                or item["page"] < 1 or item["page"] <= previous
+                or not isinstance(item.get("text"), str)):
+            raise ValueError("invalid PDF OCR text page")
+        text = item["text"]
+        total_bytes += len(text.encode("utf-8"))
+        if total_bytes > READER_RESOURCE_MAX_BYTES:
+            raise ValueError("PDF OCR text index is too large")
+        output.append((item["page"], text, text.casefold()))
+        previous = item["page"]
+    return output, total_bytes
+
+
+async def get_reader_ocr_book(path: str) -> list[tuple[int, str, str]]:
+    state = app.state
+    if not hasattr(state, "reader_ocr_cache"):
+        state.reader_ocr_cache = OrderedDict()
+        state.reader_ocr_cache_bytes = 0
+    cached = state.reader_ocr_cache.get(path)
+    if cached:
+        cached_at, pages, size = cached
+        if time.monotonic() - cached_at < READER_BUCKET_CACHE_TTL_SECONDS:
+            state.reader_ocr_cache.move_to_end(path)
+            return pages
+        state.reader_ocr_cache.pop(path)
+        state.reader_ocr_cache_bytes -= size
+    raw = await get_reader_bucket_resource(path)
+    pages, size = await asyncio.to_thread(parse_reader_ocr_book, raw)
+    if size <= READER_OCR_CACHE_MAX_BYTES:
+        previous = state.reader_ocr_cache.pop(path, None)
+        if previous:
+            state.reader_ocr_cache_bytes -= previous[2]
+        state.reader_ocr_cache[path] = (time.monotonic(), pages, size)
+        state.reader_ocr_cache_bytes += size
+        while (len(state.reader_ocr_cache) > READER_OCR_CACHE_MAX_ITEMS
+               or state.reader_ocr_cache_bytes > READER_OCR_CACHE_MAX_BYTES):
+            _, (_, _, evicted_size) = state.reader_ocr_cache.popitem(last=False)
+            state.reader_ocr_cache_bytes -= evicted_size
+    return pages
+
+
 @app.api_route("/api/reader-bucket-resource", methods=["GET", "HEAD"])
-async def api_reader_bucket_resource(path: str = Query(...), request: Request = None):
+async def api_reader_bucket_resource(path: str = Query(...), bucket: str = "vomebook/pdf-pages", request: Request = None):
     resource_path = unquote(unquote(path)).replace("\\", "/").lstrip("/")
-    if not READER_BUCKET_PATH_RE.fullmatch(resource_path):
+    valid = ((bucket == "vomebook/pdf-pages" and READER_BUCKET_PATH_RE.fullmatch(resource_path))
+             or (bucket == READER_PDF_RANGE_BUCKET and READER_PDF_RANGE_PATH_RE.fullmatch(resource_path)))
+    if not valid:
         return JSONResponse({"error": "不允许的阅读资源路径"}, status_code=400,
                             headers={"Cache-Control": "no-store"})
     try:
-        payload = await get_reader_bucket_resource(resource_path)
+        payload = await get_reader_bucket_resource(resource_path, bucket)
     except FileNotFoundError:
         return JSONResponse({"error": "阅读资源不存在"}, status_code=404,
                             headers={"Cache-Control": "no-store"})
@@ -1867,6 +1944,61 @@ async def api_reader_resolve(id: str = Query(..., min_length=13, max_length=13))
     return JSONResponse({"error": "阅读文件不存在"}, status_code=404)
 
 
+@app.get("/api/reader-ocr-search")
+async def api_reader_ocr_search(
+    id: str = Query(..., min_length=13, max_length=13),
+    q: str = Query(..., min_length=1, max_length=256),
+    page: int = Query(1, ge=1, le=1000000),
+    page_size: int = Query(50, ge=1, le=100),
+):
+    """Search one PDF's immutable OCR text without loading it into app memory."""
+    resolved = await api_reader_resolve(id)
+    if resolved.status_code != 200:
+        return resolved
+    try:
+        data = json.loads(resolved.body)
+        manifest_url = str(data.get("ocr_manifest") or "")
+        parsed = urlparse(manifest_url)
+        parameters = parse_qs(parsed.query)
+        manifest_path = parameters.get("path", [""])[0]
+        if (parsed.path != "/api/reader-bucket-resource" or set(parameters) != {"path"}
+                or not READER_BUCKET_PATH_RE.fullmatch(manifest_path)
+                or not manifest_path.endswith("/ocr-manifest.json")):
+            return JSONResponse({"error": "本书暂无 OCR 索引"}, status_code=404)
+        manifest = json.loads(await get_reader_bucket_resource(manifest_path))
+        book = manifest.get("book_text") if isinstance(manifest, dict) else None
+        book_path = book.get("path") if isinstance(book, dict) else ""
+        if (not isinstance(book_path, str) or not READER_BUCKET_PATH_RE.fullmatch(book_path)
+                or not book_path.endswith("/book-text.json.gz")):
+            return JSONResponse({"error": "OCR 索引损坏"}, status_code=502)
+        pages = await get_reader_ocr_book(book_path)
+        needle = q.casefold()
+        matches = []
+        for page_number, text, folded in pages:
+            start = 0
+            while True:
+                found = folded.find(needle, start)
+                if found < 0:
+                    break
+                end = found + len(q)
+                snippet_start = max(0, found - 72)
+                snippet_end = min(len(text), end + 88)
+                matches.append({
+                    "page": page_number, "start": found, "length": len(q),
+                    "snippet": text[snippet_start:snippet_end],
+                    "snippet_start": found - snippet_start,
+                })
+                start = end
+        total = len(matches)
+        offset = (page - 1) * page_size
+        return JSONResponse({
+            "version": 1, "page": page, "page_size": page_size, "total": total,
+            "results": matches[offset:offset + page_size],
+        }, headers={"Cache-Control": "no-store"})
+    except (ValueError, TypeError, KeyError, EOFError, gzip.BadGzipFile, zlib.error):
+        return JSONResponse({"error": "OCR 索引损坏"}, status_code=502)
+
+
 @app.api_route("/api/reader-content", methods=["GET", "HEAD"])
 async def api_reader_content(request: Request, url: Optional[str] = Query(default=None), id: Optional[str] = Query(default=None)):
     if id and not url:
@@ -1885,9 +2017,11 @@ async def api_reader_content(request: Request, url: Optional[str] = Query(defaul
         return JSONResponse({"error": str(exc)}, status_code=403)
     if not parsed.scheme and not parsed.netloc and parsed.path == "/api/reader-bucket-resource" and not parsed.fragment:
         parameters = parse_qs(parsed.query)
-        if set(parameters) != {"path"} or len(parameters["path"]) != 1:
+        if (set(parameters) - {"path", "bucket"} or set(parameters) < {"path"}
+                or len(parameters["path"]) != 1
+                or len(parameters.get("bucket", ["x"])) != 1):
             return JSONResponse({"error": "不允许的阅读资源路径"}, status_code=400)
-        return await api_reader_bucket_resource(parameters["path"][0], request)
+        return await api_reader_bucket_resource(parameters["path"][0], parameters.get("bucket", ["vomebook/pdf-pages"])[0], request)
     try:
         target_url = validate_reader_source_url(url)
     except ValueError as exc:

reader_assets.py

@@ -18,7 +18,11 @@ READER_ASSET_FILENAMES = {
     "v": {"video.mp4"},
 }
 READER_BUCKET_PATH_RE = re.compile(
-    r"^objects/[0-9a-f]{2}/[0-9a-f]{64}/[0-9a-f]{16}/(?:page-manifest\.json|pages/page-[0-9]{6}\.webp)$"
+    r"^objects/[0-9a-f]{2}/[0-9a-f]{64}/[0-9a-f]{16}/(?:page-manifest\.json|ocr-manifest\.json|pages/page-[0-9]{6}\.(?:webp|jxl)|ocr/(?:page-[0-9]{6}\.json\.gz|book-text\.json\.gz))$"
+)
+READER_PDF_RANGE_BUCKET = "vomebook/pdf-optimized"
+READER_PDF_RANGE_PATH_RE = re.compile(
+    r"^objects/[0-9a-f]{2}/[0-9a-f]{64}/[a-z0-9-]+/document\.pdf$"
 )
 
 
@@ -39,7 +43,7 @@ def decode_reader_assets(
         raise ValueError("invalid reader assets sidecar")
     clean = {}
     for key, entry in files.items():
-        if not isinstance(key, str) or not isinstance(entry, dict) or entry.get("s") not in (2, 4):
+        if not isinstance(key, str) or not isinstance(entry, dict) or entry.get("s") not in (2, 3, 4):
             continue
         if entry.get("s") == 2:
             path = entry.get("p")
@@ -54,6 +58,7 @@ def decode_reader_assets(
                 continue
             chapter_manifest = entry.get("c")
             fallback = entry.get("f")
+            ocr_manifest = entry.get("o")
             if chapter_manifest is not None and (
                 mode not in {"e", "p"}
                 or not isinstance(chapter_manifest, str)
@@ -67,14 +72,25 @@ def decode_reader_assets(
                 or not fallback.endswith("/document.pdf")
             ):
                 continue
-            bucket = entry.get("b")
-            if bucket is not None and (
-                bucket != "vomebook/pdf-pages"
-                or mode != "p"
-                or not path.endswith("/page-manifest.json")
-                or not READER_BUCKET_PATH_RE.fullmatch(path)
+            if ocr_manifest is not None and (
+                not isinstance(ocr_manifest, str)
+                or not READER_ASSET_PATH_RE.fullmatch(ocr_manifest)
+                or not ocr_manifest.endswith("/ocr-manifest.json")
             ):
                 continue
+            if entry.get("b") is not None and entry.get("b") not in {"vomebook/pdf-pages", READER_PDF_RANGE_BUCKET}:
+                continue
+            if entry.get("ob") is not None and entry.get("ob") != "vomebook/pdf-pages":
+                continue
+            bucket = entry.get("b")
+            if bucket == "vomebook/pdf-pages" and (
+                mode != "p" or not path.endswith("/page-manifest.json")
+                or not READER_BUCKET_PATH_RE.fullmatch(path)):
+                continue
+            if bucket == READER_PDF_RANGE_BUCKET and (
+                mode != "p" or not path.endswith("/document.pdf")
+                or not READER_PDF_RANGE_PATH_RE.fullmatch(path)):
+                continue
             clean[key] = {
                 "s": 2,
                 "m": mode,
@@ -82,7 +98,16 @@ def decode_reader_assets(
                 **({"b": bucket} if bucket else {}),
                 **({"c": chapter_manifest} if chapter_manifest else {}),
                 **({"f": fallback} if fallback else {}),
+                **({"o": ocr_manifest} if ocr_manifest else {}),
+                **({"ob": "vomebook/pdf-pages"} if entry.get("ob") else {}),
+                **({"om": entry.get("om")} if isinstance(entry.get("om"), str) else {}),
             }
         else:
-            clean[key] = {"s": 4}
+            ocr_manifest = entry.get("o")
+            if (isinstance(ocr_manifest, str) and READER_ASSET_PATH_RE.fullmatch(ocr_manifest)
+                    and ocr_manifest.endswith("/ocr-manifest.json")):
+                clean[key] = {"s": 3, "m": "p", "o": ocr_manifest, "b": "vomebook/pdf-pages",
+                              **({"om": entry.get("om")} if isinstance(entry.get("om"), str) else {})}
+            else:
+                clean[key] = {"s": 4}
     return {"v": 1, "f": clean}

record_metadata.py

@@ -73,8 +73,11 @@ def enrich_browser_entry(repo: str, path: str, entry: dict) -> dict:
 
 def reader_asset_url(asset: dict) -> str:
     path = quote(str(asset.get("p") or ""), safe="/")
-    if asset.get("b") == "vomebook/pdf-pages":
-        return f"/api/reader-bucket-resource?path={path}"
+    bucket = asset.get("b")
+    if bucket in {"vomebook/pdf-pages", "vomebook/pdf-optimized"}:
+        prefix = ("/api/reader-bucket-resource?path=" if bucket == "vomebook/pdf-pages"
+                  else f"/api/reader-bucket-resource?bucket={quote(bucket, safe='')}&path=")
+        return prefix + path
     return READER_ASSETS_BASE + path
 
 
@@ -94,9 +97,25 @@ def reader_extension_for_asset(asset: dict, original_extension: str = "") -> str
 
 
 def reader_asset_fields(asset: dict, original_extension: str) -> dict:
+    ocr_path = str(asset.get("o") or "")
+    fields = {}
+    if ocr_path and ocr_path.endswith("/ocr-manifest.json"):
+        fields["ocr_manifest"] = (
+            f"https://voiceofml-search.hf.space/api/reader-bucket-resource?path={quote(ocr_path, safe='/')}"
+            if asset.get("b") == "vomebook/pdf-pages" or asset.get("ob") == "vomebook/pdf-pages" else f"{READER_ASSETS_BASE}{ocr_path}"
+        )
+        fields["ocr_mode"] = str(asset.get("om") or "")
+    if asset.get("s") == 3:
+        return fields
     if asset.get("s") != 2 or asset.get("m") not in READER_ASSET_MODES or not asset.get("p"):
-        return {}
-    fields = {"url": reader_asset_url(asset), "extension": reader_extension_for_asset(asset, original_extension)}
+        return fields
+    fields.update({"url": reader_asset_url(asset), "extension": reader_extension_for_asset(asset, original_extension)})
+    if ocr_path and ocr_path.endswith("/ocr-manifest.json"):
+        fields["ocr_manifest"] = (
+            f"https://voiceofml-search.hf.space/api/reader-bucket-resource?path={quote(ocr_path, safe='/')}"
+            if asset.get("b") == "vomebook/pdf-pages" or asset.get("ob") == "vomebook/pdf-pages" else f"{READER_ASSETS_BASE}{ocr_path}"
+        )
+        fields["ocr_mode"] = str(asset.get("om") or "")
     for key, field in (("c", "chapter_manifest"), ("f", "fallback")):
         if asset.get(key):
             fields[field] = f"{READER_ASSETS_BASE}{asset[key]}"
@@ -108,7 +127,8 @@ def enrich_reader_record(record: dict, asset: dict) -> dict:
     fields = reader_asset_fields(asset, record.get("Extension", ""))
     if fields:
         for source, target in (("url", "ReaderLink"), ("extension", "ReaderExtension"),
-                               ("chapter_manifest", "ReaderChapterManifest"), ("fallback", "ReaderFallback")):
+                               ("chapter_manifest", "ReaderChapterManifest"), ("fallback", "ReaderFallback"),
+                               ("ocr_manifest", "ReaderOcrManifest"), ("ocr_mode", "ReaderOcrMode")):
             if source in fields:
                 result[target] = fields[source]
         result["DownloadLink"] = record.get("Link") or build_record_link(record)

static/reader-contract.js

@@ -212,16 +212,19 @@
 
   const assetRoot = String.raw`objects/[0-9a-f]{2}/[0-9a-f]{64}/`;
   const assetVersion = String.raw`(?:[0-9a-f]{16}/)?`;
-  const assetPages = String.raw`(?:page-manifest\.json|pages/page-[0-9]{6}\.webp)`;
+  const assetPages = String.raw`(?:page-manifest\.json|pages/page-[0-9]{6}\.(?:webp|jxl))`;
+  const assetOcr = String.raw`(?:ocr-manifest\.json|ocr/(?:page-[0-9]{6}\.json\.gz|book-text\.json\.gz))`;
   const assetDocument = String.raw`(?:linearized\.pdf|document\.(?:pdf|epub|mobi|azw|azw3|fb2|docx|html)|book\.epub|audio\.mp3|video\.mp4)`;
   const assetChapters = String.raw`(?:chapter-manifest\.json|epub-chapters/(?:chapter-manifest\.json|chapters/chapter-[0-9]{4}\.xhtml|resources/[A-Za-z0-9._~%+\-/]+|epub-search-index\.json\.gz))`;
   const assetPrimaryPattern = new RegExp(
     `^${assetRoot}${assetVersion}(?:${assetPages}|(?:[a-z0-9-]+/)?${assetDocument})$`
   );
   const assetSourcePattern = new RegExp(
-    `^(?:pdf_manifest\\.json|${assetRoot}${assetVersion}(?:${assetPages}|(?:[a-z0-9-]+/)?(?:${assetDocument}|${assetChapters})))$`
+    `^(?:pdf_manifest\\.json|${assetRoot}${assetVersion}(?:${assetPages}|${assetOcr}|(?:[a-z0-9-]+/)?(?:${assetDocument}|${assetChapters})))$`
   );
-  const bucketPathPattern = new RegExp(`^${assetRoot}${assetVersion}${assetPages}$`);
+  const bucketPathPattern = new RegExp(`^${assetRoot}${assetVersion}(?:${assetPages}|${assetOcr})$`);
+  const optimizedBucket = "vomebook/pdf-optimized";
+  const optimizedPathPattern = new RegExp(`^${assetRoot}(?:[a-z0-9-]+/)?document\\.pdf$`);
   const versionedBucketPathPattern = new RegExp(`^${assetRoot}[0-9a-f]{16}/${assetPages}$`);
   const assetBase = "https://huggingface.co/datasets/vomebook/Reader-Assets/resolve/main/";
   const assetModes = Object.freeze({
@@ -233,7 +236,8 @@
     v: "video"
   });
 
-  function isBucketPath(path, versioned = false) {
+  function isBucketPath(path, versioned = false, bucket = "vomebook/pdf-pages") {
+    if (bucket === optimizedBucket) return optimizedPathPattern.test(path);
     return (versioned ? versionedBucketPathPattern : bucketPathPattern).test(path);
   }
 
@@ -267,16 +271,21 @@
       }
       if (!path.endsWith("/page-manifest.json")) return null;
       const rootPath = path.slice(0, -"/page-manifest.json".length);
+      const pathPrefix = bucket ? "" : url.pathname.slice(0, -path.length);
       return {
         root: rootPath,
+        assetUrl(relativePath) {
+          const target = new URL(url.href);
+          if (bucket) target.searchParams.set("path", relativePath);
+          else target.pathname = `${pathPrefix}${relativePath}`;
+          return target.href;
+        },
         pageUrl(page) {
           if (!Number.isInteger(page) || page < 1 || page > 999999)
             throw new Error("PDF_PAGE_INVALID");
           const target = new URL(url.href);
           const filename = `pages/page-${String(page).padStart(6, "0")}.webp`;
-          if (bucket) target.searchParams.set("path", `${rootPath}/${filename}`);
-          else target.pathname = target.pathname.replace(/page-manifest\.json$/, filename);
-          return target.href;
+          return this.assetUrl(`${rootPath}/${filename}`);
         }
       };
     } catch (_) {
@@ -292,13 +301,21 @@
 
   function assetFields(asset, bucketBase) {
     const path = String(asset?.p || "");
-    const bucket = isBucketPath(path, true);
+    const ocrPath = String(asset?.o || "");
+    const ocrBucket = asset?.b === "vomebook/pdf-pages" || asset?.ob === "vomebook/pdf-pages";
+    const ocrUrl = ocrPath.endsWith("/ocr-manifest.json") && ocrBucket && isBucketPath(ocrPath, true)
+      ? `${bucketBase}?path=${encodeURIComponent(ocrPath)}`
+      : "";
+    if (asset?.s === 3 && ocrUrl)
+      return { ReaderOcrManifest: ocrUrl, ReaderOcrMode: String(asset.om || "") };
+    const bucketName = String(asset?.b || "vomebook/pdf-pages");
+    const bucket = isBucketPath(path, true, bucketName);
     if (
       !asset ||
       asset.s !== 2 ||
       !Object.prototype.hasOwnProperty.call(assetModes, asset.m) ||
       !assetPrimaryPattern.test(path) ||
-      (bucket && asset.b !== "vomebook/pdf-pages")
+      (bucket && !["vomebook/pdf-pages", optimizedBucket].includes(asset?.b))
     )
       return null;
     const nativeExtension =
@@ -310,10 +327,14 @@
           ? "pdf-pages"
           : assetModes[asset.m];
     return {
-      ReaderLink: bucket ? `${bucketBase}?path=${encodeURIComponent(path)}` : assetBase + path,
+      ReaderLink: bucket
+        ? `${bucketBase}?${asset.b === optimizedBucket ? `bucket=${encodeURIComponent(asset.b)}&` : ""}path=${encodeURIComponent(path)}`
+        : assetBase + path,
       ReaderExtension: asset.c ? "epub-chapters" : extension,
       ReaderChapterManifest: asset.c ? assetBase + asset.c : "",
-      ReaderFallback: asset.f ? assetBase + asset.f : ""
+      ReaderFallback: asset.f ? assetBase + asset.f : "",
+      ReaderOcrManifest: ocrUrl || (ocrPath.endsWith("/ocr-manifest.json") ? assetBase + ocrPath : ""),
+      ReaderOcrMode: String(asset.om || "")
     };
   }
 
@@ -340,6 +361,8 @@
       params.set("download", record.DownloadLink || record.downloadLink);
     if (!shortId && (record.OcrUrl || record.ocrUrl))
       params.set("ocr", record.OcrUrl || record.ocrUrl);
+    if (!shortId && (record.ReaderOcrManifest || record.readerOcrManifest))
+      params.set("ocr_manifest", record.ReaderOcrManifest || record.readerOcrManifest);
     if (!shortId && (record.ReaderFallback || record.readerFallback))
       params.set("fallback", record.ReaderFallback || record.readerFallback);
     if (

static/reader-pdf-text.js

@@ -24,3 +24,22 @@ export function populatePdfTextLayer(layer, items, pdfViewport) {
     if (!layer.textContent.trim()) layer.textContent = "此页没有可提取文本";
   } else layer.textContent = plainText.trim() || "此页没有可提取文本";
 }
+
+export function populateOcrTextLayer(layer, blocks) {
+  const fragment = layer.ownerDocument.createDocumentFragment();
+  for (const block of blocks || []) {
+    const text = String(block?.t || "");
+    const box = Array.isArray(block?.b) ? block.b : [];
+    if (!text || box.length !== 4) continue;
+    const span = layer.ownerDocument.createElement("span");
+    span.textContent = text;
+    span.dataset.ocrText = text;
+    span.style.left = `${Math.max(0, Math.min(1, Number(box[0]) || 0)) * 100}%`;
+    span.style.top = `${Math.max(0, Math.min(1, Number(box[1]) || 0)) * 100}%`;
+    span.style.width = `${Math.max(0, Math.min(1, Number(box[2]) - Number(box[0])) * 100)}%`;
+    span.style.height = `${Math.max(0.5, Math.min(1, Number(box[3]) - Number(box[1])) * 100)}%`;
+    span.style.fontSize = `${Math.max(8, Math.min(72, Math.abs(Number(box[3]) - Number(box[1])) * 100))}%`;
+    fragment.appendChild(span);
+  }
+  layer.replaceChildren(fragment);
+}

static/reader-security.js

@@ -265,6 +265,52 @@
     }
     return manifest;
   }
+  const PDF_OCR_PATH = /^objects\/[0-9a-f]{2}\/[0-9a-f]{64}\/(?:[0-9a-f]{16}\/)?ocr\/(?:page-[0-9]{6}\.json\.gz|book-text\.json\.gz)$/;
+  const PDF_OCR_MANIFEST_PATH = /^objects\/[0-9a-f]{2}\/[0-9a-f]{64}\/(?:[0-9a-f]{16}\/)?ocr-manifest\.json$/;
+  const PDF_OCR_PAGE_PATH = /^objects\/[0-9a-f]{2}\/[0-9a-f]{64}\/(?:[0-9a-f]{16}\/)?pages\/page-[0-9]{6}\.(?:webp|jxl)$/;
+  const PDF_OCR_ROOT = /^(objects\/[0-9a-f]{2}\/[0-9a-f]{64}\/(?:[0-9a-f]{16})?)/;
+  function validatePdfOcrManifest(manifest) {
+    if (!manifest || manifest.version !== 1 || manifest.kind !== "pdf-ocr" ||
+        !Number.isInteger(manifest.page_count) || manifest.page_count < 1 ||
+        manifest.page_count > LIMITS.pdfPages || !Array.isArray(manifest.pages) ||
+        manifest.pages.length !== manifest.page_count)
+      throw error("PDF_OCR_MANIFEST_INVALID");
+    let root = "";
+    for (const [index, page] of manifest.pages.entries()) {
+      const expected = String(index + 1).padStart(6, "0");
+      const pageRoot = typeof page?.o === "string" ? PDF_OCR_ROOT.exec(page.o)?.[1] || "" : "";
+      if (!page || page.p !== index + 1 || !PDF_OCR_PATH.test(page.o) ||
+          page.o !== `${pageRoot}/ocr/page-${expected}.json.gz` ||
+          (page.w !== undefined && (typeof page.w !== "string" || !PDF_OCR_PAGE_PATH.test(page.w) ||
+            page.w !== `${pageRoot}/pages/page-${expected}.webp`)) ||
+          (page.j !== undefined && (typeof page.j !== "string" || !PDF_OCR_PAGE_PATH.test(page.j) ||
+            page.j !== `${pageRoot}/pages/page-${expected}.jxl`)) ||
+          (root && root !== pageRoot))
+        throw error("PDF_OCR_MANIFEST_INVALID");
+      root = pageRoot;
+    }
+    if (!manifest.book_text || typeof manifest.book_text.path !== "string" ||
+        !PDF_OCR_PATH.test(manifest.book_text.path) || manifest.book_text.path !== `${root}/ocr/book-text.json.gz` ||
+        (manifest.page_manifest !== undefined &&
+          (!manifest.page_manifest || typeof manifest.page_manifest.path !== "string" ||
+           !PDF_OCR_MANIFEST_PATH.test(manifest.page_manifest.path.replace("page-manifest.json", "ocr-manifest.json")))))
+      throw error("PDF_OCR_MANIFEST_INVALID");
+    return manifest;
+  }
+  function validatePdfOcrPage(payload, pageNumber) {
+    if (!payload || payload.version !== 1 || payload.kind !== "pdf-ocr-page" ||
+        payload.page !== pageNumber || !Array.isArray(payload.blocks) || payload.blocks.length > 10000 ||
+        !Number.isFinite(Number(payload.width)) || !Number.isFinite(Number(payload.height)))
+      throw error("PDF_OCR_PAGE_INVALID");
+    for (const block of payload.blocks) {
+      const box = block?.b;
+      if (!block || typeof block.t !== "string" || block.t.length > 4096 ||
+          !Array.isArray(box) || box.length !== 4 || box.some((value) => !Number.isFinite(Number(value))) ||
+          box[0] < 0 || box[1] < 0 || box[2] > 1 || box[3] > 1 || box[2] < box[0] || box[3] < box[1])
+        throw error("PDF_OCR_PAGE_INVALID");
+    }
+    return payload;
+  }
   function isZipContainer(extension, bytes) {
     return (
       ["epub", "fbz"].includes(String(extension || "").toLowerCase()) ||
@@ -280,6 +326,8 @@
     inspectZip,
     validateChapterManifest,
     validatePdfPageManifest,
+    validatePdfOcrManifest,
+    validatePdfOcrPage,
     isZipContainer
   });
 })(typeof self !== "undefined" ? self : globalThis);

static/reader.css

@@ -869,7 +869,7 @@ body {
   position: absolute;
   inset: 0;
   overflow: hidden;
-  pointer-events: none;
+  pointer-events: auto;
   white-space: pre;
   border: 0;
   color: transparent;
@@ -879,6 +879,8 @@ body {
   color: transparent;
   white-space: pre;
   transform-origin: left bottom;
+  user-select: text;
+  cursor: text;
 }
 .reader-pdf-text span.full-search-highlight {
   color: #1d2023;

static/reader.js

@@ -6,7 +6,7 @@ import "/static/reader-scroll-anchor.js";
 import "/static/reader-section-virtualizer.js";
 import "/static/reader-runtime.js";
 import "/static/reader-format-adapters.js";
-import { populatePdfTextLayer } from "/static/reader-pdf-text.js";
+import { populatePdfTextLayer, populateOcrTextLayer } from "/static/reader-pdf-text.js";
 // Engines and Reader lifecycle.
 const PDFJS_URL = VoiceOfMLReaderResources.vendorUrl("pdf", "/static/");
 const PDFJS_WORKER_URL = "/static/pdf-worker-wrapper.mjs";
@@ -296,6 +296,10 @@ updateDocumentState({
 });
 function applyReaderMetadata(data) {
   if (data) resolvedReaderData = { ...(resolvedReaderData || {}), ...data };
+  if (data?.ReaderOcrManifest || data?.ocr_manifest) {
+    ocrManifestUrl = data.ReaderOcrManifest || data.ocr_manifest;
+    params.set("ocr_manifest", ocrManifestUrl);
+  }
   readerRuntime.update("source", { metadata: resolvedReaderData });
   const title = String(resolvedReaderData?.title || params.get("title") || sourceName).trim();
   const suffix = String(
@@ -311,6 +315,7 @@ function applyReaderMetadata(data) {
 }
 let fallbackUrl = params.get("fallback") || "";
 const ocrUrl = params.get("ocr") || "";
+let ocrManifestUrl = params.get("ocr_manifest") || "";
 let returnUrl = params.get("return") || "";
 const readerPathLabel = params.get("path") || "";
 const folderReturnUrl = params.get("folder_url") || "";
@@ -364,11 +369,16 @@ let bookmarkInvoker = null;
 const bookmarkInertSiblings = new Map();
 let pdfDocument = null;
 let pdfPageManifest = null;
+let pdfOcrManifest = null;
+let pdfOcrManifestPromise = null;
 let pdfActiveRenders = 0;
 let pdfShellsReady = Promise.resolve();
 const pdfRenderWaiters = [];
+let pdfActiveTextLoads = 0;
+const pdfTextWaiters = [];
 trackReaderResource(() => {
   for (const waiter of pdfRenderWaiters.splice(0)) waiter.reject(readerAbortError());
+  for (const waiter of pdfTextWaiters.splice(0)) waiter.reject(readerAbortError());
 });
 let epubRendition = null;
 let epubBook = null;
@@ -2018,10 +2028,11 @@ function validSource(raw) {
   try {
     const url = new URL(raw);
     const bucketPath = url.searchParams.get("path") || "";
+    const bucketName = url.searchParams.get("bucket") || "vomebook/pdf-pages";
     if (
       url.origin === "https://voiceofml-search.hf.space" &&
       url.pathname === "/api/reader-bucket-resource" &&
-      VoiceOfMLReader.isBucketPath(bucketPath)
+      VoiceOfMLReader.isBucketPath(bucketPath, true, bucketName)
     )
       return true;
     if (url.protocol !== "https:" || !["huggingface.co", "hf-mirror.com"].includes(url.hostname))
@@ -2175,12 +2186,60 @@ function pdfManifestSource() {
 }
 function pdfPageEntry(page) {
   if (!pdfPageManifest || page < 1 || page > pdfPageManifest.pageCount) return null;
-  return (
+  const pageEntry = (
     pdfPageManifest.entries?.[page - 1] || {
       page,
       path: `${pdfPageManifest.root}/pages/page-${String(page).padStart(6, "0")}.webp`
     }
   );
+  const ocrEntry = pdfOcrManifest?.pages?.[page - 1];
+  return ocrEntry ? { ...pageEntry, ...ocrEntry, page } : pageEntry;
+}
+
+async function readPdfOcrJson(url, limit = VoiceOfMLReaderSecurity.LIMITS.chapterBytes) {
+  const response = await fetchReaderUrl(url);
+  if (!response.ok) throw new Error(`HTTP ${response.status}`);
+  let bytes = await VoiceOfMLReaderSecurity.readBytes(response, limit);
+  if (/\.gz$/i.test(url)) {
+    if (typeof DecompressionStream !== "function") throw new Error("PDF_OCR_GZIP_UNSUPPORTED");
+    const stream = new Blob([bytes]).stream().pipeThrough(new DecompressionStream("gzip"));
+    bytes = await VoiceOfMLReaderSecurity.readBytes(new Response(stream), limit);
+  }
+  return JSON.parse(new TextDecoder().decode(bytes));
+}
+
+async function loadPdfOcrManifest() {
+  if (pdfOcrManifest) return pdfOcrManifest;
+  if (!ocrManifestUrl) return null;
+  if (!pdfOcrManifestPromise) {
+    pdfOcrManifestPromise = readPdfOcrJson(ocrManifestUrl, VoiceOfMLReaderSecurity.LIMITS.manifestBytes).then((manifest) => {
+      pdfOcrManifest = VoiceOfMLReaderSecurity.validatePdfOcrManifest(manifest);
+      return pdfOcrManifest;
+    });
+  }
+  try { return await pdfOcrManifestPromise; }
+  catch (error) { pdfOcrManifestPromise = null; throw error; }
+}
+
+async function renderPdfOcrText(shell, entry) {
+  if (shell.dataset.textReady === "1" || !entry?.o || !pdfPageManifest) return;
+  const layer = shell.querySelector(".reader-pdf-text");
+  if (!layer) return;
+  await acquirePdfTextSlot(shell.dataset.renderVisible === "1");
+  try {
+    const payload = await readPdfOcrJson(pdfPageManifest.assetUrl(entry.o));
+    assertReaderActive();
+    VoiceOfMLReaderSecurity.validatePdfOcrPage(payload, Number(shell.dataset.page));
+    populateOcrTextLayer(layer, payload.blocks);
+    shell._bookmarkTextItems = payload.blocks.map((block) => ({ text: block.t, y: block.b?.[1] || 0 }));
+    shell.dataset.textReady = "1";
+    highlightPdfText(shell);
+  } catch (error) {
+    if (!readerAbortController.signal.aborted)
+      console.warn(`PDF page ${shell.dataset.page} OCR text failed`, error);
+  } finally {
+    releasePdfTextSlot();
+  }
 }
 function trimPdfManifestImages(protectedShell) {
   const images = [...content.querySelectorAll('.reader-page[data-render-state="rendered"]')];
@@ -2193,6 +2252,10 @@ function trimPdfManifestImages(protectedShell) {
   );
   for (const shell of images.slice(25)) {
     shell.querySelector("img")?.remove();
+    const textLayer = shell.querySelector(".reader-pdf-text");
+    if (textLayer) textLayer.replaceChildren();
+    shell._bookmarkTextItems = [];
+    shell.dataset.textReady = "0";
     shell.dataset.renderState = "idle";
   }
 }
@@ -2355,6 +2418,7 @@ async function renderPdfPages(prepared) {
   const totalPages = manifest.page_count;
   if (!source) throw new Error("PDF_MANIFEST_INVALID");
   pdfPageManifest = { ...source, pageCount: totalPages };
+  if (ocrManifestUrl) loadPdfOcrManifest().catch(() => {});
   updateDocumentState({ pageCount: totalPages });
   pageInput.max = String(totalPages);
   document.querySelector("#page-total").textContent = `/ ${totalPages}`;
@@ -2370,7 +2434,10 @@ async function renderPdfPages(prepared) {
   const observer = new IntersectionObserver(
     (items) => {
       if (readerAbortController.signal.aborted) return;
-      for (const entry of items) if (entry.isIntersecting) renderPdfInBackground(entry.target);
+      for (const entry of items) if (entry.isIntersecting) {
+        entry.target.dataset.renderVisible = isPdfPageVisible(entry.target) ? "1" : "0";
+        renderPdfInBackground(entry.target);
+      }
     },
     { root: viewport, rootMargin: "1200px 0px" }
   );
@@ -2414,7 +2481,7 @@ async function renderPdf(prepared) {
     (entries) =>
       entries.forEach((entry) => {
         if (readerAbortController.signal.aborted) return;
-        entry.target.dataset.renderVisible = entry.isIntersecting ? "1" : "0";
+        entry.target.dataset.renderVisible = entry.isIntersecting && isPdfPageVisible(entry.target) ? "1" : "0";
         if (entry.isIntersecting) renderPdfInBackground(entry.target);
       }),
     { root: document.querySelector("#viewport"), rootMargin: "1200px 0px" }
@@ -2490,7 +2557,12 @@ async function renderPdf(prepared) {
   assertReaderActive();
 }
 
-function renderPdfInBackground(shell, force = false) {
+function isPdfPageVisible(shell) {
+  const pageRect = shell?.getBoundingClientRect?.();
+  const viewportRect = viewport?.getBoundingClientRect?.();
+  return !!pageRect && !!viewportRect && pageRect.bottom > viewportRect.top && pageRect.top < viewportRect.bottom;
+}
+function renderPdfInBackground(shell, force = false, priority = isPdfPageVisible(shell)) {
   if (readerAbortController.signal.aborted) return;
   if (shell._backgroundRender) {
     if (force) shell.dataset.pendingRerender = "1";
@@ -2498,8 +2570,8 @@ function renderPdfInBackground(shell, force = false) {
   }
   const task =
     capability.mode === "pdf-pages"
-      ? renderPdfManifestShell(shell, force, true)
-      : renderPdfShell(shell, force);
+      ? renderPdfManifestShell(shell, force, priority)
+      : renderPdfShell(shell, force, priority);
   shell._backgroundRender = task;
   task
     .catch((error) => {
@@ -2539,9 +2611,13 @@ function renderPdfManifestShell(shell, force = false, priority = false) {
         image.decoding = "async";
         shell.appendChild(image);
       }
-      const target = pdfPageManifest.pageUrl(entry.page);
-      await new Promise((resolve, reject) => {
-        let settled = false,
+       const fallbackPath = entry.w || `${pdfPageManifest.root}/pages/page-${String(entry.page).padStart(6, "0")}.webp`;
+       const targets = [...new Set([entry.j, fallbackPath].filter(Boolean))].map((path) =>
+         pdfPageManifest.assetUrl(path)
+       );
+       await new Promise((resolve, reject) => {
+         let settled = false,
+           targetIndex = 0,
           timeout = 0,
           untrack = () => {};
         const finish = (error) => {
@@ -2561,13 +2637,23 @@ function renderPdfManifestShell(shell, force = false, priority = false) {
           () => finish(new Error("PDF page image timeout")),
           READER_PROXY_TIMEOUT_MS
         );
-        image.onload = () => finish();
-        image.onerror = () => finish(new Error(`PDF page ${entry.page} image failed`));
-        if (image.src !== target) image.src = target;
-        if (image.complete && image.naturalWidth) finish();
+         image.onload = () => finish();
+         image.onerror = () => {
+           if (targetIndex + 1 < targets.length) {
+             targetIndex += 1;
+             image.src = targets[targetIndex];
+           } else finish(new Error(`PDF page ${entry.page} image failed`));
+         };
+         if (!targets.length) return finish(new Error(`PDF page ${entry.page} image missing`));
+         if (image.src !== targets[targetIndex]) image.src = targets[targetIndex];
+         if (image.complete && image.naturalWidth) finish();
       });
       assertReaderActive();
       shell.style.aspectRatio = `${image.naturalWidth || 1} / ${image.naturalHeight || 1}`;
+      const loadText = pdfOcrManifestPromise
+        ? pdfOcrManifestPromise.then(() => renderPdfOcrText(shell, pdfPageEntry(Number(shell.dataset.page))))
+        : renderPdfOcrText(shell, pdfPageEntry(Number(shell.dataset.page)));
+      loadText.catch(() => {});
       image.classList.add("ready");
       shell.dataset.renderState = "rendered";
       shell.dataset.renderUsedAt = String(Date.now());
@@ -2674,8 +2760,17 @@ async function renderPdfText(page, shell) {
 function highlightPdfText(shell, query = searchState.query) {
   if (!shell || readerAbortController.signal.aborted || !query) return;
   const pattern = new RegExp(fullSearchEscape(query), "iu");
-  for (const span of shell.querySelectorAll(".reader-pdf-text span"))
-    if (pattern.test(span.textContent) && !span.classList.contains("full-search-highlight")) {
+  const spans = [...shell.querySelectorAll(".reader-pdf-text span")];
+  let text = "";
+  const ranges = spans.map((span) => {
+    const start = text.length;
+    text += `${span.textContent || ""} `;
+    return { span, start, end: text.length };
+  });
+  const hit = text.search(pattern);
+  for (const { span, start, end } of ranges)
+    if (!span.classList.contains("full-search-highlight") &&
+        ((hit >= 0 && end > hit && start < hit + query.length) || pattern.test(span.textContent))) {
       span.classList.add("full-search-highlight");
       fullSearchActiveMarks.push(span);
     }
@@ -2706,6 +2801,31 @@ function releasePdfRenderSlot() {
   const waiter = pdfRenderWaiters.shift();
   if (waiter) waiter.resolve();
 }
+function acquirePdfTextSlot(priority = false) {
+  if (readerAbortController.signal.aborted) return Promise.reject(readerAbortError());
+  const limit = matchMedia("(max-width: 700px)").matches ? 1 : 2;
+  if (pdfActiveTextLoads < limit) {
+    pdfActiveTextLoads++;
+    return Promise.resolve();
+  }
+  return new Promise((resolve, reject) => {
+    const waiter = {
+      resolve: () => {
+        pdfActiveTextLoads++;
+        resolve();
+      },
+      reject
+    };
+    if (priority) pdfTextWaiters.unshift(waiter);
+    else pdfTextWaiters.push(waiter);
+  });
+}
+function releasePdfTextSlot() {
+  pdfActiveTextLoads = Math.max(0, pdfActiveTextLoads - 1);
+  if (readerAbortController.signal.aborted) return;
+  const waiter = pdfTextWaiters.shift();
+  if (waiter) waiter.resolve();
+}
 function trimPdfCanvases(protectedShell) {
   const limit = matchMedia("(max-width: 700px)").matches ? 7 : 11;
   const rendered = [...content.querySelectorAll('.reader-page[data-render-state="rendered"]')];
@@ -2737,6 +2857,10 @@ function trimPdfCanvases(protectedShell) {
     canvas.width = 0;
     canvas.height = 0;
     canvas.classList.remove("ready");
+    const textLayer = shell.querySelector(".reader-pdf-text");
+    if (textLayer) textLayer.replaceChildren();
+    shell._bookmarkTextItems = [];
+    shell.dataset.textReady = "0";
     shell.dataset.renderState = "idle";
   }
 }
@@ -3412,6 +3536,8 @@ function disposeFormatResources(mode) {
   if (["pdf", "pdf-pages"].includes(mode)) {
     pdfDocument = null;
     pdfPageManifest = null;
+    pdfOcrManifest = null;
+    pdfOcrManifestPromise = null;
     pdfFirstPagePreload?.removeAttribute("src");
     pdfFirstPagePreload = null;
     for (const canvas of content.querySelectorAll(".reader-page canvas")) {
@@ -4895,6 +5021,47 @@ async function navigateFoliateSearchResult(result, generation) {
   updateProgressTools();
   scheduleSave();
 }
+async function fullSearchPdfPageMatches(query, generation) {
+  const manifest = await loadPdfOcrManifest();
+  if (!manifest?.book_text?.path || !pdfPageManifest) return [];
+  const book = await readPdfOcrJson(pdfPageManifest.assetUrl(manifest.book_text.path), VoiceOfMLReaderSecurity.LIMITS.chapterTotalBytes);
+  const output = [], pattern = new RegExp(fullSearchEscape(query), "giu");
+  for (const page of book.pages || []) {
+    if (!isReaderGenerationCurrent("search", generation)) return [];
+    const text = String(page.text || "");
+    for (const match of text.matchAll(pattern)) {
+      if (output.length >= 100) break;
+      output.push({
+        location: `第 ${page.page} 页`,
+        snippet: fullSearchSnippet(text, match.index, match[0].length),
+        activate: (navigationGeneration) => goToPage(page.page, navigationGeneration)
+      });
+    }
+    if (output.length >= 100) break;
+  }
+  return output;
+}
+
+async function fullSearchPdfApiMatches(query, generation) {
+  if (!readerId) throw new Error("PDF_OCR_API_ID_MISSING");
+  const url = `https://voiceofml-search.hf.space/api/reader-ocr-search?id=${encodeURIComponent(readerId)}&q=${encodeURIComponent(query)}&page=1&page_size=100`;
+  const response = await fetchWithReaderTimeout(url);
+  if (!response.ok) throw new Error(`HTTP ${response.status}`);
+  const payload = await response.json();
+  if (!payload || payload.version !== 1 || !Array.isArray(payload.results))
+    throw new Error("PDF_OCR_API_INVALID");
+  return payload.results.map((item) => {
+    const text = String(item.snippet || "");
+    const start = Math.max(0, Number(item.snippet_start) || 0);
+    const length = Math.max(0, Number(item.length) || query.length);
+    return {
+      location: `第 ${item.page} 页`,
+      snippet: fullSearchSnippet(text, start, length),
+      activate: (navigationGeneration) => goToPage(item.page, navigationGeneration)
+    };
+  });
+}
+
 async function fullSearchPdfMatches(query, generation) {
   const pdf = pdfDocument,
     output = [],
@@ -4964,7 +5131,14 @@ async function runFullSearch() {
   }
   fullSearchStatus.textContent = "正在搜索正文…";
   try {
-    if (capability.mode === "pdf")
+    if (capability.mode === "pdf-pages") {
+      try {
+        publishSearchResults(generation, await fullSearchPdfApiMatches(query, generation));
+      } catch (error) {
+        publishSearchResults(generation, await fullSearchPdfPageMatches(query, generation));
+      }
+    }
+    else if (capability.mode === "pdf")
       publishSearchResults(generation, await fullSearchPdfMatches(query, generation));
     else if (capability.mode === "foliate")
       publishSearchResults(generation, await fullSearchFoliateMatches(query, generation));

tests/test_fastapi_endpoints.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import copy
+import gzip
 import json
 import tempfile
 import time
@@ -41,6 +42,30 @@ class FastApiEndpointTests(unittest.TestCase):
         self.assertRegex(response.headers["server-timing"], r"queue;dur=\d+\.\d+, search;dur=\d+\.\d+")
         self.assertNotIn("readme", response.headers["server-timing"])
 
+    def test_reader_ocr_search_returns_exact_page_hits(self):
+        root = "objects/aa/" + "a" * 64 + "/" + "b" * 16
+        manifest_path = root + "/ocr-manifest.json"
+        book_path = root + "/ocr/book-text.json.gz"
+        manifest = {"version": 1, "kind": "pdf-ocr", "page_count": 2,
+                    "pages": [{"p": 1, "o": root + "/ocr/page-000001.json.gz"},
+                              {"p": 2, "o": root + "/ocr/page-000002.json.gz"}],
+                    "book_text": {"path": book_path}}
+        book = gzip.compress(json.dumps({"version": 1, "kind": "pdf-ocr-book-text", "pages": [
+            {"page": 1, "text": "第一章 手机阅读"},
+            {"page": 2, "text": "第二章 手机搜索"},
+        ]}).encode())
+
+        async def resource(path):
+            return json.dumps(manifest).encode() if path == manifest_path else book
+
+        resolved = app.JSONResponse({"ocr_manifest": "https://voiceofml-search.hf.space/api/reader-bucket-resource?path=" + manifest_path})
+        with mock.patch.object(app, "api_reader_resolve", mock.AsyncMock(return_value=resolved)), \
+             mock.patch.object(app, "get_reader_bucket_resource", side_effect=resource):
+            response = self.client.get("/api/reader-ocr-search", params={"id": "a" * 13, "q": "手机"})
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response.json()["total"], 2)
+        self.assertEqual([item["page"] for item in response.json()["results"]], [1, 2])
+
     def test_search_endpoint_rejects_malformed_json(self):
         self.assertEqual(self.client.post("/api/search", content="not-json", headers={"content-type": "application/json"}).status_code, 422)
 

tests/test_reader_pdf_loading.py

@@ -12,7 +12,7 @@ from tests.test_reader_performance import (
     PlaywrightError, StaticHandler, minimal_pdf, static_server, sync_playwright,
 )
 
-MODULE = '**/static/vendor/pdf.min.f80490490320.mjs*'
+MODULE = '**/static/vendor/pdf.min.*.mjs*'
 SOURCE = 'https://huggingface.co/datasets/VoiceOfML/Test/resolve/main/cold-retry.pdf'
 
 

tests/test_reader_performance.py

@@ -7,6 +7,7 @@ import io
 import json
 import mimetypes
 import pathlib
+import re
 import threading
 import time
 import unittest
@@ -23,6 +24,43 @@ except ImportError:
 
 
 ROOT = pathlib.Path(__file__).resolve().parents[1]
+
+
+def vendor_name(key, pattern):
+    resources = (ROOT / "static/reader-resources.js").read_text(encoding="utf-8")
+    match = re.search(rf"\b{re.escape(key)}:\s*\{{.*?sha256:\s*\"([0-9a-f]+)\"", resources, re.S)
+    if not match:
+        raise RuntimeError(f"missing vendor digest for {key!r}")
+    return pattern.replace("*", match.group(1)[:12], 1)
+
+
+VENDOR_FILES = {
+    "pdf": vendor_name("pdf", "pdf.min.*.mjs"),
+    "pdf_worker": vendor_name("pdfWorker", "pdf.worker.min.*.mjs"),
+    "marked": vendor_name("marked", "marked.min.*.js"),
+    "purify": vendor_name("purify", "purify.min.*.js"),
+    "jszip": vendor_name("jszip", "jszip.min.*.js"),
+    "docx": vendor_name("docx", "docx-preview.min.*.js"),
+}
+VENDOR_STEMS = {
+    "pdf": "pdf.min.*.mjs",
+    "pdf_worker": "pdf.worker.min.*.mjs",
+    "marked": "marked.min.*.js",
+    "purify": "purify.min.*.js",
+    "jszip": "jszip.min.*.js",
+    "docx": "docx-preview.min.*.js",
+}
+
+
+def route_local_vendor_fallback(page):
+    for key, requested in VENDOR_FILES.items():
+        candidates = sorted((ROOT / "static/vendor").glob(VENDOR_STEMS[key]))
+        if not candidates:
+            continue
+        page.route(
+            f"**/static/vendor/{requested}",
+            lambda route, _request, path=str(candidates[-1]): route.fulfill(path=path),
+        )
 SOURCE_URL = "https://huggingface.co/datasets/VoiceOfML/Test/resolve/main/performance.pdf"
 PDF_MODULE = """
 export const GlobalWorkerOptions = {};
@@ -260,7 +298,7 @@ class ReaderPerformanceTest(unittest.TestCase):
         self.page = self.context.new_page()
         self.pdf_requested_at = None
         self.page.route("**/static/reader-store.js", lambda route: route.fulfill(status=200, content_type="text/javascript", body=STORE_SCRIPT))
-        self.page.route("**/static/vendor/pdf.min.f80490490320.mjs", self.route_pdf)
+        self.page.route("**/static/vendor/pdf.min.*.mjs", self.route_pdf)
         self.page.route("**/api/reader-content**", lambda route: route.fulfill(status=200, content_type="application/pdf", body=b"pdf"))
 
     def tearDown(self):
@@ -474,7 +512,7 @@ class ReaderPerformanceTest(unittest.TestCase):
         self.assertEqual(first_page.locator(".reader-pdf-text").text_content(), "Accessible PDF text")
 
     def test_scanned_pdf_bookmark_has_empty_excerpt(self):
-        self.page.route('**/static/vendor/pdf.min.f80490490320.mjs', lambda route: route.fulfill(
+        self.page.route('**/static/vendor/pdf.min.*.mjs', lambda route: route.fulfill(
             content_type='text/javascript', body=PDF_MODULE.replace("[{ str: 'Accessible PDF text', hasEOL: false }]", '[]')))
         self.open_pdf()
         self.page.wait_for_function("document.querySelector('.reader-pdf-text')?.textContent.includes('此页没有可提取文本')")
@@ -583,7 +621,7 @@ class ReaderPerformanceTest(unittest.TestCase):
         mobile_context = self.browser.new_context(viewport={"width": 390, "height": 844})
         mobile_page = mobile_context.new_page()
         mobile_page.route("**/static/reader-store.js", lambda route: route.fulfill(status=200, content_type="text/javascript", body=STORE_SCRIPT))
-        mobile_page.route("**/static/vendor/pdf.min.f80490490320.mjs", lambda route: route.fulfill(status=200, content_type="text/javascript", body=PDF_MODULE))
+        mobile_page.route("**/static/vendor/pdf.min.*.mjs", lambda route: route.fulfill(status=200, content_type="text/javascript", body=PDF_MODULE))
         mobile_page.route("**/api/reader-content**", lambda route: route.fulfill(status=200, content_type="application/pdf", body=b"pdf"))
         query = urllib.parse.quote(SOURCE_URL, safe="")
         mobile_page.goto(f"{self.origin}/static/reader.html?url={query}&ext=pdf&title=Performance", wait_until="domcontentloaded")
@@ -663,13 +701,13 @@ class ReaderPerformanceTest(unittest.TestCase):
                 context = self.browser.new_context(viewport={"width": 390, "height": 844})
                 page = context.new_page()
                 page.route("**/static/reader-store.js", lambda route: route.fulfill(status=200, content_type="text/javascript", body=STORE_SCRIPT))
-                page.route("**/static/vendor/pdf.min.f80490490320.mjs", lambda route: route.fulfill(status=200, content_type="text/javascript", body=PDF_MODULE))
+                page.route("**/static/vendor/pdf.min.*.mjs", lambda route: route.fulfill(status=200, content_type="text/javascript", body=PDF_MODULE))
                 if extension == "md":
-                    page.route("**/static/vendor/marked.min.b147274a9ce2.js", lambda route: route.fulfill(status=200, content_type="text/javascript", body=MARKED_SCRIPT))
-                    page.route("**/static/vendor/purify.min.f263b05369e0.js", lambda route: route.fulfill(status=200, content_type="text/javascript", body=PURIFY_SCRIPT))
+                    page.route("**/static/vendor/marked.min.*.js", lambda route: route.fulfill(status=200, content_type="text/javascript", body=MARKED_SCRIPT))
+                    page.route("**/static/vendor/purify.min.*.js", lambda route: route.fulfill(status=200, content_type="text/javascript", body=PURIFY_SCRIPT))
                 if extension == "docx":
-                    page.route("**/static/vendor/jszip.min.7f839b2d4688.js", lambda route: route.fulfill(status=200, content_type="text/javascript", body=JSZIP_SCRIPT))
-                    page.route("**/static/vendor/docx-preview.min.051ef503f267.js", lambda route: route.fulfill(status=200, content_type="text/javascript", body=DOCX_SCRIPT))
+                    page.route("**/static/vendor/jszip.min.*.js", lambda route: route.fulfill(status=200, content_type="text/javascript", body=JSZIP_SCRIPT))
+                    page.route("**/static/vendor/docx-preview.min.*.js", lambda route: route.fulfill(status=200, content_type="text/javascript", body=DOCX_SCRIPT))
                 page.route("**/api/reader-content**", lambda route, _request, content_type=content_type, body=body: route.fulfill(status=200, content_type=content_type, body=body))
                 source = f"https://huggingface.co/datasets/VoiceOfML/Test/resolve/main/matrix.{extension}"
                 if extension == "docx":
@@ -1126,8 +1164,8 @@ class ReaderPerformanceTest(unittest.TestCase):
                 self.addCleanup(context.close)
                 page = context.new_page()
                 page.route("**/static/reader-store.js", lambda route: route.fulfill(status=200, content_type="text/javascript", body=STORE_SCRIPT))
-                page.route("**/static/vendor/jszip.min.7f839b2d4688.js", lambda route: route.fulfill(status=200, content_type="text/javascript", body="window.JSZip=function(){window.__archiveParserStarted=true};"))
-                page.route("**/static/vendor/docx-preview.min.051ef503f267.js", lambda route: route.fulfill(status=200, content_type="text/javascript", body="window.docx={renderAsync(){window.__archiveParserStarted=true}};"))
+                page.route("**/static/vendor/jszip.min.*.js", lambda route: route.fulfill(status=200, content_type="text/javascript", body="window.JSZip=function(){window.__archiveParserStarted=true};"))
+                page.route("**/static/vendor/docx-preview.min.*.js", lambda route: route.fulfill(status=200, content_type="text/javascript", body="window.docx={renderAsync(){window.__archiveParserStarted=true}};"))
                 page.route("**/static/foliate-reader/view.js", lambda route: route.fulfill(status=200, content_type="text/javascript", body="customElements.define('foliate-view', class extends HTMLElement { open() { window.__archiveParserStarted=true; throw new Error('parser must not start'); } });"))
                 page.route("**/api/reader-content**", lambda route: route.fulfill(status=200, content_type="application/octet-stream", body=payload))
                 source = "https://huggingface.co/datasets/VoiceOfML/Test/resolve/main/bomb.epub" if extension == "epub" else f"https://huggingface.co/datasets/vomebook/Reader-Assets/resolve/main/objects/aa/{'a' * 64}/docx-native-v1/document.docx"
@@ -1154,14 +1192,14 @@ class ReaderPerformanceTest(unittest.TestCase):
                 context = self.browser.new_context(viewport={"width": 390, "height": 844}); page = context.new_page()
                 page.route("**/static/reader-store.js", lambda route: route.fulfill(status=200, content_type="text/javascript", body=STORE_SCRIPT))
                 if extension == "md":
-                    page.route("**/static/vendor/marked.min.b147274a9ce2.js", lambda route: route.fulfill(status=200, content_type="text/javascript", body="window.marked={parse:()=>'<h1>Markdown one</h1><p style=\"height:1000px\"></p><h2>Markdown two</h2>'};")); page.route("**/static/vendor/purify.min.f263b05369e0.js", lambda route: route.fulfill(status=200, content_type="text/javascript", body=PURIFY_SCRIPT))
+                    page.route("**/static/vendor/marked.min.*.js", lambda route: route.fulfill(status=200, content_type="text/javascript", body="window.marked={parse:()=>'<h1>Markdown one</h1><p style=\"height:1000px\"></p><h2>Markdown two</h2>'};")); page.route("**/static/vendor/purify.min.*.js", lambda route: route.fulfill(status=200, content_type="text/javascript", body=PURIFY_SCRIPT))
                 page.route("**/api/reader-content**", lambda route, _request, body=body: route.fulfill(status=200, content_type="text/html" if extension == "html" else "text/markdown", body=body))
                 source = f"https://huggingface.co/datasets/VoiceOfML/Test/resolve/main/toc.{extension}"; page.goto(f"{self.origin}/static/reader.html?url={urllib.parse.quote(source, safe='')}&ext={extension}&title=TOC", wait_until="domcontentloaded"); page.locator("#history").click(); page.locator("#toc-list .panel-item-main").nth(1).click()
                 page.wait_for_function("() => document.querySelector('iframe') ? document.querySelector('iframe').contentWindow.scrollY > 0 : document.querySelector('#viewport').scrollTop > 0"); context.close()
 
     def test_pdf_outline_click_navigates_to_declared_page(self):
         self.page.add_init_script("window.__pdfOutlineEnabled = true")
-        module = PDF_MODULE.replace("[{title: '第一章', dest: [{}], items: []}]", "[{title: '第三章', dest: [{}], items: []}]").replace("getPageIndex: () => Promise.resolve(0)", "getPageIndex: () => Promise.resolve(2)"); self.page.unroute("**/static/vendor/pdf.min.f80490490320.mjs"); self.page.route("**/static/vendor/pdf.min.f80490490320.mjs", lambda route, _request, module=module: route.fulfill(status=200, content_type="text/javascript", body=module)); self.open_pdf(); self.page.locator("#history").click(); self.page.locator("#toc-list .panel-item-main").click(); self.page.wait_for_function("() => document.querySelector('#page-number').value === '3'")
+        module = PDF_MODULE.replace("[{title: '第一章', dest: [{}], items: []}]", "[{title: '第三章', dest: [{}], items: []}]").replace("getPageIndex: () => Promise.resolve(0)", "getPageIndex: () => Promise.resolve(2)"); self.page.unroute("**/static/vendor/pdf.min.*.mjs"); self.page.route("**/static/vendor/pdf.min.*.mjs", lambda route, _request, module=module: route.fulfill(status=200, content_type="text/javascript", body=module)); self.open_pdf(); self.page.locator("#history").click(); self.page.locator("#toc-list .panel-item-main").click(); self.page.wait_for_function("() => document.querySelector('#page-number').value === '3'")
 
     def test_pdf_outline_marks_current_entry_when_page_changes(self):
         self.page.add_init_script("window.__pdfOutlineEnabled = true")
@@ -1169,8 +1207,8 @@ class ReaderPerformanceTest(unittest.TestCase):
             "[{title: '第一章', dest: [{}], items: []}]",
             "[{title: '第一章', dest: [{page: 0}], items: []}, {title: '第二章', dest: [{page: 2}], items: []}]",
         ).replace("getPageIndex: () => Promise.resolve(0)", "getPageIndex: (ref) => Promise.resolve(ref.page || 0)")
-        self.page.unroute("**/static/vendor/pdf.min.f80490490320.mjs")
-        self.page.route("**/static/vendor/pdf.min.f80490490320.mjs", lambda route, _request, module=module: route.fulfill(status=200, content_type="text/javascript", body=module))
+        self.page.unroute("**/static/vendor/pdf.min.*.mjs")
+        self.page.route("**/static/vendor/pdf.min.*.mjs", lambda route, _request, module=module: route.fulfill(status=200, content_type="text/javascript", body=module))
         self.open_pdf()
         self.page.locator("#history").click()
         self.page.locator("#toc-list .toc-item").nth(1).wait_for()
@@ -1186,7 +1224,7 @@ class ReaderPerformanceTest(unittest.TestCase):
     def test_pdf_stale_navigation_and_search_keep_latest_state(self):
         errors = []
         self.page.on("pageerror", lambda error: errors.append(str(error)))
-        self.page.route("**/static/vendor/pdf.min.f80490490320.mjs", lambda route: route.fulfill(
+        self.page.route("**/static/vendor/pdf.min.*.mjs", lambda route: route.fulfill(
             status=200, content_type="text/javascript", body=PDF_TASK_MODULE,
         ))
         self.open_pdf()
@@ -1249,7 +1287,7 @@ class ReaderPerformanceTest(unittest.TestCase):
                 page.route("**/static/reader-store.js", lambda route: route.fulfill(status=200, content_type="text/javascript", body=STORE_SCRIPT))
                 requests = []
                 page.on("request", lambda request: requests.append(request.url) if "reader-content" in request.url or request.url == SOURCE_URL else None)
-                page.route("**/static/vendor/pdf.min.f80490490320.mjs", lambda route: route.fulfill(status=200, content_type="text/javascript", body=PDF_TASK_MODULE))
+                page.route("**/static/vendor/pdf.min.*.mjs", lambda route: route.fulfill(status=200, content_type="text/javascript", body=PDF_TASK_MODULE))
                 page.goto(f"{self.origin}/static/reader.html?url={urllib.parse.quote(SOURCE_URL, safe='')}&ext=pdf", wait_until="domcontentloaded")
                 page.wait_for_function("() => Boolean(window.__pdfProbe)")
                 if phase == "rendering":
@@ -2007,8 +2045,8 @@ class ReaderPerformanceTest(unittest.TestCase):
                 context = self.browser.new_context(viewport={"width": 390, "height": 844})
                 page = context.new_page()
                 page.route("**/static/reader-store.js", lambda route: route.fulfill(status=200, content_type="text/javascript", body=STORE_SCRIPT))
-                page.route("**/static/vendor/marked.min.b147274a9ce2.js", lambda route: route.fulfill(status=200, content_type="text/javascript", body=MARKED_SCRIPT))
-                page.route("**/static/vendor/purify.min.f263b05369e0.js", lambda route: route.fulfill(status=200, content_type="text/javascript", body=PURIFY_SCRIPT))
+                page.route("**/static/vendor/marked.min.*.js", lambda route: route.fulfill(status=200, content_type="text/javascript", body=MARKED_SCRIPT))
+                page.route("**/static/vendor/purify.min.*.js", lambda route: route.fulfill(status=200, content_type="text/javascript", body=PURIFY_SCRIPT))
                 page.route("**/api/reader-content**", lambda route: route.fulfill(status=200, content_type="text/markdown", body=b"# Markdown readable"))
                 source = f"https://huggingface.co/datasets/VoiceOfML/Test/resolve/main/readme.{extension}"
                 page.goto(f"{self.origin}/static/reader.html?url={urllib.parse.quote(source, safe='')}&ext={extension}&title=Markdown", wait_until="domcontentloaded")
@@ -2113,11 +2151,11 @@ class ReaderPerformanceTest(unittest.TestCase):
                     return fulfill
 
                 page.route("**/static/reader-store.js", lambda route: route.fulfill(status=200, content_type="text/javascript", body=STORE_SCRIPT))
-                page.route("**/static/vendor/marked.min.b147274a9ce2.js", timed("marked", "text/javascript", MARKED_SCRIPT))
-                page.route("**/static/vendor/purify.min.f263b05369e0.js", timed("purify", "text/javascript", PURIFY_SCRIPT))
-                page.route("**/static/vendor/jszip.min.7f839b2d4688.js", timed("jszip", "text/javascript", JSZIP_SCRIPT))
+                page.route("**/static/vendor/marked.min.*.js", timed("marked", "text/javascript", MARKED_SCRIPT))
+                page.route("**/static/vendor/purify.min.*.js", timed("purify", "text/javascript", PURIFY_SCRIPT))
+                page.route("**/static/vendor/jszip.min.*.js", timed("jszip", "text/javascript", JSZIP_SCRIPT))
                 page.route("**/static/vendor/epub.min.06eae1574510.js", timed("epub", "text/javascript", EPUB_SCRIPT))
-                page.route("**/static/vendor/docx-preview.min.051ef503f267.js", timed("docx", "text/javascript", DOCX_SCRIPT))
+                page.route("**/static/vendor/docx-preview.min.*.js", timed("docx", "text/javascript", DOCX_SCRIPT))
                 content_type = "image/png" if extension == "png" else "application/octet-stream"
                 body = PNG_BYTES if extension == "png" else minimal_docx() if extension == "docx" else minimal_epub() if extension == "epub" else b"Reader benchmark content"
                 page.route("**/api/reader-content**", timed("content", content_type, body))
@@ -2151,9 +2189,9 @@ class ReaderPerformanceTest(unittest.TestCase):
     def test_cold_cache_first_read_with_real_format_engines(self):
         cases = [
             ("txt", b"Cold TXT readable", "text/plain", "已加载", ".reader-text", []),
-             ("md", b"# Cold Markdown", "text/markdown", "已加载", ".reader-markdown", ["marked.min.b147274a9ce2.js", "purify.min.f263b05369e0.js"]),
-            ("pdf", minimal_pdf(), "application/pdf", "1 页", ".reader-page canvas.ready", ["pdf.min.f80490490320.mjs", "pdf.worker.min.8ab0e5e30031.mjs"]),
-             ("docx", minimal_docx(), "application/vnd.openxmlformats-officedocument.wordprocessingml.document", "1 页", ".docx-body", ["jszip.min.7f839b2d4688.js", "docx-preview.min.051ef503f267.js"]),
+             ("md", b"# Cold Markdown", "text/markdown", "已加载", ".reader-markdown", [VENDOR_FILES["marked"], VENDOR_FILES["purify"]]),
+            ("pdf", minimal_pdf(), "application/pdf", "1 页", ".reader-page canvas.ready", [VENDOR_FILES["pdf"], VENDOR_FILES["pdf_worker"]]),
+             ("docx", minimal_docx(), "application/vnd.openxmlformats-officedocument.wordprocessingml.document", "1 页", ".docx-body", [VENDOR_FILES["jszip"], VENDOR_FILES["docx"]]),
             ("png", PNG_BYTES, "image/png", "图片", ".reader-image", []),
         ]
         results = []
@@ -2164,6 +2202,7 @@ class ReaderPerformanceTest(unittest.TestCase):
                     page = context.new_page(); session = context.new_cdp_session(page)
                     session.send("Network.enable"); session.send("Network.setCacheDisabled", {"cacheDisabled": True})
                     responses = []; page.on("response", lambda response: responses.append(response))
+                    route_local_vendor_fallback(page)
 
                     def serve_document(route):
                         route.fulfill(status=200, content_type=content_type, body=document)
@@ -2192,7 +2231,11 @@ class ReaderPerformanceTest(unittest.TestCase):
                         entry = next((item for item in entries if item["name"].endswith(engine)), None)
                         self.assertIsNotNone(entry, engine)
                         self.assertGreater(entry["transferSize"], 0, f"{engine} was not transferred on a cold load")
-                    byte_count = len(document) + sum((ROOT / "static/vendor" / engine).stat().st_size for engine in engines)
+                    byte_count = len(document) + sum(
+                        (ROOT / "static/vendor" / engine).stat().st_size
+                        if (ROOT / "static/vendor" / engine).exists() else 0
+                        for engine in engines
+                    )
                     results.append((extension, elapsed, byte_count, len(responses)))
                 finally:
                     context.close()

upstream_http.py

@@ -9,7 +9,7 @@ ALLOWED_DOWNLOAD_HOSTS = {"huggingface.co", "hf-mirror.com", "hf.co"}
 ALLOWED_DOWNLOAD_HOST_SUFFIXES = (".hf.co", ".huggingface.co", ".xethub.hf.co")
 MAX_REDIRECTS = 5
 READER_ASSET_PATH_RE = re.compile(
-    r"objects/[0-9a-f]{2}/[0-9a-f]{64}/(?:[0-9a-f]{16}/)?(?:page-manifest\.json|pages/page-[0-9]{6}\.webp|(?:[a-z0-9-]+/)?(?:linearized\.pdf|chapter-manifest\.json|document\.(?:pdf|epub|mobi|azw|azw3|fb2|docx|html)|book\.epub|audio\.mp3|video\.mp4|epub-chapters/(?:chapter-manifest\.json|chapters/chapter-[0-9]{4}\.xhtml|resources/[A-Za-z0-9._~%+\-/]+|epub-search-index\.json\.gz)))"
+    r"objects/[0-9a-f]{2}/[0-9a-f]{64}/(?:[0-9a-f]{16}/)?(?:page-manifest\.json|ocr-manifest\.json|pages/page-[0-9]{6}\.(?:webp|jxl)|ocr/(?:page-[0-9]{6}\.json\.gz|book-text\.json\.gz)|(?:[a-z0-9-]+/)?(?:linearized\.pdf|chapter-manifest\.json|document\.(?:pdf|epub|mobi|azw|azw3|fb2|docx|html)|book\.epub|audio\.mp3|video\.mp4|epub-chapters/(?:chapter-manifest\.json|chapters/chapter-[0-9]{4}\.xhtml|resources/[A-Za-z0-9._~%+\-/]+|epub-search-index\.json\.gz)))"
 )
 READER_ASSET_SOURCE_RE = re.compile(
     r"/datasets/vomebook/Reader-Assets/resolve/main/(?:pdf_manifest\.json|" + READER_ASSET_PATH_RE.pattern + r")"