feat(pdf): docling-parse migration phase 3.2 — recompose decomposed ligatures

pdfium decomposes a single ligature glyph (Latin fi/ffi, Arabic lam-alef) into
several chars at the *same* loose box. The contraction's gap is a Euclidean
distance (always positive), so the zero-width overlap read as a real gap and
inserted spurious intra-word spaces (`conf iguration`, `di f f i cult`). Recompose
them: consecutive glyphs sharing a loose box are appended into one cell, exactly
like docling-parse keeps the ligature whole.

This recovers 2305-pg9 to EXACT (was 0→4) and RTL_01 to 2, making the dp path
net-positive with no regression vs legacy: 2203 309→285, 2206 200→168,
multi_page 54→22, normal_4pages 108→82, redp5110 300→252, amt 16→14,
table_mislabeled 113→111; the 3 EXACT PDFs stay exact. Still behind the flag.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: artiz

crates/fleischwolf-pdf/examples/dump_chars.rs

@@ -1,14 +1,24 @@
-//! Dump pdfium's raw char stream (codepoint + x + font hash) for a page.
-//! Usage: `... --example dump_chars -- file.pdf`
+//! Dump pdfium's raw char stream (codepoint + loose left/right) for a page,
+//! optionally filtered to a substring window. Usage:
+//!   ... --example dump_chars -- file.pdf [needle]
 fn main() {
-    let path = std::env::args().nth(1).expect("usage: dump_chars <pdf>");
+    let path = std::env::args()
+        .nth(1)
+        .expect("usage: dump_chars <pdf> [needle]");
+    let needle = std::env::args().nth(2);
     let bytes = std::fs::read(&path).expect("read");
     let glyphs = fleischwolf_pdf::pdfium_backend::debug_glyphs(&bytes, 0);
-    println!("pdfium CHAR order (ch / x / font-hash):");
-    for (ch, l, font) in glyphs.iter().take(40) {
-        println!(
-            "  {:?} U+{:04X}  xl={:.1}  font={}",
-            ch, *ch as u32, l, font
-        );
+    let text: String = glyphs.iter().map(|(c, _, _)| *c).collect();
+    let start = needle
+        .as_deref()
+        .and_then(|n| text.find(n))
+        .map(|b| text[..b].chars().count())
+        .unwrap_or(0);
+    println!("pdfium chars (ch / loose-left / loose-right / gap-to-prev):");
+    let mut prev_r = f32::NAN;
+    for (ch, l, r) in glyphs.iter().skip(start).take(20) {
+        let gap = l - prev_r;
+        println!("  {:?}  l={:7.2} r={:7.2}  gap={:+.2}", ch, l, r, gap);
+        prev_r = *r;
     }
 }

crates/fleischwolf-pdf/src/dp_lines.rs

@@ -186,41 +186,49 @@ fn contract(cells: &mut Vec<Cell>) {
 
 /// Build line cells from a page's glyph stream via the docling-parse contraction.
 pub(crate) fn line_cells(glyphs: &[Glyph], page_h: f32) -> Vec<TextCell> {
-    let mut cells: Vec<Cell> = glyphs
-        .iter()
-        .filter_map(|g| {
-            // Use the loose box (uniform font ascent/descent + advance) so adjacent
-            // glyphs share a top edge, matching docling-parse's `compute_rect`.
-            if !g.ll.is_finite() {
-                return None;
-            }
-            // Drop *degenerate* space glyphs (zero-width loose box): pdfium's
-            // generated spaces get a zero-width box at the wrong baseline that
-            // breaks corner-distance adjacency. Without them the inter-word gap
-            // drives `merge_with`'s space insertion. Spaces with a real width are
-            // kept (they carry justified double-space information).
-            if g.ch == ' ' && (g.lr - g.ll).abs() < 0.5 {
-                return None;
+    let mut cells: Vec<Cell> = Vec::new();
+    for g in glyphs {
+        // Use the loose box (uniform font ascent/descent + advance) so adjacent
+        // glyphs share a top edge, matching docling-parse's `compute_rect`.
+        if !g.ll.is_finite() {
+            continue;
+        }
+        // Drop *degenerate* space glyphs (zero-width loose box): pdfium's generated
+        // spaces get a zero-width box at the wrong baseline that breaks the
+        // corner-distance adjacency. Without them the inter-word gap drives
+        // `merge_with`'s space insertion. Spaces with a real width are kept (they
+        // carry justified double-space information).
+        if g.ch == ' ' && (g.lr - g.ll).abs() < 0.5 {
+            continue;
+        }
+        // Recompose a ligature: pdfium decomposes one font glyph (Latin fi/ffi,
+        // Arabic lam-alef) into several chars at the *same* loose box. Append them
+        // into one cell so the contraction never inserts a space inside it.
+        if let Some(last) = cells.last_mut() {
+            if (last.rx0 - g.ll as f64).abs() < 0.5 && (last.rx1 - g.lr as f64).abs() < 0.5 {
+                last.text.push(g.ch);
+                last.ltr = !is_right_to_left(&last.text);
+                continue;
             }
-            let text = g.ch.to_string();
-            let ltr = !is_right_to_left(&text);
-            Some(Cell {
-                text,
-                rx0: g.ll as f64,
-                ry0: g.lb as f64,
-                rx1: g.lr as f64,
-                ry1: g.lb as f64,
-                rx2: g.lr as f64,
-                ry2: g.lt as f64,
-                rx3: g.ll as f64,
-                ry3: g.lt as f64,
-                ltr,
-                active: true,
-                lig_carry: false,
-                font: g.font,
-            })
-        })
-        .collect();
+        }
+        let text = g.ch.to_string();
+        let ltr = !is_right_to_left(&text);
+        cells.push(Cell {
+            text,
+            rx0: g.ll as f64,
+            ry0: g.lb as f64,
+            rx1: g.lr as f64,
+            ry1: g.lb as f64,
+            rx2: g.lr as f64,
+            ry2: g.lt as f64,
+            rx3: g.ll as f64,
+            ry3: g.lt as f64,
+            ltr,
+            active: true,
+            lig_carry: false,
+            font: g.font,
+        });
+    }
     contract(&mut cells);
     cells
         .into_iter()

crates/fleischwolf-pdf/src/pdfium_backend.rs

@@ -259,7 +259,7 @@ impl Drop for FfiText<'_> {
 /// Debug helper: the raw pdfium glyph stream (codepoint + native bottom-left
 /// box) for a page, in pdfium's character order. For comparing against
 /// docling-parse's char cells.
-pub fn debug_glyphs(bytes: &[u8], index: i32) -> Vec<(char, f32, u64)> {
+pub fn debug_glyphs(bytes: &[u8], index: i32) -> Vec<(char, f32, f32)> {
     let Ok(pdfium) = bind() else {
         return Vec::new();
     };
@@ -276,7 +276,7 @@ pub fn debug_glyphs(bytes: &[u8], index: i32) -> Vec<(char, f32, u64)> {
     let mut out = Vec::new();
     if !tp.is_null() {
         for g in glyphs(b, tp, true) {
-            out.push((g.ch, g.l, g.font));
+            out.push((g.ch, g.ll, g.lr));
         }
         b.FPDFText_ClosePage(tp);
     }