chore: drop dev-only probe binaries and serde dep from PR

The probe-formulas and probe-formulas-latex binaries were used to
validate the LaTeX recovery during development but are not needed
by consumers of the library. Removing them also drops the serde
runtime dependency, which was only required by the probes.

The probes can live as standalone scripts outside the published
crate.

No production behavior change. All 393 lib + 104 integration + 2 doc
tests still pass; clippy clean.

.github/workflows/publish.yml

@@ -2,14 +2,41 @@ name: Publish npm package
 
 on:
   push:
-    tags: ['v*']
+    branches: [main]
+    paths: ['napi/package.json']
 
 permissions:
   contents: read
   id-token: write
 
 jobs:
+  check-version:
+    name: Check version change
+    runs-on: ubuntu-latest
+    outputs:
+      changed: ${{ steps.check.outputs.changed }}
+      version: ${{ steps.check.outputs.version }}
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 2
+
+      - name: Check if version changed
+        id: check
+        run: |
+          NEW_VERSION=$(node -p "require('./napi/package.json').version")
+          OLD_VERSION=$(git show HEAD~1:napi/package.json | node -p "JSON.parse(require('fs').readFileSync('/dev/stdin','utf8')).version")
+          echo "old=$OLD_VERSION new=$NEW_VERSION"
+          if [ "$NEW_VERSION" != "$OLD_VERSION" ]; then
+            echo "changed=true" >> "$GITHUB_OUTPUT"
+            echo "version=$NEW_VERSION" >> "$GITHUB_OUTPUT"
+          else
+            echo "changed=false" >> "$GITHUB_OUTPUT"
+          fi
+
   build:
+    needs: check-version
+    if: needs.check-version.outputs.changed == 'true'
     name: Build ${{ matrix.target }}
     runs-on: ${{ matrix.os }}
     strategy:
@@ -68,7 +95,7 @@ jobs:
 
   publish:
     name: Publish to npm
-    needs: build
+    needs: [check-version, build]
     runs-on: ubuntu-latest
     permissions:
       contents: read

napi/package.json

@@ -1,6 +1,6 @@
 {
   "name": "firecrawl-pdf-inspector",
-  "version": "0.7.0",
+  "version": "0.7.5",
   "description": "Fast PDF classification and text extraction. Detect text-based vs scanned PDFs, extract text by region with quality checks. Native Rust performance via napi-rs.",
   "main": "index.js",
   "types": "index.d.ts",

napi/src/lib.rs

@@ -99,6 +99,26 @@ pub struct PageRegionTexts {
     pub regions: Vec<RegionText>,
 }
 
+/// LaTeX reconstruction result for a single formula region.
+#[napi(object)]
+pub struct FormulaLatexResult {
+    /// Reconstructed LaTeX string.
+    pub latex: String,
+    /// The linearized raw text (before LaTeX reconstruction).
+    pub raw_text: String,
+    /// Heuristic confidence in the LaTeX output (0.0–1.0).
+    pub confidence: f64,
+    /// `true` when extraction failed entirely and GPU OCR is needed.
+    pub needs_ocr: bool,
+}
+
+/// LaTeX reconstruction results for one page's formula regions.
+#[napi(object)]
+pub struct PageFormulaLatexResults {
+    pub page: u32,
+    pub regions: Vec<FormulaLatexResult>,
+}
+
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
@@ -317,6 +337,70 @@ pub fn extract_tables_in_regions(
     })
 }
 
+/// Extract formula text within bounding-box regions from a PDF.
+///
+/// Like `extractTextInRegions` but uses formula-specific quality checks.
+/// Formula text is legitimately symbol-heavy (Greek letters, math operators)
+/// so the generic garbage-text check is relaxed. When the text decodes
+/// cleanly, `needsOcr` is `false` — the caller can skip GPU OCR.
+///
+/// Coordinates are PDF points with top-left origin.
+#[napi]
+pub fn extract_formulas_in_regions(
+    buffer: Buffer,
+    page_regions: Vec<PageRegions>,
+) -> Result<Vec<PageRegionTexts>> {
+    let bytes: Vec<u8> = buffer.to_vec();
+    let regions = parse_page_regions(&page_regions);
+
+    catch_panic("extract_formulas_in_regions", move || {
+        let results = pdf_inspector::extract_formulas_in_regions_mem(&bytes, &regions)
+            .map_err(|e| to_napi_err(e, "extract_formulas_in_regions"))?;
+        Ok(to_page_region_texts(results))
+    })
+}
+
+/// Extract formula text within bounding-box regions and reconstruct LaTeX.
+///
+/// Like `extractFormulasInRegions` but additionally reconstructs LaTeX from
+/// the positioned text items. Each result includes the raw text, reconstructed
+/// LaTeX, a confidence score, and the `needsOcr` flag.
+///
+/// The confidence score (0.0–1.0) indicates how reliable the heuristic LaTeX
+/// reconstruction is. The caller should use this to decide whether to trust
+/// the LaTeX or fall back to GPU OCR.
+///
+/// Coordinates are PDF points with top-left origin.
+#[napi]
+pub fn extract_formulas_in_regions_as_latex(
+    buffer: Buffer,
+    page_regions: Vec<PageRegions>,
+) -> Result<Vec<PageFormulaLatexResults>> {
+    let bytes: Vec<u8> = buffer.to_vec();
+    let regions = parse_page_regions(&page_regions);
+
+    catch_panic("extract_formulas_in_regions_as_latex", move || {
+        let results = pdf_inspector::extract_formulas_in_regions_as_latex(&bytes, &regions)
+            .map_err(|e| to_napi_err(e, "extract_formulas_in_regions_as_latex"))?;
+        Ok(results
+            .into_iter()
+            .map(|page_result| PageFormulaLatexResults {
+                page: page_result.page,
+                regions: page_result
+                    .regions
+                    .into_iter()
+                    .map(|r| FormulaLatexResult {
+                        latex: r.latex,
+                        raw_text: r.raw_text,
+                        confidence: r.confidence as f64,
+                        needs_ocr: r.needs_ocr,
+                    })
+                    .collect(),
+            })
+            .collect())
+    })
+}
+
 /// Per-page markdown extraction result.
 #[napi(object)]
 pub struct PageMarkdownResult {

src/formula_latex/unicode_map.rs

@@ -0,0 +1,418 @@
+//! Unicode to LaTeX character mapping.
+//!
+//! Maps Unicode math symbols, Greek letters, operators, and relations to their
+//! LaTeX command equivalents. Only includes characters that commonly appear in
+//! PDF text extraction of mathematical formulas.
+
+use std::collections::HashMap;
+use std::sync::OnceLock;
+
+/// Returns a reference to the global Unicode → LaTeX mapping table.
+pub fn unicode_to_latex_map() -> &'static HashMap<char, &'static str> {
+    static MAP: OnceLock<HashMap<char, &'static str>> = OnceLock::new();
+    MAP.get_or_init(build_map)
+}
+
+fn build_map() -> HashMap<char, &'static str> {
+    let entries: &[(char, &str)] = &[
+        // ── Greek lowercase ─────────────────────────────────────────
+        ('\u{03B1}', r"\alpha"),
+        ('\u{03B2}', r"\beta"),
+        ('\u{03B3}', r"\gamma"),
+        ('\u{03B4}', r"\delta"),
+        ('\u{03B5}', r"\varepsilon"),
+        ('\u{03F5}', r"\epsilon"),
+        ('\u{03B6}', r"\zeta"),
+        ('\u{03B7}', r"\eta"),
+        ('\u{03B8}', r"\theta"),
+        ('\u{03D1}', r"\vartheta"),
+        ('\u{03B9}', r"\iota"),
+        ('\u{03BA}', r"\kappa"),
+        ('\u{03BB}', r"\lambda"),
+        ('\u{03BC}', r"\mu"),
+        ('\u{03BD}', r"\nu"),
+        ('\u{03BE}', r"\xi"),
+        ('\u{03C0}', r"\pi"),
+        ('\u{03D6}', r"\varpi"),
+        ('\u{03C1}', r"\rho"),
+        ('\u{03C2}', r"\varsigma"),
+        ('\u{03C3}', r"\sigma"),
+        ('\u{03C4}', r"\tau"),
+        ('\u{03C5}', r"\upsilon"),
+        ('\u{03C6}', r"\varphi"),
+        ('\u{03D5}', r"\phi"),
+        ('\u{03C7}', r"\chi"),
+        ('\u{03C8}', r"\psi"),
+        ('\u{03C9}', r"\omega"),
+        // ── Greek uppercase ─────────────────────────────────────────
+        ('\u{0393}', r"\Gamma"),
+        ('\u{0394}', r"\Delta"),
+        ('\u{0398}', r"\Theta"),
+        ('\u{039B}', r"\Lambda"),
+        ('\u{039E}', r"\Xi"),
+        ('\u{03A0}', r"\Pi"),
+        ('\u{03A3}', r"\Sigma"),
+        ('\u{03A5}', r"\Upsilon"),
+        ('\u{03A6}', r"\Phi"),
+        ('\u{03A8}', r"\Psi"),
+        ('\u{03A9}', r"\Omega"),
+        // ── Large operators ─────────────────────────────────────────
+        ('\u{222B}', r"\int"),
+        ('\u{222C}', r"\iint"),
+        ('\u{222D}', r"\iiint"),
+        ('\u{222E}', r"\oint"),
+        ('\u{2211}', r"\sum"),
+        ('\u{220F}', r"\prod"),
+        ('\u{2210}', r"\coprod"),
+        // ── Roots / radicals ────────────────────────────────────────
+        ('\u{221A}', r"\sqrt"),
+        // ── Calculus / differential ─────────────────────────────────
+        ('\u{2202}', r"\partial"),
+        ('\u{2207}', r"\nabla"),
+        // ── Binary operators ────────────────────────────────────────
+        ('\u{00B1}', r"\pm"),
+        ('\u{2213}', r"\mp"),
+        ('\u{00D7}', r"\times"),
+        ('\u{00F7}', r"\div"),
+        ('\u{2217}', r"\ast"),
+        ('\u{22C6}', r"\star"),
+        ('\u{00B7}', r"\cdot"),
+        ('\u{2219}', r"\bullet"),
+        ('\u{2218}', r"\circ"),
+        ('\u{2020}', r"\dagger"),
+        ('\u{2021}', r"\ddagger"),
+        ('\u{2295}', r"\oplus"),
+        ('\u{2297}', r"\otimes"),
+        ('\u{2227}', r"\wedge"),
+        ('\u{2228}', r"\vee"),
+        ('\u{2229}', r"\cap"),
+        ('\u{222A}', r"\cup"),
+        // ── Relations ───────────────────────────────────────────────
+        ('\u{2264}', r"\leq"),
+        ('\u{2265}', r"\geq"),
+        ('\u{2260}', r"\neq"),
+        ('\u{2248}', r"\approx"),
+        ('\u{223C}', r"\sim"),
+        ('\u{2243}', r"\simeq"),
+        ('\u{2261}', r"\equiv"),
+        ('\u{226A}', r"\ll"),
+        ('\u{226B}', r"\gg"),
+        ('\u{221D}', r"\propto"),
+        ('\u{2208}', r"\in"),
+        ('\u{2209}', r"\notin"),
+        ('\u{220B}', r"\ni"),
+        ('\u{2282}', r"\subset"),
+        ('\u{2283}', r"\supset"),
+        ('\u{2286}', r"\subseteq"),
+        ('\u{2287}', r"\supseteq"),
+        ('\u{22A2}', r"\vdash"),
+        ('\u{22A3}', r"\dashv"),
+        ('\u{22A4}', r"\top"),
+        ('\u{22A5}', r"\bot"),
+        ('\u{2225}', r"\parallel"),
+        ('\u{22A5}', r"\perp"),
+        // ── Arrows ──────────────────────────────────────────────────
+        ('\u{2190}', r"\leftarrow"),
+        ('\u{2192}', r"\to"),
+        ('\u{2191}', r"\uparrow"),
+        ('\u{2193}', r"\downarrow"),
+        ('\u{2194}', r"\leftrightarrow"),
+        ('\u{21D0}', r"\Leftarrow"),
+        ('\u{21D2}', r"\Rightarrow"),
+        ('\u{21D4}', r"\Leftrightarrow"),
+        ('\u{21A6}', r"\mapsto"),
+        ('\u{2197}', r"\nearrow"),
+        ('\u{2198}', r"\searrow"),
+        // ── Miscellaneous symbols ───────────────────────────────────
+        ('\u{221E}', r"\infty"),
+        ('\u{2200}', r"\forall"),
+        ('\u{2203}', r"\exists"),
+        ('\u{2204}', r"\nexists"),
+        ('\u{2205}', r"\emptyset"),
+        ('\u{00AC}', r"\neg"),
+        ('\u{00B0}', r"^\circ"),
+        ('\u{2032}', r"'"),  // prime (common in physics: x')
+        ('\u{2033}', r"''"), // double prime
+        ('\u{210F}', r"\hbar"),
+        ('\u{2113}', r"\ell"),
+        ('\u{211C}', r"\Re"),
+        ('\u{2111}', r"\Im"),
+        ('\u{2118}', r"\wp"),
+        ('\u{2135}', r"\aleph"),
+        // ── Dots ────────────────────────────────────────────────────
+        ('\u{22EF}', r"\cdots"),
+        ('\u{22EE}', r"\vdots"),
+        ('\u{22F1}', r"\ddots"),
+        ('\u{2026}', r"\ldots"),
+        // ── Delimiters / brackets ───────────────────────────────────
+        ('\u{27E8}', r"\langle"),
+        ('\u{27E9}', r"\rangle"),
+        ('\u{2308}', r"\lceil"),
+        ('\u{2309}', r"\rceil"),
+        ('\u{230A}', r"\lfloor"),
+        ('\u{230B}', r"\rfloor"),
+        ('\u{2016}', r"\|"),
+        // ── Accents / decorations (as standalone chars) ─────────────
+        ('\u{0302}', r"\hat{}"),
+        ('\u{0303}', r"\tilde{}"),
+        ('\u{0304}', r"\bar{}"),
+        ('\u{0307}', r"\dot{}"),
+        ('\u{0308}', r"\ddot{}"),
+        ('\u{20D7}', r"\vec{}"),
+        // Hat/tilde as standalone characters (sometimes extracted separately)
+        ('\u{02C6}', r"\hat{}"),
+        ('\u{02DC}', r"\tilde{}"),
+        // ── Subscript/superscript digits (Unicode) ──────────────────
+        ('\u{2070}', "^{0}"),
+        ('\u{00B9}', "^{1}"),
+        ('\u{00B2}', "^{2}"),
+        ('\u{00B3}', "^{3}"),
+        ('\u{2074}', "^{4}"),
+        ('\u{2075}', "^{5}"),
+        ('\u{2076}', "^{6}"),
+        ('\u{2077}', "^{7}"),
+        ('\u{2078}', "^{8}"),
+        ('\u{2079}', "^{9}"),
+        ('\u{207A}', "^{+}"),
+        ('\u{207B}', "^{-}"),
+        ('\u{2080}', "_{0}"),
+        ('\u{2081}', "_{1}"),
+        ('\u{2082}', "_{2}"),
+        ('\u{2083}', "_{3}"),
+        ('\u{2084}', "_{4}"),
+        ('\u{2085}', "_{5}"),
+        ('\u{2086}', "_{6}"),
+        ('\u{2087}', "_{7}"),
+        ('\u{2088}', "_{8}"),
+        ('\u{2089}', "_{9}"),
+        ('\u{208A}', "_{+}"),
+        ('\u{208B}', "_{-}"),
+        // ── Math italic letters (sometimes used in PDF fonts) ───────
+        // These map back to plain ASCII in LaTeX (math mode handles italics)
+    ];
+
+    let mut map = HashMap::with_capacity(entries.len());
+    for &(ch, latex) in entries {
+        map.insert(ch, latex);
+    }
+    map
+}
+
+/// Convert a single character to its LaTeX representation.
+///
+/// Returns `Some(latex_str)` if the character has a known mapping,
+/// or `None` if it should be kept as-is.
+pub fn char_to_latex(ch: char) -> Option<&'static str> {
+    unicode_to_latex_map().get(&ch).copied()
+}
+
+/// Returns true if a character is a "known math character" — either ASCII
+/// alphanumeric, basic punctuation used in math, or a mapped Unicode symbol.
+pub fn is_known_math_char(ch: char) -> bool {
+    if ch.is_ascii_alphanumeric() {
+        return true;
+    }
+    // Common ASCII math characters
+    matches!(
+        ch,
+        '+' | '-'
+            | '*'
+            | '/'
+            | '='
+            | '<'
+            | '>'
+            | '('
+            | ')'
+            | '['
+            | ']'
+            | '{'
+            | '}'
+            | ','
+            | '.'
+            | ':'
+            | ';'
+            | '!'
+            | '|'
+            | '\''
+            | '"'
+            | '^'
+            | '_'
+            | '~'
+            | ' '
+            | '\n'
+            | '\t'
+    ) || unicode_to_latex_map().contains_key(&ch)
+}
+
+/// Convert a string of text to LaTeX, applying per-character mappings.
+/// Characters without mappings are left as-is.
+///
+/// Returns `(latex_string, fraction_of_chars_that_were_known)`.
+pub fn text_to_latex_chars(text: &str) -> (String, f32) {
+    let map = unicode_to_latex_map();
+    let mut result = String::with_capacity(text.len() * 2);
+    let mut total_nonws = 0usize;
+    let mut known = 0usize;
+
+    for ch in text.chars() {
+        if ch.is_whitespace() {
+            result.push(ch);
+            continue;
+        }
+        total_nonws += 1;
+
+        if let Some(latex) = map.get(&ch) {
+            // Add space before LaTeX commands that start with backslash
+            // to prevent them from merging with preceding text
+            if latex.starts_with('\\') && !result.is_empty() && !result.ends_with(' ') {
+                // Only add space if the last char is alphanumeric (to avoid "x \alpha" but allow "( \alpha")
+                let last = result.chars().last().unwrap();
+                if last.is_alphanumeric() || last == '}' {
+                    result.push(' ');
+                }
+            }
+            result.push_str(latex);
+            // Add trailing space after LaTeX commands so next char doesn't merge
+            if latex.starts_with('\\') && !latex.ends_with('}') && !latex.ends_with('\'') {
+                result.push(' ');
+            }
+            known += 1;
+        } else if is_known_math_char(ch) {
+            result.push(ch);
+            known += 1;
+        } else {
+            // Unknown character — keep it but it lowers confidence
+            result.push(ch);
+        }
+    }
+
+    let frac = if total_nonws == 0 {
+        1.0
+    } else {
+        known as f32 / total_nonws as f32
+    };
+    (result, frac)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_greek_lowercase() {
+        assert_eq!(char_to_latex('\u{03B1}'), Some(r"\alpha"));
+        assert_eq!(char_to_latex('\u{03B2}'), Some(r"\beta"));
+        assert_eq!(char_to_latex('\u{03B3}'), Some(r"\gamma"));
+        assert_eq!(char_to_latex('\u{03B4}'), Some(r"\delta"));
+        assert_eq!(char_to_latex('\u{03B5}'), Some(r"\varepsilon"));
+        assert_eq!(char_to_latex('\u{03B6}'), Some(r"\zeta"));
+        assert_eq!(char_to_latex('\u{03B7}'), Some(r"\eta"));
+        assert_eq!(char_to_latex('\u{03B8}'), Some(r"\theta"));
+        assert_eq!(char_to_latex('\u{03D1}'), Some(r"\vartheta"));
+        assert_eq!(char_to_latex('\u{03B9}'), Some(r"\iota"));
+        assert_eq!(char_to_latex('\u{03BA}'), Some(r"\kappa"));
+        assert_eq!(char_to_latex('\u{03BB}'), Some(r"\lambda"));
+        assert_eq!(char_to_latex('\u{03BC}'), Some(r"\mu"));
+        assert_eq!(char_to_latex('\u{03BD}'), Some(r"\nu"));
+        assert_eq!(char_to_latex('\u{03BE}'), Some(r"\xi"));
+        assert_eq!(char_to_latex('\u{03C0}'), Some(r"\pi"));
+        assert_eq!(char_to_latex('\u{03C1}'), Some(r"\rho"));
+        assert_eq!(char_to_latex('\u{03C3}'), Some(r"\sigma"));
+        assert_eq!(char_to_latex('\u{03C4}'), Some(r"\tau"));
+        assert_eq!(char_to_latex('\u{03C9}'), Some(r"\omega"));
+    }
+
+    #[test]
+    fn test_greek_uppercase() {
+        assert_eq!(char_to_latex('\u{0393}'), Some(r"\Gamma"));
+        assert_eq!(char_to_latex('\u{0394}'), Some(r"\Delta"));
+        assert_eq!(char_to_latex('\u{0398}'), Some(r"\Theta"));
+        assert_eq!(char_to_latex('\u{039B}'), Some(r"\Lambda"));
+        assert_eq!(char_to_latex('\u{03A3}'), Some(r"\Sigma"));
+        assert_eq!(char_to_latex('\u{03A6}'), Some(r"\Phi"));
+        assert_eq!(char_to_latex('\u{03A9}'), Some(r"\Omega"));
+    }
+
+    #[test]
+    fn test_operators() {
+        assert_eq!(char_to_latex('\u{222B}'), Some(r"\int"));
+        assert_eq!(char_to_latex('\u{2211}'), Some(r"\sum"));
+        assert_eq!(char_to_latex('\u{220F}'), Some(r"\prod"));
+        assert_eq!(char_to_latex('\u{221A}'), Some(r"\sqrt"));
+        assert_eq!(char_to_latex('\u{2202}'), Some(r"\partial"));
+        assert_eq!(char_to_latex('\u{2207}'), Some(r"\nabla"));
+    }
+
+    #[test]
+    fn test_relations() {
+        assert_eq!(char_to_latex('\u{2264}'), Some(r"\leq"));
+        assert_eq!(char_to_latex('\u{2265}'), Some(r"\geq"));
+        assert_eq!(char_to_latex('\u{2260}'), Some(r"\neq"));
+        assert_eq!(char_to_latex('\u{2248}'), Some(r"\approx"));
+        assert_eq!(char_to_latex('\u{223C}'), Some(r"\sim"));
+        assert_eq!(char_to_latex('\u{226A}'), Some(r"\ll"));
+        assert_eq!(char_to_latex('\u{226B}'), Some(r"\gg"));
+        assert_eq!(char_to_latex('\u{221E}'), Some(r"\infty"));
+        assert_eq!(char_to_latex('\u{2208}'), Some(r"\in"));
+        assert_eq!(char_to_latex('\u{2209}'), Some(r"\notin"));
+        assert_eq!(char_to_latex('\u{2282}'), Some(r"\subset"));
+    }
+
+    #[test]
+    fn test_misc_symbols() {
+        assert_eq!(char_to_latex('\u{00B1}'), Some(r"\pm"));
+        assert_eq!(char_to_latex('\u{00D7}'), Some(r"\times"));
+        assert_eq!(char_to_latex('\u{00B7}'), Some(r"\cdot"));
+        assert_eq!(char_to_latex('\u{00B0}'), Some(r"^\circ"));
+        assert_eq!(char_to_latex('\u{2192}'), Some(r"\to"));
+        assert_eq!(char_to_latex('\u{21D2}'), Some(r"\Rightarrow"));
+        assert_eq!(char_to_latex('\u{210F}'), Some(r"\hbar"));
+    }
+
+    #[test]
+    fn test_unicode_super_sub_digits() {
+        assert_eq!(char_to_latex('\u{00B2}'), Some("^{2}"));
+        assert_eq!(char_to_latex('\u{00B3}'), Some("^{3}"));
+        assert_eq!(char_to_latex('\u{2082}'), Some("_{2}"));
+        assert_eq!(char_to_latex('\u{2083}'), Some("_{3}"));
+    }
+
+    #[test]
+    fn test_is_known_math_char() {
+        // ASCII math
+        assert!(is_known_math_char('+'));
+        assert!(is_known_math_char('='));
+        assert!(is_known_math_char('('));
+        assert!(is_known_math_char('x'));
+        assert!(is_known_math_char('0'));
+        // Mapped Unicode
+        assert!(is_known_math_char('\u{03B1}')); // alpha
+        assert!(is_known_math_char('\u{2264}')); // leq
+                                                 // Unknown
+        assert!(!is_known_math_char('\u{E000}')); // PUA
+        assert!(!is_known_math_char('\u{4E00}')); // CJK
+    }
+
+    #[test]
+    fn test_text_to_latex_simple() {
+        let (latex, frac) = text_to_latex_chars("x + y");
+        assert_eq!(latex, "x + y");
+        assert!((frac - 1.0).abs() < 0.01);
+    }
+
+    #[test]
+    fn test_text_to_latex_greek() {
+        let (latex, frac) = text_to_latex_chars("αβγ");
+        assert!(latex.contains(r"\alpha"));
+        assert!(latex.contains(r"\beta"));
+        assert!(latex.contains(r"\gamma"));
+        assert!((frac - 1.0).abs() < 0.01);
+    }
+
+    #[test]
+    fn test_text_to_latex_mixed() {
+        let (latex, frac) = text_to_latex_chars("x ≤ y");
+        assert!(latex.contains(r"\leq"));
+        assert!((frac - 1.0).abs() < 0.01);
+    }
+}

src/lib.rs

@@ -28,6 +28,7 @@ pub mod python;
 pub mod adobe_korea1;
 pub mod detector;
 pub mod extractor;
+pub mod formula_latex;
 pub mod glyph_names;
 pub mod markdown;
 pub mod process_mode;
@@ -462,6 +463,98 @@ pub struct PageRegionResult {
     pub regions: Vec<RegionText>,
 }
 
+/// Shared page extraction state for region-based extraction functions.
+struct RegionExtractionData {
+    items_by_page: HashMap<u32, Vec<TextItem>>,
+    page_heights: HashMap<u32, f32>,
+    #[allow(dead_code)]
+    gid_pages: HashSet<u32>,
+    page_thresholds: HashMap<u32, f32>,
+    rotated_pages: HashSet<u32>,
+}
+
+/// Extract text items, page heights, and metadata for the pages needed by region queries.
+///
+/// This is the shared boilerplate for `extract_text_in_regions_mem`,
+/// `extract_tables_in_regions_mem`, and `extract_formulas_in_regions_mem`.
+fn prepare_region_extraction(
+    buffer: &[u8],
+    page_regions: &[(u32, Vec<[f32; 4]>)],
+) -> Result<RegionExtractionData, PdfError> {
+    validate_pdf_bytes(buffer)?;
+    let (doc, _page_count) = load_document_from_mem(buffer)?;
+    let pages = doc.get_pages();
+
+    let needed_pages: HashSet<u32> = page_regions.iter().map(|(p, _)| p + 1).collect();
+
+    // Fast mode: skip expensive TrueType font fallback parsing.
+    // Fonts that can't be decoded from ToUnicode alone will produce empty/garbage
+    // text, triggering needs_ocr=true → GPU OCR fallback in the pipeline.
+    let font_cmaps = FontCMaps::from_doc_pages_fast(&doc, Some(&needed_pages));
+
+    let mut items_by_page: HashMap<u32, Vec<TextItem>> = HashMap::new();
+    let mut page_heights: HashMap<u32, f32> = HashMap::new();
+    let mut gid_pages: HashSet<u32> = HashSet::new();
+    let mut page_thresholds: HashMap<u32, f32> = HashMap::new();
+    let mut rotated_pages: HashSet<u32> = HashSet::new();
+
+    for (page_num, &page_id) in pages.iter() {
+        if !needed_pages.contains(page_num) {
+            continue;
+        }
+
+        let height = get_page_height(&doc, page_id).unwrap_or(792.0);
+        page_heights.insert(*page_num, height);
+
+        let ((mut items, _rects, _lines), has_gid, coords_rotated) =
+            extractor::content_stream::extract_page_text_items(
+                &doc,
+                page_id,
+                *page_num,
+                &font_cmaps,
+                false,
+            )?;
+        let threshold = text_utils::fix_letterspaced_items(&mut items);
+        if threshold > 0.10 {
+            page_thresholds.insert(*page_num, threshold);
+        }
+        if has_gid {
+            gid_pages.insert(*page_num);
+        }
+        if coords_rotated {
+            rotated_pages.insert(*page_num);
+        }
+        items_by_page.insert(*page_num, items);
+    }
+
+    Ok(RegionExtractionData {
+        items_by_page,
+        page_heights,
+        gid_pages,
+        page_thresholds,
+        rotated_pages,
+    })
+}
+
+/// Resolve per-page coord space and adaptive threshold for a given page.
+fn page_region_context(
+    data: &RegionExtractionData,
+    page_1idx: u32,
+) -> (f32, f32, RegionCoordSpace) {
+    let page_h = data.page_heights.get(&page_1idx).copied().unwrap_or(792.0);
+    let adaptive_threshold = data
+        .page_thresholds
+        .get(&page_1idx)
+        .copied()
+        .unwrap_or(0.10);
+    let coords = if data.rotated_pages.contains(&page_1idx) {
+        RegionCoordSpace::Rotated90Ccw
+    } else {
+        RegionCoordSpace::Standard
+    };
+    (page_h, adaptive_threshold, coords)
+}
+
 /// Extract text within bounding-box regions from a PDF in memory.
 ///
 /// This is designed for hybrid OCR pipelines: a layout model detects regions
@@ -485,70 +578,14 @@ pub fn extract_text_in_regions_mem(
     buffer: &[u8],
     page_regions: &[(u32, Vec<[f32; 4]>)],
 ) -> Result<Vec<PageRegionResult>, PdfError> {
-    validate_pdf_bytes(buffer)?;
-    let (doc, _page_count) = load_document_from_mem(buffer)?;
-    let pages = doc.get_pages();
+    let data = prepare_region_extraction(buffer, page_regions)?;
 
-    // Build a set of pages we need to extract (1-indexed for lopdf)
-    let needed_pages: HashSet<u32> = page_regions.iter().map(|(p, _)| p + 1).collect();
-
-    // Fast mode: skip expensive TrueType font fallback parsing.
-    // Fonts that can't be decoded from ToUnicode alone will produce empty/garbage
-    // text, triggering needs_ocr=true → GPU OCR fallback in the pipeline.
-    let font_cmaps = FontCMaps::from_doc_pages_fast(&doc, Some(&needed_pages));
-
-    // Extract text items for needed pages only
-    let mut items_by_page: HashMap<u32, Vec<TextItem>> = HashMap::new();
-    let mut page_heights: HashMap<u32, f32> = HashMap::new();
-    let mut gid_pages: HashSet<u32> = HashSet::new();
-    let mut page_thresholds: HashMap<u32, f32> = HashMap::new();
-    let mut rotated_pages: HashSet<u32> = HashSet::new();
-
-    for (page_num, &page_id) in pages.iter() {
-        if !needed_pages.contains(page_num) {
-            continue;
-        }
-
-        // Get page height from MediaBox for coordinate flip
-        let height = get_page_height(&doc, page_id).unwrap_or(792.0);
-        page_heights.insert(*page_num, height);
-
-        // Extract text items for this page
-        let ((mut items, _rects, _lines), has_gid, coords_rotated) =
-            extractor::content_stream::extract_page_text_items(
-                &doc,
-                page_id,
-                *page_num,
-                &font_cmaps,
-                false,
-            )?;
-        let threshold = text_utils::fix_letterspaced_items(&mut items);
-        if threshold > 0.10 {
-            page_thresholds.insert(*page_num, threshold);
-        }
-        if has_gid {
-            gid_pages.insert(*page_num);
-        }
-        if coords_rotated {
-            rotated_pages.insert(*page_num);
-        }
-        items_by_page.insert(*page_num, items);
-    }
-
-    // For each page's regions, filter and assemble text
     let mut results = Vec::with_capacity(page_regions.len());
 
     for (page_0idx, regions) in page_regions {
         let page_1idx = page_0idx + 1;
-        let items = items_by_page.get(&page_1idx);
-        let page_h = page_heights.get(&page_1idx).copied().unwrap_or(792.0);
-        let _page_has_gid = gid_pages.contains(&page_1idx);
-        let adaptive_threshold = page_thresholds.get(&page_1idx).copied().unwrap_or(0.10);
-        let coords = if rotated_pages.contains(&page_1idx) {
-            RegionCoordSpace::Rotated90Ccw
-        } else {
-            RegionCoordSpace::Standard
-        };
+        let items = data.items_by_page.get(&page_1idx);
+        let (page_h, adaptive_threshold, coords) = page_region_context(&data, page_1idx);
 
         let mut page_results = Vec::with_capacity(regions.len());
 
@@ -602,74 +639,20 @@ pub fn extract_tables_in_regions_mem(
     buffer: &[u8],
     page_regions: &[(u32, Vec<[f32; 4]>)],
 ) -> Result<Vec<PageRegionResult>, PdfError> {
-    validate_pdf_bytes(buffer)?;
-    let (doc, _page_count) = load_document_from_mem(buffer)?;
-    let pages = doc.get_pages();
-
-    let needed_pages: HashSet<u32> = page_regions.iter().map(|(p, _)| p + 1).collect();
-    let font_cmaps = FontCMaps::from_doc_pages_fast(&doc, Some(&needed_pages));
-
-    let mut items_by_page: HashMap<u32, Vec<TextItem>> = HashMap::new();
-    let mut page_heights: HashMap<u32, f32> = HashMap::new();
-    let mut gid_pages: HashSet<u32> = HashSet::new();
-    let mut page_thresholds: HashMap<u32, f32> = HashMap::new();
-    let mut rotated_pages: HashSet<u32> = HashSet::new();
-
-    for (page_num, &page_id) in pages.iter() {
-        if !needed_pages.contains(page_num) {
-            continue;
-        }
-        let height = get_page_height(&doc, page_id).unwrap_or(792.0);
-        page_heights.insert(*page_num, height);
-
-        let ((mut items, _rects, _lines), has_gid, coords_rotated) =
-            extractor::content_stream::extract_page_text_items(
-                &doc,
-                page_id,
-                *page_num,
-                &font_cmaps,
-                false,
-            )?;
-        let threshold = text_utils::fix_letterspaced_items(&mut items);
-        if threshold > 0.10 {
-            page_thresholds.insert(*page_num, threshold);
-        }
-        if has_gid {
-            gid_pages.insert(*page_num);
-        }
-        if coords_rotated {
-            rotated_pages.insert(*page_num);
-        }
-        items_by_page.insert(*page_num, items);
-    }
+    let data = prepare_region_extraction(buffer, page_regions)?;
 
     let mut results = Vec::with_capacity(page_regions.len());
 
     for (page_0idx, regions) in page_regions {
         let page_1idx = page_0idx + 1;
-        let items = items_by_page.get(&page_1idx);
-        let page_h = page_heights.get(&page_1idx).copied().unwrap_or(792.0);
-        let _page_has_gid = gid_pages.contains(&page_1idx);
-        let coords = if rotated_pages.contains(&page_1idx) {
-            RegionCoordSpace::Rotated90Ccw
-        } else {
-            RegionCoordSpace::Standard
-        };
+        let items = data.items_by_page.get(&page_1idx);
+        let (page_h, _adaptive_threshold, coords) = page_region_context(&data, page_1idx);
 
         let mut page_results = Vec::with_capacity(regions.len());
 
         for rect in regions {
             let [rx1, ry1, rx2, ry2] = *rect;
 
-            // Note: we intentionally DO NOT bail on page_has_gid here.
-            // The GID flag means some font on the page uses unresolvable
-            // glyph IDs, but that font may only appear in a logo or
-            // header — not in the table region. Instead we let the
-            // per-region text quality checks (is_garbage_text, is_cid_garbage,
-            // detect_encoding_issues) reject based on the actual extracted
-            // content. This avoids rejecting clean tables just because an
-            // unrelated decorative font on the same page is GID-encoded.
-
             let matched: Vec<TextItem> = match items {
                 Some(items) => {
                     let bounds = region_bounds(rx1, ry1, rx2, ry2, page_h, coords);
@@ -750,6 +733,164 @@ pub fn extract_tables_in_regions_mem(
     Ok(results)
 }
 
+/// Extract formula text within bounding-box regions from a PDF in memory.
+///
+/// Similar to [`extract_text_in_regions_mem`] but uses formula-specific quality
+/// checks. Formula text is legitimately symbol-heavy (Greek letters, math
+/// operators, subscripts) so the generic `is_garbage_text` check — which rejects
+/// text with <50% alphanumeric characters — would false-positive on valid
+/// formula regions.
+///
+/// When the extracted text decodes cleanly, `needs_ocr` is `false` and the
+/// caller can skip GPU OCR. When extraction fails (empty, PUA-heavy, encoding
+/// issues), `needs_ocr` is `true` for OCR fallback.
+pub fn extract_formulas_in_regions_mem(
+    buffer: &[u8],
+    page_regions: &[(u32, Vec<[f32; 4]>)],
+) -> Result<Vec<PageRegionResult>, PdfError> {
+    let data = prepare_region_extraction(buffer, page_regions)?;
+
+    let mut results = Vec::with_capacity(page_regions.len());
+
+    for (page_0idx, regions) in page_regions {
+        let page_1idx = page_0idx + 1;
+        let items = data.items_by_page.get(&page_1idx);
+        let (page_h, adaptive_threshold, coords) = page_region_context(&data, page_1idx);
+
+        let mut page_results = Vec::with_capacity(regions.len());
+
+        for rect in regions {
+            let [rx1, ry1, rx2, ry2] = *rect;
+
+            let text = match items {
+                Some(items) => collect_text_in_region_with_options(
+                    items,
+                    rx1,
+                    ry1,
+                    rx2,
+                    ry2,
+                    page_h,
+                    coords,
+                    adaptive_threshold,
+                ),
+                None => String::new(),
+            };
+
+            // Formula-specific quality checks:
+            // - Skip is_garbage_text (formulas are legitimately symbol-heavy)
+            // - Keep CID/encoding checks (broken font decode is still broken)
+            // - Add PUA check (extensible delimiters that didn't decode)
+            let needs_ocr = text.trim().is_empty()
+                || is_cid_garbage(&text)
+                || detect_encoding_issues(&text)
+                || is_formula_garbage(&text);
+
+            page_results.push(RegionText { text, needs_ocr });
+        }
+
+        results.push(PageRegionResult {
+            page: *page_0idx,
+            regions: page_results,
+        });
+    }
+
+    Ok(results)
+}
+
+/// Extract formula text within bounding-box regions and reconstruct LaTeX.
+///
+/// For each formula bbox, this function:
+/// 1. Gets positioned text items inside the bbox
+/// 2. Analyzes font sizes and vertical positions to detect sub/superscripts
+/// 3. Detects simple fractions from vertically stacked text
+/// 4. Converts Unicode math symbols to LaTeX commands
+/// 5. Reconstructs structured LaTeX from the positioned items
+///
+/// Each result includes a `confidence` score (0.0–1.0) indicating how reliable
+/// the LaTeX reconstruction is. Low-confidence results should be sent to GPU OCR.
+///
+/// The `needs_ocr` flag is set only when extraction fails entirely (empty text,
+/// encoding garbage), NOT based on confidence — the caller decides the threshold.
+pub fn extract_formulas_in_regions_as_latex(
+    buffer: &[u8],
+    page_regions: &[(u32, Vec<[f32; 4]>)],
+) -> Result<Vec<formula_latex::PageFormulaResult>, PdfError> {
+    let data = prepare_region_extraction(buffer, page_regions)?;
+
+    let mut results = Vec::with_capacity(page_regions.len());
+
+    for (page_0idx, regions) in page_regions {
+        let page_1idx = page_0idx + 1;
+        let items = data.items_by_page.get(&page_1idx);
+        let (page_h, _adaptive_threshold, coords) = page_region_context(&data, page_1idx);
+
+        let mut page_results = Vec::with_capacity(regions.len());
+
+        for rect in regions {
+            let [rx1, ry1, rx2, ry2] = *rect;
+
+            let result = match items {
+                Some(items) => {
+                    // Convert the bbox from top-left origin to the item coordinate space
+                    let bounds = region_bounds(rx1, ry1, rx2, ry2, page_h, coords);
+
+                    // Filter items whose center falls inside the bbox
+                    let matched = formula_latex::filter_items_in_bbox(
+                        items,
+                        bounds.x_min,
+                        bounds.y_min,
+                        bounds.x_max,
+                        bounds.y_max,
+                    );
+
+                    if matched.is_empty() {
+                        formula_latex::FormulaResult {
+                            latex: String::new(),
+                            raw_text: String::new(),
+                            confidence: 0.0,
+                            needs_ocr: true,
+                            confidence_breakdown: Vec::new(),
+                        }
+                    } else {
+                        let (latex, raw_text, confidence, confidence_breakdown) =
+                            formula_latex::reconstruct_latex(&matched);
+
+                        // Same formula-specific quality checks as extract_formulas_in_regions_mem
+                        let needs_ocr = raw_text.trim().is_empty()
+                            || is_cid_garbage(&raw_text)
+                            || detect_encoding_issues(&raw_text)
+                            || is_formula_garbage(&raw_text);
+
+                        formula_latex::FormulaResult {
+                            latex,
+                            raw_text,
+                            confidence,
+                            needs_ocr,
+                            confidence_breakdown,
+                        }
+                    }
+                }
+                None => formula_latex::FormulaResult {
+                    latex: String::new(),
+                    raw_text: String::new(),
+                    confidence: 0.0,
+                    needs_ocr: true,
+                    confidence_breakdown: Vec::new(),
+                },
+            };
+
+            page_results.push(result);
+        }
+
+        results.push(formula_latex::PageFormulaResult {
+            page: *page_0idx,
+            regions: page_results,
+        });
+    }
+
+    Ok(results)
+}
+
 /// Get page height in points from MediaBox.
 fn get_page_height(doc: &Document, page_id: lopdf::ObjectId) -> Option<f32> {
     let page_dict = doc.get_dictionary(page_id).ok()?;
@@ -1347,6 +1488,49 @@ fn is_cid_garbage(text: &str) -> bool {
     high_latin * 5 >= total * 2 && ascii_letters * 3 < total
 }
 
+/// Detect formula text that is unlikely to be usable despite passing generic checks.
+///
+/// Formula text (Greek letters, math operators, variables) is legitimately
+/// symbol-heavy, so `is_garbage_text` would false-positive. This check instead
+/// catches:
+///
+/// 1. **Private Use Area (PUA) characters** — TeX extensible delimiter glyphs
+///    (large brackets from CMEX fonts) often map to PUA U+E000–F8FF when the
+///    ToUnicode CMap is missing. >10% PUA means significant undecoded content.
+///
+/// 2. **Control characters** — C0 controls (U+0000–001F excluding whitespace)
+///    indicate broken font encoding, not formula content. >30% is rejected.
+fn is_formula_garbage(text: &str) -> bool {
+    let mut total = 0usize;
+    let mut pua = 0usize;
+    let mut control = 0usize;
+    for ch in text.chars() {
+        if ch.is_whitespace() {
+            continue;
+        }
+        total += 1;
+        if ('\u{E000}'..='\u{F8FF}').contains(&ch) {
+            pua += 1;
+        }
+        let cp = ch as u32;
+        if cp < 0x20 {
+            control += 1;
+        }
+    }
+    if total < 3 {
+        return false;
+    }
+    // >10% PUA — significant undecoded extensible delimiters
+    if pua * 10 > total {
+        return true;
+    }
+    // >30% control chars — broken encoding
+    if control * 10 > total * 3 {
+        return true;
+    }
+    false
+}
+
 /// Detect markdown tables with suspicious structure that suggest the heuristic
 /// missed/mangled rows or columns. Returns true when the caller should treat
 /// the result as `needs_ocr` and fall back to GPU OCR.
@@ -2064,4 +2248,58 @@ mod tests {
             "Valid Japanese text should not be flagged as garbage"
         );
     }
+
+    #[test]
+    fn test_is_formula_garbage_accepts_math_text() {
+        // Greek letters, math operators, variables — typical formula text
+        let formula = "Φ(ν) = ∫ ∞ dze −it r1 − iνr2 sinh z";
+        assert!(
+            !is_formula_garbage(formula),
+            "Valid formula text should not be flagged as garbage"
+        );
+
+        // Dense operator text
+        let operators = "α + β − γ × δ ÷ ε ≤ ζ ≥ η ≈ θ ≠ ι ± κ";
+        assert!(
+            !is_formula_garbage(operators),
+            "Math operator text should not be flagged as garbage"
+        );
+
+        // Short formula (e.g. single equation variable)
+        let short = "αβ";
+        assert!(
+            !is_formula_garbage(short),
+            "Short formula text should not be flagged"
+        );
+    }
+
+    #[test]
+    fn test_is_formula_garbage_rejects_pua_heavy() {
+        // Simulates extensible delimiters from CMEX fonts mapping to PUA
+        let pua_heavy = "x \u{F8EB} \u{F8EC} \u{F8ED} \u{F8F6} \u{F8F7} \u{F8F8} y";
+        assert!(
+            is_formula_garbage(pua_heavy),
+            "PUA-heavy text should be flagged as formula garbage"
+        );
+    }
+
+    #[test]
+    fn test_is_formula_garbage_rejects_control_chars() {
+        // Control characters indicate broken encoding
+        let control_heavy = "a\x01b\x02c\x03d\x04e\x05f\x06g\x07h\x08i";
+        assert!(
+            is_formula_garbage(control_heavy),
+            "Control-char-heavy text should be flagged as formula garbage"
+        );
+    }
+
+    #[test]
+    fn test_is_formula_garbage_accepts_few_pua() {
+        // A few PUA chars among many valid chars is fine (<10% threshold)
+        let mostly_good = "Φ(ν) = ∫ dze r1 − iνr2 sinh z α β γ δ ε ζ η θ \u{F8EB}";
+        assert!(
+            !is_formula_garbage(mostly_good),
+            "Mostly-good text with rare PUA should pass"
+        );
+    }
 }

src/tables/detect_heuristic.rs

@@ -1144,6 +1144,33 @@ pub(crate) fn find_first_table_row(
             continue;
         }
 
+        // Skip rows that have duplicate non-empty cells. These are spanning
+        // super-headers (e.g., "First Degree | First Degree | Higher Degree")
+        // that sit above the real column header row. Using them as the markdown
+        // header produces duplicate column names that downstream validation
+        // rejects. Only skip if a subsequent row looks like a better header
+        // (denser fill or has data).
+        if filled_count >= 2 && !has_data {
+            let mut text_counts: std::collections::HashMap<&str, usize> =
+                std::collections::HashMap::new();
+            for cell in &filled_cells {
+                *text_counts.entry(cell.trim()).or_insert(0) += 1;
+            }
+            let has_duplicates = text_counts.values().any(|&count| count >= 2);
+            if has_duplicates {
+                // Check if a later row is a better header candidate
+                let has_better_below = cells.iter().skip(row_idx + 1).take(3).any(|r| {
+                    let next_filled = r.iter().filter(|c| !c.trim().is_empty()).count();
+                    let next_fill = next_filled as f32 / total_cols as f32;
+                    let next_numeric = r.iter().filter(|c| looks_like_number(c.trim())).count();
+                    next_fill >= 0.4 || next_numeric >= 2
+                });
+                if has_better_below {
+                    continue;
+                }
+            }
+        }
+
         // Data rows are definitely table content
         if has_data {
             first_table_row = row_idx;

src/tables/grid.rs

@@ -82,33 +82,42 @@ pub(crate) fn find_column_boundaries(
         }
     }
 
-    let mut columns = Vec::new();
-    let mut cluster_items: Vec<f32> = vec![x_positions[0]];
+    // Track cluster membership: for each cluster, store the list of x positions
+    let mut cluster_xs: Vec<Vec<f32>> = vec![vec![x_positions[0]]];
 
     for &x in &x_positions[1..] {
+        let last_cluster = cluster_xs.last().unwrap();
         // For dense columns (gap-histogram triggered), use edge-based clustering:
         // compare with the last item to avoid center-drift that merges adjacent
         // narrow columns.  For normal tables, use center-based (original behavior).
         let reference = if use_edge_clustering {
-            *cluster_items.last().unwrap()
+            *last_cluster.last().unwrap()
         } else {
-            cluster_items.iter().sum::<f32>() / cluster_items.len() as f32
+            last_cluster.iter().sum::<f32>() / last_cluster.len() as f32
         };
 
         if x - reference > cluster_threshold {
-            let cluster_center = cluster_items.iter().sum::<f32>() / cluster_items.len() as f32;
-            columns.push(cluster_center);
-            cluster_items = vec![x];
+            cluster_xs.push(vec![x]);
         } else {
-            cluster_items.push(x);
+            cluster_xs.last_mut().unwrap().push(x);
         }
     }
 
-    // Don't forget last cluster
-    if !cluster_items.is_empty() {
-        columns.push(cluster_items.iter().sum::<f32>() / cluster_items.len() as f32);
+    // Numeric column merge pass: when a sparse cluster (few items, typically
+    // header text) is adjacent to a dense numeric cluster and within 1.5×
+    // threshold, merge them. This fixes tables where multi-line wrapped
+    // headers have slightly different X positions than the data columns,
+    // causing the header and data to split into separate clusters.
+    let columns_before_merge = cluster_xs.len();
+    if columns_before_merge >= 3 {
+        cluster_xs = merge_numeric_adjacent_clusters(cluster_xs, items, cluster_threshold);
     }
 
+    let columns: Vec<f32> = cluster_xs
+        .iter()
+        .map(|xs| xs.iter().sum::<f32>() / xs.len() as f32)
+        .collect();
+
     // Filter columns - each should have multiple items
     let min_items_per_col = (items.len() / columns.len().max(1) / 4).max(2);
     let columns: Vec<f32> = columns
@@ -123,8 +132,9 @@ pub(crate) fn find_column_boundaries(
         .collect();
 
     log::debug!(
-        "  find_column_boundaries: {} columns before filter, threshold={:.1}, {} items",
+        "  find_column_boundaries: {} columns (merged from {}), threshold={:.1}, {} items",
         columns.len(),
+        columns_before_merge,
         cluster_threshold,
         items.len()
     );
@@ -148,6 +158,116 @@ pub(crate) fn find_column_boundaries(
     columns
 }
 
+/// Check if a text string looks like a number (digits, decimals, sign, comma).
+fn is_numeric_text(s: &str) -> bool {
+    let s = s.trim();
+    if s.is_empty() {
+        return false;
+    }
+    // Match patterns like: 8.23, -1.05, 9.99, 7.12, 100, 3,456.78, +5%, ---
+    // But NOT: BIO, Department, Core Courses
+    s.chars()
+        .all(|c| c.is_ascii_digit() || c == '.' || c == ',' || c == '-' || c == '+' || c == '%')
+        && s.chars().any(|c| c.is_ascii_digit())
+}
+
+/// Merge adjacent X-position clusters when one is a sparse header cluster
+/// and the other is a dense numeric data cluster. This prevents multi-line
+/// wrapped headers from splitting a logical column into two clusters.
+fn merge_numeric_adjacent_clusters(
+    mut clusters: Vec<Vec<f32>>,
+    items: &[(usize, &TextItem)],
+    threshold: f32,
+) -> Vec<Vec<f32>> {
+    // For each cluster, compute: center, item count, numeric fraction
+    struct ClusterInfo {
+        center: f32,
+        count: usize,
+        numeric_frac: f32,
+    }
+
+    let compute_info = |xs: &[f32]| -> ClusterInfo {
+        let center = xs.iter().sum::<f32>() / xs.len() as f32;
+        // Count items and numeric fraction for items near this cluster center
+        let mut total = 0;
+        let mut numeric = 0;
+        for (_, item) in items {
+            if (item.x - center).abs() < threshold {
+                total += 1;
+                if is_numeric_text(&item.text) {
+                    numeric += 1;
+                }
+            }
+        }
+        ClusterInfo {
+            center,
+            count: total,
+            numeric_frac: if total > 0 {
+                numeric as f32 / total as f32
+            } else {
+                0.0
+            },
+        }
+    };
+
+    // Merge distance: allow merging clusters that are slightly beyond the
+    // original threshold. Use 1.5× threshold to catch header-vs-data splits.
+    let merge_dist = threshold * 1.5;
+
+    // Iterate and merge adjacent pairs. Use a simple left-to-right scan.
+    let mut merged = true;
+    while merged {
+        merged = false;
+        let mut i = 0;
+        while i + 1 < clusters.len() {
+            let info_a = compute_info(&clusters[i]);
+            let info_b = compute_info(&clusters[i + 1]);
+            let dist = (info_b.center - info_a.center).abs();
+
+            if dist > merge_dist {
+                i += 1;
+                continue;
+            }
+
+            // Determine if one cluster is sparse (header) and the other
+            // is dense and numeric (data). A cluster is "sparse" if it has
+            // significantly fewer items than the other.
+            let (sparse, dense) = if info_a.count < info_b.count {
+                (&info_a, &info_b)
+            } else {
+                (&info_b, &info_a)
+            };
+
+            // Merge if the dense cluster is predominantly numeric (>50%)
+            // and the sparse cluster has at most 1/3 the items of the dense one.
+            let should_merge =
+                dense.numeric_frac > 0.50 && sparse.count <= dense.count / 2 && sparse.count <= 5;
+
+            if should_merge {
+                log::debug!(
+                    "  merging column clusters: center {:.1} ({} items, {:.0}% numeric) + {:.1} ({} items, {:.0}% numeric), dist={:.1}",
+                    info_a.center,
+                    info_a.count,
+                    info_a.numeric_frac * 100.0,
+                    info_b.center,
+                    info_b.count,
+                    info_b.numeric_frac * 100.0,
+                    dist,
+                );
+                // Merge cluster i+1 into cluster i
+                let next = clusters.remove(i + 1);
+                clusters[i].extend(next);
+                merged = true;
+                // Don't increment i — check if the merged cluster can merge further
+            } else {
+                i += 1;
+            }
+        }
+    }
+
+    clusters
+}
+
 /// Find row boundaries by clustering Y positions
 pub(crate) fn find_row_boundaries(items: &[(usize, &TextItem)]) -> Vec<f32> {
     let mut y_positions: Vec<f32> = items.iter().map(|(_, i)| i.y).collect();

tests/integration_tests.rs

@@ -1438,6 +1438,42 @@ fn test_extract_tables_in_regions_nonexistent_page() {
     assert!(region.text.is_empty());
 }
 
+#[test]
+fn test_bits_pilani_page4_table_detection() {
+    // Page 4 (0-indexed 3) has a table with multi-line wrapped headers and
+    // numeric data columns. The heuristic detector previously failed because:
+    // 1. Header items at different X positions than data created extra column
+    //    clusters (6 cols instead of 4)
+    // 2. Spanning super-header row ("First Degree | First Degree") produced
+    //    duplicate header cells that looks_like_partial_table_ex rejected
+    let buf = std::fs::read("tests/fixtures/bits_pilani_feedback.pdf").unwrap();
+    let results =
+        extract_tables_in_regions_mem(&buf, &[(3, vec![[0.0, 0.0, 612.0, 792.0]])]).unwrap();
+    assert_eq!(results.len(), 1);
+    let region = &results[0].regions[0];
+    assert!(
+        !region.needs_ocr,
+        "Page 4 table should be detected, got needs_ocr=true"
+    );
+    assert!(
+        region.text.contains("BIO"),
+        "Should contain department name BIO"
+    );
+    assert!(region.text.contains("8.23"), "Should contain numeric data");
+}
+
+#[test]
+fn test_bits_pilani_page8_table_detection() {
+    // Page 8 (0-indexed 7) has a numbered-row table that already worked.
+    // Verify it still works after changes.
+    let buf = std::fs::read("tests/fixtures/bits_pilani_feedback.pdf").unwrap();
+    let results =
+        extract_tables_in_regions_mem(&buf, &[(7, vec![[0.0, 0.0, 612.0, 792.0]])]).unwrap();
+    assert_eq!(results.len(), 1);
+    let region = &results[0].regions[0];
+    assert!(!region.needs_ocr, "Page 8 table should still be detected");
+}
+
 // =========================================================================
 // extract_pages_markdown_mem tests
 // =========================================================================