test: refresh Shannon snapshot after merging main

CI checks out a merge of the PR head with main, and main advanced 8
commits since this branch was cut — including #201 (contextual digit
runs), #240 and #253 (markdown fixes). Those change extraction output,
so a snapshot generated on the unmerged branch could not match; the
Test job failed on the merge commit while passing on the branch itself.

The merged behaviour is better: the footnote marker '2' before
'Hartley, R. V. L.' is now recovered instead of dropped.

950 tests pass on the merged tree, clippy clean.

AGENTS.md

@@ -61,8 +61,7 @@ src/
 
 - **Unit tests**: inline `#[cfg(test)] mod tests` in each module with synthetic data.
 - **Integration tests**: `tests/integration_tests.rs` with fixture PDFs in `tests/fixtures/`.
-- **Regression suite**: sibling repo `pdf-evals` with ~200 snapshot PDFs. Run `cargo build --release` then `bench.py test` in that repo before committing. While iterating, prefer a subset run (`bench.py test -q` for the quick set, or `-s <name>` for a named test set) and save the full `bench.py test` for the final pre-commit check.
-- **Semantic quality**: run `bench.py score` in `pdf-evals` for the semantic verdict (TEDS + MHS + reading order + char/word + list preservation, composited). Character-level diff alone misclassifies structural improvements (e.g., column-detection rewrites) as regressions — `score` is the tie-breaker. See `pdf-evals/CLAUDE.md` "Semantic scoring".
+- **Regression suite**: sibling repo `pdf-evals` with 179+ snapshot PDFs. Run `cargo build --release` then `bench.py test` in that repo before committing.
 
 ## Debugging
 

CLAUDE.md

@@ -61,7 +61,7 @@ src/
 
 - **Unit tests**: inline `#[cfg(test)] mod tests` in each module with synthetic data.
 - **Integration tests**: `tests/integration_tests.rs` with fixture PDFs in `tests/fixtures/`.
-- **Regression suite**: sibling repo `pdf-evals` with ~200 snapshot PDFs. Run `cargo build --release` then `bench.py test` in that repo before committing. While iterating, prefer a subset run (`bench.py test -q` for the quick set, or `-s <name>` for a named test set) and save the full `bench.py test` for the final pre-commit check.
+- **Regression suite**: sibling repo `pdf-evals` with 187+ snapshot PDFs. Run `cargo build --release` then `bench.py test` in that repo before committing.
 - **Semantic quality**: run `bench.py score` in `pdf-evals` for the semantic verdict (TEDS + MHS + reading order + char/word + list preservation, composited). Character-level diff alone misclassifies structural improvements (e.g., column-detection rewrites) as regressions — `score` is the tie-breaker. See `pdf-evals/CLAUDE.md` "Semantic scoring".
 
 ## Debugging

src/extractor/content_stream.rs

@@ -41,17 +41,6 @@ fn strip_pdf_comments(data: &[u8]) -> Vec<u8> {
     while i < data.len() {
         let b = data[i];
         match b {
-            // Inside a string literal, a backslash escapes the next byte —
-            // `\(`, `\)`, and `\\` must not touch the nesting depth, or a
-            // later `%` glyph inside a string gets stripped as a comment,
-            // corrupting the stream.
-            b'\\' if in_string > 0 => {
-                result.push(b);
-                if let Some(&next) = data.get(i + 1) {
-                    result.push(next);
-                    i += 1;
-                }
-            }
             b'(' if !in_hex_string => {
                 in_string += 1;
                 result.push(b);
@@ -1865,26 +1854,4 @@ BT 30 700 Tm <41> Tj ET";
             "ET should be preserved after comment stripping"
         );
     }
-
-    #[test]
-    fn test_strip_pdf_comments_escaped_parens() {
-        // An escaped `\)` must not close the string: the `%` after it is
-        // still string content, not a comment (subset fonts routinely map
-        // glyphs to `%` and to escaped parens in the same TJ array).
-        let input = b"[ (a\\)b) 1 (%) 1 (c) ] TJ\n";
-        let output = strip_pdf_comments(input);
-        assert_eq!(output, input.to_vec());
-
-        // Same for an escaped `\(` — must not open a phantom string that
-        // shields a real comment.
-        let input = b"(x\\(y) Tj % real comment\nET\n";
-        let output = strip_pdf_comments(input);
-        assert_eq!(output, b"(x\\(y) Tj  \nET\n");
-
-        // Escaped backslash before a real close-paren: `\\` ends the escape,
-        // the `)` does close the string, and the comment is stripped.
-        let input = b"(x\\\\) Tj % comment\nET\n";
-        let output = strip_pdf_comments(input);
-        assert_eq!(output, b"(x\\\\) Tj  \nET\n");
-    }
 }

src/markdown/analysis.rs

@@ -171,74 +171,6 @@ pub(crate) fn is_toc_marker_heading(text: &str) -> bool {
 /// equation and absent from name-plus-number headings. A bare trailing colon
 /// is NOT a fragment signal either: real headings frequently end with colons
 /// ("Procedure:", "Steps for Using the Microscope:").
-/// True when the line opens with a section number ("3.", "2.1.4", "IV)").
-///
-/// Mirrors the acceptance of `heading::parse_numbering` rather than the
-/// stricter `convert::starts_with_section_number`, which deliberately
-/// requires two components because it bypasses isolation checks. Here a
-/// single "1." counts: numbering is independent evidence of a heading, and
-/// `heading.rs` applies its numbered-prefix allowance *after* consulting
-/// `is_heading_fragment`, so without this exemption a numbered
-/// sentence-case heading would be vetoed before that allowance can run.
-fn starts_with_numbering_prefix(t: &str) -> bool {
-    let Some(first) = t.split_whitespace().next() else {
-        return false;
-    };
-    let has_delimiter = first.ends_with(['.', ')', ':']);
-    let token = first.trim_end_matches(['.', ')', ':']);
-    if token.is_empty() {
-        return false;
-    }
-    let parts: Vec<&str> = token.split('.').collect();
-    let decimal = parts
-        .iter()
-        .all(|p| !p.is_empty() && p.len() <= 3 && p.chars().all(|c| c.is_ascii_digit()));
-    if decimal {
-        // "1." / "2.1." carry a delimiter; "2.3 Title" is written without
-        // one, so a multi-component number is accepted bare. A bare single
-        // number ("3 apples") is not — that is ordinary prose.
-        return has_delimiter || parts.len() >= 2;
-    }
-    // Roman numerals go through the heading parser's own grammar so the two
-    // agree: uppercase I/V/X/L/C only, at most 8 characters. A looser rule
-    // here would exempt markers the parser rejects — "iv)" or "d)" from an
-    // alphabetical list — letting an ordinary list item bypass the veto and
-    // reach heading promotion.
-    //
-    // A delimiter is also required: a bare leading "I" is the pronoun far
-    // more often than a section number.
-    has_delimiter && crate::markdown::heading::roman_value(token).is_some()
-}
-
-/// True when the line reads as a title rather than a sentence: every
-/// content word (ignoring minor words) starts uppercase. Used to spare real
-/// headings from the dangling-verb veto — "Bond Yields" is a section title,
-/// "the method yields" is a stranded clause, and only the casing tells them
-/// apart.
-fn looks_title_case(t: &str) -> bool {
-    const MINOR: &[&str] = &[
-        "a", "an", "the", "of", "and", "or", "for", "to", "in", "on", "at", "by", "with", "from",
-        "as", "is", "are", "that", "than", "into",
-    ];
-    let mut content = 0usize;
-    let mut capitalized = 0usize;
-    for w in t.split_whitespace() {
-        let cleaned: String = w.chars().filter(|c| c.is_alphabetic()).collect();
-        if cleaned.is_empty() {
-            continue;
-        }
-        if MINOR.contains(&cleaned.to_lowercase().as_str()) {
-            continue;
-        }
-        content += 1;
-        if cleaned.chars().next().is_some_and(char::is_uppercase) {
-            capitalized += 1;
-        }
-    }
-    // A single content word ("Yields") is a title by default.
-    content == 0 || capitalized == content
-}
-
 pub(crate) fn is_heading_fragment(text: &str) -> bool {
     let t = text.trim_end();
 
@@ -312,133 +244,9 @@ pub(crate) fn is_heading_fragment(text: &str) -> bool {
     if t.ends_with(':') && t.split_whitespace().any(is_equation_number) {
         return true;
     }
-
-    // Dangling clause: a stranded sentence lead-in ends on a relational
-    // verb with no terminal punctuation — "Note that the exact error equals"
-    // left ahead of its formula when a phantom table dissolved.
-    //
-    // Gated on the line reading as prose rather than a title. Case is the
-    // discriminator the trailing word alone cannot provide: a heading is
-    // title case ("Bond Yields", "The Method Yields") while a stranded
-    // lead-in is sentence case ("the method yields"). Without this gate the
-    // veto eats real headings — "Bond Yields", "Crop Yields" and any wrapped
-    // title-case heading the preprocessor failed to merge.
-    if !t.ends_with(['.', '!', '?', ':', ';', ')', ']'])
-        && !looks_title_case(t)
-        && !starts_with_numbering_prefix(t)
-    {
-        if let Some(last) = t.split_whitespace().next_back() {
-            let word: String = last
-                .trim_matches(|c: char| !c.is_alphanumeric())
-                .to_lowercase();
-            // Relational verbs only, and only those with no common noun
-            // sense. "yields" was dropped for exactly that reason: "Bond
-            // Yields" is a real section title. Function words, copulas and
-            // auxiliaries were measured and rejected outright — a heading
-            // that wraps across lines ends on those, and suppressing them
-            // destroyed real IRS Publication 17 headings.
-            const DANGLING_TAIL: &[&str] =
-                &["equals", "denotes", "implies", "satisfies", "signifies"];
-            if DANGLING_TAIL.contains(&word.as_str()) {
-                return true;
-            }
-        }
-    }
     false
 }
 
-#[cfg(test)]
-mod fragment_heading_tests {
-    use super::is_heading_fragment;
-
-    #[test]
-    fn dangling_tail_marks_stranded_clause() {
-        // opendataloader 01030000000144: left behind when a phantom table
-        // dissolved, ahead of its formula on the next line.
-        assert!(is_heading_fragment("Note that the exact error equals"));
-        assert!(is_heading_fragment("The remainder term satisfies"));
-        assert!(is_heading_fragment("we conclude that the sum equals"));
-    }
-
-    #[test]
-    fn real_headings_survive() {
-        assert!(!is_heading_fragment("Introduction"));
-        assert!(!is_heading_fragment("Error Analysis"));
-        assert!(!is_heading_fragment("Materials and Methods"));
-        assert!(!is_heading_fragment("Results"));
-        assert!(!is_heading_fragment("3.2 Richardson Extrapolation"));
-        assert!(!is_heading_fragment("Discussion and Conclusions"));
-        // Terminal punctuation means the clause is complete.
-        assert!(!is_heading_fragment("What is a Derivative?"));
-        assert!(!is_heading_fragment("Procedure:"));
-        assert!(!is_heading_fragment("Note that this is important."));
-    }
-
-    #[test]
-    fn title_case_headings_ending_in_a_verb_survive() {
-        // "yields" is also a plural noun; these are real section titles.
-        assert!(!is_heading_fragment("Bond Yields"));
-        assert!(!is_heading_fragment("Crop Yields"));
-        assert!(!is_heading_fragment("Dividend Yields"));
-        assert!(!is_heading_fragment("Yields"));
-        // A wrapped title-case heading whose first line ends on a listed
-        // verb must survive even if the preprocessor failed to merge it.
-        assert!(!is_heading_fragment("The Theorem Implies"));
-        assert!(!is_heading_fragment("What This Denotes"));
-    }
-
-    #[test]
-    fn numbered_sentence_case_headings_survive() {
-        // heading.rs consults is_heading_fragment BEFORE applying its
-        // numbered-prefix allowance, so the veto must not pre-empt it.
-        assert!(!is_heading_fragment("1. What the model implies"));
-        assert!(!is_heading_fragment("2.3 How the estimator satisfies"));
-        assert!(!is_heading_fragment("IV) What this denotes"));
-        // Without numbering the same wording is still a stranded clause.
-        assert!(is_heading_fragment("What the model implies"));
-        // A bare leading number or pronoun is prose, not numbering.
-        assert!(is_heading_fragment("3 apples and what that implies"));
-        assert!(is_heading_fragment("I think the model implies"));
-        // Markers heading::parse_numbering rejects must not be exempted
-        // either, or an ordinary list item bypasses the veto: lowercase
-        // roman, alphabetical markers, and over-long tokens.
-        assert!(is_heading_fragment("iv) the estimator satisfies"));
-        assert!(is_heading_fragment("d) the value implies"));
-        // Unsupported character (M is outside the parser's I/V/X/L/C set).
-        assert!(is_heading_fragment("MMMM. the value implies"));
-        // Over-long token: nine valid characters, so this exercises the
-        // 8-character bound rather than the character set.
-        assert!(is_heading_fragment("IIIIIIIII. the value implies"));
-        // Eight is still within the bound and stays exempt.
-        assert!(!is_heading_fragment("IIIIIIII. What this implies"));
-        // Uppercase roman within the parser's grammar is still exempt.
-        assert!(!is_heading_fragment("IV. What this denotes"));
-        assert!(!is_heading_fragment("XII) What this implies"));
-    }
-
-    #[test]
-    fn wrapped_headings_are_not_fragments() {
-        // A heading that wraps across lines ends on a function word. These
-        // are real headings from IRS Publication 17 and must survive.
-        assert!(!is_heading_fragment("Casualty and"));
-        assert!(!is_heading_fragment("Rule 10. You Must Be at"));
-        assert!(!is_heading_fragment("Higher Standard Deduction for"));
-        assert!(!is_heading_fragment("Qualifying Child of"));
-        assert!(!is_heading_fragment("When Can I Withdraw or"));
-        // Copulas and auxiliaries also end real wrapped headings.
-        assert!(!is_heading_fragment("Rule 15. Your AGI Must Be"));
-        assert!(!is_heading_fragment("What Medical Expenses Are"));
-        assert!(!is_heading_fragment("Rule 13. You Must Have"));
-        assert!(!is_heading_fragment("When Can a Roth IRA Be"));
-    }
-
-    #[test]
-    fn dangling_check_is_case_insensitive() {
-        // All-caps is not sentence case, so the veto must not fire there.
-        assert!(!is_heading_fragment("THE REMAINDER EQUALS"));
-    }
-}
-
 /// Compute the Y-gap threshold for paragraph break detection.
 ///
 /// Instead of using a fixed multiple of base_size (which fails for double-spaced

src/markdown/heading.rs

@@ -127,9 +127,7 @@ fn visual_style(line: &TextLine) -> Option<VisualStyle> {
     })
 }
 
-/// Shared with `analysis::starts_with_numbering_prefix` so the veto
-/// exemption and the heading parser agree on what a roman numeral is.
-pub(super) fn roman_value(token: &str) -> Option<u32> {
+fn roman_value(token: &str) -> Option<u32> {
     if token.is_empty() || token.len() > 8 {
         return None;
     }

src/tables/detect_heuristic.rs

@@ -435,72 +435,6 @@ fn revised_table_cell_indices(
         .collect()
 }
 
-/// Index of candidate "body" items (larger-font attachment targets) sorted by
-/// Y, so script-attachment checks scan a narrow Y window instead of the whole
-/// page per candidate.
-struct ScriptBodyIndex<'a> {
-    /// (y, item), sorted ascending by y
-    by_y: Vec<(f32, &'a TextItem)>,
-    /// widest vertical attachment window any body item can produce
-    max_window: f32,
-}
-
-impl<'a> ScriptBodyIndex<'a> {
-    fn new(items: &'a [TextItem]) -> Self {
-        // Smallest table-candidate font is 6pt, so any possible attachment
-        // target is at least 6 x 1.2 pt.
-        let mut by_y: Vec<(f32, &TextItem)> = items
-            .iter()
-            .filter(|i| i.font_size >= 6.0 * 1.2)
-            .map(|i| (i.y, i))
-            .collect();
-        by_y.sort_by(|a, b| a.0.total_cmp(&b.0));
-        let max_window = by_y
-            .iter()
-            .map(|(_, i)| i.font_size * 0.8)
-            .fold(0.0f32, f32::max);
-        Self { by_y, max_window }
-    }
-
-    /// True when a small-font item is horizontally attached to a larger-font
-    /// item at a script baseline offset — a sub/superscript in running text
-    /// or math (equation subscripts, footnote markers). Script attachments
-    /// are not table cells; without this filter, display equations with
-    /// sub/superscripts form phantom small-font table regions (e.g. TeX
-    /// papers where log subscripts cluster with footnote lines into a fake
-    /// 3-column table). A genuine baseline offset is required so same-line
-    /// table neighbours (a small cell beside a larger label cell) are never
-    /// classified as scripts.
-    ///
-    /// `min_anchor_size` additionally constrains what counts as an
-    /// attachment target: the small-font pass accepts any sufficiently
-    /// larger item (0.0), while the body-font pass requires a heading-sized
-    /// anchor so a body-size table cell beside a slightly larger label with
-    /// baseline jitter is never treated as a script.
-    fn is_script_attachment(&self, small: &TextItem, min_anchor_size: f32) -> bool {
-        let attach_gap = small.font_size.max(4.0) * 0.6;
-        let lo = self
-            .by_y
-            .partition_point(|(y, _)| *y < small.y - self.max_window);
-        self.by_y[lo..]
-            .iter()
-            .take_while(|(y, _)| *y <= small.y + self.max_window)
-            .any(|(_, body)| {
-                let dy = (small.y - body.y).abs();
-                body.font_size >= small.font_size * 1.2
-                    && body.font_size >= min_anchor_size
-                    && dy > body.font_size * 0.05
-                    && dy <= body.font_size * 0.8
-                    && {
-                        let gap_after_body = small.x - (body.x + body.width);
-                        let gap_before_body = body.x - (small.x + small.width);
-                        (-attach_gap..=attach_gap).contains(&gap_after_body)
-                            || (-attach_gap..=attach_gap).contains(&gap_before_body)
-                    }
-            })
-    }
-}
-
 /// Detect tables in a set of text items from a single page
 pub fn detect_tables(items: &[TextItem], base_font_size: f32, skip_body_font: bool) -> Vec<Table> {
     detect_tables_with_page_width(items, base_font_size, skip_body_font, content_width(items))
@@ -549,27 +483,6 @@ pub(crate) fn detect_tables_with_page_width(
     // === Pass 1: Small-font tables (existing behavior) ===
     let table_font_threshold = base_font_size * 0.90;
 
-    // Mark sub/superscript attachments once per pass. They stay candidates —
-    // the masks only remove them from region qualification and column/row
-    // geometry.
-    //
-    // The two passes need different anchor thresholds. In the small-font pass
-    // any sufficiently larger neighbour is a plausible base for a script. In
-    // the body-font pass the candidates are themselves body-sized
-    // (0.85..1.05x), so a merely "slightly larger" neighbour is usually a bold
-    // label or an adjacent column header, not the base of a superscript —
-    // treating it as one would strip real cells out of the geometry and lose
-    // the table. Requiring a heading-sized anchor (>= 1.15x base) keeps the
-    // body pass to genuine scripts hanging off headings.
-    let script_index = ScriptBodyIndex::new(items);
-    let script_flags: Vec<bool> = items
-        .iter()
-        .map(|item| script_index.is_script_attachment(item, 0.0))
-        .collect();
-    let body_script_flags: Vec<bool> = items
-        .iter()
-        .map(|item| script_index.is_script_attachment(item, base_font_size * 1.15))
-        .collect();
     let table_candidates: Vec<(usize, &TextItem)> = items
         .iter()
         .enumerate()
@@ -581,14 +494,7 @@ pub(crate) fn detect_tables_with_page_width(
         .collect();
 
     if table_candidates.len() >= 6 {
-        // Qualify regions from non-script items: a cluster of sub/superscripts
-        // must not, on its own, mark out a table region.
-        let region_evidence: Vec<(usize, &TextItem)> = table_candidates
-            .iter()
-            .filter(|(idx, _)| !script_flags[*idx])
-            .cloned()
-            .collect();
-        let regions = find_table_regions(&region_evidence);
+        let regions = find_table_regions(&table_candidates);
 
         for (y_min, y_max) in regions {
             let region_items: Vec<(usize, &TextItem)> = table_candidates
@@ -602,9 +508,7 @@ pub(crate) fn detect_tables_with_page_width(
             }
 
             if let Some(mut table) =
-                detect_table_in_region(&region_items, TableDetectionMode::SmallFont, &|i| {
-                    script_flags[i]
-                })
+                detect_table_in_region(&region_items, TableDetectionMode::SmallFont)
             {
                 // Try to recover body-font header row above the small-font table
                 recover_header_row(&mut table, items, table_font_threshold);
@@ -649,20 +553,8 @@ pub(crate) fn detect_tables_with_page_width(
             body_font_low,
             body_font_high,
         );
-        // Scripts are NOT filtered out of the candidate set here, mirroring
-        // the small-font pass: they must stay eligible for cell assignment so
-        // a sub/superscript that belongs inside a table cell keeps its text.
-        // The heading-anchored `body_script_flags` mask removes them from
-        // geometry only.
         if body_candidates.len() >= 6 {
-            // Same reasoning as the small-font pass: scripts do not qualify
-            // regions, but remain available for cell assignment within one.
-            let region_evidence: Vec<(usize, &TextItem)> = body_candidates
-                .iter()
-                .filter(|(idx, _)| !body_script_flags[*idx])
-                .cloned()
-                .collect();
-            let regions = find_table_regions_strict(&region_evidence);
+            let regions = find_table_regions_strict(&body_candidates);
             log::debug!("body-font: {} strict regions found", regions.len());
 
             for (y_min, y_max, _x_min, _x_max) in &regions {
@@ -688,9 +580,7 @@ pub(crate) fn detect_tables_with_page_width(
                 }
 
                 if let Some(table) =
-                    detect_table_in_region(&region_items, TableDetectionMode::BodyFont, &|i| {
-                        body_script_flags[i]
-                    })
+                    detect_table_in_region(&region_items, TableDetectionMode::BodyFont)
                 {
                     tables.push(table);
                 }
@@ -918,30 +808,10 @@ fn find_table_regions_strict(items: &[(usize, &TextItem)]) -> Vec<(f32, f32, f32
     regions
 }
 
-/// Detect a table within a specific region.
-///
-/// `is_script` marks items that are sub/superscript attachments. Those are
-/// excluded from the *geometry* — they must not be able to create a column,
-/// which is how equation subscript clusters used to fabricate phantom grids —
-/// but they remain eligible for cell assignment, so legitimate cell content
-/// (exponents in an engineering-notation table, footnote markers) stays in
-/// the cell it belongs to instead of leaking out into the reading order.
-fn detect_table_in_region(
-    items: &[(usize, &TextItem)],
-    mode: TableDetectionMode,
-    is_script: &dyn Fn(usize) -> bool,
-) -> Option<Table> {
-    // Column geometry from non-script items only.
-    let geometry_items: Vec<(usize, &TextItem)> = items
-        .iter()
-        .filter(|(idx, _)| !is_script(*idx))
-        .cloned()
-        .collect();
-    // A region that is *entirely* scripts has no table structure at all.
-    if geometry_items.is_empty() {
-        return None;
-    }
-    let columns = find_column_boundaries(&geometry_items, mode);
+/// Detect a table within a specific region
+fn detect_table_in_region(items: &[(usize, &TextItem)], mode: TableDetectionMode) -> Option<Table> {
+    // Find column boundaries
+    let columns = find_column_boundaries(items, mode);
     let min_cols = 2;
     if columns.len() < min_cols || columns.len() > 25 {
         log::debug!(
@@ -952,8 +822,8 @@ fn detect_table_in_region(
         return None;
     }
 
-    // Find row boundaries (geometry items only, same reasoning)
-    let rows = find_row_boundaries(&geometry_items);
+    // Find row boundaries
+    let rows = find_row_boundaries(items);
     let min_rows = 2;
     if rows.len() < min_rows {
         log::debug!(
@@ -972,11 +842,6 @@ fn detect_table_in_region(
     );
 
     // Verify this looks like a table: multiple items should align to columns
-    // Validate against ALL items, including scripts. Columns are derived from
-    // non-script geometry so scripts cannot *create* a column, but excluding
-    // them from validation too would let a region manufacture alignment: drop
-    // the awkward items and whatever remains looks like a tidy grid. Block
-    // diagrams did exactly that. Everything in the region must fit.
     let col_alignment = check_column_alignment(items, &columns, mode);
     let min_alignment = match mode {
         TableDetectionMode::SmallFont => 0.5,
@@ -1047,29 +912,6 @@ fn detect_table_in_region(
         cells.push(row_cells);
     }
 
-    // Validation 0 (small-font pass only): reject tiny all-numeric
-    // fragments. A <=2-row grid whose every cell is a bare 1-2 digit number
-    // carries no tabular information — in practice these are
-    // exponent/subscript clusters from display math that happen to align.
-    // Body-font tables are not subject to this veto: their cells cannot be
-    // script glyphs.
-    if matches!(mode, TableDetectionMode::SmallFont) {
-        let nonempty_cells: Vec<&String> =
-            cells.iter().flatten().filter(|c| !c.is_empty()).collect();
-        if rows.len() <= 2
-            && !nonempty_cells.is_empty()
-            && nonempty_cells
-                .iter()
-                .all(|c| c.len() <= 2 && c.chars().all(|ch| ch.is_ascii_digit()))
-        {
-            log::debug!(
-                "  validation 0 fail: tiny all-numeric fragment ({} cells)",
-                nonempty_cells.len()
-            );
-            return None;
-        }
-    }
-
     // Validation 1: some rows should have content in first column.
     // Use a lower threshold (25%) for tables with wrapped cells where
     // continuation lines leave the first column empty.
@@ -2135,146 +1977,6 @@ fn try_add_label_column(
 
 #[cfg(test)]
 mod tests {
-
-    fn make_item(text: &str, x: f32, y: f32, font_size: f32, width: f32) -> TextItem {
-        TextItem {
-            text: text.to_string(),
-            x,
-            y,
-            width,
-            height: font_size,
-            font: "TestFont".to_string(),
-            font_size,
-            page: 1,
-            is_bold: false,
-            is_italic: false,
-            is_underline: false,
-            is_strikeout: false,
-            item_type: ItemType::Text,
-            mcid: None,
-        }
-    }
-
-    #[test]
-    fn script_attachment_detects_subscript_after_body_text() {
-        let body = make_item("log", 100.0, 500.0, 10.0, 15.0);
-        let sub = make_item("10", 115.5, 497.0, 7.0, 7.0);
-        let items = vec![body, sub.clone()];
-        assert!(ScriptBodyIndex::new(&items).is_script_attachment(&sub, 0.0));
-    }
-
-    #[test]
-    fn script_attachment_detects_superscript_footnote_marker() {
-        let body = make_item("Hartley", 200.0, 500.0, 10.0, 35.0);
-        let sup = make_item("2", 235.8, 504.0, 6.6, 3.5);
-        let items = vec![body, sup.clone()];
-        assert!(ScriptBodyIndex::new(&items).is_script_attachment(&sup, 0.0));
-    }
-
-    #[test]
-    fn script_attachment_ignores_small_cell_far_from_body_text() {
-        let body = make_item("Revenue", 100.0, 500.0, 10.0, 40.0);
-        let cell = make_item("1,234", 180.0, 500.0, 7.0, 20.0);
-        let items = vec![body, cell.clone()];
-        assert!(!ScriptBodyIndex::new(&items).is_script_attachment(&cell, 0.0));
-    }
-
-    #[test]
-    fn body_pass_anchor_spares_cells_beside_slightly_larger_labels() {
-        // A body-font table cell (10pt) sitting beside a slightly larger,
-        // NON-heading label (12.5pt) with a little baseline jitter. The
-        // small-font pass treats any larger neighbour as a possible script
-        // base, but the body pass must not: at body sizes a slightly larger
-        // neighbour is a bold label or column header, and flagging the cell
-        // would strip it out of the table geometry and lose the table.
-        // Cell at the low end of the body band (0.85x base) beside a 10.5pt
-        // label. 10.5 clears the inherent 1.2x-of-cell rule (10.2) but falls
-        // below the body pass's heading anchor (11.5), which is exactly the
-        // band where the two masks must disagree.
-        let label = make_item("Revenue", 100.0, 500.0, 10.5, 40.0);
-        let cell = make_item("1,234", 141.0, 496.5, 8.5, 22.0);
-        let items = vec![label, cell.clone()];
-        let index = ScriptBodyIndex::new(&items);
-        let base = 10.0;
-        assert!(
-            index.is_script_attachment(&cell, 0.0),
-            "small-font pass anchor should still see this as an attachment"
-        );
-        assert!(
-            !index.is_script_attachment(&cell, base * 1.15),
-            "body pass must not treat a cell beside a slightly larger label \
-             as a script — that removes real cells from the geometry"
-        );
-        // A genuine heading-sized anchor still qualifies in the body pass.
-        let heading = make_item("Section", 100.0, 500.0, 20.0, 60.0);
-        let sup = make_item("3", 161.0, 508.0, 10.0, 5.0);
-        let h_items = vec![heading, sup.clone()];
-        assert!(
-            ScriptBodyIndex::new(&h_items).is_script_attachment(&sup, base * 1.15),
-            "script hanging off a heading must still be excluded in the body pass"
-        );
-    }
-
-    #[test]
-    fn script_attachment_ignores_same_baseline_neighbor_cell() {
-        // A small cell beside a larger label on the SAME baseline is a table
-        // layout, not a subscript — a genuine baseline offset is required.
-        let label = make_item("Total", 100.0, 500.0, 10.0, 25.0);
-        let cell = make_item("42", 127.0, 500.0, 7.5, 9.0);
-        let items = vec![label, cell.clone()];
-        assert!(!ScriptBodyIndex::new(&items).is_script_attachment(&cell, 0.0));
-    }
-
-    #[test]
-    fn script_attachment_ignores_neighbor_on_different_line() {
-        let body = make_item("Header", 100.0, 500.0, 10.0, 30.0);
-        let cell = make_item("42", 131.0, 486.0, 7.0, 10.0);
-        let items = vec![body, cell.clone()];
-        assert!(!ScriptBodyIndex::new(&items).is_script_attachment(&cell, 0.0));
-    }
-
-    /// Equation-subscript + footnote layout from Shannon entropy.pdf page 1,
-    /// with real coordinates. Without the larger-font anchors the small items
-    /// alone DO form a phantom table — proving the layout reaches detection —
-    /// and adding the anchors must suppress it.
-    fn shannon_page1_small_items() -> Vec<TextItem> {
-        vec![
-            make_item("2", 267.4, 133.9, 7.4, 3.7),
-            make_item("10", 306.2, 133.9, 7.4, 7.4),
-            make_item("10", 342.7, 133.9, 7.4, 7.4),
-            make_item("10", 325.0, 118.9, 7.4, 7.4),
-            make_item("Bell System Technical Journal,", 295.7, 101.9, 8.0, 95.0),
-            make_item(
-                "April 1924, p. 324; Certain Topics in",
-                396.7,
-                101.9,
-                8.0,
-                130.0,
-            ),
-            make_item("v. 47, April 1928, p. 617.", 250.9, 92.5, 8.0, 90.0),
-            make_item("Bell System Technical Journal,", 264.2, 82.6, 8.0, 95.0),
-            make_item("July 1928, p. 535.", 364.3, 82.6, 8.0, 65.0),
-        ]
-    }
-
-    #[test]
-    fn equation_scripts_do_not_form_phantom_table() {
-        let bare = shannon_page1_small_items();
-        assert!(
-            !detect_tables(&bare, 10.0, false).is_empty(),
-            "test layout must form a phantom table when the filter cannot fire"
-        );
-        let mut items = shannon_page1_small_items();
-        items.push(make_item("log", 253.0, 137.0, 10.0, 13.5));
-        items.push(make_item("log", 291.5, 137.0, 10.0, 13.5));
-        items.push(make_item("log", 328.0, 137.0, 10.0, 13.5));
-        items.push(make_item("log", 310.3, 122.0, 10.0, 13.5));
-        let tables = detect_tables(&items, 10.0, false);
-        assert!(
-            tables.is_empty(),
-            "equation scripts + footnotes must not become a table: {tables:?}"
-        );
-    }
     use super::*;
     use crate::types::ItemType;