refactor: organize project layout and Reader responsibilities

.prettierrc.json

@@ -3,7 +3,8 @@
     {
       "files": [
         "static/reader*.{js,css,html}",
-        "scripts/check_reader_release.mjs"
+        "static/reader/**/*.mjs",
+        "scripts/build/check_reader_release.mjs"
       ],
       "options": { "printWidth": 100, "trailingComma": "none" }
     }

Dockerfile

@@ -11,10 +11,10 @@ RUN npm install --global "esbuild@${ESBUILD_VERSION}" \
     && test "$(esbuild --version)" = "${ESBUILD_VERSION}"
 
 COPY static/ /build/static/
-COPY scripts/build_static_assets.mjs /build/build_static_assets.mjs
-COPY scripts/copy_reader_vendor.mjs /build/copy_reader_vendor.mjs
-COPY scripts/check_reader_release.mjs /build/check_reader_release.mjs
-COPY scripts/compose_app.mjs /build/compose_app.mjs
+COPY scripts/build/build_static_assets.mjs /build/build_static_assets.mjs
+COPY scripts/build/copy_reader_vendor.mjs /build/copy_reader_vendor.mjs
+COPY scripts/build/check_reader_release.mjs /build/check_reader_release.mjs
+COPY scripts/build/compose_app.mjs /build/compose_app.mjs
 
 RUN mkdir -p /out \
     && cp -a static/. /out/ \
@@ -22,7 +22,8 @@ RUN mkdir -p /out \
     && node /build/compose_app.mjs > /build/app-composed.js \
     && esbuild /build/app-composed.js --minify --target=es2020 --charset=utf8 --legal-comments=none --outfile=/out/app.js \
     && for file in $(node -e 'console.log(require("./static/reader-resources.js").buildFiles("hf").filter(f => f !== "app.js").join(" "))'); do \
-         esbuild "static/$file" --minify --target=es2020 --charset=utf8 --legal-comments=none --outfile="/out/$file" || exit 1; \
+         flags=$(node -e 'console.log(require("./static/reader-resources.js").bundleArguments(process.argv[1]).join(" "))' "$file"); \
+         esbuild "static/$file" $flags --minify --target=es2020 --charset=utf8 --legal-comments=none --outfile="/out/$file" || exit 1; \
        done \
     && node /build/build_static_assets.mjs \
     && esbuild /out/sw.js --minify --target=es2019 --charset=utf8 --legal-comments=none --outfile=/out/sw.min.js \
@@ -34,9 +35,9 @@ FROM python:3.11.17-slim AS search-index-build
 WORKDIR /build
 RUN apt-get update && apt-get install -y --no-install-recommends gcc libc6-dev \
     && rm -rf /var/lib/apt/lists/*
-COPY search_index_native.c .
-COPY scripts/build_search_index_native.py scripts/build_search_index_native.py
-RUN python scripts/build_search_index_native.py --output-dir /native
+COPY backend/native/search_index_native.c backend/native/search_index_native.c
+COPY scripts/build/build_search_index_native.py scripts/build/build_search_index_native.py
+RUN python scripts/build/build_search_index_native.py --output-dir /native
 
 FROM python:3.11.17-slim
 
@@ -49,7 +50,8 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
 COPY requirements.txt .
 RUN pip install --no-cache-dir -r requirements.txt
 
-COPY app.py data_formats.py proxy_streams.py record_metadata.py upstream_http.py search_execution.py search_indexes.py reader_assets.py reader_v3_catalog.py .
+COPY app.py .
+COPY backend/ backend/
 COPY --from=search-index-build /native/ /app/
 COPY --from=static-assets /out/ static/
 COPY data/ data/

backend/__init__.py

@@ -0,0 +1 @@
+"""Search service helpers; the FastAPI entry point remains app:app."""

reader_assets.py → backend/reader_assets.py

@@ -6,7 +6,7 @@ import json
 import posixpath
 import re
 
-from upstream_http import READER_ASSET_PATH_RE
+from backend.upstream_http import READER_ASSET_PATH_RE
 
 
 READER_ASSET_FILENAMES = {

reader_v3_catalog.py → backend/reader_v3_catalog.py

@@ -22,7 +22,7 @@ def catalog_path(generation):
 
 
 def decode_catalog(pointer, raw):
-    from reader_assets import READER_BUCKET_PATH_RE
+    from backend.reader_assets import READER_BUCKET_PATH_RE
     if pointer.get("version") != 1 or pointer.get("kind") != "reader-reading-pointer":
         raise ValueError("invalid v3 pointer")
     generation = pointer.get("generation")

scripts/{build_search_index_native.py → build/build_search_index_native.py}

@@ -11,7 +11,7 @@ parser.add_argument("--output-dir", required=True)
 args = parser.parse_args()
 output = Path(args.output_dir)
 output.mkdir(parents=True, exist_ok=True)
-source = Path(__file__).resolve().parents[1] / "search_index_native.c"
+source = Path(__file__).resolve().parents[2] / "backend/native/search_index_native.c"
 target = output / ("_search_index_native" + sysconfig.get_config_var("EXT_SUFFIX"))
 compiler = shlex.split(os.environ.get("CC") or sysconfig.get_config_var("CC") or "cc")
 subprocess.run([*compiler, "-O3", "-shared", "-fPIC", "-Wall", "-Wextra",

scripts/{build_static_assets.mjs → build/build_static_assets.mjs}

@@ -1,6 +1,6 @@
 import { createHash } from "node:crypto";
 import { renameSync, readFileSync, writeFileSync } from "node:fs";
-import { extname, join } from "node:path";
+import { dirname, extname, join, relative } from "node:path";
 import { createRequire } from "node:module";
 import { stripBundledScripts } from "./compose_app.mjs";
 const resources = createRequire(import.meta.url)(join(process.cwd(), "static/reader-resources.js"));
@@ -8,7 +8,15 @@ const resources = createRequire(import.meta.url)(join(process.cwd(), "static/rea
 const outputDir = process.env.STATIC_OUTPUT_DIR || "/out";
 const replacements = new Map();
 const currentVendorAssets = new Set(Object.values(resources.vendors).map(vendor => "/static/" + vendor.path));
-function rewrite(text) {
+function rewrite(text, filename) {
+  text = text.replace(/(["'])(\.\.?\/[^"'\s]+)\1/g, (match, quote, url) => {
+    const target = join(dirname(filename), url);
+    const versioned = replacements.get(`/static/${target}`);
+    if (!versioned) return match;
+    let pinned = relative(dirname(filename), versioned.slice("/static/".length));
+    if (!pinned.startsWith(".")) pinned = "./" + pinned;
+    return quote + pinned + quote;
+  });
   text = text.replace(/VoiceOfMLReaderResources\.engineAssets\(([\w$]+),\s*"(\/static\/)"\)/g,
     (_, extension, base) => "(" + JSON.stringify(Object.fromEntries(["pdf", "epub", "mobi", "azw", "azw3", "fb2", "fbz", "docx", "md", "markdown", "html", "htm"].map(ext => [ext, resources.engineAssets(ext, base)]))) + `[${extension}]||[])`);
   text = text.replace(/VoiceOfMLReaderResources\.(shellAssets|runtimePaths)\("(\/static\/)"\)/g,
@@ -23,7 +31,7 @@ for (const filename of resources.buildFiles("hf")) {
     let text = readFileSync(source, "utf8");
     for (const match of text.matchAll(/(?:\/static\/|\.\/)vendor\/([A-Za-z0-9._-]+\.[0-9a-f]{12}\.(?:js|mjs|css))/g))
       currentVendorAssets.add("/static/vendor/" + match[1]);
-    text = rewrite(text);
+    text = rewrite(text, filename);
     writeFileSync(source, text);
   }
   const content = readFileSync(source);
@@ -40,7 +48,7 @@ for (const filename of ["index.html", "reader.html", "sw.js"]) {
   const path = join(outputDir, filename);
   let content = readFileSync(path, "utf8");
   if (filename === "index.html") content = stripBundledScripts(content);
-  content = rewrite(content);
+  content = rewrite(content, filename);
   if (filename === "sw.js") content = content.replace(/CURRENT_HASHED_ASSETS\s*=\s*\[\]/,
     "CURRENT_HASHED_ASSETS=" + JSON.stringify([...replacements.values()].filter(url => url.startsWith("/")).concat([...currentVendorAssets])));
   writeFileSync(path, content);

scripts/{check_reader_release.mjs → build/check_reader_release.mjs}

@@ -39,10 +39,11 @@ function staticRoot(root, artifact) {
 }
 
 function checkBehavior(root) {
-  const reader = fs.readFileSync(path.join(root, "static/reader.js"), "utf8");
-  for (const [, dependency] of reader.matchAll(/(?:\/static\/)([^/"']+\.(?:js|mjs))/g)) {
+  const reader = ["reader.js", ...resources.readerComponentFiles].map(file =>
+    fs.readFileSync(path.join(root, "static", file), "utf8")).join("\n").replace(/\breaderContext\./g, "");
+  for (const [, dependency] of reader.matchAll(/(?:\/static\/)([^"'\s]+\.(?:js|mjs))/g)) {
     assert(
-      resources.readerFiles.includes(dependency),
+      required.includes(dependency),
       `Reader dependency missing from inventory: ${dependency}`
     );
   }
@@ -118,11 +119,12 @@ function checkAssets(output, hashed = false) {
 function currentAsset(output, filename) {
   if (!resources.buildFiles("github").includes(filename)) return filename;
   assert(!fs.existsSync(path.join(output, filename)), `obsolete asset alias: ${filename}`);
-  const extension = path.extname(filename), stem = filename.slice(0, -extension.length);
-  const matches = fs.readdirSync(output).filter(file => file.startsWith(stem + ".") &&
+  const directory = path.dirname(filename), basename = path.basename(filename);
+  const extension = path.extname(basename), stem = basename.slice(0, -extension.length);
+  const matches = fs.readdirSync(path.join(output, directory)).filter(file => file.startsWith(stem + ".") &&
     file.endsWith(extension) && /^[0-9a-f]{12}$/.test(file.slice(stem.length + 1, -extension.length)));
   assert(matches.length === 1, `expected one current asset: ${filename}`);
-  return matches[0];
+  return path.join(directory, matches[0]);
 }
 
 function checkProject(root, artifact) {
@@ -138,7 +140,7 @@ function checkProject(root, artifact) {
   const output = staticRoot(root, artifact);
   checkAssets(output, !!artifact);
   if (artifact) {
-    const project = fs.existsSync(path.join(root, "index.html")) ? "github" : "hf";
+    const project = args.project || (fs.existsSync(path.join(root, "Dockerfile")) ? "hf" : "github");
     for (const file of resources.buildFiles(project)) currentAsset(output, file);
     const shellPath = fs.existsSync(path.join(output, "index.html"))
       ? path.join(output, "index.html") : path.join(output, "../index.html");
@@ -167,24 +169,30 @@ function checkProject(root, artifact) {
 function crossCheck(githubRoot, hfRoot) {
   const exact = [
     "reader-resources.js",
-    "reader-store.js",
-    "reader-pdf-text.js",
-    "reader-pdf-book-search-worker.mjs",
-    "reader-pdf-book-search.mjs",
-    "search-session.js",
-    "download-controller.js",
-    "reader-navigation.js",
+    "reader/core/reader-store.js",
+    "reader/pdf/reader-pdf-text.js",
+    "reader/search/workers/reader-pdf-book-search-worker.mjs",
+    "reader/search/reader-pdf-book-search.mjs",
+    "search/search-session.js",
+    "search/download-controller.js",
+    "search/reader-navigation.js",
     "reader.css",
-    "reader-request-manager.js",
-    "reader-chapter-repository.js",
-    "reader-scroll-anchor.js",
-    "reader-section-virtualizer.js",
-    "reader-runtime.js",
-    "reader-format-adapters.js",
-    "reader-security.js",
-    "reader-search-controller.mjs",
-    "reader-dom-search.mjs",
-    "pdf-worker-wrapper.mjs"
+    "reader/core/reader-request-manager.js",
+    "reader/formats/reader-chapter-repository.js",
+    "reader/ui/reader-scroll-anchor.js",
+    "reader/formats/reader-section-virtualizer.js",
+    "reader/core/reader-runtime.js",
+    "reader/formats/reader-format-adapters.js",
+    "reader/core/reader-security.js",
+    "reader/search/reader-search-controller.mjs",
+    "reader/search/reader-dom-search.mjs",
+    "reader/formats/reader-image-loader.mjs",
+    "reader/reader-components.mjs",
+    "reader/ui/reader-document-styles.mjs",
+    "reader/core/reader-diagnostics.mjs", "reader/core/reader-lifecycle.mjs", "reader/ui/reader-bookmarks.mjs",
+    "reader/formats/reader-media-format.mjs", "reader/core/reader-document-loader.mjs", "reader/formats/reader-html-format.mjs",
+    "reader/formats/reader-text-format.mjs", "reader/formats/reader-chapter-format.mjs", "reader/formats/reader-docx-format.mjs",
+    "reader/pdf/pdf-worker-wrapper.mjs"
   ];
   for (const file of exact) {
     assert(
@@ -194,8 +202,8 @@ function crossCheck(githubRoot, hfRoot) {
   }
   for (const file of ["compose_app.mjs", "copy_reader_vendor.mjs", "check_reader_release.mjs"]) {
     assert(
-      hash(path.join(githubRoot, "scripts", file)) === hash(path.join(hfRoot, "scripts", file)),
-      `cross-project drift: scripts/${file}`
+      hash(path.join(githubRoot, "scripts/build", file)) === hash(path.join(hfRoot, "scripts/build", file)),
+      `cross-project drift: scripts/build/${file}`
     );
   }
   for (const root of [githubRoot, hfRoot]) checkBehavior(root);

scripts/{compose_app.mjs → build/compose_app.mjs}

@@ -5,12 +5,12 @@ import { pathToFileURL } from "node:url";
 // One ordered dependency list owns the production app and its shell scripts.
 // Keep classic-script globals for the host; each dependency owns its own scope.
 export const APP_DEPENDENCIES = Object.freeze([
-  "reader-resources.js", "reader-contract.js", "reader-navigation.js",
-  "search-session.js", "download-controller.js"
+  "reader-resources.js", "reader/core/reader-contract.js", "search/reader-navigation.js",
+  "search/search-session.js", "search/download-controller.js"
 ]);
 
 export function stripBundledScripts(html) {
-  return html.replace(/<script\s+src="(?:\/?(?:search\/)?static\/)([^"/]+)"\s*>\s*<\/script>\s*/g,
+  return html.replace(/<script\s+src="(?:\/?(?:search\/)?static\/)([^"\s]+)"\s*>\s*<\/script>\s*/g,
     (tag, filename) => APP_DEPENDENCIES.includes(filename) ? "" : tag);
 }
 

static/index.html

@@ -287,10 +287,10 @@ if ("serviceWorker" in navigator) {
 </script>
 
 <script src="/static/reader-resources.js"></script>
-<script src="/static/reader-contract.js"></script>
-<script src="/static/reader-navigation.js"></script>
-<script src="/static/search-session.js"></script>
-<script src="/static/download-controller.js"></script>
+<script src="/static/reader/core/reader-contract.js"></script>
+<script src="/static/search/reader-navigation.js"></script>
+<script src="/static/search/search-session.js"></script>
+<script src="/static/search/download-controller.js"></script>
 <script src="/static/app.js"></script>
 </body>
 </html>

static/reader-resources.js

@@ -85,41 +85,55 @@
     }
   };
   for (const vendor of Object.values(foliateVendors)) Object.freeze(vendor);
+  const readerComponentFiles = Object.freeze([
+    "reader/core/reader-diagnostics.mjs", "reader/core/reader-lifecycle.mjs", "reader/core/reader-source.mjs", "reader/ui/reader-ui.mjs",
+    "reader/ui/reader-toc.mjs", "reader/search/reader-search-backends.mjs", "reader/pdf/reader-pdf-scheduler.mjs", "reader/ui/reader-navigation.mjs",
+    "reader/formats/reader-foliate-format.mjs", "reader/ui/reader-progress.mjs", "reader/ui/reader-bookmarks.mjs", "reader/formats/reader-media-format.mjs",
+    "reader/core/reader-document-loader.mjs", "reader/pdf/reader-pdf-page-window.mjs", "reader/pdf/reader-pdf-text-runtime.mjs",
+    "reader/formats/reader-html-format.mjs", "reader/pdf/reader-pdf-renderer.mjs", "reader/formats/reader-text-format.mjs",
+    "reader/formats/reader-chapter-format.mjs", "reader/formats/reader-docx-format.mjs", "reader/formats/reader-format-controller.mjs",
+    "reader/pdf/reader-pdf-engine.mjs", "reader/pdf/reader-pdf-search.mjs", "reader/core/reader-bindings.mjs", "reader/ui/reader-document-styles.mjs"
+  ]);
   const readerFiles = Object.freeze([
     "reader-resources.js",
-    "reader-engine-preload.js",
-    "reader-chapter-search-worker.mjs",
-    "reader-chapter-search.mjs",
-    "reader-contract.js",
-    "reader-navigation.js",
-    "reader-store.js",
-    "reader-request-manager.js",
-    "reader-chapter-repository.js",
-    "reader-scroll-anchor.js",
-    "reader-section-virtualizer.js",
-    "reader-runtime.js",
-    "reader-format-adapters.js",
-    "reader-security.js",
-    "reader-search-controller.mjs",
-    "reader-dom-search.mjs",
-    "reader-pdf-text.js",
-    "reader-v3.mjs",
-    "reader-book-text.js",
-    "reader-pdf-book-search-worker.mjs",
-    "reader-pdf-book-search.mjs",
-    "pdf-worker-wrapper.mjs",
-    "reader-pdf-network.mjs",
-    "reader-pdf-text-store.mjs",
+    "reader/pdf/reader-engine-preload.js",
+    "reader/search/workers/reader-chapter-search-worker.mjs",
+    "reader/search/reader-chapter-search.mjs",
+    "reader/core/reader-contract.js",
+    "search/reader-navigation.js",
+    "reader/core/reader-store.js",
+    "reader/core/reader-request-manager.js",
+    "reader/formats/reader-chapter-repository.js",
+    "reader/ui/reader-scroll-anchor.js",
+    "reader/formats/reader-section-virtualizer.js",
+    "reader/core/reader-runtime.js",
+    "reader/formats/reader-format-adapters.js",
+    "reader/core/reader-security.js",
+    "reader/search/reader-search-controller.mjs",
+    "reader/search/reader-dom-search.mjs",
+    "reader/formats/reader-image-loader.mjs",
+    "reader/pdf/reader-pdf-text.js",
+    "reader/pdf/reader-v3.mjs",
+    "reader/search/reader-book-text.js",
+    "reader/search/workers/reader-pdf-book-search-worker.mjs",
+    "reader/search/reader-pdf-book-search.mjs",
+    "reader/pdf/pdf-worker-wrapper.mjs",
+    "reader/pdf/reader-pdf-network.mjs",
+    "reader/pdf/reader-pdf-text-store.mjs",
     "reader.css",
+    ...readerComponentFiles,
+    "reader/reader-components.mjs",
     "reader.js"
   ]);
   const lazyFiles = new Set([
-    "reader-pdf-text-store.mjs",
-    "reader-chapter-search-worker.mjs",
-    "reader-chapter-search.mjs",
-    "reader-pdf-book-search-worker.mjs",
-    "reader-pdf-book-search.mjs",
-    "pdf-worker-wrapper.mjs"
+    ...readerComponentFiles,
+    "reader/reader-components.mjs",
+    "reader/pdf/reader-pdf-text-store.mjs",
+    "reader/search/workers/reader-chapter-search-worker.mjs",
+    "reader/search/reader-chapter-search.mjs",
+    "reader/search/workers/reader-pdf-book-search-worker.mjs",
+    "reader/search/reader-pdf-book-search.mjs",
+    "reader/pdf/pdf-worker-wrapper.mjs"
   ]);
   const vendorUrl = (name, base) => base + vendors[name].path;
   const runtimePaths = (base) => readerFiles.map((file) => base + file);
@@ -129,7 +143,7 @@
     if (extension === "pdf")
       return [
         vendorUrl("pdf", base),
-        base + "pdf-worker-wrapper.mjs",
+        base + "reader/pdf/pdf-worker-wrapper.mjs",
         vendorUrl("pdfWorker", base)
       ];
     if (["epub", "mobi", "azw", "azw3", "fb2", "fbz"].includes(extension))
@@ -142,24 +156,33 @@
   function buildFiles(project) {
     return [
       ...readerFiles,
-      "search-session.js",
-      "download-controller.js",
+      "search/search-session.js",
+      "search/download-controller.js",
       "style.css",
-      ...(project === "github" ? ["index-worker.js"] : []),
+      ...(project === "github" ? ["search/index-worker.js"] : []),
       "app.js"
     ];
   }
+  function bundleArguments(filename) {
+    if (!["reader.js", "reader/reader-components.mjs"].includes(filename)) return [];
+    const external = readerFiles.filter(file => !readerComponentFiles.includes(file) &&
+      !["reader.js", "reader/reader-components.mjs"].includes(file) && /\.(?:js|mjs)$/.test(file));
+    return ["--bundle", "--format=esm", "--external:/static/*", "--external:/search/static/*",
+      ...external.map(file => "--external:./" + file)];
+  }
   const resources = Object.freeze({
     vendors: Object.freeze(vendors),
     foliateVendors: Object.freeze(foliateVendors),
     foliateRevision: "78914aef4466eb960965702401634c2cb348e9b1",
     pdfArchive,
     readerFiles,
+    readerComponentFiles,
     vendorUrl,
     runtimePaths,
     shellAssets,
     engineAssets,
-    buildFiles
+    buildFiles,
+    bundleArguments
   });
   if (typeof module !== "undefined" && module.exports) module.exports = resources;
   else root.VoiceOfMLReaderResources = resources;

static/reader.html

@@ -51,11 +51,11 @@
     <link rel="preconnect" href="https://huggingface.co" />
     <link rel="preconnect" href="https://voiceofml-search.hf.space" />
     <link rel="stylesheet" href="/static/reader.css" />
-    <script defer src="/static/reader-security.js"></script>
+    <script defer src="/static/reader/core/reader-security.js"></script>
     <script defer src="/static/reader-resources.js"></script>
-    <script defer src="/static/reader-engine-preload.js"></script>
-    <script defer src="/static/reader-contract.js"></script>
-    <script defer src="/static/reader-store.js"></script>
+    <script defer src="/static/reader/pdf/reader-engine-preload.js"></script>
+    <script defer src="/static/reader/core/reader-contract.js"></script>
+    <script defer src="/static/reader/core/reader-store.js"></script>
   </head>
   <body>
     <header class="reader-toolbar">

static/reader/core/reader-bindings.mjs

@@ -0,0 +1,847 @@
+export function createReaderBindings(readerContext) {
+  function trackStartupOwners() {
+    readerContext.readerRuntime.track(readerContext.readerRequestManager);
+    readerContext.readerRuntime.track(readerContext.formatAdapters);
+    readerContext.readerRuntime.track(window.__VOICE_PDF_PRELOAD__);
+    readerContext.readerRuntime.track(window.__VOICE_READER_CHAPTER_PRELOAD__);
+  }
+
+  function trackWorkCancellation() {
+    readerContext.readerRuntime.track(readerContext.stopReaderWork);
+  }
+
+  function trackEarlySourceResolution() {
+    readerContext.trackReaderResource(() => window.__VOICE_READER_RESOLVE__?.dispose());
+  }
+
+  function publishDiagnosticsAndInstallCompatibility() {
+    window.VoiceOfMLReaderPdfDiagnostics = readerContext.pdfDiagnostics;
+    readerContext.trackReaderResource(() => {
+      readerContext.pdfPageTimings.length = 0;
+      if (window.VoiceOfMLReaderPdfDiagnostics === readerContext.pdfDiagnostics) delete window.VoiceOfMLReaderPdfDiagnostics;
+    });
+
+    // Polyfills for vendor engines (pdf.js, foliate): neither helper has a direct
+    // caller in first-party code, but both are required by pinned vendor bundles.
+    if (!Map.prototype.getOrInsertComputed) {
+      Map.prototype.getOrInsertComputed = function (key, callback) {
+        if (this.has(key)) return this.get(key);
+        const value = callback(key);
+        this.set(key, value);
+        return value;
+      };
+    }
+    if (!Math.sumPrecise) {
+      Math.sumPrecise = function (values) {
+        let sum = 0;
+        let correction = 0;
+        for (const value of values) {
+          const next = sum + value;
+          correction += Math.abs(sum) >= Math.abs(value) ? sum - next + value : value - next + sum;
+          sum = next;
+        }
+        return sum + correction;
+      };
+    }
+  }
+
+  function readSelectedSourceSession() {
+    try {
+      readerContext.localReaderData = JSON.parse(sessionStorage.getItem(`reader-source:${readerContext.readerId}`) || "null");
+      if (readerContext.localReaderData) sessionStorage.removeItem(`reader-source:${readerContext.readerId}`);
+    } catch (_) {}
+  }
+
+  function normalizeConvertedPdfMode() {
+    if (
+      readerContext.extension === "pdf" &&
+      /\/api\/reader-bucket-resource\?/.test(readerContext.sourceUrl) &&
+      new URL(readerContext.sourceUrl, location.href).searchParams.get("path")?.endsWith("page-manifest.json")
+    ) {
+      readerContext.extension = "pdf-pages";
+      readerContext.capability = readerContext.readerRuntime.negotiate(VoiceOfMLReader.capability(readerContext.extension));
+    }
+  }
+
+  function applySourceSessionAndCachedMetadata() {
+    if (readerContext.localReaderData) {
+      if (readerContext.localReaderData.title) readerContext.params.set("title", readerContext.localReaderData.title);
+      if (readerContext.localReaderData.extension) readerContext.params.set("ext", readerContext.localReaderData.extension);
+      if (readerContext.localReaderData.repo)
+        readerContext.params.set("path", [readerContext.localReaderData.repo, ...(readerContext.localReaderData.folder || [])].join("/"));
+    }
+    try {
+      const cached = sessionStorage.getItem(`reader-resolve:${readerContext.readerId}`);
+      if (cached) {
+        readerContext.cachedReaderData = JSON.parse(cached);
+        readerContext.resolvedReaderData = readerContext.cachedReaderData;
+        sessionStorage.removeItem(`reader-resolve:${readerContext.readerId}`);
+      }
+    } catch (_) {}
+  }
+
+  function publishSourceAndSubscribeToStore() {
+    readerContext.readerRuntime.update("source", {
+      id: readerContext.readerId,
+      url: readerContext.sourceUrl,
+      contentUrl: readerContext.contentUrl,
+      downloadUrl: readerContext.downloadUrl,
+      extension: readerContext.extension,
+      metadata: readerContext.resolvedReaderData
+    });
+    readerContext.readerRuntime.events.on("phase", ({ phase }) => {
+      document.documentElement.dataset.readerPhase = phase;
+    });
+    readerContext.readerRuntime.track(
+      VoiceOfMLReaderStore.subscribe?.((change) => {
+        if (!change?.remote || readerContext.readerLifecycle.disposed) return;
+        if (
+          change.type === "history-clear" ||
+          (change.type === "history-remove" && change.url === readerContext.sourceUrl)
+        ) {
+          readerContext.historySuppressed = true;
+          readerContext.readerRuntime.cancel(readerContext.saveTimer);
+          readerContext.saveTimer = readerContext.saveDeadline = 0;
+        }
+        if (
+          ["history", "history-clear", "history-remove"].includes(change.type) &&
+          !document.querySelector("#history-panel").hidden
+        )
+          readerContext.renderHistory();
+        if (
+          ["bookmark", "bookmark-remove"].includes(change.type) &&
+          (readerContext.panelState.showingAllBookmarks || !change.url || change.url === readerContext.sourceUrl) &&
+          !document.querySelector("#bookmarks-panel").hidden
+        )
+          readerContext.renderBookmarks();
+      })
+    );
+
+    readerContext.setReaderPhase("startup");
+    window.fetchFile = async (url) => {
+      const requestUrl = String(url) === readerContext.sourceUrl ? readerContext.contentUrl : url;
+      const response = await readerContext.readerRequestManager.request(requestUrl, readerContext.READER_PROXY_TIMEOUT_MS);
+      if (!response.ok) throw new Error(`${response.status} ${response.statusText}`);
+      const fileName = new URL(url, location.href).pathname.split("/").pop() || "book";
+      return new File(
+        [
+          await VoiceOfMLReaderSecurity.readBytes(
+            response,
+            VoiceOfMLReaderSecurity.LIMITS.archiveCompressedBytes
+          )
+        ],
+        fileName,
+        { type: response.headers.get("content-type") || "application/octet-stream" }
+      );
+    };
+  }
+
+  function initializePanelAccessibility() {
+    document.querySelector(".reader-panel-tabs")?.setAttribute("role", "tablist");
+  }
+
+  function mountInitialLoadingFeedback() {
+    readerContext.loadingIndicator.className = "reader-loading-indicator";
+    readerContext.loadingIndicator.setAttribute("role", "status");
+    readerContext.loadingIndicator.innerHTML =
+      '<span class="reader-loading-spinner" aria-hidden="true"></span><span>正在加载正文...</span>';
+    readerContext.content.appendChild(readerContext.loadingIndicator);
+    readerContext.content.dataset.mode = readerContext.capability.mode || "unsupported";
+  }
+
+  function bindDownloadAction() {
+    readerContext.downloadButton.addEventListener("click", readerContext.startReaderDownload);
+    readerContext.loadingStatus.textContent = "";
+  }
+
+  function initializeDocumentTitle() {
+    readerContext.updateDocumentState({
+      title:
+        String(
+          readerContext.params.get("title") || (readerContext.localReaderData && readerContext.localReaderData.title) || readerContext.sourceName
+        ).trim() || readerContext.sourceName,
+      zoom: Math.min(4, Math.max(0.25, Number(localStorage.getItem("reader-zoom") || 100) / 100))
+    });
+  }
+
+  function restoreReturnNavigation() {
+    try {
+      const state = history.state;
+      const saved = JSON.parse(sessionStorage.getItem("reader-navigation-current") || "null");
+      let stateUrl =
+        state && state.voiceReaderOverlay && state.readerUrl
+          ? new URL(state.readerUrl, location.origin)
+          : null;
+      if (!stateUrl && saved && saved.shareUrl === location.href && saved.readerUrl)
+        stateUrl = new URL(saved.readerUrl, location.origin);
+      const cleanStateUrl = stateUrl && new URL(stateUrl.href);
+      if (cleanStateUrl) {
+        cleanStateUrl.searchParams.delete("return");
+        cleanStateUrl.searchParams.delete("nav");
+      }
+      if (
+        stateUrl &&
+        stateUrl.origin === location.origin &&
+        stateUrl.pathname === "/static/reader.html" &&
+        cleanStateUrl.href === location.href
+      ) {
+        if (!readerContext.returnUrl) readerContext.returnUrl = stateUrl.searchParams.get("return") || "";
+        if (!readerContext.returnNavigationToken) readerContext.returnNavigationToken = stateUrl.searchParams.get("nav") || "";
+        readerContext.returnNeedsReload = true;
+      }
+    } catch (_) {}
+  }
+
+  function validateReturnHistory() {
+    try {
+      const target = new URL(readerContext.returnUrl, location.origin);
+      const storedReturnUrl = readerContext.returnHistoryKey ? sessionStorage.getItem(readerContext.returnHistoryKey) : "";
+      readerContext.canReturnWithHistory = !!readerContext.returnHistoryKey && storedReturnUrl === target.href;
+    } catch (_) {}
+  }
+
+  function ownChapterSearchClient() {
+    readerContext.trackReaderResource(() => {
+      readerContext.chapterSearchClient?.dispose();
+      readerContext.chapterSearchClient = null;
+    });
+  }
+
+  function ownDocxPageNodes() {
+    readerContext.trackReaderResource(() => { readerContext.docxPageNodes = []; });
+  }
+
+  function ownIndependentPdfResources() {
+    readerContext.trackReaderResource(() => {
+      for (const release of [...readerContext.pdfV3BlobReleases]) release();
+      readerContext.pdfV3Repository?.dispose(); readerContext.pdfTextLayerRepository?.dispose();
+    });
+  }
+
+  function ownPdfBookSearchClient() {
+    readerContext.trackReaderResource(() => {
+      readerContext.pdfBookSearchClient?.dispose();
+      readerContext.pdfBookSearchClient = null;
+      clearTimeout(readerContext.pdfBookSearchPrefetchTimer);
+      readerContext.pdfBookSearchPrefetchTimer = 0;
+      readerContext.pdfBookSearchPrefetchPromise = null;
+    });
+  }
+
+  function ownPdfPrefetchAndQueues() {
+    readerContext.trackReaderResource(readerContext.clearPdfManifestPrefetches);
+    readerContext.trackReaderResource(() => {
+      for (const waiter of readerContext.pdfRenderWaiters.splice(0)) waiter.reject(readerContext.readerAbortError());
+      for (const waiter of readerContext.pdfTextWaiters.splice(0)) waiter.reject(readerContext.readerAbortError());
+    });
+  }
+
+  function initializeGenerations() {
+    for (const generationName of ["navigation", "search", "bookmarks", "history", "pdf"])
+      readerContext.nextReaderGeneration(generationName);
+  }
+
+  function labelToolbarControls() {
+    for (const [selector, label] of [
+      ["#back", "返回"],
+      ["#page-prev", "上一页"],
+      ["#page-next", "下一页"],
+      ["#page-number", "页码"],
+      ["#zoom-out", "缩小"],
+      ["#zoom-in", "放大"],
+      ["#zoom", "缩放百分比"],
+      ["#bookmark-ribbon", "添加书签"],
+      ["#history", "阅读选项"]
+    ])
+      document.querySelector(selector)?.setAttribute("aria-label", label);
+  }
+
+  function applyMetadataAndWatchSanitizedContent() {
+    readerContext.applyReaderMetadata(readerContext.resolvedReaderData);
+    readerContext.contentSanitizerObserver = new MutationObserver(() => {
+      const seen = new Set();
+      for (const article of document.querySelectorAll(".foliate-continuous > article[data-section]")) {
+        article.querySelectorAll("style,link[rel=stylesheet]").forEach((node) => node.remove());
+        const index = article.dataset.section;
+        if (seen.has(index)) article.remove();
+        else seen.add(index);
+      }
+    });
+    readerContext.contentSanitizerObserver.observe(readerContext.content, { childList: true, subtree: true });
+    readerContext.bookmarkPopover.className = "bookmark-popover";
+    readerContext.bookmarkPopover.setAttribute("role", "dialog");
+    readerContext.bookmarkPopover.setAttribute("aria-modal", "true");
+    readerContext.bookmarkPopover.setAttribute("aria-labelledby", "bookmark-prompt");
+  }
+
+  function initializeBookmarkEditor() {
+    readerContext.bookmarkLabelInput.id = "bookmark-label";
+    readerContext.bookmarkLabelInput.maxLength = 120;
+    readerContext.bookmarkExcerptInput.id = "bookmark-excerpt-input";
+    readerContext.bookmarkExcerptInput.maxLength = 500;
+    readerContext.bookmarkExcerptInput.rows = 3;
+    readerContext.bookmarkEditFields.className = "bookmark-edit-fields";
+    readerContext.bookmarkEditFields.innerHTML = "<label>标题</label><label>摘要</label>";
+    readerContext.bookmarkEditFields.children[0].appendChild(readerContext.bookmarkLabelInput);
+    readerContext.bookmarkEditFields.children[1].appendChild(readerContext.bookmarkExcerptInput);
+    readerContext.bookmarkPopover.insertBefore(readerContext.bookmarkEditFields, readerContext.bookmarkPopover.querySelector("div"));
+  }
+
+  function initializeBookmarkSearchControls() {
+    if (!document.querySelector("#bookmarks-panel .panel-search-toggle")) {
+      const button = document.createElement("button");
+      button.className = "panel-search-toggle";
+      button.type = "button";
+      document.querySelector("#bookmarks-panel .panel-view-header").appendChild(button);
+    }
+    readerContext.bookmarksAllButton.id = "bookmarks-all";
+    readerContext.bookmarksAllButton.className = "text-action";
+    readerContext.bookmarksAllButton.type = "button";
+    readerContext.bookmarksAllButton.textContent = "全部书签";
+    readerContext.bookmarksAllButton.setAttribute("aria-pressed", "false");
+  }
+
+  function mountBookmarkHeaderActions() {
+    readerContext.bookmarksHeaderActions.append(readerContext.bookmarksAllButton, readerContext.bookmarksSearchButton);
+    readerContext.bookmarksHeader.appendChild(readerContext.bookmarksHeaderActions);
+  }
+
+  function mountMediaPanel() {
+    readerContext.mediaTab.id = "media-tab";
+    readerContext.mediaTab.type = "button";
+    readerContext.mediaTab.role = "tab";
+    readerContext.mediaTab.dataset.panel = "media";
+    readerContext.mediaTab.textContent = "播放";
+    readerContext.mediaTab.hidden = !readerContext.capability.features.media;
+    readerContext.mediaPanel.id = "media-panel";
+    readerContext.mediaPanel.className = "reader-panel-view";
+    readerContext.mediaPanel.dataset.panelView = "media";
+    readerContext.mediaPanel.hidden = true;
+    readerContext.mediaPanel.innerHTML =
+      '<div class="media-panel-content"><strong>播放状态</strong><span class="media-panel-time">尚未播放</span><button class="text-action media-panel-bookmark" type="button">在当前时间添加书签</button></div>';
+    document.querySelector(".reader-panel-tabs").prepend(readerContext.mediaTab);
+    document
+      .querySelector("#history-panel")
+      .insertBefore(readerContext.mediaPanel, document.querySelector("#toc-panel"));
+    readerContext.mediaPanel
+      .querySelector(".media-panel-bookmark")
+      .addEventListener("click", (event) => readerContext.openBookmarkPopover(event.currentTarget));
+    document.querySelector(".page-controls").hidden = !readerContext.capability.features.pagination;
+    document.querySelector(".zoom-controls").hidden = !readerContext.capability.features.zoom;
+
+    readerContext.status.hidden = true;
+    readerContext.mediaTab.setAttribute("aria-controls", "media-panel");
+    readerContext.mediaTab.setAttribute("aria-selected", "false");
+    readerContext.mediaPanel.setAttribute("role", "tabpanel");
+    readerContext.mediaPanel.setAttribute("aria-labelledby", "media-tab");
+  }
+
+  function restoreAndBindPageInversion() {
+    try { readerContext.pageInverted = localStorage.getItem("reader-page-inversion") === "true"; } catch (_) {}
+
+    readerContext.pageInvertToggle.addEventListener("click", () => {
+      readerContext.pageInverted = !readerContext.pageInverted;
+      readerContext.applyPageInversion(true);
+    });
+    readerContext.applyPageInversion();
+  }
+
+  function restoreReaderThemeAndBindReturn() {
+    readerContext.readerThemeToggle.className = "theme-toggle";
+
+    readerContext.applyReaderTheme(readerContext.readerTheme, false, false);
+
+    readerContext.readerPath.addEventListener("click", readerContext.navigateReaderFolder);
+    document.querySelector("#back").addEventListener("click", async () => {
+      clearTimeout(readerContext.saveTimer);
+      await Promise.race([readerContext.saveProgress(), new Promise((resolve) => setTimeout(resolve, 300))]);
+      if (window.parent !== window) {
+        window.parent.postMessage({ type: "voice-reader-close" }, location.origin);
+        return;
+      }
+      readerContext.clearReturnNavigation();
+      try {
+        const target = new URL(readerContext.returnUrl, location.origin);
+        if (target.origin === location.origin) {
+          if (readerContext.returnNeedsReload) location.replace(target.href);
+          else if (readerContext.canReturnWithHistory && history.length > 2) {
+            history.go(-2);
+          } else location.assign(target.href);
+          return;
+        }
+      } catch (_) {}
+      location.assign("/");
+    });
+  }
+
+  function bindZoomAndPageControls() {
+    readerContext.setZoom(readerContext.documentState.zoom * 100, false);
+    for (const [id, delta] of [
+      ["#zoom-out", -10],
+      ["#zoom-in", 10]
+    ]) {
+      document.querySelector(id).addEventListener("click", () => {
+        readerContext.setZoom(Number(readerContext.zoomInput.value) + delta);
+      });
+    }
+    readerContext.zoomInput.addEventListener("change", () => readerContext.setZoom(readerContext.zoomInput.value));
+    readerContext.zoomInput.addEventListener("keydown", (event) => {
+      if (event.key === "Enter") {
+        readerContext.setZoom(readerContext.zoomInput.value);
+        readerContext.zoomInput.blur();
+      }
+    });
+    readerContext.pageInput.addEventListener("change", () => readerContext.goToPage(readerContext.pageInput.value));
+    readerContext.pageInput.addEventListener("keydown", (event) => {
+      if (event.key === "Enter") {
+        readerContext.goToPage(readerContext.pageInput.value);
+        readerContext.pageInput.blur();
+      }
+    });
+
+    document.addEventListener("keydown", readerContext.handleReaderKeydown);
+    document
+      .querySelector("#page-prev")
+      .addEventListener("click", () =>
+        readerContext.documentState.pageCount ? readerContext.goToPage(readerContext.documentState.page - 1) : readerContext.turnViewport(-1)
+      );
+    document
+      .querySelector("#page-next")
+      .addEventListener("click", () =>
+        readerContext.documentState.pageCount ? readerContext.goToPage(readerContext.documentState.page + 1) : readerContext.turnViewport(1)
+      );
+  }
+
+  function bindReaderUiHistory() {
+    if (window.parent === window) {
+      history.replaceState({ ...history.state, voiceReaderBase: true }, "", location.href);
+      history.pushState({ voiceReaderGuard: true }, "", location.href);
+      window.addEventListener("popstate", (event) => {
+        if (!event.state?.voiceReaderBase || readerContext.readerLifecycle.disposed) return;
+        if (document.querySelector("#history-panel").classList.contains("is-open") && !readerContext.fullSearchView.hidden)
+          readerContext.closeFullSearchView();
+        else if (document.querySelector("#history-panel").classList.contains("is-open"))
+          readerContext.setReaderPanelOpen(false, true);
+        else {
+          history.back();
+          return;
+        }
+        history.pushState({ voiceReaderGuard: true }, "", location.href);
+      });
+    }
+  }
+
+  function bindPanelBookmarkAndLifecycleControls() {
+    readerContext.trackReaderResource(() => { readerContext.headingLocationCache?.dispose(); readerContext.headingLocationCache = null; });
+
+    document.addEventListener("click", async (event) => {
+      const path = event.composedPath(),
+        link = path.find((node) => node instanceof Element && node.matches?.("a[href]")),
+        article = path.find(
+          (node) =>
+            node instanceof Element && node.matches?.(".foliate-continuous article[data-section]")
+        );
+      if (!link || !article || !readerContext.epubRendition?.book) return;
+      const raw = link.getAttribute("href") || "";
+      if (raw.startsWith("/api/reader-resource?")) return;
+      if (!raw || readerContext.epubRendition.book.isExternal?.(raw) || /^(?:https?:|mailto:|tel:)/i.test(raw))
+        return;
+      event.preventDefault();
+      const generation = readerContext.beginReaderNavigation(),
+        index = Number(article.dataset.section),
+        section = readerContext.epubRendition.book.sections.filter((item) => item.linear !== "no")[index];
+      let href = raw;
+      try {
+        href = section?.resolveHref?.(raw) || raw;
+      } catch (_) {}
+      try {
+        await readerContext.activateFoliateTocEntry({ href }, generation);
+      } catch (error) {
+        readerContext.reportNavigationError(error, generation);
+      }
+    });
+
+    // Bookmark dialog owns focus and temporarily makes only its siblings inert.
+
+    readerContext.bookmarkRibbon.addEventListener("click", () => readerContext.openBookmarkPopover(readerContext.bookmarkRibbon));
+    document.querySelector("#bookmark-cancel").addEventListener("click", readerContext.closeBookmarkPopover);
+    document.querySelector("#bookmark-add").addEventListener("click", async (event) => {
+      const button = event.currentTarget,
+        editing = readerContext.panelState.editingBookmark;
+      const snapshot = readerContext.pendingBookmarkSnapshot || editing || readerContext.captureBookmarkSnapshot();
+      const label = readerContext.bookmarkLabelInput.value.trim() || snapshot.label,
+        excerpt = readerContext.bookmarkExcerptInput.value.trim();
+      button.disabled = true;
+      try {
+        await VoiceOfMLReaderStore.putBookmark(
+          editing
+            ? { ...editing, label, excerpt }
+            : {
+                ...snapshot,
+                id: `${readerContext.sourceUrl}\0${snapshot.locator}`,
+                url: readerContext.sourceUrl,
+                title: readerContext.documentState.title,
+                extension: readerContext.extension,
+                readerUrl: readerContext.currentReaderUrl().href,
+                label,
+                excerpt,
+                createdAt: Date.now()
+              }
+        );
+        const invoker = readerContext.bookmarkInvoker;
+        readerContext.closeBookmarkPopover();
+        if (!document.querySelector("#bookmarks-panel").hidden) {
+          await readerContext.renderBookmarks();
+          if (editing && invoker && !invoker.isConnected && document.activeElement === document.body)
+            (
+              document.querySelector(
+                `#bookmarks-list [data-bookmark-id="${CSS.escape(editing.id)}"] .panel-item-edit`
+              ) || readerContext.bookmarksAllButton
+            ).focus();
+        }
+      } catch (_) {
+        document.querySelector("#bookmark-prompt").textContent = "书签保存失败，请重试。";
+      } finally {
+        button.disabled = false;
+      }
+    });
+    readerContext.bookmarkPopover.addEventListener("keydown", (event) => {
+      if (event.key === "Escape") {
+        event.preventDefault();
+        readerContext.closeBookmarkPopover();
+        return;
+      }
+      if (event.key !== "Tab") return;
+      const controls = [
+        ...readerContext.bookmarkPopover.querySelectorAll("input,textarea,select,button,a[href],[tabindex]")
+      ].filter((node) => !node.disabled && node.tabIndex >= 0 && node.getClientRects().length);
+      const first = controls[0],
+        last = controls[controls.length - 1];
+      if (event.shiftKey && document.activeElement === first) {
+        event.preventDefault();
+        last.focus();
+      } else if (!event.shiftKey && document.activeElement === last) {
+        event.preventDefault();
+        first.focus();
+      }
+    });
+    for (const button of document.querySelectorAll(".reader-panel-tabs button"))
+      button.addEventListener("click", () => readerContext.selectPanel(button.dataset.panel));
+    document.querySelector(".reader-panel-tabs").addEventListener("keydown", (event) => {
+      if (!["ArrowLeft", "ArrowRight", "Home", "End"].includes(event.key)) return;
+      const tabs = [...document.querySelectorAll(".reader-panel-tabs button:not([hidden])")],
+        current = tabs.indexOf(document.activeElement);
+      if (current < 0) return;
+      event.preventDefault();
+      const next =
+        event.key === "Home"
+          ? 0
+          : event.key === "End"
+            ? tabs.length - 1
+            : (current + (event.key === "ArrowRight" ? 1 : -1) + tabs.length) % tabs.length;
+      readerContext.selectPanel(tabs[next].dataset.panel);
+      tabs[next].focus();
+    });
+    readerContext.bookmarksAllButton.addEventListener("click", () => {
+      readerContext.updatePanelState({ showingAllBookmarks: !readerContext.panelState.showingAllBookmarks });
+      readerContext.bookmarksAllButton.textContent = readerContext.panelState.showingAllBookmarks ? "本书书签" : "全部书签";
+      readerContext.bookmarksAllButton.setAttribute("aria-pressed", String(readerContext.panelState.showingAllBookmarks));
+      readerContext.renderBookmarks();
+    });
+    for (const button of document.querySelectorAll(".panel-search-toggle")) {
+      button.classList.remove("icon-button");
+      button.classList.add("text-action");
+      button.textContent = "搜索";
+      button.hidden = false;
+      button.setAttribute("aria-expanded", "false");
+      button.addEventListener("click", () =>
+        readerContext.setPanelSearchOpen(button, button.getAttribute("aria-expanded") !== "true")
+      );
+    }
+    for (const input of document.querySelectorAll(".panel-search")) {
+      const view = input.closest(".reader-panel-view");
+      input.type = "search";
+      input.setAttribute(
+        "aria-label",
+        `搜索${view.querySelector(".panel-view-header strong")?.textContent || "列表"}`
+      );
+      input.addEventListener("input", (event) => {
+        if (!event.isComposing) readerContext.filterPanel(view);
+      });
+      input.addEventListener("compositionend", () => readerContext.filterPanel(view));
+    }
+    document.querySelector("#history-clear").addEventListener("click", async () => {
+      if (!confirm("清空全部阅读历史？")) return;
+      readerContext.historySuppressed = true;
+      await readerContext.progressSaveChain;
+      await VoiceOfMLReaderStore.clearHistory();
+      readerContext.renderHistory();
+    });
+    readerContext.readerThemeToggle.addEventListener("click", () => {
+      const theme = readerContext.readerTheme === "dark" ? "light" : "dark";
+      readerContext.applyReaderTheme(theme);
+      if (window.parent !== window)
+        window.parent.postMessage({ type: "voice-reader-theme", theme }, location.origin);
+    });
+    window.addEventListener("storage", (event) => {
+      if (event.key === "theme" && event.newValue) readerContext.applyReaderTheme(event.newValue, false);
+    });
+    window.addEventListener("voice-reader-dispose", () => {
+      readerContext.saveProgress();
+      readerContext.disposeReader();
+    });
+    window.addEventListener("message", (event) => {
+      if (
+        event.origin === location.origin &&
+        event.source === window.parent &&
+        event.data?.type === "voice-reader-abort"
+      ) {
+        readerContext.saveProgress();
+        readerContext.disposeReader();
+        return;
+      }
+      if (
+        event.origin === location.origin &&
+        event.source === window.parent &&
+        event.data &&
+        event.data.type === "voice-reader-theme-state"
+      )
+        readerContext.applyReaderTheme(event.data.theme, false);
+      if (event.origin === location.origin && event.source === window.parent &&
+          event.data?.type === "voice-reader-system-back") {
+        if (readerContext.readerUiHistoryState === "full-search") readerContext.closeFullSearchView();
+        else if (readerContext.readerUiHistoryState === "panel") readerContext.setReaderPanelOpen(false, true);
+      }
+    });
+    document
+      .querySelector("#history")
+      .addEventListener("click", () =>
+        readerContext.setReaderPanelOpen(document.querySelector("#history").getAttribute("aria-expanded") !== "true")
+      );
+    document
+      .querySelector("#history-close")
+      .addEventListener("click", () => readerContext.setReaderPanelOpen(false, true));
+    readerContext.viewport.addEventListener("scroll", readerContext.handleReaderPositionChange, { passive: true });
+
+    for (const type of ["wheel", "touchstart", "pointerdown"])
+      readerContext.viewport.addEventListener(type, readerContext.notePdfScrollIntent, { passive: true });
+  }
+
+  function bindPdfPointerSelection() {
+    readerContext.installReaderTapSelectionClear(readerContext.viewport);
+    readerContext.viewport.addEventListener("pointerdown", (event) => {
+      if (event.pointerType !== "mouse") {
+        readerContext.pdfSelectionPointer = null;
+        return;
+      }
+      const run = event.target.closest?.(".reader-pdf-text-run");
+      const selection = document.getSelection();
+      const selectedRun = !selection?.isCollapsed && event.target.closest?.(".reader-page")
+        ? selection.anchorNode?.parentElement?.closest(".reader-pdf-text-run") : null;
+      const origin = run || selectedRun;
+      const caret = !event.shiftKey && event.button === 0 ? readerContext.independentTextCaret(document, event.clientX, event.clientY) : null;
+      readerContext.pdfSelectionPointer = origin
+        ? { id: event.pointerId, x: event.clientX, y: event.clientY, frame: 0,
+            page: origin.closest(".reader-page"), anchorNode: caret?.node || (run ? null : selection.anchorNode),
+            anchorOffset: caret?.offset ?? (run ? 0 : selection.anchorOffset) } : null;
+    }, { passive: true });
+    document.addEventListener("pointermove", (event) => {
+      const start = readerContext.pdfSelectionPointer;
+      if (event.pointerType !== "mouse" || !start || start.id !== event.pointerId ||
+          Math.hypot(event.clientX - start.x, event.clientY - start.y) < 6) return;
+      const selection = document.getSelection();
+      if (!start.anchorNode && selection?.rangeCount && start.page.contains(selection.anchorNode) &&
+          selection.anchorNode.parentElement?.closest(".reader-pdf-text-run")) {
+        start.anchorNode = selection.anchorNode;
+        start.anchorOffset = selection.anchorOffset;
+      }
+      if (start.anchorNode) {
+        start.endX = event.clientX;
+        start.endY = event.clientY;
+        if (!start.frame) start.frame = requestAnimationFrame(() => {
+          start.frame = 0;
+          if (readerContext.pdfSelectionPointer === start)
+            readerContext.correctPdfCrossPageSelection(start.endX, start.endY, start);
+        });
+      }
+    }, { passive: true });
+    document.addEventListener("pointerup", (event) => {
+      const start = readerContext.pdfSelectionPointer;
+      readerContext.pdfSelectionPointer = null;
+      if (event.pointerType !== "mouse" || !["pdf", "pdf-pages"].includes(readerContext.capability.mode) ||
+          !start || start.id !== event.pointerId ||
+          Math.hypot(event.clientX - start.x, event.clientY - start.y) < 6) return;
+      const x = event.clientX, y = event.clientY;
+      requestAnimationFrame(() => readerContext.correctPdfCrossPageSelection(x, y, start));
+    }, { passive: true });
+    document.addEventListener("pointercancel", () => { readerContext.pdfSelectionPointer = null; }, { passive: true });
+  }
+
+  function bindSelectionAndPageLifecycle() {
+    document.addEventListener("selectionchange", () => {
+      if (readerContext.pdfSelectionBoundaryUpdate ||
+          !["pdf", "pdf-pages"].includes(readerContext.capability.mode)) return;
+      const selection = document.getSelection();
+      if (!selection || selection.isCollapsed || !selection.rangeCount) return;
+      const runs = [...readerContext.content.querySelectorAll(".reader-pdf-text-run")]
+        .filter((run) => run.firstChild?.nodeType === Node.TEXT_NODE);
+      if (!runs.length) return;
+      const anchorRun = selection.anchorNode?.parentElement?.closest(".reader-pdf-text-run");
+      const focusRun = selection.focusNode?.parentElement?.closest(".reader-pdf-text-run");
+      if (!anchorRun && !focusRun) return;
+      if (focusRun) return;
+      const beforeAnchor = selection.focusNode && selection.anchorNode &&
+        (selection.focusNode === selection.anchorNode
+          ? selection.focusOffset < selection.anchorOffset
+          : Boolean(selection.focusNode.compareDocumentPosition(selection.anchorNode) & Node.DOCUMENT_POSITION_FOLLOWING));
+      const target = beforeAnchor ? runs[0] : runs[runs.length - 1];
+      const node = target.firstChild;
+      readerContext.pdfSelectionBoundaryUpdate = true;
+      try {
+        selection.setBaseAndExtent(selection.anchorNode, selection.anchorOffset, node,
+          beforeAnchor ? 0 : node.length);
+      } finally {
+        readerContext.pdfSelectionBoundaryUpdate = false;
+      }
+    }, { passive: true });
+    window.addEventListener("pagehide", (event) => {
+      readerContext.saveProgress(event);
+      if (!event.persisted) readerContext.disposeReader();
+    });
+    window.addEventListener("pageshow", (event) => {
+      if (event.persisted && !readerContext.readerLifecycle.disposed) {
+        readerContext.scheduleFoliateScrollSync();
+        readerContext.updateProgressTools();
+      }
+    });
+    document.addEventListener("visibilitychange", () => {
+      if (document.visibilityState === "hidden") readerContext.saveProgress();
+      if (document.hidden) readerContext.stopPdfManifestPrefetch();
+      else readerContext.queuePdfManifestPrefetch();
+    });
+    window.addEventListener("offline", readerContext.stopPdfManifestPrefetch);
+    window.addEventListener("online", () => readerContext.queuePdfManifestPrefetch());
+  }
+
+  function mountProgressControls() {
+    readerContext.progressTools.className = "reader-progress-tools";
+    readerContext.progressTools.innerHTML =
+      '<div class="reader-progress-row"><button class="reader-chapter-prev" type="button" aria-label="上一章" title="上一章"><svg viewBox="0 0 24 24" aria-hidden="true"><path d="m14 5-7 7 7 7"/></svg></button><input class="reader-progress-range" type="range" min="0" max="100" step="0.1" value="0" aria-label="阅读进度"><span class="reader-progress-percent">0.0%</span><button class="reader-progress-undo" type="button" aria-label="撤销进度调整" title="撤销进度调整"><svg viewBox="0 0 24 24" aria-hidden="true"><path d="M7.2 8.3A6.5 6.5 0 1 1 6 16"/><path d="m7.2 8.3 3-.2"/><circle cx="12" cy="12" r="1.5" fill="currentColor" stroke="none"/></svg></button><button class="reader-chapter-next" type="button" aria-label="下一章" title="下一章"><svg viewBox="0 0 24 24" aria-hidden="true"><path d="m10 5 7 7-7 7"/></svg></button></div>';
+    document.querySelector("#history-panel").appendChild(readerContext.progressTools);
+  }
+
+  function mountProgressSummary() {
+    readerContext.readingProgressSummary.className = "reader-progress-summary";
+    readerContext.readingProgressSummary.innerHTML =
+      '<strong>阅读状态</strong><span class="reader-progress-summary-value">0.0%</span><button class="reader-progress-bookmark text-action" type="button">在当前位置添加书签</button>';
+    readerContext.progressTools.prepend(readerContext.readingProgressSummary);
+    readerContext.readingProgressSummary
+      .querySelector(".reader-progress-bookmark")
+      .addEventListener("click", (event) => readerContext.openBookmarkPopover(event.currentTarget));
+
+    readerContext.updateReadingProgressSummary();
+
+    readerContext.syncTocTab();
+  }
+
+  function bindProgressActions() {
+    readerContext.progressRange.addEventListener("pointerdown", () => {
+      readerContext.beginReaderNavigation();
+      readerContext.progressSeeking = true;
+      readerContext.previousProgressState = readerContext.captureProgressState();
+    });
+    readerContext.progressRange.addEventListener("input", () => {
+      readerContext.progressPercent.textContent = `${Number(readerContext.progressRange.value).toFixed(1)}%`;
+      readerContext.seekProgress(readerContext.progressRange.value, true);
+    });
+    for (const type of ["pointerup", "pointercancel"])
+      readerContext.progressRange.addEventListener(type, () => {
+        readerContext.progressSeeking = false;
+        const generation = readerContext.readerRuntime.currentGeneration("navigation");
+        readerContext.flushEpubSeek().then(() => {
+          if (readerContext.isReaderGenerationCurrent("navigation", generation)) readerContext.updateProgressTools();
+        });
+      });
+    readerContext.progressUndo.addEventListener("click", () => {
+      const state = readerContext.previousProgressState;
+      readerContext.previousProgressState = null;
+      readerContext.progressSeeking = false;
+      readerContext.restoreProgressState(state);
+      readerContext.updateProgressTools();
+    });
+    readerContext.chapterPrev.addEventListener("click", () =>
+      readerContext.activateChapter(readerContext.adjacentTocIndex(-1))
+    );
+    readerContext.chapterNext.addEventListener("click", () =>
+      readerContext.activateChapter(readerContext.adjacentTocIndex(1))
+    );
+  }
+
+  function ownDomSearchController() {
+    readerContext.trackReaderResource(readerContext.domSearch.dispose);
+  }
+
+  function ownSearchViewController() {
+    readerContext.trackReaderResource(readerContext.fullSearchController.dispose);
+  }
+
+  function ownPdfSearchStorageAndStart() {
+    readerContext.trackReaderResource(() => {
+      readerContext.pdfPersistentTextStore?.dispose();
+      readerContext.pdfPersistentTextStore = readerContext.pdfPersistentTextOpening = readerContext.pdfPersistentTextVersion = null;
+      readerContext.pdfSearchTextCache.clear();
+      readerContext.pdfSearchTextCacheBytes = 0;
+    });
+
+    readerContext.registerReaderFormatAdapters();
+    readerContext.syncCapabilityControls();
+    readerContext.updateProgressTools();
+    readerContext.start().catch((error) => {
+      if (readerContext.readerAbortController.signal.aborted || error?.name === "AbortError") return;
+      console.error(error);
+      readerContext.fail("阅读文件解析失败，请刷新后重试，或下载原文件。", readerContext.classifyReaderError(error));
+    });
+  }
+
+  return {
+    trackStartupOwners,
+    trackWorkCancellation,
+    trackEarlySourceResolution,
+    publishDiagnosticsAndInstallCompatibility,
+    readSelectedSourceSession,
+    normalizeConvertedPdfMode,
+    applySourceSessionAndCachedMetadata,
+    publishSourceAndSubscribeToStore,
+    initializePanelAccessibility,
+    mountInitialLoadingFeedback,
+    bindDownloadAction,
+    initializeDocumentTitle,
+    restoreReturnNavigation,
+    validateReturnHistory,
+    ownChapterSearchClient,
+    ownDocxPageNodes,
+    ownIndependentPdfResources,
+    ownPdfBookSearchClient,
+    ownPdfPrefetchAndQueues,
+    initializeGenerations,
+    labelToolbarControls,
+    applyMetadataAndWatchSanitizedContent,
+    initializeBookmarkEditor,
+    initializeBookmarkSearchControls,
+    mountBookmarkHeaderActions,
+    mountMediaPanel,
+    restoreAndBindPageInversion,
+    restoreReaderThemeAndBindReturn,
+    bindZoomAndPageControls,
+    bindReaderUiHistory,
+    bindPanelBookmarkAndLifecycleControls,
+    bindPdfPointerSelection,
+    bindSelectionAndPageLifecycle,
+    mountProgressControls,
+    mountProgressSummary,
+    bindProgressActions,
+    ownDomSearchController,
+    ownSearchViewController,
+    ownPdfSearchStorageAndStart
+  };
+}

static/reader/core/reader-diagnostics.mjs

@@ -0,0 +1,22 @@
+export function createReaderDiagnostics(readerContext) {
+  function pdfStage(stage, page = 0) {
+    const started = performance.now();
+    return (outcome = "ready") => {
+      if (readerContext.readerAbortController.signal.aborted) return;
+      readerContext.pdfPageTimings.push({at:started, stage, page, outcome, ms:performance.now()-started});
+      if (readerContext.pdfPageTimings.length > 64) readerContext.pdfPageTimings.shift();
+    };
+  }
+
+  function measurePdf(promise, stage, page = 0) {
+    const finish = readerContext.pdfStage(stage,page);
+    return Promise.resolve(promise).then(value => { finish(); return value; }, error => {
+      finish(error?.name === "AbortError" ? "cancelled" : "failed"); throw error;
+    });
+  }
+
+  return {
+    pdfStage,
+    measurePdf
+  };
+}

static/reader/core/reader-document-loader.mjs

@@ -0,0 +1,164 @@
+export function createReaderDocumentLoader(readerContext) {
+  function loadScript(url) {
+    readerContext.assertReaderActive();
+    return new Promise((resolve, reject) => {
+      const script = document.createElement("script");
+      let settled = false, timeout = 0, untrack = () => {};
+      const finish = (error) => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timeout);
+        untrack();
+        script.onload = script.onerror = null;
+        if (error) {
+          script.remove();
+          reject(error);
+        } else resolve();
+      };
+      const networkError = () => Object.assign(
+        new Error("阅读组件下载失败，请检查网络后重试加载，或下载原文件。"),
+        { code: "READER_ENGINE_NETWORK" }
+      );
+      untrack = readerContext.trackReaderResource(() => finish(readerContext.readerAbortError()));
+      // Download sibling engines concurrently, execute in dependency order.
+      script.async = false;
+      script.src = url;
+      script.onload = () => finish();
+      script.onerror = () => finish(networkError());
+      timeout = setTimeout(() => finish(networkError()), 20000);
+      document.head.appendChild(script);
+    });
+  }
+
+  function fetchWithReaderTimeout(url, timeoutMs = readerContext.READER_PROXY_TIMEOUT_MS, requestInit = {}) {
+    return readerContext.readerRequestManager.request(url, timeoutMs, requestInit);
+  }
+
+  function retryableReaderProxyError(error) {
+    return [408, 429, 500, 502, 503, 504].includes(error?.status) ||
+      ["TypeError", "TimeoutError"].includes(error?.name) ||
+      /failed to fetch|network|timeout|HTTP\s*(?:408|429|5\d\d)|server response\s*\((?:408|429|5\d\d)\)/i.test(error?.message || "");
+  }
+
+  async function retryReaderProxy(open) {
+    for (let attempt = 0; ; attempt++) {
+      readerContext.assertReaderActive();
+      try {
+        return await open();
+      } catch (error) {
+        if (attempt >= 2 || !readerContext.retryableReaderProxyError(error)) throw error;
+        await readerContext.waitForReader(350 * (attempt + 1));
+      }
+    }
+  }
+
+  function fetchReaderUrl(rawUrl, requestInit = {}) {
+    if (String(rawUrl).includes("/api/reader-bucket-resource?"))
+      return readerContext.fetchWithReaderTimeout(rawUrl, readerContext.READER_PROXY_TIMEOUT_MS, requestInit);
+    const proxyUrl = readerContext.readerContentUrl(rawUrl);
+    return readerContext.retryReaderProxy(async () => {
+        const response = await readerContext.fetchWithReaderTimeout(proxyUrl, readerContext.READER_PROXY_TIMEOUT_MS, requestInit);
+      if (response.ok) return response;
+      await response.body?.cancel();
+      throw Object.assign(new Error(`HTTP ${response.status}`), { status: response.status });
+    }).catch((error) => {
+      readerContext.assertReaderActive();
+      requestInit.signal?.throwIfAborted();
+      if (readerContext.retryableReaderProxyError(error)) throw error;
+      return readerContext.fetchWithReaderTimeout(rawUrl, readerContext.READER_PROXY_TIMEOUT_MS, requestInit);
+    });
+  }
+
+  function fetchReaderResponse() {
+    const early = window.__VOICE_PDF_PRELOAD__;
+    if (early?.manifest && early.manifestUrl === new URL(readerContext.sourceUrl, location.href).href) {
+      const pending = early.manifest;
+      early.manifest = null;
+      return pending.then(
+        (response) => (response?.ok ? response : readerContext.fetchReaderUrl(readerContext.sourceUrl)),
+        () => readerContext.fetchReaderUrl(readerContext.sourceUrl)
+      );
+    }
+    return readerContext.fetchReaderUrl(readerContext.sourceUrl);
+  }
+
+  function prepareReaderDocument(engineTasks) {
+    const engines = Promise.all(engineTasks);
+    const response = Promise.race([readerContext.fetchReaderResponse(), engines.then(() => new Promise(() => {}))]);
+    // Rendering owns both promises; early rejection must not become unhandled.
+    response.catch(() => {});
+    engines.catch(() => {});
+    return {response, engines};
+  }
+
+  function readPreparedBytes(response, engines, limit = VoiceOfMLReaderSecurity.LIMITS.documentBytes) {
+    return Promise.all([Promise.resolve(response).then(response => {
+      if (!response.ok) throw new Error(`HTTP ${response.status}`);
+      return VoiceOfMLReaderSecurity.readBytes(response,limit);
+    }), engines]).then(([bytes]) => bytes);
+  }
+
+  function loadTextDocument() {
+    return readerContext.fetchReaderResponse().then((response) => ({ response }));
+  }
+
+  function loadMarkdownDocument() {
+    return readerContext.prepareReaderDocument([readerContext.loadScript(readerContext.MARKED_URL), readerContext.loadScript(readerContext.PURIFY_URL)]);
+  }
+
+  function loadHtmlDocument() {
+    const {response, engines} = readerContext.prepareReaderDocument([readerContext.loadScript(readerContext.PURIFY_URL)]);
+    return {response, engine:engines};
+  }
+
+  function loadDocxDocument() {
+    return readerContext.prepareReaderDocument([readerContext.loadScript(readerContext.JSZIP_URL), readerContext.loadScript(readerContext.DOCX_PREVIEW_URL)]);
+  }
+
+  function loadMediaDocument() {
+    return Promise.resolve(null);
+  }
+
+  async function loadImageDocument(target = readerContext.sourceUrl) {
+    const deadline = performance.now() + readerContext.READER_PROXY_TIMEOUT_MS;
+    const image = new Image();
+    image.className = "reader-image";
+    image.alt = readerContext.documentState.title;
+    image.decoding = "async";
+    try {
+      return await readerContext.imageLoader.load(image, readerContext.readerContentUrl(target), readerContext.readerAbortController.signal, deadline);
+    } catch (error) {
+      readerContext.assertReaderActive();
+      if (error?.code === "READER_RESOURCE_LIMIT") throw error;
+      return readerContext.imageLoader.load(image, target, readerContext.readerAbortController.signal, deadline);
+    }
+  }
+
+  function loadChapterManifestDocument() {
+    const target = readerContext.chapterManifestUrl || readerContext.sourceUrl, early = window.__VOICE_READER_CHAPTER_PRELOAD__;
+    if (early?.manifest && early.manifestUrl === new URL(target, location.href).href) {
+      const pending = early.manifest;
+      early.manifest = null;
+      return pending.then(response => response.ok ? response : readerContext.fetchReaderUrl(target), () => readerContext.fetchReaderUrl(target));
+    }
+    return readerContext.fetchReaderUrl(target);
+  }
+
+  return {
+    loadScript,
+    fetchWithReaderTimeout,
+    retryableReaderProxyError,
+    retryReaderProxy,
+    fetchReaderUrl,
+    fetchReaderResponse,
+    prepareReaderDocument,
+    readPreparedBytes,
+    loadTextDocument,
+    loadMarkdownDocument,
+    loadHtmlDocument,
+    loadDocxDocument,
+    loadMediaDocument,
+    loadImageDocument,
+    loadChapterManifestDocument
+  };
+}

static/reader/core/reader-lifecycle.mjs

@@ -0,0 +1,170 @@
+export function createReaderLifecycle(readerContext) {
+  function readerAbortError() {
+    return new DOMException("Reader work cancelled", "AbortError");
+  }
+
+  function assertReaderActive() {
+    if (readerContext.readerAbortController.signal.aborted || readerContext.readerRuntime.state.lifecycle.disposed)
+      throw readerContext.readerAbortError();
+  }
+
+  function trackReaderResource(cleanup) {
+    if (readerContext.readerAbortController.signal.aborted) cleanup();
+    else readerContext.readerResources.add(cleanup);
+    return () => readerContext.readerResources.delete(cleanup);
+  }
+
+  function stopReaderWork() {
+    readerContext.readerAbortController.abort();
+    for (const cleanup of readerContext.readerResources) {
+      try {
+        cleanup();
+      } catch (_) {}
+    }
+    readerContext.readerResources.clear();
+  }
+
+  function awaitReader(promise, extraSignal = null) {
+    return new Promise((resolve, reject) => {
+      let settled = false;
+      const signals = extraSignal ? [readerContext.readerAbortController.signal, extraSignal] : [readerContext.readerAbortController.signal];
+      const finish = (callback, value) => {
+        if (settled) return;
+        settled = true;
+        signals.forEach(signal => signal.removeEventListener("abort", abort));
+        callback(value);
+      };
+      const abort = () => finish(reject, readerContext.readerAbortError());
+      Promise.resolve(promise)
+        .then(value => finish(resolve, value), error => finish(reject, error));
+      if (signals.some(signal => signal.aborted)) abort();
+      else signals.forEach(signal => signal.addEventListener("abort", abort, { once: true }));
+    });
+  }
+
+  function waitForReader(delay = 0, animationFrame = false) {
+    return new Promise((resolve, reject) => {
+      readerContext.assertReaderActive();
+      const signal = readerContext.readerAbortController.signal;
+      const abort = () => {
+        if (animationFrame) cancelAnimationFrame(handle);
+        else clearTimeout(handle);
+        reject(readerContext.readerAbortError());
+      };
+      const done = () => {
+        signal.removeEventListener("abort", abort);
+        resolve();
+      };
+      const handle = animationFrame ? requestAnimationFrame(done) : setTimeout(done, delay);
+      signal.addEventListener("abort", abort, { once: true });
+    });
+  }
+
+  function setReaderPhase(phase) {
+    return readerContext.readerRuntime.setPhase(phase);
+  }
+
+  function setReaderStage(stage) {
+    return readerContext.readerRuntime.setStage(stage);
+  }
+
+  function classifyReaderError(error, fallback = "READER_PARSE") {
+    if (["READER_ENGINE_NETWORK", "READER_RESTORE"].includes(error?.code)) return error.code;
+    const value = `${error?.name || ""} ${error?.message || error || ""}`;
+    if (/AbortError|timeout|network|fetch|HTTP\s*\d+/i.test(value)) return "READER_NETWORK";
+    if (
+      /EPUB_INVALID|corrupt|damage|truncated|central directory|end of data|invalid zip/i.test(value)
+    )
+      return "READER_CORRUPT";
+    return fallback;
+  }
+
+  function markReaderContentReady() {
+    if (["foliate", "epub-chapters"].includes(readerContext.capability?.mode) && readerContext.loadingIndicator.isConnected)
+      readerContext.foliateScrollAnchors.preserve(() => readerContext.loadingIndicator.remove());
+    else readerContext.loadingIndicator.remove();
+    readerContext.loadingStatus.hidden = true;
+  }
+
+  function nextReaderGeneration(name) {
+    const generation = readerContext.readerRuntime.nextGeneration(name);
+    if (name === "search") readerContext.drainPdfTextWaiters();
+    return generation;
+  }
+
+  function isReaderGenerationCurrent(name, value) {
+    return !readerContext.readerAbortController.signal.aborted && readerContext.readerRuntime.isCurrent(name, value);
+  }
+
+  function reportNavigationError(error, generation) {
+    if (readerContext.isReaderGenerationCurrent("navigation", generation) && error?.name !== "AbortError")
+      console.warn("Reader navigation failed", error);
+  }
+
+  function disposeReader() {
+    if (readerContext.readerLifecycle.disposed) return;
+    readerContext.updateDocumentState({ restorationReady: false });
+    readerContext.readerRuntime.dispose();
+    readerContext.contentSanitizerObserver?.disconnect();
+    readerContext.contentSanitizerObserver = null;
+    clearTimeout(readerContext.saveTimer);
+    clearTimeout(readerContext.themeAnimationTimer);
+    clearTimeout(readerContext.panelAnimationTimer);
+    for (const frame of [readerContext.markerFrame, readerContext.foliateScrollFrame, readerContext.foliateWindowFrame, readerContext.epubSeekFrame])
+      if (frame) cancelAnimationFrame(frame);
+    readerContext.saveTimer =
+      readerContext.themeAnimationTimer =
+      readerContext.panelAnimationTimer =
+      readerContext.markerFrame =
+      readerContext.foliateScrollFrame =
+      readerContext.foliateWindowFrame =
+      readerContext.epubSeekFrame =
+        0;
+    VoiceOfMLReaderStore.dispose?.();
+  }
+
+  function fail(message, code = "READER_PARSE") {
+    if (readerContext.readerLifecycle.disposed || readerContext.readerAbortController.signal.aborted) return;
+    readerContext.updateDocumentState({ restorationReady: false });
+    readerContext.readerRuntime.fail(code);
+    readerContext.stopReaderWork();
+    readerContext.readerRequestManager.dispose();
+    readerContext.formatAdapters.dispose();
+    window.__VOICE_PDF_PRELOAD__?.dispose();
+    readerContext.content.dataset.errorCode = code;
+    readerContext.loadingStatus.hidden = true;
+    readerContext.markReaderContentReady();
+    const visibleMessage = `${message} [${readerContext.readerLifecycle.stage}]`;
+    readerContext.content.innerHTML = `<div class="reader-error"></div>`;
+    readerContext.content.querySelector(".reader-error").textContent = visibleMessage;
+    if (["READER_ENGINE_NETWORK", "READER_RESTORE"].includes(code)) {
+      const retry = document.createElement("button");
+      retry.type = "button";
+      retry.className = "text-button";
+      retry.id = "reader-engine-retry";
+      retry.textContent = "重试加载";
+      // Reload clears the browser's failed module map and preserves this book URL.
+      retry.addEventListener("click", () => location.reload());
+      readerContext.content.querySelector(".reader-error").append(document.createElement("br"), retry);
+    }
+    readerContext.status.textContent = "无法打开";
+  }
+
+  return {
+    readerAbortError,
+    assertReaderActive,
+    trackReaderResource,
+    stopReaderWork,
+    awaitReader,
+    waitForReader,
+    setReaderPhase,
+    setReaderStage,
+    classifyReaderError,
+    markReaderContentReady,
+    nextReaderGeneration,
+    isReaderGenerationCurrent,
+    reportNavigationError,
+    disposeReader,
+    fail
+  };
+}

static/reader/core/reader-source.mjs

@@ -0,0 +1,335 @@
+export function createReaderSource(readerContext) {
+  function readerContentUrl(url) {
+    try {
+      const parsed = new URL(url, location.href);
+      if (parsed.origin === location.origin && parsed.pathname === "/api/reader-bucket-resource")
+        return parsed.href;
+      if (parsed.origin === "https://huggingface.co" && !parsed.username && !parsed.password && !parsed.search && !parsed.hash) {
+        const prefix = /^\/buckets\/(vomebook\/(?:pdf-pages-v2|reader-assets-v2))\/resolve\//.exec(parsed.pathname);
+        const path = prefix && decodeURIComponent(parsed.pathname.slice(prefix[0].length));
+        if (path && VoiceOfMLReader.isBucketPath(path, true, prefix[1]))
+          return `/api/reader-bucket-resource?path=${encodeURIComponent(path)}`;
+      }
+    } catch (_) {}
+    return `/api/reader-content?url=${encodeURIComponent(url)}`;
+  }
+
+  function readerDownloadApiUrl(path) {
+    return path;
+  }
+
+  function readerDownloadUrl(filename, link) {
+    return readerContext.readerDownloadApiUrl(`/api/download?file=${encodeURIComponent(filename || "file")}&link=${encodeURIComponent(link || "")}`);
+  }
+
+  async function startReaderDownload(event) {
+    event.preventDefault();
+    const button = event.currentTarget;
+    if (button.hasAttribute("aria-busy")) return;
+    readerContext.showDownloadFeedback("正在准备下载…", 0);
+    const controller = new AbortController();
+    let timer;
+    button.setAttribute("aria-busy", "true");
+    try {
+      // ID-only links share the Reader's in-flight resolution, not its render phase.
+      if (!readerContext.downloadUrl) await readerContext.readerSourcePromise;
+      if (!readerContext.downloadUrl) throw new Error("无法获取原文件地址");
+      const filename = readerContext.documentState.title || "file";
+      const checkUrl = readerContext.readerDownloadApiUrl(`/api/download/check?link=${encodeURIComponent(readerContext.downloadUrl)}`);
+      timer = setTimeout(() => controller.abort(), 8000);
+      const response = await fetch(checkUrl, { signal: controller.signal, cache: "no-store" });
+      const result = await response.json().catch(() => null);
+      if (!response.ok || result?.ok !== true) throw new Error(result?.error || "下载检查失败，请重试");
+      if (readerContext.readerLifecycle.disposed) return;
+      const frame = document.createElement("iframe");
+      frame.hidden = true;
+      frame.setAttribute("aria-hidden", "true");
+      frame.src = readerContext.readerDownloadUrl(filename, readerContext.downloadUrl);
+      document.body.appendChild(frame);
+      setTimeout(() => frame.remove(), 60000);
+      readerContext.showDownloadFeedback("已发起下载");
+    } catch (error) {
+      if (!readerContext.readerLifecycle.disposed) {
+        readerContext.showDownloadFeedback(error?.name === "AbortError" ? "下载检查超时，请重试" : (error.message || "下载失败，请重试"));
+      }
+    } finally {
+      clearTimeout(timer);
+      button.removeAttribute("aria-busy");
+    }
+  }
+
+  function normalizeSourceUrl(url) {
+    return url.startsWith("/api/reader-bucket-resource?") ? new URL(url, location.origin).href : url;
+  }
+
+  async function resolveReaderId(id) {
+    const endpoint = `/api/reader-resolve?id=${encodeURIComponent(id)}`;
+    for (let attempt = 0; attempt < 2; attempt++) {
+      const early = window.__VOICE_READER_RESOLVE__;
+      if (!attempt && early?.id === id) {
+        window.__VOICE_READER_RESOLVE__ = null;
+        const untrack = readerContext.trackReaderResource(early.dispose);
+        let result;
+        try { result = await readerContext.awaitReader(early.promise); }
+        finally { untrack(); early.dispose(); }
+        if (result.ok) return result.data;
+        if (![408, 429, 500, 502, 503, 504].includes(result.status))
+          throw new Error(`HTTP ${result.status}`);
+        await readerContext.waitForReader(350);
+        continue;
+      }
+      const response = await readerContext.readerRequestManager.request(endpoint, readerContext.READER_PROXY_TIMEOUT_MS);
+      if (response.ok) return response.json();
+      if (![408, 429, 500, 502, 503, 504].includes(response.status) || attempt)
+        throw new Error(`HTTP ${response.status}`);
+      await response.body?.cancel();
+      await readerContext.waitForReader(350);
+    }
+    throw new Error("Reader ID resolution failed");
+  }
+
+  function applyReaderMetadata(data) {
+    if (data) readerContext.resolvedReaderData = { ...(readerContext.resolvedReaderData || {}), ...data };
+    if (data?.ReaderOcrManifest || data?.ocr_manifest) {
+      readerContext.ocrManifestUrl = data.ReaderOcrManifest || data.ocr_manifest;
+      readerContext.params.set("ocr_manifest", readerContext.ocrManifestUrl);
+    }
+    readerContext.readerRuntime.update("source", { metadata: readerContext.resolvedReaderData });
+    const title = String(readerContext.resolvedReaderData?.title || readerContext.params.get("title") || readerContext.sourceName).trim();
+    const suffix = String(
+      readerContext.resolvedReaderData?.original_extension || (readerContext.extension === "pdf-pages" ? "pdf" : readerContext.extension)
+    )
+      .toLowerCase()
+      .replace(/^\./, "");
+    const value = title + (suffix && !title.toLowerCase().endsWith(`.${suffix}`) ? `.${suffix}` : "");
+    readerContext.updateDocumentState({ title: value });
+    document.querySelector("#title").textContent = value;
+    document.title = `${value} - VoiceOfML Reader`;
+    readerContext.applyReaderPathMetadata(readerContext.resolvedReaderData);
+  }
+
+  function applyReaderPathMetadata(data) {
+    const folder = Array.isArray(data?.folder) ? data.folder.join("/") : String(data?.folder || "");
+    const value = String(
+      data?.path || [data?.repo, folder].filter(Boolean).join("/") || readerContext.readerPathLabel
+    ).replace(/^\/+|\/+$/g, "");
+    readerContext.folderNavigationTarget = null;
+    try {
+      const target = new URL(readerContext.folderReturnUrl, location.origin);
+      if (
+        readerContext.folderReturnUrl &&
+        target.origin === location.origin &&
+        target.pathname.split("/").filter(Boolean).length === 1
+      )
+        readerContext.folderNavigationTarget = target;
+    } catch (_) {}
+    if (!readerContext.folderNavigationTarget && data?.repo) {
+      readerContext.folderNavigationTarget = new URL("/" + encodeURIComponent(data.repo), location.origin);
+      if (folder) readerContext.folderNavigationTarget.searchParams.set("folder_self", folder);
+    }
+    readerContext.readerPath.textContent = value;
+    readerContext.readerPath.hidden = !value;
+    readerContext.readerPath.disabled = !readerContext.folderNavigationTarget;
+    readerContext.readerPath.setAttribute("aria-label", `筛选文件夹：${value}`);
+  }
+
+  function validSource(raw) {
+    try {
+      const url = new URL(raw);
+      const bucketPath = url.searchParams.get("path") || "";
+      if (
+        (url.origin === location.origin || url.origin === "https://voiceofml-search.hf.space") &&
+        url.pathname === "/api/reader-bucket-resource" &&
+        url.searchParams.getAll("path").length === 1 &&
+        [...url.searchParams.keys()].every((key) => key === "path") &&
+         (VoiceOfMLReader.isBucketPath(bucketPath, true, "vomebook/pdf-pages-v2") ||
+          VoiceOfMLReader.isBucketPath(bucketPath, true, "vomebook/reader-assets-v2"))
+      )
+        return true;
+      if (url.protocol === "https:" && url.hostname === "huggingface.co" &&
+          (url.pathname.startsWith("/buckets/vomebook/pdf-pages-v2/resolve/") ||
+           url.pathname.startsWith("/buckets/vomebook/reader-assets-v2/resolve/")) && !url.search && !url.hash) {
+        const prefix = url.pathname.startsWith("/buckets/vomebook/pdf-pages-v2/resolve/")
+          ? "/buckets/vomebook/pdf-pages-v2/resolve/"
+          : "/buckets/vomebook/reader-assets-v2/resolve/";
+        const path = decodeURIComponent(url.pathname.slice(prefix.length));
+        const bucket = prefix.includes("pdf-pages-v2") ? "vomebook/pdf-pages-v2" : "vomebook/reader-assets-v2";
+        return VoiceOfMLReader.isBucketPath(path, true, bucket);
+      }
+      if (url.protocol !== "https:" || !["huggingface.co", "hf-mirror.com"].includes(url.hostname))
+        return false;
+      const readerAsset = VoiceOfMLReader.isAssetSourcePath(url.pathname);
+      if (readerContext.extension === "docx") return readerAsset;
+      return /^\/datasets\/VoiceOfML\/[^/]+\/(resolve|raw)\//.test(url.pathname) || readerAsset;
+    } catch (_) {
+      return false;
+    }
+  }
+
+  function validOcr(raw) {
+    try {
+      const url = new URL(raw, location.origin);
+      return url.origin === location.origin && url.pathname.startsWith("/txt/");
+    } catch (_) {
+      return false;
+    }
+  }
+
+  function validFallback(raw) {
+    try {
+      const url = new URL(raw);
+      return (
+        url.protocol === "https:" &&
+        ["huggingface.co", "hf-mirror.com"].includes(url.hostname) &&
+        /\/datasets\/vomebook\/Reader-Assets\/resolve\/[^/]+\/objects\/[0-9a-f]{2}\/[0-9a-f]{64}\/(?:linearized\.pdf|(?:[a-z0-9-]+\/)?document\.pdf)$/.test(
+          url.pathname
+        )
+      );
+    } catch (_) {
+      return false;
+    }
+  }
+
+  function readerAssetObjectFamily(raw, base = location.href) {
+    try {
+      const url = new URL(raw, base);
+      if (url.origin === "https://voiceofml-search.hf.space" && url.pathname === "/api/reader-bucket-resource") {
+        const bucketPath = url.searchParams.get("path") || "";
+         const match = bucketPath.match(/^(chapters\/ebook\/(?:epub|mobi|azw3|fb2|chm)\/[0-9a-f]{64}\/[0-9a-f]{16}\/)/);
+        if (url.hash || url.searchParams.getAll("path").length !== 1 ||
+            [...url.searchParams.keys()].some((key) => key !== "path") || !match ||
+             !VoiceOfMLReader.isBucketPath(bucketPath, true, "vomebook/reader-assets-v2")) return null;
+        return { url, prefix: match[1], bucket: true, bucketPath };
+      }
+      if (
+        url.protocol !== "https:" ||
+        !["huggingface.co", "hf-mirror.com"].includes(url.hostname) ||
+        url.username ||
+        url.password
+      )
+        return null;
+      const match = url.pathname.match(
+        /^\/datasets\/vomebook\/Reader-Assets\/resolve\/[^/]+\/(objects\/[0-9a-f]{2}\/[0-9a-f]{64}\/(?:[a-z0-9-]+\/)?)/
+      );
+      return match
+        ? { url, prefix: url.pathname.slice(0, url.pathname.indexOf(match[1])) + match[1], bucket: false }
+        : null;
+    } catch (_) {
+      return null;
+    }
+  }
+
+  function trustedReaderAssetManifestUrl(raw) {
+    const family = readerContext.readerAssetObjectFamily(raw);
+    const manifestPath = family?.bucket ? family.bucketPath : family?.url.pathname;
+    return family &&
+      (family.bucket || !family.url.search) &&
+      (family.bucket || !family.url.hash) &&
+      /\/chapter-manifest\.json$/i.test(manifestPath || "")
+      ? family.url.href
+      : null;
+  }
+
+  function trustedChapterUrl(raw, base) {
+    const manifest = readerContext.readerAssetObjectFamily(base);
+    const manifestPath = manifest?.bucket ? manifest.bucketPath : new URL(base, location.href).pathname;
+    if (!manifest || !/\/chapter-manifest\.json$/i.test(manifestPath))
+      return null;
+    try {
+      if (manifest.bucket) {
+        const url = new URL(String(raw || ""), `https://bucket.invalid/${manifest.bucketPath}`);
+        const path = decodeURIComponent(url.pathname.slice(1));
+        if (url.origin !== "https://bucket.invalid" || url.search || url.hash ||
+             !path.startsWith(manifest.prefix) ||
+             !/(?:\/chapters\/chapter-[0-9]{4}\.xhtml|\/epub-search-index\.json\.gz)$/i.test(path) ||
+             !VoiceOfMLReader.isBucketPath(path, true, "vomebook/reader-assets-v2")) return null;
+        return `${manifest.url.origin}/api/reader-bucket-resource?path=${encodeURIComponent(path)}`;
+      }
+      const url = new URL(raw, base);
+      return !url.search &&
+        !url.hash &&
+        url.origin === manifest.url.origin &&
+        url.pathname.startsWith(manifest.prefix) &&
+         /(?:\.(?:xhtml?|html?)|\/epub-search-index\.json\.gz)$/i.test(url.pathname)
+        ? url.href
+        : null;
+    } catch (_) {
+      return null;
+    }
+  }
+
+  function trustedChapterReferenceUrl(raw, base, manifestBase) {
+    const family = readerContext.readerAssetObjectFamily(manifestBase);
+    if (!family) return null;
+    try {
+      if (family.bucket) {
+        const current = readerContext.readerAssetObjectFamily(base);
+        if (!current?.bucket) return null;
+        const url = new URL(String(raw || ""), `https://bucket.invalid/${current.bucketPath}`);
+        const path = decodeURIComponent(url.pathname.slice(1));
+        if (url.origin !== "https://bucket.invalid" || url.search ||
+            !path.startsWith(family.prefix) || !/\/chapters\/chapter-[0-9]{4}\.xhtml$/i.test(path) ||
+             !VoiceOfMLReader.isBucketPath(path, true, "vomebook/reader-assets-v2")) return null;
+        return { url: `${family.url.origin}/api/reader-bucket-resource?path=${encodeURIComponent(path)}`,
+                 fragment: url.hash };
+      }
+      const url = new URL(raw, base);
+      return !url.search && url.origin === family.url.origin && url.pathname.startsWith(family.prefix) &&
+        /\/(?:chapters\/)?[^/]+\.xhtml?$/i.test(url.pathname)
+        ? { url: url.href, fragment: url.hash } : null;
+    } catch (_) {
+      return null;
+    }
+  }
+
+  function trustedChapterResourceUrl(raw, base, attribute, manifestBase) {
+    const value = String(raw || "").trim();
+    if (!value || /^(?:data:|mailto:|tel:|javascript:)/i.test(value)) return null;
+    // Chapters and resources can be siblings within the manifest's asset directory.
+    const family = readerContext.readerAssetObjectFamily(manifestBase);
+    if (!family) return null;
+    try {
+      if (family.bucket) {
+        const current = readerContext.readerAssetObjectFamily(base);
+        if (!current?.bucket) return null;
+        const url = new URL(value, `https://bucket.invalid/${current.bucketPath}`);
+        const path = decodeURIComponent(url.pathname.slice(1));
+        if (url.origin !== "https://bucket.invalid" || url.search || url.hash ||
+             !path.startsWith(family.prefix) || !VoiceOfMLReader.isBucketPath(path, true, "vomebook/reader-assets-v2")) return null;
+        const resource = `${family.url.origin}/api/reader-bucket-resource?path=${encodeURIComponent(path)}`;
+        return attribute === "href" ? resource : resource;
+      }
+      const url = new URL(value, base),
+        path = url.pathname.toLowerCase();
+      if (url.origin !== family.url.origin || !url.pathname.startsWith(family.prefix)) return null;
+      const allowed =
+        attribute === "href"
+          ? /\.(?:x?html?|css|svg|png|jpe?g|gif|webp|woff2?|ttf|otf|mp3|mp4|m4a|webm|ogg)$/i.test(
+              path
+            )
+          : /\.(?:svg|png|jpe?g|gif|webp|woff2?|ttf|otf|mp3|mp4|m4a|webm|ogg)$/i.test(path);
+      return allowed ? url.href : null;
+    } catch (_) {
+      return null;
+    }
+  }
+
+  return {
+    readerContentUrl,
+    readerDownloadApiUrl,
+    readerDownloadUrl,
+    startReaderDownload,
+    normalizeSourceUrl,
+    resolveReaderId,
+    applyReaderMetadata,
+    applyReaderPathMetadata,
+    validSource,
+    validOcr,
+    validFallback,
+    readerAssetObjectFamily,
+    trustedReaderAssetManifestUrl,
+    trustedChapterUrl,
+    trustedChapterReferenceUrl,
+    trustedChapterResourceUrl
+  };
+}

static/reader/formats/reader-chapter-format.mjs

@@ -0,0 +1,450 @@
+export function createReaderChapterFormat(readerContext) {
+  async function renderChapterManifest(prepared) {
+    const response = await prepared;
+    if (!response.ok) throw new Error(`HTTP ${response.status}`);
+    const manifest = VoiceOfMLReaderSecurity.validateChapterManifest(
+      JSON.parse(
+        await VoiceOfMLReaderSecurity.readText(response, VoiceOfMLReaderSecurity.LIMITS.manifestBytes)
+      )
+    );
+    readerContext.assertReaderActive();
+    const frame = document.createElement("div");
+    frame.className = "epub-frame";
+    frame.style.overflowAnchor = "none";
+    const openingGeneration = readerContext.readerRuntime.currentGeneration("navigation");
+    readerContext.content.appendChild(frame);
+    const loaded = new Set(), retainedBytes = new Map(),
+      manifestBase = readerContext.trustedReaderAssetManifestUrl(readerContext.chapterManifestUrl || readerContext.sourceUrl);
+    const chapterByIndex = new Map(manifest.chapters.map((chapter) => [chapter.index, chapter]));
+    const chapterPrefetchCount = 6;
+    const chapterPrefetchMaxCount = 10, chapterPrefetchBytes = 128 * 1024;
+    let chapterFocusIndex = 1, chapterWindowFrame = 0, chapterWindowReady = false;
+    let chapterNavigating = 0;
+    let chapterPreviousObserver = null;
+    const chapterBudget = VoiceOfMLReaderSecurity.createByteBudget();
+    if (!manifestBase) throw new Error("EPUB_INVALID_MANIFEST_PATH");
+    const searchIndex = manifest.search_index;
+    readerContext.chapterSearchConfiguration =
+      searchIndex?.path === "epub-search-index.json.gz" &&
+      Number.isSafeInteger(searchIndex.bytes) &&
+      searchIndex.bytes > 0 &&
+      /^[0-9a-f]{64}$/.test(searchIndex.sha256 || "")
+        ? {
+          chapters: manifest.chapters,
+          index: {
+            ...searchIndex,
+            url: (() => {
+              const resolved = readerContext.trustedChapterUrl(searchIndex.path, manifestBase);
+              if (!resolved) return "";
+              const target = new URL(resolved, location.href);
+              const bucketUrl = target.origin === "https://voiceofml-search.hf.space" &&
+                target.pathname === "/api/reader-bucket-resource"
+                ? target.pathname + target.search : resolved;
+              return readerContext.readerContentUrl(bucketUrl);
+            })()
+          }
+          }
+        : null;
+    const chapterUrl = (chapter) => readerContext.trustedChapterUrl(chapter.path, manifestBase);
+    const chapterAt = (index) => chapterByIndex.get(index) || null;
+    const nextChapterNode = (index, selector) => {
+      for (const node of frame.querySelectorAll(selector))
+        if (Number(node.dataset.chapter) > index) return node;
+      return null;
+    };
+    const resourceUrl = (raw, base, attribute) => {
+      const value = String(raw || "").trim();
+      if (!value || value.startsWith("#")) return null;
+      return readerContext.trustedChapterResourceUrl(value, base, attribute, manifestBase);
+    };
+    const insertChapter = (article) => {
+      const existing = frame.querySelector(
+        `.reader-epub-chapter[data-chapter="${article.dataset.chapter}"]`
+      );
+      if (existing) return existing;
+      const next = nextChapterNode(Number(article.dataset.chapter), ".reader-epub-chapter, .reader-chapter-sentinel");
+      const marker = frame.querySelector(`.reader-chapter-sentinel[data-chapter="${article.dataset.chapter}"]`);
+      const insert = () => {
+        if (marker) {
+          readerContext.chapterManifestObserver.unobserve(marker);
+          chapterPreviousObserver.unobserve(marker);
+          marker.replaceWith(article);
+        } else frame.insertBefore(article, next || null);
+      };
+      const preservePosition = chapterWindowReady || !readerContext.isReaderGenerationCurrent("navigation", openingGeneration);
+      if (preservePosition) readerContext.foliateScrollAnchors.preserve(insert);
+      else insert();
+      readerContext.chapterManifestObserver.observe(article);
+      if (preservePosition) readerContext.foliateScrollAnchors.observe(article);
+      return article;
+    };
+    const ensureSentinel = (chapter, previous = false) => {
+      if (readerContext.readerAbortController.signal.aborted || loaded.has(chapter.index)) return null;
+      const selector = `.reader-chapter-sentinel[data-chapter="${chapter.index}"]`;
+      const existing = frame.querySelector(selector);
+      if (existing) return existing;
+      const marker = document.createElement("button");
+      marker.type = "button";
+      marker.className = "reader-chapter-sentinel";
+      marker.dataset.chapter = String(chapter.index);
+      marker.textContent = `加载第 ${chapter.index} 章`;
+      marker.setAttribute("aria-label", `重试加载第 ${chapter.index} 章`);
+      marker.addEventListener("click", () => {
+        marker.disabled = true;
+        fetchChapter(chapter).catch((error) => {
+          marker.disabled = false;
+          console.warn("EPUB chapter could not be loaded", error);
+        });
+      });
+      const next = nextChapterNode(chapter.index,
+        ".reader-epub-chapter[data-chapter], .reader-chapter-sentinel[data-chapter]");
+      const insert = () => frame.insertBefore(marker, next || null);
+      if (chapterWindowReady || !readerContext.isReaderGenerationCurrent("navigation", openingGeneration))
+        readerContext.foliateScrollAnchors.preserve(insert);
+      else insert();
+      (previous ? chapterPreviousObserver : readerContext.chapterManifestObserver).observe(marker);
+      return marker;
+    };
+    const chapterTarget = (article, fragment) =>
+      !fragment || article.id === fragment ? article :
+        article.querySelector(`[id="${CSS.escape(fragment)}"], [name="${CSS.escape(fragment)}"]`);
+    const setChapterToc = () =>
+      readerContext.setToc(
+        (manifest.toc ?? manifest.chapters.map((item) => ({
+          title: item.title || `章节 ${item.index}`, chapter: item.index, depth: 0, fragment: ""
+        }))).map((item) => ({
+          label: item.title,
+          chapterIndex: item.chapter,
+          fragment: item.fragment,
+          depth: item.depth,
+          activate: (generation) => activateChapter(manifest.chapters[item.chapter - 1], generation, item.fragment)
+        }))
+      );
+    const chapterScheduler = VoiceOfMLReaderChapters.createChapterScheduler({
+      create: async (index, signal, priority) => {
+        const chapter = chapterAt(index);
+        readerContext.assertReaderActive();
+        const url = chapterUrl(chapter);
+        if (!url) throw new Error("EPUB_INVALID_PATH");
+        const result = await readerContext.fetchReaderUrl(url, { signal, priority });
+        if (!result.ok) throw new Error(`HTTP ${result.status}`);
+        const bytes = await VoiceOfMLReaderSecurity.readBytes(
+          result,
+          VoiceOfMLReaderSecurity.LIMITS.chapterBytes,
+          chapterBudget
+        );
+        let inserted = false;
+        try {
+          readerContext.assertReaderActive();
+          signal.throwIfAborted();
+          const doc = readerContext.parseChapterDocument(new TextDecoder().decode(bytes));
+          for (const element of doc.querySelectorAll("*")) {
+            for (const name of ["src", "href", "poster", "xlink:href"])
+              if (element.hasAttribute(name)) {
+                const value = element.getAttribute(name) || "";
+                if (name === "href" && element.localName === "a" &&
+                    readerContext.trustedChapterReferenceUrl(value, url, manifestBase)) continue;
+                const resolved = resourceUrl(value, url, name === "href" ? "href" : "resource");
+                if (resolved) element.setAttribute(name, resolved);
+                else if (!(name === "href" && value.startsWith("#"))) element.removeAttribute(name);
+              }
+            if (element.hasAttribute("srcset")) element.removeAttribute("srcset");
+          }
+          const article = document.createElement("article");
+          article.className = "reader-markdown reader-epub-chapter";
+          article.dataset.chapter = String(chapter.index);
+          if (doc.body?.id) article.id = doc.body.id;
+          article.innerHTML = doc.body ? doc.body.innerHTML : "";
+          for (const image of article.querySelectorAll("img")) {
+            image.loading = priority === "high" ? "eager" : "lazy";
+            image.fetchPriority = priority;
+            image.decoding = "async";
+          }
+          // The generated text index includes head text (e.g. the chapter title).
+          article._chapterSearchHead = doc.head ? document.importNode(doc.head, true) : null;
+          insertChapter(article);
+          loaded.add(chapter.index);
+          retainedBytes.set(chapter.index, bytes.byteLength);
+          inserted = true;
+          for (const entry of readerContext.navigationState.tocEntries)
+            if (entry.chapterIndex === chapter.index)
+              entry.target = chapterTarget(article, entry.fragment);
+          const next = chapterAt(chapter.index + 1);
+          if (next) ensureSentinel(next);
+          const previous = chapterAt(chapter.index - 1);
+          if (previous) ensureSentinel(previous, true);
+          scheduleChapterWindow();
+        } catch (error) {
+          if (!inserted) chapterBudget.release(bytes.byteLength);
+          throw error;
+        }
+      }
+    });
+    const fetchChapter = (chapter, demand = true, exclusive = false) => {
+      readerContext.assertReaderActive();
+      if (loaded.has(chapter.index)) return Promise.resolve();
+      return chapterScheduler.load(chapter.index, demand, exclusive).then(() => {
+        readerContext.foliateScrollAnchors.whenIdle(trimChapterWindow);
+      }).catch(error => {
+        if (error.name !== "AbortError" && !readerContext.readerAbortController.signal.aborted) {
+          const marker = ensureSentinel(chapter);
+          marker?.classList.add("reader-chapter-load-error");
+          marker?.removeAttribute("aria-hidden");
+        }
+        throw error;
+      });
+    };
+    const activateChapter = async (chapter, generation, fragment = "") => {
+      chapterFocusIndex = chapter.index;
+      chapterNavigating++;
+      try { await fetchChapter(chapter, true, chapterWindowReady); }
+      finally { chapterNavigating--; }
+      if (!readerContext.isReaderGenerationCurrent("navigation", generation)) return false;
+      const node = frame.querySelector(`.reader-epub-chapter[data-chapter="${chapter.index}"]`);
+      let id = fragment.replace(/^#/, "");
+      try {
+        id = decodeURIComponent(id);
+      } catch (_) {}
+      const anchor = chapterTarget(node, id);
+      if (!anchor) throw new Error("EPUB_MISSING_ANCHOR");
+      readerContext.foliateScrollAnchors.invalidate();
+      anchor.scrollIntoView({ block: "start" });
+      readerContext.foliateScrollAnchors.remember();
+      readerContext.syncHeadingLocation();
+      readerContext.updateProgressTools();
+      readerContext.scheduleSave();
+      return true;
+    };
+    frame.addEventListener("click", async (event) => {
+      const link = event.target.closest?.("a[href]");
+      const article = link?.closest(".reader-epub-chapter");
+      if (
+        !article ||
+        event.button !== 0 ||
+        event.ctrlKey ||
+        event.metaKey ||
+        event.shiftKey ||
+        event.altKey
+      )
+        return;
+      const current = chapterAt(Number(article.dataset.chapter));
+      const destination = readerContext.trustedChapterReferenceUrl(link.getAttribute("href"), chapterUrl(current), manifestBase);
+      const target = destination ? new URL(destination.url) : null;
+      const fragment = destination?.fragment || "";
+      const chapter = target && manifest.chapters.find((item) => chapterUrl(item) === target.href);
+      if (!chapter) {
+        // A stale or missing book document must not navigate out to an asset 404.
+        if (/\.(?:xhtml?|html?)(?:$|#)/i.test(link.getAttribute("href") || "")) {
+          event.preventDefault();
+          let message = link.nextElementSibling;
+          if (!message?.classList.contains("reader-chapter-link-error")) {
+            message = document.createElement("span");
+            message.className = "reader-chapter-link-error";
+            message.setAttribute("role", "status");
+            message.textContent = "（无法定位此书内链接）";
+            link.after(message);
+          }
+        }
+        return;
+      }
+      event.preventDefault();
+      const generation = readerContext.beginReaderNavigation();
+      try {
+        await activateChapter(chapter, generation, fragment);
+      } catch (error) {
+        readerContext.reportNavigationError(error, generation);
+      }
+    });
+    const chapterVirtualizer = VoiceOfMLReaderVirtual.createSectionVirtualizer({
+      limit: 12,
+      getLoaded: () => [...frame.querySelectorAll(":scope > .reader-epub-chapter")],
+      getIndex: article => Number(article.dataset.chapter),
+      getHeight: article => article.getBoundingClientRect().height,
+      canVirtualize: article => {
+        const rect = article.getBoundingClientRect(), view = readerContext.viewport.getBoundingClientRect();
+        const selection = window.getSelection();
+        return (rect.bottom < view.top - 800 || rect.top > view.bottom + 800) &&
+          !article.contains(document.activeElement) &&
+          !article.querySelector("mark.full-search-highlight") &&
+          !(selection && !selection.isCollapsed &&
+            selection.containsNode(article, true));
+      },
+      virtualize: (article, index, height) => {
+        loaded.delete(index);
+        const marker = ensureSentinel(chapterAt(index));
+        const style = getComputedStyle(article);
+        marker.classList.add("reader-chapter-placeholder");
+        marker.style.height = `${height}px`;
+        marker.style.marginTop = style.marginTop;
+        marker.style.marginBottom = style.marginBottom;
+        marker.setAttribute("aria-hidden", "true");
+        readerContext.chapterManifestObserver.unobserve(article);
+        readerContext.foliateScrollAnchors.unobserve(article);
+        for (const entry of readerContext.navigationState.tocEntries)
+          if (entry.chapterIndex === index) entry.target = null;
+        for (const image of article.querySelectorAll("img")) image.removeAttribute("src");
+        article.replaceWith(marker);
+        article._chapterSearchHead = null;
+      },
+      release: index => {
+        chapterBudget.release(retainedBytes.get(index));
+        retainedBytes.delete(index);
+      },
+      preserve: change => readerContext.foliateScrollAnchors.preserve(change)
+    });
+    function trimChapterWindow() {
+      if (chapterWindowReady) chapterVirtualizer.trim(chapterFocusIndex);
+    }
+    function chapterPrefetchIndices() {
+      if (document.hidden) return [];
+      // A fixed opening prefix keeps extra front matter within the DOM retention target.
+      const forwardCount = Math.max(chapterPrefetchCount, chapterPrefetchMaxCount + 1 - chapterFocusIndex);
+      const nearby = manifest.chapters.slice(Math.max(0, chapterFocusIndex - 2),
+        chapterFocusIndex + forwardCount);
+      const indices = [];
+      let bytes = 0;
+      for (const chapter of nearby) {
+        bytes += chapter.bytes;
+        if (chapter.index > chapterFocusIndex + chapterPrefetchCount && bytes > chapterPrefetchBytes) break;
+        if (!loaded.has(chapter.index)) indices.push(chapter.index);
+      }
+      return indices;
+    }
+    function refreshChapterWindow() {
+      chapterWindowFrame = 0;
+      if (!chapterWindowReady || readerContext.readerAbortController.signal.aborted) return;
+      const view = readerContext.viewport.getBoundingClientRect();
+      const rows = [...frame.querySelectorAll(":scope > [data-chapter]")];
+      const current = rows.find(row => {
+        const rect = row.getBoundingClientRect();
+        return rect.top <= view.top + 80 && rect.bottom > view.top + 80;
+      }) || rows.find(row => row.getBoundingClientRect().top > view.top);
+      if (current && !chapterNavigating) chapterFocusIndex = Number(current.dataset.chapter);
+      if (!chapterNavigating && current?.classList.contains("reader-chapter-sentinel") &&
+          current.getBoundingClientRect().top < view.bottom)
+        fetchChapter(chapterAt(chapterFocusIndex)).catch(() => {});
+      if (!chapterNavigating) chapterScheduler.prefetch(chapterPrefetchIndices());
+      readerContext.foliateScrollAnchors.whenIdle(trimChapterWindow);
+    }
+    function scheduleChapterWindow() {
+      if (!chapterWindowFrame) chapterWindowFrame = requestAnimationFrame(refreshChapterWindow);
+    }
+    function handleChapterVisibility() {
+      if (document.hidden) chapterScheduler.prefetch([]);
+      else scheduleChapterWindow();
+    }
+    readerContext.chapterManifestObserver = new IntersectionObserver(
+      scheduleChapterWindow,
+      { root: readerContext.viewport, rootMargin: "800px 0px" }
+    );
+    chapterPreviousObserver = new IntersectionObserver((entries) => {
+      if (!chapterWindowReady || chapterNavigating || readerContext.readerAbortController.signal.aborted) return;
+      for (const entry of entries) {
+        if (!entry.isIntersecting) continue;
+        const chapter = chapterAt(Number(entry.target.dataset.chapter));
+        if (chapter) fetchChapter(chapter).catch(() => {});
+      }
+    }, { root: readerContext.viewport });
+    readerContext.viewport.addEventListener("scroll", scheduleChapterWindow, { passive: true });
+    window.addEventListener("resize", scheduleChapterWindow);
+    document.addEventListener("visibilitychange", handleChapterVisibility);
+    let chapterCleaned = false;
+    readerContext.chapterManifestCleanup = () => {
+      if (chapterCleaned) return;
+      chapterCleaned = true;
+      chapterWindowReady = false;
+      cancelAnimationFrame(chapterWindowFrame);
+      readerContext.viewport.removeEventListener("scroll", scheduleChapterWindow);
+      window.removeEventListener("resize", scheduleChapterWindow);
+      document.removeEventListener("visibilitychange", handleChapterVisibility);
+      chapterScheduler.dispose();
+      chapterVirtualizer.dispose();
+      readerContext.chapterManifestObserver?.disconnect();
+      chapterPreviousObserver?.disconnect();
+      readerContext.chapterManifestObserver = null;
+      readerContext.chapterManifestLoader = null;
+      for (const bytes of retainedBytes.values()) chapterBudget.release(bytes);
+      retainedBytes.clear();
+      loaded.clear();
+    };
+    readerContext.trackReaderResource(readerContext.chapterManifestCleanup);
+    readerContext.chapterManifestLoader = async (index) => {
+      const chapter = chapterAt(index);
+      if (!chapter) return null;
+      chapterFocusIndex = index;
+      chapterNavigating++;
+      try { await fetchChapter(chapter, true, chapterWindowReady); }
+      finally { chapterNavigating--; }
+      return frame.querySelector(`.reader-epub-chapter[data-chapter="${index}"]`);
+    };
+    readerContext.chapterManifestLoader.count = manifest.chapters.length;
+    setChapterToc();
+    await readerContext.getInitialReaderRestoration();
+    const savedChapter = Number(readerContext.readerRestorationEntry?.chapterIndex) - 1;
+    const initialChapter = Number.isInteger(savedChapter)
+      ? Math.max(0, Math.min(manifest.chapters.length - 1, savedChapter))
+      : 0;
+    chapterFocusIndex = manifest.chapters[initialChapter].index;
+    if (initialChapter > 0) ensureSentinel(manifest.chapters[initialChapter - 1], true);
+    try {
+      const firstChapter = fetchChapter(manifest.chapters[initialChapter]);
+      chapterScheduler.prefetch(chapterPrefetchIndices());
+      await firstChapter;
+    } catch (error) {
+      if (readerContext.readerRestorationEntry?.chapterIndex == null) throw error;
+      throw Object.assign(new Error("阅读位置恢复失败，原进度已保留，请重试加载。", { cause: error }), {
+        code: "READER_RESTORE"
+      });
+    }
+    chapterWindowReady = true;
+    if (readerContext.isReaderGenerationCurrent("navigation", openingGeneration)) readerContext.foliateScrollAnchors.invalidate();
+    for (const article of frame.querySelectorAll(".reader-epub-chapter")) readerContext.foliateScrollAnchors.observe(article);
+      frame.style.overflowAnchor = "none";
+    scheduleChapterWindow();
+    readerContext.assertReaderActive();
+    readerContext.markReaderContentReady();
+    readerContext.status.textContent = `EPUB · ${manifest.chapters.length} 章`;
+  }
+
+  function captureChapterPosition() {
+    if (readerContext.capability.mode !== "epub-chapters") return null;
+    const marker = readerContext.viewport.getBoundingClientRect().top + 8;
+    const chapters = [...readerContext.content.querySelectorAll(".reader-epub-chapter")];
+    const chapter =
+      chapters.find((node) => node.getBoundingClientRect().bottom > marker) ||
+      chapters[chapters.length - 1];
+    return chapter
+      ? {
+          chapterIndex: Number(chapter.dataset.chapter),
+          chapterManifest: readerContext.chapterManifestUrl || readerContext.sourceUrl,
+          chapterOffset: marker - chapter.getBoundingClientRect().top
+        }
+      : null;
+  }
+
+  async function restoreChapterPosition(entry, generation) {
+    if (
+      /-epub-chapters-v5\//.test(readerContext.chapterManifestUrl || readerContext.sourceUrl) &&
+      entry.chapterManifest !== (readerContext.chapterManifestUrl || readerContext.sourceUrl)
+    ) return false;
+    if (!readerContext.chapterManifestLoader || !Number.isInteger(entry.chapterIndex)) return false;
+    const chapter = await readerContext.chapterManifestLoader(entry.chapterIndex);
+    if (!chapter?.isConnected || !readerContext.isReaderGenerationCurrent("navigation", generation)) return false;
+    readerContext.viewport.scrollTop +=
+      chapter.getBoundingClientRect().top -
+      readerContext.viewport.getBoundingClientRect().top -
+      8 +
+      (Number(entry.chapterOffset) || 0);
+    readerContext.foliateScrollAnchors.remember();
+    readerContext.syncHeadingLocation();
+    readerContext.updateProgressTools();
+    readerContext.scheduleSave();
+    return true;
+  }
+
+  return {
+    renderChapterManifest,
+    captureChapterPosition,
+    restoreChapterPosition
+  };
+}

static/reader/formats/reader-docx-format.mjs

@@ -0,0 +1,129 @@
+export function createReaderDocxFormat(readerContext) {
+  async function renderDocx(prepared) {
+    const bytes = await readerContext.readPreparedBytes(prepared.response, prepared.engines);
+    readerContext.assertReaderActive();
+    VoiceOfMLReaderSecurity.inspectZip(bytes, {
+      ...VoiceOfMLReaderSecurity.LIMITS,
+      archiveCompressedBytes: VoiceOfMLReaderSecurity.LIMITS.documentBytes
+    });
+    const styles = document.createElement("div");
+    styles.className = "docx-styles";
+    const body = document.createElement("div");
+    body.className = "docx-body";
+    readerContext.content.append(styles, body);
+    const options = {
+      className: "reader-docx",
+      inWrapper: true,
+      breakPages: true,
+      ignoreLastRenderedPageBreak: false,
+      useBase64URL: false,
+      renderHeaders: true,
+      renderFooters: true,
+      renderFootnotes: true,
+      renderEndnotes: true,
+      renderChanges: false,
+      renderComments: false,
+      renderAltChunks: false,
+      debug: false
+    };
+    const docxDocument = await readerContext.awaitReader(docx.parseAsync(bytes, options));
+    readerContext.assertReaderActive();
+    const urls = new Set(), urlsByPath = new Map(), contentTypes = docxDocument.contentTypes || [];
+    let released = false;
+    const release = () => {
+      released = true;
+      for (const url of urls) URL.revokeObjectURL(url);
+      urls.clear();
+      urlsByPath.clear();
+    };
+    const untrack = readerContext.trackReaderResource(release);
+    readerContext.memoizeDocxAssets(docxDocument, () => released);
+    // Own this parsed document's images, fonts and numbering assets only.
+    docxDocument.blobToURL = (blob, path) => {
+      if (released || !blob) return null;
+      if (path && urlsByPath.has(path)) return urlsByPath.get(path);
+      const type = path && contentTypes.find(entry => entry.partName === path ||
+        (entry.extension && path.endsWith(`.${entry.extension}`)));
+      const url = URL.createObjectURL(type ? new Blob([blob], {type:type.contentType}) : blob);
+      if (typeof url === "string" && url.startsWith("blob:")) {
+        urls.add(url);
+        if (path) urlsByPath.set(path, url);
+      }
+      return url;
+    };
+    try {
+      const nodes = await readerContext.awaitReader(docx.renderDocument(docxDocument, options));
+      readerContext.assertReaderActive();
+      for (const node of nodes) (node.nodeName === "STYLE" ? styles : body).appendChild(node);
+    } catch (error) {
+      release();
+      untrack();
+      throw error;
+    }
+    readerContext.assertReaderActive();
+    body.classList.toggle("reader-document-dark", readerContext.readerTheme === "dark");
+    if (!(body.textContent || "").trim() && !body.querySelector("img, table, svg, canvas")) {
+      release();
+      untrack();
+      throw new Error("DOCX rendered no supported content");
+    }
+    const pages = [...body.querySelectorAll(":scope > .reader-docx-wrapper > section.reader-docx")];
+    readerContext.docxPageNodes = pages;
+    if (pages.length) {
+      readerContext.updateDocumentState({ pageCount: pages.length });
+      readerContext.pageInput.max = String(readerContext.documentState.pageCount);
+      document.querySelector("#page-total").textContent = `/ ${readerContext.documentState.pageCount}`;
+      document.querySelector(".page-controls").hidden = false;
+      pages.forEach((page, index) => {
+        page.classList.add("reader-docx-page");
+        page.dataset.page = String(index + 1);
+        page.style.setProperty("--reader-docx-height", page.style.minHeight || page.style.height || "1123px");
+      });
+      readerContext.setToc(readerContext.headingTocEntries(body));
+    }
+    for (const link of body.querySelectorAll("a[href]")) {
+      const href = link.getAttribute("href") || "";
+      if (!href.startsWith("#") && !/^https?:\/\//i.test(href)) link.removeAttribute("href");
+      else if (!href.startsWith("#")) {
+        link.target = "_blank";
+        link.rel = "noopener noreferrer";
+      }
+    }
+    readerContext.markReaderContentReady();
+    readerContext.status.textContent = readerContext.documentState.pageCount ? `${readerContext.documentState.pageCount} 页` : "DOCX";
+  }
+
+  function memoizeDocxResource(load, keyFor, isReleased) {
+    const pending = new Map();
+    return (...args) => {
+      if (isReleased()) return Promise.resolve(null);
+      const key = keyFor(...args);
+      if (!key) return load(...args);
+      if (!pending.has(key)) {
+        const task = Promise.resolve().then(() => isReleased() ? null : load(...args));
+        pending.set(key, task);
+        task.catch(() => { if (pending.get(key) === task) pending.delete(key); });
+      }
+      return pending.get(key);
+    };
+  }
+
+  function memoizeDocxAssets(doc, isReleased) {
+    if (typeof doc.getPathById !== "function") return;
+    for (const [name, part] of [["loadDocumentImage", "documentPart"],
+      ["loadNumberingImage", "numberingPart"], ["loadFont", "fontTablePart"]]) {
+      if (typeof doc[name] !== "function") continue;
+      const original = doc[name].bind(doc);
+      doc[name] = readerContext.memoizeDocxResource(original, (id, parameter) => {
+        const path = doc.getPathById(name === "loadDocumentImage" ? parameter || doc[part] : doc[part], id);
+        return path ? (name === "loadFont" ? `${path}\u0000${parameter}` : path) : null;
+      }, isReleased);
+    }
+  }
+
+  return {
+    renderDocx,
+    memoizeDocxResource,
+    memoizeDocxAssets
+  };
+}

static/reader/formats/reader-foliate-format.mjs

@@ -0,0 +1,637 @@
+export function createReaderFoliateFormat(readerContext) {
+  function foliateSectionRoot(article) {
+    return article?.shadowRoot || article;
+  }
+
+  function foliateSectionQuery(article, selector) {
+    return readerContext.foliateSectionRoot(article)?.querySelector(selector) || null;
+  }
+
+  function foliateSectionCandidates() {
+    return [
+      ...readerContext.content.querySelectorAll(
+        ".foliate-continuous > article[data-section]:not(.foliate-section-placeholder), .reader-epub-chapter"
+      )
+    ].flatMap((article) => [
+      article,
+      ...readerContext.foliateSectionRoot(article).querySelectorAll(
+        ":is(h1,h2,h3,h4,h5,h6,p,li,blockquote,pre,img,table)"
+      )
+    ]);
+  }
+
+  function syncFoliateScrollLocation() {
+    if (!readerContext.foliateContinuous || !readerContext.navigationState.tocEntries.length) return;
+    const rows = [...document.querySelectorAll(".foliate-continuous article[data-section]")],
+      top = readerContext.viewport.getBoundingClientRect().top + 80;
+    let sectionIndex = -1,
+      sectionNode = null;
+    for (const row of rows)
+      if (row.getBoundingClientRect().top <= top) {
+        sectionIndex = Number(row.dataset.section);
+        sectionNode = row;
+      }
+    if (!sectionNode) return;
+    let best = -1;
+    let bestPosition = -Infinity;
+    for (const [index, entry] of readerContext.navigationState.tocEntries.entries()) {
+      if (entry.sectionIndex !== sectionIndex) continue;
+      let position = sectionNode.getBoundingClientRect().top;
+      if (entry.anchor) {
+        const root = readerContext.foliateSectionRoot(sectionNode);
+        const anchor = entry.anchor({
+          getElementById: (id) => root.querySelector(`[id="${CSS.escape(id)}"]`),
+          querySelector: (selector) => root.querySelector(selector)
+        });
+        if (anchor) position = anchor.getBoundingClientRect().top;
+      }
+      if (entry.fragment) {
+        const anchor = readerContext.foliateSectionQuery(
+          sectionNode,
+          `[id="${CSS.escape(entry.fragment)}"], [name="${CSS.escape(entry.fragment)}"]`
+        );
+        if (anchor) position = anchor.getBoundingClientRect().top;
+      }
+      if (position <= top && (position > bestPosition || (position === bestPosition && index > best))) {
+        best = index;
+        bestPosition = position;
+      }
+    }
+    if (best < 0) {
+      let firstPosition = Infinity;
+      for (const [index, entry] of readerContext.navigationState.tocEntries.entries()) {
+        if (entry.sectionIndex !== sectionIndex) continue;
+        const position = entry.target?.getBoundingClientRect?.().top;
+        if (Number.isFinite(position) && position < firstPosition) {
+          best = index;
+          firstPosition = position;
+        }
+      }
+    }
+    if (best >= 0 && best !== readerContext.navigationState.currentChapterIndex) {
+      readerContext.updateNavigationState({ currentChapterIndex: best });
+      readerContext.updateTocCurrentMark();
+      readerContext.updateProgressTools();
+    }
+  }
+
+  function refreshFoliateWindow() {
+    readerContext.foliateWindowFrame = 0;
+    readerContext.foliateSectionLoader?.refresh?.();
+  }
+
+  function scheduleFoliateWindowRefresh() {
+    if (!readerContext.foliateWindowFrame) readerContext.foliateWindowFrame = requestAnimationFrame(readerContext.refreshFoliateWindow);
+  }
+
+  function trimFoliateSections() {
+    if (!readerContext.foliateContinuous || !readerContext.foliateSectionVirtualizer) return;
+    const marker = readerContext.viewport.getBoundingClientRect().top + 80,
+      rows = [...document.querySelectorAll(".foliate-continuous article[data-section]")],
+      current =
+        rows.find((row) => {
+          const rect = row.getBoundingClientRect();
+          return rect.top <= marker && rect.bottom > marker;
+        }) || rows.find((row) => row.getBoundingClientRect().top > marker);
+    if (current) readerContext.foliateSectionVirtualizer.trim(Number(current.dataset.section));
+  }
+
+  function scheduleFoliateScrollSync() {
+    if (readerContext.foliateScrollFrame) return;
+    readerContext.foliateScrollFrame = requestAnimationFrame(() => {
+      readerContext.foliateScrollFrame = 0;
+      readerContext.syncFoliateScrollLocation();
+      readerContext.foliateScrollAnchors.whenIdle(readerContext.trimFoliateSections);
+    });
+  }
+
+  async function activateFoliateTocEntry(entry, generation = readerContext.beginReaderNavigation()) {
+    const book = readerContext.epubRendition?.book,
+      href = String(entry.href || ""),
+      target = await readerContext.epubRendition?.book?.resolveHref(href);
+    if (!book || !readerContext.isReaderGenerationCurrent("navigation", generation)) return false;
+    const section = target && book.sections[target.index],
+      sections = book.sections.filter((item) => item.linear !== "no"),
+      visibleIndex = section ? sections.indexOf(section) : -1;
+    if (!section || visibleIndex < 0 || !readerContext.foliateSectionLoader) return false;
+    let node = await readerContext.foliateSectionLoader(visibleIndex);
+    if (!readerContext.isReaderGenerationCurrent("navigation", generation)) return false;
+    // Background neighbors are not part of a demanded TOC destination.
+    await readerContext.waitForReader(0, true);
+    if (!readerContext.isReaderGenerationCurrent("navigation", generation)) return false;
+    if (!node?.isConnected) node = await readerContext.foliateSectionLoader(visibleIndex);
+    if (!node?.isConnected || !readerContext.isReaderGenerationCurrent("navigation", generation)) return false;
+    const root = readerContext.foliateSectionRoot(node),
+      anchorDocument = {
+        getElementById: (id) => root.querySelector(`[id="${CSS.escape(id)}"]`),
+        querySelector: (selector) => root.querySelector(selector)
+      };
+    let anchor = null;
+    try {
+      anchor = typeof target.anchor === "function" ? target.anchor(anchorDocument) : null;
+    } catch (_) {}
+    if (!anchor) {
+      const fragment = href.split("#")[1] || "",
+        id = fragment ? decodeURIComponent(fragment) : "";
+      anchor = id ? root.querySelector(`[id="${CSS.escape(id)}"], [name="${CSS.escape(id)}"]`) : null;
+    }
+    const destination = anchor || node;
+    readerContext.foliateScrollAnchors.invalidate();
+    readerContext.viewport.scrollTop = Math.max(
+      0,
+      readerContext.viewport.scrollTop +
+        destination.getBoundingClientRect().top -
+        readerContext.viewport.getBoundingClientRect().top -
+        8
+    );
+    readerContext.syncFoliateScrollLocation();
+    readerContext.updateTocCurrentMark();
+    readerContext.updateProgressTools();
+    readerContext.scheduleSave();
+    readerContext.setReaderPanelOpen(false, true);
+    readerContext.foliateScrollAnchors.remember();
+    return true;
+  }
+
+  function cloneFoliateDocument(source) {
+    const doc = source.cloneNode(true),
+      original = source.createTreeWalker(source, NodeFilter.SHOW_TEXT),
+      cloned = doc.createTreeWalker(doc, NodeFilter.SHOW_TEXT);
+    const sourceNodes = new WeakMap();
+    while (original.nextNode() && cloned.nextNode())
+      sourceNodes.set(cloned.currentNode, original.currentNode);
+    return { doc: readerContext.sanitizeEpubDocument(doc), sourceNodes };
+  }
+
+  function foliateSearchAnchor(source, sourceNodes, body, renderedBody) {
+    const sourceWalker = body.ownerDocument.createTreeWalker(body, NodeFilter.SHOW_TEXT);
+    const pairs = [];
+    let offset = 0;
+    while (sourceWalker.nextNode()) {
+      const node = sourceWalker.currentNode;
+      const original = sourceNodes.get(node);
+      if (original) pairs.push({ original, offset });
+      offset += node.length;
+    }
+    return (anchor) => {
+      const range = anchor(source);
+      if (!range || typeof range.intersectsNode !== "function") return null;
+      const intervals = [];
+      for (const { original, offset } of pairs) {
+        if (!range.intersectsNode(original)) continue;
+        const start = range.startContainer === original ? range.startOffset : 0;
+        const end = range.endContainer === original ? range.endOffset : original.length;
+        if (end > start) intervals.push({ start: offset + start, end: offset + end });
+      }
+      const walker = document.createTreeWalker(renderedBody, NodeFilter.SHOW_TEXT),
+        selected = [];
+      let offset = 0;
+      while (walker.nextNode()) {
+        const node = walker.currentNode,
+          end = offset + node.length;
+        for (const interval of intervals)
+          if (interval.start < end && interval.end > offset)
+            selected.push({
+              node,
+              start: Math.max(0, interval.start - offset),
+              end: Math.min(node.length, interval.end - offset)
+            });
+        offset = end;
+      }
+      return selected;
+    };
+  }
+
+  async function settleReaderImages(root, timeoutMs = 2500) {
+    readerContext.assertReaderActive();
+    const images = [...root.querySelectorAll("img[src],img[srcset]")];
+    if (!images.length) return;
+    let timeout = 0, active = true;
+    const cleanups = new Set();
+    const decoded = Promise.allSettled(
+      images.map(async (image) => {
+        // Sections are prepared off-DOM; lazy images cannot enter a viewport yet.
+        image.loading = "eager";
+        image.decoding = "async";
+        if (!image.complete) await new Promise((resolve) => {
+          const finish = () => {
+            image.removeEventListener("load", finish);
+            image.removeEventListener("error", finish);
+            cleanups.delete(finish);
+            resolve();
+          };
+          cleanups.add(finish);
+          image.addEventListener("load", finish, { once: true });
+          image.addEventListener("error", finish, { once: true });
+          if (image.complete) finish();
+        });
+        if (active) {
+          try { await image.decode?.(); } catch (_) {}
+        }
+      })
+    );
+    try {
+      await readerContext.awaitReader(
+        Promise.race([
+          decoded,
+          new Promise((resolve) => {
+            timeout = setTimeout(resolve, timeoutMs);
+          })
+        ])
+      );
+    } finally {
+      active = false;
+      clearTimeout(timeout);
+      for (const cleanup of cleanups) cleanup();
+    }
+  }
+
+  function rewriteFoliateResources(doc, section) {
+    const safeEmbeddedValue = (value) =>
+      /^(?:blob:|data:image\/(?:gif|png|jpe?g|webp);)/i.test(String(value || "").trim());
+    const archiveResourceUrl = (value) => {
+      const raw = String(value || "").trim();
+      if (!raw || raw.startsWith("#") || raw.includes("#") || safeEmbeddedValue(raw))
+        return safeEmbeddedValue(raw) ? raw : null;
+      if (/^(?:[a-z][a-z0-9+.-]*:|\/\/|\/)/i.test(raw)) return null;
+      try {
+        const resolved = String(
+          (section.resolveResourceHref
+            ? section.resolveResourceHref(raw)
+            : section.resolveHref?.(raw)) || ""
+        );
+        if (
+          !resolved ||
+          /^(?:[a-z][a-z0-9+.-]*:|\/\/|\/)/i.test(resolved) ||
+          /[\\\x00]/.test(resolved) ||
+          resolved.split("/").some((part) => !part || part === "." || part === "..")
+        )
+          return null;
+        return `/api/reader-resource?book=${encodeURIComponent(readerContext.sourceUrl)}&path=${encodeURIComponent(resolved)}`;
+      } catch (_) {
+        return null;
+      }
+    };
+    for (const element of doc.querySelectorAll(
+      "img[src],source[src],audio[src],video[src],video[poster]"
+    )) {
+      for (const name of ["src", "poster"])
+        if (element.hasAttribute(name)) {
+          const safe = archiveResourceUrl(element.getAttribute(name));
+          if (safe) element.setAttribute(name, safe);
+          else element.removeAttribute(name);
+        }
+    }
+    for (const element of doc.querySelectorAll("[srcset]")) {
+      const value = element.getAttribute("srcset") || "";
+      const candidates = value
+        .split(",")
+        .map((part) => {
+          const [raw, ...descriptor] = part.trim().split(/\s+/);
+          const safe = archiveResourceUrl(raw);
+          return safe ? [safe, ...descriptor].join(" ") : null;
+        })
+        .filter(Boolean);
+      if (candidates.length) element.setAttribute("srcset", candidates.join(", "));
+      else element.removeAttribute("srcset");
+    }
+    for (const image of doc.querySelectorAll("image")) {
+      const value =
+        image.getAttributeNS("http://www.w3.org/1999/xlink", "href") ||
+        image.getAttribute("xlink:href") ||
+        image.getAttribute("href");
+      const safe = archiveResourceUrl(value);
+      if (safe) {
+        image.setAttributeNS("http://www.w3.org/1999/xlink", "xlink:href", safe);
+        image.setAttribute("href", safe);
+      } else {
+        image.removeAttributeNS("http://www.w3.org/1999/xlink", "href");
+        image.removeAttribute("xlink:href");
+        image.removeAttribute("href");
+      }
+    }
+    for (const link of doc.querySelectorAll("a[href]")) {
+      const href = link.getAttribute("href") || "";
+      if (/\.(?:gif|png|jpe?g|webp)$/i.test(href)) {
+        const resource = archiveResourceUrl(href);
+        if (resource) {
+          link.setAttribute("href", resource);
+          link.target = "_blank";
+          link.rel = "noopener noreferrer";
+        }
+      }
+      if (/^(?:https?:|mailto:|tel:)/i.test(href)) {
+        link.target = "_blank";
+        link.rel = "noopener noreferrer";
+      }
+    }
+  }
+
+  async function createFoliateSection(section, index) {
+    const signal = arguments[2] || readerContext.readerAbortController.signal;
+    const priority = arguments[3] || "high";
+    const source = await readerContext.awaitReader(section.createDocument(), signal);
+    const { doc, sourceNodes } = readerContext.cloneFoliateDocument(source);
+    readerContext.assertReaderActive();
+    readerContext.rewriteFoliateResources(doc, section);
+    const styles = [...doc.querySelectorAll("style,link")].map((node) => node.cloneNode(true));
+    for (const node of doc.querySelectorAll("style,link")) node.remove();
+    const article = document.createElement("article");
+    article.dataset.section = String(index);
+    const shadow = article.attachShadow({ mode: "open" }),
+      baseStyle = document.createElement("style"),
+      sectionBody = document.createElement("div");
+    // Chapter styles live in a shadow root, so document-level preferences cannot reach them.
+    baseStyle.textContent = `
+    :host { display: block; color: inherit; }
+    * { box-sizing: border-box; }
+    .reader-section-body { display: block; color: inherit; line-height: inherit; }
+    .reader-section-body > :first-child { margin-top: 0 !important; }
+    :host(.reader-document-dark) .reader-section-body,
+    :host(.reader-document-dark) .reader-section-body :where(:not(svg, svg *, img, canvas, video, audio, math, math *)) {
+      color: inherit !important;
+      background-color: transparent !important;
+      border-color: #4a5056 !important;
+      text-shadow: none !important;
+    }
+    a { color: var(--reader-book-link) !important; }
+    :host(.reader-document-dark) .reader-section-body a { color: var(--reader-book-link) !important; }
+    img, svg, video { max-width: 100%; height: auto; }
+    mark.full-search-highlight { background: #ffd54f; color: #111; }
+    :host(.reader-document-dark) .reader-section-body mark.full-search-highlight { background: #ffd54f !important; color: #111 !important; }
+    @media (prefers-contrast: more) {
+      .reader-section-body a[href] { text-decoration: underline !important; }
+      .reader-section-body mark.full-search-highlight { outline: 2px solid currentColor; }
+    }
+  `;
+    sectionBody.className = "reader-section-body";
+    const body = readerContext.epubContentBody(doc);
+    // Import the sanitized nodes directly. Serializing and reparsing legacy
+    // nested anchors lets HTML's adoption rules reorder footnotes and citations.
+    if (body)
+      sectionBody.append(...[...body.childNodes].map((node) => document.importNode(node, true)));
+    article._resolveSearchAnchor = readerContext.foliateSearchAnchor(source, sourceNodes, body, sectionBody);
+    shadow.append(baseStyle, ...styles, sectionBody);
+    for (const image of sectionBody.querySelectorAll("img")) {
+      image.loading = priority === "high" ? "eager" : "lazy";
+      image.fetchPriority = priority;
+      image.decoding = "async";
+    }
+    signal.throwIfAborted();
+    readerContext.assertReaderActive();
+    article.classList.toggle("reader-document-dark", readerContext.readerTheme === "dark");
+    return article;
+  }
+
+  function setupFoliateWindow(stream, sections) {
+    let focus = readerContext.initialReaderTargetSection ?? 0, targetPending = false;
+    stream.style.overflowAnchor = "none";
+    const existing = index => stream.querySelector(`article[data-section="${index}"]:not(.foliate-section-placeholder)`);
+    const ensurePlaceholder = index => {
+      if (!sections[index] || stream.querySelector(`article[data-section="${index}"]`)) return;
+      const placeholder = document.createElement("article");
+      placeholder.className = "foliate-section-placeholder";
+      placeholder.dataset.section = String(index);
+      placeholder.style.setProperty("--foliate-placeholder-height", `${Math.max(400, readerContext.viewport.clientHeight)}px`);
+      placeholder.setAttribute("aria-label", `加载第 ${index + 1} 节`);
+      const next = [...stream.children].find(node => Number(node.dataset.section) > index);
+      readerContext.foliateScrollAnchors.preserve(() => stream.insertBefore(placeholder, next || null));
+      observer.observe(placeholder);
+    };
+    const warm = () => {
+      const indices = [];
+      for (const offset of [-1, 1, -2, 2, 3, 4, 5, 6]) {
+        const index = focus + offset;
+        if (sections[index] && !existing(index)) indices.push(index);
+      }
+      scheduler.prefetch(document.hidden ? [] : indices);
+    };
+    const refresh = () => {
+      if (readerContext.readerAbortController.signal.aborted) return;
+      const marker = readerContext.viewport.getBoundingClientRect().top + 80;
+      const rows = [...stream.children];
+      const current = rows.find(node => {
+        const rect = node.getBoundingClientRect();
+        return rect.top <= marker && rect.bottom > marker;
+      }) || rows.find(node => node.getBoundingClientRect().top > marker);
+      const index = current ? Number(current.dataset.section) : focus;
+      if (targetPending && index !== focus && !readerContext.foliateScrollAnchors.scrolling) return;
+      targetPending = false;
+      focus = index;
+      if (current?.classList.contains("foliate-section-placeholder")) scheduler.load(index).catch(() => {});
+      warm();
+      readerContext.foliateScrollAnchors.whenIdle(readerContext.trimFoliateSections);
+    };
+    const observer = new IntersectionObserver(readerContext.scheduleFoliateWindowRefresh,
+      { root: readerContext.viewport, rootMargin: `${readerContext.FOLIATE_PREFETCH_MARGIN}px` });
+    readerContext.foliateSectionObserver = observer;
+    const commitSection = (index, article) =>
+        readerContext.foliateScrollAnchors.preserve(() => {
+          const placeholder = stream.querySelector(
+              `article.foliate-section-placeholder[data-section="${index}"]`
+            ),
+            next = [...stream.querySelectorAll("article[data-section]")].find(
+              (item) => Number(item.dataset.section) > index
+            );
+          if (placeholder) {
+            observer.unobserve(placeholder);
+            placeholder.replaceWith(article);
+          } else stream.insertBefore(article, next || null);
+          observer.observe(article);
+          readerContext.foliateScrollAnchors.observe(article);
+          ensurePlaceholder(index - 1);
+          ensurePlaceholder(index + 1);
+          return article;
+        });
+    const scheduler = readerContext.readerRuntime.track(VoiceOfMLReaderChapters.createChapterScheduler({
+      create: async (index, signal, priority) => {
+        const article = await readerContext.createFoliateSection(sections[index], index, signal, priority);
+        signal.throwIfAborted();
+          if (existing(index)) return existing(index);
+          return commitSection(index, article);
+      }
+    }));
+    readerContext.foliateChapterRepository = VoiceOfMLReaderChapters.createChapterRepository({
+      count: sections.length, find: existing, create: index => scheduler.load(index)
+    });
+    readerContext.foliateSectionVirtualizer = VoiceOfMLReaderVirtual.createSectionVirtualizer({
+      limit: readerContext.FOLIATE_LOADED_SECTION_LIMIT,
+      getLoaded: () => [
+        ...stream.querySelectorAll("article[data-section]:not(.foliate-section-placeholder)")
+      ],
+      getIndex: (article) => Number(article.dataset.section),
+      getHeight: (article) => article.getBoundingClientRect().height,
+      canVirtualize: (article) => {
+        const rect = article.getBoundingClientRect(),
+          viewportRect = readerContext.viewport.getBoundingClientRect();
+        return (
+          rect.bottom < viewportRect.top - readerContext.FOLIATE_PREFETCH_MARGIN ||
+          rect.top > viewportRect.bottom + readerContext.FOLIATE_PREFETCH_MARGIN
+        ) && !article.contains(document.activeElement) && !article.shadowRoot?.activeElement &&
+          !readerContext.foliateSectionRoot(article).querySelector("mark.full-search-highlight") &&
+          ![window.getSelection(), article.shadowRoot?.getSelection?.()].some(selection =>
+            selection && !selection.isCollapsed && (selection.containsNode(article, true) ||
+              selection.anchorNode?.getRootNode() === article.shadowRoot));
+      },
+      virtualize: (article, index, height) => {
+        const placeholder = document.createElement("article");
+        placeholder.className = "foliate-section-placeholder";
+        placeholder.dataset.section = String(index);
+        placeholder.style.setProperty("--foliate-placeholder-height", `${height}px`);
+        placeholder.setAttribute("aria-hidden", "true");
+        observer.unobserve(article);
+        readerContext.foliateScrollAnchors.unobserve(article);
+        for (const image of readerContext.foliateSectionRoot(article).querySelectorAll("img")) {
+          image.removeAttribute("src");
+          image.removeAttribute("srcset");
+        }
+        article._resolveSearchAnchor = null;
+        article.replaceWith(placeholder);
+        observer.observe(placeholder);
+        return placeholder;
+      },
+      release: (index) => readerContext.foliateChapterRepository.release(index),
+      preserve: (change) => readerContext.foliateScrollAnchors.preserve(change)
+    });
+    readerContext.foliateSectionLoader = index => {
+      focus = index;
+      targetPending = true;
+      const task = existing(index) ? Promise.resolve(existing(index)) : scheduler.load(index, true, true);
+      warm();
+      return task;
+    };
+    readerContext.foliateSectionLoader.refresh = refresh;
+    readerContext.foliateSectionSettler = () => readerContext.waitForReader(0, true);
+    const scroll = readerContext.scheduleFoliateWindowRefresh;
+    readerContext.viewport.addEventListener("scroll", scroll, { passive: true });
+    document.addEventListener("visibilitychange", scroll);
+    readerContext.trackReaderResource(() => {
+      readerContext.viewport.removeEventListener("scroll", scroll);
+      document.removeEventListener("visibilitychange", scroll);
+    });
+  }
+
+  async function foliateTocEntries(view, sections) {
+    readerContext.assertReaderActive();
+    const entries = [];
+    const append = (items, depth = 0) => {
+      for (const item of items || []) {
+        const href = item?.href ? String(item.href) : "";
+        if (href || item?.label)
+          entries.push({
+            label: item.label || "未命名章节",
+            href,
+            depth,
+            group: !href,
+            activate: () => view.goTo(href)
+          });
+        append(item.subitems, depth + 1);
+      }
+    };
+    append(view.book.toc);
+    const sectionIndices = new Map();
+    for (const [index, section] of sections.entries())
+      if (!sectionIndices.has(section)) sectionIndices.set(section, index);
+    let next = 0, yieldDeadline = performance.now() + 8, yieldTask = null;
+    const resolveEntries = async () => {
+      while (next < entries.length) {
+        readerContext.assertReaderActive();
+        if (yieldTask || performance.now() >= yieldDeadline) {
+          yieldTask ||= readerContext.waitForReader().finally(() => {
+            yieldTask = null;
+            yieldDeadline = performance.now() + 8;
+          });
+          await yieldTask;
+          continue;
+        }
+        const entry = entries[next++];
+        if (entry.group) {
+          entry.sectionIndex = -1;
+          entry.fragment = "";
+          continue;
+        }
+        try {
+          const target = await view.book.resolveHref(entry.href),
+            section = target && view.book.sections[target.index];
+          readerContext.assertReaderActive();
+          entry.sectionIndex = section ? sectionIndices.get(section) ?? -1 : -1;
+          entry.anchor = typeof target?.anchor === "function" ? target.anchor : null;
+          const fragment = entry.href.split("#")[1] || "";
+          entry.fragment = fragment ? decodeURIComponent(fragment) : "";
+        } catch (_) {
+          readerContext.assertReaderActive();
+          entry.sectionIndex = -1;
+          entry.fragment = "";
+        }
+      }
+    };
+    await readerContext.awaitReader(Promise.all(Array.from({ length: Math.min(8, entries.length) }, resolveEntries)));
+    readerContext.assertReaderActive();
+    return entries;
+  }
+
+  async function renderFoliate() {
+    const prepared = readerContext.prepareReaderDocument([import("/static/foliate-reader/view.js")]);
+    const [response, bytes] = await Promise.all([prepared.response,readerContext.readPreparedBytes(
+      prepared.response,prepared.engines,VoiceOfMLReaderSecurity.LIMITS.archiveCompressedBytes)]);
+    readerContext.assertReaderActive();
+    if (VoiceOfMLReaderSecurity.isZipContainer(readerContext.extension, bytes))
+      VoiceOfMLReaderSecurity.inspectZip(bytes);
+    const view = document.createElement("foliate-view"),
+      stream = document.createElement("div");
+    view.className = "foliate-reader-view";
+    stream.className = "foliate-continuous";
+    readerContext.content.replaceChildren(readerContext.loadingIndicator, view, stream);
+    readerContext.epubRendition = view;
+    await view.open(
+      new File([bytes], new URL(readerContext.sourceUrl).pathname.split("/").pop() || "book.epub", {
+        type: response.headers.get("content-type") || "application/epub+zip"
+      })
+    );
+    readerContext.assertReaderActive();
+    readerContext.epubBook = view.book;
+    view.style.display = "none";
+    const sections = view.book.sections.filter((section) => section.linear !== "no");
+    await readerContext.getInitialReaderRestoration();
+    const savedSection = Number(readerContext.readerRestorationEntry?.foliateSection);
+    const initialSection = Number.isInteger(savedSection)
+      ? Math.max(0, Math.min(sections.length - 1, savedSection))
+      : 0;
+    readerContext.initialReaderTargetSection = readerContext.readerRestorationEntry?.foliateSection == null ? null : initialSection;
+    readerContext.setupFoliateWindow(stream, sections);
+    if (sections[initialSection]) await readerContext.foliateChapterRepository.load(initialSection);
+    if (initialSection > 0) await readerContext.foliateChapterRepository.load(initialSection - 1);
+    readerContext.assertReaderActive();
+    // Resolving every TOC href can be expensive for large books. The first
+    // chapter is already visible, so finish the opening path before enriching
+    // the navigation panel in the background.
+    readerContext.foliateTocEntries(view, sections)
+      .then((entries) => {
+        if (entries.length && !readerContext.readerAbortController.signal.aborted) readerContext.setToc(entries);
+      })
+      .catch(() => {});
+    readerContext.scheduleFoliateScrollSync();
+    readerContext.markReaderContentReady();
+    readerContext.status.textContent = "EPUB";
+  }
+
+  return {
+    foliateSectionRoot,
+    foliateSectionQuery,
+    foliateSectionCandidates,
+    syncFoliateScrollLocation,
+    refreshFoliateWindow,
+    scheduleFoliateWindowRefresh,
+    trimFoliateSections,
+    scheduleFoliateScrollSync,
+    activateFoliateTocEntry,
+    cloneFoliateDocument,
+    foliateSearchAnchor,
+    settleReaderImages,
+    rewriteFoliateResources,
+    createFoliateSection,
+    setupFoliateWindow,
+    foliateTocEntries,
+    renderFoliate
+  };
+}

static/reader/formats/reader-format-controller.mjs

@@ -0,0 +1,280 @@
+export function createReaderFormatController(readerContext) {
+  function disposeFormatResources(mode) {
+    if (mode === "epub-chapters") {
+      readerContext.chapterManifestCleanup?.();
+      readerContext.chapterManifestCleanup = null;
+    }
+    if (mode === "swf") {
+      readerContext.swfPlayer?.remove();
+      readerContext.swfPlayer = null;
+    }
+    if (["pdf", "pdf-pages", "image-pages"].includes(mode)) {
+      readerContext.pdfDocument = null;
+      readerContext.pdfHybridUrl = "";
+      readerContext.pdfHybridDocumentPromise = null;
+      readerContext.pdfPageManifest = null;
+      readerContext.pdfOcrManifest = null;
+      readerContext.pdfOcrManifestPromise = null;
+      readerContext.pdfV3Repository?.dispose(); readerContext.pdfTextLayerRepository?.dispose();
+      for (const shell of readerContext.pdfManifestShells) shell?._v3PreviewRelease?.();
+      readerContext.pdfV3Repository = readerContext.pdfTextLayerRepository = null;
+      readerContext.pdfV3Manifest = readerContext.pdfV3Map = null;
+      readerContext.pdfTextContentCache.clear();
+      readerContext.pdfTextContentPromises.clear();
+      readerContext.pdfTextContentCacheBytes = 0;
+      readerContext.pdfOcrPageCache.clear();
+      readerContext.pdfOcrPageCacheBytes = 0;
+      readerContext.clearPdfManifestPrefetches();
+      readerContext.pdfBookSearchClient?.dispose();
+      readerContext.pdfBookSearchClient = null;
+      readerContext.pdfShellWindow?.dispose();
+      readerContext.pdfFirstPagePreload?.removeAttribute("src");
+      readerContext.pdfFirstPagePreload = null;
+      for (const canvas of readerContext.content.querySelectorAll(".reader-page canvas")) {
+        canvas.width = 0;
+        canvas.height = 0;
+      }
+      for (const image of readerContext.content.querySelectorAll(".reader-page img")) image.removeAttribute("src");
+    }
+    if (mode === "foliate") {
+      readerContext.foliateSectionObserver?.disconnect();
+      readerContext.foliateSectionObserver = null;
+      readerContext.foliateSectionVirtualizer?.dispose();
+      readerContext.foliateChapterRepository?.dispose();
+      readerContext.foliateSectionVirtualizer = null;
+      readerContext.foliateChapterRepository = null;
+      readerContext.foliateSectionLoader = null;
+      readerContext.foliateSectionSettler = null;
+      try {
+        const closing = readerContext.epubRendition?.close?.();
+        closing?.catch?.(() => {});
+      } catch (_) {}
+      readerContext.epubRendition = null;
+      readerContext.epubBook = null;
+    }
+    if (mode === "html") {
+      readerContext.htmlFrame?.remove();
+      readerContext.htmlFrame = null;
+      readerContext.content.classList.remove("reader-content--spreadsheet");
+    }
+    if (["audio", "video"].includes(mode) && readerContext.mediaElement) {
+      readerContext.mediaElement.pause();
+      readerContext.mediaElement.removeAttribute("src");
+      readerContext.mediaElement.load();
+      readerContext.mediaElement = null;
+    }
+  }
+
+  function registerReaderFormatAdapters() {
+    const formats = {
+      "pdf-pages": [
+        () => {
+          return readerContext.fetchReaderResponse();
+        },
+        readerContext.renderPdfPages
+      ],
+      "image-pages": [
+        () => readerContext.fetchReaderResponse(),
+        readerContext.renderImagePages
+      ],
+      pdf: [readerContext.loadPdfDocument, readerContext.renderPdf],
+      image: [readerContext.loadImageDocument, readerContext.renderImageDocument],
+      text: [readerContext.loadTextDocument, readerContext.renderTextDocument],
+      markdown: [readerContext.loadMarkdownDocument, readerContext.renderMarkdownDocument],
+      html: [readerContext.loadHtmlDocument, readerContext.renderHtml],
+      "epub-chapters": [readerContext.loadChapterManifestDocument, readerContext.renderChapterManifest],
+      docx: [readerContext.loadDocxDocument, readerContext.renderDocx],
+      audio: [readerContext.loadMediaDocument, () => readerContext.renderMedia("audio")],
+      video: [readerContext.loadMediaDocument, () => readerContext.renderMedia("video")],
+      swf: [readerContext.loadSwfDocument, readerContext.renderSwf],
+      foliate: [readerContext.loadMediaDocument, readerContext.renderFoliate]
+    };
+    for (const [mode, [open, render]] of Object.entries(formats))
+      readerContext.formatAdapters.register(mode, {
+        open,
+        render,
+        restore: (entry, generation) => readerContext.restoreFormat(mode, entry, generation),
+        dispose: () => readerContext.disposeFormatResources(mode)
+      });
+  }
+
+  async function resolveReaderSource() {
+    if (!readerContext.readerId || readerContext.sourceUrl) return;
+    readerContext.setReaderStage("resolve");
+    let resolved = readerContext.cachedReaderData;
+    if (!resolved?.url) {
+      try {
+        resolved = await readerContext.resolveReaderId(readerContext.readerId);
+      } catch (error) {
+        readerContext.assertReaderActive();
+        if (!readerContext.localReaderData?.url) throw error;
+        resolved = readerContext.localReaderData;
+      }
+    }
+    readerContext.assertReaderActive();
+    readerContext.sourceUrl = readerContext.normalizeSourceUrl(resolved.url || "");
+    readerContext.contentUrl = readerContext.readerContentUrl(readerContext.sourceUrl);
+    readerContext.downloadUrl = resolved.download || readerContext.sourceUrl;
+    readerContext.chapterManifestUrl = resolved.chapter_manifest || "";
+    readerContext.fallbackUrl = resolved.fallback || "";
+    if (resolved.extension) readerContext.extension = String(resolved.extension).toLowerCase();
+    if (
+      readerContext.extension === "pdf" &&
+      readerContext.sourceUrl.includes("/api/reader-bucket-resource?") &&
+      new URL(readerContext.sourceUrl).searchParams.get("path")?.endsWith("page-manifest.json")
+    )
+      readerContext.extension = "pdf-pages";
+    readerContext.capability = readerContext.readerRuntime.negotiate(VoiceOfMLReader.capability(readerContext.extension));
+    if (readerContext.capability.mode !== "pdf" && !readerContext.pdfPrimarySource()) readerContext.releasePdfWorker?.();
+    readerContext.readerRuntime.update("source", {
+      url: readerContext.sourceUrl,
+      contentUrl: readerContext.contentUrl,
+      downloadUrl: readerContext.downloadUrl,
+      extension: readerContext.extension,
+      metadata: resolved
+    });
+    readerContext.applyReaderMetadata(resolved);
+  }
+
+  async function start() {
+    const generation = readerContext.readerRuntime.currentGeneration("navigation");
+    // A PDF link already tells us which engine is needed. Start its import while
+    // an ID-only Reader link is resolving its source URL. The promise is reused
+    // by loadPdfDocument, so this does not create a second module request.
+    if (readerContext.extension === "pdf" || /\.pdf(?:$|[?#])/i.test(readerContext.sourceUrl)) readerContext.preloadPdfEngine().catch(() => {});
+    readerContext.readerSourcePromise = readerContext.measurePdf(readerContext.resolveReaderSource(), "resolve");
+    await readerContext.readerSourcePromise;
+    readerContext.assertReaderActive();
+    if (readerContext.readerId && /\/calibre-chm-epub-[^/]+\/document\.epub(?:$|\?)/i.test(readerContext.sourceUrl)) {
+      readerContext.extension = "epub";
+      readerContext.readerRuntime.update("source", { extension: readerContext.extension });
+      readerContext.capability = readerContext.readerRuntime.negotiate(VoiceOfMLReader.capability(readerContext.extension));
+      readerContext.content.dataset.mode = readerContext.capability.mode;
+      document.querySelector(".page-controls").hidden = true;
+    }
+    readerContext.syncCapabilityControls();
+    readerContext.downloadButton.href = readerContext.readerDownloadUrl(readerContext.documentState.title, readerContext.downloadUrl);
+    if (
+      (!readerContext.validSource(readerContext.sourceUrl) && !readerContext.validSource(readerContext.chapterManifestUrl) && !readerContext.readerId) ||
+      readerContext.capability.readerMode === VoiceOfMLReader.ReaderMode.UNSUPPORTED
+    )
+      return readerContext.fail("此文件暂不支持在线阅读，请下载原文件。", "READER_UNSUPPORTED");
+    readerContext.formatAdapters.activate(readerContext.capability.mode);
+    readerContext.applyReaderMetadata(readerContext.resolvedReaderData);
+    if (readerContext.validOcr(readerContext.ocrUrl)) {
+      const ocr = document.querySelector("#ocr") || document.createElement("a");
+      ocr.id = "ocr";
+      ocr.className = "text-button";
+      ocr.target = "_blank";
+      ocr.rel = "noopener noreferrer";
+      ocr.textContent = "OCR";
+      if (!ocr.parentElement) document.querySelector(".reader-actions")?.prepend(ocr);
+      ocr.href = readerContext.ocrUrl;
+      ocr.hidden = false;
+    }
+    try {
+      if (readerContext.capability.mode === "foliate") {
+        readerContext.setReaderStage("foliate");
+        readerContext.foliateContinuous = true;
+        const restorationPromise = readerContext.loadReaderRestoration();
+        readerContext.readerRestorationPromise = restorationPromise;
+        await readerContext.awaitReader(readerContext.renderFoliate());
+        readerContext.assertReaderActive();
+        const restored = await readerContext.awaitReader(restorationPromise);
+        await readerContext.applyInitialRestoration(restored, generation);
+        readerContext.initialReaderTargetSection = null;
+        readerContext.assertReaderActive();
+        if (!readerContext.setReaderPhase("ready")) return;
+        readerContext.updateDocumentState({ restorationReady: !readerContext.restorationFailed });
+        readerContext.scheduleSave();
+        return;
+      }
+      readerContext.setReaderStage("prepare");
+      const restorationPromise = readerContext.loadReaderRestoration();
+      readerContext.readerRestorationPromise = restorationPromise;
+      const prepareResources = new Set(readerContext.readerResources);
+      try {
+        const prepared = await readerContext.awaitReader(readerContext.formatAdapters.active.open());
+        readerContext.assertReaderActive();
+        await readerContext.formatAdapters.active.render(prepared);
+      } catch (error) {
+        readerContext.assertReaderActive();
+        const originalExtension = String(readerContext.resolvedReaderData?.original_extension || "").toLowerCase();
+        if (readerContext.capability.mode !== "image-pages" || !readerContext.validSource(readerContext.downloadUrl) ||
+            !["jpg", "jpeg", "png", "gif", "bmp", "webp"].includes(originalExtension)) throw error;
+        for (const cleanup of [...readerContext.readerResources]) {
+          if (prepareResources.has(cleanup)) continue;
+          cleanup();
+          readerContext.readerResources.delete(cleanup);
+        }
+        readerContext.formatAdapters.dispose();
+        readerContext.content.replaceChildren();
+        readerContext.extension = originalExtension;
+        readerContext.capability = readerContext.readerRuntime.negotiate(VoiceOfMLReader.capability(readerContext.extension));
+        readerContext.readerRuntime.update("source", { extension: readerContext.extension });
+        readerContext.updateDocumentState({ page: 1, pageCount: 0 });
+        readerContext.formatAdapters.activate(readerContext.capability.mode);
+        readerContext.syncCapabilityControls();
+        await readerContext.renderImageDocument(await readerContext.loadImageDocument(readerContext.downloadUrl));
+      }
+      readerContext.assertReaderActive();
+      readerContext.markReaderContentReady();
+      const restored = await readerContext.awaitReader(restorationPromise);
+      await readerContext.applyInitialRestoration(restored, generation);
+      readerContext.assertReaderActive();
+      if (!readerContext.setReaderPhase("ready")) return;
+      readerContext.updateDocumentState({ restorationReady: !readerContext.restorationFailed });
+      readerContext.schedulePdfBookSearchPrefetch();
+      readerContext.updateProgressTools();
+      if (readerContext.fullSearchInput.value.trim()) readerContext.runFullSearch();
+      readerContext.scheduleSave();
+    } catch (error) {
+      if (readerContext.readerAbortController.signal.aborted || error?.name === "AbortError") return;
+      console.error(error);
+      if (
+        error?.code !== "READER_RESTORE" &&
+        readerContext.capability.mode === "epub-chapters" &&
+        readerContext.validFallback(readerContext.fallbackUrl)
+      ) {
+        const target = new URL(location.href);
+        target.searchParams.set("url", readerContext.fallbackUrl);
+        target.searchParams.set("ext", "pdf");
+        target.searchParams.delete("chapter_manifest");
+        target.searchParams.delete("fallback");
+        if (window.parent !== window)
+          window.parent.postMessage({ type: "voice-reader-open", url: target.href }, location.origin);
+        else location.replace(target.href);
+        return;
+      }
+      readerContext.fail(
+        error && error.message ? error.message : "原文件加载失败",
+        readerContext.classifyReaderError(error, readerContext.capability.mode === "foliate" ? "READER_CORRUPT" : "READER_PARSE")
+      );
+    }
+  }
+
+  function syncCapabilityControls() {
+    readerContext.content.dataset.mode = readerContext.capability.mode || "unsupported";
+    readerContext.pageInvertToggle.hidden = !["pdf", "pdf-pages"].includes(readerContext.capability.mode);
+    document.querySelector(".page-controls").hidden = !readerContext.capability.features.pagination;
+    document.querySelector(".zoom-controls").hidden = !readerContext.capability.features.zoom;
+    readerContext.mediaTab.hidden = !readerContext.capability.features.media;
+    readerContext.fullSearchButton.hidden = !readerContext.capability.features.search || (readerContext.capability.mode === "pdf-pages" && !readerContext.ocrManifestUrl && !readerContext.pdfHybridUrl);
+    readerContext.bookmarkRibbon.hidden = !readerContext.capability.features.bookmarks;
+    readerContext.readingProgressSummary.querySelector(".reader-progress-bookmark").hidden =
+      !readerContext.capability.features.bookmarks;
+    if (
+      (readerContext.panelState.selected === "media" && readerContext.mediaTab.hidden) ||
+      (readerContext.panelState.selected === "full-search" && readerContext.fullSearchButton.hidden)
+    )
+      readerContext.selectPanel("toc");
+  }
+
+  return {
+    disposeFormatResources,
+    registerReaderFormatAdapters,
+    resolveReaderSource,
+    start,
+    syncCapabilityControls
+  };
+}

static/reader/formats/reader-html-format.mjs

@@ -0,0 +1,322 @@
+export function createReaderHtmlFormat(readerContext) {
+  function normalizeEpubDocument(doc) {
+    // Legacy CHM conversions can use an XHTML prefix even in HTML content.
+    for (const element of [...doc.querySelectorAll("*")]) {
+      const tagName = String(element.tagName || "").toLowerCase();
+      const localName = tagName.includes(":") ? tagName.slice(tagName.lastIndexOf(":") + 1) : tagName;
+      if (tagName === localName || !readerContext.EPUB_HTML_TAGS.has(localName)) continue;
+      const replacement = doc.createElementNS("http://www.w3.org/1999/xhtml", localName);
+      for (const attribute of [...element.attributes]) {
+        if (!attribute.name.toLowerCase().startsWith("xmlns:"))
+          replacement.setAttribute(attribute.name, attribute.value);
+      }
+      // HTML parsing treats prefixed void tags as containers. Keep the following
+      // content as siblings: serializing real <br>/<hr>/<img> drops their children.
+      // Move the existing text nodes so Foliate's source/CFI mapping stays intact.
+      const fragment = doc.createDocumentFragment();
+      fragment.appendChild(replacement);
+      if (readerContext.EPUB_HTML_VOID_TAGS.has(localName)) {
+        while (element.firstChild) fragment.appendChild(element.firstChild);
+      } else {
+        while (element.firstChild) replacement.appendChild(element.firstChild);
+      }
+      element.replaceWith(fragment);
+    }
+    return doc;
+  }
+
+  function sanitizeReaderDocument(doc, { preserveEpubStyles = false } = {}) {
+    const blocked = preserveEpubStyles
+      ? "script,iframe,object,embed,base,form"
+      : "script,iframe,object,embed,base,form,link,style";
+    for (const node of doc.querySelectorAll(blocked)) node.remove();
+    if (preserveEpubStyles) {
+      for (const link of doc.querySelectorAll("link")) {
+        const rel = (link.getAttribute("rel") || "").toLowerCase().split(/\s+/);
+        if (!rel.includes("stylesheet") || !/^blob:/i.test(link.getAttribute("href") || ""))
+          link.remove();
+      }
+      for (const style of doc.querySelectorAll("style")) {
+        if (
+          /(?:@import\s+|url\s*\(\s*[\"']?)(?:https?:|\/\/|javascript:)/i.test(
+            style.textContent || ""
+          )
+        )
+          style.remove();
+      }
+    }
+    for (const element of doc.querySelectorAll("*"))
+      for (const attribute of [...element.attributes]) {
+        const name = attribute.name.toLowerCase(),
+          value = String(attribute.value || "").trim();
+        if (
+          name.startsWith("on") ||
+          name === "srcdoc" ||
+          ((name === "href" || name === "xlink:href" || name === "src") &&
+            /^javascript:/i.test(value))
+        )
+          element.removeAttribute(attribute.name);
+      }
+    return doc;
+  }
+
+  function sanitizeEpubDocument(doc) {
+    return readerContext.sanitizeReaderDocument(readerContext.normalizeEpubDocument(doc), { preserveEpubStyles: true });
+  }
+
+  function parseChapterDocument(text) {
+    // Parse generated XHTML before HTML's void-element rules can swallow children
+    // of prefixed elements such as <html:meta/> (including the following title).
+    const xml = new DOMParser().parseFromString(text, "application/xhtml+xml");
+    if (!xml.querySelector("parsererror"))
+      text = new XMLSerializer().serializeToString(readerContext.normalizeEpubDocument(xml));
+    return readerContext.sanitizeEpubDocument(new DOMParser().parseFromString(text, "text/html"));
+  }
+
+  function epubContentBody(doc) {
+    const nestedBody = [...doc.querySelectorAll("body")].find((body) => body !== doc.body);
+    return nestedBody || doc.body || doc.documentElement;
+  }
+
+  async function renderText(markdown, prepared) {
+    let response = await prepared.response;
+    if (!response.ok) response = await readerContext.fetchReaderResponse();
+    if (!response.ok) throw new Error(`HTTP ${response.status}`);
+    if (!markdown) await readerContext.renderPlainText(response);
+    else {
+      const bytes = await readerContext.readPreparedBytes(response, prepared.engines);
+      const text = new TextDecoder(readerContext.detectTextEncoding(bytes, readerContext.documentState.title)).decode(bytes);
+      const article = document.createElement("article");
+      article.className = "reader-markdown";
+      article.innerHTML = DOMPurify.sanitize(marked.parse(text), { USE_PROFILES: { html: true } });
+      readerContext.content.appendChild(article);
+      readerContext.setToc(readerContext.headingTocEntries(article));
+    }
+    readerContext.markReaderContentReady();
+    readerContext.status.textContent = "已加载";
+  }
+
+  function sanitizeOfflineHtml(text) {
+    const clean = DOMPurify.sanitize(text, {
+      USE_PROFILES: { html: true },
+      ADD_TAGS: ["style"],
+      FORBID_TAGS: ["base", "embed", "form", "iframe", "object", "script"],
+      FORBID_ATTR: ["action", "formaction", "srcdoc"],
+       ALLOWED_URI_REGEXP: /^data:image\/(?:gif|png|jpeg|webp|svg\+xml);/i
+    });
+    const template = document.createElement("template");
+    template.innerHTML = clean;
+    const stripUrls = (value) => value.replace(/@import[^;]+;|url\s*\([^)]*\)/gi, "");
+    for (const style of template.content.querySelectorAll("style"))
+      style.textContent = stripUrls(style.textContent);
+    for (const element of template.content.querySelectorAll("[style]"))
+      element.setAttribute("style", stripUrls(element.getAttribute("style")));
+    return template.innerHTML;
+  }
+
+  function buildDiscourseDocument(text) {
+    try {
+      const source = new DOMParser().parseFromString(text, "text/html");
+      const posts = [...source.querySelectorAll(readerContext.DISCOURSE_POST_SELECTOR)];
+      if (!source.querySelector(".post-stream") || !posts.length) return null;
+      const article = source.createElement("article");
+      article.className = "reader-forum-document";
+      const titleNode = source.querySelector(readerContext.DISCOURSE_TITLE_SELECTOR);
+      const title = titleNode?.textContent?.trim();
+      if (title) {
+        const heading = source.createElement("h1");
+        heading.textContent = title;
+        article.appendChild(heading);
+      }
+      posts.forEach((post, index) => {
+        const section = source.createElement("section");
+        section.className = "reader-forum-post";
+        section.dataset.post = String(index + 1);
+        section.innerHTML = post.innerHTML;
+        article.appendChild(section);
+      });
+      return article.outerHTML;
+    } catch (_) {
+      return null;
+    }
+  }
+
+  function prepareHtmlDocument(text) {
+    const discourse = readerContext.buildDiscourseDocument(text);
+    const html = readerContext.sanitizeOfflineHtml(discourse || text);
+    return {
+      html,
+      discourse: !!discourse,
+      spreadsheet: !discourse && html.includes("reader-spreadsheet-sheet")
+    };
+  }
+
+  function buildHtmlFrameSource(documentData) {
+    return documentData.html + readerContext.HTML_FRAME_STYLE +
+      (documentData.discourse ? readerContext.DISCOURSE_HTML_STYLE : "") +
+      (documentData.spreadsheet ? readerContext.SPREADSHEET_HTML_STYLE : "");
+  }
+
+  async function waitForSpreadsheetImages(frame) {
+    if (frame.contentDocument)
+      await readerContext.settleReaderImages(frame.contentDocument, 30000);
+  }
+
+  async function renderHtml(prepared) {
+    const bytes = await readerContext.readPreparedBytes(prepared.response, prepared.engine);
+    const text = new TextDecoder(readerContext.detectHtmlEncoding(bytes, readerContext.documentState.title)).decode(bytes);
+    readerContext.assertReaderActive();
+    const documentData = readerContext.prepareHtmlDocument(text);
+    const frame = document.createElement("iframe");
+    readerContext.htmlFrame = frame;
+    frame.className = "html-frame";
+    readerContext.content.classList.toggle("reader-content--spreadsheet", documentData.spreadsheet);
+    if (documentData.spreadsheet) frame.classList.add("spreadsheet-html-frame");
+    frame.title = `${readerContext.documentState.title} 正文`;
+    frame.setAttribute("sandbox", "allow-same-origin");
+    frame.setAttribute("referrerpolicy", "no-referrer");
+    frame.style.colorScheme = "only light";
+    const frameLoaded = new Promise((resolve, reject) => {
+      let untrack = () => {}, frameTimer = 0, deadline = 0, started = false;
+      const cleanup = () => {
+        clearTimeout(frameTimer);
+        clearTimeout(deadline);
+        frame.removeEventListener("load", loaded);
+        untrack();
+      };
+      const loaded = async () => {
+        if (started || frame.contentDocument?.URL !== "about:srcdoc" || frame.contentDocument.readyState === "loading") return;
+        started = true;
+        cleanup();
+        try {
+          readerContext.assertReaderActive();
+          readerContext.repairHtmlContrast(frame);
+          frame.contentDocument.documentElement.style.zoom = String(readerContext.documentState.zoom);
+          frame.contentWindow.addEventListener("scroll", readerContext.handleReaderPositionChange, {
+            passive: true
+          });
+          frame.contentDocument.addEventListener("keydown", readerContext.handleReaderKeydown);
+          readerContext.installReaderTapSelectionClear(frame.contentDocument.body, frame.contentDocument);
+          for (const type of ["wheel", "touchstart", "pointerdown"])
+            frame.contentDocument.addEventListener(type, readerContext.beginReaderNavigation, { passive: true });
+          readerContext.setToc(readerContext.headingTocEntries(frame.contentDocument));
+          if (documentData.spreadsheet) await readerContext.waitForSpreadsheetImages(frame);
+          readerContext.assertReaderActive();
+          resolve();
+        } catch (error) {
+          reject(error);
+        }
+      };
+      untrack = readerContext.trackReaderResource(() => {
+        cleanup();
+        reject(readerContext.readerAbortError());
+      });
+      const poll = () => {
+        if (started) return;
+        loaded();
+        if (!started) frameTimer = setTimeout(poll, 16);
+      };
+      frameTimer = setTimeout(poll, 0);
+      deadline = setTimeout(() => { cleanup(); reject(new Error("HTML document initialization timeout")); }, 20000);
+      frame.addEventListener("load", loaded);
+    });
+    frame.srcdoc = readerContext.buildHtmlFrameSource(documentData);
+    readerContext.content.appendChild(frame);
+    await frameLoaded;
+    readerContext.markReaderContentReady();
+     readerContext.status.textContent = documentData.spreadsheet ? "表格" : "HTML";
+  }
+
+  function detectHtmlEncoding(bytes, hint = "") {
+    const probe = String.fromCharCode(...bytes.subarray(0, 8192));
+    const match = probe.match(/charset\s*=\s*["']?\s*([a-z0-9._:-]+)/i);
+    if (match) {
+      const label =
+        { gb2312: "gb18030", "gb-2312": "gb18030", gbk: "gb18030", "x-gbk": "gb18030" }[
+          match[1].toLowerCase()
+        ] || match[1];
+      try {
+        new TextDecoder(label);
+        return label;
+      } catch (_) {}
+    }
+    return readerContext.detectTextEncoding(bytes, hint);
+  }
+
+  function repairHtmlContrast(frame) {
+    const doc = frame.contentDocument;
+    if (!doc || !doc.body) return;
+    const parseColor = (value) => {
+      const parts = String(value).match(/[\d.]+/g);
+      return parts && parts.length >= 3
+        ? [
+            Number(parts[0]),
+            Number(parts[1]),
+            Number(parts[2]),
+            parts[3] === undefined ? 1 : Number(parts[3])
+          ]
+        : null;
+    };
+    const luminance = (color) => {
+      const channels = color.slice(0, 3).map((value) => {
+        const normalized = value / 255;
+        return normalized <= 0.04045 ? normalized / 12.92 : ((normalized + 0.055) / 1.055) ** 2.4;
+      });
+      return channels[0] * 0.2126 + channels[1] * 0.7152 + channels[2] * 0.0722;
+    };
+    const backgrounds = new Map();
+    const background = (element, style) => {
+      const pending = [];
+      let light = 1;
+      for (let current = element; current; current = current.parentElement) {
+        if (backgrounds.has(current)) {
+          light = backgrounds.get(current);
+          break;
+        }
+        pending.push(current);
+        const color = parseColor((current === element ? style :
+          frame.contentWindow.getComputedStyle(current)).backgroundColor);
+        if (color && color[3] > 0.1) {
+          light = luminance(color);
+          break;
+        }
+      }
+      for (const current of pending) backgrounds.set(current, light);
+      return light;
+    };
+    const walker = doc.createTreeWalker(doc.body, NodeFilter.SHOW_TEXT);
+    const elements = new Set();
+    while (walker.nextNode() && elements.size < 10000)
+      if (walker.currentNode.data.trim()) elements.add(walker.currentNode.parentElement);
+    for (const element of elements) {
+      const style = frame.contentWindow.getComputedStyle(element);
+      const foreground = parseColor(style.color);
+      const dark = background(element, style);
+      if (!foreground) continue;
+      const light = luminance(foreground);
+      const contrast = (Math.max(light, dark) + 0.05) / (Math.min(light, dark) + 0.05);
+      if (contrast < 3) {
+        element.style.setProperty("color", dark > 0.45 ? "#111" : "#f5f5f5", "important");
+        // Inherited color and currentColor backgrounds can change after a repair.
+        backgrounds.clear();
+      }
+    }
+  }
+
+  return {
+    normalizeEpubDocument,
+    sanitizeReaderDocument,
+    sanitizeEpubDocument,
+    parseChapterDocument,
+    epubContentBody,
+    renderText,
+    sanitizeOfflineHtml,
+    buildDiscourseDocument,
+    prepareHtmlDocument,
+    buildHtmlFrameSource,
+    waitForSpreadsheetImages,
+    renderHtml,
+    detectHtmlEncoding,
+    repairHtmlContrast
+  };
+}

static/reader/formats/reader-image-loader.mjs

@@ -0,0 +1,59 @@
+export function createReaderImageLoader({assertActive, abortError, trackResource, request, readBytes, timeoutMs}) {
+  function wait(image, target, timeoutMs, signal) {
+    assertActive();
+    return new Promise((resolve, reject) => {
+      let settled = false, timeout = 0, untrack = () => {};
+      const abort = () => finish(abortError());
+      const finish = (error) => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timeout);
+        untrack();
+        signal?.removeEventListener("abort", abort);
+        image.onload = image.onerror = null;
+        if (error) {
+          image.removeAttribute("src");
+          reject(error);
+        } else resolve(image);
+      };
+      untrack = trackResource(() => finish(abortError()));
+      signal?.addEventListener("abort", abort, { once: true });
+      if (signal?.aborted) abort();
+      if (settled) return;
+      timeout = setTimeout(() => finish(new DOMException("Reader image stalled", "TimeoutError")), timeoutMs);
+      image.onload = () => finish();
+      image.onerror = () => finish(new Error("image load failed"));
+      if (image.src !== new URL(target, location.href).href) image.src = target;
+      if (image.complete && image.naturalWidth) finish();
+    });
+  }
+
+  async function load(image, target, signal, deadline = performance.now() + timeoutMs) {
+    const remaining = () => Math.max(1, deadline - performance.now());
+    const network = /^https?:$/.test(new URL(target, location.href).protocol);
+    try {
+      return await wait(image, target, Math.min(network ? 15000 : timeoutMs, remaining()), signal);
+    } catch (error) {
+      assertActive();
+      signal?.throwIfAborted();
+      if (!network || error?.name !== "TimeoutError" || !navigator.onLine) throw error;
+    }
+    const response = await request(target, remaining(),
+      { signal, priority: image.fetchPriority || "auto" });
+    if (!response.ok) {
+      await response.body?.cancel();
+      throw Object.assign(new Error(`HTTP ${response.status}`), {status: response.status});
+    }
+    const bytes = await readBytes(response);
+    assertActive();
+    signal?.throwIfAborted();
+    const blobUrl = URL.createObjectURL(new Blob([bytes], {type: response.headers.get("Content-Type") || ""}));
+    try {
+      return await wait(image, blobUrl, Math.min(20000, remaining()), signal);
+    } finally {
+      URL.revokeObjectURL(blobUrl);
+    }
+  }
+
+  return Object.freeze({load});
+}

static/reader/formats/reader-media-format.mjs

@@ -0,0 +1,90 @@
+export function createReaderMediaFormat(readerContext) {
+  function formatMediaTime(seconds) {
+    if (!Number.isFinite(seconds) || seconds < 0) return "00:00";
+    const total = Math.floor(seconds),
+      hours = Math.floor(total / 3600),
+      minutes = Math.floor((total % 3600) / 60),
+      secs = total % 60;
+    return `${hours ? `${String(hours).padStart(2, "0")}:` : ""}${String(minutes).padStart(2, "0")}:${String(secs).padStart(2, "0")}`;
+  }
+
+  function renderImageDocument(image) {
+    readerContext.assertReaderActive();
+    readerContext.content.appendChild(image);
+    readerContext.markReaderContentReady();
+    readerContext.status.textContent = "图片";
+  }
+
+  function renderMedia(mode) {
+    readerContext.assertReaderActive();
+    const media = document.createElement(mode);
+    media.className = mode === "audio" ? "reader-audio" : "reader-video";
+    media.controls = true;
+    media.setAttribute("aria-label", `${readerContext.documentState.title} ${mode === "audio" ? "音频" : "视频"}`);
+    media.preload = "metadata";
+    if (mode === "video") media.playsInline = true;
+    const refresh = () => {
+      if (readerContext.readerAbortController.signal.aborted) return;
+      readerContext.mediaPanel.querySelector(".media-panel-time").textContent =
+        `${readerContext.formatMediaTime(media.currentTime)} / ${readerContext.formatMediaTime(media.duration)}`;
+      readerContext.scheduleMarkerSync();
+    };
+    for (const type of ["timeupdate", "durationchange", "loadedmetadata"])
+      media.addEventListener(type, refresh, { passive: true });
+    for (const type of ["pause", "ended", "seeked"])
+      media.addEventListener(type, () => {
+        refresh();
+        readerContext.saveProgress();
+      });
+    readerContext.mediaElement = media;
+    let sourceRetried = false;
+    const originalMode = VoiceOfMLReader.capability(readerContext.resolvedReaderData?.original_extension || readerContext.extension).mode;
+    const retryUrl = originalMode === mode && readerContext.validSource(readerContext.downloadUrl) ? readerContext.downloadUrl : readerContext.sourceUrl;
+    media.addEventListener("error", () => {
+      if (readerContext.readerAbortController.signal.aborted) return;
+      if (!sourceRetried && retryUrl !== media.src && readerContext.validSource(retryUrl)) {
+        sourceRetried = true;
+        media._readerSourceRetry = true;
+        media.src = retryUrl;
+        media.load();
+        return;
+      }
+      media._readerSourceRetry = false;
+      readerContext.fail("媒体加载失败，请检查网络后重试，或下载原文件。", "READER_MEDIA");
+    });
+    media.src = readerContext.contentUrl;
+    readerContext.content.appendChild(media);
+    readerContext.markReaderContentReady();
+    readerContext.status.textContent = mode === "audio" ? "音频" : "视频";
+  }
+
+  async function loadSwfDocument() {
+    await readerContext.loadScript(readerContext.RUFFLE_URL);
+    const response = await readerContext.fetchReaderResponse();
+    return new Uint8Array(await response.arrayBuffer());
+  }
+
+  async function renderSwf(data) {
+    readerContext.assertReaderActive();
+    const factory = window.RufflePlayer?.newest?.();
+    if (!factory) throw Object.assign(new Error("Ruffle 未加载"), { code: "READER_SWF_ENGINE" });
+    const player = factory.createPlayer();
+    player.className = "reader-swf";
+    player.setAttribute("aria-label", `${readerContext.documentState.title} Flash 内容`);
+    player.style.width = "100%";
+    player.style.minHeight = "360px";
+    readerContext.content.appendChild(player);
+    readerContext.swfPlayer = player;
+    await player.ruffle().load({ data });
+    readerContext.markReaderContentReady();
+    readerContext.status.textContent = "Flash 内容";
+  }
+
+  return {
+    formatMediaTime,
+    renderImageDocument,
+    renderMedia,
+    loadSwfDocument,
+    renderSwf
+  };
+}

static/reader/formats/reader-text-format.mjs

@@ -0,0 +1,196 @@
+export function createReaderTextFormat(readerContext) {
+  async function renderPlainText(response) {
+    readerContext.assertReaderActive();
+    const pre = document.createElement("div");
+    pre.className = "reader-text";
+    readerContext.content.appendChild(pre);
+    let block = null, blockLength = 0;
+    const appendDecoded = async value => {
+      const text = value.replace(/\ufffd/g, "");
+      let offset = 0, deadline = performance.now() + 8;
+      while (offset < text.length) {
+        if (!block) {
+          block = document.createElement("pre");
+          block.className = "reader-text-block";
+          pre.appendChild(block);
+        }
+        let end = Math.min(text.length, offset + 32768 - blockLength);
+        if (end < text.length) {
+          const newline = text.lastIndexOf("\n", end - 1);
+          if (newline >= offset) end = newline + 1;
+          const previous = text.charCodeAt(end - 1), next = text.charCodeAt(end);
+          if ((previous >= 0xd800 && previous <= 0xdbff && next >= 0xdc00 && next <= 0xdfff) ||
+              (previous === 13 && next === 10)) end--;
+        }
+        if (end === offset) { block = null; blockLength = 0; continue; }
+        const tail = block.lastChild;
+        if (tail?.nodeType === Node.TEXT_NODE) tail.appendData(text.slice(offset, end));
+        else block.appendChild(document.createTextNode(text.slice(offset, end)));
+        if (text.length) readerContext.markReaderContentReady();
+        blockLength += end - offset;
+        offset = end;
+        if (offset < text.length || blockLength >= 32768) { block = null; blockLength = 0; }
+        if (offset < text.length && performance.now() >= deadline) {
+          await readerContext.waitForReader();
+          readerContext.assertReaderActive();
+          deadline = performance.now() + 8;
+        }
+      }
+    };
+    const limit = VoiceOfMLReaderSecurity.LIMITS.documentBytes;
+    VoiceOfMLReaderSecurity.assertResponseSize(response, limit);
+    if (!response.body?.getReader) {
+      const bytes = new Uint8Array(await response.arrayBuffer());
+      if (bytes.byteLength > limit) {
+        const error = new Error("READER_RESOURCE_LIMIT");
+        error.code = "READER_RESOURCE_LIMIT";
+        throw error;
+      }
+      readerContext.assertReaderActive();
+      await appendDecoded(new TextDecoder(readerContext.detectTextEncoding(bytes, readerContext.documentState.title)).decode(bytes));
+      return;
+    }
+    const reader = response.body.getReader(),
+      sampleChunks = [],
+      previewDecoder = new TextDecoder("utf-8");
+    const untrack = readerContext.trackReaderResource(() => {
+      reader.cancel(readerContext.readerAbortError()).catch(() => {});
+    });
+    let length = 0,
+      sampleLength = 0,
+      displayedSampleSize = 0,
+      previewChunkIndex = 0,
+      previewChunkOffset = 0,
+      decoder = null,
+      asciiPreviewPossible = true,
+      asciiPrefixLength = 0;
+    const startDecoder = async () => {
+      const sample = new Uint8Array(sampleLength);
+      let offset = 0;
+      for (const chunk of sampleChunks) {
+        sample.set(chunk, offset);
+        offset += chunk.byteLength;
+      }
+      decoder = new TextDecoder(readerContext.detectTextEncoding(sample, readerContext.documentState.title));
+      await appendDecoded(decoder.decode(sample.subarray(displayedSampleSize), { stream: true }));
+      sampleChunks.length = 0;
+    };
+    try {
+      while (true) {
+        const { value, done } = await readerContext.awaitReader(reader.read());
+        readerContext.assertReaderActive();
+        if (done) break;
+        if (!value?.byteLength) continue;
+        length += value.byteLength;
+        if (length > limit) {
+          const error = new Error("READER_RESOURCE_LIMIT");
+          error.code = "READER_RESOURCE_LIMIT";
+          throw error;
+        }
+        if (!decoder) {
+          sampleChunks.push(value);
+          sampleLength += value.byteLength;
+          if (asciiPreviewPossible) {
+            let asciiLength = 0;
+            while (asciiLength < value.length && value[asciiLength] > 0 && value[asciiLength] < 128)
+              asciiLength++;
+            asciiPrefixLength += asciiLength;
+            if (value[asciiLength] === 0) {
+              // A split UTF-16 prefix must not leave an ASCII preview behind.
+              pre.textContent = "";
+              block = null;
+              blockLength = 0;
+              displayedSampleSize = 0;
+              asciiPrefixLength = 0;
+              asciiPreviewPossible = false;
+            } else if (asciiLength < value.length) asciiPreviewPossible = false;
+          }
+          if (asciiPrefixLength >= 4 && asciiPrefixLength > displayedSampleSize) {
+            // The full sample remains for encoding detection; preview only its
+            // unseen ASCII prefix instead of revisiting all previous chunks.
+            while (displayedSampleSize < asciiPrefixLength) {
+              const chunk = sampleChunks[previewChunkIndex];
+              const end = Math.min(chunk.length, previewChunkOffset + asciiPrefixLength - displayedSampleSize);
+              await appendDecoded(previewDecoder.decode(chunk.subarray(previewChunkOffset, end)));
+              displayedSampleSize += end - previewChunkOffset;
+              previewChunkOffset = end;
+              if (end === chunk.length) {
+                previewChunkIndex++;
+                previewChunkOffset = 0;
+              }
+            }
+          }
+          if (sampleLength < 65540) continue;
+          await startDecoder();
+        } else {
+          await appendDecoded(decoder.decode(value, { stream: true }));
+        }
+      }
+      if (!decoder) await startDecoder();
+      await appendDecoded(decoder.decode());
+    } catch (reason) {
+      try {
+        await reader.cancel(reason);
+      } catch (_) {}
+      throw reason;
+    } finally {
+      untrack();
+      reader.releaseLock();
+    }
+  }
+
+  function detectTextEncoding(bytes, hint = "") {
+    if (bytes[0] === 0xef && bytes[1] === 0xbb && bytes[2] === 0xbf) return "utf-8";
+    if (bytes[0] === 0xff && bytes[1] === 0xfe) return "utf-16le";
+    if (bytes[0] === 0xfe && bytes[1] === 0xff) return "utf-16be";
+    const evenNulls = bytes.filter((value, index) => !value && index % 2 === 0).length;
+    const oddNulls = bytes.filter((value, index) => !value && index % 2 === 1).length;
+    if (oddNulls > bytes.length / 8 && oddNulls > evenNulls * 4) return "utf-16le";
+    if (evenNulls > bytes.length / 8 && evenNulls > oddNulls * 4) return "utf-16be";
+    try {
+      new TextDecoder("utf-8", { fatal: true }).decode(bytes, { stream: true });
+      return "utf-8";
+    } catch (_) {}
+    if (/[\u0400-\u04ff]/.test(hint)) return "windows-1251";
+    const candidates = /[\u3400-\u9fff]/.test(hint)
+      ? ["gb18030", "big5"]
+      : ["gb18030", "big5", "windows-1251", "windows-1252"];
+    let best = "gb18030",
+      bestScore = -Infinity;
+    for (const encoding of candidates) {
+      try {
+        const text = new TextDecoder(encoding).decode(bytes);
+        const controls = (text.match(/[\u0000-\u0008\u000b\u000c\u000e-\u001f]/g) || []).length;
+        const replacements = (text.match(/\ufffd/g) || []).length;
+        const cjk = (text.match(/[\u3400-\u9fff]/g) || []).length;
+        const cyrillic = (text.match(/[\u0400-\u04ff]/g) || []).length;
+        const commonCjk = (
+          text.match(
+            /[的一是在不了有和人这中大为上个国我以要他时来用们生到作地于出就分对成会可主发年动同工也能下过子说产种面而方后多定行学法所民得经之进着等部家自理起现实都体制当本性应开合因由然前外政社义事相全与关各重新内正反明原利质向道命此变结解问意建公系军情者立代通题党程展料员革文总品活长求老基资级图统知组别期论运农指区战任处理世]/g
+          ) || []
+        ).length;
+        const score = Math.max(cjk + commonCjk * 5, cyrillic) - controls * 20 - replacements * 40;
+        if (score > bestScore) {
+          best = encoding;
+          bestScore = score;
+        }
+      } catch (_) {}
+    }
+    return best;
+  }
+
+  function renderTextDocument(prepared) {
+    return readerContext.renderText(false, prepared);
+  }
+
+  function renderMarkdownDocument(prepared) {
+    return readerContext.renderText(true, prepared);
+  }
+
+  return {
+    renderPlainText,
+    detectTextEncoding,
+    renderTextDocument,
+    renderMarkdownDocument
+  };
+}

static/{pdf-worker-wrapper.mjs → reader/pdf/pdf-worker-wrapper.mjs}

@@ -19,12 +19,12 @@ if (!Math.sumPrecise) {
   };
 }
 
-import "./reader-resources.js";
+import "../../reader-resources.js";
 const pendingMessages = [];
 const bufferMessage = event => pendingMessages.push(event);
 self.addEventListener("message", bufferMessage);
 
-import(VoiceOfMLReaderResources.vendorUrl("pdfWorker", "./")).then(() => {
+import(VoiceOfMLReaderResources.vendorUrl("pdfWorker", "../../")).then(() => {
   self.removeEventListener("message", bufferMessage);
   for (const event of pendingMessages) self.dispatchEvent(new MessageEvent("message", { data: event.data }));
 });

static/{reader-engine-preload.js → reader/pdf/reader-engine-preload.js}

@@ -4,7 +4,7 @@
   let pdf = params.get("ext")?.toLowerCase() === "pdf";
   try { pdf ||= new URL(params.get("url")).pathname.toLowerCase().endsWith(".pdf"); } catch (_) {}
   if (!pdf) return;
-  const base = new URL(".", document.currentScript.src).href;
+  const base = new URL("../../", document.currentScript.src).href;
   for (const name of ["pdf", "pdfWorker"]) {
     const link = document.createElement("link");
     link.rel = "modulepreload";