tests/test_reader_performance.py

import base64
import contextlib
import functools
import hashlib
import http.server
import io
import json
import mimetypes
import pathlib
import re
import threading
import time
import unittest
import urllib.parse
import wave
import zipfile

try:
    from playwright.sync_api import Error as PlaywrightError
    from playwright.sync_api import sync_playwright
except ImportError:
    PlaywrightError = Exception
    sync_playwright = None


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 = {};
export class PDFWorker { promise = Promise.resolve(); destroy() {} }
const wait = () => new Promise((resolve) => setTimeout(resolve, 15));
export function getDocument() {
  const page = {
    getViewport({ scale }) { return { width: 600 * scale, height: 800 * scale }; },
    getTextContent() { return Promise.resolve({ items: [{ str: 'Accessible PDF text', hasEOL: false }] }); },
    render() {
      window.__pdfActive = (window.__pdfActive || 0) + 1;
      window.__pdfPeak = Math.max(window.__pdfPeak || 0, window.__pdfActive);
      return { promise: wait().then(() => { window.__pdfActive -= 1; }) };
    },
  };
  return { promise: Promise.resolve({ numPages: 30, getPage: () => Promise.resolve(page), getOutline: () => Promise.resolve(window.__pdfOutlineEnabled ? [{title: '第一章', dest: [{}], items: []}] : null), getPageIndex: () => Promise.resolve(0) }) };
}
"""
PDF_TASK_MODULE = """
export const GlobalWorkerOptions = {};
export class PDFWorker { promise = Promise.resolve(); destroy() {} }
export function getDocument() {
  const probe = window.__pdfProbe ||= { loads: 0, destroys: 0, renders: [], cancels: [], releases: {} };
  probe.loads++;
  const pdf = {
    numPages: 30,
    getOutline: async () => null,
    getPage: async (number) => ({
      getViewport: ({scale}) => ({width: 600 * scale, height: 800 * scale,
        convertToViewportPoint: (x, y) => [x, y]}),
      async getTextContent() {
        if (probe.holdText) {
          probe.holdText = false;
          await new Promise(resolve => { probe.releaseText = resolve; });
        }
        return {items: [{str: number === 1 ? 'obsolete' : number === 2 ? 'current' : 'ordinary',
          transform: [12, 0, 0, 12, 20, 40], hasEOL: false}]};
      },
      render() {
        probe.renders.push(number);
        return {promise: probe.holdPages?.includes(number)
          ? new Promise(resolve => { probe.releases[number] = resolve; }) : Promise.resolve(),
          cancel() { probe.cancels.push(number); }};
      },
    }),
  };
  return {promise: window.__holdPdfLoad
    ? new Promise(resolve => { probe.releaseLoad = () => resolve(pdf); }) : Promise.resolve(pdf),
    destroy() { probe.destroys++; return Promise.resolve(); }};
}
"""
STORE_SCRIPT = """
window.__storeStartedAt = performance.now();
window.__readerBookmarks = [];
window.VoiceOfMLReaderStore = Object.freeze({
  get: () => new Promise((resolve) => setTimeout(() => resolve(null), 300)),
  put: (entry) => { window.__savedReaderProgress = entry; return Promise.resolve(); }, list: () => Promise.resolve([]), remove: () => Promise.resolve(), clearHistory: () => Promise.resolve(),
  putBookmark: (entry) => { window.__readerBookmarks = window.__readerBookmarks.filter((item) => item.id !== entry.id).concat(entry); return Promise.resolve(); },
  listBookmarks: (url) => Promise.resolve(window.__readerBookmarks.filter((item) => item.url === url)),
  listAllBookmarks: () => Promise.resolve([...window.__readerBookmarks].sort((a, b) => b.createdAt - a.createdAt)),
  removeBookmark: (id) => { window.__readerBookmarks = window.__readerBookmarks.filter((item) => item.id !== id); return Promise.resolve(); }
});
"""
MARKED_SCRIPT = "window.marked = { parse: (text) => '<p>' + text + '</p>' };"
PURIFY_SCRIPT = "window.DOMPurify = { sanitize: (html) => html };"
JSZIP_SCRIPT = "window.JSZip = function() {};"
EPUB_SCRIPT = """
window.ePub = () => ({ renderTo: (frame) => ({
  themes: { register() {}, select() {}, fontSize() {} },
  on() {}, prev() {}, next() {},
  display: () => new Promise((resolve) => setTimeout(() => {
    frame.textContent = 'EPUB readable'; resolve();
  }, 20)),
}) });
"""
DOCX_SCRIPT = """
window.docx = { renderAsync: (_bytes, body) => new Promise((resolve) => setTimeout(() => {
  body.textContent = 'DOCX readable'; resolve();
}, 20)) };
"""
PNG_BYTES = bytes.fromhex(
    "89504e470d0a1a0a0000000d49484452000000010000000108060000001f15c489"
    "0000000d49444154789c6360f8cfc000000301010018dd8db10000000049454e44ae426082"
)
IMAGE_FIXTURES = {
    "jpg": ("image/jpeg", base64.b64decode("/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAP//////////////////////////////////////////////////////////////////////////////////////2wBDAf//////////////////////////////////////////////////////////////////////////////////////wAARCAABAAEDASIAAhEBAxEB/8QAFQABAQAAAAAAAAAAAAAAAAAAAAf/xAAUEAEAAAAAAAAAAAAAAAAAAAAA/9oADAMBAAIQAxAAAAF//8QAFBABAAAAAAAAAAAAAAAAAAAAAP/aAAgBAQABBQJ//8QAFBEBAAAAAAAAAAAAAAAAAAAAAP/aAAgBAwEBPwF//8QAFBEBAAAAAAAAAAAAAAAAAAAAAP/aAAgBAgEBPwF//8QAFBABAAAAAAAAAAAAAAAAAAAAAP/aAAgBAQAGPwJ//8QAFBABAAAAAAAAAAAAAAAAAAAAAP/aAAgBAQABPyF//9oADAMBAAIAAwAAAB//xAAUEQEAAAAAAAAAAAAAAAAAAAAA/9oACAEDAQE/EB//xAAUEQEAAAAAAAAAAAAAAAAAAAAA/9oACAECAQE/EB//xAAUEAEAAAAAAAAAAAAAAAAAAAAA/9oACAEBAAE/EB//2Q==")),
    "jpeg": ("image/jpeg", base64.b64decode("/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAP//////////////////////////////////////////////////////////////////////////////////////2wBDAf//////////////////////////////////////////////////////////////////////////////////////wAARCAABAAEDASIAAhEBAxEB/8QAFQABAQAAAAAAAAAAAAAAAAAAAAf/xAAUEAEAAAAAAAAAAAAAAAAAAAAA/9oADAMBAAIQAxAAAAF//8QAFBABAAAAAAAAAAAAAAAAAAAAAP/aAAgBAQABBQJ//8QAFBEBAAAAAAAAAAAAAAAAAAAAAP/aAAgBAwEBPwF//8QAFBEBAAAAAAAAAAAAAAAAAAAAAP/aAAgBAgEBPwF//8QAFBABAAAAAAAAAAAAAAAAAAAAAP/aAAgBAQAGPwJ//8QAFBABAAAAAAAAAAAAAAAAAAAAAP/aAAgBAQABPyF//9oADAMBAAIAAwAAAB//xAAUEQEAAAAAAAAAAAAAAAAAAAAA/9oACAEDAQE/EB//xAAUEQEAAAAAAAAAAAAAAAAAAAAA/9oACAECAQE/EB//xAAUEAEAAAAAAAAAAAAAAAAAAAAA/9oACAEBAAE/EB//2Q==")),
    "gif": ("image/gif", base64.b64decode("R0lGODlhAQABAIAAAAAAAP///ywAAAAAAQABAAACAUwAOw==")),
    "bmp": ("image/bmp", bytes.fromhex("424d3a00000000000000360000002800000001000000010000000100180000000000040000000000000000000000000000000000000000000000")),
    "webp": ("image/webp", base64.b64decode("UklGRiIAAABXRUJQVlA4IBYAAAAwAQCdASoBAAEAAUAmJaQAA3AA/v89WAAAAA==")),
}


def minimal_pdf():
    stream = b"BT /F1 18 Tf 20 100 Td (Reader PDF) Tj ET"
    objects = [
        b"<< /Type /Catalog /Pages 2 0 R >>",
        b"<< /Type /Pages /Kids [3 0 R] /Count 1 >>",
        b"<< /Type /Page /Parent 2 0 R /MediaBox [0 0 200 200] /Resources << /Font << /F1 5 0 R >> >> /Contents 4 0 R >>",
        b"<< /Length " + str(len(stream)).encode() + b" >>\nstream\n" + stream + b"\nendstream",
        b"<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica >>",
    ]
    payload = bytearray(b"%PDF-1.4\n%\xe2\xe3\xcf\xd3\n"); offsets = [0]
    for number, body in enumerate(objects, 1):
        offsets.append(len(payload)); payload.extend(f"{number} 0 obj\n".encode() + body + b"\nendobj\n")
    xref = len(payload); payload.extend(f"xref\n0 {len(objects) + 1}\n".encode()); payload.extend(b"0000000000 65535 f \n")
    for offset in offsets[1:]: payload.extend(f"{offset:010d} 00000 n \n".encode())
    payload.extend(f"trailer\n<< /Size {len(objects) + 1} /Root 1 0 R >>\nstartxref\n{xref}\n%%EOF\n".encode())
    return bytes(payload)


def zip_bytes(files, stored_first=None):
    output = io.BytesIO()
    with zipfile.ZipFile(output, "w", zipfile.ZIP_DEFLATED) as archive:
        if stored_first: archive.writestr(stored_first[0], stored_first[1], compress_type=zipfile.ZIP_STORED)
        for name, body in files.items(): archive.writestr(name, body)
    return output.getvalue()


def zip_bomb_metadata():
    # A complete, decompressible archive that exceeds the per-entry ratio limit.
    return zip_bytes({"bomb.txt": b"x" * (1024 * 1024)})


def minimal_epub():
    return zip_bytes({
        "META-INF/container.xml": '<?xml version="1.0"?><container xmlns="urn:oasis:names:tc:opendocument:xmlns:container" version="1.0"><rootfiles><rootfile full-path="OEBPS/content.opf" media-type="application/oebps-package+xml"/></rootfiles></container>',
        "OEBPS/content.opf": '<?xml version="1.0"?><package xmlns="http://www.idpf.org/2007/opf" version="3.0" unique-identifier="id"><metadata xmlns:dc="http://purl.org/dc/elements/1.1/"><dc:identifier id="id">reader</dc:identifier><dc:title>Reader</dc:title><dc:language>en</dc:language></metadata><manifest><item id="chapter" href="chapter.xhtml" media-type="application/xhtml+xml"/></manifest><spine><itemref idref="chapter"/></spine></package>',
        "OEBPS/chapter.xhtml": '<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Reader</title></head><body><p>EPUB readable</p></body></html>',
    }, ("mimetype", "application/epub+zip"))


def epub_with_navigation():
    return zip_bytes({
        "META-INF/container.xml": '<?xml version="1.0"?><container xmlns="urn:oasis:names:tc:opendocument:xmlns:container" version="1.0"><rootfiles><rootfile full-path="OEBPS/content.opf" media-type="application/oebps-package+xml"/></rootfiles></container>',
        "OEBPS/content.opf": '<?xml version="1.0"?><package xmlns="http://www.idpf.org/2007/opf" version="3.0" unique-identifier="id"><metadata xmlns:dc="http://purl.org/dc/elements/1.1/"><dc:identifier id="id">reader-e2e</dc:identifier><dc:title>Reader E2E</dc:title><dc:language>zh</dc:language></metadata><manifest><item id="nav" href="nav.xhtml" media-type="application/xhtml+xml" properties="nav"/><item id="one" href="chapter-1.xhtml" media-type="application/xhtml+xml"/><item id="two" href="chapter-2.xhtml" media-type="application/xhtml+xml"/></manifest><spine><itemref idref="nav"/><itemref idref="one"/><itemref idref="two"/></spine></package>',
        "OEBPS/nav.xhtml": '<html xmlns="http://www.w3.org/1999/xhtml" xmlns:epub="http://www.idpf.org/2007/ops"><head><title>目录</title><style>a{color:#000} body{margin-top:900px}</style></head><body><nav epub:type="toc"><h1>目录</h1><ol><li><a href="chapter-1.xhtml#one">第一章</a></li><li><a href="chapter-2.xhtml#two">第二章</a></li></ol></nav></body></html>',
        "OEBPS/chapter-1.xhtml": '<html xmlns="http://www.w3.org/1999/xhtml"><body><h1 id="one">第一章</h1><p style="height:900px">第一章正文</p></body></html>',
        "OEBPS/chapter-2.xhtml": '<html xmlns="http://www.w3.org/1999/xhtml"><body><h1 id="two">第二章</h1><p style="height:900px">第二章正文</p></body></html>',
    }, ("mimetype", "application/epub+zip"))


def epub_with_legacy_chm_markup():
    return zip_bytes({
        "META-INF/container.xml": '<?xml version="1.0"?><container xmlns="urn:oasis:names:tc:opendocument:xmlns:container" version="1.0"><rootfiles><rootfile full-path="OEBPS/content.opf" media-type="application/oebps-package+xml"/></rootfiles></container>',
        "OEBPS/content.opf": '<?xml version="1.0"?><package xmlns="http://www.idpf.org/2007/opf" version="2.0" unique-identifier="id"><metadata xmlns:dc="http://purl.org/dc/elements/1.1/"><dc:identifier id="id">legacy-chm</dc:identifier><dc:title>Legacy CHM</dc:title><dc:language>C</dc:language></metadata><manifest><item id="chapter" href="chapter.xhtml" media-type="application/xhtml+xml"/><item id="style" href="style.css" media-type="text/css"/><item id="image" href="picture.svg" media-type="image/svg+xml"/></manifest><spine><itemref idref="chapter"/></spine></package>',
        "OEBPS/style.css": "p { color: rgb(1, 2, 3); }",
        "OEBPS/picture.svg": '<svg xmlns="http://www.w3.org/2000/svg" width="32" height="16"><rect width="32" height="16" fill="red"/></svg>',
        "OEBPS/chapter.xhtml": '<html:html xmlns:html="http://www.w3.org/1999/xhtml"><html:head><html:meta/><html:title>Legacy CHM</html:title><html:link rel="stylesheet" href="style.css"/></html:head><html:body><html:a id="anchor"/><html:h1>Article title</html:h1><html:hr/><html:p id="legacy">Legacy CHM content<html:br/>正文第一段<html:br/>正文第二段</html:p><html:img src="picture.svg"/><html:p id="after-image">图片之后的正文</html:p></html:body></html:html>',
    }, ("mimetype", "application/epub+zip"))


def epub_with_many_chapters(count=14):
    manifest = '<item id="nav" href="nav.xhtml" media-type="application/xhtml+xml" properties="nav"/>'
    spine = '<itemref idref="nav"/>'
    links = []
    files = {}
    for index in range(1, count + 1):
        manifest += f'<item id="chapter-{index}" href="chapter-{index}.xhtml" media-type="application/xhtml+xml"/>'
        spine += f'<itemref idref="chapter-{index}"/>'
        links.append(f'<li><a href="chapter-{index}.xhtml#chapter-{index}">章节 {index}</a></li>')
        files[f"OEBPS/chapter-{index}.xhtml"] = f'<html xmlns="http://www.w3.org/1999/xhtml"><body><h1 id="chapter-{index}">章节 {index}</h1><p style="height:1200px">正文 {index}</p></body></html>'
    files.update({
        "META-INF/container.xml": '<?xml version="1.0"?><container xmlns="urn:oasis:names:tc:opendocument:xmlns:container" version="1.0"><rootfiles><rootfile full-path="OEBPS/content.opf" media-type="application/oebps-package+xml"/></rootfiles></container>',
        "OEBPS/content.opf": f'<?xml version="1.0"?><package xmlns="http://www.idpf.org/2007/opf" version="3.0" unique-identifier="id"><metadata xmlns:dc="http://purl.org/dc/elements/1.1/"><dc:identifier id="id">reader-race</dc:identifier><dc:title>Reader Race</dc:title><dc:language>zh</dc:language></metadata><manifest>{manifest}</manifest><spine>{spine}</spine></package>',
        "OEBPS/nav.xhtml": f'<html xmlns="http://www.w3.org/1999/xhtml" xmlns:epub="http://www.idpf.org/2007/ops"><body><nav epub:type="toc"><ol>{"".join(links)}</ol></nav></body></html>',
    })
    return zip_bytes(files, ("mimetype", "application/epub+zip"))


def minimal_docx():
    return zip_bytes({
        "[Content_Types].xml": '<?xml version="1.0"?><Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types"><Default Extension="rels" ContentType="application/vnd.openxmlformats-package.relationships+xml"/><Default Extension="xml" ContentType="application/xml"/><Override PartName="/word/document.xml" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml"/></Types>',
        "_rels/.rels": '<?xml version="1.0"?><Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships"><Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument" Target="word/document.xml"/></Relationships>',
        "word/document.xml": '<?xml version="1.0"?><w:document xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main"><w:body><w:p><w:r><w:t>DOCX readable</w:t></w:r></w:p><w:sectPr/></w:body></w:document>',
    })


def minimal_wav():
    output = io.BytesIO()
    with wave.open(output, "wb") as audio:
        audio.setnchannels(1)
        audio.setsampwidth(2)
        audio.setframerate(8000)
        audio.writeframes(b"\0\0" * 800)
    return output.getvalue()


class StaticHandler(http.server.SimpleHTTPRequestHandler):
    def guess_type(self, path):
        if path.endswith(".mjs") or path.endswith(".js"):
            return "text/javascript"
        return mimetypes.guess_type(path)[0] or "application/octet-stream"

    def log_message(self, *_args):
        pass


@contextlib.contextmanager
def static_server():
    handler = functools.partial(StaticHandler, directory=str(ROOT))
    server = http.server.ThreadingHTTPServer(("127.0.0.1", 0), handler)
    thread = threading.Thread(target=server.serve_forever, daemon=True)
    thread.start()
    try:
        yield f"http://127.0.0.1:{server.server_port}"
    finally:
        server.shutdown()
        server.server_close()
        thread.join(timeout=5)


@unittest.skipIf(sync_playwright is None, "install requirements-test.txt to run Reader performance tests")
class ReaderPerformanceTest(unittest.TestCase):
    @classmethod
    def setUpClass(cls):
        cls.server = static_server()
        cls.origin = cls.server.__enter__()
        cls.playwright = sync_playwright().start()
        try:
            cls.browser = cls.playwright.chromium.launch(headless=True, args=["--no-sandbox"])
        except PlaywrightError as error:
            cls.playwright.stop()
            cls.server.__exit__(None, None, None)
            raise unittest.SkipTest(f"Chromium is unavailable: {error}")

    @classmethod
    def tearDownClass(cls):
        cls.browser.close()
        cls.playwright.stop()
        cls.server.__exit__(None, None, None)

    def setUp(self):
        self.context = self.browser.new_context(viewport={"width": 1440, "height": 900})
        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.*.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):
        self.context.close()

    def route_pdf(self, route):
        self.pdf_requested_at = self.page.evaluate("performance.now()")
        route.fulfill(status=200, content_type="text/javascript", body=PDF_MODULE)

    def open_pdf(self):
        query = urllib.parse.quote(SOURCE_URL, safe="")
        self.page.goto(f"{self.origin}/static/reader.html?url={query}&ext=pdf&title=Performance", wait_until="domcontentloaded")
        self.page.locator(".reader-page").nth(29).wait_for(state="attached")

    def test_reader_starts_with_session_metadata_before_document_load(self):
        errors = []
        self.page.on("pageerror", lambda error: errors.append(str(error)))
        self.page.add_init_script("""
          sessionStorage.setItem('reader-source:metadata-probe', JSON.stringify({
            url: 'https://huggingface.co/datasets/VoiceOfML/Test/resolve/main/metadata.txt',
            download: 'https://huggingface.co/datasets/VoiceOfML/Test/resolve/main/metadata.txt',
            title: 'Metadata title', extension: 'txt', original_extension: 'txt',
            repo: 'Test', folder: ['Folder']
          }));
        """)
        self.page.route("**/api/reader-content**", lambda route: route.fulfill(status=200, content_type="text/plain", body=b"Metadata readable"))
        source = urllib.parse.quote("https://huggingface.co/datasets/VoiceOfML/Test/resolve/main/metadata.txt", safe="")
        self.page.goto(f"{self.origin}/static/reader.html?id=metadata-probe&url={source}&ext=txt", wait_until="domcontentloaded")
        self.page.locator(".reader-text").wait_for(state="visible")
        self.assertEqual(self.page.locator(".reader-text").text_content(), "Metadata readable")
        self.assertEqual(self.page.locator("#title").text_content(), "Metadata title.txt")
        self.assertEqual(self.page.locator("#reader-path").text_content(), "Test/Folder")
        self.assertEqual(self.page.locator("html").get_attribute("data-reader-phase"), "prepare")
        self.page.locator("html[data-reader-phase='ready']").wait_for(state="attached")
        self.assertEqual(self.page.locator("html").get_attribute("data-reader-phase"), "ready")
        self.assertEqual(errors, [])

    def test_fetch_file_aborts_when_pagehide_disposes_reader(self):
        self.page.add_init_script(r"""
          (() => {
            const nativeFetch = window.fetch.bind(window);
            const probe = window.__fetchFileProbe = { started: false, aborted: false, result: "" };
            window.fetch = (input, init = {}) => {
              if (!String(input).includes("fetch-file-probe")) return nativeFetch(input, init);
              probe.started = true;
              return new Promise((resolve, reject) => {
                const signal = init && init.signal;
                const abort = () => {
                  probe.aborted = true;
                  probe.result = "aborted";
                  reject(new DOMException("Reader disposed", "AbortError"));
                };
                if (signal && signal.aborted) return abort();
                if (signal) signal.addEventListener("abort", abort, { once: true });
                probe.resolve = () => {
                  probe.result = "fulfilled";
                  resolve(new Response("probe", { status: 200, headers: { "content-type": "text/plain" } }));
                };
              });
            };
          })();
        """)
        self.page.unroute("**/api/reader-content**")
        self.page.route("**/api/reader-content**", lambda route: route.fulfill(status=200, content_type="text/plain", body=b"Reader"))
        source = urllib.parse.quote("https://huggingface.co/datasets/VoiceOfML/Test/resolve/main/fetch-file.txt", safe="")
        self.page.goto(f"{self.origin}/static/reader.html?url={source}&ext=txt&title=FetchFile", wait_until="domcontentloaded")
        self.page.locator(".reader-text").wait_for(state="visible")
        self.page.evaluate("""() => {
          window.__fetchFilePromise = window.fetchFile("https://huggingface.co/datasets/VoiceOfML/Test/resolve/main/fetch-file-probe.txt")
            .then(() => { window.__fetchFileProbe.result = "fulfilled"; })
            .catch((error) => { window.__fetchFileProbe.error = error.name; });
        }""")
        self.page.wait_for_function("() => window.__fetchFileProbe.started === true")
        self.page.evaluate("""() => {
          const event = new Event("pagehide");
          Object.defineProperty(event, "persisted", { value: true });
          window.dispatchEvent(event);
        }""")
        self.page.wait_for_timeout(100)
        self.assertFalse(self.page.evaluate("() => window.__fetchFileProbe.aborted"))
        self.page.evaluate("window.dispatchEvent(new Event('pagehide'))")
        self.page.wait_for_function("() => window.__fetchFileProbe.result === 'aborted'", timeout=2000)
        self.assertEqual(self.page.evaluate("() => window.__fetchFileProbe.error"), "AbortError")
        self.assertEqual(self.page.locator("html").get_attribute("data-reader-phase"), "disposed")

    def test_concurrent_fetch_file_callers_receive_complete_bodies(self):
        self.page.add_init_script(r"""
          (() => {
            const nativeFetch = window.fetch.bind(window);
            window.__concurrentFetchCalls = 0;
            window.fetch = (input, init = {}) => {
              if (!String(input).includes("concurrent-fetch-file")) return nativeFetch(input, init);
              window.__concurrentFetchCalls += 1;
              return Promise.resolve(new Response("complete shared body", { status: 200, headers: { "content-type": "text/plain" } }));
            };
          })();
        """)
        source = urllib.parse.quote("https://huggingface.co/datasets/VoiceOfML/Test/resolve/main/fetch-file.txt", safe="")
        self.page.goto(f"{self.origin}/static/reader.html?url={source}&ext=txt&title=FetchFile", wait_until="domcontentloaded")
        self.page.locator(".reader-text").wait_for(state="visible")
        bodies = self.page.evaluate("""async () => {
          const url = "https://huggingface.co/datasets/VoiceOfML/Test/resolve/main/concurrent-fetch-file.txt";
          const files = await Promise.all([window.fetchFile(url), window.fetchFile(url)]);
          return Promise.all(files.map((file) => file.text()));
        }""")
        self.assertEqual(bodies, ["complete shared body", "complete shared body"])
        self.assertEqual(self.page.evaluate("window.__concurrentFetchCalls"), 1)

    def test_id_only_resolver_is_lifecycle_managed(self):
        errors = []
        self.page.on("pageerror", lambda error: errors.append(str(error)))
        self.page.add_init_script(r"""
          (() => {
            const nativeFetch = window.fetch.bind(window);
            window.__resolverProbe = { started: false, aborted: false };
            window.fetch = (input, init = {}) => {
              if (!String(input).includes("/api/reader-resolve?id=resolver-abort")) return nativeFetch(input, init);
              window.__resolverProbe.started = true;
              return new Promise((resolve, reject) => {
                const abort = () => { window.__resolverProbe.aborted = true; reject(new DOMException("Reader disposed", "AbortError")); };
                if (init.signal?.aborted) return abort();
                init.signal?.addEventListener("abort", abort, { once: true });
              });
            };
          })();
        """)
        self.page.goto(f"{self.origin}/static/reader.html?id=resolver-abort", wait_until="domcontentloaded")
        self.page.wait_for_function("window.__resolverProbe.started")
        self.page.evaluate("window.dispatchEvent(new Event('pagehide'))")
        self.page.wait_for_function("window.__resolverProbe.aborted")
        self.assertEqual(self.page.locator("html").get_attribute("data-reader-phase"), "disposed")
        self.assertEqual(errors, [])

    def test_id_only_resolver_failure_uses_reader_error_ui(self):
        errors = []
        self.page.on("pageerror", lambda error: errors.append(str(error)))
        self.page.route("**/api/reader-resolve?id=resolver-failure", lambda route: route.fulfill(status=503, body="unavailable"))
        self.page.goto(f"{self.origin}/static/reader.html?id=resolver-failure", wait_until="domcontentloaded")
        self.page.locator(".reader-error").wait_for(state="visible")
        self.assertEqual(self.page.locator("html").get_attribute("data-reader-phase"), "failed")
        self.assertEqual(self.page.locator("#content").get_attribute("data-error-code"), "READER_NETWORK")
        self.assertEqual(errors, [])

    def test_id_only_reader_source_uses_authoritative_resolve(self):
        stored = "https://huggingface.co/datasets/VoiceOfML/Test/resolve/main/stored.txt"
        authoritative = "https://huggingface.co/datasets/VoiceOfML/Test/resolve/main/authoritative.txt"
        stored_data = {
            "url": stored, "download": stored, "title": "Stored title", "extension": "txt",
            "original_extension": "txt", "repo": "Test", "folder": ["Stored"],
        }
        self.page.add_init_script(
            f"sessionStorage.setItem('reader-source:id-only-authority', {json.dumps(json.dumps(stored_data))})"
        )
        self.page.route(
            "**/api/reader-resolve?id=id-only-authority",
            lambda route: route.fulfill(
                status=200, content_type="application/json",
                body=json.dumps({"url": authoritative, "download": authoritative, "title": "Resolved title", "extension": "txt", "original_extension": "txt", "repo": "Test", "folder": "Authoritative"}),
            ),
        )
        self.page.unroute("**/api/reader-content**")
        self.page.route(
            "**/api/reader-content**",
            lambda route: route.fulfill(
                status=200, content_type="text/plain",
                body=b"Authoritative reader" if "authoritative.txt" in route.request.url else b"Stored reader",
            ),
        )
        self.page.goto(f"{self.origin}/static/reader.html?id=id-only-authority", wait_until="domcontentloaded")
        self.page.locator(".reader-text").wait_for(state="visible")
        self.assertEqual(self.page.locator(".reader-text").text_content(), "Authoritative reader")
        self.assertEqual(self.page.locator("#title").text_content(), "Resolved title.txt")
        self.assertEqual(self.page.locator("#reader-path").text_content(), "Test/Authoritative")
        self.assertNotIn("url=", self.page.url)

    def test_id_only_reader_falls_back_to_session_source_when_resolve_fails(self):
        stored = "https://huggingface.co/datasets/VoiceOfML/Test/resolve/main/stored.txt"
        stored_data = {
            "url": stored, "download": stored, "title": "Stored title", "extension": "txt",
            "original_extension": "txt", "repo": "Test", "folder": ["Stored"],
        }
        self.page.add_init_script(
            f"sessionStorage.setItem('reader-source:id-only-fallback', {json.dumps(json.dumps(stored_data))})"
        )
        self.page.route("**/api/reader-resolve?id=id-only-fallback", lambda route: route.fulfill(status=503, body="unavailable"))
        self.page.unroute("**/api/reader-content**")
        self.page.route("**/api/reader-content**", lambda route: route.fulfill(status=200, content_type="text/plain", body=b"Stored reader"))
        self.page.goto(f"{self.origin}/static/reader.html?id=id-only-fallback", wait_until="domcontentloaded")
        self.page.locator(".reader-text").wait_for(state="visible")
        self.assertEqual(self.page.locator(".reader-text").text_content(), "Stored reader")
        self.assertEqual(self.page.locator("#title").text_content(), "Stored title.txt")

    def test_document_preparation_overlaps_delayed_history_restore(self):
        self.open_pdf()
        store_started = self.page.evaluate("window.__storeStartedAt")
        self.assertIsNotNone(self.pdf_requested_at)
        self.assertLess(self.pdf_requested_at - store_started, 250)

    def test_pdf_rendering_has_bounded_concurrency_and_canvas_memory(self):
        self.open_pdf()
        metrics = self.scroll_document()
        self.assertLessEqual(metrics["peak"], 2)
        self.assertLessEqual(metrics["rendered"], 11)
        self.assertGreater(metrics["pixels"], 0)

    def test_pdf_exposes_lazy_accessible_text(self):
        self.open_pdf()
        first_page = self.page.locator(".reader-page").first
        self.assertEqual(first_page.get_attribute("role"), "region")
        self.assertEqual(first_page.locator("canvas").get_attribute("aria-hidden"), "true")
        self.page.wait_for_function("document.querySelector('.reader-page')?.dataset.textReady === '1'")
        self.assertEqual(first_page.locator(".reader-pdf-text").text_content(), "Accessible PDF text")

    def test_native_pdf_canvas_does_not_wait_for_text_layer(self):
        module = PDF_MODULE.replace(
            "getTextContent() { return Promise.resolve({ items: [{ str: 'Accessible PDF text', hasEOL: false }] }); },",
            "getTextContent() { return new Promise(resolve => setTimeout(() => resolve({ items: [{ str: 'Accessible PDF text', hasEOL: false }] }), 1000)); },",
        )
        self.page.unroute("**/static/vendor/pdf.min.*.mjs")
        self.page.route("**/static/vendor/pdf.min.*.mjs", lambda route: route.fulfill(
            content_type="text/javascript", body=module))
        self.open_pdf()
        self.page.locator('.reader-page[data-page="1"] canvas.ready').wait_for(timeout=3000)
        self.assertNotEqual(
            self.page.locator('.reader-page[data-page="1"]').get_attribute("data-text-ready"), "1"
        )
        self.page.locator('.reader-page[data-page="1"][data-text-ready="1"]').wait_for(timeout=3000)

    def test_scanned_pdf_bookmark_has_empty_excerpt(self):
        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-page')?.dataset.textReady === '1'")
        self.assertEqual(self.page.locator('.reader-pdf-text').first.text_content(), '')
        self.page.locator('#bookmark-ribbon').click()
        self.assertEqual(self.page.locator('#bookmark-excerpt-input').input_value(), '')
        self.page.locator('#bookmark-add').click()
        self.page.wait_for_function('window.__readerBookmarks.length === 1')
        self.assertEqual(self.page.evaluate('window.__readerBookmarks[0].excerpt'), '')

    def test_reader_panel_bookmark_search_and_theme(self):
        self.page.add_init_script("window.__pdfOutlineEnabled = true")
        self.open_pdf()
        self.page.locator("#bookmark-ribbon").click()
        self.assertEqual(self.page.locator("#bookmark-popover").get_attribute("role"), "dialog")
        self.assertEqual(self.page.locator("#bookmark-ribbon").get_attribute("aria-expanded"), "true")
        self.page.locator("#bookmark-add").press("Escape")
        self.assertTrue(self.page.locator("#bookmark-popover").is_hidden())
        self.assertEqual(self.page.locator("#bookmark-ribbon").get_attribute("aria-expanded"), "false")
        self.page.locator("#bookmark-ribbon").click()
        self.assertIn("第 1 / 30 页", self.page.locator("#bookmark-prompt").text_content())
        self.page.wait_for_function("() => window.__savedReaderProgress && window.__savedReaderProgress.page === 1")
        self.page.locator("#bookmark-add").click()
        self.page.locator("#history").click()
        self.assertTrue(self.page.locator("#history-panel").evaluate("element => element.classList.contains('is-open')"))
        self.assertNotEqual(self.page.locator("#history-panel").evaluate("element => getComputedStyle(element).transitionDuration"), "0s")
        self.assertTrue(self.page.locator("#toc-tab").is_visible())
        self.assertEqual(self.page.locator('.reader-panel-tabs button[aria-selected="true"]').get_attribute("data-panel"), "toc")
        self.assertEqual(self.page.locator(".reader-panel-tabs").get_attribute("role"), "tablist")
        self.page.locator("#toc-tab").focus()
        self.page.locator("#toc-tab").press("ArrowRight")
        self.assertEqual(self.page.locator('.reader-panel-tabs button[aria-selected="true"]').get_attribute("data-panel"), "bookmarks")
        self.page.locator("#bookmarks-tab").press("ArrowLeft")
        self.assertEqual(self.page.locator("#toc-list .panel-item-main").get_attribute("role"), "link")
        self.assertEqual(self.page.locator("#toc-list .panel-item-main").evaluate("element => getComputedStyle(element).userSelect"), "text")
        self.assertEqual(self.page.locator("#toc-panel .panel-search-toggle").text_content(), "搜索")
        self.assertEqual(self.page.locator("#history-panel > footer").count(), 0)
        self.assertEqual(self.page.locator("#history-panel > header #theme-toggle").count(), 1)
        self.assertEqual(self.page.locator("#history-panel > header .icon-btn").count(), 0)
        self.assertEqual(self.page.locator("#history-clear").text_content(), "清空历史")
        self.assertLess(self.page.locator("#history-clear").evaluate("element => [...element.parentElement.children].indexOf(element)"), self.page.locator("#history-view .panel-search-toggle").evaluate("element => [...element.parentElement.children].indexOf(element)"))
        self.assertEqual(self.page.locator("#history-clear").evaluate("element => getComputedStyle(element).alignItems"), "center")
        self.assertEqual(self.page.locator("#history-view .panel-search-toggle").evaluate("element => getComputedStyle(element).transform"), "none")
        self.page.locator('.reader-panel-tabs button[data-panel="bookmarks"]').click()
        self.page.locator("#bookmarks-list .panel-item-main").filter(has_text="第 1 / 30 页").wait_for()
        self.page.locator("#bookmarks-panel .panel-search-toggle").click()
        self.assertTrue(self.page.locator("#bookmarks-panel .panel-search").evaluate("element => element.classList.contains('is-open')"))
        self.page.locator("#bookmarks-panel .panel-search").fill("不存在")
        self.assertTrue(self.page.locator("#bookmarks-list .panel-item").is_hidden())
        self.page.locator("#history").click()
        self.page.locator("#history").click()
        self.assertEqual(self.page.locator('.reader-panel-tabs button[aria-selected="true"]').get_attribute("data-panel"), "toc")
        self.page.locator('.reader-panel-tabs button[data-panel="bookmarks"]').click()
        self.page.locator("#history").click()
        self.page.locator("#history").click()
        self.assertEqual(self.page.locator('.reader-panel-tabs button[aria-selected="true"]').get_attribute("data-panel"), "toc")
        self.page.locator("#theme-toggle").click()
        self.assertEqual(self.page.locator("html").get_attribute("data-theme"), "light")
        self.assertTrue(self.page.locator("html").evaluate("element => element.classList.contains('theme-transition')"))
        self.page.wait_for_timeout(300)
        self.assertNotEqual(self.page.locator(".compact-input").first.evaluate("element => getComputedStyle(element).backgroundColor"), "rgb(37, 41, 45)")
        self.page.locator("#page-prev").hover()
        self.assertNotEqual(self.page.locator("#page-prev").evaluate("element => getComputedStyle(element).backgroundColor"), "rgb(41, 45, 49)")
        self.assertEqual(self.page.locator("#zoom").get_attribute("min"), "25")
        self.assertEqual(self.page.locator("#zoom").get_attribute("max"), "400")

    def test_reader_controls_fit_viewport_without_overlap_and_work_on_mobile(self):
        self.open_pdf()

        def assert_toolbar_layout():
            layout = self.page.locator(".reader-toolbar").evaluate("""toolbar => {
              const view = {width: innerWidth, height: innerHeight};
              const selectors = ['#back', '#page-prev', '#page-number', '#page-next', '#zoom-out', '#zoom', '#zoom-in', '#history', '#download'];
              const rects = selectors.map(selector => {
                const element = document.querySelector(selector);
                const rect = element.getBoundingClientRect();
                return {selector, left: rect.left, top: rect.top, right: rect.right, bottom: rect.bottom, width: rect.width, height: rect.height, visible: !!(rect.width && rect.height)};
              }).filter(item => item.visible);
              return {toolbar: toolbar.getBoundingClientRect().toJSON(), view, rects};
            }""")
            self.assertGreaterEqual(layout["toolbar"]["height"], 36)
            for item in layout["rects"]:
                self.assertGreater(item["width"], 0, item["selector"])
                self.assertGreaterEqual(item["left"], 0, item["selector"])
                self.assertLessEqual(item["right"], layout["view"]["width"] + 1, item["selector"])
                self.assertGreaterEqual(item["top"], 0, item["selector"])
                self.assertLessEqual(item["bottom"], layout["toolbar"]["bottom"] + 1, item["selector"])
            for index, first in enumerate(layout["rects"]):
                for second in layout["rects"][index + 1:]:
                    overlap = first["left"] < second["right"] and second["left"] < first["right"] and first["top"] < second["bottom"] and second["top"] < first["bottom"]
                    self.assertFalse(overlap, f'{first["selector"]} overlaps {second["selector"]}')

        assert_toolbar_layout()
        self.page.locator("#page-next").click()
        self.assertEqual(self.page.locator("#page-number").input_value(), "2")
        self.page.locator("#page-prev").click()
        self.assertEqual(self.page.locator("#page-number").input_value(), "1")
        self.page.locator("#zoom-in").click()
        self.assertEqual(self.page.locator("#zoom").input_value(), "110")
        self.page.locator("#zoom-out").click()
        self.assertEqual(self.page.locator("#zoom").input_value(), "100")
        self.page.locator("#history").click()
        self.assertTrue(self.page.locator("#history-panel").evaluate("element => element.classList.contains('is-open')"))
        self.page.locator("#history-close").click()
        self.assertFalse(self.page.locator("#history-panel").evaluate("element => element.classList.contains('is-open')"))

        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.*.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")
        mobile_page.locator(".reader-page").nth(29).wait_for(state="attached")
        mobile_layout = mobile_page.locator(".reader-toolbar").evaluate("""toolbar => {
          const view = {width: innerWidth, height: innerHeight};
          const rects = [...toolbar.querySelectorAll('button, input, a')].map(element => {
            const rect = element.getBoundingClientRect();
            return {left: rect.left, right: rect.right, top: rect.top, bottom: rect.bottom, width: rect.width, height: rect.height, visible: !!(rect.width && rect.height)};
          }).filter(item => item.visible);
          return {toolbar: toolbar.getBoundingClientRect().toJSON(), view, rects};
        }""")
        self.assertEqual(mobile_layout["view"]["width"], 390)
        self.assertGreaterEqual(mobile_layout["toolbar"]["height"], 36)
        for item in mobile_layout["rects"]:
            self.assertGreaterEqual(item["left"], 0)
            self.assertLessEqual(item["right"], 390)
            self.assertLessEqual(item["bottom"], mobile_layout["toolbar"]["bottom"] + 1)
        mobile_page.locator("#history").click()
        self.assertTrue(mobile_page.locator("#history-panel").evaluate("element => element.classList.contains('is-open')"))
        mobile_page.wait_for_timeout(300)
        panel_box = mobile_page.locator("#history-panel").bounding_box()
        self.assertIsNotNone(panel_box)
        self.assertGreaterEqual(panel_box["x"], 0)
        self.assertLessEqual(panel_box["x"] + panel_box["width"], 390)
        mobile_context.close()

    def test_reader_controls_honor_boundaries_and_keyboard_activation(self):
        self.open_pdf()
        self.assertEqual(self.page.locator("#page-number").input_value(), "1")
        self.page.locator("#page-prev").click()
        self.assertEqual(self.page.locator("#page-number").input_value(), "1")
        self.page.locator("#page-next").focus()
        self.page.locator("#page-next").press("Enter")
        self.assertEqual(self.page.locator("#page-number").input_value(), "2")
        self.page.locator("#page-number").fill("999")
        self.page.locator("#page-number").press("Enter")
        self.page.wait_for_function("() => document.querySelector('#page-number').value === '30'")
        self.assertEqual(self.page.locator("#page-number").input_value(), "30")
        self.page.locator("#page-number").fill("0")
        self.page.locator("#page-number").press("Enter")
        self.page.wait_for_function("() => document.querySelector('#page-number').value === '1'")
        self.assertEqual(self.page.locator("#page-number").input_value(), "1")
        self.page.locator("#zoom").fill("999")
        self.page.locator("#zoom").press("Enter")
        self.page.wait_for_function("() => document.querySelector('#zoom').value === '400'")
        self.assertEqual(self.page.locator("#zoom").input_value(), "400")
        self.page.locator("#zoom-in").click()
        self.assertEqual(self.page.locator("#zoom").input_value(), "400")
        self.page.locator("#zoom").fill("1")
        self.page.locator("#zoom").press("Enter")
        self.page.wait_for_function("() => document.querySelector('#zoom').value === '25'")
        self.assertEqual(self.page.locator("#zoom").input_value(), "25")
        self.page.locator("#zoom-out").click()
        self.assertEqual(self.page.locator("#zoom").input_value(), "25")
        self.page.locator("#history").focus()
        self.page.locator("#history").press("Enter")
        self.assertEqual(self.page.locator("#history").get_attribute("aria-expanded"), "true")
        self.page.locator("#history-close").press("Enter")
        self.assertEqual(self.page.locator("#history").get_attribute("aria-expanded"), "false")
        self.assertTrue(self.page.locator("#download").get_attribute("href"))
        self.assertEqual(self.page.locator("#download").get_attribute("target"), "_blank")
        self.assertIn("noopener", self.page.locator("#download").get_attribute("rel"))

    def test_format_modes_expose_matching_controls_and_bookmark_ui(self):
        cases = [
            ("pdf", "pdf", "30 页", ".reader-page", "application/pdf", b"pdf", False, False),
            ("txt", "text", "已加载", ".reader-text", "text/plain", b"Text readable", True, False),
            ("md", "markdown", "已加载", ".reader-markdown", "text/markdown", b"# Markdown readable", True, False),
            ("html", "html", "HTML", "iframe.html-frame", "text/html", b"<p>HTML readable</p>", True, False),
            ("png", "image", "图片", ".reader-image", "image/png", PNG_BYTES, True, False),
            ("docx", "docx", "DOCX", ".docx-body", "application/vnd.openxmlformats-officedocument.wordprocessingml.document", minimal_docx(), False, False),
            ("wav", "audio", "音频", ".reader-audio", "audio/wav", minimal_wav(), True, True),
        ]
        for extension, mode, status, content_selector, content_type, body, page_hidden, zoom_hidden in cases:
            with self.subTest(extension=extension):
                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.*.mjs", lambda route: route.fulfill(status=200, content_type="text/javascript", body=PDF_MODULE))
                if extension == "md":
                    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.*.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":
                    source = "https://huggingface.co/datasets/vomebook/Reader-Assets/resolve/main/objects/aa/" + "a" * 64 + "/docx-native-v1/document.docx"
                page.route("**/api/reader-resolve?id=capability-matrix", lambda route: route.fulfill(
                    status=200, content_type="application/json",
                    body=json.dumps({"url": source, "extension": extension, "title": "Matrix"}),
                ))
                page.goto(f"{self.origin}/static/reader.html?id=capability-matrix", wait_until="domcontentloaded")
                page.wait_for_function("expected => document.querySelector('#status').textContent === expected", arg=status)
                self.assertEqual(page.locator(".reader-content").get_attribute("data-mode"), mode)
                page.locator(content_selector).first.wait_for(state="attached")
                self.assertTrue(page.locator("#bookmark-ribbon").is_visible())
                ribbon = page.locator("#bookmark-ribbon").bounding_box()
                self.assertIsNotNone(ribbon)
                self.assertGreaterEqual(ribbon["x"], 0)
                self.assertLessEqual(ribbon["x"] + ribbon["width"], 390)
                self.assertEqual(page.locator(".page-controls").is_hidden(), page_hidden)
                self.assertEqual(page.locator(".zoom-controls").is_hidden(), zoom_hidden)
                self.assertEqual(page.locator("#full-search-toggle").evaluate("node => node.hidden"), mode in ("image", "audio"))
                self.assertEqual(page.locator("#media-tab").evaluate("node => node.hidden"), mode != "audio")
                self.assertFalse(page.locator(".reader-progress-bookmark").evaluate("node => node.hidden"))
                if not zoom_hidden:
                    page.locator("#zoom-in").click()
                    self.assertEqual(page.locator("#zoom").input_value(), "110")
                page.locator("#bookmark-ribbon").press("Enter")
                self.assertTrue(page.locator("#bookmark-popover").is_visible())
                page.locator("#bookmark-cancel").press("Escape")
                self.assertTrue(page.locator("#bookmark-popover").is_hidden())
                context.close()

    def test_video_failure_shows_recoverable_reader_error(self):
        context = self.browser.new_context(viewport={"width": 390, "height": 844})
        page = context.new_page()
        page.route("**/api/reader-content**", lambda route: route.fulfill(status=200, content_type="video/mp4", body=b"invalid video fixture"))
        source = "https://huggingface.co/datasets/VoiceOfML/Test/resolve/main/broken.mp4"
        page.route(source, lambda route: route.abort())
        page.goto(f"{self.origin}/static/reader.html?url={urllib.parse.quote(source, safe='')}&ext=mp4&title=Broken", wait_until="domcontentloaded")
        page.locator(".reader-error").wait_for(timeout=10000)
        self.assertIn("媒体加载失败", page.locator(".reader-error").text_content())
        self.assertEqual(page.locator("#status").text_content(), "无法打开")
        self.assertEqual(page.locator("#content").get_attribute("data-error-code"), "READER_MEDIA")
        self.assertFalse(page.locator(".reader-loading-indicator").count())
        context.close()

    def test_video_extension_aliases_report_media_errors_consistently(self):
        for extension in ("mp4", "mov", "video"):
            with self.subTest(extension=extension):
                context = self.browser.new_context(viewport={"width": 390, "height": 844})
                page = context.new_page()
                page.route("**/api/reader-content**", lambda route: route.fulfill(status=200, content_type="video/mp4", body=b"invalid video fixture"))
                source = f"https://huggingface.co/datasets/VoiceOfML/Test/resolve/main/broken.{extension}"
                page.route(source, lambda route: route.abort())
                page.goto(f"{self.origin}/static/reader.html?url={urllib.parse.quote(source, safe='')}&ext={extension}&title=Broken", wait_until="domcontentloaded")
                page.locator(".reader-error").wait_for(timeout=10000)
                self.assertEqual(page.locator("#status").text_content(), "无法打开")
                context.close()

    def test_unsupported_format_hides_inapplicable_controls(self):
        context = self.browser.new_context(viewport={"width": 390, "height": 844})
        page = context.new_page()
        source = "https://huggingface.co/datasets/VoiceOfML/Test/resolve/main/archive.zip"
        page.route("**/api/reader-resolve?id=unsupported-controls", lambda route: route.fulfill(
            status=200, content_type="application/json", body=json.dumps({"url": source, "extension": "zip"}),
        ))
        page.goto(f"{self.origin}/static/reader.html?id=unsupported-controls", wait_until="domcontentloaded")
        page.locator(".reader-error").wait_for(timeout=10000)
        self.assertIn("此文件暂不支持在线阅读", page.locator(".reader-error").text_content())
        self.assertEqual(page.locator("#content").get_attribute("data-error-code"), "READER_UNSUPPORTED")
        self.assertTrue(page.locator(".page-controls").is_hidden())
        self.assertTrue(page.locator(".zoom-controls").is_hidden())
        for selector in ("#full-search-toggle", "#media-tab", "#bookmark-ribbon", ".reader-progress-bookmark"):
            self.assertTrue(page.locator(selector).evaluate("node => node.hidden"), selector)
        self.assertFalse(page.locator(".reader-loading-indicator").count())
        context.close()

    def test_converted_pdf_pages_reject_invalid_manifest_and_missing_first_page(self):
        cases = [
            ("old-v1", {"version": 1, "kind": "pdf-pages", "pages": [{"page": 1, "path": f"objects/aa/{'a' * 64}/pages/page-000001.webp"}]}),
            ("bad-manifest", {"version": 2, "kind": "pdf-pages", "page_count": 0}),
            ("wrong-kind", {"version": 2, "kind": "pdf", "page_count": 1}),
            ("missing-page-count", {"version": 2, "kind": "pdf-pages"}),
            ("pages-field", {"version": 2, "kind": "pdf-pages", "page_count": 1, "pages": []}),
        ]
        for name, manifest in cases:
            with self.subTest(case=name):
                context = self.browser.new_context(viewport={"width": 390, "height": 844})
                page = context.new_page()
                source = "https://huggingface.co/datasets/vomebook/Reader-Assets/resolve/main/objects/aa/" + "a" * 64 + "/page-manifest.json"
                page.route("**/static/reader-store.js", lambda route: route.fulfill(status=200, content_type="text/javascript", body=STORE_SCRIPT))
                page.route("**/api/reader-content**", lambda route, _request, manifest=manifest: route.fulfill(status=200, content_type="application/json", body=json.dumps(manifest)))
                page.route("https://huggingface.co/datasets/vomebook/Reader-Assets/resolve/main/objects/aa/**", lambda route: route.fulfill(status=404, body=b""))
                page.goto(f"{self.origin}/static/reader.html?url={urllib.parse.quote(source, safe='')}&ext=pdf-pages&title=Converted", wait_until="domcontentloaded")
                page.locator(".reader-error").wait_for(timeout=10000)
                self.assertTrue(page.locator(".reader-error").text_content().strip())
                self.assertEqual(page.locator("#status").text_content(), "无法打开")
                self.assertFalse(page.locator(".reader-loading-indicator").count())
                context.close()

    def test_converted_pdf_pages_report_error_when_later_page_is_missing(self):
        context = self.browser.new_context(viewport={"width": 390, "height": 844})
        self.addCleanup(context.close)
        page = context.new_page()
        page.route("https://huggingface.co/**", lambda route: route.abort())
        source = "https://huggingface.co/datasets/vomebook/Reader-Assets/resolve/main/objects/aa/" + "a" * 64 + "/1234567890abcdef/page-manifest.json"
        root = "https://huggingface.co/datasets/vomebook/Reader-Assets/resolve/main/objects/aa/" + "a" * 64 + "/1234567890abcdef"
        manifest = {"version": 2, "kind": "pdf-pages", "page_count": 4}
        missing_requests = []
        page.route("**/static/reader-store.js", lambda route: route.fulfill(status=200, content_type="text/javascript", body=STORE_SCRIPT))
        page.route("**/api/reader-content**", lambda route: route.fulfill(status=200, content_type="application/json", body=json.dumps(manifest)))
        def serve_page(route, _request):
            if not route.request.url.endswith("page-000004.webp"):
                route.fulfill(status=200, content_type="image/webp", body=IMAGE_FIXTURES["webp"][1])
            else:
                missing_requests.append(route.request.url)
                route.fulfill(status=404, body=b"")
        page.route(f"{root}/pages/**", serve_page)
        page.goto(f"{self.origin}/static/reader.html?url={urllib.parse.quote(source, safe='')}&ext=pdf-pages&title=Converted", wait_until="domcontentloaded")
        page.locator(".reader-page img.ready").first.wait_for(timeout=10000)
        page.locator(".reader-page[data-page='4']").scroll_into_view_if_needed()
        page.wait_for_function("""() => {
          const shell = document.querySelector('.reader-page[data-page="4"]');
          return shell?.dataset.renderState === 'idle' && Number(shell.dataset.renderRetries) > 0;
        }""")
        self.assertTrue(missing_requests)
        self.assertTrue(page.locator(".reader-page[data-page='1'] img.ready").evaluate(
            "image => image.complete && image.naturalWidth > 0"))
        self.assertNotEqual(page.locator(".reader-page[data-page='4']").get_attribute("data-render-state"), "rendered")
        self.assertEqual(page.locator(".reader-page[data-page='4'] img.ready").count(), 0)
        context.close()

    def test_pdf_pages_stalled_early_manifest_uses_proxy(self):
        context = self.browser.new_context(viewport={"width": 390, "height": 844})
        self.addCleanup(context.close)
        page = context.new_page()
        root = "https://huggingface.co/datasets/vomebook/Reader-Assets/resolve/main/objects/aa/" + "a" * 64 + "/1234567890abcdef"
        source = root + "/page-manifest.json"
        proxy = []
        page.add_init_script(f"""(() => {{
          const fetchOriginal = window.fetch.bind(window);
          window.__earlyManifestAborted = false;
          window.fetch = (url, options = {{}}) => String(url) === {json.dumps(source)}
            ? new Promise((resolve, reject) => options.signal.addEventListener('abort', () => {{
                window.__earlyManifestAborted = true;
                reject(new DOMException('cancelled', 'AbortError'));
              }}, {{once: true}}))
            : fetchOriginal(url, options);
        }})()""")
        page.route("**/api/reader-content**", lambda route: (proxy.append(route.request.url), route.fulfill(
            content_type="application/json", body=json.dumps({"version": 2, "kind": "pdf-pages", "page_count": 2}))))
        page.route(f"{root}/pages/**", lambda route: route.fulfill(
            content_type="image/webp", body=IMAGE_FIXTURES["webp"][1]))
        page.goto(f"{self.origin}/static/reader.html?url={urllib.parse.quote(source, safe='')}&ext=pdf-pages", wait_until="domcontentloaded")
        page.locator('.reader-page[data-page="1"] img.ready').wait_for(timeout=8000)
        self.assertTrue(page.evaluate('window.__earlyManifestAborted'))
        self.assertTrue(proxy)

    def test_pdf_pages_progressive_prefetch_yields_to_jump(self):
        context = self.browser.new_context(viewport={"width": 390, "height": 844})
        self.addCleanup(context.close)
        page = context.new_page()
        root = "https://huggingface.co/datasets/vomebook/Reader-Assets/resolve/main/objects/aa/" + "a" * 64 + "/1234567890abcdef"
        source = root + "/page-manifest.json"
        held, requested = [], []
        page.route("**/api/reader-content**", lambda route: route.fulfill(
            content_type="application/json", body=json.dumps({"version": 2, "kind": "pdf-pages", "page_count": 40})))
        def serve_page(route):
            number = int(route.request.url.rsplit("page-", 1)[1].split(".", 1)[0])
            requested.append(number)
            if number == 12:
                held.append(route)
            else:
                route.fulfill(content_type="image/webp", body=IMAGE_FIXTURES["webp"][1])
        page.route(f"{root}/pages/**", serve_page)
        page.goto(f"{self.origin}/static/reader.html?url={urllib.parse.quote(source, safe='')}&ext=pdf-pages", wait_until="domcontentloaded")
        page.locator('.reader-page[data-page="1"] img.ready').wait_for(timeout=10000)
        page.wait_for_function("() => document.querySelector('.reader-page[data-page=\"12\"]')")
        page.wait_for_timeout(2800)
        self.assertIn(12, requested)
        self.assertIn(13, requested)
        self.assertIn(14, requested)
        with page.expect_response(lambda response: response.url.endswith("page-000035.webp"), timeout=12000):
            page.locator('.reader-page[data-page="25"]').scroll_into_view_if_needed()
            page.locator('.reader-page[data-page="25"] img.ready').wait_for(timeout=10000)
            for route in held:
                try: route.abort()
                except PlaywrightError: pass
        self.assertIn(35, requested)

    def test_pdf_pages_jump_does_not_wait_for_stalled_background_image(self):
        context = self.browser.new_context(viewport={"width": 390, "height": 844})
        self.addCleanup(context.close)
        page = context.new_page()
        page.add_init_script("Object.defineProperty(navigator, 'connection', {value: {saveData: true}, configurable: true})")
        root = "https://huggingface.co/datasets/vomebook/Reader-Assets/resolve/main/objects/aa/" + "a" * 64 + "/1234567890abcdef"
        source = root + "/page-manifest.json"
        held, requested = [], []
        page.route("**/api/reader-content**", lambda route: route.fulfill(
            content_type="application/json", body=json.dumps({"version": 2, "kind": "pdf-pages", "page_count": 40})))
        def serve_page(route):
            number = int(route.request.url.rsplit("page-", 1)[1].split(".", 1)[0])
            requested.append(number)
            if number == 2:
                held.append(route)
            else:
                route.fulfill(content_type="image/webp", body=IMAGE_FIXTURES["webp"][1])
        page.route(f"{root}/pages/**", serve_page)
        page.goto(f"{self.origin}/static/reader.html?url={urllib.parse.quote(source, safe='')}&ext=pdf-pages", wait_until="domcontentloaded")
        page.locator('.reader-page[data-page="1"] img.ready').wait_for(timeout=10000)
        page.wait_for_function("""() => document.querySelector('.reader-page[data-page="2"]')?._renderStarted""", timeout=10000)
        page.locator("#page-number").fill("25")
        page.locator("#page-number").dispatch_event("change")
        page.wait_for_function("""() => document.querySelector('.reader-page[data-page="25"]').getBoundingClientRect().top <= document.querySelector('#viewport').getBoundingClientRect().top + 2""", timeout=3000)
        page.locator('.reader-page[data-page="25"] img.ready').wait_for(timeout=3000)
        self.assertIn(25, requested)
        for route in held:
            try: route.abort()
            except PlaywrightError: pass

    def test_converted_pdf_pages_fit_wide_images_without_overlap(self):
        context = self.browser.new_context(viewport={"width": 390, "height": 844})
        self.addCleanup(context.close)
        page = context.new_page()
        page.route("https://huggingface.co/**", lambda route: route.abort())
        source = "https://huggingface.co/datasets/vomebook/Reader-Assets/resolve/main/objects/aa/" + "a" * 64 + "/1234567890abcdef/page-manifest.json"
        root = "https://huggingface.co/datasets/vomebook/Reader-Assets/resolve/main/objects/aa/" + "a" * 64 + "/1234567890abcdef"
        manifest = {"version": 2, "kind": "pdf-pages", "page_count": 3, "toc": [{"title": "第一章", "page": 1, "depth": 0}, {"title": "第二章", "page": 2, "depth": 1}]}
        wide_page = b'<svg xmlns="http://www.w3.org/2000/svg" width="2400" height="3200"><rect width="100%" height="100%" fill="white"/></svg>'
        page.route("**/static/reader-store.js", lambda route: route.fulfill(status=200, content_type="text/javascript", body=STORE_SCRIPT))
        page.route("**/api/reader-content**", lambda route: route.fulfill(status=200, content_type="application/json", body=json.dumps(manifest)))
        page.route(f"{root}/pages/**", lambda route: route.fulfill(status=200, content_type="image/svg+xml", body=wide_page))
        page.goto(f"{self.origin}/static/reader.html?url={urllib.parse.quote(source, safe='')}&ext=pdf-pages&title=Converted", wait_until="domcontentloaded")
        page.wait_for_function("""() => {
          const images = [...document.querySelectorAll('.reader-page img.ready')];
          return images.length === 3 && images.every(image =>
            image.complete && image.naturalWidth === 2400 && image.naturalHeight === 3200);
        }""", timeout=10000)
        boxes = page.locator(".reader-page").evaluate_all("""pages => pages.slice(0, 3).map(page => {
          const shell = page.getBoundingClientRect(), image = page.querySelector('img').getBoundingClientRect();
          return { shell: { top: shell.top, right: shell.right, bottom: shell.bottom, left: shell.left, width: shell.width }, image: { top: image.top, right: image.right, bottom: image.bottom, left: image.left, width: image.width } };
        })""")
        self.assertEqual(len(boxes), 3)
        for box in boxes:
            self.assertLessEqual(box["image"]["width"], box["shell"]["width"] + 1)
            self.assertGreaterEqual(box["image"]["left"], box["shell"]["left"] - 1)
            self.assertLessEqual(box["image"]["right"], box["shell"]["right"] + 1)
        for current, following in zip(boxes, boxes[1:]):
            self.assertGreaterEqual(following["shell"]["top"], current["image"]["bottom"])
        page.locator("#history").click()
        self.assertEqual(page.locator("#toc-list .toc-item").count(), 2)
        self.assertIn("第二章 · 第 2 页", page.locator("#toc-list .toc-item").nth(1).text_content())
        page.locator("#toc-list .toc-item").nth(1).click()
        page.wait_for_function("() => document.querySelector('#page-number').value === '2'")
        context.close()

    def test_compact_pdf_manifest_virtualizes_and_navigates_to_distant_page(self):
        context = self.browser.new_context(viewport={"width": 390, "height": 844})
        page = context.new_page()
        root = "https://huggingface.co/datasets/vomebook/Reader-Assets/resolve/main/objects/aa/" + "a" * 64 + "/1234567890abcdef"
        source = root + "/page-manifest.json"
        manifest = {"version": 2, "kind": "pdf-pages", "source_sha256": "a" * 64,
                    "profile": "test", "page_count": 5000}
        page.route("**/static/reader-store.js", lambda route: route.fulfill(status=200, content_type="text/javascript", body=STORE_SCRIPT))
        page.route(source, lambda route: route.fulfill(status=200, content_type="application/json", body=json.dumps(manifest)))
        page.route("**/api/reader-content**", lambda route: route.fulfill(status=200, content_type="application/json", body=json.dumps(manifest)))
        page.route(f"{root}/pages/**", lambda route: route.fulfill(status=200, content_type="image/webp", body=IMAGE_FIXTURES["webp"][1]))
        page.goto(f"{self.origin}/static/reader.html?url={urllib.parse.quote(source, safe='')}&ext=pdf-pages&title=Compact", wait_until="domcontentloaded")
        page.locator(".reader-page img.ready").first.wait_for(timeout=10000)
        self.assertLessEqual(page.locator(".reader-page img").count(), 25)
        page.locator("#viewport").evaluate("node => node.scrollTop = node.scrollHeight * 0.5")
        page.wait_for_function("() => Number(document.querySelector('#page-number').value) > 1500")
        self.assertLessEqual(page.locator(".reader-page").count(), 160)
        page.locator("#page-number").fill("4000")
        page.locator("#viewport").evaluate("node => { node.scrollTop += node.clientHeight * 1.2; node.dispatchEvent(new Event('scroll')); }")
        page.wait_for_timeout(80)
        self.assertEqual(page.locator("#page-number").input_value(), "4000")
        page.locator("#page-number").dispatch_event("change")
        page.locator(".reader-page[data-page='4000'] img.ready").wait_for(timeout=10000)
        self.assertEqual(page.locator("#page-number").input_value(), "4000")
        self.assertLessEqual(page.locator(".reader-page").count(), 160)
        self.assertEqual(page.locator(".reader-page[data-page='1']").count(), 0)
        page.locator("#page-number").fill("1")
        page.locator("#page-number").dispatch_event("change")
        page.locator(".reader-page[data-page='1'] img.ready").wait_for(timeout=10000)
        self.assertLessEqual(page.locator(".reader-page").count(), 160)
        self.assertLessEqual(page.locator(".reader-page img").count(), 25)
        context.close()

    def test_long_native_pdf_keeps_bounded_page_shells(self):
        module = PDF_TASK_MODULE.replace("numPages: 30", "numPages: 1200")
        self.page.unroute("**/static/vendor/pdf.min.*.mjs")
        self.page.route("**/static/vendor/pdf.min.*.mjs", lambda route: route.fulfill(
            content_type="text/javascript", body=module))
        self.page.goto(f"{self.origin}/static/reader.html?url={urllib.parse.quote(SOURCE_URL, safe='')}&ext=pdf", wait_until="domcontentloaded")
        self.page.locator('.reader-page[data-page="1"] canvas.ready').wait_for()
        self.page.evaluate("""() => {
          const run = document.querySelector('.reader-page[data-page="1"] .reader-pdf-text-run');
          const range = document.createRange();
          range.selectNodeContents(run);
          getSelection().removeAllRanges();
          getSelection().addRange(range);
        }""")
        self.page.locator("#viewport").evaluate("node => node.scrollTop = node.scrollHeight * .84")
        self.page.wait_for_function("() => Number(document.querySelector('#page-number').value) > 900")
        self.assertEqual(self.page.locator('.reader-page[data-page="1"]').count(), 1)
        self.assertEqual(self.page.evaluate("getSelection().toString()"),
                         self.page.locator('.reader-page[data-page="1"] .reader-pdf-text-run').first.text_content())
        self.page.evaluate("() => { getSelection().removeAllRanges(); document.activeElement.blur(); }")
        self.page.locator("#viewport").evaluate("node => node.scrollTop = node.scrollHeight * .92")
        self.page.wait_for_function("() => Number(document.querySelector('#page-number').value) > 1000")
        self.page.wait_for_function("() => !document.querySelector('.reader-page[data-page=\"1\"]')")
        self.assertEqual(self.page.locator('.reader-page[data-page="1"]').count(), 0)
        self.assertLessEqual(self.page.locator(".reader-page").count(), 160)
        self.assertEqual(self.page.locator('.reader-page[data-page="1"]').count(), 0)
        self.page.locator("#page-number").fill("1")
        self.page.locator("#page-number").dispatch_event("change")
        self.page.locator('.reader-page[data-page="1"] canvas.ready').wait_for()
        self.assertLessEqual(self.page.locator(".reader-page").count(), 160)

    def test_reader_toolbar_controls_have_accessible_names_and_state(self):
        self.open_pdf()
        controls = self.page.locator(".reader-toolbar button, .reader-toolbar a")
        names = self.page.locator(".reader-toolbar button:visible, .reader-toolbar a:visible").evaluate_all("""elements => elements.map(element => ({
          id: element.id,
          name: element.getAttribute('aria-label') || element.getAttribute('title') || element.textContent.trim(),
          type: element.tagName === 'BUTTON' ? element.type : '',
          target: element.tagName === 'A' ? element.target : '',
          rel: element.tagName === 'A' ? element.rel : ''
        }))""")
        self.assertGreater(controls.count(), 0)
        for item in names:
            self.assertTrue(item["name"], item["id"])
            if item["type"]:
                self.assertEqual(item["type"], "button", item["id"])
            if item["id"] == "download":
                self.assertEqual(item["target"], "_blank")
                self.assertIn("noopener", item["rel"])
        self.page.locator("#history").click()
        self.assertEqual(self.page.locator("#history").get_attribute("aria-expanded"), "true")
        self.page.locator("#theme-toggle").click()
        self.assertIn(self.page.locator("#theme-toggle").get_attribute("aria-label"), ("切换到白天模式", "切换到夜间模式"))
        self.page.locator("#bookmark-ribbon").press("Enter")
        self.assertEqual(self.page.locator("#bookmark-ribbon").get_attribute("aria-expanded"), "true")
        self.page.locator("#bookmark-cancel").press("Escape")
        self.assertEqual(self.page.locator("#bookmark-ribbon").get_attribute("aria-expanded"), "false")

    def test_text_bookmark_uses_progress_excerpt_and_highlights_search(self):
        self.page.unroute("**/api/reader-content**")
        text = "\n\n".join(f"第 {index} 段 searchable-{index} 这是用于书签摘要搜索的正文内容。" * 5 for index in range(120))
        self.page.route("**/api/reader-content**", lambda route: route.fulfill(status=200, content_type="text/plain; charset=utf-8", body=text.encode()))
        source = "https://huggingface.co/datasets/VoiceOfML/Test/resolve/main/bookmark.txt"
        query = urllib.parse.quote(source, safe="")
        self.page.goto(f"{self.origin}/static/reader.html?url={query}&ext=txt&title=Bookmark", wait_until="domcontentloaded")
        self.page.locator(".reader-text").wait_for()
        self.page.locator("#viewport").evaluate("element => { element.scrollTop = element.scrollHeight * 0.5; element.dispatchEvent(new Event('scroll')); }")
        self.page.locator("#bookmark-ribbon").click()
        self.page.locator("#bookmark-label").fill("我的书签")
        self.page.locator("#bookmark-excerpt-input").fill("自定义摘要")
        self.page.locator("#viewport").evaluate("element => { element.scrollTop = element.scrollHeight * 0.35; element.dispatchEvent(new Event('scroll')); }")
        self.assertGreater(self.page.locator("#viewport").evaluate("element => element.scrollTop"), 0)
        self.assertIn("阅读进度", self.page.locator("#bookmark-prompt").text_content())
        self.assertNotIn("px", self.page.locator("#bookmark-prompt").text_content())
        self.assertRegex(self.page.locator("#bookmark-prompt").text_content(), r"阅读进度 \d+\.\d%")
        self.assertTrue(self.page.locator("#bookmark-excerpt-input").input_value())
        prompt_progress = float(self.page.locator("#bookmark-prompt").text_content().split("阅读进度 ", 1)[1].split("%", 1)[0])
        self.page.locator("#viewport").evaluate("element => { element.scrollTop = element.scrollHeight * 0.8; element.dispatchEvent(new Event('scroll')); }")
        self.page.locator("#bookmark-add").click()
        self.page.wait_for_function("() => window.__readerBookmarks.length === 1")
        bookmark = self.page.evaluate("window.__readerBookmarks[0]")
        self.assertEqual(bookmark["label"], "我的书签")
        self.assertEqual(bookmark["excerpt"], "自定义摘要")
        self.assertGreater(bookmark["progress"], 0)
        self.assertAlmostEqual(bookmark["progress"], prompt_progress, places=1)
        self.assertTrue(bookmark["excerpt"])
        self.page.evaluate("window.__readerBookmarks.push({id: 'other', url: 'https://example.test/other.txt', title: '另一本书', label: '阅读进度 12.3%', excerpt: '跨书摘要', readerUrl: location.href, createdAt: Date.now() + 1})")
        self.page.locator("#history").click()
        self.page.locator("#bookmarks-tab").click()
        self.page.locator("#bookmarks-list .bookmark-excerpt").wait_for()
        self.assertEqual(self.page.locator("#bookmarks-list .panel-item").count(), 1)
        self.page.locator("#bookmarks-all").click()
        self.page.locator("#bookmarks-list .panel-item").nth(1).wait_for()
        self.assertEqual(self.page.locator("#bookmarks-all").text_content(), "本书书签")
        self.assertIn("另一本书", self.page.locator("#bookmarks-list").text_content())
        term = bookmark["excerpt"].split()[0][:6]
        self.page.locator("#bookmarks-panel .panel-search-toggle").click()
        self.page.locator("#bookmarks-panel .panel-search").fill(term)
        self.assertGreater(self.page.locator("#bookmarks-list mark.search-match").count(), 0)
        self.page.locator("#bookmarks-panel .panel-search").fill("")
        self.page.locator("#bookmarks-list .panel-item-edit").first.click()
        self.page.locator("#bookmark-label").fill("修改后的标题")
        self.page.locator("#bookmark-excerpt-input").fill("修改后的摘要")
        self.page.locator("#bookmark-add").click()
        self.assertIn("修改后的标题", self.page.locator("#bookmarks-list").text_content())

    def test_full_text_search_lists_highlighted_snippets_and_jumps(self):
        self.page.unroute("**/api/reader-content**")
        text = ("开头内容。" * 80) + "正文目标词出现在这里，前后都有上下文。" + ("中间内容。" * 120) + "正文目标词再次出现。"
        self.page.route("**/api/reader-content**", lambda route: route.fulfill(status=200, content_type="text/plain", body=text.encode()))
        source = urllib.parse.quote("https://huggingface.co/datasets/VoiceOfML/Test/resolve/main/full-search.txt", safe="")
        self.page.goto(f"{self.origin}/static/reader.html?url={source}&ext=txt&title=FullSearch", wait_until="domcontentloaded")
        self.page.locator(".reader-text").wait_for()
        self.assertEqual(self.page.locator("#full-search-view").count(), 1)
        self.assertEqual(self.page.locator(".full-search-toggle").count(), 0)
        self.page.locator("#history").click()
        self.page.locator("#full-search-toggle").click()
        self.assertFalse(self.page.locator("#full-search-view").is_hidden())
        self.page.locator("#full-search-toggle").click()
        self.page.wait_for_timeout(300)
        self.assertTrue(self.page.locator("#history-panel").is_visible())
        self.assertTrue(self.page.locator("#full-search-view").is_hidden())
        self.page.locator("#full-search-toggle").click()
        self.page.locator("#full-search-input").fill("目标词")
        self.page.locator("#full-search-status").filter(has_text="2 个结果").wait_for()
        self.assertEqual(self.page.locator("#full-search-results .full-search-result").count(), 2)
        self.assertEqual(self.page.locator("#full-search-results mark.search-match").count(), 2)
        self.assertEqual(self.page.locator(".full-search-highlight").count(), 2)
        self.assertLessEqual(len(self.page.locator("#full-search-results .full-search-snippet").first.text_content()), 180)
        self.page.locator("#full-search-input").fill("阅读选项")
        self.page.locator("#full-search-status").filter(has_text="未找到").wait_for()
        self.assertEqual(self.page.locator("#full-search-results .full-search-result").count(), 0)
        self.page.locator("#full-search-input").fill("目标词")
        self.page.locator("#full-search-status").filter(has_text="2 个结果").wait_for()
        self.page.locator("#full-search-results .full-search-result").nth(1).click()
        self.assertGreater(self.page.locator("#viewport").evaluate("element => element.scrollTop"), 0)

    def test_pdf_allows_two_bookmarks_on_one_page_and_restores_offsets(self):
        self.open_pdf()
        self.page.locator("#bookmark-ribbon").click()
        self.page.locator("#bookmark-add").click()
        self.page.locator("#viewport").evaluate("element => { element.scrollTop = 360; element.dispatchEvent(new Event('scroll')); }")
        self.page.locator("#bookmark-ribbon").click()
        self.page.locator("#bookmark-add").click()
        bookmarks = self.page.evaluate("window.__readerBookmarks")
        self.assertEqual(len(bookmarks), 2)
        self.assertNotEqual(bookmarks[0]["id"], bookmarks[1]["id"])
        self.assertLess(bookmarks[0]["pageOffset"], bookmarks[1]["pageOffset"])
        self.page.locator("#history").click()
        self.page.locator("#bookmarks-tab").click()
        rows = self.page.locator("#bookmarks-list .panel-item-main")
        self.assertEqual(rows.count(), 2)
        self.page.locator("#viewport").evaluate("element => element.scrollTop = 0")
        rows.nth(1).click()
        self.assertGreater(self.page.locator("#viewport").evaluate("element => element.scrollTop"), 250)
        rows.nth(0).click()
        self.assertLess(self.page.locator("#viewport").evaluate("element => element.scrollTop"), 80)

    def test_bfcache_pageshow_waits_for_restoration_gate(self):
        delayed_store = STORE_SCRIPT.replace(
            "get: () => new Promise((resolve) => setTimeout(() => resolve(null), 300))",
            "get: () => new Promise((resolve) => setTimeout(() => resolve({url: location.href, scrollTop: 640, zoom: 100}), 1200))",
        )
        self.page.unroute("**/static/reader-store.js")
        self.page.route("**/static/reader-store.js", lambda route: route.fulfill(status=200, content_type="text/javascript", body=delayed_store))
        query = urllib.parse.quote(SOURCE_URL, safe="")
        self.page.goto(f"{self.origin}/static/reader.html?url={query}&ext=pdf&title=Performance", wait_until="domcontentloaded")
        self.page.evaluate("""() => {
          for (const type of ["pagehide", "pageshow"]) {
            const event = new Event(type);
            Object.defineProperty(event, "persisted", { value: true });
            window.dispatchEvent(event);
          }
        }""")
        self.page.wait_for_timeout(650)
        self.assertNotEqual(self.page.locator("html").get_attribute("data-reader-phase"), "disposed")
        self.assertIsNone(self.page.evaluate("window.__savedReaderProgress || null"))
        self.page.wait_for_function("() => window.__savedReaderProgress && window.__savedReaderProgress.scrollTop >= 600", timeout=3000)

    def test_pagehide_before_restoration_does_not_overwrite_progress(self):
        query = urllib.parse.quote(SOURCE_URL, safe="")
        self.page.goto(f"{self.origin}/static/reader.html?url={query}&ext=pdf&title=Performance", wait_until="domcontentloaded")
        self.page.evaluate("window.dispatchEvent(new Event('pagehide'))")
        self.page.wait_for_timeout(150)
        self.assertEqual(self.page.locator("html").get_attribute("data-reader-phase"), "disposed")
        self.assertIsNone(self.page.evaluate("window.__savedReaderProgress || null"))

    def test_blocked_v1_upgrade_does_not_block_document_loading(self):
        context = self.browser.new_context(viewport={"width": 390, "height": 844})
        blocker = context.new_page()
        blocker.goto(f"{self.origin}/static/reader.html", wait_until="domcontentloaded")
        blocker.evaluate("""async () => {
          await new Promise((resolve) => { const request = indexedDB.deleteDatabase('voiceofml-reader'); request.onsuccess = request.onerror = request.onblocked = resolve; });
          window.__heldDb = await new Promise((resolve, reject) => { const request = indexedDB.open('voiceofml-reader', 1); request.onupgradeneeded = () => { const store = request.result.createObjectStore('entries', {keyPath: 'url'}); store.createIndex('lastReadAt', 'lastReadAt'); }; request.onsuccess = () => resolve(request.result); request.onerror = () => reject(request.error); });
        }""")
        reader = context.new_page()
        reader.route("**/api/reader-content**", lambda route: route.fulfill(status=200, content_type="text/plain", body=b"Reader"))
        source = urllib.parse.quote("https://huggingface.co/datasets/VoiceOfML/Test/resolve/main/blocked.txt", safe="")
        reader.goto(f"{self.origin}/static/reader.html?url={source}&ext=txt&title=Blocked", wait_until="domcontentloaded")
        reader.locator(".reader-text").wait_for(timeout=5000)
        blocker.evaluate("window.__heldDb.close()")
        context.close()

    def test_html_bookmark_at_zero_restores_iframe_top(self):
        self.page.unroute("**/api/reader-content**")
        document = b"<main><p style='height:1800px'>Top bookmark content</p><p>Bottom</p></main>"
        self.page.route("**/api/reader-content**", lambda route: route.fulfill(status=200, content_type="text/html", body=document))
        source = "https://huggingface.co/datasets/VoiceOfML/Test/resolve/main/bookmark.html"
        query = urllib.parse.quote(source, safe="")
        self.page.goto(f"{self.origin}/static/reader.html?url={query}&ext=html&title=HTML", wait_until="domcontentloaded")
        self.page.locator(".html-frame").wait_for()
        self.page.evaluate("url => VoiceOfMLReaderStore.putBookmark({id: url + '\\0top', url, label: '阅读进度 0.0%', htmlScrollTop: 0, scrollTop: 0, createdAt: 1})", source)
        self.page.locator("#history").click()
        self.page.locator("#bookmarks-tab").click()
        bookmark = self.page.locator("#bookmarks-list .panel-item-main")
        bookmark.wait_for()
        self.page.locator(".html-frame").evaluate("frame => frame.contentWindow.scrollTo(0, 900)")
        bookmark.click()
        self.assertEqual(self.page.locator(".html-frame").evaluate("frame => frame.contentWindow.scrollY"), 0)

    def test_stale_bookmark_query_cannot_overwrite_all_bookmarks(self):
        context = self.browser.new_context(viewport={"width": 390, "height": 844})
        page = context.new_page()
        store = """window.VoiceOfMLReaderStore = Object.freeze({
          get: () => Promise.resolve(null), put: () => Promise.resolve(), list: () => Promise.resolve([]), remove: () => Promise.resolve(), clearHistory: () => Promise.resolve(),
          putBookmark: () => Promise.resolve(), removeBookmark: () => Promise.resolve(),
          listBookmarks: (url) => new Promise((resolve) => setTimeout(() => resolve([{id:'local', url, title:'Current book', label:'Current mark', createdAt:1}]), 180)),
          listAllBookmarks: () => new Promise((resolve) => setTimeout(() => resolve([{id:'all', url:'other', readerUrl:location.href, title:'All book', label:'All mark', createdAt:2}]), 10))
        });"""
        page.route("**/static/reader-store.js", lambda route: route.fulfill(status=200, content_type="text/javascript", body=store))
        page.route("**/api/reader-content**", lambda route: route.fulfill(status=200, content_type="text/plain", body=b"Reader"))
        source = urllib.parse.quote("https://huggingface.co/datasets/VoiceOfML/Test/resolve/main/race.txt", safe="")
        page.goto(f"{self.origin}/static/reader.html?url={source}&ext=txt&title=Race", wait_until="domcontentloaded")
        page.locator(".reader-text").wait_for()
        page.locator("#history").click()
        page.locator("#bookmarks-tab").click()
        page.locator("#bookmarks-all").click()
        page.locator("#bookmarks-list .panel-item-main", has_text="All book").wait_for()
        page.wait_for_timeout(220)
        self.assertEqual(page.locator("#bookmarks-list .panel-item").count(), 1)
        self.assertIn("All book", page.locator("#bookmarks-list .panel-item-main").text_content())
        context.close()

    def test_truncated_epub_reports_source_damage(self):
        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("**/api/reader-content**", lambda route: route.fulfill(status=200, content_type="application/epub+zip", body=b"PK\x03\x04truncated"))
        source = "https://huggingface.co/datasets/VoiceOfML/Test/resolve/main/damaged.epub"
        page.goto(f"{self.origin}/static/reader.html?url={urllib.parse.quote(source, safe='')}&ext=epub&title=Damaged", wait_until="domcontentloaded")
        page.locator(".reader-error").wait_for(timeout=10000)
        self.assertTrue(page.locator(".reader-error").text_content().strip())
        self.assertEqual(page.locator("#content").get_attribute("data-error-code"), "READER_CORRUPT")
        context.close()

    def test_malicious_html_css_and_svg_are_inert_and_keep_safe_text(self):
        document = b'''<style>@import url("https://evil.test/style.css");body{background:url(https://evil.test/bg)}</style><p id="safe">Safe reader text</p><script>parent.__unsafe=true</script><div onclick="parent.__unsafe=true"><a href="javascript:alert(1)">safe link</a></div><svg onload="parent.__unsafe=true"><image href="https://evil.test/image"></image></svg><link rel="stylesheet" href="https://evil.test/link.css"><img src="https://evil.test/image.png">'''
        self.page.unroute("**/api/reader-content**")
        self.page.route("**/api/reader-content**", lambda route: route.fulfill(status=200, content_type="text/html", body=document))
        external = []
        self.page.on("request", lambda request: external.append(request.url) if "evil.test" in request.url else None)
        source = "https://huggingface.co/datasets/VoiceOfML/Test/resolve/main/security.html"
        self.page.goto(f"{self.origin}/static/reader.html?url={urllib.parse.quote(source, safe='')}&ext=html&title=Security", wait_until="domcontentloaded")
        self.page.wait_for_function("() => document.querySelector('#status').textContent === 'HTML'")
        frame = self.page.locator("iframe.html-frame").content_frame
        self.assertEqual(frame.locator("#safe").text_content(), "Safe reader text")
        self.assertEqual(frame.locator("body script,body link,body svg").count(), 0)
        self.assertEqual(frame.locator("body img[src], body [href^='javascript:']").count(), 0)
        self.assertEqual(frame.locator("[onclick], [href^='javascript:']").count(), 0)
        self.assertFalse(self.page.evaluate("window.__unsafe === true")); self.assertEqual(external, [])

    def test_oversized_chapter_manifest_and_response_use_resource_limit(self):
        digest = "a" * 64; source = f"https://huggingface.co/datasets/vomebook/Reader-Assets/resolve/main/objects/aa/{digest}/chapter-manifest.json"; limit = 8 * 1024 * 1024
        manifest = {"version": 1, "kind": "epub-chapters", "chapters": [{"index": 1, "path": "chapter.xhtml", "bytes": 10}]}
        for name, headers, chapter_headers in (("manifest", {"content-length": str(limit + 1)}, None), ("chapter", {}, {"content-length": str(8 * 1024 * 1024 + 1)})):
            with self.subTest(case=name):
                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))
                def serve_limited(route, _request, headers=headers, chapter_headers=chapter_headers):
                    if chapter_headers and "chapter.xhtml" in route.request.url:
                        route.fulfill(status=200, content_type="text/html", headers=chapter_headers, body=b"<h1>chapter</h1>")
                    else:
                        route.fulfill(status=200, content_type="application/json", headers=headers, body=json.dumps(manifest))
                page.route("**/api/reader-content**", serve_limited)
                if chapter_headers: page.route("https://huggingface.co/**", lambda route, _request, headers=chapter_headers: route.fulfill(status=200, content_type="text/html", headers=headers, body=b"<h1>chapter</h1>"))
                page.goto(f"{self.origin}/static/reader.html?url={urllib.parse.quote(source, safe='')}&ext=epub-chapters&title=Limits", wait_until="domcontentloaded")
                page.locator(".reader-error").wait_for(timeout=10000); self.assertIn(page.locator("#content").get_attribute("data-error-code"), ("READER_PARSE", "READER_CORRUPT")); expected_limit = limit if name == "manifest" else 8 * 1024 * 1024; self.assertEqual(page.evaluate("limit => { try { VoiceOfMLReaderSecurity.assertResponseSize({headers:{get:()=>String(limit + 1)}}, limit); return null; } catch (error) { return error.message; } }", expected_limit), "READER_RESOURCE_LIMIT"); context.close()

    def test_zip_bomb_metadata_is_rejected_before_docx_and_foliate_parsers(self):
        payload = zip_bomb_metadata()
        with zipfile.ZipFile(io.BytesIO(payload)) as archive:
            self.assertIsNone(archive.testzip())
            entry = archive.getinfo("bomb.txt")
            self.assertGreater(entry.file_size / entry.compress_size, 200)
        for extension in ("epub", "docx"):
            with self.subTest(extension=extension):
                context = self.browser.new_context(viewport={"width": 390, "height": 844})
                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.*.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"
                page.goto(f"{self.origin}/static/reader.html?url={urllib.parse.quote(source, safe='')}&ext={extension}&title=Bomb", wait_until="domcontentloaded")
                page.locator(".reader-error").wait_for(timeout=10000)
                self.assertIn("READER_ARCHIVE_LIMIT", page.locator(".reader-error").text_content())
                self.assertEqual(page.locator("#content").get_attribute("data-error-code"), "READER_CORRUPT" if extension == "epub" else "READER_PARSE")
                self.assertFalse(page.evaluate("window.__archiveParserStarted === true"))
                context.close()

    def test_actual_store_broadcasts_progress_and_bookmark_updates_between_readers(self):
        self.page.unroute("**/static/reader-store.js"); self.page.unroute("**/api/reader-content**")
        self.page.route("**/api/reader-content**", lambda route: route.fulfill(status=200, content_type="text/plain", body=b"Shared reader"))
        source = "https://huggingface.co/datasets/VoiceOfML/Test/resolve/main/shared.txt"; query = urllib.parse.quote(source, safe="")
        self.page.goto(f"{self.origin}/static/reader.html?url={query}&ext=txt&title=Shared", wait_until="domcontentloaded"); self.page.locator(".reader-text").wait_for()
        other = self.context.new_page(); other.route("**/api/reader-content**", lambda route: route.fulfill(status=200, content_type="text/plain", body=b"Shared reader")); other.goto(f"{self.origin}/static/reader.html?url={query}&ext=txt&title=Shared", wait_until="domcontentloaded"); other.locator(".reader-text").wait_for(); other.locator("#history").click()
        self.page.evaluate("url => VoiceOfMLReaderStore.put({url, title:'Shared', extension:'txt', lastReadAt:Date.now(), scrollTop:321})", source)
        self.page.evaluate("url => VoiceOfMLReaderStore.putBookmark({id:'shared-bookmark', url, title:'Shared', label:'Shared mark', createdAt:Date.now()})", source)
        other.wait_for_function("() => [...document.querySelectorAll('#history-list .panel-item-main')].some(item => item.textContent.includes('Shared'))"); other.locator("#bookmarks-tab").click(); other.locator("#bookmarks-list .panel-item-main").filter(has_text="Shared mark").wait_for()

    def test_html_and_markdown_toc_click_navigation(self):
        for extension, body in (("html", b"<h1>HTML one</h1><p style='height:1000px'>space</p><h2>HTML two</h2>"), ("md", b"# Markdown one\n\n## Markdown two")):
            with self.subTest(extension=extension):
                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.*.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_does_not_delay_ready(self):
        module = PDF_MODULE.replace("getOutline: () => Promise.resolve(window.__pdfOutlineEnabled ? [{title: '第一章', dest: [{}], items: []}] : null)",
            "getOutline: () => new Promise(resolve => { window.__releaseOutline = () => resolve([{title: '第一章', dest: [{}], items: []}]); })")
        self.page.unroute("**/static/vendor/pdf.min.*.mjs")
        self.page.route("**/static/vendor/pdf.min.*.mjs", lambda route: route.fulfill(content_type="text/javascript", body=module))
        self.open_pdf()
        self.page.locator("html[data-reader-phase='ready']").wait_for()
        self.page.locator(".reader-page canvas.ready").first.wait_for()
        self.assertEqual(self.page.locator("#toc-list .toc-item").count(), 0)
        self.page.evaluate("window.__releaseOutline()")
        self.page.locator("#toc-list .toc-item").first.wait_for(state="attached")

    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.*.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_jump_scrolls_before_target_render_finishes(self):
        self.page.add_init_script("window.__pdfProbe = { loads: 0, destroys: 0, renders: [], cancels: [], releases: {}, holdPages: [20] }")
        module = PDF_TASK_MODULE.replace(
            "getOutline: async () => null,",
            "getOutline: async () => [{title: '第二十页', dest: [{}], items: []}],\n    getPageIndex: async () => 19,",
        )
        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("""() => {
            const viewport = document.querySelector('#viewport');
            return document.querySelector('#page-number').value === '20' &&
              viewport.scrollTop > 1000 && Boolean(window.__pdfProbe.releases[20]);
        }""")
        self.assertGreater(self.page.locator("#viewport").evaluate("node => node.scrollTop"), 1000)
        self.page.evaluate("window.__pdfProbe.releases[20]()")
        self.page.locator('.reader-page[data-page="20"] canvas.ready').wait_for()

    def test_pdf_outline_marks_current_entry_when_page_changes(self):
        self.page.add_init_script("window.__pdfOutlineEnabled = true")
        module = PDF_MODULE.replace(
            "[{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.*.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()
        self.assertTrue(self.page.locator("#toc-list .toc-item").nth(0).evaluate("row => row.classList.contains('is-current')"))
        self.page.evaluate("""() => {
            const viewport = document.querySelector('#viewport');
            viewport.scrollTop = document.querySelector('.reader-page[data-page="3"]').offsetTop;
            viewport.dispatchEvent(new Event('scroll'));
        }""")
        self.page.wait_for_function("() => document.querySelector('#page-number').value === '3'")
        self.assertTrue(self.page.locator("#toc-list .toc-item").nth(1).evaluate("row => row.classList.contains('is-current')"))

    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.*.mjs", lambda route: route.fulfill(
            status=200, content_type="text/javascript", body=PDF_TASK_MODULE,
        ))
        self.open_pdf()
        self.page.wait_for_function("() => document.documentElement.dataset.readerPhase === 'ready'")
        self.page.evaluate("window.__pdfProbe.holdPages = [20]")
        self.page.locator("#page-number").fill("20")
        self.page.locator("#page-number").dispatch_event("change")
        self.page.wait_for_function("() => Boolean(window.__pdfProbe.releases[20])")
        self.page.locator("#page-number").fill("3")
        self.page.locator("#page-number").dispatch_event("change")
        self.page.wait_for_function("() => Math.abs(document.querySelector('[data-page=\"3\"]').getBoundingClientRect().top - document.querySelector('#viewport').getBoundingClientRect().top) < 2")
        self.page.evaluate("""async () => {
          const pending = document.querySelector('[data-page="20"]')._renderPromise;
          window.__pdfProbe.releases[20](); await pending.catch(() => {});
          await new Promise(resolve => requestAnimationFrame(() => requestAnimationFrame(resolve)));
        }""")
        self.assertEqual(self.page.locator("#page-number").input_value(), "3")
        self.assertAlmostEqual(self.page.locator("#viewport").evaluate("node => node.getBoundingClientRect().top"),
                               self.page.locator('[data-page="3"]').evaluate("node => node.getBoundingClientRect().top"), delta=2)
        self.page.wait_for_function("() => window.__savedReaderProgress?.page === 3")
        self.page.locator("#history").click()
        self.page.locator("#full-search-toggle").click()
        for action in ("replace", "clear"):
            with self.subTest(action=action):
                if action == "clear":
                    # A completed search caches extracted text. Use a fresh
                    # document so cancellation still exercises an in-flight read.
                    self.open_pdf()
                    self.page.wait_for_function("() => document.documentElement.dataset.readerPhase === 'ready'")
                    self.page.locator("#history").click()
                    self.page.locator("#full-search-toggle").click()
                self.page.evaluate("window.__pdfProbe.holdText = true; delete window.__pdfProbe.releaseText")
                self.page.locator("#full-search-input").fill("obsolete")
                self.page.wait_for_function("() => Boolean(window.__pdfProbe.releaseText)")
                if action == "replace":
                    self.page.locator("#full-search-input").fill("current")
                    self.page.locator("#full-search-status").filter(has_text="1 个结果").wait_for()
                else:
                    self.page.locator("#full-search-clear").click()
                self.page.evaluate("""async () => {
                  window.__pdfProbe.releaseText();
                  await new Promise(resolve => requestAnimationFrame(() => requestAnimationFrame(resolve)));
                }""")
                self.assertEqual(self.page.locator('[data-page="1"] .full-search-highlight').count(), 0)
                if action == "replace":
                    self.assertEqual(self.page.locator("#full-search-results .full-search-location").all_text_contents(), ["第 2 页"])
                    self.assertEqual(self.page.locator("#full-search-results mark").all_text_contents(), ["current"])
                    self.assertEqual(self.page.locator("#content .full-search-highlight").all_text_contents(), ["current"])
                    self.assertFalse(self.page.locator("#full-search-next").is_disabled())
                else:
                    self.assertEqual(self.page.locator("#full-search-results .full-search-result").count(), 0)
                    self.assertEqual(self.page.locator("#content .full-search-highlight").count(), 0)
                    self.assertEqual(self.page.locator("#full-search-status").text_content(), "输入关键词搜索正文")
                    self.assertTrue(self.page.locator("#full-search-next").is_disabled())
                    self.assertTrue(self.page.locator("#full-search-prev").is_disabled())
        self.assertEqual(errors, [])

    def test_pdf_disposal_destroys_loading_task_and_cancels_render_queue(self):
        for phase in ("loading", "rendering"):
            with self.subTest(phase=phase):
                context = self.browser.new_context()
                self.addCleanup(context.close)
                page = context.new_page()
                errors = []
                page.on("pageerror", lambda error: errors.append(str(error)))
                page.add_init_script(f"window.__holdPdfLoad = {json.dumps(phase == 'loading')}")
                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.*.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":
                    page.wait_for_function("() => document.documentElement.dataset.readerPhase === 'ready'")
                    page.evaluate("""() => {
                      window.__pdfProbe.holdPages = [20, 21, 22];
                      for (const number of [20, 21, 22]) {
                        document.querySelector(`[data-page="${number}"]`).dispatchEvent(new Event('focus'));
                      }
                    }""")
                    page.wait_for_function("() => Boolean(window.__pdfProbe.releases[20] && window.__pdfProbe.releases[21])")
                    self.assertFalse(page.evaluate("Boolean(window.__pdfProbe.releases[22])"))
                page.evaluate("window.dispatchEvent(new PageTransitionEvent('pagehide', {persisted: true}))")
                self.assertEqual(page.evaluate("window.__pdfProbe.destroys"), 0)
                self.assertEqual(page.evaluate("window.__pdfProbe.cancels"), [])
                page.evaluate("window.dispatchEvent(new Event('pagehide'))")
                page.wait_for_function("() => document.documentElement.dataset.readerPhase === 'disposed'")
                before = page.evaluate("({renders: [...window.__pdfProbe.renders], saved: window.__savedReaderProgress || null})")
                page.evaluate("""async () => {
                  const pending = [...document.querySelectorAll('.reader-page')].map(node => node._renderPromise).filter(Boolean);
                  window.__pdfProbe.releaseLoad?.();
                  Object.values(window.__pdfProbe.releases).forEach(resolve => resolve());
                  await Promise.allSettled(pending);
                  window.dispatchEvent(new Event('pagehide'));
                }""")
                page.wait_for_timeout(550)  # Cross delayed history restoration and the save debounce.
                self.assertEqual(page.evaluate("window.__pdfProbe.destroys"), 1)
                self.assertEqual(page.evaluate("window.__pdfProbe.loads"), 1)
                self.assertEqual(page.evaluate("window.__pdfProbe.renders"), before["renders"])
                self.assertEqual(page.evaluate("window.__savedReaderProgress || null"), before["saved"])
                self.assertEqual(page.locator(".reader-error").count(), 0)
                self.assertEqual(page.locator("html").get_attribute("data-reader-phase"), "disposed")
                self.assertTrue(page.locator(".reader-page canvas").evaluate_all("nodes => nodes.every(node => node.width === 0 && node.height === 0)"))
                self.assertEqual(sorted(page.evaluate("window.__pdfProbe.cancels")), [20, 21] if phase == "rendering" else [])
                if phase == "loading":
                    self.assertEqual(page.locator(".reader-page").count(), 0)
                    self.assertIsNone(before["saved"])
                self.assertEqual(requests, [])
                self.assertEqual(errors, [])
                context.close()

    def test_epub_chapters_load_first_lazy_next_and_toc_destination(self):
        digest = "b" * 64
        source = f"https://huggingface.co/datasets/vomebook/Reader-Assets/resolve/main/objects/aa/{digest}/chapter-manifest.json"
        manifest = {"version": 1, "kind": "epub-chapters", "chapters": [
            {"index": i, "path": f"chapter-{i}.xhtml", "title": f"Chapter {i}", "bytes": 100}
            for i in range(1, 5)
        ]}
        requests, delayed = [], []
        self.page.unroute("**/api/reader-content**")
        def serve_chapter(route, _request):
            number = next((i for i in range(1, 5) if f"chapter-{i}.xhtml" in route.request.url), None)
            if number is None:
                route.fulfill(status=200, content_type="application/json", body=json.dumps(manifest))
                return
            requests.append(number)
            route.fulfill(status=200, content_type="text/html", body=f"<h1>Chapter {number}</h1><p style='height:1800px'>body</p>")
        self.page.route("**/api/reader-content**", serve_chapter)
        self.page.goto(f"{self.origin}/static/reader.html?url={urllib.parse.quote(source, safe='')}&ext=epub-chapters&title=Chapters", wait_until="domcontentloaded")
        self.page.locator(".reader-epub-chapter[data-chapter='1']").wait_for()
        self.assertEqual(set(requests), {1, 2, 3, 4})
        self.page.locator(".reader-epub-chapter[data-chapter='2']").wait_for()
        self.page.locator("#history").click()
        self.page.locator("#toc-list .panel-item-main").nth(2).click()
        self.page.locator(".reader-epub-chapter[data-chapter='3']").wait_for()
        self.page.locator(".reader-epub-chapter[data-chapter='4']").wait_for()
        self.page.evaluate("() => new Promise(resolve => requestAnimationFrame(() => requestAnimationFrame(resolve)))")
        self.assertEqual(self.page.locator(".reader-epub-chapter").evaluate_all("nodes => nodes.map(node => Number(node.dataset.chapter))"), [1, 2, 3, 4])
        self.assertEqual(self.page.locator(".reader-chapter-sentinel").count(), 0)
        self.assertEqual(sorted(requests), [1, 2, 3, 4])
        self.assertTrue(self.page.locator("#toc-list .toc-item").nth(2).evaluate("node => node.classList.contains('is-current')"))

    def test_epub_chapters_serve_nested_bundle_with_resources(self):
        digest = "c" * 64
        base = f"https://huggingface.co/datasets/vomebook/Reader-Assets/resolve/main/objects/aa/{digest}/foliate-original-v1/epub-chapters"
        source = base + "/chapter-manifest.json"
        chapters = {
            "chapters/chapter-0001.xhtml": '<h1>第一章</h1><img src="../resources/img.png"/><p style="height:900px">one</p>'.encode(),
            "chapters/chapter-0002.xhtml": "<h1>第二章</h1><p>two</p>".encode(),
        }
        manifest = {"version": 1, "kind": "epub-chapters", "chapters": [
            {"index": i, "title": f"第{i}章", "path": path, "bytes": len(body),
             "sha256": hashlib.sha256(body).hexdigest()}
            for i, (path, body) in enumerate(chapters.items(), 1)
        ]}
        image_url = base + "/resources/img.png"
        image_requests, unexpected_requests = [], []

        def reject_external(route):
            unexpected_requests.append(route.request.url)
            route.abort()

        def serve_image(route):
            image_requests.append(route.request.url)
            route.fulfill(status=200, content_type="image/png", body=PNG_BYTES)

        def serve_nested(route, _request):
            url = urllib.parse.parse_qs(urllib.parse.urlsplit(route.request.url).query)["url"][0]
            if url == source:
                route.fulfill(status=200, content_type="application/json", body=json.dumps(manifest).encode())
            elif url.startswith(base + "/") and url[len(base) + 1:] in chapters:
                route.fulfill(status=200, content_type="text/html", body=chapters[url[len(base) + 1:]])
            else:
                unexpected_requests.append(url)
                route.fulfill(status=404, body=b"no")

        self.page.unroute("**/api/reader-content**")
        self.page.route("**/api/reader-content**", serve_nested)
        self.page.route("https://huggingface.co/**", reject_external)
        self.page.route(image_url, serve_image)
        self.page.goto(f"{self.origin}/static/reader.html?url={urllib.parse.quote(source, safe='')}&ext=epub-chapters&title=Nested", wait_until="domcontentloaded")
        first = self.page.locator(".reader-epub-chapter[data-chapter='1']")
        first.wait_for()
        self.assertIn("第一章", first.inner_text())
        image = first.locator("img")
        image.wait_for()
        self.page.wait_for_function("""() => {
          const image = document.querySelector('.reader-epub-chapter[data-chapter="1"] img');
          return image?.complete && image.naturalWidth === 1 && image.naturalHeight === 1;
        }""")
        self.assertEqual(image.get_attribute("src"), image_url)
        self.assertEqual(image_requests, [image_url])
        self.page.locator("#history").click()
        self.page.locator("#toc-list .panel-item-main").nth(1).click()
        second = self.page.locator(".reader-epub-chapter[data-chapter='2']")
        second.wait_for()
        self.assertIn("第二章", second.inner_text())
        self.assertEqual(unexpected_requests, [])

    def test_foliate_normalizes_legacy_chm_markup_and_keeps_resources(self):
        # This case verifies preservation of source CSS; night colors have a separate contract.
        self.page.add_init_script("localStorage.setItem('theme', 'light')")
        with zipfile.ZipFile(io.BytesIO(epub_with_legacy_chm_markup())) as archive:
            files = {name: archive.read(name) for name in archive.namelist()}
        chapter_path = "OEBPS/chapters space%20/chapter.xhtml"
        files["OEBPS/content.opf"] = files["OEBPS/content.opf"].replace(
            b'href="chapter.xhtml"',
            f'href="{urllib.parse.quote(chapter_path.removeprefix("OEBPS/"))}"'.encode(),
        )
        resource_files = {
            f"OEBPS/images %23/{name}": PNG_BYTES
            for name in ("cover#1.png", "cover space.png", "literal%20.png", "literal%23.png")
        }
        resource_files["OEBPS/chapters space%20/local image.png"] = PNG_BYTES
        images = []
        for path in resource_files:
            relative = (path.removeprefix("OEBPS/chapters space%20/")
                        if path.startswith("OEBPS/chapters space%20/")
                        else "../" + path.removeprefix("OEBPS/"))
            images.append(f'<image href="{urllib.parse.quote(relative)}" width="16" height="16"/>')
        chapter = files.pop("OEBPS/chapter.xhtml").decode().replace(
            'href="style.css"', 'href="../style.css"',
        ).replace('src="picture.svg"', 'src="../picture.svg"')
        files[chapter_path] = chapter.replace(
            "<html:img",
            '<svg xmlns="http://www.w3.org/2000/svg" width="32" height="16">'
            + "".join(images) + '</svg><html:a id="full-image" href="local%20image.png">查看原图</html:a><html:img',
        )
        files.update(resource_files)
        payload = zip_bytes(files)
        requested_paths = []

        def resource(route):
            params = urllib.parse.parse_qs(urllib.parse.urlsplit(route.request.url).query)
            path = params["path"][0]
            requested_paths.append(path)
            self.assertEqual(params["book"], [source])
            # Match the backend's literal ZIP lookup, without an extra URL decode.
            with zipfile.ZipFile(io.BytesIO(payload)) as archive:
                try:
                    body = archive.read(path)
                except KeyError:
                    route.fulfill(status=404, body="missing member")
                    return
            route.fulfill(status=200, content_type="image/png", body=body)

        self.context.route("**/api/reader-resource**", resource)
        self.page.unroute("**/api/reader-content**")
        self.page.route("**/api/reader-content**", lambda route: route.fulfill(
            status=200, content_type="application/epub+zip", body=payload,
        ))
        source = "https://huggingface.co/datasets/VoiceOfML/Test/resolve/main/legacy.chm"
        query = urllib.parse.quote(source, safe="")
        self.page.goto(f"{self.origin}/static/reader.html?url={query}&ext=epub&title=Legacy", wait_until="domcontentloaded")
        paragraph = self.page.locator(".foliate-continuous article[data-section='0'] #legacy")
        paragraph.wait_for(state="visible")
        self.assertEqual(paragraph.text_content(), "Legacy CHM content正文第一段正文第二段")
        self.assertEqual(self.page.locator(".foliate-continuous #after-image").text_content(), "图片之后的正文")
        self.assertEqual(self.page.locator(".foliate-continuous h1").text_content(), "Article title")
        image = self.page.locator(".foliate-continuous article[data-section='0'] img")
        image.wait_for(state="visible")
        self.page.wait_for_timeout(100)
        self.assertEqual(paragraph.evaluate("element => getComputedStyle(element).color"), "rgb(1, 2, 3)")
        self.assertTrue((image.get_attribute("src") or "").startswith("blob:"))
        self.assertGreater(image.bounding_box()["height"], 0)
        self.page.wait_for_function("""count => performance.getEntriesByType('resource')
          .filter(entry => entry.name.includes('/api/reader-resource?')).length >= count""",
                                    arg=len(resource_files))
        self.assertEqual(set(requested_paths), set(resource_files))
        resource_paths = self.page.locator(".foliate-continuous article[data-section='0'] svg image").evaluate_all("""images =>
          images.map(image => new URL(image.getAttribute('href'), location.origin).searchParams.get('path'))""")
        self.assertCountEqual(resource_paths, resource_files)
        with self.page.expect_popup() as opened:
            self.page.locator('.foliate-continuous #full-image').click()
        popup = opened.value
        popup.wait_for_load_state()
        self.assertEqual(urllib.parse.parse_qs(urllib.parse.urlsplit(popup.url).query)['path'],
                         ['OEBPS/chapters space%20/local image.png'])
        popup.wait_for_function('() => document.querySelector("img")?.naturalWidth === 1')
        popup.close()

    def test_foliate_navigation_path_dark_links_and_unique_sections(self):
        context = self.browser.new_context(viewport={"width": 390, "height": 844})
        self.addCleanup(context.close)
        page = context.new_page()
        page.add_init_script("localStorage.setItem('theme', 'dark')")
        page.route("**/static/reader-store.js", lambda route: route.fulfill(status=200, content_type="text/javascript", body=STORE_SCRIPT))
        page.route("**/api/reader-content**", lambda route: route.fulfill(status=200, content_type="application/epub+zip", body=epub_with_navigation()))
        source = "https://huggingface.co/datasets/VoiceOfML/Test/resolve/main/e2e.epub"
        url = f"{self.origin}/static/reader.html?url={urllib.parse.quote(source, safe='')}&ext=epub&title=E2E&path=Test%2Fbooks"
        page.goto(url, wait_until="domcontentloaded")
        page.wait_for_function("() => document.querySelectorAll('#toc-list .toc-item').length === 2")
        link = page.locator(".foliate-continuous article[data-section='0'] a").first
        link.wait_for(state="attached")
        self.assertIsNotNone(page.locator(".foliate-continuous article[data-section='0']").evaluate("article => article.shadowRoot"))
        title_display = page.locator("#title").evaluate("element => getComputedStyle(element).display")
        page.locator(".foliate-continuous article[data-section='0']").evaluate("article => { const style = document.createElement('style'); style.textContent = '#title{display:none!important} a{color:rgb(1,2,3)!important;border-top-style:dotted}'; article.shadowRoot.appendChild(style); }")
        self.assertEqual(page.locator("#title").evaluate("element => getComputedStyle(element).display"), title_display)
        self.assertEqual(link.evaluate("element => getComputedStyle(element).borderTopStyle"), "dotted")
        self.assertEqual(link.evaluate("element => getComputedStyle(element).color"), "rgb(138, 180, 232)")
        page.locator("#history").click()
        for theme, color in (("light", "rgb(1, 2, 3)"), ("dark", "rgb(138, 180, 232)")):
            page.locator("#theme-toggle").click()
            page.wait_for_function("() => !document.documentElement.classList.contains('theme-transition')")
            self.assertEqual(page.locator("html").get_attribute("data-theme"), theme)
            self.assertEqual(link.evaluate("element => getComputedStyle(element).color"), color)
        page.locator("#history").click()
        self.assertEqual(page.locator("#reader-path").text_content(), "Test/books")
        self.assertIsNone(page.locator("#reader-path").get_attribute("hidden"))
        initial_url = page.url
        link.click()
        page.wait_for_function("() => document.querySelector('#viewport').scrollTop > 0")
        self.assertEqual(page.url, initial_url)
        self.assertAlmostEqual(page.locator("#one").evaluate("element => element.getBoundingClientRect().top - document.querySelector('#viewport').getBoundingClientRect().top"), 8, delta=2)
        page.locator("#history").click()
        page.locator("#toc-list .panel-item-main").nth(1).click()
        page.wait_for_function("() => document.querySelector('#toc-list .toc-item:nth-child(2)').classList.contains('is-current')")
        page.wait_for_function("() => document.querySelectorAll('.foliate-continuous article[data-section]').length === 3")
        sections = page.locator(".foliate-continuous article[data-section]").evaluate_all("items => items.map(item => item.dataset.section)")
        self.assertEqual(sections, ["0", "1", "2"])
        page.locator("#viewport").evaluate("element => { element.scrollTop = element.scrollHeight; element.dispatchEvent(new Event('scroll')); }")
        page.wait_for_timeout(250)
        self.assertEqual(page.locator(".foliate-continuous article[data-section]").evaluate_all("items => items.map(item => item.dataset.section)"), ["0", "1", "2"])
        context.close()

    def test_foliate_rapid_toc_navigation_keeps_latest_destination(self):
        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("**/api/reader-content**", lambda route: route.fulfill(status=200, content_type="application/epub+zip", body=epub_with_many_chapters()))
        source = "https://huggingface.co/datasets/VoiceOfML/Test/resolve/main/race.epub"
        page.goto(f"{self.origin}/static/reader.html?url={urllib.parse.quote(source, safe='')}&ext=epub&title=Race", wait_until="domcontentloaded")
        page.wait_for_function("() => document.querySelectorAll('#toc-list .toc-item').length === 14")
        page.evaluate("""() => {
          const sections = document.querySelector('foliate-view').book.sections.filter(section => section.linear !== 'no');
          for (const [index, delay] of [[6, 350], [10, 20]]) {
            const original = sections[index].createDocument.bind(sections[index]);
            sections[index].createDocument = () => new Promise((resolve, reject) => setTimeout(() => original().then(resolve, reject), delay));
          }
          document.querySelectorAll('#toc-list .panel-item-main')[5].click();
          document.querySelectorAll('#toc-list .panel-item-main')[9].click();
        }""")
        page.wait_for_timeout(700)
        self.assertTrue(page.locator("#toc-list .toc-item").nth(9).evaluate("item => item.classList.contains('is-current')"))
        self.assertAlmostEqual(page.locator("#chapter-10").evaluate("element => element.getBoundingClientRect().top - document.querySelector('#viewport').getBoundingClientRect().top"), 8, delta=2)
        sections = page.locator(".foliate-continuous article[data-section]").evaluate_all("items => items.map(item => Number(item.dataset.section))")
        self.assertEqual(sections, sorted(set(sections)))
        context.close()

    def test_foliate_failed_toc_section_can_retry(self):
        context = self.browser.new_context(viewport={"width": 390, "height": 844})
        page = context.new_page()
        errors = []
        page.on("pageerror", lambda error: errors.append(str(error)))
        page.route("**/static/reader-store.js", lambda route: route.fulfill(status=200, content_type="text/javascript", body=STORE_SCRIPT))
        page.route("**/api/reader-content**", lambda route: route.fulfill(status=200, content_type="application/epub+zip", body=epub_with_many_chapters()))
        source = "https://huggingface.co/datasets/VoiceOfML/Test/resolve/main/retry.epub"
        page.goto(f"{self.origin}/static/reader.html?url={urllib.parse.quote(source, safe='')}&ext=epub&title=Retry", wait_until="domcontentloaded")
        page.wait_for_function("() => document.querySelectorAll('#toc-list .toc-item').length === 14")
        page.evaluate("""() => {
          const sections = document.querySelector('foliate-view').book.sections.filter(item => item.linear !== 'no');
          const section = sections[10];
          window.__neighborFailures = 0;
          sections[9].createDocument = () => { window.__neighborFailures++; return Promise.reject(new Error('neighbor unavailable')); };
          const original = section.createDocument.bind(section); let attempts = 0;
          section.createDocument = () => ++attempts === 1 ? Promise.reject(new Error('transient section failure')) : original();
          window.__retrySection = () => document.querySelectorAll('#toc-list .panel-item-main')[9].click();
        }""")
        page.evaluate("window.__retrySection()")
        page.wait_for_timeout(100)
        page.evaluate("window.__retrySection()")
        page.locator("#chapter-10").wait_for(timeout=5000)
        page.wait_for_function("() => document.querySelector('#toc-list .toc-item:nth-child(10)').classList.contains('is-current')")
        self.assertAlmostEqual(page.locator("#chapter-10").evaluate("element => element.getBoundingClientRect().top - document.querySelector('#viewport').getBoundingClientRect().top"), 8, delta=2)
        self.assertGreater(page.evaluate("window.__neighborFailures"), 0)
        self.assertEqual(page.locator(".reader-error").count(), 0)
        self.assertEqual(errors, [])
        context.close()

    def test_foliate_duplicate_toc_navigation_shares_section_load(self):
        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("**/api/reader-content**", lambda route: route.fulfill(status=200, content_type="application/epub+zip", body=epub_with_many_chapters()))
        source = "https://huggingface.co/datasets/VoiceOfML/Test/resolve/main/deduplicate.epub"
        page.goto(f"{self.origin}/static/reader.html?url={urllib.parse.quote(source, safe='')}&ext=epub&title=Deduplicate", wait_until="domcontentloaded")
        page.wait_for_function("() => document.querySelectorAll('#toc-list .toc-item').length === 14")
        page.evaluate("""() => {
          const section = document.querySelector('foliate-view').book.sections.filter(item => item.linear !== 'no')[10];
          const original = section.createDocument.bind(section); window.__sectionCreates = 0;
          section.createDocument = () => { window.__sectionCreates += 1; return new Promise((resolve, reject) => setTimeout(() => original().then(resolve, reject), 200)); };
          document.querySelectorAll('#toc-list .panel-item-main')[9].click();
          document.querySelectorAll('#toc-list .panel-item-main')[9].click();
        }""")
        page.locator("#chapter-10").wait_for(timeout=5000)
        page.wait_for_function("() => document.querySelector('#toc-list .toc-item:nth-child(10)').classList.contains('is-current')")
        self.assertEqual(page.evaluate("window.__sectionCreates"), 1)
        self.assertEqual(page.locator(".foliate-continuous article[data-section='10']").count(), 1)
        self.assertTrue(page.locator("#toc-list .toc-item").nth(9).evaluate("item => item.classList.contains('is-current')"))
        context.close()

    def test_foliate_chapter_buttons_use_continuous_reader_navigation(self):
        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("**/api/reader-content**", lambda route: route.fulfill(status=200, content_type="application/epub+zip", body=epub_with_many_chapters()))
        source = "https://huggingface.co/datasets/VoiceOfML/Test/resolve/main/chapter-buttons.epub"
        page.goto(f"{self.origin}/static/reader.html?url={urllib.parse.quote(source, safe='')}&ext=epub&title=Buttons", wait_until="domcontentloaded")
        page.wait_for_function("() => document.querySelectorAll('#toc-list .toc-item').length === 14")
        page.locator("#history").click()
        page.locator("#toc-list .panel-item-main").nth(9).click()
        page.locator("#chapter-10").wait_for(timeout=5000)
        page.wait_for_function("() => document.querySelector('#toc-list .toc-item:nth-child(10)').classList.contains('is-current')")
        page.locator("#history").click()
        page.locator(".reader-chapter-next").click()
        page.locator("#chapter-11").wait_for(timeout=5000)
        page.wait_for_function("() => document.querySelector('#toc-list .toc-item:nth-child(11)').classList.contains('is-current')")
        self.assertAlmostEqual(page.locator("#chapter-11").evaluate("element => element.getBoundingClientRect().top - document.querySelector('#viewport').getBoundingClientRect().top"), 8, delta=2)
        self.assertTrue(page.locator("#toc-list .toc-item").nth(10).evaluate("item => item.classList.contains('is-current')"))
        context.close()

    def test_foliate_toc_retains_groups_and_chapter_buttons_skip_them(self):
        with zipfile.ZipFile(io.BytesIO(epub_with_navigation())) as archive:
            files = {name: archive.read(name) for name in archive.namelist()}
        files['OEBPS/nav.xhtml'] = files['OEBPS/nav.xhtml'].replace(
            b'<ol><li><a', '<ol><li><span>第一卷</span><ol><li><a'.encode()
        ).replace(b'</li><li><a', '</li></ol></li><li><span>第二卷</span><ol><li><a'.encode()).replace(
            b'</ol></nav>', b'</ol></li></ol></nav>')
        self.page.unroute('**/api/reader-content**')
        self.page.route('**/api/reader-content**', lambda route: route.fulfill(
            status=200, content_type='application/epub+zip', body=zip_bytes(files)))
        source = 'https://huggingface.co/datasets/VoiceOfML/Test/resolve/main/groups.epub'
        self.page.goto(f'{self.origin}/static/reader.html?url={urllib.parse.quote(source, safe="")}&ext=epub', wait_until='domcontentloaded')
        self.page.wait_for_function("() => document.querySelectorAll('#toc-list .toc-item').length === 4")
        self.page.locator('#history').click()
        self.assertEqual(self.page.locator('#toc-list [role=heading]').all_text_contents(), ['第一卷', '第二卷'])
        self.assertEqual(self.page.locator('#toc-list [role=link]').all_text_contents(), ['第一章', '第二章'])
        self.assertEqual(self.page.locator('#toc-list .toc-group [tabindex]').count(), 0)
        self.page.locator('#toc-list [role=link]').first.click()
        self.page.wait_for_function("() => document.querySelector('[data-toc-index=\"1\"]').classList.contains('is-current')")
        self.page.wait_for_function("() => document.querySelector('#history').getAttribute('aria-expanded') === 'false'")
        self.page.locator('#history').click()
        self.page.locator('.reader-chapter-next').click()
        self.page.wait_for_function("() => document.querySelector('[data-toc-index=\"3\"]').classList.contains('is-current')")
        self.assertAlmostEqual(self.page.locator('#two').evaluate(
            "e => e.getBoundingClientRect().top - document.querySelector('#viewport').getBoundingClientRect().top"), 8, delta=2)

    def test_chm_rebuilt_spine_ignores_previous_asset_positions(self):
        with zipfile.ZipFile(io.BytesIO(epub_with_navigation())) as archive:
            files = {name: archive.read(name) for name in archive.namelist()}
        files['OEBPS/content.opf'] = files['OEBPS/content.opf'].replace(
            b'<itemref idref="one"/><itemref idref="two"/>', b'<itemref idref="two"/><itemref idref="one"/>')
        root = 'objects/aa/' + 'a' * 64 + '/'
        files['META-INF/reader-chm.json'] = json.dumps({'version': 1,
            'previous_path': root + 'calibre-chm-epub-v2/document.epub',
            'previous_sections': ['OEBPS/nav.xhtml', 'OEBPS/chapter-1.xhtml', 'OEBPS/chapter-2.xhtml']})
        self.page.route('**/static/reader-store.js', lambda route: route.fulfill(
            status=200, content_type='text/javascript', body=STORE_SCRIPT.replace(
                'get: () => new Promise((resolve) => setTimeout(() => resolve(null), 300))',
                "get: url => Promise.resolve(url.includes('calibre-chm-epub-v2') ? {foliateSection:2, foliateOffset:100, foliateTocIndex:1} : null)")))
        self.page.route('**/api/reader-content**', lambda route: route.fulfill(
            status=200, content_type='application/epub+zip', body=zip_bytes(files)))
        source = 'https://huggingface.co/datasets/vomebook/Reader-Assets/resolve/main/' + root + 'manual-chm-navigation-v2/document.epub'
        self.page.goto(f'{self.origin}/static/reader.html?url={urllib.parse.quote(source, safe="")}&ext=epub', wait_until='domcontentloaded')
        self.page.wait_for_function("() => document.documentElement.dataset.readerPhase === 'ready'")
        self.page.wait_for_function("() => window.__savedReaderProgress?.foliateSection === 0")
        previous = source.replace('manual-chm-navigation-v2', 'calibre-chm-epub-v2')
        self.page.evaluate("url => VoiceOfMLReaderStore.putBookmark({id:'old-chm-mark',url,foliateSection:1,foliateOffset:150,label:'Old chapter one',createdAt:1})", previous)
        self.page.locator('#history').click()
        self.page.locator('#bookmarks-tab').click()
        self.assertEqual(self.page.locator('#bookmarks-list .panel-item-main', has_text='Old chapter one').count(), 0)
        self.assertIn('manual-chm-navigation-v2', urllib.parse.unquote(self.page.url))

    def test_foliate_scroll_updates_toc_on_animation_frame(self):
        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("**/api/reader-content**", lambda route: route.fulfill(status=200, content_type="application/epub+zip", body=epub_with_many_chapters()))
        source = "https://huggingface.co/datasets/VoiceOfML/Test/resolve/main/scroll-toc.epub"
        page.goto(f"{self.origin}/static/reader.html?url={urllib.parse.quote(source, safe='')}&ext=epub&title=ScrollToc", wait_until="domcontentloaded")
        page.wait_for_function("() => document.querySelectorAll('#toc-list .toc-item').length === 14")
        page.locator("#history").click()
        page.locator("#toc-list .panel-item-main").nth(9).click()
        page.wait_for_function("() => document.querySelector('#toc-list .toc-item:nth-child(10)').classList.contains('is-current')")
        page.evaluate("""() => { const viewport = document.querySelector('#viewport'), target = document.querySelector('.foliate-continuous article[data-section="11"]').shadowRoot.querySelector('#chapter-11'); viewport.scrollTop += target.getBoundingClientRect().top - viewport.getBoundingClientRect().top + 100; viewport.dispatchEvent(new Event('scroll')); }""")
        page.wait_for_function("() => document.querySelector('#toc-list .toc-item:nth-child(11)').classList.contains('is-current')", timeout=1000)
        context.close()

    def test_foliate_resize_keeps_current_text_anchor(self):
        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("**/api/reader-content**", lambda route: route.fulfill(status=200, content_type="application/epub+zip", body=epub_with_many_chapters()))
        source = "https://huggingface.co/datasets/VoiceOfML/Test/resolve/main/scroll-anchor.epub"
        page.goto(f"{self.origin}/static/reader.html?url={urllib.parse.quote(source, safe='')}&ext=epub&title=Anchor", wait_until="domcontentloaded")
        page.wait_for_function("() => document.querySelectorAll('#toc-list .toc-item').length === 14")
        page.locator("#history").click()
        page.locator("#toc-list .panel-item-main").nth(9).click()
        page.wait_for_function("() => document.querySelector('#toc-list .toc-item:nth-child(10)').classList.contains('is-current')")
        page.evaluate("""() => { const viewport = document.querySelector('#viewport'); viewport.style.overflowAnchor = 'none'; viewport.dispatchEvent(new Event('scroll')); }""")
        page.wait_for_timeout(50)
        before = page.locator("#chapter-10").evaluate("element => element.getBoundingClientRect().top")
        page.evaluate("""() => { const spacer = document.createElement('div'); spacer.style.height = '600px'; const articles = [...document.querySelectorAll('.foliate-continuous article[data-section]:not(.foliate-section-placeholder)')].filter(article => Number(article.dataset.section) < 10); articles[articles.length - 1].shadowRoot.querySelector('.reader-section-body').appendChild(spacer); }""")
        page.wait_for_function("top => Math.abs(document.querySelector('.foliate-continuous article[data-section=\"10\"]').shadowRoot.querySelector('#chapter-10').getBoundingClientRect().top - top) < 3", arg=before, timeout=2000)
        context.close()

    def test_foliate_virtualizes_distant_sections_and_reloads_them(self):
        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("**/api/reader-content**", lambda route: route.fulfill(status=200, content_type="application/epub+zip", body=epub_with_many_chapters()))
        source = "https://huggingface.co/datasets/VoiceOfML/Test/resolve/main/virtual.epub"
        page.goto(f"{self.origin}/static/reader.html?url={urllib.parse.quote(source, safe='')}&ext=epub&title=Virtual", wait_until="domcontentloaded")
        page.wait_for_function("() => document.querySelectorAll('#toc-list .toc-item').length === 14")
        for index in [1, 3, 5, 7, 9, 11, 13]:
            page.evaluate("i => document.querySelectorAll('#toc-list .panel-item-main')[i].click()", index)
            page.wait_for_function("i => document.querySelectorAll('#toc-list .toc-item')[i].classList.contains('is-current')", arg=index)
            page.wait_for_timeout(100)
        self.assertLessEqual(page.locator(".foliate-continuous article[data-section]:not(.foliate-section-placeholder)").count(), 12)
        self.assertGreater(page.locator(".foliate-section-placeholder").count(), 0)
        sections = page.locator(".foliate-continuous article[data-section]").evaluate_all("items => items.map(item => Number(item.dataset.section))")
        self.assertEqual(sections, sorted(set(sections)))
        page.evaluate("() => document.querySelectorAll('#toc-list .panel-item-main')[1].click()")
        page.wait_for_function("() => document.querySelector('#toc-list .toc-item:nth-child(2)').classList.contains('is-current')")
        page.locator(".foliate-continuous article[data-section]:not(.foliate-section-placeholder) #chapter-2").wait_for(timeout=5000)
        page.wait_for_function("() => document.querySelectorAll('.foliate-continuous article[data-section]:not(.foliate-section-placeholder)').length <= 12")
        context.close()

    def test_large_foliate_toc_keeps_a_bounded_dom_window(self):
        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("**/api/reader-content**", lambda route: route.fulfill(status=200, content_type="application/epub+zip", body=epub_with_many_chapters(600)))
        source = "https://huggingface.co/datasets/VoiceOfML/Test/resolve/main/large-toc.epub"
        page.goto(f"{self.origin}/static/reader.html?url={urllib.parse.quote(source, safe='')}&ext=epub&title=LargeToc", wait_until="domcontentloaded")
        page.wait_for_function("() => document.querySelector('#toc-list')?.classList.contains('toc-list-virtualized')")
        page.locator("#history").click()
        self.assertLess(page.locator("#toc-list .toc-item").count(), 100)
        page.evaluate("""() => { const panel = document.querySelector('#toc-panel'); panel.scrollTop = 20000; panel.dispatchEvent(new Event('scroll')); }""")
        page.wait_for_function("() => [...document.querySelectorAll('#toc-list .toc-item')].some(row => row.textContent.includes('章节 501'))")
        self.assertLess(page.locator("#toc-list .toc-item").count(), 100)
        page.locator('#toc-list [data-toc-index="500"] .panel-item-main').click()
        page.wait_for_function("() => document.querySelector('#toc-list [data-toc-index=\"500\"]')?.classList.contains('is-current')")
        self.assertEqual(page.locator('#toc-list .is-current').get_attribute('data-toc-index'), '500')
        context.close()

    def test_foliate_full_search_uses_continuous_reader_navigation(self):
        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("**/api/reader-content**", lambda route: route.fulfill(status=200, content_type="application/epub+zip", body=epub_with_many_chapters()))
        source = "https://huggingface.co/datasets/VoiceOfML/Test/resolve/main/search.epub"
        page.goto(f"{self.origin}/static/reader.html?url={urllib.parse.quote(source, safe='')}&ext=epub&title=Search", wait_until="domcontentloaded")
        page.wait_for_function("() => document.querySelectorAll('#toc-list .toc-item').length === 14")
        page.locator("#history").click()
        page.locator("#full-search-toggle").click()
        page.locator("#full-search-input").fill("正文 10")
        page.locator("#full-search-results .full-search-result").first.wait_for(timeout=10000)
        page.locator("#full-search-results .full-search-result").first.click()
        page.locator("#chapter-10").wait_for(timeout=5000)
        page.locator(".foliate-continuous .full-search-highlight").wait_for(timeout=5000)
        page.wait_for_function("() => !document.querySelector('#history-panel').classList.contains('is-open')")
        self.assertTrue(page.locator(".foliate-continuous .full-search-highlight").evaluate("element => { const rect = element.getBoundingClientRect(), viewport = document.querySelector('#viewport').getBoundingClientRect(); return rect.bottom > viewport.top && rect.top < viewport.bottom; }"))
        context.close()

    def test_foliate_bookmark_restores_continuous_section_position(self):
        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("**/api/reader-content**", lambda route: route.fulfill(status=200, content_type="application/epub+zip", body=epub_with_many_chapters()))
        source = "https://huggingface.co/datasets/VoiceOfML/Test/resolve/main/bookmark.epub"
        page.goto(f"{self.origin}/static/reader.html?url={urllib.parse.quote(source, safe='')}&ext=epub&title=Bookmark", wait_until="domcontentloaded")
        page.wait_for_function("() => document.querySelectorAll('#toc-list .toc-item').length === 14")
        page.locator("#history").click()
        page.locator("#toc-list .panel-item-main").nth(9).click()
        page.wait_for_function("() => document.querySelector('#toc-list .toc-item:nth-child(10)').classList.contains('is-current')")
        page.locator("#bookmark-ribbon").click()
        page.locator("#bookmark-add").click()
        page.wait_for_function("() => window.__readerBookmarks.length === 1")
        bookmark = page.evaluate("window.__readerBookmarks[0]")
        self.assertEqual(bookmark.get("foliateSection"), 10)
        page.locator("#viewport").evaluate("element => { element.scrollTop = 0; element.dispatchEvent(new Event('scroll')); }")
        page.locator("#history").click()
        page.locator("#bookmarks-tab").click()
        page.locator("#bookmarks-list .panel-item-main").click()
        page.wait_for_function("() => !document.querySelector('#history-panel').classList.contains('is-open')")
        page.wait_for_function("() => document.querySelector('#toc-list .toc-item:nth-child(10)').classList.contains('is-current')")
        self.assertAlmostEqual(page.locator("#chapter-10").evaluate("element => element.getBoundingClientRect().top - document.querySelector('#viewport').getBoundingClientRect().top"), 8, delta=3)
        context.close()

    def test_foliate_progress_slider_uses_continuous_viewport(self):
        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("**/api/reader-content**", lambda route: route.fulfill(status=200, content_type="application/epub+zip", body=epub_with_many_chapters()))
        source = "https://huggingface.co/datasets/VoiceOfML/Test/resolve/main/progress.epub"
        page.goto(f"{self.origin}/static/reader.html?url={urllib.parse.quote(source, safe='')}&ext=epub&title=Progress", wait_until="domcontentloaded")
        page.wait_for_function("() => document.querySelectorAll('#toc-list .toc-item').length === 14")
        page.locator("#history").click()
        page.locator("#toc-list .panel-item-main").nth(3).click()
        page.wait_for_function("() => document.querySelector('#toc-list .toc-item:nth-child(4)').classList.contains('is-current')")
        page.locator("#history").click()
        page.locator(".reader-progress-range").dispatch_event("pointerdown")
        # Seek inside section 12, away from its fractional-pixel top boundary.
        page.locator(".reader-progress-range").fill("81")
        page.locator(".reader-progress-range").dispatch_event("pointerup")
        page.wait_for_function("() => { const article = document.querySelector('.foliate-continuous article[data-section=\"12\"]'), viewport = document.querySelector('#viewport'); if (!article) return false; const marker = viewport.getBoundingClientRect().top + 8, rect = article.getBoundingClientRect(); return rect.top <= marker && rect.bottom > marker; }")
        self.assertAlmostEqual(float(page.locator(".reader-progress-percent").text_content().rstrip("%")), 81, delta=7)
        page.locator('.foliate-section-placeholder').first.evaluate("node => node.style.setProperty('--foliate-placeholder-height', `${node.getBoundingClientRect().height + 600}px`)")
        page.locator(".reader-progress-undo").click()
        page.wait_for_function("() => document.querySelector('#toc-list .toc-item:nth-child(4)').classList.contains('is-current')")
        self.assertAlmostEqual(page.locator("#chapter-4").evaluate("node => node.getBoundingClientRect().top - document.querySelector('#viewport').getBoundingClientRect().top"), 8, delta=3)
        self.assertTrue(page.locator(".reader-progress-undo").is_hidden())
        page.wait_for_function("() => window.__savedReaderProgress?.foliateSection === 4")
        context.close()

    def test_foliate_history_saves_structured_section_position(self):
        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("**/api/reader-content**", lambda route: route.fulfill(status=200, content_type="application/epub+zip", body=epub_with_many_chapters()))
        source = "https://huggingface.co/datasets/VoiceOfML/Test/resolve/main/history.epub"
        page.goto(f"{self.origin}/static/reader.html?url={urllib.parse.quote(source, safe='')}&ext=epub&title=History", wait_until="domcontentloaded")
        page.wait_for_function("() => document.querySelectorAll('#toc-list .toc-item').length === 14")
        page.locator("#history").click()
        page.locator("#toc-list .panel-item-main").nth(9).click()
        page.wait_for_function("() => document.querySelector('#toc-list .toc-item:nth-child(10)').classList.contains('is-current')")
        page.evaluate("window.dispatchEvent(new Event('pagehide'))")
        page.wait_for_function("() => window.__savedReaderProgress && window.__savedReaderProgress.foliateSection === 10")
        self.assertEqual(page.evaluate("window.__savedReaderProgress.foliateTocIndex"), 9)
        context.close()

    def test_foliate_history_restores_structured_section_position(self):
        context = self.browser.new_context(viewport={"width": 390, "height": 844})
        page = context.new_page()
        restored_store = STORE_SCRIPT.replace("get: () => new Promise((resolve) => setTimeout(() => resolve(null), 300)),", "get: () => Promise.resolve({foliateSection: 10, foliateOffset: 0, foliateTocIndex: 9, zoom: 1}),")
        page.route("**/static/reader-store.js", lambda route: route.fulfill(status=200, content_type="text/javascript", body=restored_store))
        page.route("**/api/reader-content**", lambda route: route.fulfill(status=200, content_type="application/epub+zip", body=epub_with_many_chapters()))
        source = "https://huggingface.co/datasets/VoiceOfML/Test/resolve/main/restore.epub"
        page.goto(f"{self.origin}/static/reader.html?url={urllib.parse.quote(source, safe='')}&ext=epub&title=Restore", wait_until="domcontentloaded")
        page.wait_for_function("() => document.querySelector('#toc-list .toc-item:nth-child(10)')?.classList.contains('is-current')", timeout=10000)
        self.assertAlmostEqual(page.locator("#chapter-10").evaluate("element => element.getBoundingClientRect().top - document.querySelector('#viewport').getBoundingClientRect().top"), 8, delta=3)
        delayed_store = restored_store.replace(
            "get: () => Promise.resolve({foliateSection: 10, foliateOffset: 0, foliateTocIndex: 9, zoom: 1}),",
            "get: () => new Promise(resolve => { window.__releaseHistory = () => resolve({foliateSection: 10, foliateOffset: 0, foliateTocIndex: 9, zoom: 1}); }),",
        )
        page.route("**/static/reader-store.js", lambda route: route.fulfill(status=200, content_type="text/javascript", body=delayed_store))
        page.reload(wait_until="domcontentloaded")
        page.wait_for_function("() => document.querySelectorAll('#toc-list .toc-item').length === 14")
        page.locator("#history").click()
        page.locator("#toc-list .panel-item-main").nth(1).click()
        page.wait_for_function("() => document.querySelector('#toc-list .toc-item:nth-child(2)').classList.contains('is-current')")
        page.evaluate("window.__releaseHistory()")
        page.wait_for_function("() => document.documentElement.dataset.readerPhase === 'ready'")
        page.wait_for_function("() => window.__savedReaderProgress?.foliateSection === 2")
        self.assertAlmostEqual(page.locator("#chapter-2").evaluate("node => node.getBoundingClientRect().top - document.querySelector('#viewport').getBoundingClientRect().top"), 8, delta=3)
        context.close()

    def test_reader_store_resets_old_history_and_keeps_current_bookmarks(self):
        context = self.browser.new_context(viewport={"width": 390, "height": 844})
        page = context.new_page()
        page.goto(f"{self.origin}/static/reader.html", wait_until="domcontentloaded")
        page.evaluate("""async () => {
          await new Promise((resolve) => { const request = indexedDB.deleteDatabase('voiceofml-reader'); request.onsuccess = request.onerror = request.onblocked = resolve; });
          await new Promise((resolve, reject) => {
            const request = indexedDB.open('voiceofml-reader', 1);
            request.onupgradeneeded = () => { const store = request.result.createObjectStore('entries', {keyPath: 'url'}); store.createIndex('lastReadAt', 'lastReadAt'); };
            request.onerror = () => reject(request.error);
            request.onsuccess = () => { const db = request.result, tx = db.transaction('entries', 'readwrite'); tx.objectStore('entries').put({url: 'legacy', lastReadAt: 1}); tx.oncomplete = () => { db.close(); resolve(); }; };
          });
        }""")
        page.route("**/api/reader-content**", lambda route: route.fulfill(status=200, content_type="text/plain", body=b"Reader"))
        source = "https://huggingface.co/datasets/VoiceOfML/Test/resolve/main/store.txt"
        page.goto(f"{self.origin}/static/reader.html?url={urllib.parse.quote(source, safe='')}&ext=txt&title=Store", wait_until="domcontentloaded")
        page.wait_for_function("() => document.querySelector('#status').textContent === '已加载'")
        result = page.evaluate("""async (url) => {
          const legacy = await VoiceOfMLReaderStore.get('legacy');
          await VoiceOfMLReaderStore.putBookmark({id: url + '\\0page:1', url, label: '第 1 页', createdAt: 1});
          const historyBeforeClear = await VoiceOfMLReaderStore.list();
          const bookmarkEntries = await VoiceOfMLReaderStore.listBookmarks(url);
          await VoiceOfMLReaderStore.clearHistory();
          return {legacy: !!legacy, schema: VoiceOfMLReaderStore.SCHEMA_VERSION,
            validHistory: historyBeforeClear.every(entry => typeof entry.url === 'string' && entry.schemaVersion === 1),
            history: (await VoiceOfMLReaderStore.list()).length, bookmarks: (await VoiceOfMLReaderStore.listBookmarks(url)).length,
            bookmarkSchema: bookmarkEntries[0].schemaVersion};
        }""", source)
        self.assertEqual(result, {"legacy": False, "schema": 1, "validHistory": True, "history": 0, "bookmarks": 1, "bookmarkSchema": 1})
        context.close()

    def test_mobile_pdf_rendering_uses_one_slot_and_seven_canvases(self):
        self.page.set_viewport_size({"width": 390, "height": 844})
        self.open_pdf()
        metrics = self.scroll_document()
        self.assertLessEqual(metrics["peak"], 1)
        self.assertLessEqual(metrics["rendered"], 7)
        self.assertGreater(metrics["pixels"], 0)

    def test_high_density_mobile_pdf_uses_backing_scale_without_distortion(self):
        context = self.browser.new_context(
            viewport={"width": 390, "height": 844}, device_scale_factor=3
        )
        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.*.mjs", lambda route: route.fulfill(
            status=200, content_type="text/javascript", body=PDF_MODULE
        ))
        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="")
        page.goto(
            f"{self.origin}/static/reader.html?url={query}&ext=pdf&title=Performance",
            wait_until="domcontentloaded",
        )
        page.locator(".reader-page canvas.ready").first.wait_for(timeout=10000)
        metrics = page.locator(".reader-page").first.evaluate("""shell => {
          const canvas = shell.querySelector('canvas');
          const box = canvas.getBoundingClientRect();
          return {
            dpr: devicePixelRatio,
            backingWidth: canvas.width,
            backingHeight: canvas.height,
            cssWidth: box.width,
            cssHeight: box.height,
            shellAspect: shell.getBoundingClientRect().width / shell.getBoundingClientRect().height,
            cssAspect: box.width / box.height,
            backingAspect: canvas.width / canvas.height,
            canvasCssWidth: parseFloat(getComputedStyle(canvas).width),
            canvasCssHeight: parseFloat(getComputedStyle(canvas).height),
          };
        }""")
        self.assertEqual(metrics["dpr"], 3)
        self.assertGreaterEqual(metrics["backingWidth"], metrics["cssWidth"] * 1.9)
        self.assertGreaterEqual(metrics["backingHeight"], metrics["cssHeight"] * 1.9)
        self.assertAlmostEqual(metrics["shellAspect"], metrics["cssAspect"], delta=0.01)
        self.assertAlmostEqual(metrics["cssAspect"], metrics["backingAspect"], delta=0.01)
        self.assertAlmostEqual(metrics["cssWidth"], metrics["canvasCssWidth"], delta=0.01)
        self.assertAlmostEqual(metrics["cssHeight"], metrics["canvasCssHeight"], delta=0.01)
        context.close()

    def test_mobile_zoom_enlarges_pdf_page_without_resizing_content_shell(self):
        self.page.set_viewport_size({"width": 390, "height": 844})
        self.open_pdf()
        before = self.page.evaluate("""() => ({
          content: document.querySelector('.reader-content').getBoundingClientRect().width,
          page: document.querySelector('.reader-page').getBoundingClientRect().width,
          pixels: document.querySelector('.reader-page canvas').width,
        })""")
        self.page.locator("#zoom-in").click(click_count=5)
        self.page.wait_for_function("before => document.querySelector('.reader-page canvas').width > before * 1.45", arg=before["pixels"])
        after = self.page.evaluate("""() => ({
          content: document.querySelector('.reader-content').getBoundingClientRect().width,
          page: document.querySelector('.reader-page').getBoundingClientRect().width,
          pixels: document.querySelector('.reader-page canvas').width,
        })""")
        self.assertAlmostEqual(after["content"], before["content"], delta=1)
        self.assertGreater(after["page"], before["page"] * 1.45)
        self.assertGreater(after["pixels"], before["pixels"] * 1.45)

    def test_txt_displays_before_stream_finishes(self):
        self.page.add_init_script(r"""
        const nativeFetch = window.fetch.bind(window);
        window.fetch = (input, init) => {
          const url = String(input && input.url || input);
          if (!url.includes('/api/reader-content?url=')) return nativeFetch(input, init);
          const encode = text => new TextEncoder().encode(text);
          const bytes = encode('first line\n');
          const large = encode('large ASCII chunk\n'.repeat(8192) + 'target\n中文');
          return Promise.resolve(new Response(new ReadableStream({
            start(controller) {
              window.__txtStream = controller;
              controller.enqueue(bytes);
              window.__txtLargeChunk = () => {
                controller.enqueue(large.slice(0, -1));
              };
              window.__txtFinish = () => {
                controller.enqueue(large.slice(-1));
                const ending = encode('\nfinal 中文');
                controller.enqueue(ending.slice(0, ending.length - 1));
                controller.enqueue(ending.slice(-1));
                controller.close();
              };
            }
          }), { status: 200, headers: { 'Content-Type': 'text/plain' } }));
        };
        """)
        source = "https://huggingface.co/datasets/VoiceOfML/Test/resolve/main/performance.txt"
        self.page.goto(f"{self.origin}/static/reader.html?url={urllib.parse.quote(source, safe='')}&ext=txt&title=Performance", wait_until="domcontentloaded")
        self.page.locator(".reader-text").filter(has_text="first line").wait_for(timeout=3000)
        self.assertNotEqual(self.page.locator("#status").text_content(), "已加载")
        self.assertEqual(self.page.locator(".reader-text").text_content(), "first line\n")
        self.page.locator("#history").click()
        self.page.locator("#full-search-toggle").click()
        self.page.locator("#full-search-input").fill("first line")
        self.page.locator(".reader-text mark.full-search-highlight").wait_for()
        self.assertEqual(self.page.locator(".reader-text mark.full-search-highlight").count(), 1)
        self.page.evaluate("window.__txtLargeChunk()")
        expected = "first line\n" + "large ASCII chunk\n" * 8192 + "target\n中"
        self.page.wait_for_function("() => document.querySelector('.reader-text').textContent.endsWith('target\\n中')")
        self.assertEqual(self.page.locator(".reader-text").text_content(), expected)
        self.assertNotEqual(self.page.locator("#status").text_content(), "已加载")
        self.page.locator("#full-search-clear").click()
        self.assertEqual(self.page.locator(".reader-text mark").count(), 0)
        self.assertEqual(self.page.locator(".reader-text").text_content(), expected)
        self.page.evaluate("window.__txtFinish()")
        self.page.wait_for_function("() => document.querySelector('#status').textContent === '已加载'")
        expected += "文\nfinal 中文"
        self.assertEqual(self.page.locator(".reader-text").text_content(), expected)
        self.page.locator("#full-search-input").fill("中文")
        self.page.wait_for_function("() => document.querySelectorAll('#full-search-results .full-search-result').length === 2")
        self.assertEqual(self.page.locator("#full-search-results .full-search-result").count(), 2)
        self.assertEqual(self.page.locator(".reader-text mark.full-search-highlight").all_text_contents(), ["中文", "中文"])
        self.page.locator("#full-search-clear").click()
        self.assertEqual(self.page.locator(".reader-text").text_content(), expected)
        self.assertEqual(self.page.locator(".full-search-highlight").count(), 0)
        self.assertEqual(self.page.locator("#full-search-results .full-search-result").count(), 0)

    def test_text_reader_uses_scroll_mode_without_pagination_controls(self):
        text = "\n\n".join(f"第 {index} 段内容。" * 120 for index in range(8))
        self.page.route("**/api/reader-content**", lambda route: route.fulfill(status=200, content_type="text/plain", body=text.encode()))
        source = "https://huggingface.co/datasets/VoiceOfML/Test/resolve/main/scroll.txt"
        self.page.goto(f"{self.origin}/static/reader.html?url={urllib.parse.quote(source, safe='')}&ext=txt&title=Scroll", wait_until="domcontentloaded")
        self.page.locator(".reader-text").wait_for()
        self.assertEqual(self.page.locator("#reading-mode").count(), 0)
        self.assertTrue(self.page.locator(".page-controls").is_hidden())
        self.assertFalse(self.page.locator(".reader-viewport").evaluate("element => element.classList.contains('is-paginated')"))
        self.page.locator("#viewport").evaluate("element => { element.scrollTop = element.scrollHeight; element.dispatchEvent(new Event('scroll')); }")
        self.assertGreater(self.page.locator("#viewport").evaluate("element => element.scrollTop"), 0)

    def test_reader_tab_is_hidden_for_document_without_toc(self):
        self.page.route("**/api/reader-content**", lambda route: route.fulfill(status=200, content_type="text/plain", body=b"No table of contents"))
        source = "https://huggingface.co/datasets/VoiceOfML/Test/resolve/main/no-toc.txt"
        self.page.goto(f"{self.origin}/static/reader.html?url={urllib.parse.quote(source, safe='')}&ext=txt&title=NoToc", wait_until="domcontentloaded")
        self.page.locator(".reader-text").wait_for()
        self.page.locator("#history").click()
        self.assertTrue(self.page.locator("#toc-tab").is_hidden())

    def test_txt_detects_legacy_encodings_and_multibyte_sample_boundary(self):
        cases = [
            (list("中文文本".encode("gb18030")), "Encoding", "中文文本"),
            (list("中文文本".encode("utf-16")), "Encoding", "中文文本"),
            (list("AB中文".encode("utf-16le")), "Encoding", "AB中文"),
            (list("Русский текст".encode("cp1251")), "Русский", "Русский текст"),
            (list(b"A" * 65535 + "中文".encode("gb18030")), "中文", "A" * 65535 + "中文"),
            (list("中文".encode("gb18030") + b"\xff" + "文本".encode("gb18030")), "中文", "中文文本"),
        ]
        for encoded, title, expected in cases:
            with self.subTest(title=title, size=len(encoded)):
                context = self.browser.new_context(viewport={"width": 1440, "height": 900})
                page = context.new_page()
                page.route("**/static/reader-store.js", lambda route: route.fulfill(status=200, content_type="text/javascript", body=STORE_SCRIPT))
                page.add_init_script("""
                window.__txtBytes = new Uint8Array(%s);
                const nativeFetch = window.fetch.bind(window);
                window.fetch = (input, init) => {
                  const url = String(input && input.url || input);
                  if (!url.includes('/api/reader-content?url=')) return nativeFetch(input, init);
                  return Promise.resolve(new Response(window.__txtBytes, { status: 200 }));
                };
                """ % json.dumps(encoded))
                source = "https://huggingface.co/datasets/VoiceOfML/Test/resolve/main/encoding.txt"
                page.goto(f"{self.origin}/static/reader.html?url={urllib.parse.quote(source, safe='')}&ext=txt&title={urllib.parse.quote(title)}", wait_until="domcontentloaded")
                page.wait_for_function("() => document.querySelector('#status').textContent === '已加载'")
                self.assertEqual(page.locator(".reader-text").text_content(), expected)
                context.close()

    def test_markdown_extension_aliases_render_content(self):
        for extension in ("md", "markdown"):
            with self.subTest(extension=extension):
                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.*.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")
                page.wait_for_function("() => document.querySelector('#status').textContent === '已加载'")
                self.assertIn("Markdown readable", page.locator(".reader-markdown").inner_text())
                context.close()

    def test_html_aliases_render_safely_with_visible_text(self):
        document = b'<style>body{background:#fff;color:#fff}</style><p id="visible">HTML readable</p><script>parent.__unsafe=true</script><iframe src="https://evil.test/frame"></iframe><img src="https://evil.test/image.png">'
        for extension in ("html", "htm"):
            with self.subTest(extension=extension):
                context = self.browser.new_context(viewport={"width": 390, "height": 844}, color_scheme="dark")
                page = context.new_page(); external = []
                page.on("request", lambda request: external.append(request.url) if "evil.test" in request.url else None)
                page.route("**/api/reader-content**", lambda route: route.fulfill(status=200, content_type="text/html", body=document))
                source = f"https://huggingface.co/datasets/VoiceOfML/Test/resolve/main/page.{extension}"
                page.goto(f"{self.origin}/static/reader.html?url={urllib.parse.quote(source, safe='')}&ext={extension}&title=HTML", wait_until="domcontentloaded")
                page.wait_for_function("() => document.querySelector('#status').textContent === 'HTML'")
                frame = page.locator("iframe.html-frame").content_frame
                self.assertEqual(frame.locator("#visible").text_content(), "HTML readable")
                self.assertEqual(frame.locator("script, iframe").count(), 0)
                self.assertFalse(page.evaluate("window.__unsafe === true"))
                self.assertEqual(external, [])
                self.assertNotEqual(frame.locator("#visible").evaluate("e => getComputedStyle(e).color"), "rgb(255, 255, 255)")
                context.close()

    def test_image_aliases_decode_real_image_bytes(self):
        for extension, (content_type, document) in IMAGE_FIXTURES.items():
            with self.subTest(extension=extension):
                context = self.browser.new_context(viewport={"width": 390, "height": 844})
                page = context.new_page()
                def serve_image(route, _request, mime=content_type, body=document):
                    route.fulfill(status=200, content_type=mime, body=body)
                page.route("**/api/reader-content**", serve_image)
                source = f"https://huggingface.co/datasets/VoiceOfML/Test/resolve/main/image.{extension}"
                page.goto(f"{self.origin}/static/reader.html?url={urllib.parse.quote(source, safe='')}&ext={extension}&title=Image", wait_until="domcontentloaded")
                page.wait_for_function("() => document.querySelector('#status').textContent === '图片'")
                self.assertTrue(page.locator(".reader-image").evaluate("image => image.complete && image.naturalWidth === 1 && image.naturalHeight === 1"))
                context.close()

    def test_native_media_uses_proxy_controls_and_mobile_layout(self):
        context = self.browser.new_context(viewport={"width": 390, "height": 844})
        page = context.new_page()
        requests = []
        page.route("**/api/reader-content**", lambda route: (
            requests.append(route.request.url),
            route.fulfill(status=200, content_type="audio/wav", body=minimal_wav()),
        ))
        source = "https://huggingface.co/datasets/VoiceOfML/Test/resolve/main/sound.wav"
        page.goto(f"{self.origin}/static/reader.html?url={urllib.parse.quote(source, safe='')}&ext=wav&title=Sound", wait_until="domcontentloaded")
        page.wait_for_function("() => document.querySelector('audio')?.readyState >= 1")
        audio = page.locator(".reader-audio")
        self.assertTrue(audio.evaluate("element => element.controls"))
        self.assertEqual(audio.get_attribute("preload"), "metadata")
        self.assertIn("/api/reader-content?url=", audio.get_attribute("src"))
        self.assertTrue(page.locator(".zoom-controls").is_hidden())
        page.locator("#history").click()
        self.assertTrue(page.locator("#media-tab").is_visible())
        self.assertEqual(page.locator('.reader-panel-tabs button[aria-selected="true"]').get_attribute("data-panel"), "media")
        page.locator(".media-panel-bookmark").click()
        self.assertIn("时间", page.locator("#bookmark-prompt").text_content())
        page.locator("#bookmark-add").click()
        page.locator("#bookmarks-tab").click()
        page.locator("#bookmarks-list .panel-item-main").wait_for()
        self.assertIn("时间", page.locator("#bookmarks-list").text_content())
        self.assertTrue(requests)
        context.close()

    def test_audio_extension_aliases_use_native_reader_controls(self):
        for extension in ("mp3", "m4a", "flac", "mpga", "audio"):
            with self.subTest(extension=extension):
                context = self.browser.new_context(viewport={"width": 390, "height": 844})
                page = context.new_page()
                page.route("**/api/reader-content**", lambda route: route.fulfill(status=200, content_type="audio/wav", body=minimal_wav()))
                source = f"https://huggingface.co/datasets/VoiceOfML/Test/resolve/main/alias.{extension}"
                page.goto(f"{self.origin}/static/reader.html?url={urllib.parse.quote(source, safe='')}&ext={extension}&title=Audio", wait_until="domcontentloaded")
                page.wait_for_function("() => document.querySelector('#status').textContent === '音频'")
                audio = page.locator(".reader-audio")
                self.assertTrue(audio.evaluate("element => element.controls"))
                self.assertEqual(page.locator(".reader-content").get_attribute("data-mode"), "audio")
                self.assertTrue(page.locator(".zoom-controls").is_hidden())
                self.assertTrue(page.locator("#bookmark-ribbon").is_visible())
                context.close()

    def test_supported_formats_start_loading_while_history_restores(self):
        cases = [
            ("md", "已加载", ".reader-markdown", ["content", "marked", "purify"]),
            ("docx", "DOCX", ".docx-body", ["content", "jszip", "docx"]),
            ("png", "图片", ".reader-image", ["content"]),
        ]
        elapsed_by_format = {}
        for extension, ready_status, selector, expected_requests in cases:
            with self.subTest(extension=extension):
                context = self.browser.new_context(viewport={"width": 1440, "height": 900})
                page = context.new_page()
                requested_at = {}

                def timed(name, content_type, body):
                    def fulfill(route):
                        requested_at[name] = page.evaluate("performance.now()")
                        page.evaluate("name => (window.__formatRequests ||= []).push(name)", name)
                        route.fulfill(status=200, content_type=content_type, body=body)
                    return fulfill

                pending_store = STORE_SCRIPT.replace(
                    "get: () => new Promise((resolve) => setTimeout(() => resolve(null), 300))",
                    "get: () => new Promise((resolve) => { window.__releaseHistory = () => { window.__historyResolved = true; resolve(null); }; })",
                )
                page.route("**/static/reader-store.js", lambda route: route.fulfill(status=200, content_type="text/javascript", body=pending_store))
                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.*.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))
                if extension == "docx":
                    digest = "a" * 64
                    source = f"https://huggingface.co/datasets/vomebook/Reader-Assets/resolve/main/objects/aa/{digest}/docx-native-v1/document.docx"
                else:
                    source = f"https://huggingface.co/datasets/VoiceOfML/Test/resolve/main/performance.{extension}"
                if extension == "png":
                    page.route(source, timed("content", content_type, body))
                started = time.perf_counter()
                page.goto(
                    f"{self.origin}/static/reader.html?url={urllib.parse.quote(source, safe='')}&ext={extension}&title=Performance",
                    wait_until="domcontentloaded",
                )
                page.wait_for_function("expected => expected.every(name => window.__formatRequests?.includes(name))", arg=expected_requests)
                self.assertFalse(page.evaluate("window.__historyResolved === true"))
                page.evaluate("window.__releaseHistory()")
                page.wait_for_function(
                    "expected => document.querySelector('#status').textContent === expected",
                    arg=ready_status,
                )
                page.locator(selector).wait_for(state="attached")
                elapsed_by_format[extension] = (time.perf_counter() - started) * 1000
                store_started = page.evaluate("window.__storeStartedAt")
                self.assertEqual(set(requested_at), set(expected_requests))
                self.assertTrue(all(requested_at[name] >= store_started for name in expected_requests))
                context.close()
        print("\n  Reader format load times: " + ", ".join(
            f"{name}={elapsed_by_format[name]:.1f}ms" for name in sorted(elapsed_by_format)
        ))

    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", [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 = []
        for extension, document, content_type, ready_status, selector, engines in cases:
            with self.subTest(extension=extension):
                context = self.browser.new_context(viewport={"width": 1440, "height": 900}, service_workers="block")
                try:
                    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)

                    page.route("**/api/reader-content**", serve_document)
                    if extension == "docx":
                        digest = "a" * 64
                        source = f"https://huggingface.co/datasets/vomebook/Reader-Assets/resolve/main/objects/aa/{digest}/docx-native-v1/document.docx"
                    else:
                        source = f"https://huggingface.co/datasets/VoiceOfML/Test/resolve/main/cold.{extension}"
                    if extension == "png": page.route(source, serve_document)
                    started = time.perf_counter()
                    page.goto(f"{self.origin}/static/reader.html?url={urllib.parse.quote(source, safe='')}&ext={extension}&title=Cold", wait_until="domcontentloaded")
                    page.wait_for_function("expected => document.querySelector('#status').textContent === expected", arg=ready_status, timeout=30000)
                    page.locator(selector).wait_for(state="attached", timeout=30000)
                    if extension == "docx":
                        self.assertTrue(page.locator(".page-controls").is_visible())
                        self.assertEqual(page.locator(".reader-docx-page").count(), 1)
                    elapsed = (time.perf_counter() - started) * 1000
                    urls = [urllib.parse.urlsplit(response.url).path.rsplit("/", 1)[-1] for response in responses]
                    for engine in engines: self.assertIn(engine, urls)
                    for response in responses: self.assertFalse(response.from_service_worker)
                    entries = page.evaluate("""() => performance.getEntriesByType('resource').map((entry) => ({ name: entry.name, transferSize: entry.transferSize }))""")
                    for engine in engines:
                        if ".worker." in engine: continue
                        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
                        if (ROOT / "static/vendor" / engine).exists() else 0
                        for engine in engines
                    )
                    results.append((extension, elapsed, byte_count, len(responses)))
                finally:
                    context.close()
        print("\n  Reader cold-cache first read (real engines):")
        for extension, elapsed, byte_count, request_count in results:
            print(f"    {extension:<5s} {elapsed:>7.1f}ms  {byte_count / 1024:>8.1f}KiB  {request_count:>2d} responses")

    def test_image_proxy_failure_falls_back_to_direct_source(self):
        source = "https://huggingface.co/datasets/VoiceOfML/Test/resolve/main/fallback.png"
        requests = []
        self.page.route(source, lambda route: (requests.append("source"), route.fulfill(status=200, content_type="image/png", body=PNG_BYTES)))
        self.page.route(
            "**/api/reader-content**",
            lambda route: (requests.append("proxy"), route.fulfill(status=404, body=b"")),
        )
        self.page.goto(
            f"{self.origin}/static/reader.html?url={urllib.parse.quote(source, safe='')}&ext=png&title=Fallback",
            wait_until="domcontentloaded",
        )
        self.page.wait_for_function("() => document.querySelector('#status').textContent === '图片'")
        self.assertEqual(requests, ["proxy", "source"])

    def scroll_document(self):
        pages = self.page.locator(".reader-page")
        for index in range(30):
            pages.nth(index).scroll_into_view_if_needed()
            self.page.wait_for_timeout(20)
        self.page.wait_for_timeout(100)
        return self.page.locator("body").evaluate("""() => ({
          peak: window.__pdfPeak,
          rendered: document.querySelectorAll('.reader-page[data-render-state="rendered"]').length,
          pixels: [...document.querySelectorAll('.reader-page canvas')].reduce((sum, canvas) => sum + canvas.width * canvas.height, 0),
        })""")


def load_tests(_loader, _tests, _pattern):
    return unittest.TestSuite()


if __name__ == "__main__":
    unittest.main()