diff --git a/UPSTREAM_SYNC.md b/UPSTREAM_SYNC.md
new file mode 100644
index 0000000..bea08e2
--- /dev/null
+++ b/UPSTREAM_SYNC.md
@@ -0,0 +1,86 @@
+# Upstream Sync Record
+
+This library is a standalone, pip-installable extraction of the `deepdoc/`
+module from [infiniflow/ragflow](https://github.com/infiniflow/ragflow),
+restructured around explicit configuration injection
+(`PdfModelConfig` / `TokenizerConfig`, `DEEPDOC_*` env vars) and
+ModelScope-based model distribution instead of ragflow's global settings and
+HuggingFace runtime downloads.
+
+Upstream changes are **ported by behavior, never by wholesale file copy**,
+so the library's public API (`from deepdoc import PdfParser, ...`) and
+packaging stay stable.
+
+## Sync history
+
+### 2026-07-23 — synced to ragflow `18ea0fb7` (2026-07-22)
+
+Ported fixes (upstream PR references):
+
+| Area | Fix | Upstream |
+|---|---|---|
+| vision/operators | `StandardizeImag` → `StandardizeImage` rename; the dynamic `getattr(operators, "StandardizeImage")` dispatch silently skipped image standardization before | [#16785](https://github.com/infiniflow/ragflow/pull/16785) |
+| mineru/tcadp | zip extraction hardening: reject symlink / encrypted / absolute-path / `..`-traversal / zip-slip entries; streaming download for TCADP results | [#12527](https://github.com/infiniflow/ragflow/pull/12527) |
+| html_parser | parse bodyless HTML fragments (`soup.body or soup`) | [#16423](https://github.com/infiniflow/ragflow/pull/16423) |
+| html_parser | switch `html5lib` → `html.parser` (aligns with upstream #14486-era behavior the later fixes assume) | [#14486](https://github.com/infiniflow/ragflow/pull/14486) |
+| html_parser | h4 heading mapping `#####` → `####` | [#13833](https://github.com/infiniflow/ragflow/pull/13833) |
+| html_parser | oversized-block splitting preserves original text (CJK-aware atom splitting) | [#16052](https://github.com/infiniflow/ragflow/pull/16052) |
+| excel_parser | keep `0` / `False` cells; skip fully-empty rows | [#16287](https://github.com/infiniflow/ragflow/pull/16287) |
+| excel_parser | no spurious header-only chunk when data rows are an exact multiple of `chunk_rows` | [#15490](https://github.com/infiniflow/ragflow/pull/15490) |
+| excel_parser | binary-search actual row count for sheets with abnormal `max_row` | [#13018](https://github.com/infiniflow/ragflow/pull/13018) |
+| markdown_parser | full sync to upstream state: protected ranges (fenced code / MD tables / HTML tables) never split by delimiters; GFM separators with 1+ dashes; lone-header attachment | #10896 #11018 #11520 #13892 #15630 #15632 #16109 #16319 |
+| ppt_parser | cached, None-safe shape sorting (group shapes with `top=None` no longer crash) | [#13054](https://github.com/infiniflow/ragflow/pull/13054) |
+| parser/utils | `get_text`: `if binary:` → `if binary is not None:` | [#13196](https://github.com/infiniflow/ragflow/pull/13196) |
+| table_structure_recognizer | English caption patterns (`Figure N` / `Table N` / `Fig. N`) | [#15481](https://github.com/infiniflow/ragflow/pull/15481) |
+| vision/ocr | env-configurable ONNX thread counts (`OCR_INTRA_OP_NUM_THREADS` / `OCR_INTER_OP_NUM_THREADS`) and opt-in GPU arena shrinkage (`OCR_GPUMEM_ARENA_SHRINKAGE=1`) | [#12777](https://github.com/infiniflow/ragflow/pull/12777) |
+| layout_recognizer | figure/equation placeholder boxes get per-type layoutno namespaces (`figure-N` / `equation-N`), preventing unrelated figure and equation crops from merging on scientific PDFs | [#15873](https://github.com/infiniflow/ragflow/pull/15873) |
+| layout_recognizer | re-enable CID-pattern garbage filter for text boxes | [#13404](https://github.com/infiniflow/ragflow/pull/13404) |
+| pdf_parser | garbled-text detection → OCR fallback (PUA/CID chars, subset-font encoding garbling, OCR-alphabet coverage check) | [#13404](https://github.com/infiniflow/ragflow/pull/13404) |
+| pdf_parser | geometry-based word-space recovery, CJK-aware (`_insert_word_spaces`) | [#16958](https://github.com/infiniflow/ragflow/pull/16958) |
+| pdf_parser | remove 299-page hardcoded limit (`MAXIMUM_PAGE_NUMBER = 100000`) | [#14382](https://github.com/infiniflow/ragflow/pull/14382) |
+| pdf_parser | chunked `parse_into_bboxes` for large PDFs (`PDF_PARSER_PAGE_BATCH_SIZE`, default 50) with window→global box remapping; lazy `img_np` in `__ocr` | [#14385](https://github.com/infiniflow/ragflow/pull/14385) |
+| pdf_parser | out-of-range page-index guards in `cropout` / table-figure insertion | [#12938](https://github.com/infiniflow/ragflow/pull/12938) [#12848](https://github.com/infiniflow/ragflow/pull/12848) |
+| pdf_parser (VisionParser) | `pdf_page_num = from_page + idx` (page numbering was wrong when `from_page > 0`); fixed broken relative import of `llm_adapter` | [#12938](https://github.com/infiniflow/ragflow/pull/12938) + fork-local fix |
+| parser (new) | EPUB parser (spine-order XHTML extraction, delegates to HtmlParser), exported as `deepdoc.EpubParser` | [#13650](https://github.com/infiniflow/ragflow/pull/13650) |
+
+Already present before this sync (no action needed): `ast.literal_eval`
+security fix (#12236), XLS/calamine loading (#10660), chartsheet guards
+(#10819), KMeans multi-column detection (#11415 + #12534 cleanup),
+`is_english` regex fix (#11432), OCR GPU memory limit env (#10407),
+`vision_figure_parser_docx_wrapper` guard (#12104).
+
+**Deliberately NOT ported** (decisions):
+
+- **Go + HTTP microservice pipeline** (#16323, `deepdoc/server/`, `DEEPDOC_URL`
+  DLA client): conflicts with this library's pure-Python, in-process design.
+- **Automatic table orientation detection/rotation** (#12719 feature +
+  #12981 / #17016 follow-ups): feature not in our baseline; runs 4× OCR per
+  table; adopt separately if ever needed.
+- **`rag.utils.lazy_image` memory refactors** (docx/excel lazy image loading,
+  #13329 / #13558): optimization only; deferred until vendoring lazy_image is
+  justified.
+- **3-tuple outlines** (`extract_pdf_outlines` returning
+  `(title, depth, page)`, #10456 TOC feature): our `outlines` stays
+  `(title, depth)` to avoid breaking downstream consumers.
+- **`model_speciess` → `model_species` rename** (#13929): our attribute name
+  is part of the public surface; renaming would break existing callers.
+- **paddleocr / opendataloader / somark parsers**: cloud-API clients, not
+  currently needed; revisit on demand.
+- **MinerU feature evolution** (API-only backends, VLM descriptions, etc.):
+  only the security fix was taken; feature sync deferred until MinerU usage
+  is confirmed.
+- **Pure refactors** (moving functions between ragflow modules, lefthook
+  reformatting): not applicable to our layout.
+
+Regression tests: `tests/test_upstream_sync_regressions.py`.
+
+## How to run the next sync
+
+```bash
+# in a ragflow clone
+git log --reverse --format="%h %ad %s" --date=short 18ea0fb7..origin/main -- deepdoc
+```
+
+Then for each commit: understand the behavior change, find the corresponding
+code in this repo, and re-implement it in this library's style (config
+injection, relative imports, vendored `common/` + `depend/`). Update this file.
diff --git a/deepdoc/__init__.py b/deepdoc/__init__.py
index e68ad56..5904190 100644
--- a/deepdoc/__init__.py
+++ b/deepdoc/__init__.py
@@ -27,6 +27,7 @@
     "PlainParser",
     "DocxParser",
     "DoclingParser",
+    "EpubParser",
     "ExcelParser",
     "PptParser",
     "HtmlParser",
diff --git a/deepdoc/parser/__init__.py b/deepdoc/parser/__init__.py
index bce30e7..1097b27 100644
--- a/deepdoc/parser/__init__.py
+++ b/deepdoc/parser/__init__.py
@@ -16,6 +16,7 @@
 
 from .docx_parser import RAGFlowDocxParser as DocxParser
 from .docling_parser import DoclingParser
+from .epub_parser import RAGFlowEpubParser as EpubParser
 from .excel_parser import RAGFlowExcelParser as ExcelParser
 from .html_parser import RAGFlowHtmlParser as HtmlParser
 from .json_parser import RAGFlowJsonParser as JsonParser
@@ -31,6 +32,7 @@
     "PlainParser",
     "DocxParser",
     "DoclingParser",
+    "EpubParser",
     "ExcelParser",
     "PptParser",
     "HtmlParser",
diff --git a/deepdoc/parser/epub_parser.py b/deepdoc/parser/epub_parser.py
new file mode 100644
index 0000000..37ab1bc
--- /dev/null
+++ b/deepdoc/parser/epub_parser.py
@@ -0,0 +1,139 @@
+#
+#  Copyright 2025 The InfiniFlow Authors. All Rights Reserved.
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+#
+
+import logging
+import warnings
+import zipfile
+from io import BytesIO
+from xml.etree import ElementTree
+
+from ..config import TokenizerConfig
+from .html_parser import RAGFlowHtmlParser
+
+# OPF XML namespaces
+_OPF_NS = "http://www.idpf.org/2007/opf"
+_CONTAINER_NS = "urn:oasis:names:tc:opendocument:xmlns:container"
+
+# Media types that contain readable XHTML content
+_XHTML_MEDIA_TYPES = {"application/xhtml+xml", "text/html", "text/xml"}
+
+logger = logging.getLogger(__name__)
+
+
+class RAGFlowEpubParser:
+    """Parse EPUB files by extracting XHTML content in spine (reading) order
+    and delegating to RAGFlowHtmlParser for chunking."""
+
+    def __init__(self, tokenizer_cfg: TokenizerConfig | None = None):
+        self.html_parser = RAGFlowHtmlParser(tokenizer_cfg=tokenizer_cfg)
+
+    def __call__(self, fnm, binary=None, chunk_token_num=512):
+        if binary is not None:
+            if not binary:
+                logger.warning(
+                    "RAGFlowEpubParser received an empty EPUB binary payload for %r",
+                    fnm,
+                )
+                raise ValueError("Empty EPUB binary payload")
+            zf = zipfile.ZipFile(BytesIO(binary))
+        else:
+            zf = zipfile.ZipFile(fnm)
+
+        try:
+            content_items = self._get_spine_items(zf)
+            all_sections = []
+
+            for item_path in content_items:
+                try:
+                    html_bytes = zf.read(item_path)
+                except KeyError:
+                    continue
+                if not html_bytes:
+                    logger.debug("Skipping empty EPUB content item: %s", item_path)
+                    continue
+                with warnings.catch_warnings():
+                    warnings.filterwarnings("ignore", category=UserWarning)
+                    sections = self.html_parser(item_path, binary=html_bytes, chunk_token_num=chunk_token_num)
+                all_sections.extend(sections)
+
+            return all_sections
+        finally:
+            zf.close()
+
+    @staticmethod
+    def _get_spine_items(zf):
+        """Return content file paths in spine (reading) order."""
+        # 1. Find the OPF file path from META-INF/container.xml
+        try:
+            container_xml = zf.read("META-INF/container.xml")
+        except KeyError:
+            return RAGFlowEpubParser._fallback_xhtml_order(zf)
+
+        try:
+            container_root = ElementTree.fromstring(container_xml)
+        except ElementTree.ParseError:
+            logger.warning("Failed to parse META-INF/container.xml; falling back to XHTML order.")
+            return RAGFlowEpubParser._fallback_xhtml_order(zf)
+
+        rootfile_el = container_root.find(f".//{{{_CONTAINER_NS}}}rootfile")
+        if rootfile_el is None:
+            return RAGFlowEpubParser._fallback_xhtml_order(zf)
+
+        opf_path = rootfile_el.get("full-path", "")
+        if not opf_path:
+            return RAGFlowEpubParser._fallback_xhtml_order(zf)
+
+        # Base directory of the OPF file (content paths are relative to it)
+        opf_dir = opf_path.rsplit("/", 1)[0] + "/" if "/" in opf_path else ""
+
+        # 2. Parse the OPF file
+        try:
+            opf_xml = zf.read(opf_path)
+        except KeyError:
+            return RAGFlowEpubParser._fallback_xhtml_order(zf)
+
+        try:
+            opf_root = ElementTree.fromstring(opf_xml)
+        except ElementTree.ParseError:
+            logger.warning("Failed to parse OPF file '%s'; falling back to XHTML order.", opf_path)
+            return RAGFlowEpubParser._fallback_xhtml_order(zf)
+
+        # 3. Build id->href+mediatype map from <manifest>
+        manifest = {}
+        for item in opf_root.findall(f".//{{{_OPF_NS}}}item"):
+            item_id = item.get("id", "")
+            href = item.get("href", "")
+            media_type = item.get("media-type", "")
+            if item_id and href:
+                manifest[item_id] = (href, media_type)
+
+        # 4. Walk <spine> to get reading order
+        spine_items = []
+        for itemref in opf_root.findall(f".//{{{_OPF_NS}}}itemref"):
+            idref = itemref.get("idref", "")
+            if idref not in manifest:
+                continue
+            href, media_type = manifest[idref]
+            if media_type not in _XHTML_MEDIA_TYPES:
+                continue
+            spine_items.append(opf_dir + href)
+
+        return spine_items if spine_items else RAGFlowEpubParser._fallback_xhtml_order(zf)
+
+    @staticmethod
+    def _fallback_xhtml_order(zf):
+        """Fallback: return all .xhtml/.html files sorted alphabetically."""
+        return sorted(n for n in zf.namelist() if n.lower().endswith((".xhtml", ".html", ".htm")) and not n.startswith("META-INF/"))
diff --git a/deepdoc/parser/excel_parser.py b/deepdoc/parser/excel_parser.py
index f4c451e..731ba7e 100644
--- a/deepdoc/parser/excel_parser.py
+++ b/deepdoc/parser/excel_parser.py
@@ -74,6 +74,14 @@ def clean_string(s):
 
         return df.apply(lambda col: col.map(clean_string))
 
+    @staticmethod
+    def _fill_worksheet_from_dataframe(ws, df: pd.DataFrame):
+        for col_num, column_name in enumerate(df.columns, 1):
+            ws.cell(row=1, column=col_num, value=column_name)
+        for row_num, row in enumerate(df.values, 2):
+            for col_num, value in enumerate(row, 1):
+                ws.cell(row=row_num, column=col_num, value=value)
+
     @staticmethod
     def _dataframe_to_workbook(df):
         # if contains multiple sheets use _dataframes_to_workbook
@@ -84,30 +92,19 @@ def _dataframe_to_workbook(df):
         wb = Workbook()
         ws = wb.active
         ws.title = "Data"
-
-        for col_num, column_name in enumerate(df.columns, 1):
-            ws.cell(row=1, column=col_num, value=column_name)
-
-        for row_num, row in enumerate(df.values, 2):
-            for col_num, value in enumerate(row, 1):
-                ws.cell(row=row_num, column=col_num, value=value)
-
+        RAGFlowExcelParser._fill_worksheet_from_dataframe(ws, df)
         return wb
-    
+
     @staticmethod
     def _dataframes_to_workbook(dfs: dict):
         wb = Workbook()
         default_sheet = wb.active
         wb.remove(default_sheet)
-        
+
         for sheet_name, df in dfs.items():
             df = RAGFlowExcelParser._clean_dataframe(df)
             ws = wb.create_sheet(title=sheet_name)
-            for col_num, column_name in enumerate(df.columns, 1):
-                ws.cell(row=1, column=col_num, value=column_name)
-            for row_num, row in enumerate(df.values, 2):
-                for col_num, value in enumerate(row, 1):
-                    ws.cell(row=row_num, column=col_num, value=value)
+            RAGFlowExcelParser._fill_worksheet_from_dataframe(ws, df)
         return wb
 
     @staticmethod
@@ -156,6 +153,55 @@ def _extract_images_from_worksheet(ws, sheetname=None):
                 continue
         return raw_items
 
+    @staticmethod
+    def _get_actual_row_count(ws):
+        max_row = ws.max_row
+        if not max_row:
+            return 0
+        if max_row <= 10000:
+            return max_row
+
+        max_col = min(ws.max_column or 1, 50)
+
+        def row_has_data(row_idx):
+            for col_idx in range(1, max_col + 1):
+                cell = ws.cell(row=row_idx, column=col_idx)
+                if cell.value is not None and str(cell.value).strip():
+                    return True
+            return False
+
+        if not any(row_has_data(i) for i in range(1, min(101, max_row + 1))):
+            return 0
+
+        left, right = 1, max_row
+        last_data_row = 1
+
+        while left <= right:
+            mid = (left + right) // 2
+            found = False
+            for r in range(mid, min(mid + 10, max_row + 1)):
+                if row_has_data(r):
+                    found = True
+                    last_data_row = max(last_data_row, r)
+                    break
+            if found:
+                left = mid + 1
+            else:
+                right = mid - 1
+
+        for r in range(last_data_row, min(last_data_row + 500, max_row + 1)):
+            if row_has_data(r):
+                last_data_row = r
+
+        return last_data_row
+
+    @staticmethod
+    def _get_rows_limited(ws):
+        actual_rows = RAGFlowExcelParser._get_actual_row_count(ws)
+        if actual_rows == 0:
+            return []
+        return list(ws.iter_rows(min_row=1, max_row=actual_rows))
+
     def html(self, fnm, chunk_rows=256):
         from html import escape
 
@@ -171,7 +217,7 @@ def _fmt(v):
         for sheetname in wb.sheetnames:
             ws = wb[sheetname]
             try:
-                rows = list(ws.rows)
+                rows = RAGFlowExcelParser._get_rows_limited(ws)
             except Exception as e:
                 logging.warning(f"Skip sheet '{sheetname}' due to rows access error: {e}")
                 continue
@@ -184,7 +230,12 @@ def _fmt(v):
                 tb_rows_0 += f"<th>{escape(_fmt(t.value))}</th>"
             tb_rows_0 += "</tr>"
 
-            for chunk_i in range((len(rows) - 1) // chunk_rows + 1):
+            # rows[0] is the header; split the remaining data rows into
+            # ceil(n_data / chunk_rows) chunks. Using +1 here over-counts by one
+            # when the data-row count is an exact multiple of chunk_rows and emits
+            # a spurious header-only chunk.
+            n_data_rows = len(rows) - 1
+            for chunk_i in range((n_data_rows + chunk_rows - 1) // chunk_rows):
                 tb = ""
                 tb += f"<table><caption>{sheetname}</caption>"
                 tb += tb_rows_0
@@ -223,7 +274,7 @@ def __call__(self, fnm):
         for sheetname in wb.sheetnames:
             ws = wb[sheetname]
             try:
-                rows = list(ws.rows)
+                rows = RAGFlowExcelParser._get_rows_limited(ws)
             except Exception as e:
                 logging.warning(f"Skip sheet '{sheetname}' due to rows access error: {e}")
                 continue
@@ -233,11 +284,13 @@ def __call__(self, fnm):
             for r in list(rows[1:]):
                 fields = []
                 for i, c in enumerate(r):
-                    if not c.value:
+                    if c.value is None or str(c.value).strip() == "":
                         continue
                     t = str(ti[i].value) if i < len(ti) else ""
                     t += ("：" if t else "") + str(c.value)
                     fields.append(t)
+                if not fields:
+                    continue
                 line = "; ".join(fields)
                 if sheetname.lower().find("sheet") < 0:
                     line += " ——" + sheetname
@@ -251,12 +304,12 @@ def row_number(fnm, binary):
             total = 0
             
             for sheetname in wb.sheetnames:
-               try:
-                   ws = wb[sheetname]
-                   total += len(list(ws.rows))
-               except Exception as e:
-                   logging.warning(f"Skip sheet '{sheetname}' due to rows access error: {e}")
-                   continue
+                try:
+                    ws = wb[sheetname]
+                    total += RAGFlowExcelParser._get_actual_row_count(ws)
+                except Exception as e:
+                    logging.warning(f"Skip sheet '{sheetname}' due to rows access error: {e}")
+                    continue
             return total
 
         if fnm.split(".")[-1].lower() in ["csv", "txt"]:
diff --git a/deepdoc/parser/html_parser.py b/deepdoc/parser/html_parser.py
index 538e37a..67d859c 100644
--- a/deepdoc/parser/html_parser.py
+++ b/deepdoc/parser/html_parser.py
@@ -16,6 +16,8 @@
 #
 
 import html
+import logging
+import re
 import uuid
 
 import chardet
@@ -37,7 +39,7 @@ def get_encoding(file):
     "table", "pre", "code", "blockquote",
     "figure", "figcaption"
 ]
-TITLE_TAGS = {"h1": "#", "h2": "##", "h3": "###", "h4": "#####", "h5": "#####", "h6": "######"}
+TITLE_TAGS = {"h1": "#", "h2": "##", "h3": "###", "h4": "####", "h5": "#####", "h6": "######"}
 
 
 class RAGFlowHtmlParser:
@@ -65,7 +67,7 @@ def parser_txt(self, txt, chunk_token_num):
             raise TypeError("txt type should be string!")
 
         temp_sections = []
-        soup = BeautifulSoup(txt, "html5lib")
+        soup = BeautifulSoup(txt, "html.parser")
         # delete <style> tag
         for style_tag in soup.find_all(["style", "script"]):
             style_tag.decompose()
@@ -81,7 +83,10 @@ def parser_txt(self, txt, chunk_token_num):
         for comment in soup.find_all(string=lambda text: isinstance(text, Comment)):
             comment.extract()
 
-        self.read_text_recursively(soup.body, temp_sections, chunk_token_num=chunk_token_num)
+        root = soup.body or soup
+        if soup.body is None:
+            logging.debug("html_parser: parsing HTML fragment without <body>; falling back to soup root")
+        self.read_text_recursively(root, temp_sections, chunk_token_num=chunk_token_num)
         block_txt_list, table_list = self.merge_block_text(temp_sections)
         sections = self.chunk_block(block_txt_list, chunk_token_num=chunk_token_num)
         for table in table_list:
@@ -186,26 +191,84 @@ def merge_block_text(self, parser_result):
             block_content.append(current_content)
         return block_content, table_info_list
 
+    # Characters from scripts written without spaces between words (CJK, kana,
+    # Hangul). These must be split per-character, since whitespace is not a
+    # usable word boundary for them.
+    _SPACELESS = (
+        "぀-ヿ"  # Hiragana, Katakana
+        "㐀-䶿"  # CJK Extension A
+        "一-鿿"  # CJK Unified Ideographs
+        "豈-﫿"  # CJK Compatibility Ideographs
+        "가-힯"  # Hangul syllables
+    )
+    _ATOM_RE = re.compile(r"[{s}]|[^\s{s}]+|\s+".format(s=_SPACELESS))
+
+    def _token_count(self, text):
+        if not text:
+            return 0
+        tks_str = self.tokenizer.tokenize(text)
+        return len(tks_str.split(" ")) if tks_str else 0
+
+    def _split_oversized_block(self, block, chunk_token_num):
+        # Split the ORIGINAL text into pieces of at most chunk_token_num tokens,
+        # preserving the source characters. Break on whitespace for
+        # space-delimited scripts and per-character for scripts that have no
+        # spaces (e.g. Chinese), so both are split without mangling the text.
+        pieces = []
+        current = ""
+        current_tokens = 0
+        # Spaceless scripts yield many repeated single-character atoms, so cache
+        # the token count per distinct atom to avoid re-tokenizing each one.
+        token_cache = {}
+
+        def atom_token_count(atom):
+            if atom.isspace():
+                return 0
+            if atom not in token_cache:
+                token_cache[atom] = self._token_count(atom)
+            return token_cache[atom]
+
+        for atom in self._ATOM_RE.findall(block):
+            atom_tokens = atom_token_count(atom)
+            if current and current_tokens + atom_tokens > chunk_token_num:
+                pieces.append(current)
+                current = ""
+                current_tokens = 0
+            if atom_tokens > chunk_token_num and not atom.isspace():
+                # A single atom longer than the budget (e.g. a very long
+                # unbroken token): fall back to fixed character windows.
+                logging.debug(
+                    "html_parser: atom of %d chars exceeds chunk_token_num=%d; falling back to character windows",
+                    len(atom),
+                    chunk_token_num,
+                )
+                for i in range(0, len(atom), chunk_token_num):
+                    pieces.append(atom[i : i + chunk_token_num])
+                continue
+            current += atom
+            current_tokens += atom_tokens
+        if current:
+            pieces.append(current)
+        logging.debug(
+            "html_parser: split oversized block of %d chars into %d pieces",
+            len(block),
+            len(pieces),
+        )
+        return pieces
+
     def chunk_block(self, block_txt_list, chunk_token_num=512):
         chunks = []
         current_block = ""
         current_token_count = 0
 
         for block in block_txt_list:
-            tks_str = self.tokenizer.tokenize(block)
-            block_token_count = len(tks_str.split(" ")) if tks_str else 0
+            block_token_count = self._token_count(block)
             if block_token_count > chunk_token_num:
                 if current_block:
                     chunks.append(current_block)
-                start = 0
-                tokens = tks_str.split(" ")
-                while start < len(tokens):
-                    end = start + chunk_token_num
-                    split_tokens = tokens[start:end]
-                    chunks.append(" ".join(split_tokens))
-                    start = end
-                current_block = ""
-                current_token_count = 0
+                    current_block = ""
+                    current_token_count = 0
+                chunks.extend(self._split_oversized_block(block, chunk_token_num))
             else:
                 if current_token_count + block_token_count <= chunk_token_num:
                     current_block += ("\n" if current_block else "") + block
diff --git a/deepdoc/parser/markdown_parser.py b/deepdoc/parser/markdown_parser.py
index 900ef52..583e4ff 100644
--- a/deepdoc/parser/markdown_parser.py
+++ b/deepdoc/parser/markdown_parser.py
@@ -15,6 +15,7 @@
 #  limitations under the License.
 #
 
+import logging
 import re
 
 from markdown import markdown
@@ -56,7 +57,7 @@ def replace_tables_with_rendered_html(pattern, table_list, render=True):
             """,
                 re.VERBOSE,
             )
-            working_text = replace_tables_with_rendered_html(border_table_pattern, tables)
+            working_text = replace_tables_with_rendered_html(border_table_pattern, tables, render=separate_tables)
 
             # Borderless Markdown table
             no_border_table_pattern = re.compile(
@@ -68,7 +69,7 @@ def replace_tables_with_rendered_html(pattern, table_list, render=True):
                 """,
                 re.VERBOSE,
             )
-            working_text = replace_tables_with_rendered_html(no_border_table_pattern, tables)
+            working_text = replace_tables_with_rendered_html(no_border_table_pattern, tables, render=separate_tables)
 
         # Replace any TAGS e.g. <table ...> to <table>
         TAGS = ["table", "td", "tr", "th", "tbody", "thead", "div"]
@@ -132,6 +133,165 @@ def get_delimiters(self, delimiters):
         toks = sorted(set(toks), key=lambda x: -len(x))
         return "|".join(re.escape(t) for t in toks if t)
 
+    def _get_fence_marker(self, line):
+        match = re.match(r"^[ \t]{0,3}(?P<fence>`{3,}|~{3,})(?:.*)$", line)
+        if not match:
+            return None
+        fence = match.group("fence")
+        return fence[0], len(fence)
+
+    def _is_closing_fence(self, line, fence_char, fence_len):
+        pattern = r"^[ \t]{0,3}" + re.escape(fence_char) + r"{" + str(fence_len) + r",}\s*$"
+        return re.match(pattern, line) is not None
+
+    def _line_start_offsets(self, text):
+        offsets = []
+        offset = 0
+        for line in self.lines:
+            offsets.append(offset)
+            offset += len(line) + 1
+        return offsets
+
+    def _fenced_code_ranges(self, text):
+        ranges = []
+        line_offsets = self._line_start_offsets(text)
+
+        i = 0
+        while i < len(self.lines):
+            marker = self._get_fence_marker(self.lines[i])
+            if not marker:
+                i += 1
+                continue
+
+            fence_char, fence_len = marker
+            start_pos = line_offsets[i]
+            end_line = len(self.lines) - 1
+            for j in range(i + 1, len(self.lines)):
+                if self._is_closing_fence(self.lines[j], fence_char, fence_len):
+                    end_line = j
+                    break
+
+            end_pos = min(len(text), line_offsets[end_line] + len(self.lines[end_line]))
+            ranges.append((start_pos, end_pos))
+            i = end_line + 1
+
+        return ranges
+
+    def _table_cells(self, line):
+        stripped = line.strip()
+        if "|" not in stripped:
+            return []
+        if stripped.startswith("|"):
+            stripped = stripped[1:]
+        if stripped.endswith("|"):
+            stripped = stripped[:-1]
+        return [cell.strip() for cell in stripped.split("|")]
+
+    def _is_table_row(self, line):
+        cells = self._table_cells(line)
+        return len(cells) >= 2 and any(cell for cell in cells)
+
+    def _is_table_separator_row(self, line):
+        cells = self._table_cells(line)
+        return len(cells) >= 2 and all(re.match(r"^:?-+:?$", cell.replace(" ", "")) for cell in cells)
+
+    def _markdown_table_ranges(self, text):
+        ranges = []
+        line_offsets = self._line_start_offsets(text)
+
+        i = 0
+        while i < len(self.lines) - 1:
+            if not self._is_table_row(self.lines[i]) or not self._is_table_separator_row(self.lines[i + 1]):
+                i += 1
+                continue
+
+            end_line = i + 1
+            j = i + 2
+            while j < len(self.lines) and self._is_table_row(self.lines[j]):
+                end_line = j
+                j += 1
+
+            end_pos = min(len(text), line_offsets[end_line] + len(self.lines[end_line]))
+            ranges.append((line_offsets[i], end_pos))
+            i = end_line + 1
+
+        return ranges
+
+    def _html_table_ranges(self, text):
+        table_pattern = re.compile(
+            r"""
+            (?:
+                (?:<html[^>]*>\s*<body[^>]*>\s*<table[^>]*>.*?</table>\s*</body>\s*</html>)
+                |
+                (?:<body[^>]*>\s*<table[^>]*>.*?</table>\s*</body>)
+                |
+                (?:<table[^>]*>.*?</table>)
+            )
+            """,
+            re.VERBOSE | re.DOTALL | re.IGNORECASE,
+        )
+        return [(match.start(), match.end()) for match in table_pattern.finditer(text)]
+
+    def _merge_ranges(self, ranges):
+        if not ranges:
+            return []
+
+        merged = []
+        for start, end in sorted(ranges):
+            if not merged or start > merged[-1][1]:
+                merged.append((start, end))
+            else:
+                merged[-1] = (merged[-1][0], max(merged[-1][1], end))
+        return merged
+
+    def _protected_ranges(self, text):
+        return self._merge_ranges(self._fenced_code_ranges(text) + self._markdown_table_ranges(text) + self._html_table_ranges(text))
+
+    def _append_delimited_section(self, sections, text, start, end, include_meta):
+        part = text[start:end]
+        if not part or not part.strip():
+            return
+        if include_meta:
+            sections.append(
+                {
+                    "content": part.strip(),
+                    "start_line": text.count("\n", 0, start),
+                    "end_line": text.count("\n", 0, end),
+                }
+            )
+        else:
+            sections.append(part.strip())
+
+    def _extract_delimited_elements(self, text, delimiters, include_meta=False):
+        sections = []
+        pattern = re.compile(delimiters)
+        protected_ranges = self._protected_ranges(text)
+        if protected_ranges:
+            logging.debug("markdown_parser: detected %d protected ranges for delimiter extraction", len(protected_ranges))
+        protected_idx = 0
+        last_end = 0
+
+        for match in pattern.finditer(text):
+            while protected_idx < len(protected_ranges) and protected_ranges[protected_idx][1] <= match.start():
+                protected_idx += 1
+
+            if protected_idx < len(protected_ranges):
+                start, end = protected_ranges[protected_idx]
+                if start <= match.start() < end:
+                    logging.debug(
+                        "markdown_parser: skipped delimiter match at pos=%d delimiter=%r inside fenced range %s",
+                        match.start(),
+                        match.group(),
+                        (start, end),
+                    )
+                    continue
+
+            self._append_delimited_section(sections, text, last_end, match.start(), include_meta)
+            last_end = match.end()
+
+        self._append_delimited_section(sections, text, last_end, len(text), include_meta)
+        return sections
+
     def extract_elements(self, delimiter=None, include_meta=False):
         """Extract individual elements (headers, code blocks, lists, etc.)"""
         sections = []
@@ -142,34 +302,79 @@ def extract_elements(self, delimiter=None, include_meta=False):
             dels = self.get_delimiters(delimiter)
         if len(dels) > 0:
             text = "\n".join(self.lines)
-            if include_meta:
-                pattern = re.compile(dels)
-                last_end = 0
-                for m in pattern.finditer(text):
-                    part = text[last_end : m.start()]
-                    if part and part.strip():
-                        sections.append(
-                            {
-                                "content": part.strip(),
-                                "start_line": text.count("\n", 0, last_end),
-                                "end_line": text.count("\n", 0, m.start()),
-                            }
-                        )
-                    last_end = m.end()
-
-                part = text[last_end:]
-                if part and part.strip():
-                    sections.append(
-                        {
-                            "content": part.strip(),
-                            "start_line": text.count("\n", 0, last_end),
-                            "end_line": text.count("\n", 0, len(text)),
-                        }
-                    )
-            else:
-                parts = re.split(dels, text)
-                sections = [p.strip() for p in parts if p and p.strip()]
-            return sections
+            sections = self._extract_delimited_elements(text, dels, include_meta)
+
+            # Attach lone header lines to the section that follows them so that
+            # "## Title\n" never becomes an isolated chunk when the delimiter
+            # splits at every newline.  A header is "lone" when it occupies a
+            # single line (no embedded newline after stripping).
+            def _is_lone_header(section_content):
+                stripped = section_content.strip()
+                return bool(re.match(r"^#{1,6}\s+\S", stripped)) and "\n" not in stripped
+
+            def _is_attachable_body(section_content):
+                """True when the following chunk is prose body, not code/table/list/etc."""
+                stripped = section_content.strip()
+                if not stripped:
+                    return False
+                first_line = stripped.split("\n", 1)[0]
+                if self._get_fence_marker(first_line):
+                    return False
+                if first_line.lstrip().startswith("|"):
+                    return False
+                if re.match(r"^\S+\s*\|", first_line):
+                    return False
+                if first_line.lstrip().startswith("<"):
+                    return False
+                if re.match(r"^\s*[-*+]\s+", first_line) or re.match(r"^\s*\d+\.\s+", first_line):
+                    return False
+                if first_line.lstrip().startswith(">"):
+                    return False
+                return True
+
+            merged = []
+            merged_header_count = 0
+            i = 0
+            while i < len(sections):
+                content = sections[i]["content"] if include_meta else sections[i]
+                if _is_lone_header(content):
+                    header_parts = [content.strip()]
+                    j = i + 1
+                    while j < len(sections):
+                        next_content = sections[j]["content"] if include_meta else sections[j]
+                        if not _is_lone_header(next_content):
+                            break
+                        header_parts.append(next_content.strip())
+                        j += 1
+                    if j < len(sections):
+                        body_content = sections[j]["content"] if include_meta else sections[j]
+                        if _is_attachable_body(body_content):
+                            combined = "\n".join(header_parts) + "\n" + body_content
+                            if include_meta:
+                                merged.append(
+                                    {
+                                        **sections[i],
+                                        "content": combined,
+                                        "end_line": sections[j]["end_line"],
+                                    }
+                                )
+                            else:
+                                merged.append(combined)
+                            merged_header_count += len(header_parts)
+                            i = j + 1
+                            continue
+                    for k in range(i, j):
+                        merged.append(sections[k])
+                    i = j
+                    continue
+                merged.append(sections[i])
+                i += 1
+            if merged_header_count:
+                logging.debug(
+                    "markdown_parser: merged %d lone header line(s) into following sections",
+                    merged_header_count,
+                )
+            return merged
         while i < len(self.lines):
             line = self.lines[i]
 
@@ -178,7 +383,7 @@ def extract_elements(self, delimiter=None, include_meta=False):
                 element = self._extract_header(i)
                 sections.append(element if include_meta else element["content"])
                 i = element["end_line"] + 1
-            elif line.strip().startswith("```"):
+            elif self._get_fence_marker(line):
                 # code block
                 element = self._extract_code_block(i)
                 sections.append(element if include_meta else element["content"])
@@ -218,12 +423,13 @@ def _extract_header(self, start_pos):
     def _extract_code_block(self, start_pos):
         end_pos = start_pos
         content_lines = [self.lines[start_pos]]
+        fence_char, fence_len = self._get_fence_marker(self.lines[start_pos])
 
         # Find the end of the code block
         for i in range(start_pos + 1, len(self.lines)):
             content_lines.append(self.lines[i])
             end_pos = i
-            if self.lines[i].strip().startswith("```"):
+            if self._is_closing_fence(self.lines[i], fence_char, fence_len):
                 break
 
         return {
@@ -292,13 +498,13 @@ def _extract_text_block(self, start_pos):
         while i < len(self.lines):
             line = self.lines[i]
             # stop if we encounter a block element
-            if re.match(r"^#{1,6}\s+.*$", line) or line.strip().startswith("```") or re.match(r"^\s*[-*+]\s+.*$", line) or re.match(r"^\s*\d+\.\s+.*$", line) or line.strip().startswith(">"):
+            if re.match(r"^#{1,6}\s+.*$", line) or self._get_fence_marker(line) or re.match(r"^\s*[-*+]\s+.*$", line) or re.match(r"^\s*\d+\.\s+.*$", line) or line.strip().startswith(">"):
                 break
             elif not line.strip():
                 # check if the next line is a block element
                 if i + 1 < len(self.lines) and (
                     re.match(r"^#{1,6}\s+.*$", self.lines[i + 1])
-                    or self.lines[i + 1].strip().startswith("```")
+                    or self._get_fence_marker(self.lines[i + 1])
                     or re.match(r"^\s*[-*+]\s+.*$", self.lines[i + 1])
                     or re.match(r"^\s*\d+\.\s+.*$", self.lines[i + 1])
                     or self.lines[i + 1].strip().startswith(">")
diff --git a/deepdoc/parser/mineru_parser.py b/deepdoc/parser/mineru_parser.py
index aba237d..f77fc18 100644
--- a/deepdoc/parser/mineru_parser.py
+++ b/deepdoc/parser/mineru_parser.py
@@ -17,6 +17,7 @@
 import logging
 import os
 import re
+import shutil
 import sys
 import tempfile
 import threading
@@ -138,39 +139,58 @@ def __init__(self, mineru_path: str = "mineru", mineru_api: str = "", mineru_ser
         self.outlines = []
         self.logger = logging.getLogger(self.__class__.__name__)
 
+    @staticmethod
+    def _is_zipinfo_symlink(member: zipfile.ZipInfo) -> bool:
+        return (member.external_attr >> 16) & 0o170000 == 0o120000
+
     def _extract_zip_no_root(self, zip_path, extract_to, root_dir):
         self.logger.info(f"[MinerU] Extract zip: zip_path={zip_path}, extract_to={extract_to}, root_hint={root_dir}")
+        base_dir = Path(extract_to).resolve()
         with zipfile.ZipFile(zip_path, "r") as zip_ref:
+            members = zip_ref.infolist()
             if not root_dir:
-                files = zip_ref.namelist()
-                if files and files[0].endswith("/"):
-                    root_dir = files[0]
+                if members and members[0].filename.endswith("/"):
+                    root_dir = members[0].filename
                 else:
                     root_dir = None
-
-            if not root_dir or not root_dir.endswith("/"):
-                self.logger.info(f"[MinerU] No root directory found, extracting all (root_hint={root_dir})")
-                zip_ref.extractall(extract_to)
-                return
-
-            root_len = len(root_dir)
-            for member in zip_ref.infolist():
-                filename = member.filename
-                if filename == root_dir:
+            if root_dir:
+                root_dir = root_dir.replace("\\", "/")
+                if not root_dir.endswith("/"):
+                    root_dir += "/"
+
+            for member in members:
+                if member.flag_bits & 0x1:
+                    raise RuntimeError(f"[MinerU] Encrypted zip entry not supported: {member.filename}")
+                if self._is_zipinfo_symlink(member):
+                    raise RuntimeError(f"[MinerU] Symlink zip entry not supported: {member.filename}")
+
+                name = member.filename.replace("\\", "/")
+                if root_dir and name == root_dir:
                     self.logger.info("[MinerU] Ignore root folder...")
                     continue
+                if root_dir and name.startswith(root_dir):
+                    name = name[len(root_dir) :]
+                if not name:
+                    continue
+                if name.startswith("/") or name.startswith("//") or re.match(r"^[A-Za-z]:", name):
+                    raise RuntimeError(f"[MinerU] Unsafe zip path (absolute): {member.filename}")
 
-                path = filename
-                if path.startswith(root_dir):
-                    path = path[root_len:]
+                parts = [p for p in name.split("/") if p not in ("", ".")]
+                if any(p == ".." for p in parts):
+                    raise RuntimeError(f"[MinerU] Unsafe zip path (traversal): {member.filename}")
+
+                rel_path = os.path.join(*parts) if parts else ""
+                dest_path = (Path(extract_to) / rel_path).resolve(strict=False)
+                if dest_path != base_dir and base_dir not in dest_path.parents:
+                    raise RuntimeError(f"[MinerU] Unsafe zip path (escape): {member.filename}")
 
-                full_path = os.path.join(extract_to, path)
                 if member.is_dir():
-                    os.makedirs(full_path, exist_ok=True)
-                else:
-                    os.makedirs(os.path.dirname(full_path), exist_ok=True)
-                    with open(full_path, "wb") as f:
-                        f.write(zip_ref.read(filename))
+                    os.makedirs(dest_path, exist_ok=True)
+                    continue
+
+                os.makedirs(dest_path.parent, exist_ok=True)
+                with zip_ref.open(member) as src, open(dest_path, "wb") as dst:
+                    shutil.copyfileobj(src, dst)
 
     @staticmethod
     def _is_http_endpoint_valid(url, timeout=5):
diff --git a/deepdoc/parser/pdf_parser.py b/deepdoc/parser/pdf_parser.py
index f1bb0d9..7d31d04 100644
--- a/deepdoc/parser/pdf_parser.py
+++ b/deepdoc/parser/pdf_parser.py
@@ -23,6 +23,7 @@
 import re
 import sys
 import threading
+import unicodedata
 from collections import Counter, defaultdict
 from copy import deepcopy
 from io import BytesIO
@@ -47,6 +48,10 @@
 if LOCK_KEY_pdfplumber not in sys.modules:
     sys.modules[LOCK_KEY_pdfplumber] = threading.Lock()
 
+# Parsing layer uses MAXIMUM_PAGE_NUMBER as the "no explicit limit" sentinel
+# so large PDFs (>300 pages) are no longer silently truncated.
+MAXIMUM_PAGE_NUMBER = 100000
+
 
 class RAGFlowPdfParser:
     def __init__(
@@ -307,6 +312,180 @@ def gather(kwd, fzy=10, ption=0.6):
                 b["H_right"] = spans[ii]["x1"]
                 b["SP"] = ii
 
+    # CID pattern regex for unmapped font characters from pdfminer
+    _CID_PATTERN = re.compile(r"\(cid\s*:\s*\d+\s*\)")
+
+    _OCR_ALPHABET = None
+
+    def _ocr_can_represent(self, text, min_coverage=0.8):
+        """True if the OCR recogniser's alphabet covers this text well enough to be worth OCRing."""
+        if not text:
+            return True
+        cls = RAGFlowPdfParser
+        if cls._OCR_ALPHABET is None:
+            model_cfg = getattr(self, "model_cfg", None)
+            if model_cfg is None:
+                return True  # unknown alphabet: preserve existing behaviour
+            res = os.path.join(model_cfg.resolve_vision_model_dir(), "ocr.res")
+            try:
+                with open(res, encoding="utf-8") as f:
+                    cls._OCR_ALPHABET = set(f.read())
+            except (OSError, UnicodeDecodeError) as e:
+                logging.warning("Could not load OCR alphabet from %s: %s; treating all text as representable.", res, e)
+                cls._OCR_ALPHABET = set()
+        if not cls._OCR_ALPHABET:
+            return True  # unknown alphabet: preserve existing behaviour
+        letters = [c for c in text if c.strip()]
+        if not letters:
+            return True
+        covered = sum(1 for c in letters if c in cls._OCR_ALPHABET)
+        return covered / len(letters) >= min_coverage
+
+    # CJK scripts (Han, Hiragana, Katakana, Hangul) do not separate words with
+    # spaces, so a geometric gap between their glyphs must not become one.
+    _CJK_PATTERN = re.compile(r"[ᄀ-ᇿ぀-ヿ㄰-㆏㐀-䶿一-鿿가-힯豈-﫿]|[\U00020000-\U0002fa1f]")
+
+    @classmethod
+    def _insert_word_spaces(cls, chars, gap_ratio=0.25):
+        """Recover missing spaces from character geometry.
+
+        Many PDFs encode no space glyphs and separate words by positioning alone.
+        Append a space to a char when the gap to the next exceeds ``gap_ratio`` of
+        the mean char width; intra-word kerns fall well below that. CJK is skipped:
+        it does not write inter-word spaces, so a gap between CJK glyphs is ordinary
+        tracking, not a boundary. ``chars`` is a list of pdfplumber-style dicts and
+        is mutated in place.
+        """
+        widths = [c["width"] for c in chars if c["text"] and c["text"].strip()]
+        mean_w = sum(widths) / len(widths) if widths else 0
+        if mean_w <= 0:
+            return
+        for cur, nxt in zip(chars, chars[1:]):
+            if (
+                cur["text"]
+                and nxt["text"]
+                and cur["text"].strip()
+                and nxt["text"].strip()
+                and not cls._CJK_PATTERN.search(cur["text"])
+                and not cls._CJK_PATTERN.search(nxt["text"])
+                and nxt["x0"] - cur["x1"] > mean_w * gap_ratio
+            ):
+                cur["text"] += " "
+
+    @staticmethod
+    def _is_garbled_char(ch):
+        """Check if a single character is garbled (unmappable from PDF font encoding).
+
+        A character is considered garbled if it falls into Unicode Private Use Areas
+        or certain replacement/control character ranges that typically indicate
+        pdfminer failed to map a CID to a valid Unicode codepoint.
+        """
+        if not ch:
+            return False
+        cp = ord(ch)
+        if 0xE000 <= cp <= 0xF8FF:
+            return True
+        if 0xF0000 <= cp <= 0xFFFFF:
+            return True
+        if 0x100000 <= cp <= 0x10FFFF:
+            return True
+        if cp == 0xFFFD:
+            return True
+        if cp < 0x20 and ch not in ("\t", "\n", "\r"):
+            return True
+        if 0x80 <= cp <= 0x9F:
+            return True
+        cat = unicodedata.category(ch)
+        if cat in ("Cn", "Cs"):
+            return True
+        return False
+
+    @staticmethod
+    def _is_garbled_text(text, threshold=0.5):
+        """Check if a text string contains too many garbled characters.
+
+        Examines each character and determines if the overall proportion
+        of garbled characters exceeds the given threshold. Also detects
+        pdfminer's CID placeholder patterns like '(cid:123)'.
+        """
+        if not text or not text.strip():
+            return False
+        if RAGFlowPdfParser._CID_PATTERN.search(text):
+            return True
+        garbled_count = 0
+        total = 0
+        for ch in text:
+            if ch.isspace():
+                continue
+            total += 1
+            if RAGFlowPdfParser._is_garbled_char(ch):
+                garbled_count += 1
+        if total == 0:
+            return False
+        return garbled_count / total >= threshold
+
+    @staticmethod
+    def _has_subset_font_prefix(fontname):
+        """Check if a font name has a subset prefix (e.g. 'DY1+ZLQDm1-1').
+
+        PDF subset fonts use a 6-letter uppercase tag followed by '+' before
+        the actual font name. Some tools use shorter tags (e.g. 'DY1+').
+        """
+        if not fontname:
+            return False
+        return bool(re.match(r"^[A-Z0-9]{2,6}\+", fontname))
+
+    @staticmethod
+    def _is_garbled_by_font_encoding(page_chars, min_chars=20):
+        """Detect garbled text caused by broken font encoding mappings.
+
+        Some PDFs (especially older Chinese standards) embed custom fonts that
+        map CJK glyphs to ASCII codepoints. The extracted text appears as
+        random ASCII punctuation/symbols instead of actual CJK characters.
+
+        Detection strategy: if a significant proportion of characters come from
+        subset-embedded fonts and the page produces overwhelmingly ASCII
+        (punctuation, digits, symbols) with virtually no CJK/Hangul/Kana
+        characters, the page is likely garbled due to broken font encoding.
+        """
+        if not page_chars or len(page_chars) < min_chars:
+            return False
+
+        subset_font_count = 0
+        total_non_space = 0
+        ascii_punct_sym = 0
+        cjk_like = 0
+
+        for c in page_chars:
+            text = c.get("text", "")
+            fontname = c.get("fontname", "")
+            if not text or text.isspace():
+                continue
+            total_non_space += 1
+
+            if RAGFlowPdfParser._has_subset_font_prefix(fontname):
+                subset_font_count += 1
+
+            cp = ord(text[0])
+            if 0x2E80 <= cp <= 0x9FFF or 0xF900 <= cp <= 0xFAFF or 0x20000 <= cp <= 0x2FA1F or 0xAC00 <= cp <= 0xD7AF or 0x3040 <= cp <= 0x30FF:
+                cjk_like += 1
+            elif 0x21 <= cp <= 0x2F or 0x3A <= cp <= 0x40 or 0x5B <= cp <= 0x60 or 0x7B <= cp <= 0x7E:
+                ascii_punct_sym += 1
+
+        if total_non_space < min_chars:
+            return False
+
+        subset_ratio = subset_font_count / total_non_space
+        if subset_ratio < 0.3:
+            return False
+
+        cjk_ratio = cjk_like / total_non_space
+        punct_ratio = ascii_punct_sym / total_non_space
+        if cjk_ratio < 0.05 and punct_ratio > 0.4:
+            return True
+
+        return False
+
     def __ocr(self, pagenum, img, chars, ZM=3, device_id: int | None = None):
         start = timer()
         bxs = self.ocr.detect(np.array(img), device_id)
@@ -343,21 +522,62 @@ def __ocr(self, pagenum, img, chars, ZM=3, device_id: int | None = None):
             if not b["chars"]:
                 del b["chars"]
                 continue
-            m_ht = np.mean([c["height"] for c in b["chars"]])
-            for c in Recognizer.sort_Y_firstly(b["chars"], m_ht):
+            box_chars = b["chars"]
+            m_ht = np.mean([c["height"] for c in box_chars])
+            garbled_count = 0
+            total_count = 0
+            for c in Recognizer.sort_Y_firstly(box_chars, m_ht):
                 if c["text"] == " " and b["text"]:
                     if re.match(r"[0-9a-zA-Zа-яА-Я,.?;:!%%]", b["text"][-1]):
                         b["text"] += " "
                 else:
                     b["text"] += c["text"]
+                    for ch in c["text"]:
+                        if not ch.isspace():
+                            total_count += 1
+                            if self._is_garbled_char(ch):
+                                garbled_count += 1
             del b["chars"]
 
+            # Strategy 1: PUA / unmapped CID characters. These are genuine garbage,
+            # so re-OCR regardless of script.
+            if total_count > 0 and garbled_count / total_count >= 0.5:
+                logging.info(
+                    "Page %d: detected garbled pdfplumber text (garbled=%d/%d), falling back to OCR for box at (%.1f, %.1f)",
+                    pagenum,
+                    garbled_count,
+                    total_count,
+                    b["x0"],
+                    b["top"],
+                )
+                b["text"] = ""
+                continue
+
+            # Keep a clean text layer the recogniser cannot spell: ocr.res is
+            # CJK+Latin, so re-OCRing e.g. a Cyrillic page only produces garbage.
+            if total_count > 0 and not self._ocr_can_represent(b["text"]):
+                continue
+
+            # Strategy 2: font-encoding garbling — all chars are ASCII
+            # punctuation from subset fonts (no CJK output)
+            if total_count > 0 and self._is_garbled_by_font_encoding(box_chars, min_chars=5):
+                logging.info(
+                    "Page %d: detected font-encoding garbled text (%d chars), falling back to OCR for box at (%.1f, %.1f)",
+                    pagenum,
+                    total_count,
+                    b["x0"],
+                    b["top"],
+                )
+                b["text"] = ""
+
         logging.info(f"__ocr sorting {len(chars)} chars cost {timer() - start}s")
         start = timer()
         boxes_to_reg = []
-        img_np = np.array(img)
+        img_np = None
         for b in bxs:
             if not b["text"]:
+                if img_np is None:
+                    img_np = np.asarray(img)
                 left, right, top, bott = b["x0"] * ZM, b["x1"] * ZM, b["top"] * ZM, b["bottom"] * ZM
                 b["box_image"] = self.ocr.get_rotate_crop_image(img_np, np.array([[left, top], [right, top], [right, bott], [left, bott]], dtype=np.float32))
                 boxes_to_reg.append(b)
@@ -882,7 +1102,30 @@ def nearest(tbls):
 
         def cropout(bxs, ltype, poss):
             nonlocal ZM
-            pn = set([b["page_number"] - 1 for b in bxs])
+            max_page_index = len(self.page_images) - 1
+
+            def local_page_index(page_number):
+                idx = page_number - 1 if page_number > 0 else 0
+                if idx > max_page_index and self.page_from:
+                    idx = page_number - 1 - self.page_from
+                return idx
+
+            pn = set()
+            for b in bxs:
+                idx = local_page_index(b["page_number"])
+                if 0 <= idx <= max_page_index:
+                    pn.add(idx)
+                else:
+                    logging.warning(
+                        "Skip out-of-range page_number %s (page_from=%s, pages=%s)",
+                        b.get("page_number"),
+                        self.page_from,
+                        len(self.page_images),
+                    )
+
+            if not pn:
+                return None
+
             if len(pn) < 2:
                 pn = list(pn)[0]
                 ht = self.page_cum_height[pn]
@@ -914,12 +1157,16 @@ def cropout(bxs, ltype, poss):
                     return None
             pn = {}
             for b in bxs:
-                p = b["page_number"] - 1
-                if p not in pn:
-                    pn[p] = []
-                pn[p].append(b)
+                p = local_page_index(b["page_number"])
+                if 0 <= p <= max_page_index:
+                    if p not in pn:
+                        pn[p] = []
+                    pn[p].append(b)
             pn = sorted(pn.items(), key=lambda x: x[0])
             imgs = [cropout(arr, ltype, poss) for p, arr in pn]
+            imgs = [img for img in imgs if img is not None]
+            if not imgs:
+                return None
             pic = Image.new("RGB", (int(np.max([i.size[0] for i in imgs])), int(np.sum([m.size[1] for m in imgs]))), (245, 245, 245))
             height = 0
             for img in imgs:
@@ -963,7 +1210,10 @@ def cropout(bxs, ltype, poss):
 
             poss = []
 
-            res.append((cropout(bxs, "table", poss), self.tbl_det.construct_table(bxs, html=return_html, is_english=self.is_english)))
+            img = cropout(bxs, "table", poss)
+            if img is None:
+                continue
+            res.append((img, self.tbl_det.construct_table(bxs, html=return_html, is_english=self.is_english)))
             positions.append(poss)
 
         if separate_tables_figures:
@@ -1089,7 +1339,7 @@ def total_page_number(fnm, binary=None):
         except Exception:
             logging.exception("total_page_number")
 
-    def __images__(self, fnm, zoomin=3, page_from=0, page_to=299, callback=None):
+    def __images__(self, fnm, zoomin=3, page_from=0, page_to=MAXIMUM_PAGE_NUMBER, callback=None):
         self.lefted_chars = []
         self.mean_height = []
         self.mean_width = []
@@ -1109,7 +1359,35 @@ def __images__(self, fnm, zoomin=3, page_from=0, page_to=299, callback=None):
                         self.page_chars = [[c for c in page.dedupe_chars().chars if self._has_color(c)] for page in self.pdf.pages[page_from:page_to]]
                     except Exception as e:
                         logging.warning(f"Failed to extract characters for pages {page_from}-{page_to}: {str(e)}")
-                        self.page_chars = [[] for _ in range(page_to - page_from)]  # If failed to extract, using empty list instead.
+                        self.page_chars = [[] for _ in range(len(self.page_images))]  # If failed to extract, using empty list instead.
+
+                    # Detect garbled pages and clear their chars so the OCR
+                    # path will be used instead. Two detection strategies:
+                    # 1) PUA / unmapped CID characters (threshold=0.3)
+                    # 2) Font-encoding garbling: subset fonts mapping CJK to ASCII
+                    for pi, page_ch in enumerate(self.page_chars):
+                        if not page_ch:
+                            continue
+                        # Strategy 1: PUA / CID garbling
+                        sample = page_ch if len(page_ch) <= 200 else page_ch[:200]
+                        sample_text = "".join(c.get("text", "") for c in sample)
+                        if self._is_garbled_text(sample_text, threshold=0.3):
+                            logging.warning(
+                                "Page %d: pdfplumber extracted mostly garbled characters (%d chars), clearing to use OCR fallback.",
+                                page_from + pi + 1,
+                                len(page_ch),
+                            )
+                            self.page_chars[pi] = []
+                            continue
+
+                        # Strategy 2: font-encoding garbling (CJK mapped to ASCII)
+                        if self._is_garbled_by_font_encoding(page_ch):
+                            logging.warning(
+                                "Page %d: detected font-encoding garbled text (subset fonts with no CJK output, %d chars), clearing to use OCR fallback.",
+                                page_from + pi + 1,
+                                len(page_ch),
+                            )
+                            self.page_chars[pi] = []
 
                     self.total_page = len(self.pdf.pages)
 
@@ -1150,16 +1428,7 @@ def dfs(arr, depth):
             self.is_english = False
 
         async def __img_ocr(i, id, img, chars, limiter):
-            j = 0
-            while j + 1 < len(chars):
-                if (
-                    chars[j]["text"]
-                    and chars[j + 1]["text"]
-                    and re.match(r"[0-9a-zA-Z,.:;!%]+", chars[j]["text"] + chars[j + 1]["text"])
-                    and chars[j + 1]["x0"] - chars[j]["x1"] >= min(chars[j + 1]["width"], chars[j]["width"]) / 2
-                ):
-                    chars[j]["text"] += " "
-                j += 1
+            self._insert_word_spaces(chars)
 
             if limiter:
                 async with limiter:
@@ -1267,12 +1536,49 @@ def __call__(self, fnm, need_image=True, zoomin=3, return_html=False):
         tbls = self._extract_table_figure(need_image, zoomin, return_html, False)
         return self.__filterout_scraps(deepcopy(self.boxes), zoomin), tbls
 
-    def parse_into_bboxes(self, fnm, callback=None, zoomin=3):
-        start = timer()
-        self.__images__(fnm, zoomin, callback=callback)
-        if callback:
-            callback(0.40, "OCR finished ({:.2f}s)".format(timer() - start))
+    def parse_into_bboxes(self, fnm, callback=None, zoomin=3, from_page=0, to_page=MAXIMUM_PAGE_NUMBER):
+        batch_size = max(1, int(os.getenv("PDF_PARSER_PAGE_BATCH_SIZE", "50")))
+        if isinstance(fnm, str):
+            total_pages = self.total_page_number(fnm)
+        else:
+            total_pages = self.total_page_number(fnm, binary=fnm)
 
+        if total_pages is None:
+            effective_to_page = to_page
+            logging.warning(
+                "parse_into_bboxes: total_page_number returned None; using caller-supplied to_page=%s",
+                to_page,
+            )
+        else:
+            effective_to_page = min(to_page, total_pages)
+
+        if effective_to_page - from_page <= batch_size:
+            start = timer()
+            self.__images__(fnm, zoomin, page_from=from_page, page_to=effective_to_page, callback=callback)
+            if callback:
+                callback(0.40, "OCR finished ({:.2f}s)".format(timer() - start))
+            return self._parse_loaded_window_into_bboxes(zoomin, callback=callback)
+
+        logging.info(
+            "parse_into_bboxes uses chunk mode: from_page=%s, effective_to_page=%s, batch_size=%s",
+            from_page,
+            effective_to_page,
+            batch_size,
+        )
+        all_boxes = []
+        start = timer()
+        for page_from in range(from_page, effective_to_page, batch_size):
+            page_to = min(page_from + batch_size, effective_to_page)
+            self.__images__(fnm, zoomin, page_from=page_from, page_to=page_to, callback=None)
+            chunk_boxes = self._parse_loaded_window_into_bboxes(zoomin)
+            all_boxes.extend(self._to_global_boxes(chunk_boxes))
+            if callback:
+                callback((page_to - from_page) / max(1, effective_to_page - from_page), f"Structured: {page_to}/{effective_to_page} pages")
+
+        logging.info("parse_into_bboxes chunk mode cost %.2fs", timer() - start)
+        return all_boxes
+
+    def _parse_loaded_window_into_bboxes(self, zoomin=3, callback=None):
         start = timer()
         self._layouts_rec(zoomin)
         if callback:
@@ -1314,19 +1620,37 @@ def min_rectangle_distance(rect1, rect2):
                 return math.sqrt(dx * dx + dy * dy)  # + (pn2-pn1)*10000
 
             for (img, txt), poss in tbls_or_figs:
-                bboxes = [(i, (b["page_number"], b["x0"], b["x1"], b["top"], b["bottom"])) for i, b in enumerate(self.boxes)]
-                dists = [
-                    (min_rectangle_distance((pn, left, right, top + self.page_cum_height[pn], bott + self.page_cum_height[pn]), rect), i) for i, rect in bboxes for pn, left, right, top, bott in poss
-                ]
-                min_i = np.argmin(dists, axis=0)[0]
-                min_i, rect = bboxes[dists[min_i][-1]]
+                local_poss = []
+                for pn, left, right, top, bott in poss:
+                    local_pn = pn - self.page_from
+                    if 0 <= local_pn < len(self.page_cum_height) - 1:
+                        local_poss.append((local_pn, left, right, top, bott))
+                    else:
+                        logging.debug(f"Skip out-of-range table/figure position pn={pn}, page_from={self.page_from}")
+                if not local_poss:
+                    logging.debug("No valid local positions for table/figure; skip insertion.")
+                    continue
+
                 if isinstance(txt, list):
                     txt = "\n".join(txt)
-                pn, left, right, top, bott = poss[0]
-                if self.boxes[min_i]["bottom"] < top + self.page_cum_height[pn]:
-                    min_i += 1
+                pn, left, right, top, bott = local_poss[0]
+                insert_at = len(self.boxes)
+                bboxes = [(i, (b["page_number"], b["x0"], b["x1"], b["top"], b["bottom"])) for i, b in enumerate(self.boxes)]
+                if bboxes:
+                    dists = [
+                        (min_rectangle_distance((cand_pn, cand_left, cand_right, cand_top + self.page_cum_height[cand_pn], cand_bott + self.page_cum_height[cand_pn]), rect), i)
+                        for i, rect in bboxes
+                        for cand_pn, cand_left, cand_right, cand_top, cand_bott in local_poss
+                    ]
+                    if dists:
+                        nearest_bbox_idx = int(np.argmin([dist for dist, _ in dists]))
+                        insert_at, _ = bboxes[dists[nearest_bbox_idx][-1]]
+                        if self.boxes[insert_at]["bottom"] < top + self.page_cum_height[pn]:
+                            insert_at += 1
+                else:
+                    logging.debug("No text boxes available; append %s block directly.", layout_type)
                 self.boxes.insert(
-                    min_i,
+                    insert_at,
                     {
                         "page_number": pn + 1,
                         "x0": left,
@@ -1351,6 +1675,29 @@ def min_rectangle_distance(rect1, rect2):
             callback(1, "Structured ({:.2f}s)".format(timer() - start))
         return deepcopy(self.boxes)
 
+    @staticmethod
+    def _offset_position_tag(text, page_offset):
+        if not text or page_offset <= 0:
+            return text
+
+        def _replace(match):
+            pages = [str(int(p) + page_offset) for p in match.group(1).split("-")]
+            return f"@@{'-'.join(pages)}\t"
+
+        return re.sub(r"@@([0-9-]+)\t", _replace, text)
+
+    def _to_global_boxes(self, boxes):
+        if self.page_from <= 0:
+            return boxes
+
+        for box in boxes:
+            box["page_number"] = int(box.get("page_number", 1)) + self.page_from
+            if isinstance(box.get("position_tag"), str):
+                box["position_tag"] = self._offset_position_tag(box["position_tag"], self.page_from)
+            if isinstance(box.get("positions"), list):
+                box["positions"] = [[int(pos[0]) + self.page_from, *pos[1:]] if isinstance(pos, list) and len(pos) > 0 and isinstance(pos[0], (int, float)) else pos for pos in box["positions"]]
+        return boxes
+
     @staticmethod
     def remove_tag(txt):
         return re.sub(r"@@[\t0-9.-]+?##", "", txt)
@@ -1493,7 +1840,7 @@ class PlainParser:
     def __init__(self):
         pass
 
-    def __call__(self, filename, from_page=0, to_page=100000, **kwargs):
+    def __call__(self, filename, from_page=0, to_page=MAXIMUM_PAGE_NUMBER, **kwargs):
         self.outlines = []
         lines = []
         try:
@@ -1538,7 +1885,7 @@ def __init__(
         self.outlines = []
 
 
-    def __images__(self, fnm, zoomin=3, page_from=0, page_to=299, callback=None):
+    def __images__(self, fnm, zoomin=3, page_from=0, page_to=MAXIMUM_PAGE_NUMBER, callback=None):
         try:
             with sys.modules[LOCK_KEY_pdfplumber]:
                 self.pdf = pdfplumber.open(fnm) if isinstance(fnm, str) else pdfplumber.open(BytesIO(fnm))
@@ -1549,7 +1896,7 @@ def __images__(self, fnm, zoomin=3, page_from=0, page_to=299, callback=None):
             self.total_page = 0
             logging.exception("VisionParser __images__")
 
-    def __call__(self, filename, from_page=0, to_page=100000, **kwargs):
+    def __call__(self, filename, from_page=0, to_page=MAXIMUM_PAGE_NUMBER, **kwargs):
         callback = kwargs.get("callback", lambda prog, msg: None)
         zoomin = kwargs.get("zoomin", 3)
         self.__images__(fnm=filename, zoomin=zoomin, page_from=from_page, page_to=to_page, callback=callback)
@@ -1562,11 +1909,11 @@ def __call__(self, filename, from_page=0, to_page=100000, **kwargs):
         all_docs = []
 
         for idx, img_binary in enumerate(self.page_images or []):
-            pdf_page_num = idx  # 0-based
+            pdf_page_num = from_page + idx  # 0-based
             if pdf_page_num < start_page or pdf_page_num >= end_page:
                 continue
 
-            from .llm_adapter.vision import vision_llm_chunk as picture_vision_llm_chunk
+            from ..llm_adapter.vision import vision_llm_chunk as picture_vision_llm_chunk
 
             text = picture_vision_llm_chunk(
                 binary=img_binary,
diff --git a/deepdoc/parser/ppt_parser.py b/deepdoc/parser/ppt_parser.py
index 1b04b4d..486d818 100644
--- a/deepdoc/parser/ppt_parser.py
+++ b/deepdoc/parser/ppt_parser.py
@@ -22,6 +22,13 @@
 class RAGFlowPptParser:
     def __init__(self):
         super().__init__()
+        self._shape_cache = {}
+
+    def __sort_shapes(self, shapes):
+        cache_key = id(shapes)
+        if cache_key not in self._shape_cache:
+            self._shape_cache[cache_key] = sorted(shapes, key=lambda x: ((x.top if x.top is not None else 0) // 10, x.left if x.left is not None else 0))
+        return self._shape_cache[cache_key]
 
     def __get_bulleted_text(self, paragraph):
         is_bulleted = bool(paragraph._p.xpath("./a:pPr/a:buChar")) or bool(paragraph._p.xpath("./a:pPr/a:buAutoNum")) or bool(paragraph._p.xpath("./a:pPr/a:buBlip"))
@@ -62,7 +69,7 @@ def __extract(self, shape):
             # Handle group shape
             if shape_type == 6:
                 texts = []
-                for p in sorted(shape.shapes, key=lambda x: (x.top // 10, x.left)):
+                for p in self.__sort_shapes(shape.shapes):
                     t = self.__extract(p)
                     if t:
                         texts.append(t)
@@ -86,8 +93,7 @@ def __call__(self, fnm, from_page, to_page, callback=None):
             if i >= to_page:
                 break
             texts = []
-            for shape in sorted(
-                    slide.shapes, key=lambda x: ((x.top if x.top is not None else 0) // 10, x.left if x.left is not None else 0)):
+            for shape in self.__sort_shapes(slide.shapes):
                 txt = self.__extract(shape)
                 if txt:
                     texts.append(txt)
diff --git a/deepdoc/parser/tcadp_parser.py b/deepdoc/parser/tcadp_parser.py
index 60d2788..a63a450 100644
--- a/deepdoc/parser/tcadp_parser.py
+++ b/deepdoc/parser/tcadp_parser.py
@@ -17,6 +17,7 @@
 import json
 import logging
 import os
+import re
 import shutil
 import tempfile
 import time
@@ -169,9 +170,6 @@ def download_result_file(self, download_url, output_dir):
             return None
 
         try:
-            response = requests.get(download_url)
-            response.raise_for_status()
-
             # Ensure output directory exists
             os.makedirs(output_dir, exist_ok=True)
 
@@ -180,15 +178,22 @@ def download_result_file(self, download_url, output_dir):
             filename = f"tcadp_result_{timestamp}.zip"
             file_path = os.path.join(output_dir, filename)
 
-            # Save file
-            with open(file_path, "wb") as f:
-                f.write(response.content)
+            with requests.get(download_url, stream=True) as response:
+                response.raise_for_status()
+                with open(file_path, "wb") as f:
+                    response.raw.decode_content = True
+                    shutil.copyfileobj(response.raw, f)
 
             logging.info(f"[TCADP] Document parsing result downloaded to: {os.path.basename(file_path)}")
             return file_path
 
-        except requests.exceptions.RequestException as e:
+        except Exception as e:
             logging.error(f"[TCADP] Failed to download file: {e}")
+            try:
+                if "file_path" in locals() and os.path.exists(file_path):
+                    os.unlink(file_path)
+            except Exception:
+                pass
             return None
 
 
@@ -246,6 +251,10 @@ def __init__(
         if not self.secret_id or not self.secret_key:
             raise ValueError("[TCADP] Please set Tencent Cloud API keys, configure tcadp_config in service_conf.yaml")
 
+    @staticmethod
+    def _is_zipinfo_symlink(member: zipfile.ZipInfo) -> bool:
+        return (member.external_attr >> 16) & 0o170000 == 0o120000
+
     def check_installation(self) -> bool:
         """Check if Tencent Cloud API configuration is correct"""
         try:
@@ -280,23 +289,34 @@ def _extract_content_from_zip(self, zip_path: str) -> list[dict[str, Any]]:
 
         try:
             with zipfile.ZipFile(zip_path, "r") as zip_file:
-                # Find JSON result files
-                json_files = [f for f in zip_file.namelist() if f.endswith(".json")]
-
-                for json_file in json_files:
-                    with zip_file.open(json_file) as f:
-                        data = json.load(f)
-                        if isinstance(data, list):
-                            results.extend(data)
+                members = zip_file.infolist()
+                for member in members:
+                    name = member.filename.replace("\\", "/")
+                    if member.is_dir():
+                        continue
+                    if member.flag_bits & 0x1:
+                        raise RuntimeError(f"[TCADP] Encrypted zip entry not supported: {member.filename}")
+                    if self._is_zipinfo_symlink(member):
+                        raise RuntimeError(f"[TCADP] Symlink zip entry not supported: {member.filename}")
+                    if name.startswith("/") or name.startswith("//") or re.match(r"^[A-Za-z]:", name):
+                        raise RuntimeError(f"[TCADP] Unsafe zip path (absolute): {member.filename}")
+                    parts = [p for p in name.split("/") if p not in ("", ".")]
+                    if any(p == ".." for p in parts):
+                        raise RuntimeError(f"[TCADP] Unsafe zip path (traversal): {member.filename}")
+
+                    if not (name.endswith(".json") or name.endswith(".md")):
+                        continue
+
+                    with zip_file.open(member) as f:
+                        if name.endswith(".json"):
+                            data = json.load(f)
+                            if isinstance(data, list):
+                                results.extend(data)
+                            else:
+                                results.append(data)
                         else:
-                            results.append(data)
-
-                # Find Markdown files
-                md_files = [f for f in zip_file.namelist() if f.endswith(".md")]
-                for md_file in md_files:
-                    with zip_file.open(md_file) as f:
-                        content = f.read().decode("utf-8")
-                        results.append({"type": "text", "content": content, "file": md_file})
+                            content = f.read().decode("utf-8")
+                            results.append({"type": "text", "content": content, "file": name})
 
         except Exception as e:
             self.logger.error(f"[TCADP] Failed to extract ZIP file content: {e}")
diff --git a/deepdoc/parser/utils.py b/deepdoc/parser/utils.py
index 19d0b85..45394c7 100644
--- a/deepdoc/parser/utils.py
+++ b/deepdoc/parser/utils.py
@@ -19,7 +19,7 @@
 
 def get_text(fnm: str, binary=None) -> str:
     txt = ""
-    if binary:
+    if binary is not None:
         encoding = find_codec(binary)
         txt = binary.decode(encoding, errors="ignore")
     else:
diff --git a/deepdoc/vision/layout_recognizer.py b/deepdoc/vision/layout_recognizer.py
index 147ff29..eb681cd 100644
--- a/deepdoc/vision/layout_recognizer.py
+++ b/deepdoc/vision/layout_recognizer.py
@@ -17,7 +17,7 @@
 import logging
 import math
 import os
-# import re
+import re
 from collections import Counter
 from copy import deepcopy
 
@@ -68,9 +68,8 @@ def __init__(
 
     def __call__(self, image_list, ocr_res, scale_factor=3, thr=0.2, batch_size=16, drop=True):
         def __is_garbage(b):
-            return False
-            # patt = [r"^•+$", "^[0-9]{1,2} / ?[0-9]{1,2}$", r"^[0-9]{1,2} of [0-9]{1,2}$", "^http://[^ ]{12,}", "\\(cid *: *[0-9]+ *\\)"]
-            # return any([re.search(p, b["text"]) for p in patt])
+            patt = [r"\(cid\s*:\s*\d+\s*\)"]
+            return any([re.search(p, b.get("text", "")) for p in patt])
 
         if self.client:
             layouts = self.client.predict(image_list)
@@ -138,16 +137,23 @@ def findLayout(ty):
             for lt in ["footer", "header", "reference", "figure caption", "table caption", "title", "table", "text", "figure", "equation"]:
                 findLayout(lt)
 
-            # add box to figure layouts which has not text box
-            for i, lt in enumerate([lt for lt in lts if lt["type"] in ["figure", "equation"]]):
-                if lt.get("visited"):
-                    continue
-                lt = deepcopy(lt)
-                del lt["type"]
-                lt["text"] = ""
-                lt["layout_type"] = "figure"
-                lt["layoutno"] = f"figure-{i}"
-                bxs.append(lt)
+            # add box to figure/equation layouts which have no text box.
+            # Index within each type's own list and keep the type as the layoutno
+            # prefix so these match the namespace findLayout() assigns to
+            # text-overlapping boxes (figure-N vs equation-N). Using a combined
+            # figure+equation index with a fixed "figure" prefix would collide
+            # with figure-N tags from findLayout and merge unrelated regions.
+            for ty in ["figure", "equation"]:
+                for i, lt in enumerate([lt for lt in lts if lt["type"] == ty]):
+                    if lt.get("visited"):
+                        continue
+                    lt = deepcopy(lt)
+                    lt.pop("type", None)
+                    lt["text"] = ""
+                    lt["layout_type"] = "figure"
+                    lt["layoutno"] = f"{ty}-{i}"
+                    logging.debug(f"Created placeholder box {lt['layoutno']} for textless {ty} region")
+                    bxs.append(lt)
 
             boxes.extend(bxs)
 
@@ -457,16 +463,21 @@ def _tag_layout(ty):
             for ty in ["footer", "header", "reference", "figure caption", "table caption", "title", "table", "text", "figure", "equation"]:
                 _tag_layout(ty)
 
-            figs = [lt for lt in lts if lt["type"] in ["figure", "equation"]]
-            for i, lt in enumerate(figs):
-                if lt.get("visited"):
-                    continue
-                lt = deepcopy(lt)
-                lt.pop("type", None)
-                lt["text"] = ""
-                lt["layout_type"] = "figure"
-                lt["layoutno"] = f"figure-{i}"
-                bxs.append(lt)
+            # Index within each type's own list and keep the type as the layoutno
+            # prefix so these match the namespace _tag_layout() assigns to
+            # text-overlapping boxes (figure-N vs equation-N). Using a combined
+            # figure+equation index with a fixed "figure" prefix would collide
+            # with figure-N tags from _tag_layout and merge unrelated regions.
+            for ty in ["figure", "equation"]:
+                for i, lt in enumerate([lt for lt in lts if lt["type"] == ty]):
+                    if lt.get("visited"):
+                        continue
+                    lt = deepcopy(lt)
+                    lt.pop("type", None)
+                    lt["text"] = ""
+                    lt["layout_type"] = "figure"
+                    lt["layoutno"] = f"{ty}-{i}"
+                    bxs.append(lt)
 
             boxes_out.extend(bxs)
 
diff --git a/deepdoc/vision/ocr.py b/deepdoc/vision/ocr.py
index da1c9cf..3fc1aeb 100644
--- a/deepdoc/vision/ocr.py
+++ b/deepdoc/vision/ocr.py
@@ -93,8 +93,9 @@ def cuda_is_available():
     options = ort.SessionOptions()
     options.enable_cpu_mem_arena = False
     options.execution_mode = ort.ExecutionMode.ORT_SEQUENTIAL
-    options.intra_op_num_threads = 2
-    options.inter_op_num_threads = 2
+    # Prevent CPU oversubscription by allowing explicit thread control in multi-worker environments
+    options.intra_op_num_threads = int(os.environ.get("OCR_INTRA_OP_NUM_THREADS", "2"))
+    options.inter_op_num_threads = int(os.environ.get("OCR_INTER_OP_NUM_THREADS", "2"))
 
     # https://github.com/microsoft/onnxruntime/issues/9509#issuecomment-951546580
     # Shrink GPU memory after execution
@@ -115,6 +116,11 @@ def cuda_is_available():
             provider_options=[cuda_provider_options]
             )
         logging.info(f"load_model {model_file_path} uses GPU (device {provider_device_id}, gpu_mem_limit={cuda_provider_options['gpu_mem_limit']}, arena_strategy={arena_strategy})")
+        # Explicit arena shrinkage for GPU to release VRAM back to the system after each run
+        if os.environ.get("OCR_GPUMEM_ARENA_SHRINKAGE") == "1":
+            run_options.add_run_config_entry("memory.enable_memory_arena_shrinkage", f"gpu:{provider_device_id}")
+            logging.info(
+                f"load_model {model_file_path} enabled GPU memory arena shrinkage on device {provider_device_id}")
     else:
         sess = ort.InferenceSession(
             model_file_path,
diff --git a/deepdoc/vision/operators.py b/deepdoc/vision/operators.py
index 65d2efa..1229f58 100644
--- a/deepdoc/vision/operators.py
+++ b/deepdoc/vision/operators.py
@@ -66,7 +66,7 @@ def __call__(self, data):
         return data
 
 
-class StandardizeImag:
+class StandardizeImage:
     """normalize image
     Args:
         mean (list): im - mean
diff --git a/deepdoc/vision/table_structure_recognizer.py b/deepdoc/vision/table_structure_recognizer.py
index a8effb5..aacdbce 100644
--- a/deepdoc/vision/table_structure_recognizer.py
+++ b/deepdoc/vision/table_structure_recognizer.py
@@ -112,7 +112,12 @@ def __call__(self, images, thr=0.2):
 
     @staticmethod
     def is_caption(bx):
-        patt = [r"[图表]+[ 0-9:：]{2,}"]
+        patt = [
+            r"[图表]+[ 0-9:：]{2,}",
+            r"(?i)Fig\.?\s*\d+",
+            r"(?i)Figure\s+\d+",
+            r"(?i)Table\s+\d+",
+        ]
         if any([re.match(p, bx["text"].strip()) for p in patt]) or bx.get("layout_type", "").find("caption") >= 0:
             return True
         return False
diff --git a/tests/test_upstream_sync_regressions.py b/tests/test_upstream_sync_regressions.py
new file mode 100644
index 0000000..12f7f11
--- /dev/null
+++ b/tests/test_upstream_sync_regressions.py
@@ -0,0 +1,250 @@
+"""Regression tests for fixes ported from upstream ragflow (2026-07 sync).
+
+Each test pins one ported fix. They avoid model downloads: only pure-Python
+code paths are exercised.
+"""
+
+import io
+import logging
+import os
+import zipfile
+
+import pytest
+
+
+# ---------------------------------------------------------------------------
+# vision/operators.py — ragflow #16785
+# ---------------------------------------------------------------------------
+def test_standardize_image_resolves_by_canonical_name():
+    from deepdoc.vision import operators
+
+    assert hasattr(operators, "StandardizeImage")
+    assert not hasattr(operators, "StandardizeImag")
+
+    import numpy as np
+
+    op = getattr(operators, "StandardizeImage")(
+        mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225], is_scale=True
+    )
+    out, _ = op(np.ones((4, 4, 3), dtype="float32"), {})
+    assert out.shape == (4, 4, 3)
+
+
+# ---------------------------------------------------------------------------
+# parser/markdown_parser.py — ragflow #15630/#15632/#16109/#16319 et al.
+# ---------------------------------------------------------------------------
+def test_markdown_tables_and_code_blocks_survive_delimiter_split():
+    from deepdoc.parser.markdown_parser import MarkdownElementExtractor
+
+    text = (
+        "# Title\n"
+        "Intro; with delimiter.\n\n"
+        "| a | b |\n"
+        "|-|:-|\n"
+        "| 1; x | 2 |\n\n"
+        "```python\ncode; still code\n```\n"
+        "Tail; end."
+    )
+    ex = MarkdownElementExtractor(text)
+    assert ex._is_table_separator_row("|-|:-|"), "GFM one-dash separator must be accepted"
+    sections = ex.extract_elements(delimiter=";")
+    joined = "\n".join(sections)
+    assert "| 1; x | 2 |" in joined, "table row must not be split at the delimiter"
+    assert "code; still code" in joined, "fenced code must not be split at the delimiter"
+
+
+# ---------------------------------------------------------------------------
+# parser/excel_parser.py — ragflow #16287 / #15490 / #13018
+# ---------------------------------------------------------------------------
+def _xlsx_bytes(rows):
+    from openpyxl import Workbook
+
+    wb = Workbook()
+    ws = wb.active
+    for r in rows:
+        ws.append(r)
+    buf = io.BytesIO()
+    wb.save(buf)
+    return buf.getvalue()
+
+
+def test_excel_keeps_zero_and_false_cells():
+    from deepdoc.parser.excel_parser import RAGFlowExcelParser
+
+    data = _xlsx_bytes([["h1", "h2"], [0, False], ["", None]])
+    res = RAGFlowExcelParser()(data)
+    joined = " || ".join(res)
+    assert "0" in joined
+    assert "False" in joined
+    assert len(res) == 1, "all-empty row must not emit a line"
+
+
+def test_excel_html_no_header_only_chunk_at_exact_multiple():
+    from deepdoc.parser.excel_parser import RAGFlowExcelParser
+
+    data = _xlsx_bytes([["h"], [1], [2]])
+    chunks = RAGFlowExcelParser().html(data, chunk_rows=2)
+    assert len(chunks) == 1
+
+
+# ---------------------------------------------------------------------------
+# parser/html_parser.py — ragflow #16423 / #13833 / #16052
+# ---------------------------------------------------------------------------
+def test_html_title_tags_h4_mapping():
+    from deepdoc.parser import html_parser
+
+    assert html_parser.TITLE_TAGS["h4"] == "####"
+
+
+def test_html_parses_bodyless_fragment():
+    from deepdoc.parser.html_parser import RAGFlowHtmlParser
+
+    parser = RAGFlowHtmlParser()
+    sections = parser.parser_txt("<div><p>hello fragment</p></div>", chunk_token_num=512)
+    assert any("hello fragment" in s for s in sections)
+
+
+def test_html_oversized_block_split_preserves_text():
+    from deepdoc.parser.html_parser import RAGFlowHtmlParser
+
+    parser = RAGFlowHtmlParser()
+    block = "word " * 1200
+    pieces = parser._split_oversized_block(block.strip(), 512)
+    assert "".join(pieces).replace(" ", "") == block.strip().replace(" ", "")
+
+
+# ---------------------------------------------------------------------------
+# zip extraction hardening — ragflow #12527
+# ---------------------------------------------------------------------------
+def _zip_with(arcname, payload=b"evil"):
+    buf = io.BytesIO()
+    with zipfile.ZipFile(buf, "w") as z:
+        z.writestr(arcname, payload)
+    return buf.getvalue()
+
+
+@pytest.mark.parametrize(
+    "arcname", ["../escape.txt", "/abs.txt", "C:/win.txt", "a/../../up.txt"]
+)
+def test_mineru_zip_rejects_unsafe_entries(tmp_path, arcname):
+    from deepdoc.parser.mineru_parser import MinerUParser
+
+    zpath = tmp_path / "evil.zip"
+    zpath.write_bytes(_zip_with(arcname))
+
+    class Dummy:
+        logger = logging.getLogger("test")
+        _is_zipinfo_symlink = staticmethod(MinerUParser._is_zipinfo_symlink)
+
+    with pytest.raises(RuntimeError):
+        MinerUParser._extract_zip_no_root(Dummy(), str(zpath), str(tmp_path / "out"), None)
+
+
+def test_mineru_zip_extracts_benign_entries(tmp_path):
+    from deepdoc.parser.mineru_parser import MinerUParser
+
+    zpath = tmp_path / "ok.zip"
+    zpath.write_bytes(_zip_with("ok/file.txt", b"fine"))
+
+    class Dummy:
+        logger = logging.getLogger("test")
+        _is_zipinfo_symlink = staticmethod(MinerUParser._is_zipinfo_symlink)
+
+    outdir = tmp_path / "out"
+    MinerUParser._extract_zip_no_root(Dummy(), str(zpath), str(outdir), None)
+    assert (outdir / "ok" / "file.txt").read_bytes() == b"fine"
+
+
+def test_tcadp_zip_rejects_traversal_entries(tmp_path):
+    from deepdoc.parser.tcadp_parser import TCADPParser
+
+    zpath = tmp_path / "evil.zip"
+    zpath.write_bytes(_zip_with("../escape.json", b"{}"))
+
+    class Dummy:
+        logger = logging.getLogger("test")
+        _is_zipinfo_symlink = staticmethod(TCADPParser._is_zipinfo_symlink)
+
+    assert TCADPParser._extract_content_from_zip(Dummy(), str(zpath)) == []
+
+
+# ---------------------------------------------------------------------------
+# parser/pdf_parser.py — ragflow #13404 / #16958 / #14382 / #14385
+# ---------------------------------------------------------------------------
+def test_pdf_garbled_detection_statics():
+    from deepdoc.parser.pdf_parser import RAGFlowPdfParser as K
+
+    assert K._is_garbled_char("")
+    assert not K._is_garbled_char("永")
+    assert K._is_garbled_text("(cid:123) hello")
+    assert not K._is_garbled_text("normal text 中文")
+    assert K._has_subset_font_prefix("DY1+ZLQDm1-1")
+    assert not K._has_subset_font_prefix("Arial")
+
+
+def test_pdf_insert_word_spaces_latin_not_cjk():
+    from deepdoc.parser.pdf_parser import RAGFlowPdfParser as K
+
+    latin = [
+        {"text": "hello", "x0": 0, "x1": 10, "width": 10},
+        {"text": "world", "x0": 14, "x1": 24, "width": 10},
+    ]
+    K._insert_word_spaces(latin)
+    assert latin[0]["text"] == "hello "
+
+    cjk = [
+        {"text": "中", "x0": 0, "x1": 10, "width": 10},
+        {"text": "文", "x0": 14, "x1": 24, "width": 10},
+    ]
+    K._insert_word_spaces(cjk)
+    assert cjk[0]["text"] == "中"
+
+
+def test_pdf_page_limit_and_offset_tag():
+    from deepdoc.parser import pdf_parser
+
+    assert pdf_parser.MAXIMUM_PAGE_NUMBER == 100000
+    out = pdf_parser.RAGFlowPdfParser._offset_position_tag("@@1-2\t0.0\t1.0\t2.0\t3.0##", 50)
+    assert out.startswith("@@51-52\t")
+
+
+# ---------------------------------------------------------------------------
+# parser/epub_parser.py — ragflow #13650
+# ---------------------------------------------------------------------------
+def test_epub_parses_spine_order():
+    from deepdoc.parser.epub_parser import RAGFlowEpubParser
+
+    buf = io.BytesIO()
+    with zipfile.ZipFile(buf, "w") as z:
+        z.writestr(
+            "META-INF/container.xml",
+            '<?xml version="1.0"?>'
+            '<container xmlns="urn:oasis:names:tc:opendocument:xmlns:container">'
+            '<rootfiles><rootfile full-path="OEBPS/content.opf" media-type="application/oebps-package+xml"/></rootfiles>'
+            "</container>",
+        )
+        z.writestr(
+            "OEBPS/content.opf",
+            '<?xml version="1.0"?>'
+            '<package xmlns="http://www.idpf.org/2007/opf">'
+            "<manifest>"
+            '<item id="c1" href="c1.xhtml" media-type="application/xhtml+xml"/>'
+            "</manifest>"
+            '<spine><itemref idref="c1"/></spine>'
+            "</package>",
+        )
+        z.writestr("OEBPS/c1.xhtml", "<html><body><p>epub says hi</p></body></html>")
+
+    parser = RAGFlowEpubParser()
+    sections = parser("test.epub", binary=buf.getvalue())
+    assert any("epub says hi" in s for s in sections)
+
+
+# ---------------------------------------------------------------------------
+# vision/table_structure_recognizer.py — ragflow #15481
+# ---------------------------------------------------------------------------
+def test_tsr_caption_matches_english_patterns():
+    from deepdoc.vision.table_structure_recognizer import TableStructureRecognizer
+
+    for text in ["Figure 3: results", "Table 12. stats", "Fig. 4 overview"]:
+        assert TableStructureRecognizer.is_caption({"text": text, "layout_type": ""}), text