docvortex 0.5.2__tar.gz → 0.5.4__tar.gz

{docvortex-0.5.2 → docvortex-0.5.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: docvortex
-Version: 0.5.2
+Version: 0.5.4
 Summary: A fast, multi-format document parsing and conversion engine
 License-Expression: MIT
 Project-URL: Repository, https://github.com/myhloli/DocVortex
@@ -62,12 +62,14 @@ Dynamic: license-file
 
 [![PyPI](https://img.shields.io/pypi/v/docvortex?color=008cff)](https://pypi.org/project/docvortex/)
 [![Python](https://img.shields.io/pypi/pyversions/docvortex)](https://pypi.org/project/docvortex/)
+[![Downloads](https://static.pepy.tech/badge/docvortex)](https://pepy.tech/project/docvortex)
+[![Monthly Downloads](https://static.pepy.tech/badge/docvortex/month)](https://pepy.tech/project/docvortex)
 [![CI](https://github.com/myhloli/DocVortex/actions/workflows/ci.yml/badge.svg)](https://github.com/myhloli/DocVortex/actions/workflows/ci.yml)
 [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://github.com/myhloli/DocVortex/blob/main/LICENSE.md)
 
 **English** · [简体中文](https://github.com/myhloli/DocVortex/blob/main/README_zh-CN.md)
 
-[Quick start](#quick-start) · [Formats](#supported-formats) · [Documentation](#documentation)
+[Performance](#pdf-performance) · [Quick start](#quick-start) · [Formats](#supported-formats) · [Documentation](#documentation)
 
 </div>
 
@@ -86,6 +88,18 @@ Native parsing works without an OCR or VLM inference service. Use DocVortex dire
 
 ![DocVortex pipeline: native documents become a unified representation, then Markdown, HTML, LaTeX, DOCX, EPUB, PDF or structured JSON.](https://gcore.jsdelivr.net/gh/myhloli/DocVortex@main/docs/images/docvortex-overview.jpg)
 
+## PDF performance
+
+**The 0.5 series brings a major boost to PDF processing with Rust acceleration: public parsing is 2.76× as fast as 0.4.25 on the tested corpus.**
+
+| Pipeline | 0.4.25 | 0.5.2 (Rust + session) | Speedup | Time reduction | Peak RSS reduction |
+| --- | ---: | ---: | ---: | ---: | ---: |
+| DocVortex public `parse()` | 42.36 s | 15.35 s | **2.76×** | **63.77%** | **33.45%** |
+| MinerU Flash | 44.50 s | 15.78 s | **2.82×** | **64.53%** | **32.78%** |
+| MinerU shared PDF processing | 76.28 s | 14.91 s | **5.12×** | **80.45%** | **36.25%** |
+
+Same-machine warm-run comparison on 32 PDFs / 299 pages (31 PDFs for Flash); times are sums of per-document medians. RSS reductions are medians of per-document process-tree peak RSS reductions. MinerU results include improvements in both projects. The shared pipeline excludes model computation; excluding the extreme dense-table sample, its speedup is **2.46×**.
+
 ## Quick start
 
 Requires **Python 3.10–3.14**.

{docvortex-0.5.2 → docvortex-0.5.4}/README.md

@@ -8,12 +8,14 @@
 
 [![PyPI](https://img.shields.io/pypi/v/docvortex?color=008cff)](https://pypi.org/project/docvortex/)
 [![Python](https://img.shields.io/pypi/pyversions/docvortex)](https://pypi.org/project/docvortex/)
+[![Downloads](https://static.pepy.tech/badge/docvortex)](https://pepy.tech/project/docvortex)
+[![Monthly Downloads](https://static.pepy.tech/badge/docvortex/month)](https://pepy.tech/project/docvortex)
 [![CI](https://github.com/myhloli/DocVortex/actions/workflows/ci.yml/badge.svg)](https://github.com/myhloli/DocVortex/actions/workflows/ci.yml)
 [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://github.com/myhloli/DocVortex/blob/main/LICENSE.md)
 
 **English** · [简体中文](https://github.com/myhloli/DocVortex/blob/main/README_zh-CN.md)
 
-[Quick start](#quick-start) · [Formats](#supported-formats) · [Documentation](#documentation)
+[Performance](#pdf-performance) · [Quick start](#quick-start) · [Formats](#supported-formats) · [Documentation](#documentation)
 
 </div>
 
@@ -32,6 +34,18 @@ Native parsing works without an OCR or VLM inference service. Use DocVortex dire
 
 ![DocVortex pipeline: native documents become a unified representation, then Markdown, HTML, LaTeX, DOCX, EPUB, PDF or structured JSON.](https://gcore.jsdelivr.net/gh/myhloli/DocVortex@main/docs/images/docvortex-overview.jpg)
 
+## PDF performance
+
+**The 0.5 series brings a major boost to PDF processing with Rust acceleration: public parsing is 2.76× as fast as 0.4.25 on the tested corpus.**
+
+| Pipeline | 0.4.25 | 0.5.2 (Rust + session) | Speedup | Time reduction | Peak RSS reduction |
+| --- | ---: | ---: | ---: | ---: | ---: |
+| DocVortex public `parse()` | 42.36 s | 15.35 s | **2.76×** | **63.77%** | **33.45%** |
+| MinerU Flash | 44.50 s | 15.78 s | **2.82×** | **64.53%** | **32.78%** |
+| MinerU shared PDF processing | 76.28 s | 14.91 s | **5.12×** | **80.45%** | **36.25%** |
+
+Same-machine warm-run comparison on 32 PDFs / 299 pages (31 PDFs for Flash); times are sums of per-document medians. RSS reductions are medians of per-document process-tree peak RSS reductions. MinerU results include improvements in both projects. The shared pipeline excludes model computation; excluding the extreme dense-table sample, its speedup is **2.46×**.
+
 ## Quick start
 
 Requires **Python 3.10–3.14**.

docvortex-0.5.4/docs/pdf-render-worker-leases.md

@@ -0,0 +1,38 @@
+# PDF 渲染任务租约与空闲文档缓存
+
+`PDFRenderSession` 保存共享输入文件、参数和取消状态；worker 使用权只持续到一次 `render()` 完成。进程池继续受既有全局预算约束，默认最多三个 worker，池的范围是当前宿主进程。
+
+## 调度与缓存
+
+- 等待请求按 FIFO 获取租约，归还、取消和池关闭通过条件变量唤醒等待者。有其他请求排队时先分配一个 worker；请求不会持有部分 worker 再等待更多额度。
+- 空闲 worker 优先按文档身份复用，其次选择无缓存的 worker，最后替换其他文档的缓存。每个 worker 最多保留一个 PDFium 文档。
+- 渲染结果全部收到并物化为独立图片后，归还所有任务租约。空闲缓存不阻止其他文档使用进程；模型推理不持有渲染租约。
+- 跨文档切换先发送 `close` 并确认旧输入释放，再发送 `open`。输入文件、常驻进程、原始像素传输和裁图算法继续复用。
+
+## 关闭与异常
+
+缓存归属和任务租约归属分别登记。A 的缓存正由 B 替换时，A 关闭会等待旧输入释放确认；它不会取消 B，也不会在确认前删除输入文件。B 已经打开自己的输入后，A 的关闭不再触碰该 worker。
+
+任务取消、打开或切换失败、活动进程崩溃会终止对应 worker 并归还额度。空闲进程崩溃只使缓存失效，下次请求可以重建。全池关闭直接回收活动进程，不向另一个线程正在读取的活动管道插入关闭命令。
+
+legacy 后端仍不得与活动 session 渲染并行叠加进程预算，但可以替换空闲缓存；未关闭的 session 随后可重新加载输入。等待预算的请求在真正取得额度后再次检查后端互斥状态。
+
+## 接口与诊断
+
+公开调用签名不变，`auto` 后端选择不变。`worker_diagnostics` 继续累计实际打开输入的记录，同文档命中缓存不增加打开次数。`close_diagnostics` 记录缓存被替换或文档关闭时的输入释放；强制进程回收记录额外包含 `worker_terminated: true`。
+
+内部 `_workers` 仅表示该 session 当前任务的租约，正常 `render()` 返回后为空；worker 进程仍可在全局空闲池中存活。文档关闭仍确认自己的所有输入句柄已释放，然后删除临时文件。
+
+## 回归覆盖
+
+测试覆盖同文档缓存亲和性、五份打开文档共享三个进程、FIFO 与队首取消、等待超时、活动和空闲进程崩溃、切换失败、旧会话关闭与缓存替换竞态、新旧后端切换，以及完整页像素、旋转、透明度、裁图编码和图像所有权。
+
+性能验证分别检查无竞争时的缓存收益、真实 PDF 输出摘要和连续处理的进程树 RSS。模型调用未参与这些渲染基准，不能将其耗时直接解释为完整解析或在线服务的吞吐。
+
+### 本地验证（2026-09-28）
+
+- PDF 相关回归（含真实 MinerU 五文档推理屏障）：386 passed；MinerU session 与窗口专项：21 passed。五文档均能在任一解析结束前进入推理等待，此时渲染租约为零。
+- 冻结基线为 `31654b8` 的原渲染模块，其余代码与原生扩展保持相同。32 PDF／299 页、4 页窗口，以及额外 64 页和逐页窗口，输出像素摘要全等，同文档打开次数保持一致。
+- 32 份样本预热后各测五次，渲染 CPU 时间中位数之和为基线 4.749384 秒、候选 4.749379 秒。独立进程墙钟计时有明显噪声；一份两页财务表在初测和反序复测仍超过 5%，同渲染实现与资源路径下交替配对 31 次后为 +0.15%，不将初测或复测结果删除，也不据此声称完整解析提速。
+- 两份真实 PDF 各连续五轮、16 页窗口、三个 worker：进程树峰值 RSS 中位数比例分别为 114.27% 和 82.67%，中位与最大峰值均通过既有 130% 门槛。进程身份稳定、输入释放通过，关闭池后渲染进程全部退出。有限回放不代表无限运行无泄漏。
+- 原始报告保存在本地 `output/pdf/render-worker-leases-20260928/`，入口为 `summary.json`。没有运行真实模型端到端吞吐或跨平台 CI。

docvortex-0.5.4/docs/pdf-tight-spacing-2026-09-28.md

@@ -0,0 +1,50 @@
+# 非 CJK 原生文本词距修复（2026-09-28）
+
+## 行为与边界
+
+相邻普通非 CJK 字符在同一方向和基线上、源编号连续、字号与页面墨迹尺度可信时，若 tight bbox 间隙严格大于两侧较大字号的 0.25 倍，则补一个 ASCII 空格。任意一侧为 CJK、标点或符号时不新增词界；已有空白及原有补空格规则保持不变。没有行长或样本数量门槛，不使用字距统计或词典。
+
+完整语料实际发现的反例决定了三个保守限制：
+
+- 部分 PDF 用 1pt 字号配合文字矩阵放大；墨迹高度超过自身字号 1.5 倍时不进行新增推断。
+- 连续数字中的窄字形（例如 Arial 的 `11`）有自然大留白，数字内部不新增空格。
+- 等宽字体中的 `i` 等窄字形不能仅靠墨迹留白判词界，固定宽度标志或通用等宽字体元数据命中时跳过。
+
+同时排除显著字号变化、上下标位移、不可靠方向和跨行几何。这些边界有意牺牲召回率，避免误拆正常文本。
+
+## 接入与兼容
+
+- Flash 从视觉行建立紧凑词界证据，在自然语言块归属和分类完成后、链接及样式物化前应用；代码、公式与原始字符不改写。复用现有去行末连字符的对齐规则。
+- Rust 快照直接批量返回源词界编号；Python 回退使用同一判据。不会为补空格额外持有整页字符副本。
+- MinerU Basic/Standard/Advanced 的 TXT 字符回填、Rust span 内容物化和旋转 line/span 回填均接入。实际代码区域的禁用标记会穿过整页虚拟文本框。
+- Flash/Basic/Standard 的原生表格在单元格内部物化空格；表格恢复失败后的文本投影也接入。通用代码空间投影、OCR 和模型内容保持原行为。
+- 公共 parse 参数及 MiddleJson schema 不变。新增 Rust span 参数可省略，旧宿主省略参数时保持原行为；内部 native protocol 升至 23，防止混用旧扩展。
+- DocVortex 本地版本为 0.5.4；MinerU 最低依赖同步为 `docvortex>=0.5.4,<1`。本次未提交、推送或发布。
+
+## 质量验证
+
+输入 `demo/pdfs/中文论文2.pdf`，SHA256 为 `937cfb51e9e8abc6b3a2d8c46d38003cd2ad795a0692eab3f9e92ac604fcc9ad`。
+
+完整重放 41 份 PDF、457 页：40 份输出完全不变。目标论文的 21 页、187 个块新增 2,095 个空格；非空格字符、块数量、类型、顺序和坐标保持不变。原件全部 23 页已打开审阅，包括两个无变化页；第 2 页表格的 `ChatbotArena` 修复为 `Chatbot Arena`。
+
+Python/Rust 的 41 份完整 ModelJson/MiddleJson 输出全部一致。四档均通过公共 `mineru.parser.parse()` 完整解析 23 页并导出 ModelJson、MiddleJson、Markdown、HTML 和素材；Basic/Standard/Advanced 的原生内容调用计数证明实际进入 Rust 路径。四档均恢复 `Large Language Models`、`Natural Language Processing`、`School of Computer Science`、`Pre-training of deep bidirectional transformers` 和参考文献会议名称，且不再出现 `LargeLanguageModels`。四档 HTML 已在本地浏览器检查。
+
+测试日志保存在本次运行目录：
+
+- `docvortex-final.log`：2,593 项通过，3 条既有 Office 依赖警告。
+- `mineru-final.log`：172 项通过。
+- `python-final.log`：68 项通过，3 个仅用于 Rust 的测试按预期跳过。
+- `final-focused.log`：220 项通过。
+- `final-boundaries-02.log`：128 项通过，含代码空间投影隔离。
+- `rust-final.log`：15 项 Rust 测试通过。
+- Ruff 与两个仓库的 `git diff --check` 通过。
+
+仅更新 `flash_reviewed_history.json` 中目标论文的 21 页内容指纹，以及 `native_pdf_table_demo_manifest.json` 中一处单元格文字和对应 HTML 指纹。逐页裁决见 `tests/fixtures/pdf_tight_spacing_review_decisions.json`；其余基线保留。
+
+## 性能与证据
+
+冻结旧源码和扩展，在没有模型推理并发的阶段，以独立进程逐份交错测量基线与候选，各预热后计时 3 次。41 份语料中位耗时之和增加约 1.31%；目标论文由 1.6792s 到 1.7251s（+2.74%），RSS +0.14%。峰值 RSS 最大增幅约 0.80%。
+
+一份约 42ms 的短文档首次测得 +9.90%；反转先后顺序、各测 7 次后为 41.656ms → 43.727ms（+4.97%），没有复现持续超过 5% 的退化。模型档位单次全文耗时受模型缓存和推理影响，不用来证明原生规则性能。
+
+完整日志、源码快照、逐页对比和四档输出位于 `output/pdf/tight-spacing-20260928/`。主要证据：`final-tiers/`、`final-corpus-diff.json`、`review-final/`、`python-corpus/report.json`、`performance/report.json`、`performance-retest/report.json`。拒绝的早期候选保留，未作为最终输出交付。

{docvortex-0.5.2 → docvortex-0.5.4}/rust/docvortex-core/src/lib.rs

@@ -1,6 +1,6 @@
 //! 不访问 Python 对象或 PDFium 的单线程批量计算内核。
 
-pub const PROTOCOL_VERSION: u32 = 22;
+pub const PROTOCOL_VERSION: u32 = 23;
 pub mod columns;
 pub mod note_index;
 pub mod row_geometry;
@@ -47,6 +47,7 @@ pub mod text_pipeline;
 pub mod text_assignment;
 pub mod text_content;
 pub mod text_snapshot;
+pub mod text_spacing;
 
 pub mod geometry_risk;
 pub mod geometry_runs;

{docvortex-0.5.2 → docvortex-0.5.4}/rust/docvortex-core/src/text_content.rs

@@ -85,6 +85,9 @@ fn clean(text: &str) -> String {
 
 /// 连续执行 PUA 信号、重叠附加符合成、词间空格及正文组装；空组保留调用方原文本。
 pub struct Rules<'a> {
+    pub ordinary: &'a HashSet<char>,
+    pub decimals: &'a HashSet<char>,
+    pub tight_spacing: &'a [bool],
     pub modifiers: &'a HashMap<String, String>,
     pub threshold: f64,
     pub compositions: &'a HashMap<(String, String), String>,
@@ -96,6 +99,9 @@ pub struct Rules<'a> {
 /// 使用本次调用固定的字符规则构造所有片段，避免重新读取可变 Python 配置。
 pub fn build(data: &TextSnapshot, groups: &[Vec<usize>], rules: &Rules<'_>) -> Vec<Content> {
     let Rules {
+        ordinary,
+        decimals,
+        tight_spacing,
         modifiers,
         threshold,
         compositions,
@@ -105,7 +111,8 @@ pub fn build(data: &TextSnapshot, groups: &[Vec<usize>], rules: &Rules<'_>) -> V
     } = rules;
     groups
         .iter()
-        .map(|group| {
+        .enumerate()
+        .map(|(group_index, group)| {
             let mut result = Content {
                 text: None,
                 private_count: 0,
@@ -133,7 +140,7 @@ pub fn build(data: &TextSnapshot, groups: &[Vec<usize>], rules: &Rules<'_>) -> V
                 return result;
             }
             let members = ordered(data, group);
-            let mut chars: Vec<(&str, Box4)> = Vec::with_capacity(members.len());
+            let mut chars: Vec<(&str, Box4, usize)> = Vec::with_capacity(members.len());
             let mut cursor = 0;
             while cursor < members.len() {
                 if cursor + 1 < members.len() {
@@ -148,17 +155,17 @@ pub fn build(data: &TextSnapshot, groups: &[Vec<usize>], rules: &Rules<'_>) -> V
                         let b = &data.chars[modifier];
                         if let Some(composed) = compositions.get(&(a.text.clone(), b.text.clone()))
                         {
-                            chars.push((composed, a.bbox));
+                            chars.push((composed, a.bbox, base));
                             cursor += 2;
                             continue;
                         }
                     }
                 }
                 let ch = &data.chars[members[cursor]];
-                chars.push((&ch.text, ch.bbox));
+                chars.push((&ch.text, ch.bbox, members[cursor]));
                 cursor += 1;
             }
-            let mut widths: Vec<_> = chars.iter().map(|(_, b)| b[2] - b[0]).collect();
+            let mut widths: Vec<_> = chars.iter().map(|(_, b, _)| b[2] - b[0]).collect();
             widths.sort_by(|a, b| a.partial_cmp(b).unwrap_or(std::cmp::Ordering::Equal));
             let median = if widths.len() % 2 == 1 {
                 widths[widths.len() / 2]
@@ -166,13 +173,24 @@ pub fn build(data: &TextSnapshot, groups: &[Vec<usize>], rules: &Rules<'_>) -> V
                 (widths[widths.len() / 2 - 1] + widths[widths.len() / 2]) / 2.0
             };
             let mut text = String::new();
-            for (index, &(value, bbox)) in chars.iter().enumerate() {
+            for (index, &(value, bbox, source)) in chars.iter().enumerate() {
                 if breaks.contains(value) {
                     continue;
                 }
                 text.push_str(value);
-                if let Some(&(next, next_box)) = chars.get(index + 1) {
-                    if next_box[0] - bbox[2] > median * 0.25 && value != " " && next != " " {
+                if let Some(&(next, next_box, next_source)) = chars.get(index + 1) {
+                    if (next_box[0] - bbox[2] > median * 0.25
+                        || (tight_spacing.get(group_index).copied().unwrap_or(false)
+                            && crate::text_spacing::needs_space(
+                                data,
+                                source,
+                                next_source,
+                                ordinary,
+                                decimals,
+                            )))
+                        && value != " "
+                        && next != " "
+                    {
                         text.push(' ');
                     }
                 }

docvortex-0.5.4/rust/docvortex-core/src/text_spacing.rs

@@ -0,0 +1,118 @@
+//! 与 Python 参考实现相同的相邻非 CJK 字形词界判定。
+use crate::{geometry::Box4, text_snapshot::TextSnapshot};
+use std::collections::HashSet;
+
+/// 排除汉字扩展、假名、韩文及兼容字形，不以所在整行的语言决定词界。
+pub fn is_cjk(ch: char) -> bool {
+    matches!(ch as u32,
+        0x1100..=0x11ff | 0x2e80..=0xa4cf | 0xa960..=0xa97f | 0xac00..=0xd7ff |
+        0xf900..=0xfaff | 0xff66..=0xff9f | 0x1aff0..=0x1b16f | 0x20000..=0x323af)
+}
+
+/// 墨迹框只转换坐标轴；相邻间隙与页面原点平移无关。
+fn local(b: Box4, angle: i32) -> Box4 {
+    match angle {
+        90 => [b[1], -b[2], b[3], -b[0]],
+        180 => [-b[2], -b[3], -b[0], -b[1]],
+        270 => [-b[3], b[0], -b[1], b[2]],
+        _ => b,
+    }
+}
+
+/// 只接受解释器确认的普通单字形，避免两端标点或连字展开改变语义。
+fn ordinary(text: &str, letters: &HashSet<char>) -> bool {
+    let mut chars = text.chars();
+    let Some(ch) = chars.next() else { return false };
+    chars.next().is_none() && !is_cjk(ch) && (ch.is_ascii_alphanumeric() || letters.contains(&ch))
+}
+
+/// 使用真实源编号、方向和基线保护，只为可靠的大墨迹间隙返回一个词界。
+pub fn needs_space(
+    data: &TextSnapshot,
+    first: usize,
+    second: usize,
+    letters: &HashSet<char>,
+    decimals: &HashSet<char>,
+) -> bool {
+    let a = &data.chars[first];
+    let b = &data.chars[second];
+    if !ordinary(&a.text, letters)
+        || !ordinary(&b.text, letters)
+        || a.index.checked_add(1) != Some(b.index)
+    {
+        return false;
+    }
+    if a.text
+        .chars()
+        .all(|c| c.is_ascii_digit() || decimals.contains(&c))
+        && b.text
+            .chars()
+            .all(|c| c.is_ascii_digit() || decimals.contains(&c))
+    {
+        return false;
+    }
+    for font in [&data.fonts[a.font], &data.fonts[b.font]] {
+        let name = font.name.to_lowercase();
+        if font.flags & 1 != 0
+            || [
+                "mono",
+                "courier",
+                "consolas",
+                "menlo",
+                "typewriter",
+                "fixed",
+            ]
+            .iter()
+            .any(|hint| name.contains(hint))
+        {
+            return false;
+        }
+    }
+    let ls = data.fonts[a.font].size;
+    let rs = data.fonts[b.font].size;
+    let em = ls.max(rs);
+    if !ls.is_finite() || !rs.is_finite() || ls.min(rs) <= 0.0 || ls.min(rs) < 0.8 * em {
+        return false;
+    }
+    if !a.writing_angle.is_finite() || !b.writing_angle.is_finite() {
+        return false;
+    }
+    let degrees = a.writing_angle.to_degrees().rem_euclid(360.0);
+    let angle = ((degrees / 90.0).round_ties_even() as i32 * 90) % 360;
+    if ((degrees - angle as f64 + 180.0).rem_euclid(360.0) - 180.0).abs() > 0.1
+        || ((b.writing_angle.to_degrees() - angle as f64 + 180.0).rem_euclid(360.0) - 180.0).abs()
+            > 0.1
+    {
+        return false;
+    }
+    let (Some(ab), Some(bb)) = (a.tight, b.tight) else {
+        return false;
+    };
+    if ab.iter().chain(bb.iter()).any(|v| !v.is_finite()) {
+        return false;
+    }
+    let ab = local(ab, angle);
+    let bb = local(bb, angle);
+    if ab[2] <= ab[0]
+        || bb[2] <= bb[0]
+        || ab[3] <= ab[1]
+        || bb[3] <= bb[1]
+        || ab[3] - ab[1] > 1.5 * ls
+        || bb[3] - bb[1] > 1.5 * rs
+        || bb[0] - ab[2] <= 0.25 * em
+        || ab[3].min(bb[3]) - ab[1].max(bb[1]) < 0.5 * (ab[3] - ab[1]).min(bb[3] - bb[1])
+    {
+        return false;
+    }
+    if let (Some(ao), Some(bo)) = (a.origin, b.origin) {
+        let axis = usize::from(angle != 90 && angle != 270);
+        if ao.iter().chain(bo.iter()).any(|v| !v.is_finite())
+            || (ao[axis] - bo[axis]).abs() > 0.15 * em
+        {
+            return false;
+        }
+    } else if (ab[3] - bb[3]).abs() > 0.15 * em {
+        return false;
+    }
+    true
+}

{docvortex-0.5.2 → docvortex-0.5.4}/rust/docvortex-python/src/snapshot.rs

@@ -620,6 +620,7 @@ impl NativeTextSnapshot {
         Ok(Some(result))
     }
     /// 正文已有共享上下标侧车时，字符归属及内容构造连续完成，仅输出每个 span 的文本和 PUA 计数。
+    #[pyo3(signature = (span_bboxes, median_height, stop_flags, start_flags, height_ratio, break_flags, modifiers, overlap_threshold, private_range, tight_spacing=None))]
     fn prepare_span_texts<'py>(
         &self,
         py: Python<'py>,
@@ -632,6 +633,7 @@ impl NativeTextSnapshot {
         modifiers: HashMap<String, String>,
         overlap_threshold: f64,
         private_range: (u32, u32),
+        tight_spacing: Option<Vec<bool>>,
     ) -> PyResult<Option<Bound<'py, PyList>>> {
         if !overlap_threshold.is_finite()
             || self
@@ -643,6 +645,13 @@ impl NativeTextSnapshot {
             return Ok(None);
         }
         let count = span_bboxes.len();
+        // 旧宿主没有代码区域掩码，省略新增参数时保持历史文本组装行为。
+        let tight_spacing = tight_spacing.unwrap_or_else(|| vec![false; count]);
+        if tight_spacing.len() != count {
+            return Err(pyo3::exceptions::PyValueError::new_err(
+                "Tight spacing mask must match span count",
+            ));
+        }
         let Some(assigned) = self.assign_spans(
             py,
             span_bboxes,
@@ -660,16 +669,29 @@ impl NativeTextSnapshot {
         let category = unicode.getattr("category")?;
         let normalize = unicode.getattr("normalize")?;
         let mut spaces = HashSet::new();
+        let mut ordinary = HashSet::new();
+        let mut decimals = HashSet::new();
         let mut seen_chars = HashSet::new();
         for ch in &self.data.chars {
             for value in ch.text.chars() {
-                if seen_chars.insert(value)
-                    && pyo3::types::PyString::new(py, &value.to_string())
-                        .call_method0("isspace")?
-                        .extract::<bool>()?
+                if !seen_chars.insert(value) {
+                    continue;
+                }
+                if pyo3::types::PyString::new(py, &value.to_string())
+                    .call_method0("isspace")?
+                    .extract::<bool>()?
                 {
                     spaces.insert(value);
                 }
+                if !value.is_ascii() && !docvortex_core::text_spacing::is_cjk(value) {
+                    let kind: String = category.call1((value.to_string(),))?.extract()?;
+                    if kind.starts_with('L') || kind == "Nd" {
+                        ordinary.insert(value);
+                    }
+                    if kind == "Nd" {
+                        decimals.insert(value);
+                    }
+                }
             }
         }
         let mut compositions = HashMap::new();
@@ -709,6 +731,9 @@ impl NativeTextSnapshot {
                 &self.data,
                 &groups,
                 &text_content::Rules {
+                    ordinary: &ordinary,
+                    decimals: &decimals,
+                    tight_spacing: &tight_spacing,
                     modifiers: &modifiers,
                     threshold: overlap_threshold,
                     compositions: &compositions,
@@ -734,6 +759,44 @@ impl NativeTextSnapshot {
         SPAN_CONTENT_CALLS.fetch_add(1, Ordering::Relaxed);
         Ok(Some(output))
     }
+    /// 在自有字符上计算可靠词界，仅返回源编号，避免 Flash 逐字符重复跨语言判定。
+    fn tight_space_indices(&self, py: Python<'_>) -> PyResult<Vec<usize>> {
+        let category = py.import("unicodedata")?.getattr("category")?;
+        let mut ordinary = HashSet::new();
+        let mut decimals = HashSet::new();
+        let mut seen = HashSet::new();
+        for ch in &self.data.chars {
+            for value in ch.text.chars() {
+                if !value.is_ascii()
+                    && !docvortex_core::text_spacing::is_cjk(value)
+                    && seen.insert(value)
+                {
+                    let kind: String = category.call1((value.to_string(),))?.extract()?;
+                    if kind.starts_with('L') || kind == "Nd" {
+                        ordinary.insert(value);
+                    }
+                    if kind == "Nd" {
+                        decimals.insert(value);
+                    }
+                }
+            }
+        }
+        Ok(py.detach(|| {
+            (1..self.data.chars.len())
+                .filter(|&index| {
+                    docvortex_core::text_spacing::needs_space(
+                        &self.data,
+                        index - 1,
+                        index,
+                        &ordinary,
+                        &decimals,
+                    )
+                })
+                .map(|index| self.data.chars[index].index)
+                .collect()
+        }))
+    }
+
     /// 为新鲜同源页面证据准备独立上下标记录，后续批次只传整数成员索引。
     fn prepare_script_evidence(
         &self,

{docvortex-0.5.2 → docvortex-0.5.4}/src/docvortex/_compute_backend.py

@@ -10,7 +10,7 @@ from functools import lru_cache
 from pathlib import Path
 from types import ModuleType
 
-_PROTOCOL_VERSION = 22
+_PROTOCOL_VERSION = 23
 _SELECTED_MODE = None
 _LOAD_FAILURE = None
 

{docvortex-0.5.2 → docvortex-0.5.4}/src/docvortex/analyzers/native/office/docx/package_normalizer.py

@@ -7,7 +7,16 @@ from zipfile import BadZipFile, ZipFile, ZipInfo
 from loguru import logger
 from lxml import etree
 
-from ..opc import relationship_source_base_dir, write_zip_package
+from ..opc import (
+    CONTENT_TYPES_MEMBER,
+    STRICT_OOXML_COMMON_REPLACEMENTS,
+    STRICT_WORDPROCESSINGML_NS,
+    WORDPROCESSINGML_NS,
+    relationship_source_base_dir,
+    repair_content_type_overrides,
+    translate_strict_ooxml_uris,
+    write_zip_package,
+)
 
 
 PACKAGE_RELATIONSHIPS_NS = "http://schemas.openxmlformats.org/package/2006/relationships"
@@ -15,6 +24,27 @@ RELATIONSHIP_TAG = f"{{{PACKAGE_RELATIONSHIPS_NS}}}Relationship"
 ZIP_MEMBER_READ_ERRORS = (BadZipFile, RuntimeError, NotImplementedError, zlib.error)
 DOCX_EMBEDDED_OFFICE_PREFIX = "word/embeddings/"
 
+STRICT_DOCX_REPLACEMENTS = STRICT_OOXML_COMMON_REPLACEMENTS + (
+    (
+        STRICT_WORDPROCESSINGML_NS.encode("utf-8"),
+        WORDPROCESSINGML_NS.encode("utf-8"),
+    ),
+)
+
+# 关系类型尾段到 part 内容类型的映射，用于按关系图补全 [Content_Types].xml Override。
+DOCX_REL_CONTENT_TYPES = {
+    "officeDocument": "application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml",
+    "styles": "application/vnd.openxmlformats-officedocument.wordprocessingml.styles+xml",
+    "numbering": "application/vnd.openxmlformats-officedocument.wordprocessingml.numbering+xml",
+    "footnotes": "application/vnd.openxmlformats-officedocument.wordprocessingml.footnotes+xml",
+    "endnotes": "application/vnd.openxmlformats-officedocument.wordprocessingml.endnotes+xml",
+    "comments": "application/vnd.openxmlformats-officedocument.wordprocessingml.comments+xml",
+    "settings": "application/vnd.openxmlformats-officedocument.wordprocessingml.settings+xml",
+    "webSettings": "application/vnd.openxmlformats-officedocument.wordprocessingml.webSettings+xml",
+    "fontTable": "application/vnd.openxmlformats-officedocument.wordprocessingml.fontTable+xml",
+    "theme": "application/vnd.openxmlformats-officedocument.theme+xml",
+}
+
 
 def normalize_docx_package(file_bytes: bytes) -> bytes:
     """在进入 python-docx 前修复 DOCX 包级容错问题。"""
@@ -41,10 +71,15 @@ def normalize_docx_package(file_bytes: bytes) -> bytes:
         rewritten_members: list[tuple[ZipInfo, bytes]] = []
         for info, member_data in loaded_members:
             normalized_data = member_data
+            if info.filename.endswith(".xml") or info.filename.endswith(".rels"):
+                # ISO Strict 命名空间与关系类型统一改写为 Transitional，python-docx 才能识别。
+                normalized_data = translate_strict_ooxml_uris(normalized_data, STRICT_DOCX_REPLACEMENTS)
+                if normalized_data != member_data:
+                    changed = True
             if info.filename.endswith(".rels"):
                 normalized_data = _remove_missing_internal_relationships(
                     info.filename,
-                    member_data,
+                    normalized_data,
                     package_members,
                     skipped_members,
                 )
@@ -52,6 +87,17 @@ def normalize_docx_package(file_bytes: bytes) -> bytes:
                     changed = True
             rewritten_members.append((info, normalized_data))
 
+        repaired_content_types = repair_content_type_overrides(
+            {info.filename: member_data for info, member_data in rewritten_members},
+            DOCX_REL_CONTENT_TYPES,
+        )
+        if repaired_content_types is not None:
+            rewritten_members = [
+                (info, repaired_content_types if info.filename == CONTENT_TYPES_MEMBER else member_data)
+                for info, member_data in rewritten_members
+            ]
+            changed = True
+
     if not changed:
         return file_bytes
 

{docvortex-0.5.2 → docvortex-0.5.4}/src/docvortex/analyzers/native/office/docx/resources.py

@@ -286,8 +286,34 @@ class _DocxResources:
                 "type": BlockType.IMAGE,
                 "image_base64": img_base64,
             }
+            alt_text = self._docx_image_alt_text(image)
+            if alt_text:
+                image_block["content"] = alt_text
             self.cur_page.append(image_block)
 
+    @staticmethod
+    def _docx_image_alt_text(image: Any) -> str:
+        """读取 DrawingML wp:docPr 的 descr 或 VML v:shape 的 alt 替代文本。"""
+        element = image
+        while element is not None:
+            tag = str(getattr(element, "tag", ""))
+            local_name = tag.rsplit("}", 1)[-1]
+            if local_name in {"inline", "anchor"}:
+                for child in element:
+                    child_tag = str(getattr(child, "tag", ""))
+                    if child_tag.rsplit("}", 1)[-1] == "docPr":
+                        descr = (child.get("descr") or "").strip()
+                        if descr:
+                            return descr
+                return ""
+            if local_name == "shape" and "urn:schemas-microsoft-com:vml" in tag:
+                alt = (element.get("alt") or "").strip()
+                if alt:
+                    return alt
+                return ""
+            element = element.getparent()
+        return ""
+
     def _handle_drawingml(self, elements: list[BaseOxmlElement]):
         """
         处理 DrawingML 元素，目前先处理 chart 元素。