add demo_gradio_batch.py

demo/demo_gradio_batch.py

@@ -0,0 +1,2786 @@
+import os
+import io
+import uuid
+import json
+import zipfile
+import tempfile
+import threading
+import queue
+import shutil
+from pathlib import Path
+from PIL import Image
+import requests
+import gradio as gr
+import re
+import math
+import datetime
+
+# Local project imports (assumed available)
+from dots_ocr.utils import dict_promptmode_to_prompt
+from dots_ocr.utils.consts import MIN_PIXELS, MAX_PIXELS
+from dots_ocr.utils.demo_utils.display import read_image
+from dots_ocr.parser import DotsOCRParser
+
+# ---------------- Config & globals ----------------
+DEFAULT_CONFIG = {
+    "ip": "127.0.0.1",
+    "port_vllm": 8000,
+    "min_pixels": MIN_PIXELS,
+    "max_pixels": MAX_PIXELS,
+}
+
+# Absolute constraints discovered from runtime:
+ABS_MIN_PIXELS = 3136
+ABS_MAX_PIXELS = 11289600
+
+current_config = DEFAULT_CONFIG.copy()
+
+# default parser instance (can be overridden per-task)
+dots_parser = DotsOCRParser(
+    ip=DEFAULT_CONFIG["ip"],
+    port=DEFAULT_CONFIG["port_vllm"],
+    dpi=200,
+    min_pixels=DEFAULT_CONFIG["min_pixels"],
+    max_pixels=DEFAULT_CONFIG["max_pixels"],
+)
+
+RESULTS_CACHE = {}  # rid -> result dict or placeholder
+TASK_QUEUE = queue.Queue()
+# Worker pool for background processing (adjustable via UI)
+WORKER_THREADS = []
+MAX_CONCURRENCY = 6
+THREAD_LOCK = threading.Lock()
+RETRY_COUNTS = {}  # rid -> attempts
+MAX_AUTO_RETRIES = 5
+RETRY_BACKOFF_BASE = 1.7
+DEFAULT_SCRIPT_TEMPLATE = """# 高级脚本使用说明
+# 提供对象: api
+# 日志: 使用 print(...) 或 debug(...) 输出到下方“脚本日志”实时区域。
+# api.get_ids() -> [rid,...] 按当前 UI 顺序返回
+# api.get_status(rid) -> {'status','ui': {'tab','nohf','source'}, 'filtered': bool, 'input_width': int, 'input_height': int}
+# api.get_texts(rid) -> {
+#   'md': 原始 Markdown, 'md_nohf': 原始 NOHF Markdown, 'json': 原始 JSON,
+#   'md_edit': 编辑版 Markdown 或 None, 'md_nohf_edit': 编辑版 NOHF Markdown 或 None, 'json_edit': 编辑版 JSON 或 None
+# }
+# api.choose_texts(rid, prefer_ui=True, prefer_edit=True, prefer_nohf=None) -> {'md','json'}
+#   - prefer_ui: True 时根据当前 UI 的 NOHF/来源选择内容
+#   - prefer_edit: True 时优先用编辑内容（若存在）
+#   - prefer_nohf: 显式指定是否使用 NOHF（覆盖 UI），None 表示跟随 UI
+# api.list_paths(rid) -> {
+#   'temp_dir': str, 'session_id': str,
+#   'result': {'md':path,'md_nohf':path,'json':path,'layout':path or None,'image':path or None},
+#   'edited': {'md':path or None,'md_nohf':path or None,'json':path or None}
+# }
+# api.path_exists(path) -> bool   判断路径是否存在
+# api.build_export(name='custom') -> ExportBuilder
+# ExportBuilder:
+#   .add_text('dir/file.md', '...')            写入文本
+#   .add_bytes('bin/data.bin', b'...')         写入二进制
+#   .add_file('/abs/path/file.md', 'dir/file.md')  拷贝已有文件
+#   .mkdir('subdir/')                           创建目录
+#   .finalize() -> zip_path                     打包为 zip 并返回路径
+#
+# 约定: 定义 main(api) 并返回以下之一：
+# - ExportBuilder 实例（将自动 finalize）
+# - 目录路径或文件路径（目录将被打包为 zip）
+# - None（若存在变量 export=ExportBuilder，将自动 finalize）
+#
+# 示例：按 UI 所见优先使用“编辑源码”与 NOHF，导出每个结果的 md/json，同时附带原始与编辑文件
+def main(api):
+    ids = api.get_ids()
+    eb = api.build_export('custom_export')
+    for i, rid in enumerate(ids, start=1):
+        st = api.get_status(rid)
+        if st['status'] != 'done':
+            continue
+        choice = api.choose_texts(rid, prefer_ui=True, prefer_edit=True)
+        eb.add_text(f'result_{i}_{rid}/content.md', choice['md'] or '')
+        eb.add_text(f'result_{i}_{rid}/data.json', choice['json'] or '{}')
+        paths = api.list_paths(rid)
+        # 附带原始文件
+        for p in (paths.get('result') or {}).values():
+            if p and api.path_exists(p):
+                name = Path(p).name
+                eb.add_file(p, f'result_{i}_{rid}/raw/{name}')
+        # 附带编辑文件
+        for p in (paths.get('edited') or {}).values():
+            if p and api.path_exists(p):
+                name = Path(p).name
+                eb.add_file(p, f'result_{i}_{rid}/edited/{name}')
+    return eb
+"""
+
+
+# ---------------- Helpers ----------------
+def read_image_v2(img):
+    """Read image from URL or local path / PIL.Image. Supports file paths and URLs."""
+    if isinstance(img, Image.Image):
+        return img
+    if isinstance(img, str) and img.startswith(("http://", "https://")):
+        with requests.get(img, stream=True) as r:
+            r.raise_for_status()
+            return Image.open(io.BytesIO(r.content)).convert("RGB")
+    if isinstance(img, str) and os.path.exists(img):
+        return Image.open(img).convert("RGB")
+    try:
+        img_res = read_image(img, use_native=True)
+        if isinstance(img_res, tuple) and isinstance(img_res[0], Image.Image):
+            return img_res[0]
+    except Exception:
+        pass
+    raise ValueError(f"Unsupported image input: {type(img)} / {repr(img)[:200]}")
+
+
+def create_temp_session_dir():
+    session_id = uuid.uuid4().hex[:8]
+    temp_dir = os.path.join(tempfile.gettempdir(), f"dots_ocr_demo_{session_id}")
+    os.makedirs(temp_dir, exist_ok=True)
+    return temp_dir, session_id
+
+
+def classify_parse_failure(exc, min_p, max_p):
+    """Return a user-friendly error message for known failure causes."""
+    msg = str(exc)
+    reasons = []
+    # Absolute & semantic constraints
+    if min_p < ABS_MIN_PIXELS:
+        reasons.append(
+            f"Min Pixels 过小：{min_p}，必须 >= {ABS_MIN_PIXELS}。建议提高 Min Pixels。"
+        )
+    if max_p > ABS_MAX_PIXELS:
+        reasons.append(
+            f"Max Pixels 过大：{max_p}，必须 <= {ABS_MAX_PIXELS}。建议降低 Max Pixels。"
+        )
+    if min_p >= max_p:
+        reasons.append(
+            f"像素参数不合法：Min Pixels({min_p}) >= Max Pixels({max_p})，必须满足 Min Pixels < Max Pixels。"
+        )
+
+    lower = msg.lower()
+    if "no results returned from parser" in lower or "no results returned" in lower:
+        reasons.append(
+            "解析未返回结果。可能原因：图像过小、Min Pixels 设置过小或过滤过强。"
+            f"建议：Min Pixels >= {ABS_MIN_PIXELS} 且 Max Pixels <= {ABS_MAX_PIXELS}。"
+        )
+    if "failed to read input" in lower or "cannot identify image file" in lower:
+        reasons.append("无法读取输入文件，请确认文件是否为有效图片或PDF。")
+    if ("connection" in lower and "refused" in lower) or ("connectionerror" in lower):
+        reasons.append("无法连接后端推理服务，请检查 Server IP/Port 与服务状态。")
+
+    if not reasons:
+        reasons.append(f"未知错误：{msg}")
+
+    detail = "\n".join(f"- {r}" for r in reasons)
+    cfg = f"(当前参数：min_pixels={min_p}, max_pixels={max_p})"
+    return f"解析失败：\n{detail}\n{cfg}"
+
+
+def _is_transient_backend_error(exc: Exception):
+    lower = str(exc).lower()
+    # Common signals: connection refused/reset, timeout, gateway, service unavailable
+    keywords = [
+        "connection refused",
+        "connectionerror",
+        "timeout",
+        "timed out",
+        "gateway",
+        "service unavailable",
+        "failed to establish a new connection",
+        "max retries exceeded",
+        "read timeout",
+        "connect timeout",
+    ]
+    return any(k in lower for k in keywords)
+
+
+def parse_image_with_high_level_api(parser, image, prompt_mode, fitz_preprocess=False):
+    """
+    Calls parser.parse_image with a PIL image (or accepts image path if parser expects path).
+    Returns dictionary with artifacts. Keeps a temp PNG of the input for traceability.
+    """
+    temp_dir, session_id = create_temp_session_dir()
+    if not isinstance(image, Image.Image):
+        image = read_image_v2(image)
+    temp_image_path = os.path.join(temp_dir, f"input_{session_id}.png")
+    image.save(temp_image_path, "PNG")
+
+    filename = f"demo_{session_id}"
+    results = parser.parse_image(
+        input_path=image,
+        filename=filename,
+        prompt_mode=prompt_mode,
+        save_dir=temp_dir,
+        fitz_preprocess=fitz_preprocess,
+    )
+    if not results:
+        raise RuntimeError("No results returned from parser")
+
+    result = results[0]
+    layout_image = None
+    if result.get("layout_image_path") and os.path.exists(result["layout_image_path"]):
+        try:
+            layout_image = Image.open(result["layout_image_path"]).convert("RGB")
+        except Exception:
+            layout_image = None
+
+    cells_data = None
+    if result.get("layout_info_path") and os.path.exists(result["layout_info_path"]):
+        with open(result["layout_info_path"], "r", encoding="utf-8") as f:
+            cells_data = json.load(f)
+
+    md_content = None
+    if result.get("md_content_path") and os.path.exists(result["md_content_path"]):
+        with open(result["md_content_path"], "r", encoding="utf-8") as f:
+            md_content = f.read()
+
+    md_content_nohf = None
+    if result.get("md_content_nohf_path") and os.path.exists(
+        result["md_content_nohf_path"]
+    ):
+        with open(result["md_content_nohf_path"], "r", encoding="utf-8") as f:
+            md_content_nohf = f.read()
+
+    json_code = ""
+    if cells_data is not None:
+        try:
+            json_code = json.dumps(cells_data, ensure_ascii=False, indent=2)
+        except Exception:
+            json_code = str(cells_data)
+
+    return {
+        "original_image": image,
+        "layout_image": layout_image,
+        "cells_data": cells_data,
+        "md_content": md_content,
+        "md_content_nohf": md_content_nohf,
+        "json_code": json_code,
+        "filtered": result.get("filtered", False),
+        "temp_dir": temp_dir,
+        "session_id": session_id,
+        "result_paths": result,
+        "input_width": result.get("input_width", 0),
+        "input_height": result.get("input_height", 0),
+        "input_temp_path": temp_image_path,
+    }
+
+
+def _validate_pixels(min_p, max_p):
+    """Coerce pixel parameters. Do NOT auto-swap; semantic errors are handled by pre-validation."""
+    try:
+        min_p = int(min_p)
+    except Exception:
+        min_p = DEFAULT_CONFIG["min_pixels"]
+    try:
+        max_p = int(max_p)
+    except Exception:
+        max_p = DEFAULT_CONFIG["max_pixels"]
+    if min_p <= 0:
+        min_p = DEFAULT_CONFIG["min_pixels"]
+    if max_p <= 0:
+        max_p = DEFAULT_CONFIG["max_pixels"]
+    return min_p, max_p
+
+
+def _set_parser_config(server_ip, server_port, min_pixels, max_pixels):
+    min_pixels, max_pixels = _validate_pixels(min_pixels, max_pixels)
+    current_config.update(
+        {
+            "ip": server_ip,
+            "port_vllm": int(server_port),
+            "min_pixels": min_pixels,
+            "max_pixels": max_pixels,
+        }
+    )
+    dots_parser.ip = server_ip
+    dots_parser.port = int(server_port)
+    dots_parser.min_pixels = min_pixels
+    dots_parser.max_pixels = max_pixels
+
+
+def purge_queue(rid):
+    """Best-effort remove tasks matching rid from queue."""
+    pending = []
+    try:
+        while True:
+            task = TASK_QUEUE.get_nowait()
+            if task and isinstance(task, tuple):
+                if task[0] != rid:
+                    pending.append(task)
+            TASK_QUEUE.task_done()
+    except queue.Empty:
+        pass
+    for t in pending:
+        TASK_QUEUE.put(t)
+
+
+# ---------------- Export helpers ----------------
+def export_one_rid(rid):
+    st = RESULTS_CACHE.get(rid)
+    if not st:
+        return None
+    temp_dir = st.get("temp_dir")
+    if not temp_dir or not os.path.isdir(temp_dir):
+        return None
+    out_dir, _sess = create_temp_session_dir()
+    zip_path = os.path.join(out_dir, f"export_{rid}.zip")
+    with zipfile.ZipFile(zip_path, "w", zipfile.ZIP_DEFLATED) as zf:
+        for rt, _, files in os.walk(temp_dir):
+            for f in files:
+                src = os.path.join(rt, f)
+                rel = os.path.relpath(src, temp_dir)
+                zf.write(src, os.path.join(f"result_{rid}", rel))
+    return zip_path
+
+
+def ensure_export_ready(rid):
+    """Create and cache export zip path if not present."""
+    st = RESULTS_CACHE.get(rid) or {}
+    if not st or st.get("status") != "done":
+        return None
+    path = st.get("export_path")
+    if path and os.path.exists(path):
+        return path
+    path = export_one_rid(rid)
+    if path:
+        st["export_path"] = path
+        RESULTS_CACHE[rid] = st
+    return path
+
+
+# ---------------- Script API & execution ----------------
+class ExportBuilder:
+    def __init__(self, name=None):
+        root, sid = create_temp_session_dir()
+        sub = f"script_export_{sid}"
+        if name:
+            sub = f"{name}_{sid}"
+        self.root_dir = os.path.join(root, sub)
+        os.makedirs(self.root_dir, exist_ok=True)
+        self._final_zip = None
+
+    def _abspath(self, rel_path: str):
+        rel_path = rel_path.lstrip("/\\")
+        return os.path.join(self.root_dir, rel_path)
+
+    def mkdir(self, rel_dir: str):
+        p = self._abspath(rel_dir)
+        os.makedirs(p, exist_ok=True)
+        return p
+
+    def add_text(self, rel_path: str, content: str, encoding: str = "utf-8"):
+        p = self._abspath(rel_path)
+        os.makedirs(os.path.dirname(p), exist_ok=True)
+        with open(p, "w", encoding=encoding) as f:
+            f.write("" if content is None else str(content))
+        return p
+
+    def add_bytes(self, rel_path: str, data: bytes):
+        p = self._abspath(rel_path)
+        os.makedirs(os.path.dirname(p), exist_ok=True)
+        with open(p, "wb") as f:
+            f.write(data or b"")
+        return p
+
+    def add_file(self, src_path: str, dest_rel_path: str = None):
+        if not src_path or not os.path.exists(src_path):
+            return None
+        dest_rel_path = dest_rel_path or os.path.basename(src_path)
+        p = self._abspath(dest_rel_path)
+        os.makedirs(os.path.dirname(p), exist_ok=True)
+        shutil.copy2(src_path, p)
+        return p
+
+    def finalize(self, zip_name: str = None):
+        if self._final_zip and os.path.exists(self._final_zip):
+            return self._final_zip
+        out_dir, sid = create_temp_session_dir()
+        zip_name = zip_name or f"script_export_{sid}.zip"
+        zip_path = os.path.join(out_dir, zip_name)
+        with zipfile.ZipFile(zip_path, "w", zipfile.ZIP_DEFLATED) as zf:
+            for rt, _, files in os.walk(self.root_dir):
+                for f in files:
+                    src = os.path.join(rt, f)
+                    rel = os.path.relpath(src, self.root_dir)
+                    zf.write(src, rel)
+        self._final_zip = zip_path
+        return zip_path
+
+
+class ScriptAPI:
+    def __init__(self, ids_snapshot):
+        self._ids = list(ids_snapshot or [])
+
+    def get_ids(self):
+        return list(self._ids)
+
+    def get_status(self, rid: str):
+        st = dict(RESULTS_CACHE.get(rid) or {})
+        ui = dict(st.get("ui") or {})
+        return {
+            "status": st.get("status", "pending"),
+            "ui": {
+                "tab": ui.get("tab", "md"),
+                "nohf": bool(ui.get("nohf", False)),
+                "source": ui.get("source", "源码"),
+            },
+            "filtered": bool(st.get("filtered", False)),
+            "input_width": int(st.get("input_width", 0) or 0),
+            "input_height": int(st.get("input_height", 0) or 0),
+        }
+
+    def get_texts(self, rid: str):
+        st = dict(RESULTS_CACHE.get(rid) or {})
+        edits = dict(st.get("edits") or {})
+        return {
+            "md": st.get("md_content") or "",
+            "md_nohf": st.get("md_content_nohf") or "",
+            "json": st.get("json_code") or "",
+            "md_edit": edits.get("md"),
+            "md_nohf_edit": edits.get("nohf"),
+            "json_edit": edits.get("json"),
+        }
+
+    def choose_texts(
+        self,
+        rid: str,
+        prefer_ui: bool = True,
+        prefer_edit: bool = True,
+        prefer_nohf: bool | None = None,
+    ):
+        st = dict(RESULTS_CACHE.get(rid) or {})
+        ui = dict(st.get("ui") or {})
+        # UI 指示
+        ui_nohf = bool(ui.get("nohf", False))
+        ui_source_is_edit = str(ui.get("source", "源码")) == "编辑源码"
+        # 选择 nohf
+        use_nohf = ui_nohf if prefer_nohf is None else bool(prefer_nohf)
+        # 选择是否优先编辑
+        prefer_edit_final = bool(prefer_edit or (prefer_ui and ui_source_is_edit))
+        t = self.get_texts(rid)
+        # Markdown
+        md_orig = t["md_nohf"] if use_nohf else t["md"]
+        md_edit = t["md_nohf_edit"] if use_nohf else t["md_edit"]
+        md = (md_edit if (prefer_edit_final and md_edit is not None) else md_orig) or ""
+        # JSON
+        json_text = (
+            t["json_edit"]
+            if (prefer_edit_final and t.get("json_edit") is not None)
+            else t["json"]
+        ) or ""
+        return {"md": md, "json": json_text}
+
+    def list_paths(self, rid: str):
+        st = dict(RESULTS_CACHE.get(rid) or {})
+        rp = dict(st.get("result_paths") or {})
+        md_p = rp.get("md_content_path")
+        nohf_p = rp.get("md_content_nohf_path")
+        json_p = rp.get("layout_info_path") or rp.get("json_path")
+        image_p = rp.get("layout_image_path") or None
+        # 编辑路径（若存在）
+        edited_md = None
+        edited_nohf = None
+        edited_json = None
+        try:
+            edited_md = _edited_filepath(st, "md")
+            if not os.path.exists(edited_md):
+                edited_md = None
+        except Exception:
+            edited_md = None
+        try:
+            edited_nohf = _edited_filepath(st, "nohf")
+            if not os.path.exists(edited_nohf):
+                edited_nohf = None
+        except Exception:
+            edited_nohf = None
+        try:
+            edited_json = _edited_filepath(st, "json")
+            if not os.path.exists(edited_json):
+                edited_json = None
+        except Exception:
+            edited_json = None
+        return {
+            "temp_dir": st.get("temp_dir"),
+            "session_id": st.get("session_id"),
+            "result": {
+                "md": md_p if (md_p and os.path.exists(md_p)) else None,
+                "md_nohf": nohf_p if (nohf_p and os.path.exists(nohf_p)) else None,
+                "json": json_p if (json_p and os.path.exists(json_p)) else None,
+                "layout": image_p if (image_p and os.path.exists(image_p)) else None,
+                "input_image": (
+                    st.get("input_temp_path")
+                    if (
+                        st.get("input_temp_path")
+                        and os.path.exists(st.get("input_temp_path"))
+                    )
+                    else None
+                ),
+            },
+            "edited": {
+                "md": edited_md,
+                "md_nohf": edited_nohf,
+                "json": edited_json,
+            },
+        }
+
+    def path_exists(self, p: str) -> bool:
+        try:
+            return bool(p) and os.path.exists(p)
+        except Exception:
+            return False
+
+    def build_export(self, name: str | None = None):
+        return ExportBuilder(name=name)
+
+
+def _safe_builtins():
+    base = (
+        __builtins__
+        if isinstance(__builtins__, dict)
+        else getattr(__builtins__, "__dict__", {})
+    )
+    allow = [
+        "abs",
+        "min",
+        "max",
+        "sum",
+        "len",
+        "range",
+        "enumerate",
+        "map",
+        "filter",
+        "zip",
+        "list",
+        "dict",
+        "set",
+        "tuple",
+        "str",
+        "int",
+        "float",
+        "bool",
+        "print",
+        "any",
+        "all",
+        "sorted",
+    ]
+    return {k: base[k] for k in allow if k in base}
+
+
+def run_user_script(script_code: str, ids_snapshot):
+    """
+    非流式执行用户脚本，捕获标准输出并返回（zip_path, logs）。
+    """
+    api = ScriptAPI(ids_snapshot)
+    ns = {
+        "__builtins__": _safe_builtins(),
+        "api": api,
+        "json": json,
+        "re": re,
+        "math": math,
+        "datetime": datetime,
+        "Path": Path,
+        "io": io,
+        "ExportBuilder": ExportBuilder,
+    }
+    import contextlib
+    from io import StringIO
+
+    buf = StringIO()
+    zip_path = None
+    try:
+        code = script_code or ""
+        with contextlib.redirect_stdout(buf):
+            exec(code, ns, ns)
+            result = None
+            main_fn = ns.get("main")
+            if callable(main_fn):
+                result = main_fn(api)
+            else:
+                result = ns.get("RESULT") or ns.get("OUTPUT_PATH")
+            if isinstance(result, ExportBuilder):
+                zip_path = result.finalize()
+            elif isinstance(result, str) and result:
+                if os.path.isdir(result):
+                    eb = ExportBuilder("script_dir_export")
+                    for rt, _, files in os.walk(result):
+                        for f in files:
+                            src = os.path.join(rt, f)
+                            rel = os.path.relpath(src, result)
+                            eb.add_file(src, rel)
+                    zip_path = eb.finalize()
+                elif os.path.exists(result):
+                    zip_path = result
+            if not zip_path:
+                exp = ns.get("export")
+                if isinstance(exp, ExportBuilder):
+                    zip_path = exp.finalize()
+    except Exception as e:
+        err = f"[Script Error] {type(e).__name__}: {e}"
+        return None, (buf.getvalue() + "\n" + err)
+    return (
+        zip_path if (zip_path and os.path.exists(zip_path)) else None
+    ), buf.getvalue()
+
+
+def run_user_script_stream(script_code: str, ids_snapshot):
+    """生成器：实时输出日志，并在结束时返回下载地址与完成状态。"""
+    # 日志队列
+    log_q = queue.Queue()
+
+    def _emit(kind, payload=None):
+        log_q.put((kind, payload))
+
+    def debug(*args, **kwargs):
+        text = " ".join(str(a) for a in args)
+        if text:
+            _emit("log", text)
+
+    # 准备脚本命名空间（与非流式版本一致，但覆盖 print/debug）
+    api = ScriptAPI(ids_snapshot)
+    ns = {
+        "__builtins__": _safe_builtins(),
+        "api": api,
+        "json": json,
+        "re": re,
+        "math": math,
+        "datetime": datetime,
+        "Path": Path,
+        "io": io,
+        "ExportBuilder": ExportBuilder,
+        # 专用日志函数
+        "debug": debug,
+        "print": debug,
+    }
+
+    result_holder = {"zip_path": None, "error": None}
+
+    def _worker():
+        try:
+            code = script_code or ""
+            exec(code, ns, ns)
+            res = None
+            main_fn = ns.get("main")
+            if callable(main_fn):
+                res = main_fn(api)
+            else:
+                res = ns.get("RESULT") or ns.get("OUTPUT_PATH")
+            zip_path = None
+            if isinstance(res, ExportBuilder):
+                zip_path = res.finalize()
+            elif isinstance(res, str) and res:
+                if os.path.isdir(res):
+                    eb = ExportBuilder("script_dir_export")
+                    for rt, _, files in os.walk(res):
+                        for f in files:
+                            src = os.path.join(rt, f)
+                            rel = os.path.relpath(src, res)
+                            eb.add_file(src, rel)
+                    zip_path = eb.finalize()
+                elif os.path.exists(res):
+                    zip_path = res
+            if not zip_path:
+                exp = ns.get("export")
+                if isinstance(exp, ExportBuilder):
+                    zip_path = exp.finalize()
+            result_holder["zip_path"] = (
+                zip_path if (zip_path and os.path.exists(zip_path)) else None
+            )
+        except Exception as e:
+            result_holder["error"] = f"[Script Error] {type(e).__name__}: {e}"
+        finally:
+            _emit("done", None)
+
+    # 启动脚本线程
+    t = threading.Thread(target=_worker, daemon=True)
+    t.start()
+
+    # 初始状态显示
+    spinner_html = (
+        "<div style='display:flex;align-items:center;gap:8px;'>"
+        "<svg width='18' height='18' viewBox='0 0 50 50' style='animation:spin 1s linear infinite'>"
+        "<circle cx='25' cy='25' r='20' stroke='#FF576D' stroke-width='4' fill='none' stroke-linecap='round' "
+        "stroke-dasharray='31.4 31.4'>"  # dash pattern for arc
+        "</circle></svg>"
+        "<style>@keyframes spin{0%{transform:rotate(0deg)}100%{transform:rotate(360deg)}}</style>"
+        "<span>脚本运行中…</span></div>"
+    )
+    log_buf_lines = []
+    # 初始仅显示运行中动画，日志区域留空
+    yield None, spinner_html, ""
+
+    # 实时拉取日志并渲染
+    while True:
+        try:
+            kind, payload = log_q.get(timeout=0.2)
+        except queue.Empty:
+            if not t.is_alive():
+                # 线程已结束但没有新的事件，跳到收尾
+                break
+            else:
+                continue
+
+        if kind == "log":
+            # 追加日志并推送更新
+            if isinstance(payload, str):
+                for line in payload.splitlines() or [payload]:
+                    if line.strip() == "":
+                        continue
+                    log_buf_lines.append(line)
+            yield None, spinner_html, "```\n" + "\n".join(
+                log_buf_lines[-200:]
+            ) + "\n```"  # 限制最后200行
+        elif kind == "done":
+            break
+
+    # 收尾：根据结果/错误输出最终状态
+    if result_holder.get("error"):
+        log_buf_lines.append(result_holder["error"])
+        status_html = (
+            "<div style='display:flex;align-items:center;gap:8px;color:#fca5a5'>"
+            "<span>❌ 脚本执行失败</span></div>"
+        )
+        yield None, status_html, "```\n" + "\n".join(log_buf_lines[-500:]) + "\n```"
+    else:
+        status_html = (
+            "<div style='display:flex;align-items:center;gap:8px;color:#86efac'>"
+            "<span>✅ 脚本执行完成</span></div>"
+        )
+        if result_holder.get("zip_path"):
+            yield result_holder["zip_path"], status_html, "```\n" + "\n".join(
+                log_buf_lines[-500:]
+            ) + "\n```"
+        else:
+            log_buf_lines.append(
+                "(无可下载文件返回，若需导出请返回 ExportBuilder 或目录/文件路径)"
+            )
+            yield None, status_html, "```\n" + "\n".join(log_buf_lines[-500:]) + "\n```"
+    """
+    执行用户脚本，返回 (zip_path or None, log_text)
+    """
+    api = ScriptAPI(ids_snapshot)
+    ns = {
+        "__builtins__": _safe_builtins(),
+        "api": api,
+        # 常用库（只读注入）
+        "json": json,
+        "re": re,
+        "math": math,
+        "datetime": datetime,
+        "Path": Path,
+        "io": io,
+        # 导出构建器类型（如需构造）
+        "ExportBuilder": ExportBuilder,
+    }
+    import contextlib
+    from io import StringIO
+
+    buf = StringIO()
+    zip_path = None
+    try:
+        code = script_code or ""
+        with contextlib.redirect_stdout(buf):
+            exec(code, ns, ns)
+            result = None
+            main_fn = ns.get("main")
+            if callable(main_fn):
+                result = main_fn(api)
+            else:
+                result = ns.get("RESULT") or ns.get("OUTPUT_PATH")
+            # 结果归档处理
+            if isinstance(result, ExportBuilder):
+                zip_path = result.finalize()
+            elif isinstance(result, str) and result:
+                if os.path.isdir(result):
+                    eb = ExportBuilder("script_dir_export")
+                    for rt, _, files in os.walk(result):
+                        for f in files:
+                            src = os.path.join(rt, f)
+                            rel = os.path.relpath(src, result)
+                            eb.add_file(src, rel)
+                    zip_path = eb.finalize()
+                elif os.path.exists(result):
+                    zip_path = result
+            if not zip_path:
+                exp = ns.get("export")
+                if isinstance(exp, ExportBuilder):
+                    zip_path = exp.finalize()
+    except Exception as e:
+        err = f"[Script Error] {type(e).__name__}: {e}"
+        return None, (buf.getvalue() + "\n" + err)
+    return (
+        zip_path if (zip_path and os.path.exists(zip_path)) else None
+    ), buf.getvalue()
+
+
+def export_selected_rids(ids, selected_labels):
+    """
+    Build a combined zip for multiple selected results based on their current images (no reupload).
+    Only includes items with status == 'done'.
+    """
+    if not ids or not selected_labels:
+        return None
+    # Map labels "Result N" -> indices
+    sel_indices = []
+    for label in selected_labels:
+        try:
+            idx = int(str(label).split()[-1]) - 1
+            if 0 <= idx < len(ids):
+                sel_indices.append(idx)
+        except Exception:
+            continue
+    if not sel_indices:
+        return None
+
+    out_dir, session_id = create_temp_session_dir()
+    zip_path = os.path.join(out_dir, f"export_selected_{session_id}.zip")
+    with zipfile.ZipFile(zip_path, "w", zipfile.ZIP_DEFLATED) as zf:
+        for i in sel_indices:
+            rid = ids[i]
+            st = RESULTS_CACHE.get(rid) or {}
+            if st.get("status") != "done":
+                continue
+            temp_dir = st.get("temp_dir")
+            if not temp_dir or not os.path.isdir(temp_dir):
+                # fallback: ensure individual export then include that zip
+                single_zip = ensure_export_ready(rid)
+                if single_zip and os.path.exists(single_zip):
+                    zf.write(single_zip, os.path.join(f"result_{i+1}_{rid}.zip"))
+                continue
+            base_dir = f"result_{i+1}_{rid}"
+            for rt, _, files in os.walk(temp_dir):
+                for f in files:
+                    src = os.path.join(rt, f)
+                    rel = os.path.relpath(src, temp_dir)
+                    zf.write(src, os.path.join(base_dir, rel))
+    return zip_path if os.path.exists(zip_path) else None
+
+
+# --------- Edited sources helpers ----------
+def _get_base_name_from_result(st: dict):
+    """Infer base filename like 'demo_xxx' from result paths or session id."""
+    rp = st.get("result_paths") or {}
+    for key in ("md_content_path", "md_content_nohf_path", "layout_info_path"):
+        p = rp.get(key)
+        if p and isinstance(p, str):
+            base = os.path.splitext(os.path.basename(p))[0]
+            if key == "md_content_nohf_path" and base.endswith("_nohf"):
+                base = base[: -len("_nohf")]
+            return base
+    sid = st.get("session_id")
+    if sid:
+        return f"demo_{sid}"
+    return f"demo_{uuid.uuid4().hex[:8]}"
+
+
+def _edited_dir_for(st: dict):
+    temp_dir = st.get("temp_dir")
+    if not temp_dir:
+        temp_dir, _ = create_temp_session_dir()
+        st["temp_dir"] = temp_dir
+    d = os.path.join(temp_dir, "edited")
+    os.makedirs(d, exist_ok=True)
+    return d
+
+
+def _edited_filepath(st: dict, which: str):
+    """
+    which in {'md','nohf','json'}
+    """
+    base = _get_base_name_from_result(st)
+    if which == "md":
+        name = f"{base}.md"
+    elif which == "nohf":
+        name = f"{base}_nohf.md"
+    elif which == "json":
+        name = f"{base}.json"
+    else:
+        raise ValueError(f"unknown edited type: {which}")
+    return os.path.join(_edited_dir_for(st), name)
+
+
+def _save_edited_to_disk(st: dict, which: str, content: str):
+    path = _edited_filepath(st, which)
+    with open(path, "w", encoding="utf-8") as f:
+        f.write(content if content is not None else "")
+    return path
+
+
+def _delete_edited_from_disk(st: dict, which: str):
+    try:
+        path = _edited_filepath(st, which)
+        if os.path.exists(path):
+            os.remove(path)
+    except Exception:
+        pass
+
+
+def _invalidate_export_zip(rid: str):
+    st = RESULTS_CACHE.get(rid) or {}
+    old = st.get("export_path")
+    if old and isinstance(old, str) and os.path.exists(old):
+        try:
+            os.remove(old)
+        except Exception:
+            pass
+    if "export_path" in st:
+        st["export_path"] = None
+    RESULTS_CACHE[rid] = st
+
+
+# ---------------- UI state helpers (per-card) ----------------
+def _default_ui_state():
+    # 增加 source: '源码' 或 '编辑源码'
+    return {"preview": True, "nohf": False, "tab": "md", "source": "源码"}
+
+
+def _ensure_ui_state(rid):
+    st = RESULTS_CACHE.get(rid) or {}
+    ui = st.get("ui")
+    if not isinstance(ui, dict):
+        ui = _default_ui_state()
+        st["ui"] = ui
+        RESULTS_CACHE[rid] = st
+    else:
+        # 兼容旧状态缺少新字段
+        if "source" not in ui:
+            ui["source"] = "源码"
+        if "tab" not in ui:
+            ui["tab"] = "md"
+        if "preview" not in ui:
+            ui["preview"] = True
+        if "nohf" not in ui:
+            ui["nohf"] = False
+        RESULTS_CACHE[rid] = st
+    return ui
+
+
+# ---------------- Background worker ----------------
+def background_processor():
+    while True:
+        try:
+            task = TASK_QUEUE.get(timeout=1)
+        except queue.Empty:
+            continue
+        if task is None:
+            # Important: mark done for sentinel to keep queue counters balanced
+            try:
+                TASK_QUEUE.task_done()
+            finally:
+                pass
+            break
+        rid, filepath, prompt_mode, server_ip, server_port, min_p, max_p, fitz_flag = (
+            task
+        )
+        image = None
+        try:
+            # Build parser instance for this task
+            local_parser = DotsOCRParser(
+                ip=server_ip,
+                port=int(server_port),
+                dpi=200,
+                min_pixels=min_p,
+                max_pixels=max_p,
+            )
+
+            # Read image
+            try:
+                fp_lower = str(filepath).lower() if isinstance(filepath, str) else ""
+                if fitz_flag or fp_lower.endswith(".pdf"):
+                    try:
+                        import fitz as _fitz
+
+                        doc = _fitz.open(filepath)
+                        page = doc.load_page(0)
+                        pix = page.get_pixmap()
+                        mode = "RGBA" if pix.alpha else "RGB"
+                        image = Image.frombytes(
+                            mode, (pix.width, pix.height), pix.samples
+                        )
+                        doc.close()
+                    except Exception:
+                        image = read_image_v2(filepath)
+                else:
+                    image = read_image_v2(filepath)
+            except Exception as e:
+                raise RuntimeError(f"Failed to read input {filepath}: {e}")
+
+            # Parse
+            result = parse_image_with_high_level_api(
+                local_parser, image, prompt_mode, fitz_preprocess=fitz_flag
+            )
+            result["status"] = "done"
+
+            # Preserve source/input path but prefer prev.source_path if available
+            prev = RESULTS_CACHE.get(rid) or {}
+
+            # Preserve UI state across re-parses/results
+            prev_ui = prev.get("ui") if isinstance(prev, dict) else None
+            result["ui"] = prev_ui if isinstance(prev_ui, dict) else _default_ui_state()
+
+            if isinstance(prev, dict) and isinstance(prev.get("edits"), dict):
+                result["edits"] = dict(prev.get("edits"))
+
+            if isinstance(prev, dict) and prev.get("source_path"):
+                result["source_path"] = prev.get("source_path")
+            else:
+                if isinstance(filepath, str) and os.path.exists(filepath):
+                    result["source_path"] = filepath
+                else:
+                    result["source_path"] = result.get("input_temp_path")
+
+            if isinstance(prev, dict) and prev.get("input_path"):
+                result["input_path"] = prev.get("input_path")
+
+            # Commit result
+            RESULTS_CACHE[rid] = result
+
+            # Pre-build export zip for first-click download
+            try:
+                zip_path = ensure_export_ready(rid)
+                if zip_path:
+                    result = RESULTS_CACHE.get(rid, result)
+                    result["export_path"] = zip_path
+                    RESULTS_CACHE[rid] = result
+            except Exception:
+                pass
+
+        except Exception as e:
+            # Auto-retry for transient backend errors (e.g., server down temporarily)
+            if _is_transient_backend_error(e):
+                attempts = RETRY_COUNTS.get(rid, 0)
+                if attempts < MAX_AUTO_RETRIES:
+                    RETRY_COUNTS[rid] = attempts + 1
+                    delay = min(10.0, (RETRY_BACKOFF_BASE**attempts))
+                    # keep state pending, annotate attempts
+                    prev = RESULTS_CACHE.get(rid, {}) or {}
+                    pend_state = dict(prev)
+                    pend_state.update(
+                        {
+                            "status": "pending",
+                            "retry_attempts": attempts + 1,
+                        }
+                    )
+                    RESULTS_CACHE[rid] = pend_state
+
+                    # Re-enqueue after delay on a timer to avoid blocking worker
+                    def _requeue_later():
+                        TASK_QUEUE.put(
+                            (
+                                rid,
+                                filepath,
+                                prompt_mode,
+                                server_ip,
+                                int(server_port),
+                                min_p,
+                                max_p,
+                                fitz_flag,
+                            )
+                        )
+
+                    threading.Timer(delay, _requeue_later).start()
+                    # Do not mark error; move on
+                    continue
+
+            # Build a rich error state that preserves re-parse materials
+            prev = RESULTS_CACHE.get(rid, {}) or {}
+            err_state = dict(prev)  # preserve input_path etc.
+            err_state["status"] = "error"
+            err_state["md_content"] = classify_parse_failure(e, min_p, max_p)
+
+            # Save a temporary PNG for re-parse if we have an image in memory
+            if isinstance(image, Image.Image):
+                try:
+                    tmp_dir, _sid = create_temp_session_dir()
+                    tmp_path = os.path.join(tmp_dir, f"error_input_{rid}.png")
+                    image.save(tmp_path, "PNG")
+                    err_state["original_image"] = image
+                    err_state["input_temp_path"] = tmp_path
+                    err_state["temp_dir"] = tmp_dir
+                except Exception:
+                    err_state["original_image"] = image
+            if isinstance(filepath, str) and filepath:
+                err_state.setdefault("source_path", filepath)
+
+            # Preserve UI state if missing
+            if not isinstance(err_state.get("ui"), dict):
+                err_state["ui"] = _default_ui_state()
+
+            RESULTS_CACHE[rid] = err_state
+        finally:
+            # Mark the non-sentinel task as done
+            try:
+                # If previous branch already marked sentinel done, skip double mark
+                if task is not None:
+                    TASK_QUEUE.task_done()
+            except Exception:
+                pass
+
+
+def _stop_all_workers():
+    """Stop all worker threads gracefully by sending sentinels and joining."""
+    global WORKER_THREADS
+    with THREAD_LOCK:
+        n = len(WORKER_THREADS)
+        if n == 0:
+            return
+        # Send one sentinel per worker
+        for _ in range(n):
+            TASK_QUEUE.put(None)
+        # Join all workers
+        for t in WORKER_THREADS:
+            try:
+                t.join(timeout=5.0)
+            except Exception:
+                pass
+        WORKER_THREADS = []
+
+
+def _start_workers(count: int):
+    """Start exactly `count` worker threads if not already running."""
+    global WORKER_THREADS
+    with THREAD_LOCK:
+        running = len(WORKER_THREADS)
+        need = max(0, int(count) - running)
+        for _ in range(need):
+            t = threading.Thread(target=background_processor, daemon=True)
+            t.start()
+            WORKER_THREADS.append(t)
+
+
+def start_background_processor():
+    """Ensure at least one worker is running (used by legacy calls)."""
+    _start_workers(max(1, MAX_CONCURRENCY))
+
+
+def set_max_concurrency(n: int):
+    """Restart worker pool to match desired concurrency."""
+    global MAX_CONCURRENCY
+    n = int(n) if isinstance(n, (int, float)) else 1
+    if n <= 0:
+        n = 1
+    MAX_CONCURRENCY = n
+    # Restart workers to apply new concurrency
+    _stop_all_workers()
+    _start_workers(MAX_CONCURRENCY)
+
+
+# ---------------- Queueing / task helpers ----------------
+def _pixel_reasons(min_p, max_p):
+    reasons = []
+    if min_p < ABS_MIN_PIXELS:
+        reasons.append(f"Min Pixels 过小：{min_p}，必须 >= {ABS_MIN_PIXELS}。")
+    if max_p > ABS_MAX_PIXELS:
+        reasons.append(f"Max Pixels 过大：{max_p}，必须 <= {ABS_MAX_PIXELS}。")
+    if min_p >= max_p:
+        reasons.append(
+            f"像素参数不合法：Min Pixels({min_p}) >= Max Pixels({max_p})，必须满足 Min Pixels < Max Pixels。"
+        )
+    return reasons
+
+
+def add_tasks_to_queue(
+    file_list, prompt_mode, server_ip, server_port, min_p, max_p, fitz, cur_ids
+):
+    """Queue uploaded file paths (expects file_list of local file paths or tuples (parse_path, source_path))."""
+    if not file_list:
+        return cur_ids, "No images uploaded."
+
+    min_p, max_p = _validate_pixels(min_p, max_p)
+    start_background_processor()
+
+    ids = list(cur_ids or [])
+    skipped = 0
+    queued = 0
+
+    for fp in file_list:
+        # Normalize: support tuple (parse_path, source_path)
+        parse_fp = None
+        source_fp = None
+        if isinstance(fp, (list, tuple)) and len(fp) >= 1:
+            parse_fp = fp[0]
+            # If tuple contains original source as second element, use it
+            source_fp = fp[1] if len(fp) >= 2 else fp[0]
+        else:
+            parse_fp = fp
+            source_fp = fp
+
+        if isinstance(parse_fp, (list, tuple)):
+            parse_fp = parse_fp[0] if len(parse_fp) > 0 else None
+
+        rid = uuid.uuid4().hex[:8]
+        ids.append(rid)
+
+        # placeholder with input_path so re-parse works even before parse
+        RESULTS_CACHE[rid] = {
+            "status": "pending",
+            "input_path": parse_fp,
+            "source_path": source_fp,
+            "ui": _default_ui_state(),  # 初始化每项的独立 UI 状态
+        }
+
+        reason = _pixel_reasons(min_p, max_p)
+        if reason:
+            RESULTS_CACHE[rid] = {
+                "status": "error",
+                "md_content": "参数越界，未开始解析：\n"
+                + "\n".join(f"- {r}" for r in reason)
+                + f"\n(当前参数：min_pixels={min_p}, max_pixels={max_p})",
+                "input_path": parse_fp,
+                "source_path": source_fp,
+                "ui": _default_ui_state(),
+            }
+            skipped += 1
+            continue
+
+        TASK_QUEUE.put(
+            (
+                rid,
+                parse_fp,
+                prompt_mode,
+                server_ip,
+                int(server_port),
+                min_p,
+                max_p,
+                fitz,
+            )
+        )
+        queued += 1
+
+    info = f"Queued {queued} item(s)."
+    if skipped:
+        info += f" Skipped {skipped} due to invalid pixel limits."
+    return ids, info
+
+
+def enqueue_single_reparse(
+    rid, reupload_path, prompt_mode, server_ip, server_port, min_p, max_p, fitz
+):
+    """
+    Enqueue a reparse for single result id.
+    Path selection priority:
+      reupload_path -> result.source_path -> result.input_temp_path -> result.input_path -> result.original_image (dump to temp PNG)
+    """
+    min_p, max_p = _validate_pixels(min_p, max_p)
+    start_background_processor()
+    st = RESULTS_CACHE.get(rid, {}) or {}
+
+    # Pixel constraints: if invalid, set error state and return (do not enqueue)
+    reason = _pixel_reasons(min_p, max_p)
+    if reason:
+        new_state = st.copy()
+        new_state.update(
+            {
+                "status": "error",
+                "md_content": "参数越界，未开始解析：\n"
+                + "\n".join(f"- {r}" for r in reason)
+                + f"\n(当前参数：min_pixels={min_p}, max_pixels={max_p})",
+            }
+        )
+        # 保留 UI 状态
+        if "ui" not in new_state:
+            new_state["ui"] = _default_ui_state()
+        RESULTS_CACHE[rid] = new_state
+        return
+
+    if isinstance(reupload_path, (tuple, list)):
+        reupload_path = reupload_path[0] if len(reupload_path) > 0 else None
+
+    filepath = None
+    if reupload_path:
+        filepath = reupload_path
+    elif st.get("source_path"):
+        filepath = st.get("source_path")
+    elif st.get("input_temp_path"):
+        filepath = st.get("input_temp_path")
+    elif st.get("input_path"):
+        filepath = st.get("input_path")
+    else:
+        img = st.get("original_image")
+        if isinstance(img, Image.Image):
+            tmp_dir, _ = create_temp_session_dir()
+            tmp_path = os.path.join(tmp_dir, f"reparse_{rid}.png")
+            try:
+                img.save(tmp_path, "PNG")
+                filepath = tmp_path
+            except Exception:
+                filepath = None
+
+    if not filepath:
+        new_state = st.copy()
+        new_state.update(
+            {
+                "status": "error",
+                "md_content": "重解析失败：未找到可用的图片来源。请重新上传图片或检查缓存目录。",
+            }
+        )
+        if "ui" not in new_state:
+            new_state["ui"] = _default_ui_state()
+        RESULTS_CACHE[rid] = new_state
+        return
+
+    new_state = st.copy()
+    new_state.update(
+        {
+            "status": "pending",
+            "input_path": filepath,
+            "last_used_config": {
+                "ip": server_ip,
+                "port": int(server_port),
+                "min_pixels": min_p,
+                "max_pixels": max_p,
+                "prompt_mode": prompt_mode,
+            },
+        }
+    )
+    # 保留 UI 状态
+    if "ui" not in new_state:
+        new_state["ui"] = _default_ui_state()
+    RESULTS_CACHE[rid] = new_state
+    TASK_QUEUE.put(
+        (rid, filepath, prompt_mode, server_ip, int(server_port), min_p, max_p, fitz)
+    )
+
+
+def delete_one(ids, rid, tick):
+    new_ids = [x for x in (ids or []) if x != rid]
+    st = RESULTS_CACHE.get(rid)
+    temp_dir = st.get("temp_dir") if st else None
+    if rid in RESULTS_CACHE:
+        del RESULTS_CACHE[rid]
+    if rid in RETRY_COUNTS:
+        del RETRY_COUNTS[rid]
+    purge_queue(rid)
+    if temp_dir and os.path.exists(temp_dir):
+        threading.Thread(
+            target=lambda: shutil.rmtree(temp_dir, ignore_errors=True), daemon=True
+        ).start()
+    return new_ids, int(tick or 0) + 1
+
+
+# ---------------- Gradio UI ----------------
+def create_gradio_interface():
+    css = """
+    /* basic theme */
+    :root { --bg:#0b1220; --card:#111827; --muted:#9ca3af; --accent:#FF576D; --text:#e5e7eb; }
+    body, .gradio-container { background: var(--bg) !important; color: var(--text) !important; }
+    .result-card { background: var(--card); border:1px solid #1f2937; border-radius:8px; padding:10px; margin-bottom:12px; }
+    .muted { color: var(--muted); font-size:0.9em; }
+
+    /* skeleton shimmer */
+    .skeleton { position:relative; overflow:hidden; background:#0f172a; border-radius:6px; }
+    .skeleton::after {
+      content:""; position:absolute; inset:0; transform:translateX(-100%);
+      background:linear-gradient(90deg, rgba(255,255,255,0), rgba(255,255,255,0.06), rgba(255,255,255,0));
+      animation:shimmer 1.2s infinite;
+    }
+    @keyframes shimmer { 100% { transform:translateX(100%);} }
+
+    /* Hide unwanted footer/buttons (robust selectors) */
+    footer, .footer, #footer, footer[role="contentinfo"] { display:none !important; }
+    [aria-label="Use via API"], [aria-label*="API"], [title*="API"], a[href*="/api"], a[href*="api_docs"], a[href*="gradio.app"] { display:none !important; }
+    button[aria-label="Settings"], button[aria-label*="设置"], [aria-label="Built with Gradio"] { display:none !important; }
+
+        /* Script log area: single inner scrollbar on <pre>, outer container hidden overflow */
+        .script-log { max-height: 260px; overflow: hidden; border:1px solid #1f2937; border-radius:6px; padding:0; }
+        .script-log pre {
+            max-height: 260px;
+            overflow: auto;
+            margin: 0;
+            padding: 6px;
+            background: transparent;
+            scrollbar-width: thin; /* Firefox */
+            scrollbar-color: rgba(255,255,255,0.2) transparent;
+        }
+        .script-log pre::-webkit-scrollbar { width: 6px; height: 6px; }
+        .script-log pre::-webkit-scrollbar-track { background: transparent; }
+        .script-log pre::-webkit-scrollbar-thumb { background: rgba(255,255,255,0.12); border-radius: 4px; }
+        .script-log pre:hover::-webkit-scrollbar-thumb { background: rgba(255,255,255,0.25); }
+    """
+
+    with gr.Blocks(css=css, title="dots.ocr") as demo:
+        # Left column controls
+        with gr.Row():
+            with gr.Column(scale=1):
+                file_input = gr.File(
+                    label="Upload Multiple Images",
+                    type="filepath",
+                    file_count="multiple",
+                    file_types=[".jpg", ".jpeg", ".png", ".pdf"],
+                )
+                # Filter out the unwanted 'prompt_grounding_ocr' mode
+                allowed_modes = [
+                    m
+                    for m in dict_promptmode_to_prompt.keys()
+                    if m != "prompt_grounding_ocr"
+                ]
+                if not allowed_modes:
+                    allowed_modes = list(dict_promptmode_to_prompt.keys())
+                prompt_mode = gr.Dropdown(
+                    label="Prompt Mode",
+                    choices=allowed_modes,
+                    value=allowed_modes[0],
+                )
+                prompt_display = gr.Textbox(
+                    label="Prompt Preview",
+                    value=dict_promptmode_to_prompt[allowed_modes[0]],
+                    interactive=False,
+                    lines=4,
+                )
+
+                with gr.Row():
+                    parse_btn = gr.Button("🔍 Parse", variant="primary")
+                    clear_btn = gr.Button("🗑️ Clear")
+
+                with gr.Accordion("Advanced Config", open=False):
+                    fitz_preprocess = gr.Checkbox(label="fitz_preprocess", value=True)
+                    server_ip = gr.Textbox(
+                        label="Server IP", value=DEFAULT_CONFIG["ip"]
+                    )
+                    server_port = gr.Number(
+                        label="Port", value=DEFAULT_CONFIG["port_vllm"], precision=0
+                    )
+                    min_pixels = gr.Number(
+                        label="Min Pixels", value=DEFAULT_CONFIG["min_pixels"]
+                    )
+                    max_pixels = gr.Number(
+                        label="Max Pixels", value=DEFAULT_CONFIG["max_pixels"]
+                    )
+                    concurrency = gr.Number(
+                        label="Max Concurrency",
+                        value=MAX_CONCURRENCY,  # 与实际生效的后台并发保持一致（支持刷新后保持）
+                        precision=0,
+                        interactive=True,
+                    )
+                    confirm_delete = gr.Checkbox(
+                        label="删除前确认（推荐）", value=True, interactive=True
+                    )
+
+            # Right column: results & actions
+            with gr.Column(scale=5):
+                info_display = gr.Markdown("Waiting...", elem_id="info_box")
+                ids_state = gr.State(value=[])
+                store_tick = gr.State(value=0)
+                render_bump = gr.State(value=0)  # 仅用于在状态变化时触发结果重渲染
+                confirm_delete_state = gr.State(value=True)
+                confirm_delete.change(
+                    lambda v: v, inputs=[confirm_delete], outputs=[confirm_delete_state]
+                )
+
+                progress_timer = gr.Timer(1.0)
+
+                # Actions 面板（多选）
+                with gr.Accordion("Actions", open=False):
+                    selected_group = gr.CheckboxGroup(
+                        label="Select Items", choices=[], value=[], interactive=True
+                    )
+                    with gr.Row():
+                        select_all_btn = gr.Button("全选")
+                        clear_sel_btn = gr.Button("清空选择")
+                    with gr.Row():
+                        bulk_reparse_btn = gr.Button("🔁 重解析所选")
+                        delete_selected_btn = gr.Button("🗑️ 删除所选", variant="stop")
+                        export_selected_btn = gr.DownloadButton("📦 导出所选")
+                    # 高级脚本导出
+                    with gr.Accordion("高级脚本", open=False):
+                        gr.Markdown(
+                            "在下方编辑并运行自定义 Python 脚本以自由处理当前解析结果并导出为任意目录/文件结构。"
+                            "<br/>脚本将在受限环境中执行，可通过 api 对象访问只读数据与构建导出压缩包。",
+                            elem_classes=["muted"],
+                        )
+                        script_code = gr.Code(
+                            label="Python 脚本",
+                            language="python",
+                            value=DEFAULT_SCRIPT_TEMPLATE,
+                            lines=24,
+                            interactive=True,
+                        )
+                        with gr.Row():
+                            run_script_btn = gr.Button("▶ 运行脚本", variant="primary")
+                            script_download_btn = gr.DownloadButton("📦 下载脚本输出")
+                        script_status = gr.HTML("")
+                        script_log = gr.Markdown(
+                            "", elem_id="script_log", elem_classes=["script-log"]
+                        )
+
+                        # 流式执行脚本：实时打印日志与运行状态，并在完成后绑定下载按钮
+                        run_script_btn.click(
+                            run_user_script_stream,
+                            inputs=[script_code, ids_state],
+                            outputs=[script_download_btn, script_status, script_log],
+                            show_progress="hidden",
+                        )
+                    # 批量删除确认面板
+                    with gr.Row(visible=False) as bulk_delete_confirm_panel:
+                        gr.Markdown(
+                            "确认删除所选结果？该操作不可恢复。",
+                            elem_classes=["muted"],
+                        )
+                        bulk_confirm_delete_btn = gr.Button("确认删除", variant="stop")
+                        bulk_cancel_delete_btn = gr.Button("取消")
+
+                # Render results dynamically
+                @gr.render(inputs=[ids_state, render_bump])
+                def render_results(ids, _bump):
+                    if not ids:
+                        return gr.Markdown("No results yet.")
+                    with gr.Column():
+                        for idx, rid in enumerate(ids):
+                            data = RESULTS_CACHE.get(rid, {}) or {}
+                            status = data.get("status", "pending")
+
+                            # 确保每张卡都有独立 UI 状态（并写回缓存，保证后续使用）
+                            ui = _ensure_ui_state(rid)
+                            preview_on = bool(ui.get("preview", True))
+                            nohf_on = bool(ui.get("nohf", False))
+                            active_tab = ui.get("tab", "md")
+                            if active_tab not in ("md", "json"):
+                                active_tab = "md"
+                            source_sel = ui.get("source", "源码")
+                            if source_sel not in ("源码", "编辑源码"):
+                                source_sel = "源码"
+
+                            with gr.Column(
+                                elem_classes=["result-card"], elem_id=f"card-{rid}"
+                            ):
+                                with gr.Row():
+                                    gr.Markdown(
+                                        f"### Result {idx+1} <span class='muted'>RID: {rid}</span>"
+                                    )
+
+                                if status == "error":
+                                    gr.Markdown(
+                                        f"⚠️ 解析失败：\n\n{data.get('md_content','Unknown error')}",
+                                        elem_classes=["muted"],
+                                    )
+
+                                if status == "done":
+                                    orig_img = data.get("original_image")
+                                    layout_img = data.get("layout_image")
+                                    with gr.Row():
+                                        gr.Image(
+                                            value=orig_img, label="Original", height=300
+                                        )
+                                        gr.Image(
+                                            value=layout_img, label="Layout", height=300
+                                        )
+                                elif status == "pending":
+                                    with gr.Row():
+                                        gr.HTML(
+                                            "<div class='skeleton' style='width:100%;height:300px;'></div>"
+                                        )
+                                        gr.HTML(
+                                            "<div class='skeleton' style='width:100%;height:300px;'></div>"
+                                        )
+
+                                # badges
+                                with gr.Row():
+                                    badge_md = gr.HTML(
+                                        f"<span class='muted'>MD: {'Preview' if preview_on else 'Source'}</span>"
+                                    )
+                                    badge_nohf = gr.HTML(
+                                        f"<span class='muted'>NOHF: {'On' if nohf_on else 'Off'}</span>"
+                                    )
+
+                                # controls
+                                with gr.Row():
+                                    rid_box = gr.Textbox(value=rid, visible=False)
+                                    preview_cb = gr.Checkbox(
+                                        label="Preview Markdown",
+                                        value=preview_on,
+                                    )
+                                    nohf_cb = gr.Checkbox(label="NOHF", value=nohf_on)
+
+                                # 视图切换
+                                selected_label = (
+                                    "Markdown" if active_tab == "md" else "JSON"
+                                )
+                                with gr.Row():
+                                    view_radio = gr.Radio(
+                                        label="视图",
+                                        choices=["Markdown", "JSON"],
+                                        value=selected_label,
+                                    )
+
+                                # 内容来源（仅完成状态可用）
+                                with gr.Row():
+                                    source_radio = gr.Radio(
+                                        label="内容来源",
+                                        choices=["源码", "编辑源码"],
+                                        value=source_sel,
+                                        interactive=True,
+                                        visible=(status == "done"),
+                                    )
+
+                                # 内容获取助手
+                                def _get_texts(rid_value, nohf_flag):
+                                    st = RESULTS_CACHE.get(rid_value, {}) or {}
+                                    md_orig = st.get("md_content") or ""
+                                    md_nohf_orig = st.get("md_content_nohf") or ""
+                                    md_current_orig = (
+                                        md_nohf_orig if nohf_flag else md_orig
+                                    )
+                                    edits = st.get("edits") or {}
+                                    md_edit = (
+                                        edits.get("nohf")
+                                        if nohf_flag
+                                        else edits.get("md")
+                                    )
+                                    if md_edit is None:
+                                        md_edit = md_current_orig
+                                    json_orig = st.get("json_code") or ""
+                                    json_edit = edits.get("json")
+                                    if json_edit is None:
+                                        json_edit = json_orig
+                                    return (
+                                        md_current_orig,
+                                        md_edit,
+                                        json_orig,
+                                        json_edit,
+                                    )
+
+                                (
+                                    md_orig_val,
+                                    md_edit_val,
+                                    json_orig_val,
+                                    json_edit_val,
+                                ) = _get_texts(rid, nohf_on)
+                                is_md_init = selected_label == "Markdown"
+                                use_edit_init = source_sel == "编辑源码"
+
+                                # 单一预览组件（Markdown 用）
+                                md_preview = gr.Markdown(
+                                    value=(
+                                        md_edit_val if use_edit_init else md_orig_val
+                                    ),
+                                    visible=(
+                                        status == "done" and is_md_init and preview_on
+                                    ),
+                                )
+                                # 原始源码（只读）
+                                md_code_orig = gr.Code(
+                                    language="markdown",
+                                    value=md_orig_val,
+                                    interactive=False,
+                                    visible=(
+                                        status == "done"
+                                        and is_md_init
+                                        and (not preview_on)
+                                        and (not use_edit_init)
+                                    ),
+                                )
+                                # 编辑源码（可编辑、自动保存）
+                                md_code_edit = gr.Code(
+                                    language="markdown",
+                                    value=md_edit_val,
+                                    interactive=True,
+                                    visible=(
+                                        status == "done"
+                                        and is_md_init
+                                        and (not preview_on)
+                                        and use_edit_init
+                                    ),
+                                )
+
+                                # JSON（原始与编辑）
+                                json_code_orig = gr.Code(
+                                    language="json",
+                                    value=json_orig_val,
+                                    interactive=False,
+                                    visible=(
+                                        status == "done"
+                                        and (not is_md_init)
+                                        and (not use_edit_init)
+                                    ),
+                                )
+                                json_code_edit = gr.Code(
+                                    language="json",
+                                    value=json_edit_val,
+                                    interactive=True,
+                                    visible=(
+                                        status == "done"
+                                        and (not is_md_init)
+                                        and use_edit_init
+                                    ),
+                                )
+
+                                # 仅编辑模式显示
+                                restore_btn = gr.Button(
+                                    "还原当前内容",
+                                    visible=(status == "done" and use_edit_init),
+                                )
+
+                                # 统一可见性/内容更新
+                                def _apply_all(
+                                    preview, use_nohf, view_label, src_label, rid_value
+                                ):
+                                    preview = bool(preview)
+                                    use_nohf = bool(use_nohf)
+                                    is_md = str(view_label) == "Markdown"
+                                    use_edit = str(src_label) == "编辑源码"
+
+                                    # 写回 UI 状态
+                                    st = RESULTS_CACHE.get(rid_value, {}) or {}
+                                    ui0 = dict(st.get("ui") or _default_ui_state())
+                                    ui0["preview"] = preview
+                                    ui0["nohf"] = use_nohf
+                                    ui0["tab"] = "md" if is_md else "json"
+                                    ui0["source"] = "编辑源码" if use_edit else "源码"
+                                    st["ui"] = ui0
+                                    RESULTS_CACHE[rid_value] = st
+
+                                    md_o, md_e, j_o, j_e = _get_texts(
+                                        rid_value, use_nohf
+                                    )
+                                    return (
+                                        gr.update(
+                                            value=f"<span class='muted'>MD: {'Preview' if preview else 'Source'}</span>"
+                                        ),
+                                        gr.update(
+                                            value=f"<span class='muted'>NOHF: {'On' if use_nohf else 'Off'}</span>"
+                                        ),
+                                        gr.update(
+                                            value=(md_e if use_edit else md_o),
+                                            visible=(is_md and preview),
+                                        ),
+                                        gr.update(
+                                            value=md_o,
+                                            visible=(
+                                                is_md
+                                                and (not preview)
+                                                and (not use_edit)
+                                            ),
+                                        ),
+                                        gr.update(
+                                            value=md_e,
+                                            visible=(
+                                                is_md and (not preview) and use_edit
+                                            ),
+                                        ),
+                                        gr.update(
+                                            value=j_o,
+                                            visible=(not is_md and (not use_edit)),
+                                        ),
+                                        gr.update(
+                                            value=j_e, visible=(not is_md and use_edit)
+                                        ),
+                                        gr.update(visible=use_edit),
+                                    )
+
+                                # 绑定控制项变化：预览、NOHF、视图、来源
+                                preview_cb.change(
+                                    _apply_all,
+                                    inputs=[
+                                        preview_cb,
+                                        nohf_cb,
+                                        view_radio,
+                                        source_radio,
+                                        rid_box,
+                                    ],
+                                    outputs=[
+                                        badge_md,
+                                        badge_nohf,
+                                        md_preview,
+                                        md_code_orig,
+                                        md_code_edit,
+                                        json_code_orig,
+                                        json_code_edit,
+                                        restore_btn,
+                                    ],
+                                    show_progress="hidden",
+                                )
+                                nohf_cb.change(
+                                    _apply_all,
+                                    inputs=[
+                                        preview_cb,
+                                        nohf_cb,
+                                        view_radio,
+                                        source_radio,
+                                        rid_box,
+                                    ],
+                                    outputs=[
+                                        badge_md,
+                                        badge_nohf,
+                                        md_preview,
+                                        md_code_orig,
+                                        md_code_edit,
+                                        json_code_orig,
+                                        json_code_edit,
+                                        restore_btn,
+                                    ],
+                                    show_progress="hidden",
+                                )
+
+                                def _on_view_change(
+                                    view_label,
+                                    rid_value,
+                                    preview_flag,
+                                    nohf_flag,
+                                    src_label,
+                                ):
+                                    st = RESULTS_CACHE.get(rid_value, {}) or {}
+                                    ui0 = dict(st.get("ui") or _default_ui_state())
+                                    ui0["tab"] = (
+                                        "md"
+                                        if str(view_label) == "Markdown"
+                                        else "json"
+                                    )
+                                    st["ui"] = ui0
+                                    RESULTS_CACHE[rid_value] = st
+                                    return _apply_all(
+                                        preview_flag,
+                                        nohf_flag,
+                                        view_label,
+                                        src_label,
+                                        rid_value,
+                                    )
+
+                                view_radio.change(
+                                    _on_view_change,
+                                    inputs=[
+                                        view_radio,
+                                        rid_box,
+                                        preview_cb,
+                                        nohf_cb,
+                                        source_radio,
+                                    ],
+                                    outputs=[
+                                        badge_md,
+                                        badge_nohf,
+                                        md_preview,
+                                        md_code_orig,
+                                        md_code_edit,
+                                        json_code_orig,
+                                        json_code_edit,
+                                        restore_btn,
+                                    ],
+                                    show_progress="hidden",
+                                )
+
+                                def _on_source_change(
+                                    src_label,
+                                    rid_value,
+                                    preview_flag,
+                                    nohf_flag,
+                                    view_label,
+                                ):
+                                    st = RESULTS_CACHE.get(rid_value, {}) or {}
+                                    ui0 = dict(st.get("ui") or _default_ui_state())
+                                    ui0["source"] = (
+                                        "编辑源码"
+                                        if str(src_label) == "编辑源码"
+                                        else "源码"
+                                    )
+                                    st["ui"] = ui0
+                                    RESULTS_CACHE[rid_value] = st
+                                    return _apply_all(
+                                        preview_flag,
+                                        nohf_flag,
+                                        view_label,
+                                        src_label,
+                                        rid_value,
+                                    )
+
+                                source_radio.change(
+                                    _on_source_change,
+                                    inputs=[
+                                        source_radio,
+                                        rid_box,
+                                        preview_cb,
+                                        nohf_cb,
+                                        view_radio,
+                                    ],
+                                    outputs=[
+                                        badge_md,
+                                        badge_nohf,
+                                        md_preview,
+                                        md_code_orig,
+                                        md_code_edit,
+                                        json_code_orig,
+                                        json_code_edit,
+                                        restore_btn,
+                                    ],
+                                    show_progress="hidden",
+                                )
+
+                                # Action buttons per-card
+                                with gr.Row():
+                                    reparse_btn = gr.Button(
+                                        "🔁 重新解析",
+                                        interactive=(status in ("done", "error")),
+                                    )
+                                    export_btn = gr.DownloadButton(
+                                        "📦 导出",
+                                        interactive=(status == "done"),
+                                        value=(
+                                            data.get("export_path")
+                                            if status == "done"
+                                            else None
+                                        ),
+                                    )
+                                    delete_btn = gr.Button("🗑️ 删除", variant="stop")
+
+                                # 自动保存（编辑器变更即写盘 + 刷新导出 + 可能的 Markdown 预览）
+                                def _save_md_edit(
+                                    val,
+                                    rid_value,
+                                    nohf_flag,
+                                    preview_flag,
+                                    view_label,
+                                    src_label,
+                                    ids,
+                                    selected_labels,
+                                ):
+                                    st = RESULTS_CACHE.get(rid_value, {}) or {}
+                                    if st.get("status") != "done":
+                                        # 同步“导出所选”以防其它项在编辑（极少见）
+                                        path_sel = export_selected_rids(
+                                            ids, selected_labels
+                                        )
+                                        return (
+                                            gr.update(),
+                                            gr.update(),
+                                            gr.update(value=path_sel),
+                                        )
+                                    which = "nohf" if bool(nohf_flag) else "md"
+                                    edits = dict(st.get("edits") or {})
+                                    edits[which] = val or ""
+                                    st["edits"] = edits
+                                    RESULTS_CACHE[rid_value] = st
+                                    try:
+                                        _save_edited_to_disk(st, which, val or "")
+                                    except Exception:
+                                        pass
+                                    _invalidate_export_zip(rid_value)
+                                    new_zip = ensure_export_ready(rid_value)
+
+                                    # 刷新“导出所选”
+                                    path_sel = export_selected_rids(
+                                        ids, selected_labels
+                                    )
+
+                                    # 若当前正处于 Markdown/预览/编辑模式，则更新预览内容
+                                    is_md = str(view_label) == "Markdown"
+                                    use_edit = str(src_label) == "编辑源码"
+                                    if is_md and use_edit and bool(preview_flag):
+                                        return (
+                                            gr.update(value=val or ""),
+                                            gr.update(value=new_zip),
+                                            gr.update(value=path_sel),
+                                        )
+                                    return (
+                                        gr.update(),
+                                        gr.update(value=new_zip),
+                                        gr.update(value=path_sel),
+                                    )
+
+                                md_code_edit.change(
+                                    _save_md_edit,
+                                    inputs=[
+                                        md_code_edit,
+                                        rid_box,
+                                        nohf_cb,
+                                        preview_cb,
+                                        view_radio,
+                                        source_radio,
+                                        ids_state,
+                                        selected_group,
+                                    ],
+                                    outputs=[
+                                        md_preview,
+                                        export_btn,
+                                        export_selected_btn,
+                                    ],
+                                    show_progress="hidden",
+                                )
+
+                                def _save_json_edit(
+                                    val, rid_value, ids, selected_labels
+                                ):
+                                    st = RESULTS_CACHE.get(rid_value, {}) or {}
+                                    if st.get("status") != "done":
+                                        path_sel = export_selected_rids(
+                                            ids, selected_labels
+                                        )
+                                        return gr.update(), gr.update(value=path_sel)
+                                    edits = dict(st.get("edits") or {})
+                                    edits["json"] = val or ""
+                                    st["edits"] = edits
+                                    RESULTS_CACHE[rid_value] = st
+                                    try:
+                                        _save_edited_to_disk(st, "json", val or "")
+                                    except Exception:
+                                        pass
+                                    _invalidate_export_zip(rid_value)
+                                    new_zip = ensure_export_ready(rid_value)
+                                    path_sel = export_selected_rids(
+                                        ids, selected_labels
+                                    )
+                                    return gr.update(value=new_zip), gr.update(
+                                        value=path_sel
+                                    )
+
+                                json_code_edit.change(
+                                    _save_json_edit,
+                                    inputs=[
+                                        json_code_edit,
+                                        rid_box,
+                                        ids_state,
+                                        selected_group,
+                                    ],
+                                    outputs=[export_btn, export_selected_btn],
+                                    show_progress="hidden",
+                                )
+
+                                # 还原当前内容
+                                def _restore_current(
+                                    src_label,
+                                    rid_value,
+                                    nohf_flag,
+                                    preview_flag,
+                                    view_label,
+                                    ids,
+                                    selected_labels,
+                                ):
+                                    st = RESULTS_CACHE.get(rid_value, {}) or {}
+                                    which = (
+                                        "json"
+                                        if str(view_label) == "JSON"
+                                        else ("nohf" if bool(nohf_flag) else "md")
+                                    )
+                                    # 删除编辑版
+                                    edits = dict(st.get("edits") or {})
+                                    if which in edits:
+                                        edits.pop(which, None)
+                                        st["edits"] = edits
+                                    RESULTS_CACHE[rid_value] = st
+                                    try:
+                                        _delete_edited_from_disk(st, which)
+                                    except Exception:
+                                        pass
+                                    # 重新取原始内容
+                                    md_o, md_e, j_o, j_e = _get_texts(
+                                        rid_value, bool(nohf_flag)
+                                    )
+                                    # 刷新导出
+                                    _invalidate_export_zip(rid_value)
+                                    new_zip = ensure_export_ready(rid_value)
+                                    path_sel = export_selected_rids(
+                                        ids, selected_labels
+                                    )
+                                    # 更新编辑器与预览
+                                    up_md_editor = (
+                                        gr.update(value=md_o)
+                                        if which in ("md", "nohf")
+                                        else gr.update()
+                                    )
+                                    up_json_editor = (
+                                        gr.update(value=j_o)
+                                        if which == "json"
+                                        else gr.update()
+                                    )
+                                    is_md = str(view_label) == "Markdown"
+                                    use_edit = str(src_label) == "编辑源码"
+                                    up_preview = (
+                                        gr.update(value=(md_e if use_edit else md_o))
+                                        if is_md and bool(preview_flag)
+                                        else gr.update()
+                                    )
+                                    return (
+                                        up_md_editor,
+                                        up_json_editor,
+                                        up_preview,
+                                        gr.update(value=new_zip),
+                                        gr.update(value=path_sel),
+                                    )
+
+                                restore_btn.click(
+                                    _restore_current,
+                                    inputs=[
+                                        source_radio,
+                                        rid_box,
+                                        nohf_cb,
+                                        preview_cb,
+                                        view_radio,
+                                        ids_state,
+                                        selected_group,
+                                    ],
+                                    outputs=[
+                                        md_code_edit,
+                                        json_code_edit,
+                                        md_preview,
+                                        export_btn,
+                                        export_selected_btn,
+                                    ],
+                                    show_progress="hidden",
+                                )
+
+                                # Reparse panel (collapsed)
+                                with gr.Column(visible=False) as reparse_panel:
+                                    gr.Markdown("**重解析**")
+                                    with gr.Row():
+                                        reparse_current_btn = gr.Button(
+                                            "基于当前图片直接重解析", variant="primary"
+                                        )
+
+                                # Delete confirm panel (collapsed)
+                                with gr.Row(visible=False) as delete_confirm_panel:
+                                    gr.Markdown(
+                                        "确认删除该结果？该操作不可恢复。",
+                                        elem_classes=["muted"],
+                                    )
+                                    confirm_delete_btn = gr.Button(
+                                        "确认删除", variant="stop"
+                                    )
+                                    cancel_delete_btn = gr.Button("取消")
+
+                                # 绑定其他交互
+                                reparse_btn.click(
+                                    lambda: gr.update(visible=True),
+                                    outputs=[reparse_panel],
+                                    show_progress="hidden",
+                                )
+
+                                def _start_reparse_current(
+                                    rid_value,
+                                    p_mode,
+                                    ip_addr,
+                                    port_val,
+                                    minp,
+                                    maxp,
+                                    fitz_flag,
+                                    tick,
+                                    ids,
+                                    selected_labels,
+                                ):
+                                    try:
+                                        enqueue_single_reparse(
+                                            rid_value,
+                                            None,
+                                            p_mode,
+                                            ip_addr,
+                                            int(port_val),
+                                            int(minp),
+                                            int(maxp),
+                                            fitz_flag,
+                                        )
+                                        # 重建“导出所选”
+                                        path_sel = export_selected_rids(
+                                            ids, selected_labels
+                                        )
+                                        return (
+                                            int(tick or 0) + 1,
+                                            gr.update(visible=False),
+                                            gr.update(value=path_sel),
+                                        )
+                                    except Exception as e:
+                                        RESULTS_CACHE[rid_value] = {
+                                            "status": "error",
+                                            "md_content": f"Reparse error: {e}",
+                                            # 保留 UI 状态
+                                            "ui": _ensure_ui_state(rid_value),
+                                        }
+                                        path_sel = export_selected_rids(
+                                            ids, selected_labels
+                                        )
+                                        return (
+                                            int(tick or 0) + 1,
+                                            gr.update(visible=False),
+                                            gr.update(value=path_sel),
+                                        )
+
+                                reparse_current_btn.click(
+                                    _start_reparse_current,
+                                    inputs=[
+                                        rid_box,
+                                        prompt_mode,
+                                        server_ip,
+                                        server_port,
+                                        min_pixels,
+                                        max_pixels,
+                                        fitz_preprocess,
+                                        store_tick,
+                                        ids_state,
+                                        selected_group,
+                                    ],
+                                    outputs=[
+                                        store_tick,
+                                        reparse_panel,
+                                        export_selected_btn,
+                                    ],
+                                    show_progress="hidden",
+                                )
+
+                                def _on_delete_click(
+                                    rid_value, ids, need_confirm, tick
+                                ):
+                                    # 如果需要确认，仅展开确认面板，不修改选择框/导出按钮
+                                    if need_confirm:
+                                        return (
+                                            gr.update(visible=True),
+                                            ids,
+                                            tick,
+                                            gr.update(),  # selected_group 不变
+                                            gr.update(),  # export button 不变
+                                        )
+                                    # 直接删除：更新 ids/tick，并同步 Actions 的选择项与导出按钮
+                                    new_ids, new_tick = delete_one(ids, rid_value, tick)
+                                    choices = [
+                                        f"Result {i+1}"
+                                        for i in range(len(new_ids or []))
+                                    ]
+                                    return (
+                                        gr.update(visible=False),
+                                        new_ids,
+                                        new_tick,
+                                        gr.update(choices=choices, value=[]),
+                                        gr.update(value=None),  # 清空导出
+                                    )
+
+                                # 单卡删除输出同步 selected_group 与 export_selected_btn
+                                delete_btn.click(
+                                    _on_delete_click,
+                                    inputs=[
+                                        rid_box,
+                                        ids_state,
+                                        confirm_delete_state,
+                                        store_tick,
+                                    ],
+                                    outputs=[
+                                        delete_confirm_panel,
+                                        ids_state,
+                                        store_tick,
+                                        selected_group,
+                                        export_selected_btn,
+                                    ],
+                                    show_progress="hidden",
+                                )
+
+                                def _confirm_delete(rid_value, ids, tick):
+                                    new_ids, new_tick = delete_one(ids, rid_value, tick)
+                                    choices = [
+                                        f"Result {i+1}"
+                                        for i in range(len(new_ids or []))
+                                    ]
+                                    return (
+                                        new_ids,
+                                        new_tick,
+                                        gr.update(visible=False),
+                                        gr.update(choices=choices, value=[]),
+                                        gr.update(value=None),
+                                    )
+
+                                # 确认删除后同步 selected_group 与 export_selected_btn
+                                confirm_delete_btn.click(
+                                    _confirm_delete,
+                                    inputs=[rid_box, ids_state, store_tick],
+                                    outputs=[
+                                        ids_state,
+                                        store_tick,
+                                        delete_confirm_panel,
+                                        selected_group,
+                                        export_selected_btn,
+                                    ],
+                                    show_progress="hidden",
+                                )
+                                cancel_delete_btn.click(
+                                    lambda: gr.update(visible=False),
+                                    outputs=[delete_confirm_panel],
+                                    show_progress="hidden",
+                                )
+
+                # Top-level events
+                def _on_prompt_mode_change(m):
+                    return dict_promptmode_to_prompt.get(m, "")
+
+                prompt_mode.change(
+                    fn=_on_prompt_mode_change,
+                    inputs=[prompt_mode],
+                    outputs=[prompt_display],
+                    show_progress="hidden",
+                )
+
+                def process_images_simple(
+                    file_list,
+                    p_mode,
+                    server_ip_val,
+                    server_port_val,
+                    min_p_val,
+                    max_p_val,
+                    fitz_val,
+                    cur_ids,
+                    tick,
+                ):
+                    """
+                    Process images with selected prompt mode. Grounding mode is removed; all files go through normal path.
+                    """
+                    minp, maxp = _validate_pixels(min_p_val, max_p_val)
+                    _set_parser_config(server_ip_val, server_port_val, minp, maxp)
+
+                    # normalize file_list (gradio file element may pass nested lists)
+                    files = []
+                    if not file_list:
+                        return (
+                            gr.update(value=None),
+                            gr.update(value="No files uploaded."),
+                            cur_ids,
+                            tick,
+                            gr.update(choices=[], value=[]),
+                            gr.update(value=None),  # 清空导出
+                        )
+
+                    # build normalized list
+                    for f in file_list:
+                        if isinstance(f, (list, tuple)):
+                            files.append(f[0] if len(f) > 0 else None)
+                        else:
+                            files.append(f)
+
+                    # Normal path: queue originals
+                    new_ids, info = add_tasks_to_queue(
+                        files,
+                        p_mode,
+                        server_ip_val,
+                        server_port_val,
+                        minp,
+                        maxp,
+                        fitz_val,
+                        cur_ids,
+                    )
+                    # Update checkbox group choices
+                    choices = [f"Result {i+1}" for i in range(len(new_ids or []))]
+                    return (
+                        gr.update(value=None),
+                        gr.update(value=info),
+                        new_ids,
+                        int(tick or 0) + 1,
+                        gr.update(choices=choices, value=[]),
+                        gr.update(value=None),  # 清空导出
+                    )
+
+                parse_btn.click(
+                    fn=process_images_simple,
+                    inputs=[
+                        file_input,
+                        prompt_mode,
+                        server_ip,
+                        server_port,
+                        min_pixels,
+                        max_pixels,
+                        fitz_preprocess,
+                        ids_state,
+                        store_tick,
+                    ],
+                    outputs=[
+                        file_input,
+                        info_display,
+                        ids_state,
+                        store_tick,
+                        selected_group,
+                        export_selected_btn,
+                    ],
+                    show_progress="hidden",
+                )
+
+                # Concurrency change handler: apply immediately
+                def _on_concurrency_change(n):
+                    try:
+                        set_max_concurrency(int(n))
+                        return gr.update(value=f"并发已设置为 {int(n)}。")
+                    except Exception as e:
+                        return gr.update(value=f"设置并发失败：{e}")
+
+                concurrency.change(
+                    _on_concurrency_change,
+                    inputs=[concurrency],
+                    outputs=[info_display],
+                    show_progress="hidden",
+                )
+
+                # 会话加载时同步 UI 与当前真实并发（解决刷新后 UI 值与实际不一致）
+                def _sync_concurrency_on_session_load():
+                    try:
+                        # 如有需要，补齐 worker 到目标并发数（不会减少已有线程）
+                        _start_workers(max(1, MAX_CONCURRENCY))
+                        return (
+                            gr.update(value=int(MAX_CONCURRENCY)),
+                            gr.update(
+                                value=f"已同步当前并发为 {int(MAX_CONCURRENCY)}。"
+                            ),
+                        )
+                    except Exception as e:
+                        return (
+                            gr.update(value=int(MAX_CONCURRENCY)),
+                            gr.update(value=f"同步并发时发生异常：{e}"),
+                        )
+
+                demo.load(
+                    _sync_concurrency_on_session_load,
+                    inputs=None,
+                    outputs=[concurrency, info_display],
+                )
+
+                # 生成导出 ZIP（基于当前选择），用于首次点击即可下载
+                def _update_export_for_selection(ids, selected_labels):
+                    path = export_selected_rids(ids, selected_labels)
+                    return gr.update(
+                        value=path if path and os.path.exists(path) else None
+                    )
+
+                # Actions: 全选/清空
+                def _select_all(ids):
+                    choices = [f"Result {i+1}" for i in range(len(ids or []))]
+                    # 预生成 zip
+                    path = export_selected_rids(ids, choices)
+                    return (
+                        gr.update(choices=choices, value=choices),
+                        gr.update(
+                            value=path if path and os.path.exists(path) else None
+                        ),
+                    )
+
+                def _clear_selection(ids):
+                    choices = [f"Result {i+1}" for i in range(len(ids or []))]
+                    return (
+                        gr.update(choices=choices, value=[]),
+                        gr.update(value=None),
+                    )
+
+                select_all_btn.click(
+                    _select_all,
+                    inputs=[ids_state],
+                    outputs=[selected_group, export_selected_btn],
+                    show_progress="hidden",
+                )
+                clear_sel_btn.click(
+                    _clear_selection,
+                    inputs=[ids_state],
+                    outputs=[selected_group, export_selected_btn],
+                    show_progress="hidden",
+                )
+
+                # 当用户手动变更选择时，预构建导出 zip 并绑定到按钮
+                selected_group.change(
+                    _update_export_for_selection,
+                    inputs=[ids_state, selected_group],
+                    outputs=[export_selected_btn],
+                    show_progress="hidden",
+                )
+
+                # Actions: 批量重解析（基于当前图片）
+                def bulk_reparse(
+                    selected_labels, ids, p_mode, ip, port, minp, maxp, fitz, tick
+                ):
+                    if not ids or not selected_labels:
+                        path_sel = export_selected_rids(ids, selected_labels)
+                        return (
+                            gr.update(value="未选择任何结果。"),
+                            int(tick or 0),
+                            gr.update(value=path_sel),
+                        )
+                    # Map labels -> rids
+                    count = 0
+                    for label in selected_labels:
+                        try:
+                            idx = int(str(label).split()[-1]) - 1
+                            rid = ids[idx]
+                            enqueue_single_reparse(
+                                rid,
+                                None,
+                                p_mode,
+                                ip,
+                                int(port),
+                                int(minp),
+                                int(maxp),
+                                fitz,
+                            )
+                            count += 1
+                        except Exception:
+                            continue
+                    path_sel = export_selected_rids(ids, selected_labels)
+                    return (
+                        gr.update(value=f"已触发 {count} 个重解析任务。"),
+                        int(tick or 0) + 1,
+                        gr.update(value=path_sel),
+                    )
+
+                bulk_reparse_btn.click(
+                    bulk_reparse,
+                    inputs=[
+                        selected_group,
+                        ids_state,
+                        prompt_mode,
+                        server_ip,
+                        server_port,
+                        min_pixels,
+                        max_pixels,
+                        fitz_preprocess,
+                        store_tick,
+                    ],
+                    outputs=[info_display, store_tick, export_selected_btn],
+                    show_progress="hidden",
+                )
+
+                # Actions: 删除所选（尊重“删除前确认”）
+                def delete_selected_action(ids, selected_labels, tick):
+                    # 先从“原始 ids 列表”解析出要删除的 rid 列表，避免索引随删除而错位
+                    if not ids or not selected_labels:
+                        choices = [f"Result {i+1}" for i in range(len(ids or []))]
+                        return (
+                            ids,
+                            int(tick or 0),
+                            gr.update(choices=choices, value=[]),
+                            gr.update(value=None),
+                        )
+                    # 解析 label -> index（去重、过滤非法）
+                    sel_indices = []
+                    for label in selected_labels:
+                        try:
+                            idx = int(str(label).split()[-1]) - 1
+                            if 0 <= idx < len(ids):
+                                sel_indices.append(idx)
+                        except Exception:
+                            continue
+                    if not sel_indices:
+                        choices = [f"Result {i+1}" for i in range(len(ids or []))]
+                        return (
+                            ids,
+                            int(tick or 0),
+                            gr.update(choices=choices, value=[]),
+                            gr.update(value=None),
+                        )
+                    sel_indices = sorted(set(sel_indices))
+                    rids_to_delete = [ids[i] for i in sel_indices]
+
+                    new_ids = list(ids)
+                    new_tick = int(tick or 0)
+                    # 基于 rid 删除，避免受索引变化影响
+                    for rid in rids_to_delete:
+                        new_ids, new_tick = delete_one(new_ids, rid, new_tick)
+
+                    choices = [f"Result {i+1}" for i in range(len(new_ids or []))]
+                    return (
+                        new_ids,
+                        new_tick,
+                        gr.update(choices=choices, value=[]),
+                        gr.update(value=None),
+                    )
+
+                def _on_bulk_delete_click(ids, selected_labels, need_confirm, tick):
+                    if need_confirm:
+                        # 展示确认面板，不改动任何选择与导出
+                        return (
+                            gr.update(visible=True),
+                            ids,
+                            tick,
+                            gr.update(),
+                            gr.update(),
+                        )
+                    # 直接删除并隐藏确认面板
+                    new_ids, new_tick, sel_update, export_update = (
+                        delete_selected_action(ids, selected_labels, tick)
+                    )
+                    return (
+                        gr.update(visible=False),
+                        new_ids,
+                        new_tick,
+                        sel_update,
+                        export_update,
+                    )
+
+                delete_selected_btn.click(
+                    _on_bulk_delete_click,
+                    inputs=[
+                        ids_state,
+                        selected_group,
+                        confirm_delete_state,
+                        store_tick,
+                    ],
+                    outputs=[
+                        bulk_delete_confirm_panel,
+                        ids_state,
+                        store_tick,
+                        selected_group,
+                        export_selected_btn,
+                    ],
+                    show_progress="hidden",
+                )
+
+                def _bulk_confirm_delete(ids, selected_labels, tick):
+                    new_ids, new_tick, sel_update, export_update = (
+                        delete_selected_action(ids, selected_labels, tick)
+                    )
+                    return (
+                        new_ids,
+                        new_tick,
+                        sel_update,
+                        export_update,
+                        gr.update(visible=False),
+                    )
+
+                bulk_confirm_delete_btn.click(
+                    _bulk_confirm_delete,
+                    inputs=[ids_state, selected_group, store_tick],
+                    outputs=[
+                        ids_state,
+                        store_tick,
+                        selected_group,
+                        export_selected_btn,
+                        bulk_delete_confirm_panel,
+                    ],
+                    show_progress="hidden",
+                )
+                bulk_cancel_delete_btn.click(
+                    lambda: gr.update(visible=False),
+                    outputs=[bulk_delete_confirm_panel],
+                    show_progress="hidden",
+                )
+
+                # 进度信息
+                def update_progress_info(ids, tick, bump):
+                    if not ids:
+                        return (
+                            gr.update(value="Waiting..."),
+                            tick,
+                            int(bump or 0),
+                        )
+                    pending = 0
+                    done = 0
+                    errors = 0
+                    status_signature = []
+                    for rid in ids:
+                        st = RESULTS_CACHE.get(rid, {})
+                        status = st.get("status", "pending")
+                        status_signature.append((rid, status))
+                        if status == "done":
+                            done += 1
+                        elif status == "error":
+                            errors += 1
+                        else:
+                            pending += 1
+                    qsize = TASK_QUEUE.qsize()
+                    running = max(0, pending - qsize)
+
+                    # Info text
+                    if pending == 0:
+                        info = (
+                            f"进度：完成 {done}"
+                            + ("" if errors == 0 else f"，错误 {errors}")
+                            + "。"
+                        )
+                    else:
+                        info = f"进度：完成 {done}，错误 {errors}，正在解析 {running}，排队 {qsize}，待处理合计 {pending}。"
+
+                    # Only bump render when any item's status changed
+                    sig_tuple = tuple(status_signature)
+                    last_sig = getattr(update_progress_info, "_last_status_sig", None)
+                    bump_out = int(bump or 0)
+                    if last_sig != sig_tuple:
+                        setattr(update_progress_info, "_last_status_sig", sig_tuple)
+                        bump_out = bump_out + 1
+
+                    # Only tick when coarse counts change (avoid unnecessary churn)
+                    key = f"{done}_{errors}_{pending}"
+                    last_key = getattr(update_progress_info, "_last_counts_key", None)
+                    new_tick = int(tick or 0)
+                    if last_key != key:
+                        setattr(update_progress_info, "_last_counts_key", key)
+                        new_tick = new_tick + 1
+
+                    return (
+                        gr.update(value=info),
+                        new_tick,
+                        bump_out,
+                    )
+
+                # 计时器不再触达 selected_group，杜绝与用户交互竞争导致选择重置/计时停止
+                progress_timer.tick(
+                    fn=update_progress_info,
+                    inputs=[ids_state, store_tick, render_bump],
+                    outputs=[info_display, store_tick, render_bump],
+                    show_progress="hidden",
+                )
+
+                # Clear all
+                def clear_all():
+                    global RESULTS_CACHE
+                    while not TASK_QUEUE.empty():
+                        try:
+                            TASK_QUEUE.get_nowait()
+                            TASK_QUEUE.task_done()
+                        except queue.Empty:
+                            break
+                    RESULTS_CACHE = {}
+                    RETRY_COUNTS.clear()
+                    # Do not stop workers; keep them alive
+                    return (
+                        [],
+                        0,
+                        gr.update(value="Waiting..."),
+                        0,
+                        gr.update(choices=[], value=[]),
+                        gr.update(value=None),
+                    )
+
+                clear_btn.click(
+                    clear_all,
+                    inputs=None,
+                    outputs=[
+                        ids_state,
+                        store_tick,
+                        info_display,
+                        render_bump,
+                        selected_group,
+                        export_selected_btn,
+                    ],
+                    show_progress="hidden",
+                )
+
+    return demo
+
+
+# ---------------- main ----------------
+def _queue_compat(blocks: gr.Blocks):
+    """
+    Gradio version compatibility layer for Blocks.queue:
+    - Try Gradio 4.x: default_concurrency_limit + status_update_rate
+    - Fallback to Gradio 3.x: concurrency_count + status_update_rate
+    - Final fallback: no-arg queue()
+    """
+    try:
+        # Gradio 4.x path
+        return blocks.queue(default_concurrency_limit=20, status_update_rate=0.2)
+    except TypeError:
+        try:
+            # Gradio 3.x path
+            return blocks.queue(concurrency_count=16, status_update_rate=0.2)
+        except TypeError:
+            # Minimal fallback
+            return blocks.queue()
+
+
+def _launch_compat(app: gr.Blocks, port: int):
+    """
+    Gradio version compatibility for launch parameters.
+    """
+    try:
+        app.launch(
+            server_name="0.0.0.0",
+            server_port=port,
+            debug=True,
+            show_api=False,  # 3.x/部分4.x可用
+        )
+    except TypeError:
+        # Fallback without show_api
+        app.launch(
+            server_name="0.0.0.0",
+            server_port=port,
+            debug=True,
+        )
+
+
+if __name__ == "__main__":
+    import sys
+
+    port = int(sys.argv[1]) if len(sys.argv) > 1 else 7860
+    demo = create_gradio_interface()
+    app = _queue_compat(demo)
+    _launch_compat(app, port)