fix: streamline inline review editing controls

apps/readest-app/.claude/memory/epub-review-editor-migration.md

@@ -2,24 +2,32 @@
 
 Date: 2026-07-08
 
-This fork includes a first-stage migration of the Chinese/Japanese EPUB review editor into Readest.
+This fork includes a desktop migration of the Chinese/Japanese EPUB review editor into Readest.
 
 Current shape:
 - Bundled sidecar lives at `apps/readest-app/tools/epub-review-editor`.
 - Readest route is `/review-editor`.
 - Library menu entry is `Settings Menu -> Advanced Settings -> EPUB 审校器`.
 - Dev launcher API is `POST /api/review-editor/launch`.
+- Desktop launcher command is `launch_epub_review_editor`.
 - Dev script is `pnpm epub-reviewer:dev`.
 - Default runtime data is `apps/readest-app/epub_review_sessions/`; it is ignored by git. Override with `READEST_REVIEW_ROOT`.
-- The automatic launcher is deliberately gated to local `dev-web`; packaged Tauri/static export needs a Rust command or packaged sidecar.
+- The automatic launcher now works in Tauri desktop through the Rust command and keeps local `dev-web` as a fallback.
+- `/review-editor` is the desktop feature-block page for both 校对 and 翻译. It now uses native React blocks as the main work surface and calls the local sidecar APIs directly.
+- Readest EPUB bookshelf context menus can open the reviewer in 校对 or 翻译 mode. The native file path is handed to the Tauri command, which creates/reuses a sidecar session and returns `sessionId`; the Readest page should use `session_id`, not keep `epub_path` in the URL.
+- The old `static/index.html` UI remains bundled only as standalone/debug fallback. Do not treat an iframe of the old UI as the desktop migration acceptance path.
 
 Important boundary:
-- This is not a full native rewrite yet. The migrated tool still uses the proven Flask backend and static UI from the previous long-term translation project.
-- Next/Tauri production static export will need a Tauri desktop command or packaged sidecar before this becomes a production desktop feature.
+- This is not a full native rewrite yet. The migrated tool still uses the proven Flask backend from the previous long-term translation project.
+- The production desktop path still depends on local Python/venv/pip as a temporary sidecar runtime. Next step should package a controlled runtime or convert the hot APIs to native Rust/Tauri commands.
 - Do not remove existing review-editor behavior while migrating: bookshelf, upload, bilingual review, glossary editing, GPT retranslate, full-book AI translation, soft delete, duplicate translation layer prevention, ruby preservation.
 - If `/review-editor` shows `ERR_BLOCKED_BY_RESPONSE`, check both sides of cross-origin isolation: the Readest route keeps COEP `require-corp`, and the sidecar response should include local `frame-ancestors`, `Cross-Origin-Embedder-Policy: require-corp`, and `Cross-Origin-Resource-Policy: cross-origin`.
+- If React blocks cannot fetch the sidecar, check restricted CORS in `server.py`; allowed origins are local Readest dev and Tauri origins only.
 
 Next recommended steps:
-1. Move launching from the Next dev API route into a Tauri desktop command.
-2. Add per-book "Open in EPUB Reviewer" actions from Readest bookshelf/detail views.
-3. Gradually port the review UI into React after the sidecar entry is stable.
+1. Package the Python sidecar/runtime or replace it with native Tauri commands so desktop users do not need a system Python installation.
+2. Add a launch token / origin guard for the loopback sidecar API before wider distribution.
+3. Gradually port long-tail review-editor surfaces into React: glossary editing, full bookshelf classification UI, richer chapter navigation, and reading-position restore.
+
+Desktop latest-version entrypoint:
+- `scripts/open-readest-latest.ps1` and `scripts/open-readest-latest.cmd` are the stable desktop shortcut targets. They fetch `akai-tools/codex/desktop-review-editor-blocks`, fast-forward only on a clean worktree, update submodules/dependencies when needed, then start `pnpm --filter @readest/readest-app tauri dev`. Do not point the user shortcut directly at `target/debug/Readest.exe`, because that can launch stale code or miss the Next/Tauri dev server.

apps/readest-app/public/locales/en/translation.json

@@ -69,6 +69,11 @@
   "Imported {{count}} annotations_one": "Imported {{count}} annotation",
   "Imported {{count}} annotations_other": "Imported {{count}} annotations",
   "Recently read": "Recently read",
+  "All Books": "All Books",
+  "Categories": "Categories",
+  "Category": "Category",
+  "Publication Year": "Publication Year",
+  "Bilingual": "Bilingual",
   "Show recently read": "Show recently read",
   "Your books will appear here": "Your books will appear here",
   "{{count}} results_one": "{{count}} result",

apps/readest-app/public/locales/zh-CN/translation.json

@@ -9,7 +9,12 @@
   "Apply": "应用",
   "Auto Mode": "自动主题",
   "Behavior": "行为",
+  "Bilingual": "双语拆分",
   "Book": "书籍",
+  "All Books": "全部书籍",
+  "Categories": "分类",
+  "Category": "类别",
+  "Publication Year": "出版年份",
   "Bookmark": "书签",
   "Cancel": "取消",
   "Chapter": "章节",

apps/readest-app/public/locales/zh-TW/translation.json

@@ -9,7 +9,12 @@
   "Apply": "應用",
   "Auto Mode": "自動主題",
   "Behavior": "行為",
+  "Bilingual": "雙語拆分",
   "Book": "書籍",
+  "All Books": "全部書籍",
+  "Categories": "分類",
+  "Category": "類別",
+  "Publication Year": "出版年份",
   "Bookmark": "書籤",
   "Cancel": "取消",
   "Chapter": "章節",

apps/readest-app/src-tauri/src/lib.rs

@@ -33,6 +33,8 @@ mod mobi_parser;
 mod nightly_update;
 mod parser_common;
 mod range_file;
+#[cfg(desktop)]
+mod review_editor;
 mod sentry_config;
 #[cfg(desktop)]
 mod spawn_fresh_browser;
@@ -397,6 +399,8 @@ pub fn run() {
             set_webview_info,
             #[cfg(desktop)]
             is_updater_disabled,
+            #[cfg(desktop)]
+            review_editor::launch_epub_review_editor,
             allow_paths_in_scopes,
             dir_scanner::read_dir,
             epub_parser::parse_epub_metadata,

apps/readest-app/src-tauri/src/review_editor.rs

@@ -0,0 +1,465 @@
+use serde::Serialize;
+use serde_json::Value;
+use std::sync::Mutex;
+use std::{
+    fs,
+    io::{Read, Write},
+    net::{SocketAddr, TcpStream},
+    path::{Path, PathBuf},
+    process::Command,
+    time::Duration,
+};
+use tauri::{AppHandle, Manager};
+
+const DEFAULT_PORT: u16 = 5177;
+const PORT_SCAN_LIMIT: u16 = 100;
+static LAUNCH_LOCK: Mutex<()> = Mutex::new(());
+
+#[derive(Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ReviewEditorLaunchResponse {
+    ok: bool,
+    url: String,
+    reused: bool,
+    review_root: String,
+    version: String,
+    session_id: Option<String>,
+}
+
+struct CommandOutput {
+    stdout: String,
+    stderr: String,
+}
+
+struct PythonCommand {
+    program: String,
+    args: Vec<String>,
+}
+
+#[tauri::command]
+pub async fn launch_epub_review_editor(
+    app: AppHandle,
+    epub_path: Option<String>,
+) -> Result<ReviewEditorLaunchResponse, String> {
+    tauri::async_runtime::spawn_blocking(move || launch_epub_review_editor_sync(&app, epub_path))
+        .await
+        .map_err(|err| err.to_string())?
+}
+
+fn launch_epub_review_editor_sync(
+    app: &AppHandle,
+    epub_path: Option<String>,
+) -> Result<ReviewEditorLaunchResponse, String> {
+    let _launch_guard = LAUNCH_LOCK
+        .lock()
+        .map_err(|_| "审校器启动锁已损坏。请重启 Readest 后重试。".to_string())?;
+    let tool_root = resolve_tool_root(app)?;
+    let server_path = tool_root.join("server.py");
+    if !server_path.exists() {
+        return Err(format!(
+            "没有找到审校器后端：{}",
+            server_path.to_string_lossy()
+        ));
+    }
+
+    let review_root = std::env::var("READEST_REVIEW_ROOT")
+        .map(PathBuf::from)
+        .unwrap_or_else(|_| {
+            app.path()
+                .app_data_dir()
+                .unwrap_or_else(|_| std::env::current_dir().unwrap_or_else(|_| PathBuf::from(".")))
+                .join("epub_review_sessions")
+        });
+    fs::create_dir_all(&review_root).map_err(|err| {
+        format!(
+            "创建审校数据目录失败：{} ({err})",
+            review_root.to_string_lossy()
+        )
+    })?;
+
+    let expected_version = read_expected_version(&tool_root);
+    if let Some(url) = find_running_editor(expected_version.as_deref(), &review_root) {
+        let session_id = ensure_session_from_path(&url, epub_path.as_deref())?;
+        return Ok(ReviewEditorLaunchResponse {
+            ok: true,
+            url,
+            reused: true,
+            review_root: review_root.to_string_lossy().to_string(),
+            version: expected_version.unwrap_or_default(),
+            session_id,
+        });
+    }
+
+    let runtime_root = app
+        .path()
+        .app_data_dir()
+        .unwrap_or_else(|_| review_root.clone())
+        .join("epub-review-editor-runtime");
+    let venv_root = runtime_root.join(".venv");
+    let venv_python = venv_python_path(&venv_root);
+
+    ensure_venv(&venv_python, &venv_root)?;
+    ensure_dependencies(&venv_python, &tool_root)?;
+
+    let output = run_command(
+        &venv_python.to_string_lossy(),
+        &[
+            server_path.to_string_lossy().to_string(),
+            "--review-root".to_string(),
+            review_root.to_string_lossy().to_string(),
+            "--host".to_string(),
+            "127.0.0.1".to_string(),
+            "--port".to_string(),
+            DEFAULT_PORT.to_string(),
+            "--daemon".to_string(),
+            "--no-browser".to_string(),
+        ],
+        Some(&tool_root),
+    )?;
+
+    let launched_url = extract_url(&output.stdout)
+        .or_else(|| find_running_editor(expected_version.as_deref(), &review_root))
+        .ok_or_else(|| {
+            format!(
+                "审校器已启动但没有返回访问地址。\nstdout:\n{}\nstderr:\n{}",
+                output.stdout, output.stderr
+            )
+        })?;
+
+    let launched_url = launched_url.replace("http://localhost:", "http://127.0.0.1:");
+    let session_id = ensure_session_from_path(&launched_url, epub_path.as_deref())?;
+
+    Ok(ReviewEditorLaunchResponse {
+        ok: true,
+        url: launched_url,
+        reused: false,
+        review_root: review_root.to_string_lossy().to_string(),
+        version: expected_version.unwrap_or_default(),
+        session_id,
+    })
+}
+
+fn resolve_tool_root(app: &AppHandle) -> Result<PathBuf, String> {
+    if let Ok(raw) = std::env::var("READEST_REVIEW_EDITOR_TOOL_ROOT") {
+        let path = PathBuf::from(raw);
+        if path.join("server.py").exists() {
+            return Ok(path);
+        }
+    }
+
+    if let Ok(resource_dir) = app.path().resource_dir() {
+        for candidate in [
+            resource_dir.join("tools").join("epub-review-editor"),
+            resource_dir
+                .join("apps")
+                .join("readest-app")
+                .join("tools")
+                .join("epub-review-editor"),
+        ] {
+            if candidate.join("server.py").exists() {
+                return Ok(candidate);
+            }
+        }
+    }
+
+    #[cfg(debug_assertions)]
+    if let Ok(current) = std::env::current_dir() {
+        for ancestor in current.ancestors() {
+            for candidate in [
+                ancestor.join("tools").join("epub-review-editor"),
+                ancestor
+                    .join("apps")
+                    .join("readest-app")
+                    .join("tools")
+                    .join("epub-review-editor"),
+            ] {
+                if candidate.join("server.py").exists() {
+                    return Ok(candidate);
+                }
+            }
+        }
+    }
+
+    Err("没有找到已迁移的 EPUB 审校器资源目录。".to_string())
+}
+
+fn ensure_venv(venv_python: &Path, venv_root: &Path) -> Result<(), String> {
+    if venv_python.exists() {
+        return Ok(());
+    }
+    if let Some(parent) = venv_root.parent() {
+        fs::create_dir_all(parent).map_err(|err| {
+            format!(
+                "创建审校器运行目录失败：{} ({err})",
+                parent.to_string_lossy()
+            )
+        })?;
+    }
+    let python = resolve_python_command()?;
+    let mut args = python.args;
+    args.extend([
+        "-m".to_string(),
+        "venv".to_string(),
+        venv_root.to_string_lossy().to_string(),
+    ]);
+    run_command(&python.program, &args, None)?;
+    Ok(())
+}
+
+fn ensure_dependencies(venv_python: &Path, tool_root: &Path) -> Result<(), String> {
+    let check = run_command_allow_failure(
+        &venv_python.to_string_lossy(),
+        &[
+            "-c".to_string(),
+            "import importlib.util, sys; sys.exit(0 if importlib.util.find_spec('flask') else 1)"
+                .to_string(),
+        ],
+        Some(tool_root),
+    )?;
+    if check.0 {
+        return Ok(());
+    }
+
+    let requirements = tool_root.join("requirements.txt");
+    run_command(
+        &venv_python.to_string_lossy(),
+        &[
+            "-m".to_string(),
+            "pip".to_string(),
+            "install".to_string(),
+            "-r".to_string(),
+            requirements.to_string_lossy().to_string(),
+        ],
+        Some(tool_root),
+    )?;
+    Ok(())
+}
+
+fn venv_python_path(venv_root: &Path) -> PathBuf {
+    if cfg!(windows) {
+        venv_root.join("Scripts").join("python.exe")
+    } else {
+        venv_root.join("bin").join("python")
+    }
+}
+
+fn resolve_python_command() -> Result<PythonCommand, String> {
+    let candidates: Vec<PythonCommand> = if cfg!(windows) {
+        vec![
+            PythonCommand {
+                program: "py".to_string(),
+                args: vec!["-3".to_string()],
+            },
+            PythonCommand {
+                program: "python".to_string(),
+                args: vec![],
+            },
+            PythonCommand {
+                program: "python3".to_string(),
+                args: vec![],
+            },
+        ]
+    } else {
+        vec![
+            PythonCommand {
+                program: "python3".to_string(),
+                args: vec![],
+            },
+            PythonCommand {
+                program: "python".to_string(),
+                args: vec![],
+            },
+        ]
+    };
+
+    for candidate in candidates {
+        let mut args = candidate.args.clone();
+        args.push("--version".to_string());
+        if run_command_allow_failure(&candidate.program, &args, None)
+            .map(|(ok, _)| ok)
+            .unwrap_or(false)
+        {
+            return Ok(candidate);
+        }
+    }
+    Err("没有找到 Python 3。请先安装 Python 3，然后重新打开 EPUB 审校器。".to_string())
+}
+
+fn read_expected_version(tool_root: &Path) -> Option<String> {
+    let text = fs::read_to_string(tool_root.join("version.py")).ok()?;
+    let marker = "version = \"";
+    let start = text.find(marker)? + marker.len();
+    let rest = &text[start..];
+    Some(rest[..rest.find('"')?].to_string())
+}
+
+fn find_running_editor(expected_version: Option<&str>, review_root: &Path) -> Option<String> {
+    let expected_root = review_root
+        .canonicalize()
+        .unwrap_or_else(|_| review_root.to_path_buf());
+    for port in DEFAULT_PORT..(DEFAULT_PORT + PORT_SCAN_LIMIT) {
+        let Some(payload) = request_json(port, "/api/version") else {
+            continue;
+        };
+        let Some(version) = payload.get("version").and_then(Value::as_str) else {
+            continue;
+        };
+        if expected_version.map_or(true, |expected| expected == version) {
+            let running_root = payload
+                .get("review_root")
+                .and_then(Value::as_str)
+                .map(PathBuf::from);
+            let running_root_matches = running_root
+                .as_ref()
+                .and_then(|path| path.canonicalize().ok())
+                .map(|path| path == expected_root)
+                .unwrap_or(false);
+            if !running_root_matches {
+                continue;
+            }
+            return Some(format!("http://127.0.0.1:{port}"));
+        }
+    }
+    None
+}
+
+fn request_json(port: u16, path: &str) -> Option<Value> {
+    let addr = SocketAddr::from(([127, 0, 0, 1], port));
+    let mut stream = TcpStream::connect_timeout(&addr, Duration::from_millis(250)).ok()?;
+    let _ = stream.set_read_timeout(Some(Duration::from_millis(800)));
+    let _ = stream.set_write_timeout(Some(Duration::from_millis(800)));
+    let request = format!("GET {path} HTTP/1.1\r\nHost: 127.0.0.1\r\nConnection: close\r\n\r\n");
+    stream.write_all(request.as_bytes()).ok()?;
+    read_http_json_response(stream)
+}
+
+fn post_json(url: &str, path: &str, body: &str) -> Result<Value, String> {
+    let port = parse_loopback_port(url)?;
+    let addr = SocketAddr::from(([127, 0, 0, 1], port));
+    let mut stream = TcpStream::connect_timeout(&addr, Duration::from_secs(3))
+        .map_err(|err| format!("连接审校器失败：{err}"))?;
+    let _ = stream.set_read_timeout(Some(Duration::from_secs(30)));
+    let _ = stream.set_write_timeout(Some(Duration::from_secs(5)));
+    let request = format!(
+        "POST {path} HTTP/1.1\r\nHost: 127.0.0.1\r\nContent-Type: application/json\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}",
+        body.len(),
+        body
+    );
+    stream
+        .write_all(request.as_bytes())
+        .map_err(|err| format!("写入审校器请求失败：{err}"))?;
+    read_http_json_response_result(stream)
+}
+
+fn read_http_json_response(mut stream: TcpStream) -> Option<Value> {
+    let mut response = String::new();
+    stream.read_to_string(&mut response).ok()?;
+    if !response.starts_with("HTTP/1.1 200") && !response.starts_with("HTTP/1.0 200") {
+        return None;
+    }
+    let body = response.split("\r\n\r\n").nth(1)?;
+    serde_json::from_str(body).ok()
+}
+
+fn read_http_json_response_result(mut stream: TcpStream) -> Result<Value, String> {
+    let mut response = String::new();
+    stream
+        .read_to_string(&mut response)
+        .map_err(|err| format!("读取审校器响应失败：{err}"))?;
+    let status_line = response.lines().next().unwrap_or_default().to_string();
+    let body = response.split("\r\n\r\n").nth(1).unwrap_or("");
+    let payload = serde_json::from_str::<Value>(body).unwrap_or(Value::Null);
+    if status_line.starts_with("HTTP/1.1 200") || status_line.starts_with("HTTP/1.0 200") {
+        if payload.is_null() {
+            return Err("审校器返回了空响应。".to_string());
+        }
+        return Ok(payload);
+    }
+    let message = payload
+        .get("error")
+        .and_then(Value::as_str)
+        .unwrap_or(status_line.as_str());
+    Err(message.to_string())
+}
+
+fn parse_loopback_port(url: &str) -> Result<u16, String> {
+    let rest = url
+        .strip_prefix("http://127.0.0.1:")
+        .or_else(|| url.strip_prefix("http://localhost:"))
+        .ok_or_else(|| format!("审校器地址不是本机 HTTP 地址：{url}"))?;
+    let port_text = rest.split('/').next().unwrap_or(rest);
+    port_text
+        .parse::<u16>()
+        .map_err(|err| format!("无法解析审校器端口：{port_text} ({err})"))
+}
+
+fn ensure_session_from_path(url: &str, epub_path: Option<&str>) -> Result<Option<String>, String> {
+    let Some(raw_path) = epub_path.map(str::trim).filter(|value| !value.is_empty()) else {
+        return Ok(None);
+    };
+    let body = serde_json::json!({ "epub_path": raw_path, "activate": false }).to_string();
+    let payload = post_json(url, "/api/session/from-path", &body)?;
+    Ok(payload
+        .get("id")
+        .and_then(Value::as_str)
+        .map(ToOwned::to_owned))
+}
+
+fn run_command(
+    program: &str,
+    args: &[String],
+    cwd: Option<&Path>,
+) -> Result<CommandOutput, String> {
+    let (ok, output) = run_command_allow_failure(program, args, cwd)?;
+    if ok {
+        Ok(output)
+    } else {
+        Err(format!(
+            "命令执行失败：{} {}\nstdout:\n{}\nstderr:\n{}",
+            program,
+            args.join(" "),
+            output.stdout,
+            output.stderr
+        ))
+    }
+}
+
+fn run_command_allow_failure(
+    program: &str,
+    args: &[String],
+    cwd: Option<&Path>,
+) -> Result<(bool, CommandOutput), String> {
+    let mut command = Command::new(program);
+    command.args(args);
+    if let Some(cwd) = cwd {
+        command.current_dir(cwd);
+    }
+    command.stdin(std::process::Stdio::null());
+    hide_command_window(&mut command);
+    let output = command
+        .output()
+        .map_err(|err| format!("无法执行命令 {program}: {err}"))?;
+    Ok((
+        output.status.success(),
+        CommandOutput {
+            stdout: String::from_utf8_lossy(&output.stdout).to_string(),
+            stderr: String::from_utf8_lossy(&output.stderr).to_string(),
+        },
+    ))
+}
+
+#[cfg(windows)]
+fn hide_command_window(command: &mut Command) {
+    use std::os::windows::process::CommandExt;
+    const CREATE_NO_WINDOW: u32 = 0x08000000;
+    command.creation_flags(CREATE_NO_WINDOW);
+}
+
+#[cfg(not(windows))]
+fn hide_command_window(_command: &mut Command) {}
+
+fn extract_url(text: &str) -> Option<String> {
+    text.split_whitespace()
+        .find(|part| part.starts_with("http://") || part.starts_with("https://"))
+        .map(ToOwned::to_owned)
+}

apps/readest-app/src-tauri/tauri.conf.json

@@ -49,7 +49,15 @@
       "icons/icon.icns",
       "icons/icon.ico"
     ],
-    "resources": [],
+    "resources": {
+      "../tools/epub-review-editor/server.py": "tools/epub-review-editor/server.py",
+      "../tools/epub-review-editor/version.py": "tools/epub-review-editor/version.py",
+      "../tools/epub-review-editor/requirements.txt": "tools/epub-review-editor/requirements.txt",
+      "../tools/epub-review-editor/README.md": "tools/epub-review-editor/README.md",
+      "../tools/epub-review-editor/MAINTENANCE.md": "tools/epub-review-editor/MAINTENANCE.md",
+      "../tools/epub-review-editor/READEST_MIGRATION.md": "tools/epub-review-editor/READEST_MIGRATION.md",
+      "../tools/epub-review-editor/static/*": "tools/epub-review-editor/static/"
+    },
     "windows": {
       "webviewInstallMode": {
         "type": "embedBootstrapper"

apps/readest-app/src-tauri/tauri.windows.conf.json

@@ -1,7 +1,14 @@
 {
   "bundle": {
     "resources": {
-      "../extensions/windows-thumbnail/target/windows_thumbnail.dll": "readest_thumbnail.dll"
+      "../extensions/windows-thumbnail/target/windows_thumbnail.dll": "readest_thumbnail.dll",
+      "../tools/epub-review-editor/server.py": "tools/epub-review-editor/server.py",
+      "../tools/epub-review-editor/version.py": "tools/epub-review-editor/version.py",
+      "../tools/epub-review-editor/requirements.txt": "tools/epub-review-editor/requirements.txt",
+      "../tools/epub-review-editor/README.md": "tools/epub-review-editor/README.md",
+      "../tools/epub-review-editor/MAINTENANCE.md": "tools/epub-review-editor/MAINTENANCE.md",
+      "../tools/epub-review-editor/READEST_MIGRATION.md": "tools/epub-review-editor/READEST_MIGRATION.md",
+      "../tools/epub-review-editor/static/*": "tools/epub-review-editor/static/"
     }
   }
 }

apps/readest-app/src/__tests__/app/library/book-context-menu.test.ts

@@ -22,6 +22,8 @@ describe('getBookContextMenuItemIds', () => {
       'markFinished',
       'markAbandoned',
       'showDetails',
+      'reviewInEpubEditor',
+      'translateInEpubEditor',
       'showInFinder',
       'searchGoodreads',
       'upload',
@@ -39,6 +41,8 @@ describe('getBookContextMenuItemIds', () => {
       'markAbandoned',
       'clearStatus',
       'showDetails',
+      'reviewInEpubEditor',
+      'translateInEpubEditor',
       'showInFinder',
       'searchGoodreads',
       'upload',
@@ -56,6 +60,8 @@ describe('getBookContextMenuItemIds', () => {
       'markAbandoned',
       'clearStatus',
       'showDetails',
+      'reviewInEpubEditor',
+      'translateInEpubEditor',
       'showInFinder',
       'searchGoodreads',
       'upload',
@@ -72,6 +78,8 @@ describe('getBookContextMenuItemIds', () => {
       'markFinished',
       'clearStatus',
       'showDetails',
+      'reviewInEpubEditor',
+      'translateInEpubEditor',
       'showInFinder',
       'searchGoodreads',
       'upload',
@@ -88,6 +96,8 @@ describe('getBookContextMenuItemIds', () => {
       'markFinished',
       'markAbandoned',
       'showDetails',
+      'reviewInEpubEditor',
+      'translateInEpubEditor',
       'showInFinder',
       'searchGoodreads',
       'download',
@@ -104,6 +114,8 @@ describe('getBookContextMenuItemIds', () => {
       'markFinished',
       'markAbandoned',
       'showDetails',
+      'reviewInEpubEditor',
+      'translateInEpubEditor',
       'showInFinder',
       'searchGoodreads',
       'delete',

apps/readest-app/src/__tests__/components/ReviewModeController.test.ts

@@ -0,0 +1,147 @@
+import { describe, expect, test } from 'vitest';
+
+import { __testing } from '@/app/reader/components/ReviewModeController';
+import type { BookDoc } from '@/libs/document';
+
+describe('ReviewModeController marks', () => {
+  test('marks bilingual source and target paragraphs by file and index', () => {
+    const doc = document.implementation.createHTMLDocument('chapter');
+    doc.body.innerHTML = [
+      '<p class="sourceText">原文一</p>',
+      '<p>译文一</p>',
+      '<p class="sourceText">原文二</p>',
+      '<p>译文二</p>',
+    ].join('');
+
+    __testing.applyReviewMarks(
+      doc,
+      'OEBPS/Text/chapter.xhtml',
+      [
+        {
+          id: 'R00002',
+          file: 'Text/chapter.xhtml',
+          ja_p_index: 2,
+          cn_p_index: 3,
+          jp_html: '原文二',
+          jp_text: '原文二',
+          cn_html: '译文二',
+          current_html: '<span>新译文二</span><script>alert(1)</script>',
+        },
+      ],
+      'R00002',
+    );
+
+    const paragraphs = Array.from(doc.querySelectorAll('p'));
+    expect(paragraphs[2]?.getAttribute('data-readest-review-row-id')).toBe('R00002');
+    expect(paragraphs[2]?.classList.contains('readest-review-source')).toBe(true);
+    expect(paragraphs[3]?.getAttribute('data-readest-review-row-id')).toBe('R00002');
+    expect(paragraphs[3]?.classList.contains('readest-review-target')).toBe(true);
+    expect(paragraphs[3]?.innerHTML).toBe('<span>新译文二</span>');
+  });
+
+  test('uses section id when foliate sections do not expose href', () => {
+    const bookDoc = {
+      sections: [{ id: 'OEBPS/Text/chapter.xhtml' }],
+    } as unknown as BookDoc;
+
+    expect(__testing.sectionHrefAt(bookDoc, 0)).toBe('OEBPS/Text/chapter.xhtml');
+  });
+
+  test('clearReviewMarks restores original target HTML', () => {
+    const doc = document.implementation.createHTMLDocument('chapter');
+    doc.body.innerHTML = '<p class="sourceText">原文</p><p><ruby>旧<rt>old</rt></ruby>译文</p>';
+
+    __testing.applyReviewMarks(
+      doc,
+      'chapter.xhtml',
+      [
+        {
+          id: 'R00001',
+          file: 'chapter.xhtml',
+          ja_p_index: 0,
+          cn_p_index: 1,
+          jp_html: '原文',
+          jp_text: '原文',
+          cn_html: '<ruby>旧<rt>old</rt></ruby>译文',
+          current_html: '<span>新译文</span>',
+        },
+      ],
+      '',
+    );
+
+    __testing.clearReviewMarks(doc);
+
+    const target = doc.querySelectorAll('p')[1];
+    expect(target?.innerHTML).toBe('<ruby>旧<rt>old</rt></ruby>译文');
+    expect(target?.hasAttribute('data-readest-review-row-id')).toBe(false);
+  });
+
+  test('strips event handlers and dangerous links from target HTML', () => {
+    const doc = document.implementation.createHTMLDocument('chapter');
+    doc.body.innerHTML = '<p>原文</p><p>译文</p>';
+
+    __testing.applyReviewMarks(
+      doc,
+      'chapter.xhtml',
+      [
+        {
+          id: 'R00001',
+          file: 'chapter.xhtml',
+          ja_p_index: 0,
+          cn_p_index: 1,
+          jp_html: '原文',
+          jp_text: '原文',
+          cn_html: '译文',
+          current_html: '<span onclick="alert(1)"><a href="javascript:alert(1)">新译文</a></span>',
+        },
+      ],
+      'R00001',
+    );
+
+    const target = doc.querySelectorAll('p')[1];
+    expect(target?.innerHTML).toBe('<span>新译文</span>');
+  });
+
+  test('updates active classes without rewriting translated paragraph HTML', () => {
+    const doc = document.implementation.createHTMLDocument('chapter');
+    doc.body.innerHTML = '<p>原文一</p><p>译文一</p><p>原文二</p><p>译文二</p>';
+
+    __testing.applyReviewMarks(
+      doc,
+      'chapter.xhtml',
+      [
+        {
+          id: 'R00001',
+          file: 'chapter.xhtml',
+          ja_p_index: 0,
+          cn_p_index: 1,
+          jp_html: '原文一',
+          jp_text: '原文一',
+          cn_html: '译文一',
+          current_html: '<span>新译文一</span>',
+        },
+        {
+          id: 'R00002',
+          file: 'chapter.xhtml',
+          ja_p_index: 2,
+          cn_p_index: 3,
+          jp_html: '原文二',
+          jp_text: '原文二',
+          cn_html: '译文二',
+          current_html: '<span>新译文二</span>',
+        },
+      ],
+      'R00001',
+    );
+
+    const target = doc.querySelectorAll('p')[1]!;
+    target.dataset['localState'] = 'kept';
+
+    __testing.applyActiveReviewMark(doc, 'R00002');
+
+    expect(target.innerHTML).toBe('<span>新译文一</span>');
+    expect(target.dataset['localState']).toBe('kept');
+    expect(target.classList.contains('readest-review-active')).toBe(false);
+    expect(doc.querySelectorAll('p')[3]?.classList.contains('readest-review-active')).toBe(true);
+  });
+});

apps/readest-app/src/__tests__/services/reviewEditorService.test.ts

@@ -0,0 +1,121 @@
+import { afterEach, describe, expect, test, vi } from 'vitest';
+
+import {
+  createReviewSessionFromPath,
+  exportReviewedEpub,
+  generateReviewFeedback,
+  loadInlineReviewData,
+  loadReviewGlossary,
+  saveReviewGptConfig,
+  retranslateReviewRow,
+  saveReviewRow,
+  saveReviewGlossary,
+  sidecarApi,
+  switchReviewGlossaryPath,
+} from '@/services/reviewEditorService';
+
+afterEach(() => {
+  vi.unstubAllGlobals();
+});
+
+const stubJsonFetch = () => {
+  const fetchMock = vi.fn(async () =>
+    Response.json({
+      status: 'ok',
+      updated_at: '2026-07-09T00:00:00Z',
+      current_html: '<span>净化译文</span>',
+    }),
+  );
+  vi.stubGlobal('fetch', fetchMock);
+  return fetchMock;
+};
+
+const firstFetchUrl = (fetchMock: ReturnType<typeof vi.fn>) => {
+  const input = fetchMock.mock.calls[0]?.[0];
+  if (input instanceof URL) return input.toString();
+  if (typeof input === 'string') return input;
+  return input?.toString() || '';
+};
+
+describe('reviewEditorService', () => {
+  test('adds session_id to sidecar API calls without mutating endpoint paths', async () => {
+    const fetchMock = stubJsonFetch();
+
+    await sidecarApi('http://127.0.0.1:5177', '/api/rows', {}, 'session-a');
+
+    const url = new URL(firstFetchUrl(fetchMock));
+    expect(url.pathname).toBe('/api/rows');
+    expect(url.searchParams.get('session_id')).toBe('session-a');
+  });
+
+  test('row operations are scoped to the current review session', async () => {
+    const fetchMock = stubJsonFetch();
+
+    await saveReviewRow('http://127.0.0.1:5177', 'session-a', 'R00001', {
+      current_html: '<span>译文</span>',
+      marked: true,
+      issue_type: '误译',
+      severity: '严重',
+      tags: '术语',
+      comment: '备注',
+      learn_note: '长期规则',
+    });
+    await retranslateReviewRow('http://127.0.0.1:5177', 'session-a', 'R00001', '');
+    await generateReviewFeedback('http://127.0.0.1:5177', 'session-a');
+    await exportReviewedEpub('http://127.0.0.1:5177', 'session-a');
+
+    expect(fetchMock).toHaveBeenCalledTimes(4);
+    for (const call of fetchMock.mock.calls as unknown as [
+      string | URL,
+      RequestInit | undefined,
+    ][]) {
+      const input = call[0];
+      const url = new URL(input instanceof URL ? input.toString() : input);
+      expect(url.searchParams.get('session_id')).toBe('session-a');
+    }
+  });
+
+  test('inline launch creates sessions without activating sidecar global session', async () => {
+    const fetchMock = stubJsonFetch();
+
+    await createReviewSessionFromPath('http://127.0.0.1:5177', 'C:/books/demo.epub');
+
+    const calls = fetchMock.mock.calls as unknown as [string | URL, RequestInit][];
+    const body = JSON.parse(String(calls[0]?.[1]?.body || '{}'));
+    expect(body).toMatchObject({
+      epub_path: 'C:/books/demo.epub',
+      activate: false,
+      reset: false,
+    });
+  });
+
+  test('inline bootstrap and config operations are scoped to the current review session', async () => {
+    const fetchMock = vi.fn(async () =>
+      Response.json({
+        has_session: true,
+        rows: [],
+        entries: [],
+      }),
+    );
+    vi.stubGlobal('fetch', fetchMock);
+
+    await loadInlineReviewData('http://127.0.0.1:5177', 'session-a');
+    await saveReviewGptConfig('http://127.0.0.1:5177', 'session-a', {
+      base_url: 'https://api.example.test/v1',
+      model: 'model-a',
+    });
+    await loadReviewGlossary('http://127.0.0.1:5177', 'session-a');
+    await switchReviewGlossaryPath('http://127.0.0.1:5177', 'session-a', 'mingcibiao.json');
+    await saveReviewGlossary('http://127.0.0.1:5177', 'session-a', 'mingcibiao.json', []);
+
+    expect(fetchMock).toHaveBeenCalledTimes(7);
+    for (const call of fetchMock.mock.calls as unknown as [
+      string | URL,
+      RequestInit | undefined,
+    ][]) {
+      const input = call[0];
+      const url = new URL(input instanceof URL ? input.toString() : input);
+      expect(url.searchParams.get('session_id')).toBe('session-a');
+    }
+  });
+});

apps/readest-app/src/__tests__/store/review-mode-store.test.ts

@@ -0,0 +1,102 @@
+import { beforeEach, describe, expect, test } from 'vitest';
+
+import { useReviewModeStore } from '@/store/reviewModeStore';
+
+beforeEach(() => {
+  useReviewModeStore.setState({
+    activeBookKey: null,
+    isPanelVisible: false,
+    isPanelPinned: false,
+    panelWidth: '32%',
+    panelHeight: '68vh',
+    books: {},
+  });
+});
+
+describe('reviewModeStore', () => {
+  test('enables review mode for a book and opens the panel', () => {
+    useReviewModeStore.getState().setBookEnabled('book-a', true);
+
+    const state = useReviewModeStore.getState();
+    expect(state.activeBookKey).toBe('book-a');
+    expect(state.isPanelVisible).toBe(true);
+    expect(state.books['book-a']?.enabled).toBe(true);
+  });
+
+  test('selects rows without replacing loaded review data', () => {
+    useReviewModeStore.getState().setBookData('book-a', {
+      baseUrl: 'http://127.0.0.1:5177',
+      sessionId: 'session-a',
+      rows: [
+        {
+          id: 'R00001',
+          file: 'chapter.xhtml',
+          jp_html: '原文',
+          jp_text: '原文',
+          cn_html: '译文',
+          current_html: '译文',
+        },
+      ],
+    });
+    useReviewModeStore.getState().selectRow('book-a', 'R00001');
+
+    const state = useReviewModeStore.getState();
+    expect(state.activeBookKey).toBe('book-a');
+    expect(state.isPanelVisible).toBe(true);
+    expect(state.books['book-a']?.baseUrl).toBe('http://127.0.0.1:5177');
+    expect(state.books['book-a']?.selectedRowId).toBe('R00001');
+  });
+
+  test('updates one review row after save', () => {
+    useReviewModeStore.getState().setBookData('book-a', {
+      rows: [
+        {
+          id: 'R00001',
+          file: 'chapter.xhtml',
+          jp_html: '原文',
+          jp_text: '原文',
+          cn_html: '旧译文',
+          current_html: '旧译文',
+        },
+      ],
+    });
+
+    useReviewModeStore.getState().updateRow('book-a', {
+      id: 'R00001',
+      file: 'chapter.xhtml',
+      jp_html: '原文',
+      jp_text: '原文',
+      cn_html: '旧译文',
+      current_html: '新译文',
+      edited: true,
+    });
+
+    expect(useReviewModeStore.getState().books['book-a']?.rows[0]?.current_html).toBe('新译文');
+    expect(useReviewModeStore.getState().books['book-a']?.rows[0]?.edited).toBe(true);
+  });
+
+  test('disabling the active book closes the panel', () => {
+    useReviewModeStore.getState().setBookEnabled('book-a', true);
+    useReviewModeStore.getState().setBookEnabled('book-a', false);
+
+    const state = useReviewModeStore.getState();
+    expect(state.activeBookKey).toBeNull();
+    expect(state.isPanelVisible).toBe(false);
+    expect(state.books['book-a']?.enabled).toBe(false);
+  });
+
+  test('clears an active book and closes the panel', () => {
+    useReviewModeStore.getState().setBookEnabled('book-a', true);
+    useReviewModeStore.getState().setBookData('book-a', {
+      baseUrl: 'http://127.0.0.1:5177',
+      sessionId: 'session-a',
+    });
+
+    useReviewModeStore.getState().clearBook('book-a');
+
+    const state = useReviewModeStore.getState();
+    expect(state.books['book-a']).toBeUndefined();
+    expect(state.activeBookKey).toBeNull();
+    expect(state.isPanelVisible).toBe(false);
+  });
+});

apps/readest-app/src/app/layout.tsx

@@ -129,8 +129,16 @@ const devHmrPatchScript = `(${patchTauriHmrWebSocket.toString()})(${JSON.stringi
 // fallback HTML and crash with `Unexpected token '<'`. All runtime-config
 // consumers fall back to `NEXT_PUBLIC_*` envs baked at build time on Tauri.
 const shouldInjectRuntimeConfig = process.env['NEXT_PUBLIC_APP_PLATFORM'] === 'web';
+const shouldUseViewTransitions =
+  process.env['NODE_ENV'] !== 'development' || process.env['NEXT_PUBLIC_APP_PLATFORM'] !== 'web';
 
 export default function RootLayout({ children }: { children: React.ReactNode }) {
+  const app = (
+    <EnvProvider>
+      <Providers>{children}</Providers>
+    </EnvProvider>
+  );
+
   return (
     <html
       lang='en'
@@ -144,13 +152,7 @@ export default function RootLayout({ children }: { children: React.ReactNode })
           <script dangerouslySetInnerHTML={{ __html: devHmrPatchScript }} />
         ) : null}
       </head>
-      <body>
-        <ViewTransitions>
-          <EnvProvider>
-            <Providers>{children}</Providers>
-          </EnvProvider>
-        </ViewTransitions>
-      </body>
+      <body>{shouldUseViewTransitions ? <ViewTransitions>{app}</ViewTransitions> : app}</body>
     </html>
   );
 }

apps/readest-app/src/app/library/components/BilingualFilterAlert.tsx

@@ -0,0 +1,115 @@
+import clsx from 'clsx';
+import * as React from 'react';
+import { useState } from 'react';
+import { LuLanguages } from 'react-icons/lu';
+import { PiX } from 'react-icons/pi';
+import { useKeyDownActions } from '@/hooks/useKeyDownActions';
+import { useTranslation } from '@/hooks/useTranslation';
+import type { BilingualFilterMode, BilingualFilterOptions } from '@/services/bilingualEpubFilter';
+
+interface BilingualFilterAlertProps {
+  bookTitle: string;
+  safeAreaBottom: number;
+  processing: boolean;
+  onCancel: () => void;
+  onFilter: (options: BilingualFilterOptions) => void;
+}
+
+const BilingualFilterAlert: React.FC<BilingualFilterAlertProps> = ({
+  bookTitle,
+  safeAreaBottom,
+  processing,
+  onCancel,
+  onFilter,
+}) => {
+  const _ = useTranslation();
+  const divRef = useKeyDownActions({ onCancel });
+  const [mode, setMode] = useState<BilingualFilterMode>('auto');
+  const [removeUnknown, setRemoveUnknown] = useState(false);
+
+  const handleFilter = (removeLanguage: BilingualFilterOptions['removeLanguage']) => {
+    if (processing) return;
+    onFilter({ removeLanguage, mode, removeUnknown });
+  };
+
+  return (
+    <div
+      ref={divRef}
+      className='fixed bottom-0 left-0 right-0 z-50 flex justify-center px-3'
+      style={{ paddingBottom: `${safeAreaBottom + 16}px` }}
+    >
+      <div
+        className={clsx(
+          'border-base-content/10 bg-base-200/95 flex w-full max-w-xl flex-col gap-4 rounded-2xl border p-4 shadow-lg backdrop-blur-sm',
+          processing && 'pointer-events-none opacity-80',
+        )}
+      >
+        <div className='relative flex min-w-0 items-center justify-center gap-2 pr-8'>
+          <LuLanguages className='size-5 shrink-0' />
+          <div className='min-w-0 truncate text-center text-sm font-medium'>
+            {_('Bilingual EPUB')}: {bookTitle}
+          </div>
+          <button
+            className={clsx(
+              'absolute right-0 flex items-center justify-center rounded-full p-1.5',
+              'text-base-content/70 transition-colors hover:text-base-content',
+            )}
+            onClick={onCancel}
+            aria-label={_('Cancel')}
+            disabled={processing}
+          >
+            <PiX className='size-5' />
+          </button>
+        </div>
+
+        <div className='grid grid-cols-1 gap-3 sm:grid-cols-[minmax(0,1fr)_auto] sm:items-center'>
+          <label className='flex min-w-0 items-center gap-2'>
+            <span className='text-neutral-content shrink-0 text-xs'>{_('Detection')}</span>
+            <select
+              className='select select-bordered select-sm min-w-0 flex-1'
+              value={mode}
+              disabled={processing}
+              onChange={(event) => setMode(event.target.value as BilingualFilterMode)}
+            >
+              <option value='auto'>{_('Auto')}</option>
+              <option value='style'>{_('Style')}</option>
+              <option value='script'>{_('Script')}</option>
+            </select>
+          </label>
+          <label className='flex cursor-pointer items-center gap-2 justify-self-start sm:justify-self-end'>
+            <input
+              type='checkbox'
+              className='checkbox checkbox-sm'
+              checked={removeUnknown}
+              disabled={processing}
+              onChange={(event) => setRemoveUnknown(event.target.checked)}
+            />
+            <span className='text-sm'>{_('Remove uncertain text')}</span>
+          </label>
+        </div>
+
+        <div className='grid grid-cols-1 gap-2 sm:grid-cols-3'>
+          <button
+            className='btn btn-primary btn-sm'
+            disabled={processing}
+            onClick={() => handleFilter('ja')}
+          >
+            {_('Keep Chinese')}
+          </button>
+          <button
+            className='btn btn-secondary btn-sm'
+            disabled={processing}
+            onClick={() => handleFilter('zh')}
+          >
+            {_('Keep Japanese')}
+          </button>
+          <button className='btn btn-ghost btn-sm' disabled={processing} onClick={onCancel}>
+            {processing ? _('Processing...') : _('Cancel')}
+          </button>
+        </div>
+      </div>
+    </div>
+  );
+};
+
+export default BilingualFilterAlert;

apps/readest-app/src/app/library/components/Bookshelf.tsx

@@ -50,6 +50,7 @@ import { eventDispatcher } from '@/utils/event';
 import { getLocalBookFilename } from '@/utils/book';
 import { MIMETYPES, EXTS } from '@/libs/document';
 import { makeSafeFilename } from '@/utils/misc';
+import { getBookCategoryValues, type LibraryCategoryFilter } from '../utils/categoryFilters';
 
 import { useSpatialNavigation } from '../hooks/useSpatialNavigation';
 import DeleteConfirmAlert from '@/components/DeleteConfirmAlert';
@@ -63,6 +64,11 @@ import GroupingModal from './GroupingModal';
 import SetStatusAlert from './SetStatusAlert';
 import RecentShelf, { RECENT_SHELF_BOOK_COUNT } from './RecentShelf';
 import { useOpenBook } from '../hooks/useOpenBook';
+import BilingualFilterAlert from './BilingualFilterAlert';
+import {
+  filterBilingualEpubFile,
+  type BilingualFilterOptions,
+} from '@/services/bilingualEpubFilter';
 
 interface BookshelfProps {
   libraryBooks: Book[];
@@ -83,6 +89,7 @@ interface BookshelfProps {
   handleLibraryNavigation: (targetGroup: string) => void;
   handlePushLibrary: () => Promise<void>;
   booksTransferProgress: { [key: string]: number | null };
+  categoryFilter?: LibraryCategoryFilter;
 }
 
 /**
@@ -170,6 +177,7 @@ const Bookshelf: React.FC<BookshelfProps> = ({
   handleLibraryNavigation,
   handlePushLibrary,
   booksTransferProgress,
+  categoryFilter = 'all',
 }) => {
   const _ = useTranslation();
   const router = useRouter();
@@ -180,6 +188,7 @@ const Bookshelf: React.FC<BookshelfProps> = ({
 
   const groupId = searchParams?.get('group') || '';
   const queryTerm = searchParams?.get('q') || null;
+  const categoryValue = searchParams?.get('categoryValue') || '';
   const viewMode = searchParams?.get('view') || settings.libraryViewMode;
   const storedSortBy = ensureLibrarySortByType(searchParams?.get('sort'), settings.librarySortBy);
   const sortOrder = searchParams?.get('order') || (settings.librarySortAscending ? 'asc' : 'desc');
@@ -199,6 +208,9 @@ const Bookshelf: React.FC<BookshelfProps> = ({
   const [showDeleteAlert, setShowDeleteAlert] = useState(false);
   const [showStatusAlert, setShowStatusAlert] = useState(false);
   const [showGroupingModal, setShowGroupingModal] = useState(false);
+  const [showBilingualFilterAlert, setShowBilingualFilterAlert] = useState(false);
+  const [bilingualFilterBook, setBilingualFilterBook] = useState<Book | null>(null);
+  const [bilingualFilterProcessing, setBilingualFilterProcessing] = useState(false);
   const [importBookUrl] = useState(searchParams?.get('url') || '');
 
   const abortDeletionRef = useRef(false);
@@ -241,10 +253,20 @@ const Bookshelf: React.FC<BookshelfProps> = ({
     [router, searchParams],
   );
 
+  const categoryFilteredBooks = useMemo(() => {
+    if (categoryFilter === 'all' || !categoryValue) return libraryBooks;
+    return libraryBooks.filter(
+      (book) =>
+        !book.deletedAt && getBookCategoryValues(book, categoryFilter).includes(categoryValue),
+    );
+  }, [libraryBooks, categoryFilter, categoryValue]);
+
   const filteredBooks = useMemo(() => {
     const bookFilter = createBookFilter(queryTerm);
-    return queryTerm ? libraryBooks.filter((book) => bookFilter(book)) : libraryBooks;
-  }, [libraryBooks, queryTerm]);
+    return queryTerm
+      ? categoryFilteredBooks.filter((book) => bookFilter(book))
+      : categoryFilteredBooks;
+  }, [categoryFilteredBooks, queryTerm]);
 
   const currentBookshelfItems = useMemo(() => {
     if (groupBy === LibraryGroupByType.Group) {
@@ -452,6 +474,112 @@ const Bookshelf: React.FC<BookshelfProps> = ({
     setShowStatusAlert(true);
   };
 
+  const getSingleSelectedBook = () => {
+    const ids = getSelectedBooks();
+    if (ids.length !== 1) return;
+    return filteredBooks.find((book) => book.hash === ids[0]);
+  };
+
+  const showBilingualFilterSelection = () => {
+    const book = getSingleSelectedBook();
+    if (!book || book.format !== 'EPUB') return;
+    setBilingualFilterBook(null);
+    setShowSelectModeActions(false);
+    setShowBilingualFilterAlert(true);
+  };
+
+  const showBilingualFilterBook = useCallback(
+    (book: Book) => {
+      if (book.format !== 'EPUB') {
+        eventDispatcher.dispatch('toast', {
+          type: 'warning',
+          message: _('Only EPUB books can be filtered'),
+          timeout: 2500,
+        });
+        return;
+      }
+      setBilingualFilterBook(book);
+      setShowSelectModeActions(false);
+      setShowBilingualFilterAlert(true);
+    },
+    [_],
+  );
+
+  const closeBilingualFilterSelection = () => {
+    if (bilingualFilterProcessing) return;
+    setShowBilingualFilterAlert(false);
+    setBilingualFilterBook(null);
+    if (isSelectMode) setShowSelectModeActions(true);
+  };
+
+  const runBilingualFilter = async (options: BilingualFilterOptions) => {
+    const book = bilingualFilterBook ?? getSingleSelectedBook();
+    if (!book || !appService) return;
+    if (book.format !== 'EPUB') {
+      eventDispatcher.dispatch('toast', {
+        type: 'warning',
+        message: _('Only EPUB books can be filtered'),
+        timeout: 2500,
+      });
+      return;
+    }
+
+    setBilingualFilterProcessing(true);
+    setLoading(true);
+
+    try {
+      if (!(await appService.isBookAvailable(book))) {
+        if (!book.uploadedAt || !(await handleBookDownload(book, { queued: false }))) {
+          throw new Error('Book file is not available locally');
+        }
+      }
+
+      const { file } = await appService.loadBookContent(book);
+      try {
+        const result = await filterBilingualEpubFile(file, options);
+        const importedBook = await appService.importBook(result.file, libraryBooks);
+        if (!importedBook) throw new Error('Failed to import generated EPUB');
+
+        importedBook.group = book.group;
+        importedBook.groupId = book.groupId;
+        importedBook.groupName = book.groupName;
+        importedBook.tags = book.tags;
+        importedBook.updatedAt = Date.now();
+
+        await updateBooks(envConfig, [importedBook]);
+        handlePushLibrary();
+        setSelectedBooks([]);
+        setBilingualFilterBook(null);
+        setShowBilingualFilterAlert(false);
+        handleSetSelectMode(false);
+        eventDispatcher.dispatch('toast', {
+          type: 'success',
+          message: _('Created {{title}}. Removed {{count}} paragraph(s).', {
+            title: importedBook.title || result.title,
+            count: result.stats.removed,
+          }),
+          timeout: 3500,
+        });
+      } finally {
+        const closable = file as File & { close?: () => Promise<void> | void };
+        await closable.close?.();
+      }
+    } catch (error) {
+      console.error('Failed to filter bilingual EPUB:', error);
+      eventDispatcher.dispatch('toast', {
+        type: 'error',
+        message: _('Failed to filter bilingual EPUB'),
+        timeout: 3000,
+      });
+      setBilingualFilterBook(null);
+      setShowBilingualFilterAlert(false);
+      if (isSelectMode) setShowSelectModeActions(true);
+    } finally {
+      setLoading(false);
+      setBilingualFilterProcessing(false);
+    }
+  };
+
   const sendSelectedBook = async () => {
     // "Send" hands the actual book file (epub/pdf/...) to the OS share
     // sheet (UIActivityViewController on iOS, Intent.ACTION_SEND on
@@ -678,6 +806,11 @@ const Bookshelf: React.FC<BookshelfProps> = ({
   );
 
   const selectedBooks = getSelectedBooks();
+  const selectedBilingualBook =
+    selectedBooks.length === 1
+      ? filteredBooks.find((book) => book.hash === selectedBooks[0])
+      : null;
+  const bilingualFilterEnabled = !!selectedBilingualBook && selectedBilingualBook.format === 'EPUB';
   const isGridMode = viewMode === 'grid';
   const hasItems = sortedBookshelfItems.length > 0;
   // In grid mode the Import-Books "+" tile is rendered as an extra grid cell
@@ -791,6 +924,7 @@ const Bookshelf: React.FC<BookshelfProps> = ({
           handleBookDelete={handleBookDelete}
           handleSetSelectMode={handleSetSelectMode}
           handleShowDetailsBook={handleShowDetailsBook}
+          handleBilingualFilterBook={showBilingualFilterBook}
           handleLibraryNavigation={handleLibraryNavigation}
           handleUpdateReadingStatus={handleUpdateReadingStatus}
           transferProgress={
@@ -816,6 +950,7 @@ const Bookshelf: React.FC<BookshelfProps> = ({
       handleBookDelete,
       handleSetSelectMode,
       handleShowDetailsBook,
+      showBilingualFilterBook,
       handleLibraryNavigation,
       handleUpdateReadingStatus,
     ],
@@ -889,9 +1024,20 @@ const Bookshelf: React.FC<BookshelfProps> = ({
           onGroup={groupSelectedBooks}
           onDetails={openBookDetails}
           onStatus={showStatusSelection}
+          onBilingualFilter={showBilingualFilterSelection}
           onSend={sendSelectedBook}
           onDelete={deleteSelectedBooks}
           onCancel={() => handleSetSelectMode(false)}
+          bilingualFilterEnabled={bilingualFilterEnabled}
+        />
+      )}
+      {showBilingualFilterAlert && (bilingualFilterBook || selectedBilingualBook) && (
+        <BilingualFilterAlert
+          bookTitle={(bilingualFilterBook || selectedBilingualBook)?.title || ''}
+          safeAreaBottom={safeAreaInsets?.bottom || 0}
+          processing={bilingualFilterProcessing}
+          onCancel={closeBilingualFilterSelection}
+          onFilter={runBilingualFilter}
         />
       )}
       {showGroupingModal && selectedBooks.length > 0 && (

apps/readest-app/src/app/library/components/BookshelfItem.tsx

@@ -1,20 +1,25 @@
 import clsx from 'clsx';
-import { useCallback } from 'react';
+import { useCallback, useState } from 'react';
 import { useEnv } from '@/context/EnvContext';
 import { useSettingsStore } from '@/store/settingsStore';
 import { useTranslation } from '@/hooks/useTranslation';
+import { useAppRouter } from '@/hooks/useAppRouter';
 import { useLongPress } from '@/hooks/useLongPress';
-import { Menu, type MenuItemOptions } from '@tauri-apps/api/menu';
+import { Menu as TauriMenu } from '@tauri-apps/api/menu';
 import { revealItemInDir } from '@tauri-apps/plugin-opener';
 import { eventDispatcher } from '@/utils/event';
 import { openExternalUrl } from '@/utils/open';
 import { getBookGoodreadsQuery, getGoodreadsSearchUrl } from '@/utils/goodreads';
 import { getOSPlatform } from '@/utils/misc';
 import { throttle } from '@/utils/throttle';
+import { Overlay } from '@/components/Overlay';
+import Menu from '@/components/Menu';
+import MenuItem from '@/components/MenuItem';
 import { LibraryCoverFitType, LibraryViewModeType } from '@/types/settings';
 import { BOOK_UNGROUPED_ID, BOOK_UNGROUPED_NAME } from '@/services/constants';
 import { FILE_REVEAL_LABELS, FILE_REVEAL_PLATFORMS } from '@/utils/os';
 import { Book, BooksGroup, ReadingStatus } from '@/types/book';
+import { navigateToReviewEditor } from '@/utils/nav';
 import {
   getBookContextMenuItemIds,
   type BookContextMenuItemId,
@@ -24,6 +29,17 @@ import BookItem from './BookItem';
 import GroupItem from './GroupItem';
 import { useOpenBook } from '../hooks/useOpenBook';
 
+type WebContextMenuItem = {
+  text: string;
+  action: () => void | Promise<void>;
+};
+
+type WebContextMenuState = {
+  x: number;
+  y: number;
+  items: WebContextMenuItem[];
+} | null;
+
 export const generateBookshelfItems = (
   books: Book[],
   parentGroupName: string,
@@ -103,6 +119,7 @@ interface BookshelfItemProps {
   handleBookDelete: (book: Book, syncBooks?: boolean) => Promise<boolean>;
   handleSetSelectMode: (selectMode: boolean) => void;
   handleShowDetailsBook: (book: Book) => void;
+  handleBilingualFilterBook: (book: Book) => void;
   handleLibraryNavigation: (targetGroup: string) => void;
   handleUpdateReadingStatus: (book: Book, status: ReadingStatus | undefined) => void;
 }
@@ -121,13 +138,16 @@ const BookshelfItem: React.FC<BookshelfItemProps> = ({
   handleBookDownload,
   handleSetSelectMode,
   handleShowDetailsBook,
+  handleBilingualFilterBook,
   handleLibraryNavigation,
   handleUpdateReadingStatus,
 }) => {
   const _ = useTranslation();
+  const router = useAppRouter();
   const { appService } = useEnv();
   const { settings } = useSettingsStore();
-  const { openBook } = useOpenBook({ setLoading, handleBookDownload });
+  const { openBook, makeBookAvailable } = useOpenBook({ setLoading, handleBookDownload });
+  const [webContextMenu, setWebContextMenu] = useState<WebContextMenuState>(null);
 
   const showBookDetailsModal = useCallback(async (book: Book) => {
     handleShowDetailsBook(book);
@@ -145,6 +165,25 @@ const BookshelfItem: React.FC<BookshelfItemProps> = ({
     [isSelectMode, openBook, toggleSelection],
   );
 
+  const openBookInReviewEditor = useCallback(
+    async (book: Book, mode: 'review' | 'translate') => {
+      const available = await makeBookAvailable(book);
+      if (!available) return;
+      const epubPath = await appService?.resolveNativeBookFilePath(book);
+      if (!epubPath) {
+        eventDispatcher.dispatch('toast', {
+          message: _('Book file is not available locally'),
+          type: 'warning',
+        });
+        return;
+      }
+      sessionStorage.setItem('reviewEditorLaunchContext', JSON.stringify({ mode, epubPath }));
+      const params = new URLSearchParams({ mode });
+      navigateToReviewEditor(router, params);
+    },
+    [_, appService, makeBookAvailable, router],
+  );
+
   const handleGroupClick = useCallback(
     (group: BooksGroup) => {
       if (isSelectMode) {
@@ -157,8 +196,7 @@ const BookshelfItem: React.FC<BookshelfItemProps> = ({
     [isSelectMode, handleLibraryNavigation],
   );
 
-  const bookContextMenuHandler = async (book: Book) => {
-    if (!appService?.hasContextMenu) return;
+  const bookContextMenuHandler = async (book: Book, event?: React.MouseEvent) => {
     const osPlatform = getOSPlatform();
     const fileRevealLabel =
       FILE_REVEAL_LABELS[osPlatform as FILE_REVEAL_PLATFORMS] || FILE_REVEAL_LABELS.default;
@@ -166,7 +204,7 @@ const BookshelfItem: React.FC<BookshelfItemProps> = ({
     // in a single Menu.new({ items }) call. Appending items one-by-one with
     // un-awaited Menu.append() promises races on the Tauri IPC boundary and
     // shuffles the order on every open (issue #4389).
-    const itemOptions: Record<BookContextMenuItemId, MenuItemOptions> = {
+    const itemOptions: Record<BookContextMenuItemId, WebContextMenuItem> = {
       select: {
         text: itemSelected ? _('Deselect Book') : _('Select Book'),
         action: async () => {
@@ -214,6 +252,24 @@ const BookshelfItem: React.FC<BookshelfItemProps> = ({
           showBookDetailsModal(book);
         },
       },
+      reviewInEpubEditor: {
+        text: '用 EPUB 审校器校对',
+        action: async () => {
+          await openBookInReviewEditor(book, 'review');
+        },
+      },
+      translateInEpubEditor: {
+        text: '用 EPUB 审校器翻译',
+        action: async () => {
+          await openBookInReviewEditor(book, 'translate');
+        },
+      },
+      bilingual: {
+        text: _('Bilingual'),
+        action: async () => {
+          handleBilingualFilterBook(book);
+        },
+      },
       showInFinder: {
         text: _(fileRevealLabel),
         action: async () => {
@@ -254,16 +310,22 @@ const BookshelfItem: React.FC<BookshelfItemProps> = ({
         },
       },
     };
-    const items = getBookContextMenuItemIds(book).map((id) => itemOptions[id]);
-    const menu = await Menu.new({ items });
-    await menu.popup();
+    const itemIds = getBookContextMenuItemIds(book).filter(
+      (id) => appService?.hasContextMenu || id !== 'showInFinder',
+    );
+    const items = itemIds.map((id) => itemOptions[id]);
+    if (appService?.hasContextMenu) {
+      const menu = await TauriMenu.new({ items });
+      await menu.popup();
+      return;
+    }
+    if (event) setWebContextMenu({ x: event.clientX, y: event.clientY, items });
   };
 
-  const groupContextMenuHandler = async (group: BooksGroup) => {
-    if (!appService?.hasContextMenu) return;
+  const groupContextMenuHandler = async (group: BooksGroup, event?: React.MouseEvent) => {
     // Single Menu.new({ items }) call keeps the order deterministic — see the
     // note in bookContextMenuHandler about the Menu.append() IPC race (#4389).
-    const items: MenuItemOptions[] = [
+    const items: WebContextMenuItem[] = [
       {
         text: itemSelected ? _('Deselect Group') : _('Select Group'),
         action: async () => {
@@ -293,8 +355,12 @@ const BookshelfItem: React.FC<BookshelfItemProps> = ({
         },
       },
     ];
-    const menu = await Menu.new({ items });
-    await menu.popup();
+    if (appService?.hasContextMenu) {
+      const menu = await TauriMenu.new({ items });
+      await menu.popup();
+      return;
+    }
+    if (event) setWebContextMenu({ x: event.clientX, y: event.clientY, items });
   };
 
   // eslint-disable-next-line react-hooks/exhaustive-deps
@@ -330,14 +396,28 @@ const BookshelfItem: React.FC<BookshelfItemProps> = ({
 
   // eslint-disable-next-line react-hooks/exhaustive-deps
   const handleContextMenu = useCallback(
-    throttle(() => {
+    throttle((event?: React.MouseEvent) => {
       if ('format' in item) {
-        bookContextMenuHandler(item as Book);
+        bookContextMenuHandler(item as Book, event);
       } else {
-        groupContextMenuHandler(item as BooksGroup);
+        groupContextMenuHandler(item as BooksGroup, event);
       }
     }, 100),
-    [itemSelected, settings.localBooksDir],
+    [
+      appService?.hasContextMenu,
+      appService?.isMobileApp,
+      handleBookDownload,
+      handleBookUpload,
+      handleBilingualFilterBook,
+      handleGroupBooks,
+      handleSetSelectMode,
+      handleUpdateReadingStatus,
+      item,
+      itemSelected,
+      settings.localBooksDir,
+      showBookDetailsModal,
+      toggleSelection,
+    ],
   );
 
   const { pressing, handlers } = useLongPress(
@@ -348,9 +428,11 @@ const BookshelfItem: React.FC<BookshelfItemProps> = ({
       onTap: () => {
         handleOpenItem();
       },
-      onContextMenu: () => {
+      onContextMenu: (event) => {
         if (appService?.hasContextMenu) {
           handleContextMenu();
+        } else if (!appService?.isMobileApp) {
+          handleContextMenu(event);
         } else if (appService?.isAndroidApp) {
           handleSelectItem();
         }
@@ -380,6 +462,29 @@ const BookshelfItem: React.FC<BookshelfItemProps> = ({
 
   return (
     <div className={clsx(mode === 'grid' ? 'h-full' : 'sm:hover:bg-base-300/50 px-4 sm:px-6')}>
+      {webContextMenu && (
+        <>
+          <Overlay onDismiss={() => setWebContextMenu(null)} className='z-40' />
+          <Menu
+            className='bg-base-100 border-base-300 fixed z-50 min-w-56 rounded-lg border p-1 shadow-xl'
+            style={{ left: webContextMenu.x, top: webContextMenu.y }}
+            onCancel={() => setWebContextMenu(null)}
+          >
+            {webContextMenu.items.map((menuItem) => (
+              <MenuItem
+                key={menuItem.text}
+                label={menuItem.text}
+                noIcon
+                transient
+                onClick={() => {
+                  setWebContextMenu(null);
+                  void menuItem.action();
+                }}
+              />
+            ))}
+          </Menu>
+        </>
+      )}
       <div
         className={clsx(
           'visible-focus-inset-2 group',

apps/readest-app/src/app/library/components/LibrarySidebar.tsx

@@ -0,0 +1,316 @@
+import clsx from 'clsx';
+import React, { useCallback, useMemo, useState } from 'react';
+import { useRouter, useSearchParams } from 'next/navigation';
+import {
+  PiBooks,
+  PiCalendarBlank,
+  PiDotsThreeCircle,
+  PiGear,
+  PiGlobeHemisphereEast,
+  PiHouseLine,
+  PiPlus,
+  PiSelectionAll,
+  PiSelectionAllFill,
+  PiStackSimple,
+  PiTag,
+  PiUser,
+} from 'react-icons/pi';
+import { MdBusiness, MdKeyboardArrowDown, MdKeyboardArrowUp, MdOutlineMenu } from 'react-icons/md';
+import { IoMdCloseCircle } from 'react-icons/io';
+import { FaSearch } from 'react-icons/fa';
+import type { IconType } from 'react-icons';
+import { useTranslation } from '@/hooks/useTranslation';
+import { useResponsiveSize } from '@/hooks/useResponsiveSize';
+import { debounce } from '@/utils/debounce';
+import { navigateToLibrary } from '@/utils/nav';
+import Dropdown from '@/components/Dropdown';
+import ImportMenu from './ImportMenu';
+import SettingsMenu from './SettingsMenu';
+import ViewMenu from './ViewMenu';
+import type { Book } from '@/types/book';
+import {
+  countCategoryValues,
+  ensureLibraryCategoryFilter,
+  type CategoryValue,
+  type LibraryCategoryFilter,
+} from '../utils/categoryFilters';
+
+interface LibrarySidebarProps {
+  books: Book[];
+  isSelectMode: boolean;
+  onPullLibrary: () => void;
+  onImportBooksFromFiles: () => void;
+  onImportBooksFromDirectory?: () => void;
+  onImportBookFromUrl?: () => void;
+  onOpenCatalogManager: () => void;
+  onToggleSelectMode: () => void;
+}
+
+type CategoryItem = {
+  id: LibraryCategoryFilter;
+  label: string;
+  count: number;
+  Icon: IconType;
+  values: CategoryValue[];
+};
+
+const LibrarySidebar: React.FC<LibrarySidebarProps> = ({
+  books,
+  isSelectMode,
+  onPullLibrary,
+  onImportBooksFromFiles,
+  onImportBooksFromDirectory,
+  onImportBookFromUrl,
+  onOpenCatalogManager,
+  onToggleSelectMode,
+}) => {
+  const _ = useTranslation();
+  const router = useRouter();
+  const searchParams = useSearchParams();
+  const iconSize18 = useResponsiveSize(18);
+  const [searchQuery, setSearchQuery] = useState(searchParams?.get('q') ?? '');
+  const activeCategory = ensureLibraryCategoryFilter(searchParams?.get('category'));
+  const activeCategoryValue = searchParams?.get('categoryValue') || '';
+  const [expandedCategories, setExpandedCategories] = useState<Set<LibraryCategoryFilter>>(
+    () => new Set(activeCategory !== 'all' ? [activeCategory] : ['author']),
+  );
+
+  const activeBooks = useMemo(() => books.filter((book) => !book.deletedAt), [books]);
+  const categories: CategoryItem[] = useMemo(() => {
+    const makeCategory = (
+      id: LibraryCategoryFilter,
+      label: string,
+      Icon: IconType,
+    ): CategoryItem => {
+      const values = countCategoryValues(activeBooks, id);
+      return { id, label, count: values.length, Icon, values };
+    };
+
+    return [
+      {
+        id: 'all',
+        label: _('All Books'),
+        count: activeBooks.length,
+        Icon: PiBooks,
+        values: [],
+      },
+      makeCategory('author', _('Authors'), PiUser),
+      makeCategory('publisher', _('Publisher'), MdBusiness),
+      makeCategory('year', _('Publication Year'), PiCalendarBlank),
+      makeCategory('language', _('Language'), PiGlobeHemisphereEast),
+      makeCategory('format', _('Category'), PiStackSimple),
+      makeCategory('subject', _('Subject'), PiHouseLine),
+      makeCategory('tag', _('Tags'), PiTag),
+    ];
+  }, [_, activeBooks]);
+
+  const updateParams = useCallback(
+    (updates: Record<string, string | null>) => {
+      const params = new URLSearchParams(searchParams?.toString());
+      for (const [key, value] of Object.entries(updates)) {
+        if (!value) {
+          params.delete(key);
+        } else {
+          params.set(key, value);
+        }
+      }
+      if (params.get('category') === 'all') params.delete('category');
+      navigateToLibrary(router, params.toString());
+    },
+    [router, searchParams],
+  );
+
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  const debouncedUpdateQueryParam = useCallback(
+    debounce((value: string) => updateParams({ q: value || null }), 500),
+    [updateParams],
+  );
+
+  const handleSearchChange = (event: React.ChangeEvent<HTMLInputElement>) => {
+    const newQuery = event.target.value;
+    setSearchQuery(newQuery);
+    debouncedUpdateQueryParam(newQuery);
+  };
+
+  const clearSearch = () => {
+    setSearchQuery('');
+    debouncedUpdateQueryParam('');
+  };
+
+  const toggleCategory = (category: LibraryCategoryFilter) => {
+    if (category === 'all') {
+      updateParams({ category: null, categoryValue: null, group: null });
+      return;
+    }
+    setExpandedCategories((prev) => {
+      const next = new Set(prev);
+      if (next.has(category)) {
+        next.delete(category);
+      } else {
+        next.add(category);
+      }
+      return next;
+    });
+  };
+
+  const selectCategoryValue = (category: LibraryCategoryFilter, value: string) => {
+    updateParams({ category, categoryValue: value, group: null });
+  };
+
+  return (
+    <aside
+      className={clsx(
+        'library-sidebar bg-base-200/80 border-base-300/70 hidden h-full w-[248px] shrink-0 flex-col border-r md:flex',
+        'pt-[max(env(safe-area-inset-top),0px)]',
+      )}
+    >
+      <div className='exclude-title-bar-mousedown flex min-h-0 flex-1 flex-col px-3 py-3'>
+        <div className='mb-3 flex h-8 items-center gap-2 px-1'>
+          <MdOutlineMenu className='text-base-content/70 h-5 w-5 shrink-0' />
+          <div className='min-w-0 flex-1 truncate text-sm font-semibold'>Readest</div>
+        </div>
+
+        <div className='relative mb-3 flex h-8 items-center'>
+          <span className='text-base-content/45 absolute left-3'>
+            <FaSearch className='h-3.5 w-3.5' />
+          </span>
+          <input
+            type='text'
+            value={searchQuery}
+            placeholder={_('Search Books...')}
+            onChange={handleSearchChange}
+            spellCheck='false'
+            className={clsx(
+              'input input-sm bg-base-100 border-base-300 h-8 w-full rounded-md ps-9 pe-8',
+              'text-sm placeholder:text-base-content/45 focus:outline-none',
+            )}
+          />
+          {searchQuery && (
+            <button
+              type='button'
+              onClick={clearSearch}
+              className='text-base-content/40 hover:text-base-content/70 absolute right-2'
+              aria-label={_('Clear Search')}
+            >
+              <IoMdCloseCircle className='h-4 w-4' />
+            </button>
+          )}
+        </div>
+
+        <nav className='min-h-0 flex-1 overflow-y-auto pb-3' aria-label={_('Categories')}>
+          <div className='space-y-1'>
+            {categories.map(({ id, label, count, Icon, values }) => {
+              const active = (activeCategory || 'all') === id && !activeCategoryValue;
+              const expanded = expandedCategories.has(id);
+              return (
+                <div key={id}>
+                  <button
+                    type='button'
+                    onClick={() => toggleCategory(id)}
+                    className={clsx(
+                      'flex h-9 w-full items-center gap-3 rounded-md px-2 text-sm transition-colors',
+                      active
+                        ? 'bg-base-300 text-base-content'
+                        : 'text-base-content/85 hover:bg-base-300/55',
+                    )}
+                  >
+                    <Icon className='h-4.5 w-4.5 shrink-0' />
+                    <span className='min-w-0 flex-1 truncate text-left'>{label}</span>
+                    {id !== 'all' &&
+                      (expanded ? (
+                        <MdKeyboardArrowUp className='text-base-content/60 h-4 w-4 shrink-0' />
+                      ) : (
+                        <MdKeyboardArrowDown className='text-base-content/60 h-4 w-4 shrink-0' />
+                      ))}
+                    <span className='bg-base-content/30 text-base-100 min-w-5 rounded-full px-1.5 text-center text-[11px] font-medium leading-5'>
+                      {count}
+                    </span>
+                  </button>
+                  {id !== 'all' && expanded && values.length > 0 && (
+                    <div className='mt-1 space-y-1 pb-1 ps-7'>
+                      {values.map((item) => {
+                        const valueActive =
+                          activeCategory === id && activeCategoryValue === item.value;
+                        return (
+                          <button
+                            key={item.value}
+                            type='button'
+                            onClick={() => selectCategoryValue(id, item.value)}
+                            className={clsx(
+                              'flex h-8 w-full items-center gap-2 rounded-md px-2 text-sm transition-colors',
+                              valueActive
+                                ? 'bg-base-300 text-base-content'
+                                : 'text-base-content/80 hover:bg-base-300/45',
+                            )}
+                          >
+                            <span
+                              className={clsx(
+                                'h-4 w-0.5 rounded-full',
+                                valueActive ? 'bg-primary' : 'bg-transparent',
+                              )}
+                            />
+                            <span className='min-w-0 flex-1 truncate text-left'>{item.value}</span>
+                            <span className='bg-base-content/30 text-base-100 min-w-5 rounded-full px-1.5 text-center text-[11px] font-medium leading-5'>
+                              {item.count}
+                            </span>
+                          </button>
+                        );
+                      })}
+                    </div>
+                  )}
+                </div>
+              );
+            })}
+          </div>
+        </nav>
+
+        <div className='border-base-300/70 flex items-center gap-1 border-t pt-2'>
+          <Dropdown
+            label={_('Import Books')}
+            className='exclude-title-bar-mousedown dropdown-top dropdown-start'
+            buttonClassName='btn btn-ghost h-8 min-h-8 w-8 p-0'
+            toggleButton={<PiPlus role='none' size={iconSize18} />}
+          >
+            <ImportMenu
+              onImportBooksFromFiles={onImportBooksFromFiles}
+              onImportBooksFromDirectory={onImportBooksFromDirectory}
+              onImportBookFromUrl={onImportBookFromUrl}
+              onOpenCatalogManager={onOpenCatalogManager}
+            />
+          </Dropdown>
+          <Dropdown
+            label={_('View Menu')}
+            className='exclude-title-bar-mousedown dropdown-top dropdown-start'
+            buttonClassName='btn btn-ghost h-8 min-h-8 w-8 p-0'
+            toggleButton={<PiDotsThreeCircle role='none' size={iconSize18} />}
+          >
+            <ViewMenu />
+          </Dropdown>
+          <button
+            onClick={onToggleSelectMode}
+            aria-label={_('Select Books')}
+            title={_('Select Books')}
+            className='btn btn-ghost h-8 min-h-8 w-8 p-0'
+          >
+            {isSelectMode ? (
+              <PiSelectionAllFill className='h-[18px] w-[18px]' />
+            ) : (
+              <PiSelectionAll className='h-[18px] w-[18px]' />
+            )}
+          </button>
+          <div className='flex-1' />
+          <Dropdown
+            label={_('Settings Menu')}
+            className='exclude-title-bar-mousedown dropdown-top dropdown-start'
+            buttonClassName='btn btn-ghost h-8 min-h-8 w-8 p-0'
+            toggleButton={<PiGear role='none' size={iconSize18} />}
+          >
+            <SettingsMenu onPullLibrary={onPullLibrary} />
+          </Dropdown>
+        </div>
+      </div>
+    </aside>
+  );
+};
+
+export default LibrarySidebar;

apps/readest-app/src/app/library/components/SelectModeActions.tsx

@@ -7,7 +7,7 @@ import {
   MdCheckCircleOutline,
 } from 'react-icons/md';
 import { IoShareSocialOutline } from 'react-icons/io5';
-import { LuFolderPlus } from 'react-icons/lu';
+import { LuFolderPlus, LuLanguages } from 'react-icons/lu';
 import { useKeyDownActions } from '@/hooks/useKeyDownActions';
 import { useTranslation } from '@/hooks/useTranslation';
 import { isMd5 } from '@/utils/md5';
@@ -25,6 +25,7 @@ interface SelectModeActionsProps {
   onGroup: () => void;
   onDetails: () => void;
   onStatus: () => void;
+  onBilingualFilter: () => void;
   // The macOS / iPad share popover is anchored to the selected book's
   // cover (located via its data-book-hash attribute), not to this
   // button — the user's visual focus is on the cover they just tapped.
@@ -32,6 +33,7 @@ interface SelectModeActionsProps {
   onSend: () => void;
   onDelete: () => void;
   onCancel: () => void;
+  bilingualFilterEnabled?: boolean;
 }
 
 const SelectModeActions: React.FC<SelectModeActionsProps> = ({
@@ -42,9 +44,11 @@ const SelectModeActions: React.FC<SelectModeActionsProps> = ({
   onGroup,
   onDetails,
   onStatus,
+  onBilingualFilter,
   onSend,
   onDelete,
   onCancel,
+  bilingualFilterEnabled = false,
 }) => {
   const _ = useTranslation();
 
@@ -110,13 +114,21 @@ const SelectModeActions: React.FC<SelectModeActionsProps> = ({
           <MdInfoOutline />
           <div>{_('Details')}</div>
         </button>
+        <button
+          onClick={onBilingualFilter}
+          className={clsx(
+            'flex flex-col items-center justify-center gap-1',
+            !bilingualFilterEnabled && 'btn-disabled opacity-50',
+          )}
+        >
+          <LuLanguages />
+          <div>{_('Bilingual')}</div>
+        </button>
         {sendEnabled && (
           <button
             onClick={onSend}
             className={clsx(
               'flex flex-col items-center justify-center gap-1',
-              // Wraps to the start of the second row on narrow viewports.
-              'max-[500px]:col-start-1',
               (!hasSingleSelection || !hasValidBooks) && 'btn-disabled opacity-50',
             )}
           >
@@ -128,12 +140,6 @@ const SelectModeActions: React.FC<SelectModeActionsProps> = ({
           onClick={onDelete}
           className={clsx(
             'flex flex-col items-center justify-center gap-1',
-            // Without Send (Linux/Windows/web), Delete needs an explicit
-            // col-start-2 so the wrapped row {Delete, Cancel} stays centred
-            // under the 4-col grid. With Send present, the layout is
-            // {Send, Delete, Cancel} starting at col-start-1, so Delete
-            // naturally lands in col-start-2 without an override.
-            !sendEnabled && 'max-[500px]:col-start-2',
             !hasSelection && 'btn-disabled opacity-50',
           )}
         >

apps/readest-app/src/app/library/components/SettingsMenu.tsx

@@ -436,7 +436,8 @@ const SettingsMenu: React.FC<SettingsMenuProps> = ({ onPullLibrary, setIsDropdow
       <hr aria-hidden='true' className='border-base-200 my-1' />
       <MenuItem label={_('Advanced Settings')}>
         <ul className='ms-0 flex flex-col ps-0 before:hidden'>
-          {process.env['NODE_ENV'] === 'development' && isWebAppPlatform() && (
+          {(isTauriAppPlatform() ||
+            (process.env['NODE_ENV'] === 'development' && isWebAppPlatform())) && (
             <MenuItem label='EPUB 审校器' onClick={handleOpenReviewEditor} />
           )}
           <MenuItem label={_('Backup & Restore')} onClick={handleBackupRestore} />

apps/readest-app/src/app/library/page.tsx

@@ -100,6 +100,8 @@ import {
 } from './utils/libraryUtils';
 import Spinner from '@/components/Spinner';
 import LibraryHeader from './components/LibraryHeader';
+import LibrarySidebar from './components/LibrarySidebar';
+import { ensureLibraryCategoryFilter } from './utils/categoryFilters';
 import Bookshelf from './components/Bookshelf';
 import LibraryEmptyState from './components/LibraryEmptyState';
 import GroupHeader from './components/GroupHeader';
@@ -1592,133 +1594,161 @@ const LibraryPageContent = ({ searchParams }: { searchParams: ReadonlyURLSearchP
   }
 
   const showBookshelf = libraryLoaded || libraryBooks.length > 0;
+  const categoryFilter = ensureLibraryCategoryFilter(searchParams?.get('category'));
 
   return (
     <div
       ref={pageRef}
       aria-label={_('Your Library')}
       className={clsx(
-        'library-page text-base-content full-height flex select-none flex-col overflow-hidden',
+        'library-page text-base-content full-height flex select-none overflow-hidden',
         viewSettings?.isEink ? 'bg-base-100' : 'bg-base-200',
         appService?.hasRoundedWindow && isRoundedWindow && 'window-border rounded-window',
       )}
     >
-      <div
-        className='relative top-0 z-40 w-full'
-        role='banner'
-        tabIndex={-1}
-        aria-label={_('Library Header')}
-      >
-        <LibraryHeader
-          isSelectMode={isSelectMode}
-          isSelectAll={isSelectAll}
-          onPullLibrary={pullLibrary}
-          onImportBooksFromFiles={handleImportBooksFromFiles}
-          onImportBooksFromDirectory={
-            appService?.canReadExternalDir ? handleImportBooksFromDirectory : undefined
-          }
-          onImportBookFromUrl={isTauriAppPlatform() ? () => setShowImportFromUrl(true) : undefined}
-          onOpenCatalogManager={handleShowOPDSDialog}
-          onToggleSelectMode={() => handleSetSelectMode(!isSelectMode)}
-          onSelectAll={handleSelectAll}
-          onDeselectAll={handleDeselectAll}
-        />
+      <LibrarySidebar
+        books={libraryBooks}
+        isSelectMode={isSelectMode}
+        onPullLibrary={pullLibrary}
+        onImportBooksFromFiles={handleImportBooksFromFiles}
+        onImportBooksFromDirectory={
+          appService?.canReadExternalDir ? handleImportBooksFromDirectory : undefined
+        }
+        onImportBookFromUrl={isTauriAppPlatform() ? () => setShowImportFromUrl(true) : undefined}
+        onOpenCatalogManager={handleShowOPDSDialog}
+        onToggleSelectMode={() => handleSetSelectMode(!isSelectMode)}
+      />
+      <div className='flex min-w-0 flex-1 flex-col overflow-hidden'>
+        <div
+          className='relative top-0 z-40 w-full md:hidden'
+          role='banner'
+          tabIndex={-1}
+          aria-label={_('Library Header')}
+        >
+          <LibraryHeader
+            isSelectMode={isSelectMode}
+            isSelectAll={isSelectAll}
+            onPullLibrary={pullLibrary}
+            onImportBooksFromFiles={handleImportBooksFromFiles}
+            onImportBooksFromDirectory={
+              appService?.canReadExternalDir ? handleImportBooksFromDirectory : undefined
+            }
+            onImportBookFromUrl={
+              isTauriAppPlatform() ? () => setShowImportFromUrl(true) : undefined
+            }
+            onOpenCatalogManager={handleShowOPDSDialog}
+            onToggleSelectMode={() => handleSetSelectMode(!isSelectMode)}
+            onSelectAll={handleSelectAll}
+            onDeselectAll={handleDeselectAll}
+          />
+          <progress
+            aria-label={_('Library Sync Progress')}
+            aria-hidden={isSyncing ? 'false' : 'true'}
+            className={clsx(
+              'progress progress-success absolute bottom-0 left-0 right-0 h-1 translate-y-[2px] transition-opacity duration-200 sm:translate-y-[4px]',
+              isSyncing ? 'opacity-100' : 'opacity-0',
+            )}
+            value={syncProgress * 100}
+            max='100'
+          />
+        </div>
         <progress
           aria-label={_('Library Sync Progress')}
           aria-hidden={isSyncing ? 'false' : 'true'}
           className={clsx(
-            'progress progress-success absolute bottom-0 left-0 right-0 h-1 translate-y-[2px] transition-opacity duration-200 sm:translate-y-[4px]',
+            'progress progress-success hidden h-1 rounded-none transition-opacity duration-200 md:block',
             isSyncing ? 'opacity-100' : 'opacity-0',
           )}
           value={syncProgress * 100}
           max='100'
         />
-      </div>
-      {(loading || isSyncing) && (
-        <div className='fixed inset-0 z-50 flex items-center justify-center'>
-          <Spinner loading />
-        </div>
-      )}
-      {currentGroupPath && (
-        <div
-          className={`transition-all duration-300 ease-in-out ${
-            currentGroupPath ? 'opacity-100' : 'max-h-0 opacity-0'
-          }`}
-        >
-          <div className='flex flex-wrap items-center gap-y-1 px-4 text-base'>
-            <button
-              onClick={() => handleNavigateToPath(undefined)}
-              className='hover:bg-base-300 text-base-content/85 rounded px-2 py-1'
-            >
-              {_('All')}
-            </button>
-            {getBreadcrumbs(currentGroupPath).map((crumb, index, array) => {
-              const isLast = index === array.length - 1;
-              return (
-                <React.Fragment key={index}>
-                  <MdChevronRight size={iconSize} className='text-neutral-content' />
-                  {isLast ? (
-                    <span className='truncate rounded px-2 py-1'>{crumb.name}</span>
-                  ) : (
-                    <button
-                      onClick={() => handleNavigateToPath(crumb.path)}
-                      className='hover:bg-base-300 text-base-content/85 truncate rounded px-2 py-1'
-                    >
-                      {crumb.name}
-                    </button>
-                  )}
-                </React.Fragment>
-              );
-            })}
+        {(loading || isSyncing) && (
+          <div className='fixed inset-0 z-50 flex items-center justify-center'>
+            <Spinner loading />
           </div>
-        </div>
-      )}
-      {currentSeriesAuthorGroup && (
-        <GroupHeader
-          groupBy={currentSeriesAuthorGroup.groupBy}
-          groupName={currentSeriesAuthorGroup.groupName}
-        />
-      )}
-      {showBookshelf &&
-        (libraryBooks.some((book) => !book.deletedAt) ? (
-          <div aria-label={_('Your Bookshelf')} className='flex min-h-0 flex-grow flex-col'>
-            <div
-              ref={containerRef}
-              className={clsx(
-                'scroll-container drop-zone flex min-h-0 flex-grow flex-col',
-                isDragging && 'drag-over',
-              )}
-              style={{
-                paddingRight: `${insets.right}px`,
-                paddingLeft: `${insets.left}px`,
-              }}
-            >
-              <DropIndicator />
-              <Bookshelf
-                libraryBooks={libraryBooks}
-                isSelectMode={isSelectMode}
-                isSelectAll={isSelectAll}
-                isSelectNone={isSelectNone}
-                onScrollerRef={handleScrollerRef}
-                handleImportBooks={handleImportBooksFromFiles}
-                handleBookUpload={handleBookUpload}
-                handleBookDownload={handleBookDownload}
-                handleBookDelete={handleBookDelete('both')}
-                handleBookPurge={handleBookDelete('purge')}
-                handleSetSelectMode={handleSetSelectMode}
-                handleShowDetailsBook={handleShowDetailsBook}
-                handleLibraryNavigation={handleLibraryNavigation}
-                booksTransferProgress={booksTransferProgress}
-                handlePushLibrary={pushLibrary}
-              />
+        )}
+        {currentGroupPath && (
+          <div
+            className={`transition-all duration-300 ease-in-out ${
+              currentGroupPath ? 'opacity-100' : 'max-h-0 opacity-0'
+            }`}
+          >
+            <div className='flex flex-wrap items-center gap-y-1 px-4 py-2 text-base'>
+              <button
+                onClick={() => handleNavigateToPath(undefined)}
+                className='hover:bg-base-300 text-base-content/85 rounded px-2 py-1'
+              >
+                {_('All')}
+              </button>
+              {getBreadcrumbs(currentGroupPath).map((crumb, index, array) => {
+                const isLast = index === array.length - 1;
+                return (
+                  <React.Fragment key={index}>
+                    <MdChevronRight size={iconSize} className='text-neutral-content' />
+                    {isLast ? (
+                      <span className='truncate rounded px-2 py-1'>{crumb.name}</span>
+                    ) : (
+                      <button
+                        onClick={() => handleNavigateToPath(crumb.path)}
+                        className='hover:bg-base-300 text-base-content/85 truncate rounded px-2 py-1'
+                      >
+                        {crumb.name}
+                      </button>
+                    )}
+                  </React.Fragment>
+                );
+              })}
             </div>
           </div>
-        ) : (
-          <div className='hero drop-zone h-screen items-center justify-center'>
-            <DropIndicator />
-            <LibraryEmptyState onImport={handleImportBooksFromFiles} />
-          </div>
-        ))}
+        )}
+        {currentSeriesAuthorGroup && (
+          <GroupHeader
+            groupBy={currentSeriesAuthorGroup.groupBy}
+            groupName={currentSeriesAuthorGroup.groupName}
+          />
+        )}
+        {showBookshelf &&
+          (libraryBooks.some((book) => !book.deletedAt) ? (
+            <div aria-label={_('Your Bookshelf')} className='flex min-h-0 flex-grow flex-col'>
+              <div
+                ref={containerRef}
+                className={clsx(
+                  'scroll-container drop-zone flex min-h-0 flex-grow flex-col',
+                  isDragging && 'drag-over',
+                )}
+                style={{
+                  paddingRight: `${insets.right}px`,
+                  paddingLeft: `${insets.left}px`,
+                }}
+              >
+                <DropIndicator />
+                <Bookshelf
+                  libraryBooks={libraryBooks}
+                  categoryFilter={categoryFilter}
+                  isSelectMode={isSelectMode}
+                  isSelectAll={isSelectAll}
+                  isSelectNone={isSelectNone}
+                  onScrollerRef={handleScrollerRef}
+                  handleImportBooks={handleImportBooksFromFiles}
+                  handleBookUpload={handleBookUpload}
+                  handleBookDownload={handleBookDownload}
+                  handleBookDelete={handleBookDelete('both')}
+                  handleBookPurge={handleBookDelete('purge')}
+                  handleSetSelectMode={handleSetSelectMode}
+                  handleShowDetailsBook={handleShowDetailsBook}
+                  handleLibraryNavigation={handleLibraryNavigation}
+                  booksTransferProgress={booksTransferProgress}
+                  handlePushLibrary={pushLibrary}
+                />
+              </div>
+            </div>
+          ) : (
+            <div className='hero drop-zone h-screen items-center justify-center'>
+              <DropIndicator />
+              <LibraryEmptyState onImport={handleImportBooksFromFiles} />
+            </div>
+          ))}
+      </div>
       <NowPlayingBar isSelectMode={isSelectMode} />
       {showDetailsBook && (
         <BookDetailModal

apps/readest-app/src/app/library/utils/categoryFilters.ts

@@ -0,0 +1,93 @@
+import type { Book } from '@/types/book';
+import { formatAuthors, formatLanguage, formatPublisher } from '@/utils/book';
+import { parseAuthors } from './libraryUtils';
+
+export type LibraryCategoryFilter =
+  | 'all'
+  | 'author'
+  | 'publisher'
+  | 'year'
+  | 'language'
+  | 'format'
+  | 'subject'
+  | 'tag';
+
+const LIBRARY_CATEGORY_FILTERS: LibraryCategoryFilter[] = [
+  'all',
+  'author',
+  'publisher',
+  'year',
+  'language',
+  'format',
+  'subject',
+  'tag',
+];
+
+export type CategoryValue = {
+  value: string;
+  count: number;
+};
+
+export const ensureLibraryCategoryFilter = (
+  value: string | null | undefined,
+): LibraryCategoryFilter =>
+  LIBRARY_CATEGORY_FILTERS.includes(value as LibraryCategoryFilter)
+    ? (value as LibraryCategoryFilter)
+    : 'all';
+
+const getPublishedYear = (book: Book) =>
+  typeof book.metadata?.published === 'string'
+    ? book.metadata.published.match(/\d{4}/)?.[0]
+    : undefined;
+
+const getSubjects = (book: Book): string[] => {
+  const subject = book.metadata?.subject;
+  if (!subject) return [];
+  if (Array.isArray(subject)) return subject.map((item) => `${item}`.trim()).filter(Boolean);
+  if (typeof subject === 'string') {
+    return subject
+      .split(/[,;，、]/u)
+      .map((item) => item.trim())
+      .filter(Boolean);
+  }
+  return [formatAuthors(subject)].filter(Boolean);
+};
+
+export const getBookCategoryValues = (book: Book, category: LibraryCategoryFilter): string[] => {
+  switch (category) {
+    case 'author':
+      return parseAuthors(formatAuthors(book.author, book.primaryLanguage));
+    case 'publisher': {
+      const publisher = formatPublisher(book.metadata?.publisher || '').trim();
+      return publisher ? [publisher] : [];
+    }
+    case 'year': {
+      const year = getPublishedYear(book);
+      return year ? [year] : [];
+    }
+    case 'language': {
+      const language = formatLanguage(book.metadata?.language).trim();
+      return language ? [language] : [];
+    }
+    case 'format':
+      return book.format ? [book.format] : [];
+    case 'subject':
+      return getSubjects(book);
+    case 'tag':
+      return book.tags?.map((tag) => tag.trim()).filter(Boolean) || [];
+    case 'all':
+      return [];
+  }
+};
+
+export const countCategoryValues = (books: Book[], category: LibraryCategoryFilter) => {
+  const counts = new Map<string, number>();
+  for (const book of books) {
+    for (const value of getBookCategoryValues(book, category)) {
+      counts.set(value, (counts.get(value) || 0) + 1);
+    }
+  }
+  return [...counts.entries()]
+    .map(([value, count]) => ({ value, count }))
+    .sort((a, b) => a.value.localeCompare(b.value, navigator.language));
+};

apps/readest-app/src/app/library/utils/libraryUtils.ts

@@ -651,6 +651,9 @@ export type BookContextMenuItemId =
   | 'markAbandoned'
   | 'clearStatus'
   | 'showDetails'
+  | 'reviewInEpubEditor'
+  | 'translateInEpubEditor'
+  | 'bilingual'
   | 'showInFinder'
   | 'searchGoodreads'
   | 'download'
@@ -750,7 +753,11 @@ export const getBookContextMenuItemIds = (book: Book): BookContextMenuItemId[] =
   ) {
     ids.push('clearStatus');
   }
-  ids.push('showDetails', 'showInFinder', 'searchGoodreads');
+  ids.push('showDetails');
+  if (book.format?.toUpperCase() === 'EPUB') {
+    ids.push('bilingual', 'reviewInEpubEditor', 'translateInEpubEditor');
+  }
+  ids.push('showInFinder', 'searchGoodreads');
   if (book.uploadedAt && !book.downloadedAt) ids.push('download');
   if (!book.uploadedAt && book.downloadedAt) ids.push('upload');
   // Share is offered for any local-or-uploaded book; the dialog uploads first

apps/readest-app/src/app/reader/components/BooksGrid.tsx

@@ -17,6 +17,7 @@ import FoliateViewer from './FoliateViewer';
 import SectionInfo from './SectionInfo';
 import HeaderBar from './HeaderBar';
 import PageNavigationButtons from './PageNavigationButtons';
+import ReviewModeController from './ReviewModeController';
 import FooterBar from './footerbar/FooterBar';
 import ProgressBar from './ProgressBar';
 import Ribbon from './Ribbon';
@@ -171,6 +172,7 @@ const BookCellInner: React.FC<BookCellProps> = ({
         gridInsets={gridInsets}
         contentInsets={contentInsets}
       />
+      <ReviewModeController bookKey={bookKey} bookDoc={bookDoc} />
       {viewSettings.vertical && viewSettings.scrolled && (
         <>
           {(showFooter || viewSettings.doubleBorder) && (
@@ -337,7 +339,7 @@ const BooksGrid: React.FC<BooksGridProps> = ({ bookKeys, onCloseBook, onGoToLibr
 
   return (
     <div
-      className={clsx('books-grid bg-base-100 relative grid h-full flex-grow')}
+      className={clsx('books-grid bg-base-100 relative grid h-full min-w-0 flex-grow')}
       style={gridStyle}
       role='main'
       aria-label={_('Books Content')}

apps/readest-app/src/app/reader/components/HeaderBar.tsx

@@ -27,6 +27,7 @@ import QuickActionMenu from './annotator/QuickActionMenu';
 import SidebarToggler from './SidebarToggler';
 import BookmarkToggler from './BookmarkToggler';
 import NotebookToggler from './NotebookToggler';
+import ReviewModeToggler from './ReviewModeToggler';
 import SettingsToggler from './SettingsToggler';
 import TranslationToggler from './TranslationToggler';
 import ViewMenu from './ViewMenu';
@@ -282,6 +283,7 @@ const HeaderBar: React.FC<HeaderBarProps> = ({
 
         <div className='header-tools-end bg-base-100 z-20 ms-auto flex h-full min-w-max items-center gap-x-4 ps-2 max-[350px]:gap-x-2'>
           {!isHeaderCompact && <SettingsToggler bookKey={bookKey} />}
+          <ReviewModeToggler bookKey={bookKey} />
           <NotebookToggler bookKey={bookKey} />
           <Dropdown
             label={_('View Options')}

apps/readest-app/src/app/reader/components/ReaderContent.tsx

@@ -9,6 +9,7 @@ import { useSettingsStore } from '@/store/settingsStore';
 import { useBookDataStore } from '@/store/bookDataStore';
 import { useReaderStore } from '@/store/readerStore';
 import { useSidebarStore } from '@/store/sidebarStore';
+import { useReviewModeStore } from '@/store/reviewModeStore';
 import { useGamepad } from '@/hooks/useGamepad';
 import { useTranslation } from '@/hooks/useTranslation';
 import { SystemSettings } from '@/types/settings';
@@ -37,6 +38,7 @@ import Spinner from '@/components/Spinner';
 import SideBar from './sidebar/SideBar';
 import Notebook from './notebook/Notebook';
 import BooksGrid from './BooksGrid';
+import ReviewPanel from './ReviewPanel';
 import SettingsDialog from '@/components/settings/SettingsDialog';
 
 const ReaderContent: React.FC<{ ids?: string; settings: SystemSettings }> = ({ ids, settings }) => {
@@ -50,6 +52,7 @@ const ReaderContent: React.FC<{ ids?: string; settings: SystemSettings }> = ({ i
   const { getConfig, getBookData, saveConfig } = useBookDataStore();
   const { getView, setBookKeys, getViewSettings } = useReaderStore();
   const { initViewState, getViewState, clearViewState } = useReaderStore();
+  const clearReviewBook = useReviewModeStore((state) => state.clearBook);
   const { isSettingsDialogOpen, settingsDialogBookKey } = useSettingsStore();
   const [showDetailsBook, setShowDetailsBook] = useState<Book | null>(null);
   const [shareDialogState, setShareDialogState] = useState<{
@@ -176,6 +179,7 @@ const ReaderContent: React.FC<{ ids?: string; settings: SystemSettings }> = ({ i
 
   const saveConfigAndCloseBook = async (bookKey: string, keepTTSAlive = false) => {
     console.log('Closing book', bookKey);
+    clearReviewBook(bookKey);
 
     const viewState = getViewState(bookKey);
     if (viewState?.isPrimary && appService?.isDesktopApp) {
@@ -291,6 +295,7 @@ const ReaderContent: React.FC<{ ids?: string; settings: SystemSettings }> = ({ i
         onGoToLibrary={handleCloseBooksToLibrary}
       />
       {isSettingsDialogOpen && <SettingsDialog bookKey={settingsDialogBookKey} />}
+      <ReviewPanel />
       <Notebook />
       {showDetailsBook && (
         <BookDetailModal

apps/readest-app/src/app/reader/components/ReviewModeController.tsx

@@ -0,0 +1,307 @@
+import DOMPurify from 'dompurify';
+import { useEffect, useRef } from 'react';
+
+import type { BookDoc } from '@/libs/document';
+import type { ReviewRow } from '@/services/reviewEditorService';
+import { useReaderStore } from '@/store/readerStore';
+import { useReviewModeStore } from '@/store/reviewModeStore';
+
+const STYLE_ID = 'readest-inline-review-style';
+const ROW_ATTR = 'data-readest-review-row-id';
+const ROLE_ATTR = 'data-readest-review-role';
+const ORIGINAL_HTML_ATTR = 'data-readest-review-original-html';
+
+const reviewHtmlPurifyOptions = {
+  ALLOWED_TAGS: [
+    'ruby',
+    'rb',
+    'rt',
+    'rp',
+    'span',
+    'mark',
+    'br',
+    'em',
+    'strong',
+    'b',
+    'i',
+    'u',
+    's',
+    'sub',
+    'sup',
+  ],
+  ALLOWED_ATTR: ['class', 'title'],
+  ALLOW_DATA_ATTR: false,
+};
+
+const sanitizeReviewHtml = (html: string) =>
+  DOMPurify.sanitize(html || '', reviewHtmlPurifyOptions);
+
+const emptyReviewRows: ReviewRow[] = [];
+
+const normalizeFile = (value?: string) =>
+  (() => {
+    const raw = (value || '').split('#')[0] || '';
+    try {
+      return decodeURIComponent(raw);
+    } catch {
+      return raw;
+    }
+  })()
+    .replaceAll('\\', '/')
+    .replace(/^\/+/, '')
+    .toLowerCase();
+
+const sameFile = (rowFile: string, sectionHref?: string) => {
+  const row = normalizeFile(rowFile);
+  const href = normalizeFile(sectionHref);
+  if (!row || !href) return false;
+  return row === href || row.endsWith(`/${href}`) || href.endsWith(`/${row}`);
+};
+
+const sectionHrefAt = (bookDoc: BookDoc, index: number | undefined) => {
+  const section = bookDoc.sections[index ?? -1];
+  return section?.href || section?.id;
+};
+
+const clearReviewMarks = (doc: Document) => {
+  doc.getElementById(STYLE_ID)?.remove();
+  doc.querySelectorAll(`[${ROW_ATTR}]`).forEach((element) => {
+    const originalHtml = element.getAttribute(ORIGINAL_HTML_ATTR);
+    if (originalHtml !== null) {
+      element.innerHTML = originalHtml;
+    }
+    element.removeAttribute(ROW_ATTR);
+    element.removeAttribute(ROLE_ATTR);
+    element.removeAttribute(ORIGINAL_HTML_ATTR);
+    element.classList.remove(
+      'readest-review-source',
+      'readest-review-target',
+      'readest-review-active',
+    );
+  });
+};
+
+const ensureReviewStyle = (doc: Document) => {
+  if (doc.getElementById(STYLE_ID)) return;
+  const style = doc.createElement('style');
+  style.id = STYLE_ID;
+  style.textContent = `
+    [${ROW_ATTR}] {
+      cursor: pointer;
+      user-select: text;
+      outline-offset: 0.18em;
+      transition: background-color 120ms ease, outline-color 120ms ease;
+    }
+    .readest-review-source {
+      background: rgba(127, 127, 127, 0.12);
+      outline: 1px dashed rgba(127, 127, 127, 0.64);
+    }
+    .readest-review-target {
+      background: rgba(22, 163, 74, 0.14);
+      outline: 1px solid rgba(22, 163, 74, 0.72);
+    }
+    .readest-review-active {
+      background: rgba(37, 99, 235, 0.18) !important;
+      outline: 2px solid currentColor !important;
+    }
+  `;
+  doc.head.appendChild(style);
+};
+
+const closestReviewTarget = (target: EventTarget | null): HTMLElement | null => {
+  const element = target as Element | null;
+  if (!element || typeof element.closest !== 'function') return null;
+  if (element.closest('a, button, input, textarea, select, video, audio')) return null;
+  return element.closest(`[${ROW_ATTR}]`) as HTMLElement | null;
+};
+
+const closestReviewTargetFromNode = (node: Node | null): HTMLElement | null => {
+  const element =
+    node?.nodeType === Node.ELEMENT_NODE
+      ? (node as Element)
+      : (node?.parentElement as Element | null);
+  if (!element || typeof element.closest !== 'function') return null;
+  return element.closest(`[${ROW_ATTR}]`) as HTMLElement | null;
+};
+
+const selectedReviewTarget = (doc: Document): HTMLElement | null => {
+  const selection = doc.getSelection();
+  if (!selection || selection.isCollapsed || selection.rangeCount === 0) return null;
+  const range = selection.getRangeAt(0);
+  return (
+    closestReviewTargetFromNode(range.commonAncestorContainer) ||
+    closestReviewTargetFromNode(range.startContainer) ||
+    closestReviewTargetFromNode(range.endContainer)
+  );
+};
+
+const markParagraph = (
+  element: Element | undefined,
+  row: ReviewRow,
+  role: 'source' | 'target',
+  active: boolean,
+) => {
+  const htmlElement = element as HTMLElement | undefined;
+  if (!htmlElement || typeof htmlElement.setAttribute !== 'function') return;
+  htmlElement.setAttribute(ROW_ATTR, row.id);
+  htmlElement.setAttribute(ROLE_ATTR, role);
+  htmlElement.classList.add(role === 'source' ? 'readest-review-source' : 'readest-review-target');
+  htmlElement.classList.toggle('readest-review-active', active);
+  if (role === 'target' && row.current_html) {
+    if (!htmlElement.hasAttribute(ORIGINAL_HTML_ATTR)) {
+      htmlElement.setAttribute(ORIGINAL_HTML_ATTR, htmlElement.innerHTML);
+    }
+    htmlElement.innerHTML = sanitizeReviewHtml(row.current_html);
+  }
+};
+
+const applyActiveReviewMark = (doc: Document, selectedRowId: string) => {
+  doc.querySelectorAll(`[${ROW_ATTR}]`).forEach((element) => {
+    element.classList.toggle(
+      'readest-review-active',
+      element.getAttribute(ROW_ATTR) === selectedRowId,
+    );
+  });
+};
+
+const applyReviewMarks = (
+  doc: Document,
+  sectionHref: string | undefined,
+  rows: ReviewRow[],
+  selectedRowId: string,
+) => {
+  clearReviewMarks(doc);
+  const sectionRows = rows.filter((row) => sameFile(row.file, sectionHref));
+  if (!sectionRows.length) return;
+
+  ensureReviewStyle(doc);
+  const paragraphs = Array.from(doc.querySelectorAll('p'));
+  for (const row of sectionRows) {
+    const active = row.id === selectedRowId;
+    markParagraph(paragraphs[Number(row.ja_p_index)], row, 'source', active);
+    markParagraph(paragraphs[Number(row.cn_p_index)], row, 'target', active);
+  }
+};
+
+export const __testing = {
+  applyReviewMarks,
+  applyActiveReviewMark,
+  clearReviewMarks,
+  sectionHrefAt,
+};
+
+const ReviewModeController: React.FC<{ bookKey: string; bookDoc: BookDoc }> = ({
+  bookKey,
+  bookDoc,
+}) => {
+  const view = useReaderStore((state) => state.viewStates[bookKey]?.view);
+  const enabled = useReviewModeStore((state) => !!state.books[bookKey]?.enabled);
+  const rows = useReviewModeStore((state) => state.books[bookKey]?.rows ?? emptyReviewRows);
+  const selectedRowId = useReviewModeStore((state) => state.books[bookKey]?.selectedRowId || '');
+  const selectRow = useReviewModeStore((state) => state.selectRow);
+  const selectedRowIdRef = useRef(selectedRowId);
+
+  useEffect(() => {
+    selectedRowIdRef.current = selectedRowId;
+  }, [selectedRowId]);
+
+  useEffect(() => {
+    if (!view) return;
+
+    const cleanupLoadedDocs = () => {
+      for (const { doc } of view.renderer.getContents()) {
+        clearReviewMarks(doc);
+      }
+    };
+
+    if (!enabled || !rows.length) {
+      cleanupLoadedDocs();
+      return;
+    }
+
+    const applyToLoadedDocs = () => {
+      for (const { doc, index } of view.renderer.getContents()) {
+        applyReviewMarks(doc, sectionHrefAt(bookDoc, index), rows, selectedRowIdRef.current);
+      }
+    };
+
+    const handleClick = (event: Event) => {
+      const target = closestReviewTarget(event.target);
+      if (!target) return;
+      const rowId = target.getAttribute(ROW_ATTR);
+      if (!rowId) return;
+      event.preventDefault();
+      event.stopPropagation();
+      if ('stopImmediatePropagation' in event) {
+        event.stopImmediatePropagation();
+      }
+      selectRow(bookKey, rowId);
+    };
+
+    const handleSelectionEnd = (event: Event) => {
+      const doc = event.currentTarget as Document | null;
+      if (!doc?.getSelection) return;
+      window.setTimeout(() => {
+        const target = selectedReviewTarget(doc);
+        const rowId = target?.getAttribute(ROW_ATTR);
+        if (rowId) selectRow(bookKey, rowId);
+      }, 0);
+    };
+
+    const listenedDocs = new Set<Document>();
+
+    const addDocListeners = (doc: Document) => {
+      if (listenedDocs.has(doc)) return;
+      listenedDocs.add(doc);
+      doc.addEventListener('click', handleClick, true);
+      doc.addEventListener('mouseup', handleSelectionEnd, true);
+      doc.addEventListener('touchend', handleSelectionEnd, true);
+      doc.addEventListener('keyup', handleSelectionEnd, true);
+    };
+
+    const removeDocListeners = (doc: Document) => {
+      listenedDocs.delete(doc);
+      doc.removeEventListener('click', handleClick, true);
+      doc.removeEventListener('mouseup', handleSelectionEnd, true);
+      doc.removeEventListener('touchend', handleSelectionEnd, true);
+      doc.removeEventListener('keyup', handleSelectionEnd, true);
+    };
+
+    const handleLoad = (event: Event) => {
+      const detail = (event as CustomEvent<{ doc?: Document; index?: number }>).detail;
+      if (!detail?.doc) return;
+      applyReviewMarks(
+        detail.doc,
+        sectionHrefAt(bookDoc, detail.index),
+        rows,
+        selectedRowIdRef.current,
+      );
+      addDocListeners(detail.doc);
+    };
+
+    for (const { doc } of view.renderer.getContents()) {
+      addDocListeners(doc);
+    }
+    applyToLoadedDocs();
+    view.addEventListener('load', handleLoad);
+
+    return () => {
+      view.removeEventListener('load', handleLoad);
+      for (const doc of listenedDocs) {
+        removeDocListeners(doc);
+        clearReviewMarks(doc);
+      }
+    };
+  }, [bookDoc, bookKey, enabled, rows, selectRow, view]);
+
+  useEffect(() => {
+    if (!view || !enabled || !rows.length) return;
+    for (const { doc } of view.renderer.getContents()) {
+      applyActiveReviewMark(doc, selectedRowId);
+    }
+  }, [bookKey, enabled, rows.length, selectedRowId, view]);
+
+  return null;
+};
+
+export default ReviewModeController;

apps/readest-app/src/app/reader/components/ReviewModeToggler.tsx

@@ -0,0 +1,99 @@
+import clsx from 'clsx';
+import React from 'react';
+
+import Button from '@/components/Button';
+import { useEnv } from '@/context/EnvContext';
+import { useTranslation } from '@/hooks/useTranslation';
+import { useBookDataStore } from '@/store/bookDataStore';
+import { useReaderStore } from '@/store/readerStore';
+import { useReviewModeStore } from '@/store/reviewModeStore';
+import { eventDispatcher } from '@/utils/event';
+import { launchInlineReviewEditor, loadInlineReviewData } from '@/services/reviewEditorService';
+
+interface ReviewModeTogglerProps {
+  bookKey: string;
+}
+
+const ReviewModeToggler: React.FC<ReviewModeTogglerProps> = ({ bookKey }) => {
+  const _ = useTranslation();
+  const { appService } = useEnv();
+  const { setHoveredBookKey } = useReaderStore();
+  const bookData = useBookDataStore((state) => state.getBookData(bookKey));
+  const reviewState = useReviewModeStore((state) => state.books[bookKey]);
+  const {
+    setActiveBookKey,
+    setPanelVisible,
+    setBookLoading,
+    setBookError,
+    setBookEnabled,
+    setBookData,
+  } = useReviewModeStore();
+
+  const enabled = !!reviewState?.enabled;
+  const loading = !!reviewState?.loading;
+
+  if (!appService?.isDesktopApp || bookData?.book?.format !== 'EPUB') return null;
+
+  const handleToggleReviewMode = async () => {
+    if (appService?.isMobile) {
+      setHoveredBookKey('');
+    }
+
+    if (enabled) {
+      setBookEnabled(bookKey, false);
+      return;
+    }
+
+    if (!bookData?.book) {
+      setBookError(bookKey, _('Unable to open book'));
+      return;
+    }
+
+    setActiveBookKey(bookKey);
+    setPanelVisible(true);
+    setBookLoading(bookKey, true);
+
+    try {
+      const launch = await launchInlineReviewEditor(appService, bookData.book);
+      const data = await loadInlineReviewData(launch.url, launch.sessionId);
+      setBookData(bookKey, {
+        baseUrl: launch.url,
+        sessionId: launch.sessionId,
+        reviewRoot: launch.reviewRoot,
+        version: launch.version,
+        session: data.session,
+        rows: data.rows,
+        gptConfig: data.gptConfig,
+        selectedRowId: data.rows[0]?.id || '',
+      });
+      setBookEnabled(bookKey, true);
+      eventDispatcher.dispatch('toast', {
+        type: 'info',
+        message: data.rows.length
+          ? `审校模式已开启，共 ${data.rows.length} 段`
+          : '审校模式已开启，但当前 EPUB 没有识别到双语段落',
+        timeout: 2500,
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      setBookError(bookKey, message);
+      eventDispatcher.dispatch('toast', {
+        type: 'error',
+        message,
+        timeout: 3500,
+      });
+    }
+  };
+
+  return (
+    <Button
+      icon={<span className='text-sm font-semibold leading-none'>校</span>}
+      onClick={handleToggleReviewMode}
+      disabled={loading}
+      label={enabled ? _('Disable Review Mode') : _('Review Mode')}
+      className={clsx(enabled && 'bg-base-300/50', loading && 'animate-pulse')}
+    />
+  );
+};
+
+export default ReviewModeToggler;

apps/readest-app/src/context/EnvContext.tsx

@@ -9,6 +9,7 @@ import { initReplicaSync } from '@/services/sync/replicaSync';
 import { createSettingsCursorStore } from '@/services/sync/replicaCursorStore';
 import { startReplicaTransferIntegration } from '@/services/sync/replicaTransferIntegration';
 import { enableReplicaAutoPersist } from '@/services/sync/replicaPersist';
+import { isViewTransitionTimeoutError } from '@/utils/error';
 
 interface EnvContextType {
   envConfig: EnvConfigType;
@@ -40,14 +41,33 @@ export const EnvProvider = ({ children }: { children: ReactNode }) => {
         console.warn('replica sync init failed', err);
       }
     });
-    window.addEventListener('error', (e) => {
+    const handleError = (e: ErrorEvent) => {
       if (e.message === 'ResizeObserver loop limit exceeded') {
         e.stopImmediatePropagation();
         e.preventDefault();
         return true;
       }
+      if (isViewTransitionTimeoutError(e.error)) {
+        e.stopImmediatePropagation();
+        e.preventDefault();
+        return true;
+      }
       return false;
-    });
+    };
+    const handleUnhandledRejection = (e: PromiseRejectionEvent) => {
+      if (isViewTransitionTimeoutError(e.reason)) {
+        e.stopImmediatePropagation();
+        e.preventDefault();
+        return true;
+      }
+      return false;
+    };
+    window.addEventListener('error', handleError);
+    window.addEventListener('unhandledrejection', handleUnhandledRejection);
+    return () => {
+      window.removeEventListener('error', handleError);
+      window.removeEventListener('unhandledrejection', handleUnhandledRejection);
+    };
   }, [envConfig]);
 
   const value = useMemo(() => ({ envConfig, appService }), [envConfig, appService]);

apps/readest-app/src/hooks/useAppRouter.ts

@@ -2,7 +2,12 @@ import { useEnv } from '@/context/EnvContext';
 import { useRouter } from 'next/navigation';
 import { useTransitionRouter } from 'next-view-transitions';
 
-export const useAppRouter = () => {
+const isWebDevMode =
+  process.env['NODE_ENV'] === 'development' && process.env['NEXT_PUBLIC_APP_PLATFORM'] === 'web';
+
+const usePlainAppRouter = () => useRouter();
+
+const useTransitionAppRouter = () => {
   const { appService } = useEnv();
   const transitionRouter = useTransitionRouter();
   const plainRouter = useRouter();
@@ -15,3 +20,5 @@ export const useAppRouter = () => {
   // seen on unsupported webviews (Sentry READEST-9).
   return appService?.supportsViewTransitionsAPI ? transitionRouter : plainRouter;
 };
+
+export const useAppRouter = isWebDevMode ? usePlainAppRouter : useTransitionAppRouter;

apps/readest-app/src/hooks/useLongPress.ts

@@ -3,7 +3,7 @@ import { useCallback, useEffect, useRef, useState } from 'react';
 interface UseLongPressOptions {
   onTap?: () => void;
   onLongPress?: () => void;
-  onContextMenu?: () => void;
+  onContextMenu?: (event: React.MouseEvent) => void;
   onCancel?: () => void;
   threshold?: number;
   moveThreshold?: number;
@@ -149,7 +149,7 @@ export const useLongPress = (
         e.preventDefault();
         e.stopPropagation();
         setTimeout(() => {
-          onContextMenu();
+          onContextMenu(e);
         }, 100);
       }
       reset();

apps/readest-app/src/services/bilingualEpubFilter.ts

@@ -0,0 +1,471 @@
+import { makeSafeFilename } from '@/utils/misc';
+import { getBaseFilename } from '@/utils/path';
+
+export type BilingualFilterLanguage = 'ja' | 'zh';
+export type BilingualFilterMode = 'auto' | 'style' | 'script';
+
+export interface BilingualFilterOptions {
+  removeLanguage: BilingualFilterLanguage;
+  mode?: BilingualFilterMode;
+  removeUnknown?: boolean;
+}
+
+export interface BilingualFilterFileStats {
+  path: string;
+  paragraphs: number;
+  removed: number;
+  kept: number;
+  unknown: number;
+  anchorsMoved: number;
+  byLanguage: Record<BilingualFilterLanguage | 'unknown', number>;
+}
+
+export interface BilingualFilterStats {
+  filesSeen: number;
+  htmlFiles: number;
+  changedFiles: number;
+  paragraphs: number;
+  removed: number;
+  kept: number;
+  unknown: number;
+  anchorsMoved: number;
+  fileStats: BilingualFilterFileStats[];
+}
+
+export interface BilingualFilterResult {
+  file: File;
+  filename: string;
+  title: string;
+  stats: BilingualFilterStats;
+}
+
+const HTML_EXTENSIONS = ['.html', '.htm', '.xhtml'];
+const TEXT_BLOCK_RE = /<p\b[^>]*>.*?<\/p>/gis;
+const BODY_END_RE = /<\/body\s*>/i;
+const ANCHOR_RE =
+  /<a\b(?=[^>]*(?:\bid\s*=\s*['"][^'"]+['"]|\bname\s*=\s*['"][^'"]+['"]))[^>]*>\s*<\/a\s*>/gis;
+const TAG_RE = /<[^>]+>/g;
+const OPF_EXT = '.opf';
+
+const makeEmptyFileStats = (path: string): BilingualFilterFileStats => ({
+  path,
+  paragraphs: 0,
+  removed: 0,
+  kept: 0,
+  unknown: 0,
+  anchorsMoved: 0,
+  byLanguage: { ja: 0, zh: 0, unknown: 0 },
+});
+
+const makeEmptyRunStats = (): BilingualFilterStats => ({
+  filesSeen: 0,
+  htmlFiles: 0,
+  changedFiles: 0,
+  paragraphs: 0,
+  removed: 0,
+  kept: 0,
+  unknown: 0,
+  anchorsMoved: 0,
+  fileStats: [],
+});
+
+const isHtmlPath = (path: string) => {
+  const lower = path.toLowerCase();
+  return HTML_EXTENSIONS.some((ext) => lower.endsWith(ext));
+};
+
+const decodeHtmlEntities = (text: string) => {
+  if (typeof document !== 'undefined') {
+    const textarea = document.createElement('textarea');
+    textarea.innerHTML = text;
+    return textarea.value;
+  }
+  return text
+    .replace(/&nbsp;/g, ' ')
+    .replace(/&amp;/g, '&')
+    .replace(/&lt;/g, '<')
+    .replace(/&gt;/g, '>')
+    .replace(/&quot;/g, '"')
+    .replace(/&#39;/g, "'");
+};
+
+const stripTags = (fragment: string) => decodeHtmlEntities(fragment.replace(TAG_RE, '')).trim();
+
+const getOpeningTag = (fragment: string) => fragment.match(/^<p\b[^>]*>/is)?.[0] ?? '';
+
+const isImageOrEmptyParagraph = (fragment: string) => {
+  if (stripTags(fragment)) return false;
+  return /<(img|svg|math)\b/i.test(fragment);
+};
+
+const getStyleAttribute = (openingTag: string) =>
+  openingTag.match(/\bstyle\s*=\s*(["'])(.*?)\1/is)?.[2] ?? '';
+
+const getClassAttribute = (openingTag: string) =>
+  openingTag.match(/\bclass\s*=\s*(["'])(.*?)\1/is)?.[2] ?? '';
+
+const hasGrayColor = (style: string) => {
+  const compact = style.replace(/\s+/g, '').toLowerCase();
+  return (
+    /(^|;)color:(gray|grey)(;|$)/i.test(style) ||
+    compact.includes('color:#808080') ||
+    compact.includes('color:#888') ||
+    compact.includes('color:rgb(128,128,128)') ||
+    compact.includes('color:rgba(128,128,128,')
+  );
+};
+
+const isProbablyJapaneseByStyle = (fragment: string) => {
+  const openingTag = getOpeningTag(fragment);
+  const style = getStyleAttribute(openingTag);
+  const className = getClassAttribute(openingTag).toLowerCase();
+  return (
+    /\bopacity\s*:\s*0(?:\.40*|\.4|\.5|\.50*)\b/i.test(style) ||
+    hasGrayColor(style) ||
+    /\b(japanese|source|original|src|ja|jp)\b/.test(className)
+  );
+};
+
+const isProbablyChineseByStyle = (fragment: string) => {
+  const openingTag = getOpeningTag(fragment);
+  const className = getClassAttribute(openingTag).toLowerCase();
+  return /\b(chinese|translation|translated|target|zh|cn)\b/.test(className);
+};
+
+const scriptCounts = (text: string) => {
+  const counts = { hiragana: 0, katakana: 0, kana: 0, cjk: 0, ascii: 0 };
+  for (const ch of text) {
+    const code = ch.codePointAt(0) ?? 0;
+    if (code >= 0x3040 && code <= 0x309f) {
+      counts.hiragana += 1;
+      counts.kana += 1;
+    } else if (
+      (code >= 0x30a0 && code <= 0x30ff) ||
+      (code >= 0x31f0 && code <= 0x31ff) ||
+      (code >= 0xff66 && code <= 0xff9d)
+    ) {
+      counts.katakana += 1;
+      counts.kana += 1;
+    } else if (
+      (code >= 0x4e00 && code <= 0x9fff) ||
+      (code >= 0x3400 && code <= 0x4dbf) ||
+      (code >= 0xf900 && code <= 0xfaff)
+    ) {
+      counts.cjk += 1;
+    } else if (/^[a-z]$/i.test(ch)) {
+      counts.ascii += 1;
+    }
+  }
+  return counts;
+};
+
+const classifyByScript = (fragment: string): BilingualFilterLanguage | 'unknown' => {
+  const text = stripTags(fragment);
+  if (!text) return 'unknown';
+
+  const counts = scriptCounts(text);
+  const meaningful = counts.kana + counts.cjk + counts.ascii;
+  if (meaningful === 0) return 'unknown';
+
+  if (counts.kana >= 2) return 'ja';
+  if (counts.kana === 1 && counts.cjk <= 2) return 'ja';
+  if (counts.cjk >= 2 && counts.kana === 0) return 'zh';
+
+  return 'unknown';
+};
+
+const classifyParagraph = (
+  fragment: string,
+  mode: BilingualFilterMode,
+): BilingualFilterLanguage | 'unknown' => {
+  if (isImageOrEmptyParagraph(fragment)) return 'unknown';
+  if (mode === 'auto' || mode === 'style') {
+    if (isProbablyJapaneseByStyle(fragment)) return 'ja';
+    if (isProbablyChineseByStyle(fragment)) return 'zh';
+  }
+  if (mode === 'style') {
+    return stripTags(fragment) ? 'zh' : 'unknown';
+  }
+  return classifyByScript(fragment);
+};
+
+const looksLikeStyleBilingual = (text: string) => {
+  const paragraphs = text.match(TEXT_BLOCK_RE) ?? [];
+  if (paragraphs.length < 10) return false;
+  const textBlocks = paragraphs.filter((paragraph) => stripTags(paragraph)).length;
+  if (textBlocks === 0) return false;
+  const styled = paragraphs.filter(isProbablyJapaneseByStyle).length;
+  const ratio = styled / textBlocks;
+  return styled >= 5 && ratio >= 0.15 && ratio <= 0.85;
+};
+
+const extractEmptyAnchors = (fragment: string) => fragment.match(ANCHOR_RE) ?? [];
+
+const insertAnchorsIntoParagraph = (paragraph: string, anchors: string[]) => {
+  if (anchors.length === 0) return paragraph;
+  const insertion = anchors.join('');
+  const match = paragraph.match(/^<p\b[^>]*>/is);
+  if (!match) return insertion + paragraph;
+  const index = match[0].length;
+  return paragraph.slice(0, index) + insertion + paragraph.slice(index);
+};
+
+const insertPendingAnchorsBeforeBodyEnd = (text: string, anchors: string[]) => {
+  if (anchors.length === 0) return text;
+  const fallback = `<p style="display:none;">${anchors.join('')}</p>\n`;
+  const match = text.match(BODY_END_RE);
+  if (!match || match.index === undefined) return `${text}\n${fallback}`;
+  return text.slice(0, match.index) + fallback + text.slice(match.index);
+};
+
+const shouldRemove = (
+  language: BilingualFilterLanguage | 'unknown',
+  removeLanguage: BilingualFilterLanguage,
+  removeUnknown: boolean,
+) => language === removeLanguage || (removeUnknown && language === 'unknown');
+
+const filterHtmlText = (text: string, options: Required<BilingualFilterOptions>, path: string) => {
+  const stats = makeEmptyFileStats(path);
+  const output: string[] = [];
+  let pendingAnchors: string[] = [];
+  let position = 0;
+  let changed = false;
+  const mode = options.mode === 'auto' && looksLikeStyleBilingual(text) ? 'style' : options.mode;
+
+  for (const match of text.matchAll(TEXT_BLOCK_RE)) {
+    if (match.index === undefined) continue;
+    output.push(text.slice(position, match.index));
+
+    let paragraph = match[0];
+    const language = classifyParagraph(paragraph, mode);
+    stats.paragraphs += 1;
+    stats.byLanguage[language] += 1;
+
+    if (shouldRemove(language, options.removeLanguage, options.removeUnknown)) {
+      const anchors = extractEmptyAnchors(paragraph);
+      pendingAnchors = [...pendingAnchors, ...anchors];
+      stats.removed += 1;
+      stats.anchorsMoved += anchors.length;
+      changed = true;
+    } else {
+      if (language === 'unknown') stats.unknown += 1;
+      stats.kept += 1;
+      if (pendingAnchors.length > 0) {
+        paragraph = insertAnchorsIntoParagraph(paragraph, pendingAnchors);
+        pendingAnchors = [];
+        changed = true;
+      }
+      output.push(paragraph);
+    }
+
+    position = match.index + match[0].length;
+  }
+
+  output.push(text.slice(position));
+  let newText = output.join('');
+  if (pendingAnchors.length > 0) {
+    newText = insertPendingAnchorsBeforeBodyEnd(newText, pendingAnchors);
+    changed = true;
+  }
+
+  return { text: changed ? newText : text, stats };
+};
+
+const escapeXml = (value: string) =>
+  value
+    .replace(/&/g, '&amp;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+    .replace(/'/g, '&apos;');
+
+const decodeText = (data: Uint8Array) => {
+  const encodings = ['utf-8', 'shift_jis', 'gb18030'];
+  for (const encoding of encodings) {
+    try {
+      const decoder = new TextDecoder(encoding, { fatal: true });
+      return decoder.decode(data);
+    } catch {
+      // Try the next common EPUB encoding.
+    }
+  }
+  return new TextDecoder('utf-8').decode(data);
+};
+
+const setDocumentLanguageAndTitle = (text: string, title: string, language: string) => {
+  let updated = text;
+  if (/<title\b[^>]*>.*?<\/title>/is.test(updated)) {
+    updated = updated.replace(/<title\b[^>]*>.*?<\/title>/is, `<title>${escapeXml(title)}</title>`);
+  }
+  if (/\bxml:lang\s*=\s*["'][^"']*["']/i.test(updated)) {
+    updated = updated.replace(/\bxml:lang\s*=\s*(["'])[^"']*\1/i, `xml:lang="${language}"`);
+  }
+  if (/\blang\s*=\s*["'][^"']*["']/i.test(updated)) {
+    updated = updated.replace(/\blang\s*=\s*(["'])[^"']*\1/i, `lang="${language}"`);
+  } else {
+    updated = updated.replace(/<html\b/i, `<html lang="${language}"`);
+  }
+  return updated;
+};
+
+const extractOpfTitle = (text: string) => {
+  const match = text.match(/<dc:title\b[^>]*>(.*?)<\/dc:title>/is);
+  return match ? stripTags(match[1] ?? '') : '';
+};
+
+const getVariantInfo = (
+  sourceName: string,
+  removeLanguage: BilingualFilterLanguage,
+  metadataTitle?: string,
+) => {
+  const sourceTitle = metadataTitle?.trim() || getBaseFilename(sourceName);
+  const suffix = removeLanguage === 'ja' ? '简中译本' : '日文原文版';
+  const language = removeLanguage === 'ja' ? 'zh-CN' : 'ja';
+  const title = `${sourceTitle}（${suffix}）`;
+  const filename = `${makeSafeFilename(`${sourceTitle}_${suffix}`)}.epub`;
+  const identifierSuffix = removeLanguage === 'ja' ? 'readest-no-ja' : 'readest-no-zh';
+  return { title, filename, language, identifierSuffix };
+};
+
+const patchOpfMetadata = (
+  text: string,
+  variant: ReturnType<typeof getVariantInfo>,
+  removeLanguage: BilingualFilterLanguage,
+) => {
+  let updated = text;
+  const title = escapeXml(variant.title);
+  if (/<dc:title\b[^>]*>.*?<\/dc:title>/is.test(updated)) {
+    updated = updated.replace(
+      /<dc:title\b([^>]*)>.*?<\/dc:title>/is,
+      `<dc:title$1>${title}</dc:title>`,
+    );
+  }
+  if (/<dc:language\b[^>]*>.*?<\/dc:language>/is.test(updated)) {
+    updated = updated.replace(
+      /<dc:language\b([^>]*)>.*?<\/dc:language>/is,
+      `<dc:language$1>${variant.language}</dc:language>`,
+    );
+  }
+  if (/<dc:identifier\b[^>]*>.*?<\/dc:identifier>/is.test(updated)) {
+    updated = updated.replace(
+      /<dc:identifier\b([^>]*)>(.*?)<\/dc:identifier>/gis,
+      (_match, attrs: string, value: string) => {
+        const trimmed = value.trim();
+        const suffix = `:${variant.identifierSuffix}`;
+        const nextValue = trimmed.includes(suffix) ? trimmed : `${trimmed}${suffix}`;
+        return `<dc:identifier${attrs}>${escapeXml(nextValue)}</dc:identifier>`;
+      },
+    );
+  } else {
+    updated = updated.replace(
+      /<\/metadata\s*>/i,
+      `<dc:identifier id="readest-filter-id">readest:${removeLanguage}:${Date.now()}</dc:identifier></metadata>`,
+    );
+  }
+  updated = updated.replace(
+    /<meta\b([^>]*\bproperty\s*=\s*["']dcterms:modified["'][^>]*)>.*?<\/meta>/is,
+    `<meta$1>${new Date().toISOString().replace(/\.\d{3}Z$/, 'Z')}</meta>`,
+  );
+  return updated;
+};
+
+const updateRunStats = (runStats: BilingualFilterStats, fileStats: BilingualFilterFileStats) => {
+  runStats.fileStats.push(fileStats);
+  runStats.paragraphs += fileStats.paragraphs;
+  runStats.removed += fileStats.removed;
+  runStats.kept += fileStats.kept;
+  runStats.unknown += fileStats.unknown;
+  runStats.anchorsMoved += fileStats.anchorsMoved;
+};
+
+export async function filterBilingualEpubFile(
+  sourceFile: File,
+  filterOptions: BilingualFilterOptions,
+): Promise<BilingualFilterResult> {
+  const options: Required<BilingualFilterOptions> = {
+    mode: 'auto',
+    removeUnknown: false,
+    ...filterOptions,
+  };
+  const {
+    BlobReader,
+    BlobWriter,
+    TextReader,
+    Uint8ArrayReader,
+    Uint8ArrayWriter,
+    ZipReader,
+    ZipWriter,
+  } = await import('@zip.js/zip.js');
+
+  const reader = new ZipReader(new BlobReader(sourceFile));
+  const writer = new ZipWriter(new BlobWriter('application/epub+zip'));
+  const runStats = makeEmptyRunStats();
+
+  try {
+    const entries = await reader.getEntries();
+    const readableEntries = entries.filter(isReadableZipEntry);
+    const opfEntry = readableEntries.find((entry) =>
+      entry.filename.toLowerCase().endsWith(OPF_EXT),
+    );
+    const opfTitle = opfEntry
+      ? extractOpfTitle(decodeText(await opfEntry.getData(new Uint8ArrayWriter())))
+      : '';
+    const variant = getVariantInfo(sourceFile.name, options.removeLanguage, opfTitle);
+    const seen = new Set<string>();
+    const mimetype = entries.find((entry) => entry.filename.toLowerCase() === 'mimetype');
+    if (mimetype) {
+      await writer.add('mimetype', new TextReader('application/epub+zip'), { level: 0 });
+      seen.add(mimetype.filename);
+      runStats.filesSeen += 1;
+    }
+
+    for (const entry of readableEntries) {
+      if (seen.has(entry.filename)) continue;
+      seen.add(entry.filename);
+      runStats.filesSeen += 1;
+
+      const lowerName = entry.filename.toLowerCase();
+      const rawData = await entry.getData(new Uint8ArrayWriter());
+      let outData: Uint8Array | string = rawData;
+
+      if (isHtmlPath(lowerName)) {
+        runStats.htmlFiles += 1;
+        const originalText = decodeText(rawData);
+        const filtered = filterHtmlText(originalText, options, entry.filename);
+        const patchedText = setDocumentLanguageAndTitle(
+          filtered.text,
+          variant.title,
+          variant.language,
+        );
+        updateRunStats(runStats, filtered.stats);
+        if (patchedText !== originalText) runStats.changedFiles += 1;
+        outData = patchedText;
+      } else if (lowerName.endsWith(OPF_EXT)) {
+        const originalText = decodeText(rawData);
+        const patchedText = patchOpfMetadata(originalText, variant, options.removeLanguage);
+        if (patchedText !== originalText) runStats.changedFiles += 1;
+        outData = patchedText;
+      }
+
+      const writerReader =
+        typeof outData === 'string'
+          ? new TextReader(outData)
+          : new Uint8ArrayReader(outData as Uint8Array);
+      await writer.add(entry.filename, writerReader, zipOptionsForEntry(entry));
+    }
+
+    const blob = await writer.close();
+    const file = new File([blob], variant.filename, { type: 'application/epub+zip' });
+    return { file, filename: variant.filename, title: variant.title, stats: runStats };
+  } finally {
+    await reader.close();
+  }
+}
+
+const isReadableZipEntry = (
+  entry: import('@zip.js/zip.js').Entry,
+): entry is import('@zip.js/zip.js').FileEntry =>
+  !entry.directory && typeof entry.getData === 'function';
+
+const zipOptionsForEntry = (entry: import('@zip.js/zip.js').Entry) =>
+  entry.filename.toLowerCase() === 'mimetype' ? { level: 0 } : {};

apps/readest-app/src/services/reviewEditorService.ts

@@ -0,0 +1,374 @@
+import { invoke } from '@tauri-apps/api/core';
+
+import type { Book } from '@/types/book';
+import type { AppService } from '@/types/system';
+import { isTauriAppPlatform } from '@/services/environment';
+
+export type ReviewEditorLaunchResponse = {
+  ok: boolean;
+  url?: string;
+  reused?: boolean;
+  reviewRoot?: string;
+  version?: string;
+  sessionId?: string | null;
+  error?: string;
+};
+
+export type ReviewSessionSummary = {
+  id: string;
+  source_name?: string;
+  title?: string;
+  source_epub?: string;
+  row_count?: number;
+  touched_count?: number;
+  marked_count?: number;
+  feedback_md?: string;
+  feedback_jsonl?: string;
+  latest_export?: string;
+};
+
+export type ReviewSessionOpenResponse = ReviewSessionSummary & {
+  has_session?: boolean;
+};
+
+export type ReviewSessionPayload = {
+  has_session: boolean;
+  id?: string;
+  title?: string;
+  source_name?: string;
+  source_epub?: string;
+  row_count?: number;
+  touched_count?: number;
+  marked_count?: number;
+  feedback_md?: string;
+  feedback_jsonl?: string;
+  review_root?: string;
+  error?: string;
+};
+
+export type ReviewRow = {
+  id: string;
+  file: string;
+  file_label?: string;
+  document_title?: string;
+  file_order?: number;
+  file_row_index?: number;
+  ja_p_index?: number;
+  cn_p_index?: number;
+  jp_html: string;
+  jp_text: string;
+  cn_html: string;
+  cn_text?: string;
+  current_html: string;
+  marked?: boolean;
+  issue_type?: string;
+  severity?: string;
+  comment?: string;
+  learn_note?: string;
+  tags?: string;
+  edited?: boolean;
+  updated_at?: string;
+};
+
+export type ReviewRowsPayload = {
+  rows: ReviewRow[];
+};
+
+export type ReviewGptConfig = {
+  configured?: boolean;
+  base_url?: string;
+  model?: string;
+  key_source?: string;
+  updated_at?: string;
+  translation_prompt?: string;
+  format_prompt?: string;
+  character_prompt?: string;
+  glossary_path?: string;
+  prompt_defaults?: {
+    translation_prompt?: string;
+    format_prompt?: string;
+    character_prompt?: string;
+  };
+};
+
+export type ReviewEditPayload = {
+  current_html: string;
+  marked: boolean;
+  issue_type: string;
+  severity: string;
+  tags: string;
+  comment: string;
+  learn_note: string;
+};
+
+export type ReviewSaveRowPayload = {
+  status?: string;
+  row_id?: string;
+  updated_at?: string;
+  current_html?: string;
+};
+
+export type ReviewGlossaryEntry = {
+  source: string;
+  target: string;
+  clean_target?: string;
+};
+
+export type ReviewGlossaryPayload = {
+  path?: string;
+  exists?: boolean;
+  count?: number;
+  entries?: ReviewGlossaryEntry[];
+  updated_at?: string;
+};
+
+export type ReviewBootstrapPayload = {
+  session: ReviewSessionPayload;
+  rows: ReviewRow[];
+  gptConfig: ReviewGptConfig;
+};
+
+export type ReviewSessionFromPathOptions = {
+  activate?: boolean;
+  reset?: boolean;
+};
+
+const ensureBaseUrl = (baseUrl: string) => {
+  if (!baseUrl) throw new Error('审校器后端尚未启动');
+  return baseUrl.endsWith('/') ? baseUrl : `${baseUrl}/`;
+};
+
+export async function sidecarApi<T>(
+  baseUrl: string,
+  path: string,
+  options: RequestInit = {},
+  sessionId?: string | null,
+): Promise<T> {
+  const url = new URL(path, ensureBaseUrl(baseUrl));
+  if (sessionId) {
+    url.searchParams.set('session_id', sessionId);
+  }
+  const headers =
+    options.body === undefined
+      ? options.headers
+      : {
+          'Content-Type': 'application/json',
+          ...(options.headers || {}),
+        };
+  const response = await fetch(url.toString(), {
+    ...options,
+    headers,
+  });
+  const data = await response.json().catch(() => ({}));
+  if (!response.ok) {
+    throw new Error(String(data.error || `HTTP ${response.status}`));
+  }
+  return data as T;
+}
+
+export async function createReviewSessionFromPath(
+  baseUrl: string,
+  epubPath: string,
+  options: ReviewSessionFromPathOptions = {},
+): Promise<ReviewSessionSummary> {
+  return sidecarApi(baseUrl, '/api/session/from-path', {
+    method: 'POST',
+    body: JSON.stringify({
+      epub_path: epubPath,
+      activate: options.activate ?? false,
+      reset: options.reset ?? false,
+    }),
+  });
+}
+
+export async function openReviewSession(
+  baseUrl: string,
+  sessionId: string,
+  options: { activate?: boolean } = {},
+): Promise<ReviewSessionOpenResponse> {
+  return sidecarApi(baseUrl, '/api/session/open', {
+    method: 'POST',
+    body: JSON.stringify({
+      session_id: sessionId,
+      activate: options.activate ?? false,
+    }),
+  });
+}
+
+export async function launchInlineReviewEditor(
+  appService: AppService | null | undefined,
+  book: Book,
+): Promise<ReviewEditorLaunchResponse & { url: string; sessionId: string | null }> {
+  if (!appService) throw new Error('Readest 服务尚未初始化');
+  if (book.format !== 'EPUB') throw new Error('审校模式目前只支持 EPUB 书籍');
+
+  const epubPath = await appService.resolveNativeBookFilePath(book);
+  if (!epubPath) throw new Error('无法定位当前 EPUB 的本机文件路径');
+
+  const launch = isTauriAppPlatform()
+    ? await invoke<ReviewEditorLaunchResponse>('launch_epub_review_editor', {
+        epubPath,
+      })
+    : await fetch('/api/review-editor/launch', {
+        method: 'POST',
+        headers: {
+          'x-readest-review-editor-launch': '1',
+        },
+      }).then((response) => response.json() as Promise<ReviewEditorLaunchResponse>);
+
+  if (!launch.ok || !launch.url) {
+    throw new Error(launch.error || '审校器启动失败');
+  }
+
+  let sessionId = launch.sessionId || null;
+  if (!sessionId) {
+    const createdSession = await createReviewSessionFromPath(launch.url, epubPath);
+    sessionId = createdSession.id || null;
+  }
+
+  return { ...launch, url: launch.url, sessionId };
+}
+
+export async function loadInlineReviewData(
+  baseUrl: string,
+  sessionId: string | null | undefined,
+): Promise<ReviewBootstrapPayload> {
+  if (!sessionId) throw new Error('审校器没有返回当前书籍会话');
+  const [session, rowsPayload, gptConfig] = await Promise.all([
+    sidecarApi<ReviewSessionPayload>(baseUrl, '/api/session', {}, sessionId),
+    sidecarApi<ReviewRowsPayload>(baseUrl, '/api/rows', {}, sessionId),
+    sidecarApi<ReviewGptConfig>(baseUrl, '/api/gpt/config', {}, sessionId),
+  ]);
+  return {
+    session,
+    rows: rowsPayload.rows || [],
+    gptConfig,
+  };
+}
+
+export async function saveReviewRow(
+  baseUrl: string,
+  sessionId: string | null | undefined,
+  rowId: string,
+  edit: ReviewEditPayload,
+): Promise<ReviewSaveRowPayload> {
+  return sidecarApi(
+    baseUrl,
+    `/api/row/${encodeURIComponent(rowId)}`,
+    {
+      method: 'POST',
+      body: JSON.stringify(edit),
+    },
+    sessionId,
+  );
+}
+
+export async function retranslateReviewRow(
+  baseUrl: string,
+  sessionId: string | null | undefined,
+  rowId: string,
+  instruction: string,
+): Promise<{
+  candidate_html?: string;
+  candidate_text?: string;
+  glossary_matches?: string[];
+}> {
+  return sidecarApi(
+    baseUrl,
+    `/api/row/${encodeURIComponent(rowId)}/retranslate`,
+    {
+      method: 'POST',
+      body: JSON.stringify({ instruction }),
+    },
+    sessionId,
+  );
+}
+
+export async function saveReviewGptConfig(
+  baseUrl: string,
+  sessionId: string | null | undefined,
+  config: {
+    base_url?: string;
+    model?: string;
+    api_key?: string;
+    glossary_path?: string;
+    translation_prompt?: string;
+    format_prompt?: string;
+    character_prompt?: string;
+  },
+): Promise<ReviewGptConfig> {
+  return sidecarApi(
+    baseUrl,
+    '/api/gpt/config',
+    {
+      method: 'POST',
+      body: JSON.stringify({
+        ...config,
+        keep_existing: true,
+      }),
+    },
+    sessionId,
+  );
+}
+
+export async function loadReviewGlossary(
+  baseUrl: string,
+  sessionId?: string | null,
+): Promise<ReviewGlossaryPayload> {
+  return sidecarApi(baseUrl, '/api/glossary', {}, sessionId);
+}
+
+export async function switchReviewGlossaryPath(
+  baseUrl: string,
+  sessionId: string | null | undefined,
+  path: string,
+): Promise<ReviewGlossaryPayload> {
+  return sidecarApi(
+    baseUrl,
+    '/api/glossary',
+    {
+      method: 'POST',
+      body: JSON.stringify({ path }),
+    },
+    sessionId,
+  );
+}
+
+export async function saveReviewGlossary(
+  baseUrl: string,
+  sessionId: string | null | undefined,
+  path: string,
+  entries: ReviewGlossaryEntry[],
+): Promise<ReviewGlossaryPayload> {
+  return sidecarApi(
+    baseUrl,
+    '/api/glossary',
+    {
+      method: 'POST',
+      body: JSON.stringify({ path, entries }),
+    },
+    sessionId,
+  );
+}
+
+export async function generateReviewFeedback(
+  baseUrl: string,
+  sessionId: string | null | undefined,
+): Promise<{ feedback_md?: string; feedback_jsonl?: string }> {
+  return sidecarApi(baseUrl, '/api/feedback', {}, sessionId);
+}
+
+export async function exportReviewedEpub(
+  baseUrl: string,
+  sessionId: string | null | undefined,
+): Promise<{ output?: string; download_url?: string }> {
+  return sidecarApi(
+    baseUrl,
+    '/api/export',
+    {
+      method: 'POST',
+      body: '{}',
+    },
+    sessionId,
+  );
+}

apps/readest-app/src/store/reviewModeStore.ts

@@ -0,0 +1,142 @@
+import { create } from 'zustand';
+
+import type {
+  ReviewGptConfig,
+  ReviewRow,
+  ReviewSessionPayload,
+} from '@/services/reviewEditorService';
+
+export type ReviewBookState = {
+  enabled: boolean;
+  loading: boolean;
+  error: string;
+  baseUrl: string;
+  sessionId: string | null;
+  reviewRoot?: string;
+  version?: string;
+  rows: ReviewRow[];
+  session: ReviewSessionPayload | null;
+  gptConfig: ReviewGptConfig | null;
+  selectedRowId: string;
+};
+
+type ReviewModeStore = {
+  activeBookKey: string | null;
+  isPanelVisible: boolean;
+  isPanelPinned: boolean;
+  panelWidth: string;
+  panelHeight: string;
+  books: Record<string, ReviewBookState>;
+  getBookState: (bookKey: string | null) => ReviewBookState | null;
+  setActiveBookKey: (bookKey: string | null) => void;
+  setPanelVisible: (visible: boolean) => void;
+  togglePanelPin: () => void;
+  setPanelWidth: (width: string) => void;
+  setPanelHeight: (height: string) => void;
+  setBookLoading: (bookKey: string, loading: boolean) => void;
+  setBookError: (bookKey: string, error: string) => void;
+  setBookEnabled: (bookKey: string, enabled: boolean) => void;
+  setBookData: (
+    bookKey: string,
+    data: Partial<Omit<ReviewBookState, 'enabled' | 'loading' | 'error'>>,
+  ) => void;
+  selectRow: (bookKey: string, rowId: string) => void;
+  updateRow: (bookKey: string, row: ReviewRow) => void;
+  clearBook: (bookKey: string) => void;
+};
+
+const emptyBookState = (): ReviewBookState => ({
+  enabled: false,
+  loading: false,
+  error: '',
+  baseUrl: '',
+  sessionId: null,
+  rows: [],
+  session: null,
+  gptConfig: null,
+  selectedRowId: '',
+});
+
+const withBookState = (
+  books: Record<string, ReviewBookState>,
+  bookKey: string,
+  patch: Partial<ReviewBookState>,
+) => ({
+  ...books,
+  [bookKey]: {
+    ...(books[bookKey] || emptyBookState()),
+    ...patch,
+  },
+});
+
+export const useReviewModeStore = create<ReviewModeStore>((set, get) => ({
+  activeBookKey: null,
+  isPanelVisible: false,
+  isPanelPinned: false,
+  panelWidth: '32%',
+  panelHeight: '68vh',
+  books: {},
+  getBookState: (bookKey) => (bookKey ? get().books[bookKey] || null : null),
+  setActiveBookKey: (bookKey) => set({ activeBookKey: bookKey }),
+  setPanelVisible: (visible) => set({ isPanelVisible: visible }),
+  togglePanelPin: () => set((state) => ({ isPanelPinned: !state.isPanelPinned })),
+  setPanelWidth: (width) => set({ panelWidth: width }),
+  setPanelHeight: (height) => set({ panelHeight: height }),
+  setBookLoading: (bookKey, loading) =>
+    set((state) => ({
+      books: withBookState(state.books, bookKey, loading ? { loading, error: '' } : { loading }),
+    })),
+  setBookError: (bookKey, error) =>
+    set((state) => ({
+      books: withBookState(state.books, bookKey, { error, loading: false }),
+    })),
+  setBookEnabled: (bookKey, enabled) =>
+    set((state) => ({
+      activeBookKey: enabled
+        ? bookKey
+        : state.activeBookKey === bookKey
+          ? null
+          : state.activeBookKey,
+      isPanelVisible: enabled
+        ? true
+        : state.activeBookKey === bookKey
+          ? false
+          : state.isPanelVisible,
+      books: withBookState(state.books, bookKey, { enabled }),
+    })),
+  setBookData: (bookKey, data) =>
+    set((state) => ({
+      books: withBookState(state.books, bookKey, {
+        ...data,
+        loading: false,
+        error: '',
+      }),
+    })),
+  selectRow: (bookKey, rowId) =>
+    set((state) => ({
+      activeBookKey: bookKey,
+      isPanelVisible: true,
+      books: withBookState(state.books, bookKey, {
+        selectedRowId: rowId,
+      }),
+    })),
+  updateRow: (bookKey, row) =>
+    set((state) => {
+      const current = state.books[bookKey] || emptyBookState();
+      return {
+        books: withBookState(state.books, bookKey, {
+          rows: current.rows.map((item) => (item.id === row.id ? row : item)),
+        }),
+      };
+    }),
+  clearBook: (bookKey) =>
+    set((state) => {
+      const books = { ...state.books };
+      delete books[bookKey];
+      return {
+        books,
+        activeBookKey: state.activeBookKey === bookKey ? null : state.activeBookKey,
+        isPanelVisible: state.activeBookKey === bookKey ? false : state.isPanelVisible,
+      };
+    }),
+}));

apps/readest-app/src/utils/error.ts

@@ -1,4 +1,17 @@
+const VIEW_TRANSITION_TIMEOUT = 'Transition was aborted because of timeout in DOM update';
+
+export const isViewTransitionTimeoutError = (error: unknown) => {
+  if (process.env['NODE_ENV'] !== 'development') return false;
+  return (
+    error instanceof Error &&
+    error.name === 'TimeoutError' &&
+    error.message === VIEW_TRANSITION_TIMEOUT
+  );
+};
+
 export const handleGlobalError = (e: Error) => {
+  if (isViewTransitionTimeoutError(e)) return;
+
   const isChunkError = e?.message?.includes('Loading chunk');
 
   if (!isChunkError) {

apps/readest-app/src/utils/nav.ts

@@ -132,8 +132,12 @@ export const navigateToLibrary = (
   router.replace(`/library${queryParams ? `?${queryParams}` : ''}`, navOptions);
 };
 
-export const navigateToReviewEditor = (router: ReturnType<typeof useRouter>) => {
-  router.push('/review-editor');
+export const navigateToReviewEditor = (
+  router: ReturnType<typeof useRouter>,
+  queryParams?: string | URLSearchParams,
+) => {
+  const query = queryParams?.toString() || '';
+  router.push(`/review-editor${query ? `?${query}` : ''}`);
 };
 
 // Recovery action when a reader has nothing to display — e.g. all books were

apps/readest-app/tools/epub-review-editor/MAINTENANCE.md

@@ -49,7 +49,9 @@ epub_review_sessions/
 - `series_configs/<series-id>.json` 保存同系列共享的 `glossary_path`、`translation_prompt`、`format_prompt`、`character_prompt`，不得保存 API Key、Base URL 或模型密钥。
 - `translation_jobs/<job-id>/job.json` 保存整书 AI 翻译任务状态、进度、输出路径和日志；不得保存 API Key。
 - `translated_outputs/` 保存 AI 翻译生成的 EPUB；生成后应创建独立 session，使 `/api/sessions` 和书架自然可见。
-- Readest 迁移阶段的本地入口委托 `tools/epub-review-editor/open_editor.ps1` 或 `/api/review-editor/launch` 创建 `.venv`、安静检测 Flask 依赖、缺失时自动安装依赖、复用同版本已运行服务或启动 `server.py --daemon`；该入口不得硬编码用户私有路径。
+- Readest 桌面端入口委托 Tauri command `launch_epub_review_editor` 启动或复用本地 sidecar；dev-web 入口继续使用 `/api/review-editor/launch`。两者都应创建 `.venv`、安静检测 Flask 依赖、缺失时自动安装依赖、复用同版本且 `review_root` 一致的已运行服务或启动 `server.py --daemon`；该入口不得硬编码用户私有路径。桌面端从书架进入时，文件路径只交给 Tauri command 注册 session，Readest 页面 URL 应改用 `session_id`，避免长期暴露本机 EPUB 路径。
+- Readest `/review-editor` 的主路径必须是原生 React 功能块，校对和翻译功能直接调用本地 sidecar API；旧 `static/index.html` 界面只保留为独立启动、调试或应急 fallback，不再作为桌面迁移验收的主界面。若 React 直接访问 loopback sidecar，sidecar 只能对本机 Readest/Tauri 来源返回受限 CORS，不得开放任意 Origin。
+- Readest 原生阅读页可提供内嵌审校模式，但只能作为当前 EPUB 的阅读增强：顶栏“校”按钮启动/复用 sidecar、注册当前书 session、读取 `/api/rows` 与 `/api/gpt/config`，在 Foliate iframe 正文中只标记对应的中日双语段落；点击或选中日文/中文段落时打开同一条审校记录。右侧面板可复用旧审校器右侧栏能力（编辑中文、问题类型、严重程度、标签、备注、长期规则、GPT 配置、术语表、单段重翻、反馈生成、导出），但不显示独立段落列表；GPT 配置与术语表应放在面板底部，避免挤占逐段编辑区。中文编辑区的译文预览默认折叠；注音、注释和保存按钮应靠近“修改中文译文”标题，注音/注释操作应对当前选择位置插入可直接改写的内联标签并自动展开预览，便于保存前确认格式。桌面端右侧面板必须保留固定按钮：固定时作为阅读布局的一列停靠并压缩正文，不固定时作为浮动面板覆盖在正文上方，可横向/纵向拖动位置，并可调整宽度和高度；固定/取消固定或调整固定面板宽度后，应尽量恢复用户原先正在阅读的位置。面板内容在窄宽度下应换行和纵向堆叠，避免文字被截断。移动窄屏仍可用抽屉/底部面板。不得迁入整书翻译、书架管理等无关功能。
 
 ## 目录与插图
 
@@ -93,6 +95,7 @@ epub_review_sessions/
 - 鼠标停留在顶栏或阅读标题栏时，沉浸顶栏不得因自动计时过早收起；前端脚本和样式发布时应带版本参数或等效缓存失效机制，避免浏览器继续执行旧入口代码。
 - 阅读区“上一节 / 下一节”必须按 spine/目录内的小章节顺序移动，覆盖文字 part 与插图条目，不得只跳顶层大章节。
 - 点击正文段落打开右侧精修与重翻面板。
+- 在 Readest 原生阅读页启用“校”审校模式后，点击或选中 Foliate 正文里的日文源段或中文译文段必须打开同一条审校记录；未开启审校模式时不得改变普通阅读、翻页、标注或笔记行为。
 - 右侧面板打开或关闭导致正文宽度变化时，应恢复用户原来正在看的段落位置。
 - 刷新页面、重启服务或从已有会话重新打开 EPUB 时，应恢复到上次阅读的章节/part/插图、段落和滚动位置。
 - 移动窄屏下，侧栏和右侧面板应以抽屉/底部面板方式显示，不遮死主要操作。
@@ -104,6 +107,8 @@ epub_review_sessions/
 - sanitize 中文 HTML，但允许 `ruby/rb/rt/rp/mark/span` 等必要内联标签。
 - 记录 `before_cn_html`、`after_cn_html`、问题类型、严重程度、标签、备注、长期规则建议。
 - 更新 `feedback/translation_feedback.jsonl`。
+- `/api/row/<row_id>` 保存响应应返回服务端清洗后的 `current_html`，原生 Readest 面板和 Foliate 审校标记必须以后端规范化结果或同等前端 sanitize 结果更新本地 store，不能把用户输入的原始 HTML 直接写回正文 iframe。
+- 原生 Readest 阅读页的 inline 审校 API 调用必须携带当前书的 `session_id`；`/api/session`、`/api/rows`、`/api/row/<row_id>`、`/api/row/<row_id>/retranslate`、`/api/feedback`、`/api/export` 与导出下载都应支持 session-scoped 调用，不能依赖 sidecar 全局 active session，以免多书格子或 `/review-editor` 页面切换会话时串写。
 
 生成反馈时必须：
 
@@ -239,7 +244,14 @@ Prompt 硬规则：
 - `python -B -m py_compile tools/epub-review-editor/server.py tools/epub-review-editor/version.py`
 - `node --check tools/epub-review-editor/static/app.js`
 - `powershell -NoProfile -ExecutionPolicy Bypass -File apps/readest-app/tools/epub-review-editor/open_editor.ps1` 能启动服务并打开书架/上传页
-- Readest dev-web 中 `POST /api/review-editor/launch` 必须带 `x-readest-review-editor-launch: 1`，只能从本机入口调用；成功时返回 sidecar URL、版本和 review root
+- Readest 桌面端 `invoke('launch_epub_review_editor')` 能启动或复用 sidecar，成功时返回 sidecar URL、版本、review root 和可选 session id；dev-web 中 `POST /api/review-editor/launch` 必须带 `x-readest-review-editor-launch: 1`，只能从本机入口调用
+- Readest `/review-editor` 页面必须提供“校对”“翻译”两个原生 React 功能块，切换后直接调用 sidecar API，不得把旧静态审校器 iframe 作为主工作区；旧网页只能作为外部打开/调试 fallback
+- Readest 原生阅读页顶栏“校”按钮必须能启动/复用 sidecar，当前 EPUB 的中日双语段落必须能被 Foliate iframe 内高亮，并能通过点击或文本选择打开右侧审校面板；关闭审校模式后高亮、事件监听与临时译文预览必须清理
+- Readest 原生阅读页右侧审校面板必须支持保存 `/api/row/<row_id>`、重翻 `/api/row/<row_id>/retranslate`、配置 `/api/gpt/config`、读取/保存 `/api/glossary`、生成 `/api/feedback` 与导出 `/api/export`
+- 校对功能块至少能加载 `/api/rows` 与 `/api/structure`，选择行，保存 `/api/row/<row_id>`，调用 `/api/row/<row_id>/retranslate`，生成反馈 `/api/feedback`，并导出 `/api/export`
+- 翻译功能块至少能读取 `/api/session/<session_id>/translation-source` 与 `/api/translation/defaults`，保存 `/api/gpt/config`，保存同系列 `/api/series/<series_id>/config`，启动 `/api/translation/start`，轮询 `/api/translation/jobs/<job_id>`，完成后能打开输出 session
+- Readest 书架 EPUB 右键进入校对/翻译时，Tauri command 应先创建或复用对应 session，并将 `/review-editor` 地址整理为 `session_id`，不把本机 EPUB 路径长期留在页面 URL 中
+- 审校器静态页支持 `mode=review|translate&session_id=<id>` 直达已有会话，支持 `epub_path=<path>` 先创建/复用会话再进入对应功能
 - 重复执行一键入口时优先复用同版本已运行服务；如需新起服务，端口探测不得允许多个服务同时监听同一端口
 - `git diff --check`
 - `/api/version`

apps/readest-app/tools/epub-review-editor/READEST_MIGRATION.md

@@ -2,18 +2,20 @@
 
 ## 当前定位
 
-本目录是从长期翻译项目的 EPUB 审校器迁移进 Readest 的第一阶段基座。当前保留原 Python/Flask 后端与静态审校 UI，Readest 负责提供入口、启动本地 sidecar，并在 `/review-editor` 页面中承载审校器。
+本目录是从长期翻译项目的 EPUB 审校器迁移进 Readest 的桌面端基座。当前保留原 Python/Flask 后端作为本地 sidecar，Readest 负责提供入口、启动本地 sidecar，并在 `/review-editor` 页面中用原生 React 功能块承载“校对”和“翻译”核心流程。
 
 ## 入口
 
 - Readest 书架页菜单：`Settings Menu -> Advanced Settings -> EPUB 审校器`
 - Next 路由：`/review-editor`
-- 本地启动 API：`POST /api/review-editor/launch`
+- 桌面启动命令：`launch_epub_review_editor`
+- dev-web 启动 API：`POST /api/review-editor/launch`
 - 开发脚本：`pnpm epub-reviewer:dev`
 
-当前 Readest 页面内自动启动仅限本地 `dev-web` 开发环境。生产 Tauri 包会静态导出 Next 页面，不能依赖 Next API route 启动本地进程；正式迁移到桌面包前，需要改为 Tauri desktop command 或打包 sidecar。
+Readest 桌面端通过 Tauri command 启动本地 sidecar；本地 `dev-web` 继续保留 Next API route 作为开发 fallback。
+从 Readest 书架进入单本 EPUB 时，桌面端先把本机路径交给 Tauri command 创建或复用审校 session，再用 `session_id` 打开校对/翻译功能块；页面 URL 不长期保留本机 EPUB 路径。
 
-Readest dev-web 页面带跨源隔离头；本地 sidecar 会为 HTML 入口返回限定本机 Readest 来源的 `frame-ancestors`，并发送 `Cross-Origin-Embedder-Policy: require-corp` 与 `Cross-Origin-Resource-Policy: cross-origin`，否则 Chromium 会把 iframe 请求拦截为 `ERR_BLOCKED_BY_RESPONSE`。
+Readest dev-web 页面带跨源隔离头；本地 sidecar 会为 HTML 入口返回限定本机 Readest 来源的 `frame-ancestors`，并发送 `Cross-Origin-Embedder-Policy: require-corp` 与 `Cross-Origin-Resource-Policy: cross-origin`，旧静态网页 fallback 因此仍可被外部打开。React 功能块直接访问 loopback API，sidecar 只对本机 Readest/Tauri 来源返回受限 CORS。
 
 ## 运行数据
 
@@ -35,17 +37,22 @@ READEST_REVIEW_ROOT=<absolute path>
 
 当前阶段不重写审校器业务逻辑，不把 Flask API 立即拆成 Next API 或 Tauri command。这样可以先保留已验证的功能闭环：书架、上传、双语审校、术语表、GPT 重翻、整书 AI 翻译和导出。
 
+旧 `static/index.html` + `static/app.js` 继续保留，用于独立启动、调试和应急 fallback；Readest 桌面迁移验收以 React 功能块为准，不再以 iframe 中显示旧 UI 为完成标准。
+
 后续原生化顺序建议：
 
-1. 把启动 sidecar 从 Next dev API 迁到 Tauri desktop command，生产桌面包不依赖 Next API route。
-2. 复用 Readest 的书库与文件选择能力，把单书“发送到审校器”入口接到 EPUB 文件路径。
+1. 继续收敛校对/翻译功能块，把术语表编辑、书架分类和阅读位置恢复等长尾操作逐步改成 Readest 原生 React 控件。
+2. 把 Python/Flask sidecar 打包成独立可执行 sidecar，减少对用户本机 Python 的依赖。
 3. 逐步把书架/审校/翻译 UI 拆成 React 组件，最后再替换 Flask API。
 
 ## 验收标准
 
-- 本地 `dev-web` 环境下，`/review-editor` 能从 Readest 书架菜单进入。
+- 桌面端与本地 `dev-web` 环境下，`/review-editor` 能从 Readest 书架菜单进入。
+- `/review-editor` 提供“校对”“翻译”两个原生 React 功能块，主工作区不渲染旧静态审校器 iframe。
+- Readest EPUB 书籍右键菜单能直接进入审校器校对或翻译。
 - 首次进入会创建 `.venv`、安装 Flask 依赖并启动 `server.py --daemon --no-browser`。
 - 已运行同版本审校器时优先复用 `localhost:5177+` 端口，不重复启动。
-- iframe 中能显示审校器书架/上传页。
+- 校对功能块能加载行、保存译文/标记、单段重翻、生成反馈并导出 EPUB。
+- 翻译功能块能读取可翻译正文块、保存 API/提示词配置、启动任务、轮询进度，并打开输出 session。
 - 审校数据目录不会进入 git。
 - 原审校器 `server.py` 能通过 Python 编译检查，迁移入口 TypeScript 能通过类型检查。

apps/readest-app/tools/epub-review-editor/README.md

@@ -1,6 +1,6 @@
 # 双语 EPUB 审校编辑器
 
-当前版本：`0.13.2`
+当前版本：`0.16.4`
 
 这个工具用于把生成后的中日双语 EPUB 打开成浏览器审校界面。用户可以直接修改中文译文，也可以标记“哪里翻得不好”，并把所有记录沉淀为可交给 Codex 的反馈文件。
 
@@ -52,6 +52,21 @@
 
 `0.13.2` 修复迁移到 Readest dev-web 后被浏览器阻止 iframe 加载的问题：本地 sidecar 为 HTML 入口添加限定本机 Readest 的 `frame-ancestors`，并通过 `Cross-Origin-Embedder-Policy: require-corp` 与 `Cross-Origin-Resource-Policy: cross-origin` 兼容 Readest 的跨源隔离页面。
 
+`0.14.0` 新增 Readest 桌面端功能块入口：Tauri command 可在桌面端启动或复用本地审校 sidecar，Readest 内提供“校对”“翻译”两个功能块，并支持从 Readest 书架 EPUB 右键直接进入校对或 AI 翻译。审校器静态页新增 `mode=review|translate`、`session_id`、`epub_path` URL 参数入口。
+从 Readest 桌面书架进入时，本机 EPUB 路径由 Tauri command 交给 sidecar 创建/复用 session，随后页面会改用 `session_id` 进入对应功能块。
+
+`0.15.0` 将 Readest `/review-editor` 迁移为原生 React 桌面功能块：校对和翻译不再以旧网页 iframe 作为主界面，而是直接调用本地 sidecar API 完成行加载、保存、重翻、反馈、导出、翻译配置、任务启动和进度轮询。旧静态网页界面保留为独立启动与调试 fallback。sidecar 为本机 Readest/Tauri 来源增加受限 CORS，以支持原生功能块直接访问 loopback API。
+
+`0.16.0` 新增 Readest 原生阅读页审校模式：桌面端阅读界面顶栏提供“校”按钮，启用后会启动或复用本地 sidecar，并在 Foliate 原生正文里标记中日双语段落；点击或选中日文/中文段落会打开右侧审校面板，可直接修改中文译文、标记问题类型/严重程度/标签/备注/长期规则，配置 API 与术语表，执行单段重翻、生成反馈并导出修订 EPUB。
+
+`0.16.1` 优化 Readest 原生阅读页审校面板：桌面端右侧面板改为停靠布局，打开后压缩正文而不是遮挡右侧文字；移除面板内独立段落列表，把 API 与提示词、术语表放到面板底部，并明确区分标签、本段备注和长期规则建议的用途。
+
+`0.16.2` 恢复 Readest 原生审校面板固定按钮：固定时面板停靠并挤开正文，取消固定时变为可拖动浮动面板；固定状态切换和固定宽度调整后会恢复原阅读位置，窄面板下控件和文本改为换行/纵向堆叠，避免内容被截断。
+
+`0.16.3` 修复 Readest 原生审校面板浮动模式交互：取消固定后面板不再占满整页高度，可在正文上方横向和纵向拖动，并支持分别调整宽度与高度。
+
+`0.16.4` 优化 Readest 原生审校面板的中文编辑区：译文预览默认折叠，中文编辑标题右侧新增注音、注释和保存按钮；注音/注释会在当前选择位置插入可直接改写的内联标签，并自动展开预览，便于保存前确认显示效果。
+
 ## 独立安装
 
 这个审校器现在可以脱离 Codex 使用，只需要 Python 和浏览器。把 `tools/epub-review-editor` 目录复制到其他电脑或服务器后，在该目录里安装依赖：
@@ -94,7 +109,9 @@ Advanced Settings -> EPUB 审校器
 apps/readest-app\epub_review_sessions\
 ```
 
-这一阶段仍是 dev-web 基座：正式 Tauri 桌面包需要后续把启动逻辑迁到 Rust command 或打包 sidecar。
+桌面端会通过 Tauri command 启动本地 sidecar；dev-web 仍保留 `/api/review-editor/launch` 作为开发入口。Readest `/review-editor` 页面使用 React 原生“校对”“翻译”功能块直接调用 sidecar API；旧静态网页界面仅作为独立运行和排查问题时的 fallback。
+
+在 Readest 桌面端原生阅读界面中，打开 EPUB 后也可以点击顶栏“校”按钮进入内嵌审校模式。该模式不离开阅读页，只给当前书的双语段落加审校标记，并把旧审校器右侧栏能力收敛到阅读页右侧面板。
 
 ## 独立启动
 
@@ -156,6 +173,7 @@ python .\server.py --host 0.0.0.0 --port 5177 --review-root .\epub_review_sessio
 - 插图页会作为所属章节的次级条目出现在目录里，点击后可在阅读模式中直接查看原 EPUB 图片；点击目录项不会自动隐藏左侧侧栏。
 - 检索支持“当前范围”和“全书全局”两种范围，适合在单章精查和整本书排查术语时切换。
 - 在阅读模式中点击段落即可打开右侧精修与重翻面板，直接编辑中文译文、标记问题或调用 GPT 重翻；打开/关闭面板时会尽量保持原来的阅读位置。
+- 在 Readest 原生阅读界面中可点击顶栏“校”启用内嵌审校模式；中文和日文段落会在正文中高亮可选，点击或选中任一侧都会打开同一段的审校面板。
 - 精修模式保留原有逐段编辑界面，用于较细的逐段复审。
 - 可从“审校工具”统一配置 OpenAI 兼容的 `base_url`、`model`、API Key、重翻提示词与术语表，并对当前段落生成重翻候选；候选不会自动覆盖正文，需要点击“应用重翻”并保存。
 - 可在“审校工具”的“AI 设置与术语表”里配置并读取正式术语表，实时搜索、增删改术语并保存；单段重翻会按当前段落命中术语表条目，而不是只在提示词里泛泛要求遵守术语。

apps/readest-app/tools/epub-review-editor/server.py

@@ -36,7 +36,7 @@ except ImportError:
         "MINOR": "新增向后兼容能力、API 字段或可选配置",
         "MAJOR": "破坏兼容的 API、配置或行为变更",
     }
-    version = "0.13.2"
+    version = "0.15.0"
 
 
 P_RE = re.compile(r"(<p\b[^>]*>)(.*?)(</p>)", re.S | re.I)
@@ -105,7 +105,7 @@ DEFAULT_TRANSLATION_LIMIT = 20
 TRANSLATION_RANGE_LIMIT_MAX = 5000
 TRANSLATION_CONTEXT_RADIUS = 1
 LIBRARY_DB_NAME = "library.json"
-ROWS_PARSER_VERSION = "0.13.1-translation-pair-cleanup"
+ROWS_PARSER_VERSION = "0.16.0-inline-review-source-opacity"
 
 
 def now_iso() -> str:
@@ -239,6 +239,14 @@ def is_gray_source(attrs: str, inner: str) -> bool:
     return False
 
 
+def is_inline_review_source_paragraph(open_tag: str, inner: str) -> bool:
+    attrs = open_tag[2:-1]
+    return is_gray_source(attrs, inner) or (
+        bool(re.search(r"\bopacity\s*:\s*0?\.[0-9]+", attrs, flags=re.I))
+        and is_japaneseish(inner)
+    )
+
+
 def paragraph_visible_text(inner: str) -> str:
     return compact_text(strip_tags(inner or ""))
 
@@ -541,6 +549,55 @@ def public_gpt_config(review_root: Path) -> dict[str, Any]:
     }
 
 
+def normalize_gpt_config(data: dict[str, Any]) -> dict[str, Any]:
+    api_key = str(data.get("api_key") or "").strip()
+    prompts = {
+        name: normalize_gpt_prompt(name, data.get(name, default))
+        for name, default in GPT_PROMPT_DEFAULTS.items()
+    }
+    return {
+        "base_url": normalize_gpt_base_url(str(data.get("base_url") or DEFAULT_GPT_BASE_URL)),
+        "model": str(data.get("model") or DEFAULT_GPT_MODEL).strip() or DEFAULT_GPT_MODEL,
+        "api_key": api_key,
+        "configured": bool(api_key),
+        "key_source": str(data.get("key_source") or ""),
+        "updated_at": data.get("updated_at", ""),
+        "glossary_path": normalize_glossary_path_value(str(data.get("glossary_path") or "")),
+        **prompts,
+    }
+
+
+def session_gpt_config_path(session_root: Path) -> Path:
+    return session_root / "review_state" / "gpt_config.json"
+
+
+def read_scoped_gpt_config(review_root: Path, session_root: Path | None = None) -> dict[str, Any]:
+    config = read_gpt_config(review_root)
+    if session_root is not None:
+        scoped = read_json(session_gpt_config_path(session_root), {})
+        if isinstance(scoped, dict):
+            config.update({key: value for key, value in scoped.items() if key != "api_key"})
+    return normalize_gpt_config(config)
+
+
+def public_scoped_gpt_config(review_root: Path, session_root: Path | None = None) -> dict[str, Any]:
+    if session_root is None:
+        return public_gpt_config(review_root)
+    config = read_scoped_gpt_config(review_root, session_root)
+    return {
+        "configured": config["configured"],
+        "base_url": config["base_url"],
+        "model": config["model"],
+        "key_source": config["key_source"],
+        "updated_at": config["updated_at"],
+        "translation_prompt": config["translation_prompt"],
+        "format_prompt": config["format_prompt"],
+        "character_prompt": config["character_prompt"],
+        "glossary_path": config["glossary_path"],
+        "prompt_defaults": gpt_prompt_defaults(),
+    }
+
+
 def save_gpt_config(review_root: Path, data: dict[str, Any]) -> dict[str, Any]:
     base_url = normalize_gpt_base_url(str(data.get("base_url") or DEFAULT_GPT_BASE_URL))
     model = str(data.get("model") or DEFAULT_GPT_MODEL).strip() or DEFAULT_GPT_MODEL
@@ -568,14 +625,47 @@ def save_gpt_config(review_root: Path, data: dict[str, Any]) -> dict[str, Any]:
     return public_gpt_config(review_root)
 
 
-def glossary_path(review_root: Path) -> Path:
+def save_scoped_gpt_config(
+    review_root: Path, data: dict[str, Any], session_root: Path | None = None
+) -> dict[str, Any]:
+    if session_root is None:
+        return save_gpt_config(review_root, data)
+    current = read_scoped_gpt_config(review_root, session_root)
+    base_url = normalize_gpt_base_url(str(data.get("base_url") or current["base_url"]))
+    model = str(data.get("model") or current["model"]).strip() or DEFAULT_GPT_MODEL
+    api_key = str(data.get("api_key") or "").strip()
+    if api_key:
+        update_gpt_config_fields(review_root, {"api_key": api_key})
+    prompts = {}
+    for key in ("translation_prompt", "format_prompt", "character_prompt"):
+        value = data.get(key) if key in data else current.get(key)
+        prompts[key] = normalize_gpt_prompt(key, value)
+    record = {
+        "base_url": base_url,
+        "model": model,
+        "glossary_path": normalize_glossary_path_value(
+            str(data.get("glossary_path") or current["glossary_path"] or "")
+        ),
+        **prompts,
+        "updated_at": now_iso(),
+    }
+    write_json(session_gpt_config_path(session_root), record)
+    return public_scoped_gpt_config(review_root, session_root)
+
+
+def glossary_path(review_root: Path, session_root: Path | None = None) -> Path:
+    if session_root is not None:
+        scoped = read_json(session_gpt_config_path(session_root), {})
+        configured = str(scoped.get("glossary_path") or "").strip()
+        if configured:
+            return Path(normalize_glossary_path_value(configured))
     data = read_json(gpt_config_path(review_root), {})
     configured = str(data.get("glossary_path") or "").strip()
     return Path(normalize_glossary_path_value(configured))
 
 
-def read_glossary(review_root: Path) -> dict[str, str]:
-    path = glossary_path(review_root)
+def read_glossary(review_root: Path, session_root: Path | None = None) -> dict[str, str]:
+    path = glossary_path(review_root, session_root)
     if not path.exists():
         return {}
     try:
@@ -591,9 +681,9 @@ def read_glossary(review_root: Path) -> dict[str, str]:
     return glossary
 
 
-def public_glossary(review_root: Path) -> dict[str, Any]:
-    path = glossary_path(review_root)
-    glossary = read_glossary(review_root)
+def public_glossary(review_root: Path, session_root: Path | None = None) -> dict[str, Any]:
+    path = glossary_path(review_root, session_root)
+    glossary = read_glossary(review_root, session_root)
     entries = [
         {
             "source": key,
@@ -611,8 +701,10 @@ def public_glossary(review_root: Path) -> dict[str, Any]:
     }
 
 
-def save_glossary(review_root: Path, entries: list[dict[str, Any]]) -> dict[str, Any]:
-    path = glossary_path(review_root)
+def save_glossary(
+    review_root: Path, entries: list[dict[str, Any]], session_root: Path | None = None
+) -> dict[str, Any]:
+    path = glossary_path(review_root, session_root)
     if path.exists() and not path.is_file():
         raise ValueError("术语表路径不是文件")
     glossary: dict[str, str] = {}
@@ -634,7 +726,7 @@ def save_glossary(review_root: Path, entries: list[dict[str, Any]]) -> dict[str,
         glossary[source] = target
     path.parent.mkdir(parents=True, exist_ok=True)
     write_json(path, glossary)
-    return public_glossary(review_root)
+    return public_glossary(review_root, session_root)
 
 
 def search_glossary_entries(glossary: dict[str, str], term: str, limit: int = GLOSSARY_ENTRY_LIMIT) -> list[str]:
@@ -688,9 +780,14 @@ def glossary_prompt_line(key: str, value: str, source: str) -> str:
     return f"{key} => {translation}"
 
 
-def glossary_matches_for_prompt(review_root: Path, row: dict[str, Any], limit: int = GLOSSARY_PROMPT_LIMIT) -> list[str]:
+def glossary_matches_for_prompt(
+    review_root: Path,
+    row: dict[str, Any],
+    limit: int = GLOSSARY_PROMPT_LIMIT,
+    session_root: Path | None = None,
+) -> list[str]:
     try:
-        glossary = read_glossary(review_root)
+        glossary = read_glossary(review_root, session_root)
     except ValueError:
         raise
     except Exception as exc:
@@ -2401,7 +2498,9 @@ def build_rows(session_root: Path) -> list[dict[str, Any]]:
             cn_inner = matches[i + 1].group(2)
             next_open = matches[i + 1].group(1)
             next_attrs = next_open[2:-1]
-            if is_gray_source(attrs, jp_inner) and not is_gray_source(next_attrs, cn_inner):
+            if is_inline_review_source_paragraph(open_tag, jp_inner) and not is_inline_review_source_paragraph(
+                next_open, cn_inner
+            ):
                 serial += 1
                 file_serial += 1
                 rows.append(
@@ -3171,6 +3270,18 @@ def create_app(review_root: Path, initial_epub_path: Path | None = None, reset:
                 return app.config["SESSION_ROOT"], app.config["EPUB_PATH"]
         return None, None
 
+    def session_from_request() -> tuple[Path | None, Path | None]:
+        session_id = str(request.args.get("session_id") or "").strip()
+        if not session_id:
+            return active_session()
+        try:
+            session_root = session_root_from_id(review_root, session_id)
+        except ValueError:
+            return None, None
+        if not (session_root / "review_state" / "state.json").exists() or session_is_hidden(session_root):
+            return None, None
+        return session_root, session_epub_path(session_root)
+
     def no_active_response():
         return jsonify(
             {
@@ -3190,13 +3301,36 @@ def create_app(review_root: Path, initial_epub_path: Path | None = None, reset:
     @app.after_request
     def add_local_embedding_headers(response):
         # Readest dev-web is cross-origin isolated; the local sidecar must opt in
-        # before Chromium will allow it inside the /review-editor iframe.
+        # before Chromium will allow it inside the /review-editor iframe. The
+        # desktop React migration calls the same loopback APIs directly, so keep
+        # CORS limited to local Readest origins instead of opening the sidecar.
+        allowed_origins = {
+            "http://localhost:3000",
+            "http://127.0.0.1:3000",
+            "http://localhost:3001",
+            "http://127.0.0.1:3001",
+            "http://tauri.localhost",
+            "https://tauri.localhost",
+            "tauri://localhost",
+        }
+        origin = request.headers.get("Origin", "")
+        if origin in allowed_origins:
+            response.headers["Access-Control-Allow-Origin"] = origin
+            response.headers["Access-Control-Allow-Credentials"] = "false"
+            response.headers["Access-Control-Allow-Headers"] = "Content-Type"
+            response.headers["Access-Control-Allow-Methods"] = "GET,POST,DELETE,OPTIONS"
+            response.headers["Vary"] = "Origin"
         response.headers.setdefault("Cross-Origin-Embedder-Policy", "require-corp")
         if "Cross-Origin-Resource-Policy" not in response.headers:
             response.headers["Cross-Origin-Resource-Policy"] = "cross-origin"
         response.headers.pop("X-Frame-Options", None)
         if request.path == "/" or request.path.endswith(".html"):
-            frame_ancestors = "frame-ancestors 'self' http://localhost:3000 http://127.0.0.1:3000"
+            frame_ancestors = (
+                "frame-ancestors 'self' "
+                "http://localhost:3000 http://127.0.0.1:3000 "
+                "http://localhost:3001 http://127.0.0.1:3001 "
+                "http://tauri.localhost https://tauri.localhost tauri://localhost"
+            )
             existing_csp = response.headers.get("Content-Security-Policy", "").strip()
             if existing_csp:
                 if "frame-ancestors" not in existing_csp:
@@ -3211,7 +3345,7 @@ def create_app(review_root: Path, initial_epub_path: Path | None = None, reset:
 
     @app.route("/api/session")
     def api_session():
-        session_root, epub_path = active_session()
+        session_root, epub_path = session_from_request()
         if session_root is None or epub_path is None:
             return jsonify(
                 {
@@ -3245,7 +3379,7 @@ def create_app(review_root: Path, initial_epub_path: Path | None = None, reset:
 
     @app.route("/api/version")
     def api_version():
-        return jsonify({"version": version, "version_rules": VERSION_RULES})
+        return jsonify({"version": version, "version_rules": VERSION_RULES, "review_root": str(review_root)})
 
     @app.route("/api/sessions")
     def api_sessions():
@@ -3312,6 +3446,7 @@ def create_app(review_root: Path, initial_epub_path: Path | None = None, reset:
     def api_open_session():
         data = request.get_json(silent=True) or {}
         session_id = str(data.get("session_id", ""))
+        activate = bool(data.get("activate", True))
         if not session_id:
             return jsonify({"error": "缺少 session_id"}), 400
         try:
@@ -3322,8 +3457,33 @@ def create_app(review_root: Path, initial_epub_path: Path | None = None, reset:
             return jsonify({"error": "会话不存在或不完整"}), 404
         if session_is_hidden(session_root):
             return jsonify({"error": "会话已从书架移除"}), 404
+        if activate:
+            with app.config["LOCK"]:
+                set_active_session(session_root)
+        summary = summarize_session(session_root)
+        summary["has_session"] = True
+        return jsonify(summary)
+
+    @app.route("/api/session/from-path", methods=["POST"])
+    def api_session_from_path():
+        data = request.get_json(silent=True) or {}
+        raw_path = str(data.get("epub_path") or "").strip()
+        if not raw_path:
+            return jsonify({"error": "缺少 epub_path"}), 400
+        epub_path = Path(raw_path).expanduser().resolve()
+        if not epub_path.exists():
+            return jsonify({"error": f"EPUB not found: {epub_path}"}), 404
+        try:
+            validate_epub_file(epub_path)
+        except ValueError as exc:
+            return jsonify({"error": str(exc)}), 400
+        reset_session = bool(data.get("reset", False))
+        activate = bool(data.get("activate", True))
         with app.config["LOCK"]:
-            set_active_session(session_root)
+            session_root = session_root_for(review_root, epub_path)
+            ensure_state(session_root, epub_path, reset=reset_session)
+            if activate:
+                set_active_session(session_root, epub_path)
         summary = summarize_session(session_root)
         summary["has_session"] = True
         return jsonify(summary)
@@ -3349,21 +3509,21 @@ def create_app(review_root: Path, initial_epub_path: Path | None = None, reset:
 
     @app.route("/api/rows")
     def api_rows():
-        session_root, _epub_path = active_session()
+        session_root, _epub_path = session_from_request()
         if session_root is None:
             return no_active_response()
         return jsonify({"rows": merge_rows(session_root)})
 
     @app.route("/api/structure")
     def api_structure():
-        session_root, _epub_path = active_session()
+        session_root, _epub_path = session_from_request()
         if session_root is None:
             return no_active_response()
         return jsonify(build_structure(session_root))
 
     @app.route("/api/reading-position", methods=["GET", "POST"])
     def api_reading_position():
-        session_root, _epub_path = active_session()
+        session_root, _epub_path = session_from_request()
         if session_root is None:
             return no_active_response()
         if request.method == "GET":
@@ -3385,7 +3545,7 @@ def create_app(review_root: Path, initial_epub_path: Path | None = None, reset:
 
     @app.route("/api/asset/<path:entry_name>")
     def api_asset(entry_name: str):
-        session_root, _epub_path = active_session()
+        session_root, _epub_path = session_from_request()
         if session_root is None:
             return no_active_response()
         entry_name = urllib.parse.unquote(entry_name)
@@ -3434,12 +3594,13 @@ def create_app(review_root: Path, initial_epub_path: Path | None = None, reset:
 
     @app.route("/api/gpt/config", methods=["GET", "POST"])
     def api_gpt_config():
+        session_root, _epub_path = session_from_request()
         if request.method == "GET":
-            return jsonify(public_gpt_config(review_root))
+            return jsonify(public_scoped_gpt_config(review_root, session_root))
         data = request.get_json(silent=True) or {}
         try:
             if data.get("reset_prompts"):
-                current = read_gpt_config(review_root)
+                current = read_scoped_gpt_config(review_root, session_root)
                 data = {
                     **data,
                     "base_url": data.get("base_url") or current["base_url"],
@@ -3447,39 +3608,48 @@ def create_app(review_root: Path, initial_epub_path: Path | None = None, reset:
                     "keep_existing": data.get("keep_existing", True),
                     **gpt_prompt_defaults(),
                 }
-            return jsonify(save_gpt_config(review_root, data))
+            return jsonify(save_scoped_gpt_config(review_root, data, session_root))
         except ValueError as exc:
             return jsonify({"error": str(exc)}), 400
 
     @app.route("/api/glossary", methods=["GET", "POST"])
     def api_glossary():
+        session_root, _epub_path = session_from_request()
         if request.method == "GET":
             try:
-                return jsonify(public_glossary(review_root))
+                return jsonify(public_glossary(review_root, session_root))
             except ValueError as exc:
                 return jsonify({"error": str(exc)}), 400
         data = request.get_json(silent=True) or {}
         try:
             requested_path = str(data.get("path") or "").strip()
             if requested_path:
-                update_gpt_config_fields(review_root, {"glossary_path": normalize_glossary_path_value(requested_path)})
+                path_value = normalize_glossary_path_value(requested_path)
+                if session_root is None:
+                    update_gpt_config_fields(review_root, {"glossary_path": path_value})
+                else:
+                    current = read_json(session_gpt_config_path(session_root), {})
+                    current["glossary_path"] = path_value
+                    current["updated_at"] = now_iso()
+                    write_json(session_gpt_config_path(session_root), current)
             if "entries" not in data:
-                return jsonify(public_glossary(review_root))
+                return jsonify(public_glossary(review_root, session_root))
             entries = data.get("entries", [])
             if not isinstance(entries, list):
                 return jsonify({"error": "entries 必须是数组"}), 400
-            return jsonify(save_glossary(review_root, entries))
+            return jsonify(save_glossary(review_root, entries, session_root))
         except ValueError as exc:
             return jsonify({"error": str(exc)}), 400
 
     @app.route("/api/glossary/entry", methods=["POST", "DELETE"])
     def api_glossary_entry():
+        session_root, _epub_path = session_from_request()
         data = request.get_json(silent=True) or {}
         source = str(data.get("source") or "").strip()
         if not source:
             return jsonify({"error": "缺少术语原文"}), 400
         try:
-            glossary = read_glossary(review_root)
+            glossary = read_glossary(review_root, session_root)
             if request.method == "DELETE":
                 if source not in glossary:
                     return jsonify({"error": "术语不存在"}), 404
@@ -3492,15 +3662,22 @@ def create_app(review_root: Path, initial_epub_path: Path | None = None, reset:
                 if old_source and old_source != source:
                     glossary.pop(old_source, None)
                 glossary[source] = target
-            return jsonify(save_glossary(review_root, [{"source": key, "target": value} for key, value in glossary.items()]))
+            return jsonify(
+                save_glossary(
+                    review_root,
+                    [{"source": key, "target": value} for key, value in glossary.items()],
+                    session_root,
+                )
+            )
         except ValueError as exc:
             return jsonify({"error": str(exc)}), 400
 
     @app.route("/api/glossary/search")
     def api_glossary_search():
+        session_root, _epub_path = session_from_request()
         term = str(request.args.get("q") or "")
         try:
-            matches = search_glossary_entries(read_glossary(review_root), term)
+            matches = search_glossary_entries(read_glossary(review_root, session_root), term)
             return jsonify({"query": term, "count": len(matches), "matches": matches})
         except ValueError as exc:
             return jsonify({"error": str(exc)}), 400
@@ -3651,7 +3828,7 @@ def create_app(review_root: Path, initial_epub_path: Path | None = None, reset:
 
     @app.route("/api/row/<row_id>/retranslate", methods=["POST"])
     def api_retranslate_row(row_id: str):
-        session_root, _epub_path = active_session()
+        session_root, _epub_path = session_from_request()
         if session_root is None:
             return no_active_response()
         rows = merge_rows(session_root)
@@ -3660,7 +3837,7 @@ def create_app(review_root: Path, initial_epub_path: Path | None = None, reset:
             return jsonify({"error": "row not found"}), 404
         data = request.get_json(silent=True) or {}
         try:
-            config = read_gpt_config(review_root)
+            config = read_scoped_gpt_config(review_root, session_root)
             requested_base_url = str(data.get("base_url") or "").strip()
             requested_model = str(data.get("model") or "").strip()
             if requested_base_url and normalize_gpt_base_url(requested_base_url) != config["base_url"]:
@@ -3668,12 +3845,13 @@ def create_app(review_root: Path, initial_epub_path: Path | None = None, reset:
             if requested_model and requested_model != config["model"]:
                 return jsonify({"error": "重翻请求不能临时覆盖模型。请先保存 API 设置后再重翻。"}), 400
             instruction = str(data.get("instruction") or "")
-            glossary_lines = glossary_matches_for_prompt(review_root, row)
+            glossary_lines = glossary_matches_for_prompt(review_root, row, session_root=session_root)
             raw = call_openai_compatible_chat(config, build_retranslate_messages(row, rows, config, glossary_lines, instruction))
             candidate_html = sanitize_cn_html(restore_glossary_ruby_candidates(normalize_candidate_punctuation(raw), glossary_lines))
             if not candidate_html:
                 return jsonify({"error": "GPT 返回内容为空或无法作为译文保存"}), 502
             candidate_text = strip_tags(candidate_html)
+            resolved_glossary_path = str(glossary_path(review_root, session_root))
             record = {
                 "ts": now_iso(),
                 "event": "row_retranslated",
@@ -3685,7 +3863,7 @@ def create_app(review_root: Path, initial_epub_path: Path | None = None, reset:
                 "translation_prompt": config.get("translation_prompt", ""),
                 "format_prompt": config.get("format_prompt", ""),
                 "character_prompt": config.get("character_prompt", ""),
-                "glossary_path": str(glossary_path(review_root)),
+                "glossary_path": resolved_glossary_path,
                 "glossary_matches": glossary_lines,
                 "instruction": instruction[:1200],
                 "jp_text": row["jp_text"],
@@ -3700,7 +3878,7 @@ def create_app(review_root: Path, initial_epub_path: Path | None = None, reset:
                     "candidate_html": candidate_html,
                     "candidate_text": candidate_text,
                     "model": config["model"],
-                    "glossary_path": str(glossary_path(review_root)),
+                    "glossary_path": resolved_glossary_path,
                     "glossary_matches": glossary_lines,
                     "updated_at": record["ts"],
                 }
@@ -3712,11 +3890,11 @@ def create_app(review_root: Path, initial_epub_path: Path | None = None, reset:
 
     @app.route("/api/row/<row_id>", methods=["POST"])
     def api_save_row(row_id: str):
-        session_root, _epub_path = active_session()
+        session_root, _epub_path = session_from_request()
         if session_root is None:
             return no_active_response()
         data = request.get_json(silent=True) or {}
-        rows = read_json(session_root / "review_state" / "rows.json", [])
+        rows = ensure_rows_current(session_root)
         base = next((row for row in rows if row["id"] == row_id), None)
         if base is None:
             return jsonify({"error": "row not found"}), 404
@@ -3759,11 +3937,18 @@ def create_app(review_root: Path, initial_epub_path: Path | None = None, reset:
                     "after_cn_html": current_html,
                 },
             )
-        return jsonify({"status": "ok", "row_id": row_id, "updated_at": edit["updated_at"]})
+        return jsonify(
+            {
+                "status": "ok",
+                "row_id": row_id,
+                "updated_at": edit["updated_at"],
+                "current_html": current_html,
+            }
+        )
 
     @app.route("/api/apply", methods=["POST"])
     def api_apply():
-        session_root, _epub_path = active_session()
+        session_root, _epub_path = session_from_request()
         if session_root is None:
             return no_active_response()
         with app.config["LOCK"]:
@@ -3778,7 +3963,7 @@ def create_app(review_root: Path, initial_epub_path: Path | None = None, reset:
 
     @app.route("/api/export", methods=["POST"])
     def api_export():
-        session_root, _epub_path = active_session()
+        session_root, _epub_path = session_from_request()
         if session_root is None:
             return no_active_response()
         with app.config["LOCK"]:
@@ -3787,36 +3972,40 @@ def create_app(review_root: Path, initial_epub_path: Path | None = None, reset:
             {
                 "status": "ok",
                 "output": str(out_path),
-                "download_url": f"/downloads/export/{urllib.parse.quote(out_path.name)}",
+                "download_url": (
+                    f"/downloads/export/{urllib.parse.quote(out_path.name)}"
+                    f"?session_id={urllib.parse.quote(session_public_id(session_root))}"
+                ),
             }
         )
 
     @app.route("/api/feedback")
     def api_feedback():
-        session_root, _epub_path = active_session()
+        session_root, _epub_path = session_from_request()
         if session_root is None:
             return no_active_response()
         path = write_feedback_summary(session_root)
+        session_query = f"?session_id={urllib.parse.quote(session_public_id(session_root))}"
         return jsonify(
             {
                 "status": "ok",
                 "feedback_md": str(path),
                 "feedback_jsonl": str(session_root / "feedback" / "translation_feedback.jsonl"),
-                "feedback_md_url": "/downloads/feedback/feedback_for_codex.md",
-                "feedback_jsonl_url": "/downloads/feedback/translation_feedback.jsonl",
+                "feedback_md_url": f"/downloads/feedback/feedback_for_codex.md{session_query}",
+                "feedback_jsonl_url": f"/downloads/feedback/translation_feedback.jsonl{session_query}",
             }
         )
 
     @app.route("/downloads/export/<path:filename>")
     def download_export(filename: str):
-        session_root, _epub_path = active_session()
+        session_root, _epub_path = session_from_request()
         if session_root is None:
             return no_active_response()
         return send_from_directory(session_root / "exports", filename, as_attachment=True)
 
     @app.route("/downloads/feedback/<path:filename>")
     def download_feedback(filename: str):
-        session_root, _epub_path = active_session()
+        session_root, _epub_path = session_from_request()
         if session_root is None:
             return no_active_response()
         if filename not in {"feedback_for_codex.md", "translation_feedback.jsonl"}:

apps/readest-app/tools/epub-review-editor/static/app.js

@@ -1718,6 +1718,40 @@ async function openSession(sessionId) {
   }
 }
 
+async function openFromUrlParams() {
+  const params = new URLSearchParams(window.location.search);
+  const mode = params.get('mode') || 'review';
+  let sessionId = params.get('session_id') || '';
+  const epubPath = params.get('epub_path') || '';
+  if (!sessionId && epubPath) {
+    const payload = await api('/api/session/from-path', {
+      method: 'POST',
+      body: JSON.stringify({ epub_path: epubPath }),
+    });
+    sessionId = payload.id || '';
+  }
+  if (!sessionId && mode === 'translate') {
+    const session = await loadSession();
+    if (session && session.has_session && session.id) {
+      sessionId = session.id;
+    } else {
+      await showBookshelf();
+      return true;
+    }
+  }
+  if (!sessionId) return false;
+  if (mode === 'translate') {
+    await showTranslationScreen(sessionId);
+    return true;
+  }
+  await api('/api/session/open', {
+    method: 'POST',
+    body: JSON.stringify({ session_id: sessionId }),
+  });
+  await loadActiveSession({ message: '已打开审校会话。' });
+  return true;
+}
+
 function updateStructureCountsFromRows() {
   for (const chapter of structure.chapters || []) {
     chapter.row_count = 0;
@@ -3198,6 +3232,9 @@ function initEvents() {
 async function main() {
   initEvents();
   try {
+    if (await openFromUrlParams()) {
+      return;
+    }
     const session = await loadSession();
     if (!session || !session.has_session) {
       return;

apps/readest-app/tools/epub-review-editor/static/index.html

@@ -4,13 +4,13 @@
   <meta charset="utf-8">
   <meta name="viewport" content="width=device-width, initial-scale=1">
   <title>双语 EPUB 审校编辑器</title>
-  <link rel="stylesheet" href="/static/style.css?v=0.13.2">
+  <link rel="stylesheet" href="/static/style.css?v=0.16.4">
 </head>
 <body>
   <header class="topbar">
     <button id="bookshelfBtn" class="bookshelfNavButton" type="button">书架</button>
     <div class="brandBlock">
-      <h1>双语 EPUB 审校编辑器 <span id="appVersion" class="versionBadge">v0.13.2</span></h1>
+      <h1>双语 EPUB 审校编辑器 <span id="appVersion" class="versionBadge">v0.16.4</span></h1>
       <p id="sessionMeta">正在载入……</p>
     </div>
     <div class="modeTabs" role="tablist" aria-label="审校模式">
@@ -509,6 +509,6 @@
   </aside>
 
   <div class="toast" id="toast" hidden></div>
-  <script src="/static/app.js?v=0.13.2"></script>
+  <script src="/static/app.js?v=0.16.4"></script>
 </body>
 </html>

apps/readest-app/tools/epub-review-editor/test_inline_review_session_scope.py

@@ -0,0 +1,184 @@
+import importlib.util
+import json
+import tempfile
+import unittest
+from pathlib import Path
+
+
+SERVER_PATH = Path(__file__).with_name("server.py")
+SPEC = importlib.util.spec_from_file_location("epub_review_editor_server", SERVER_PATH)
+server = importlib.util.module_from_spec(SPEC)
+assert SPEC.loader is not None
+SPEC.loader.exec_module(server)
+
+
+def write_json(path: Path, data):
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(data, ensure_ascii=False), encoding="utf-8")
+
+
+class InlineReviewSessionScopeTest(unittest.TestCase):
+    def test_sanitize_cn_html_keeps_reader_review_inline_markup(self):
+        sanitized = server.sanitize_cn_html(
+            '<ruby><rb>文字</rb><rt>注音</rt></ruby>'
+            '<span class="review-annotation">（注：注释）</span>'
+            '<script>alert(1)</script>'
+        )
+
+        self.assertEqual(
+            sanitized,
+            '<ruby><rb>文字</rb><rt>注音</rt></ruby>'
+            '<span class="review-annotation">（注：注释）</span>',
+        )
+
+    def make_session(
+        self,
+        review_root: Path,
+        session_id: str,
+        epub_path: Path,
+        glossary_path: Path,
+    ) -> Path:
+        session_root = review_root / session_id
+        write_json(
+            session_root / "review_state" / "session.json",
+            {
+                "id": session_id,
+                "source_name": epub_path.name,
+                "source_epub": str(epub_path),
+            },
+        )
+        write_json(
+            session_root / "review_state" / "state.json",
+            {
+                "source_epub": str(epub_path),
+                "edits": {},
+            },
+        )
+        write_json(
+            session_root / "review_state" / "gpt_config.json",
+            {
+                "base_url": "https://session.example.test/v1",
+                "model": "session-model",
+                "glossary_path": str(glossary_path),
+                "translation_prompt": "session translation prompt",
+                "format_prompt": "session format prompt",
+                "character_prompt": "session character prompt",
+            },
+        )
+        return session_root
+
+    def test_inline_retranslate_uses_request_session_config_and_glossary(self):
+        with tempfile.TemporaryDirectory() as temp_dir:
+            root = Path(temp_dir)
+            review_root = root / "review-root"
+            global_glossary = root / "global-glossary.json"
+            session_glossary = root / "session-glossary.json"
+            write_json(global_glossary, {"別語": "全局译名"})
+            write_json(session_glossary, {"ファルシオン": "大砍刀"})
+            write_json(
+                review_root / "gpt_config.json",
+                {
+                    "api_key": "test-key",
+                    "base_url": "https://global.example.test/v1",
+                    "model": "global-model",
+                    "glossary_path": str(global_glossary),
+                },
+            )
+
+            epub_path = root / "book.epub"
+            epub_path.write_bytes(b"not a real epub")
+            session_root = self.make_session(review_root, "session-a", epub_path, session_glossary)
+            write_json(
+                session_root / "review_state" / "rows_meta.json",
+                {"parser_version": server.ROWS_PARSER_VERSION},
+            )
+            write_json(
+                session_root / "review_state" / "rows.json",
+                [
+                    {
+                        "id": "R00001",
+                        "file": "chapter.xhtml",
+                        "file_label": "chapter.xhtml",
+                        "document_title": "chapter",
+                        "ja_p_index": 0,
+                        "cn_p_index": 1,
+                        "jp_html": "<ruby>ファルシオン<rt>Falchion</rt></ruby>",
+                        "jp_text": "ファルシオン",
+                        "cn_html": "旧译文",
+                    }
+                ],
+            )
+
+            captured = {}
+            original_call = server.call_openai_compatible_chat
+
+            def fake_call(config, messages, temperature=0.2, timeout=90):
+                captured["config"] = config
+                captured["messages"] = messages
+                return "<span>候选译文</span>"
+
+            server.call_openai_compatible_chat = fake_call
+            try:
+                app = server.create_app(review_root)
+                response = app.test_client().post(
+                    "/api/row/R00001/retranslate?session_id=session-a",
+                    json={"instruction": ""},
+                )
+            finally:
+                server.call_openai_compatible_chat = original_call
+
+            self.assertEqual(response.status_code, 200, response.get_data(as_text=True))
+            payload = response.get_json()
+            self.assertEqual(payload["model"], "session-model")
+            self.assertEqual(payload["glossary_path"], str(session_glossary))
+            self.assertEqual(payload["glossary_matches"], ["ファルシオン => 大砍刀"])
+            self.assertEqual(captured["config"]["base_url"], "https://session.example.test/v1")
+            self.assertEqual(captured["config"]["translation_prompt"], "session translation prompt")
+            prompt_text = "\n".join(message["content"] for message in captured["messages"])
+            self.assertIn("ファルシオン => 大砍刀", prompt_text)
+            self.assertNotIn("全局译名", prompt_text)
+
+    def test_scoped_gpt_config_saves_secret_globally_and_public_response_hides_it(self):
+        with tempfile.TemporaryDirectory() as temp_dir:
+            root = Path(temp_dir)
+            review_root = root / "review-root"
+            glossary = root / "glossary.json"
+            write_json(glossary, {})
+            write_json(review_root / "gpt_config.json", {"glossary_path": str(glossary)})
+            epub_path = root / "book.epub"
+            epub_path.write_bytes(b"not a real epub")
+            self.make_session(review_root, "session-a", epub_path, glossary)
+
+            app = server.create_app(review_root)
+            response = app.test_client().post(
+                "/api/gpt/config?session_id=session-a",
+                json={
+                    "api_key": "session-secret",
+                    "base_url": "https://session.example.test/v1",
+                    "model": "session-model",
+                    "glossary_path": str(glossary),
+                    "translation_prompt": "session translation prompt",
+                    "format_prompt": "session format prompt",
+                    "character_prompt": "session character prompt",
+                },
+            )
+
+            self.assertEqual(response.status_code, 200, response.get_data(as_text=True))
+            payload = response.get_json()
+            self.assertTrue(payload["configured"])
+            self.assertNotIn("api_key", payload)
+            self.assertEqual(payload["base_url"], "https://session.example.test/v1")
+            self.assertEqual(
+                json.loads((review_root / "gpt_config.json").read_text(encoding="utf-8"))["api_key"],
+                "session-secret",
+            )
+            scoped = json.loads(
+                (review_root / "session-a" / "review_state" / "gpt_config.json").read_text(
+                    encoding="utf-8"
+                )
+            )
+            self.assertNotIn("api_key", scoped)
+
+
+if __name__ == "__main__":
+    unittest.main()

apps/readest-app/tools/epub-review-editor/version.py

@@ -1,4 +1,4 @@
-version = "0.13.2"
+version = "0.16.4"
 
 VERSION_RULES = {
     "PATCH": "修复 bug 或兼容性小修",

scripts/open-readest-latest.cmd

@@ -0,0 +1,2 @@
+@echo off
+powershell.exe -NoLogo -NoProfile -ExecutionPolicy Bypass -File "%~dp0open-readest-latest.ps1" %*

scripts/open-readest-latest.ps1

@@ -0,0 +1,162 @@
+param(
+  [string]$Remote = "akai-tools",
+  [string]$Branch = "codex/desktop-review-editor-blocks",
+  [switch]$SkipPull,
+  [switch]$CheckOnly,
+  [switch]$KeepRunning
+)
+
+$ErrorActionPreference = "Stop"
+[Console]::OutputEncoding = [System.Text.Encoding]::UTF8
+
+$RepoRoot = (Resolve-Path (Join-Path $PSScriptRoot "..")).Path
+
+function Write-Step {
+  param([string]$Message)
+  Write-Host ""
+  Write-Host "==> $Message" -ForegroundColor Cyan
+}
+
+function Invoke-Checked {
+  param(
+    [string]$Command,
+    [string[]]$Arguments,
+    [string]$WorkingDirectory = $RepoRoot
+  )
+
+  Push-Location $WorkingDirectory
+  try {
+    & $Command @Arguments
+    if ($LASTEXITCODE -ne 0) {
+      throw "$Command $($Arguments -join ' ') failed with exit code $LASTEXITCODE."
+    }
+  } finally {
+    Pop-Location
+  }
+}
+
+function Add-PathIfExists {
+  param([string]$PathToAdd)
+  if ($PathToAdd -and (Test-Path -LiteralPath $PathToAdd)) {
+    $script:PathParts += $PathToAdd
+  }
+}
+
+function Stop-OldReadestDev {
+  if ($KeepRunning) {
+    return
+  }
+
+  Write-Step "Stopping old Readest desktop/dev processes"
+  Get-Process -Name "Readest" -ErrorAction SilentlyContinue | Stop-Process -Force -ErrorAction SilentlyContinue
+
+  $repoLower = $RepoRoot.ToLowerInvariant()
+  $currentPid = $PID
+  Get-CimInstance Win32_Process |
+    Where-Object {
+      $_.ProcessId -ne $currentPid -and
+      $_.CommandLine -and
+      $_.CommandLine.ToLowerInvariant().Contains($repoLower) -and
+      ($_.CommandLine -match "tauri\s+dev|next\s+dev|@readest/readest-app|epub-reviewer:dev")
+    } |
+    ForEach-Object {
+      Stop-Process -Id $_.ProcessId -Force -ErrorAction SilentlyContinue
+    }
+}
+
+function Assert-CleanWorktree {
+  $status = (& git -C $RepoRoot status --porcelain)
+  if ($status) {
+    Write-Host ""
+    Write-Host "Local changes were found. The launcher will not pull or overwrite them:" -ForegroundColor Yellow
+    & git -C $RepoRoot status --short
+    throw "Commit, stash, or discard local changes before launching the latest organization version."
+  }
+}
+
+try {
+  $PathParts = @()
+  $runtimeRoot = Join-Path $env:USERPROFILE ".cache\codex-runtimes\codex-primary-runtime\dependencies"
+  Add-PathIfExists "C:\w64devkit\bin"
+  Add-PathIfExists (Join-Path $runtimeRoot "bin")
+  Add-PathIfExists (Join-Path $runtimeRoot "node\bin")
+  Add-PathIfExists (Join-Path $env:USERPROFILE ".cargo\bin")
+  $env:Path = (($PathParts + ($env:Path -split ";" | Where-Object { $_ })) -join ";")
+  $env:RUSTUP_TOOLCHAIN = "stable-x86_64-pc-windows-gnu"
+
+  foreach ($command in @("git", "pnpm", "cargo")) {
+    if (-not (Get-Command $command -ErrorAction SilentlyContinue)) {
+      throw "Required command not found: $command"
+    }
+  }
+
+  Write-Step "Readest latest launcher"
+  Write-Host "Repository: $RepoRoot"
+  Write-Host "Remote:     $Remote"
+  Write-Host "Branch:     $Branch"
+
+  $beforeHead = (& git -C $RepoRoot rev-parse HEAD).Trim()
+
+  if (-not $SkipPull) {
+    Assert-CleanWorktree
+
+    Write-Step "Fetching latest code from organization remote"
+    Invoke-Checked "git" @("-C", $RepoRoot, "fetch", "--prune", $Remote)
+
+    $currentBranch = (& git -C $RepoRoot branch --show-current).Trim()
+    if ($currentBranch -ne $Branch) {
+      Write-Step "Switching to $Branch"
+      & git -C $RepoRoot show-ref --verify --quiet "refs/heads/$Branch"
+      if ($LASTEXITCODE -eq 0) {
+        Invoke-Checked "git" @("-C", $RepoRoot, "switch", $Branch)
+      } else {
+        Invoke-Checked "git" @("-C", $RepoRoot, "switch", "--track", "-c", $Branch, "$Remote/$Branch")
+      }
+    }
+
+    Write-Step "Fast-forwarding local branch"
+    Invoke-Checked "git" @("-C", $RepoRoot, "pull", "--ff-only", $Remote, $Branch)
+  } else {
+    Write-Step "Skipping git pull by request"
+  }
+
+  $afterHead = (& git -C $RepoRoot rev-parse HEAD).Trim()
+
+  Write-Step "Updating submodules"
+  Invoke-Checked "git" @("-C", $RepoRoot, "submodule", "update", "--init", "--recursive")
+
+  $changedFiles = @()
+  if ($beforeHead -ne $afterHead) {
+    $changedFiles = (& git -C $RepoRoot diff --name-only $beforeHead $afterHead)
+  }
+
+  $needsInstall =
+    -not (Test-Path -LiteralPath (Join-Path $RepoRoot "node_modules")) -or
+    ($changedFiles -contains "pnpm-lock.yaml") -or
+    ($changedFiles -contains "package.json") -or
+    ($changedFiles -contains "apps/readest-app/package.json")
+
+  if ($needsInstall) {
+    Write-Step "Installing/updating dependencies"
+    Invoke-Checked "pnpm" @("install", "--frozen-lockfile")
+  }
+
+  if ($CheckOnly) {
+    Write-Step "Launcher check complete"
+    exit 0
+  }
+
+  Stop-OldReadestDev
+
+  Write-Step "Starting Readest desktop with the latest code"
+  Write-Host "Close the Readest window or press Ctrl+C here to stop the dev server."
+  Invoke-Checked "pnpm" @("--filter", "@readest/readest-app", "tauri", "dev")
+} catch {
+  Write-Host ""
+  Write-Host "Readest launcher failed:" -ForegroundColor Red
+  Write-Host $_.Exception.Message -ForegroundColor Red
+  Write-Host ""
+  Write-Host "Press Enter to close this window."
+  [void][Console]::ReadLine()
+  exit 1
+}