fix(pdf-inspector): relax vector table confidence gates

.github/workflows/publish-crate.yml

@@ -1,87 +0,0 @@
-name: Publish Rust crate
-
-on:
-  push:
-    branches: [main]
-    paths: ['Cargo.toml']
-
-permissions:
-  contents: read
-
-env:
-  CARGO_TERM_COLOR: always
-
-jobs:
-  check-version:
-    name: Check version change
-    runs-on: ubuntu-latest
-    outputs:
-      changed: ${{ steps.check.outputs.changed }}
-      published: ${{ steps.check.outputs.published }}
-      version: ${{ steps.check.outputs.version }}
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          fetch-depth: 2
-
-      - name: Check if version changed
-        id: check
-        run: |
-          NEW_VERSION=$(python3 -c 'import pathlib, tomllib; print(tomllib.loads(pathlib.Path("Cargo.toml").read_text())["package"]["version"])')
-          OLD_VERSION=$(git show HEAD~1:Cargo.toml | python3 -c 'import sys, tomllib; print(tomllib.loads(sys.stdin.read())["package"]["version"])')
-          echo "old=$OLD_VERSION new=$NEW_VERSION"
-          echo "version=$NEW_VERSION" >> "$GITHUB_OUTPUT"
-
-          if [ "$NEW_VERSION" = "$OLD_VERSION" ]; then
-            echo "changed=false" >> "$GITHUB_OUTPUT"
-            echo "published=false" >> "$GITHUB_OUTPUT"
-            exit 0
-          fi
-
-          echo "changed=true" >> "$GITHUB_OUTPUT"
-
-          HTTP_STATUS=$(curl --silent --show-error --output /tmp/crate-version.json --write-out "%{http_code}" \
-            -H "User-Agent: firecrawl/pdf-inspector publish workflow (https://github.com/firecrawl/pdf-inspector)" \
-            "https://crates.io/api/v1/crates/pdf-inspector/$NEW_VERSION")
-
-          case "$HTTP_STATUS" in
-            200)
-              echo "published=true" >> "$GITHUB_OUTPUT"
-              echo "pdf-inspector v$NEW_VERSION is already published"
-              ;;
-            404)
-              echo "published=false" >> "$GITHUB_OUTPUT"
-              ;;
-            *)
-              cat /tmp/crate-version.json
-              echo "Unexpected crates.io response: $HTTP_STATUS" >&2
-              exit 1
-              ;;
-          esac
-
-  publish:
-    name: Publish to crates.io
-    needs: check-version
-    if: needs.check-version.outputs.changed == 'true' && needs.check-version.outputs.published == 'false'
-    runs-on: ubuntu-latest
-    environment: crates-io
-    permissions:
-      contents: read
-      id-token: write
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Install Rust
-        uses: dtolnay/rust-toolchain@stable
-
-      - name: Verify package
-        run: cargo publish --dry-run
-
-      - name: Authenticate with crates.io
-        id: auth
-        uses: rust-lang/crates-io-auth-action@v1
-
-      - name: Publish crate
-        run: cargo publish
-        env:
-          CARGO_REGISTRY_TOKEN: ${{ steps.auth.outputs.token }}

Cargo.toml

@@ -17,7 +17,7 @@ crate-type = ["lib", "cdylib"]
 pyo3 = { version = "0.25", features = ["extension-module"], optional = true }
 
 # PDF parsing
-lopdf = { version = "0.41.0", features = ["rayon"] }
+lopdf = { git = "https://github.com/J-F-Liu/lopdf", rev = "7a05512d831415b1f2b1ce522391d6beab8a1284", features = ["rayon"] }
 
 # Error handling
 thiserror = "2.0"

README.md

@@ -1,8 +1,5 @@
 # pdf-inspector
 
-[![Crates.io](https://img.shields.io/crates/v/pdf-inspector.svg)](https://crates.io/crates/pdf-inspector)
-[![npm](https://img.shields.io/npm/v/@firecrawl/pdf-inspector.svg)](https://www.npmjs.com/package/@firecrawl/pdf-inspector)
-
 Fast Rust library for PDF classification and text extraction. Detects whether a PDF is text-based or scanned, extracts text with position awareness, and converts to clean Markdown — all without OCR. Includes bindings for [Python](docs/python.md) and [Node.js](napi/README.md).
 
 Built by [Firecrawl](https://firecrawl.dev) to handle text-based PDFs locally in under 200ms, skipping expensive OCR services for the ~54% of PDFs that don't need them.
@@ -74,17 +71,9 @@ console.log(result.markdown);  // Markdown string or null
 
 ### Rust
 
-Install from [crates.io](https://crates.io/crates/pdf-inspector):
-
-```bash
-cargo add pdf-inspector
-```
-
-Or add it manually:
-
 ```toml
 [dependencies]
-pdf-inspector = "0.1"
+pdf-inspector = { git = "https://github.com/firecrawl/pdf-inspector" }
 ```
 
 ```rust
@@ -102,34 +91,29 @@ if let Some(markdown) = &result.markdown {
 ### CLI
 
 ```bash
-# Install the CLI tools
-cargo install pdf-inspector
-
 # Convert PDF to Markdown
-pdf2md document.pdf
+cargo run --bin pdf2md -- document.pdf
 
 # JSON output (for piping)
-pdf2md document.pdf --json
+cargo run --bin pdf2md -- document.pdf --json
 
 # Raw markdown only (no headers)
-pdf2md document.pdf --raw
+cargo run --bin pdf2md -- document.pdf --raw
 
 # Insert page break markers (<!-- Page N -->)
-pdf2md document.pdf --pages
+cargo run --bin pdf2md -- document.pdf --pages
 
 # Process only specific pages
-pdf2md document.pdf --select-pages 1,3,5-10
+cargo run --bin pdf2md -- document.pdf --select-pages 1,3,5-10
 
 # Detection only (no extraction)
-detect-pdf document.pdf
-detect-pdf document.pdf --json
+cargo run --bin detect-pdf -- document.pdf
+cargo run --bin detect-pdf -- document.pdf --json
 
 # Detection + layout analysis (tables, columns)
-detect-pdf document.pdf --analyze --json
+cargo run --bin detect-pdf -- document.pdf --analyze --json
 ```
 
-From a source checkout, use `cargo run --bin pdf2md -- document.pdf` or `cargo run --bin detect-pdf -- document.pdf` instead.
-
 ## Architecture
 
 ```

docs/publishing.md

@@ -1,21 +0,0 @@
-# Publishing
-
-The Rust crate is published to [crates.io](https://crates.io/crates/pdf-inspector) with trusted publishing from GitHub Actions. The first release was published manually; future releases publish from `.github/workflows/publish-crate.yml` when a `Cargo.toml` version change lands on `main`.
-
-## crates.io Trusted Publisher
-
-Configure the trusted publisher for the `pdf-inspector` crate with:
-
-- Repository: `firecrawl/pdf-inspector`
-- Workflow: `publish-crate.yml`
-- Environment: `crates-io`
-
-The workflow uses `rust-lang/crates-io-auth-action@v1` to exchange GitHub's OIDC token for a short-lived crates.io token, then passes it to `cargo publish`.
-
-## Release Steps
-
-1. Update `version` in `Cargo.toml`.
-2. Merge the version bump to `main`.
-3. The publish workflow compares the new `Cargo.toml` version with `HEAD~1`, runs `cargo publish --dry-run`, then publishes if that version is not already on crates.io.
-
-If `Cargo.toml` changes without a package version bump, the workflow exits without publishing.

napi/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@firecrawl/pdf-inspector",
-  "version": "1.9.5",
+  "version": "1.9.1",
   "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",

src/extractor/fonts.rs

@@ -858,13 +858,6 @@ pub(crate) fn extract_text_from_operand(
             // unmapped. Don't fall through to text-interpretation fallbacks
             // (Latin-1, UTF-16, etc.) which would misinterpret CID bytes as
             // character codes (e.g. CID 0x01A9 → Latin-1 "©").
-            if is_type0_cid_font && bytes.iter().any(|&b| b > 0x7F) {
-                // 2-byte CIDs (Identity-H) are by far the common case; for
-                // an odd byte count we still emit at least one marker so
-                // detection downstream fires.
-                let cid_count = (bytes.len() / 2).max(1);
-                return Some("\u{FFFD}".repeat(cid_count));
-            }
 
             // Try our custom encoding map from Differences arrays.
             // The Differences array overrides specific codes in a base encoding (typically
@@ -973,6 +966,27 @@ pub(crate) fn extract_text_from_operand(
                 return Some(symbol_text);
             }
 
+            // Latin-1 fallback. Safe ONLY for fonts that use single-byte
+            // encodings — for these, an unmapped byte is a valid character
+            // code in Latin-1/WinAnsi space. CID fonts (Type0 / Identity-H)
+            // emit multi-byte CIDs that aren't characters; per-byte Latin-1
+            // produces mojibake (e.g. 2-byte CID 0xCDD9 → "ÍÙ" for the
+            // production scrape_id 019de78c-... samples).
+            //
+            // For a CID font (has_cmap is set OR a /ToUnicode reference
+            // exists) with any non-ASCII bytes, emit a single U+FFFD per
+            // CID instead. This both replaces the mojibake with a proper
+            // "decode failed" marker AND keeps `detect_encoding_issues`
+            // tripping so the page is flagged for OCR — the existing
+            // garbage-detection path that the high-Latin-1 mojibake used
+            // to satisfy by accident.
+            if is_type0_cid_font && bytes.iter().any(|&b| b > 0x7F) {
+                // 2-byte CIDs (Identity-H) are by far the common case; for
+                // an odd byte count we still emit at least one marker so
+                // detection downstream fires.
+                let cid_count = (bytes.len() / 2).max(1);
+                return Some("\u{FFFD}".repeat(cid_count));
+            }
             // Pure ASCII bytes round-trip safely (Latin-1 == ASCII for
             // 0x00..=0x7F), and non-CID (Type1 / TrueType / Type3) fonts
             // use single-byte encodings where Latin-1 fallback is the

src/lib.rs

@@ -823,8 +823,7 @@ pub fn extract_tables_in_regions_mem(
                     // symmetrically low under font-decode failure — this
                     // guard breaks that symmetry by comparing against
                     // bbox area, which is independent of extraction.
-                    if source != TableCandidateSource::KeyValue
-                        && region_text_density_too_low(region_text_chars, region_area)
+                    if region_text_density_too_low(region_text_chars, region_area)
                         && !markdown_table_body_is_dense(&md)
                     {
                         return None;
@@ -837,10 +836,8 @@ pub fn extract_tables_in_regions_mem(
                         Some(TableCandidateIssue::LineRowUndercount)
                     } else if wide_table_sparse_prefix_undercount(&md) {
                         Some(TableCandidateIssue::SparseWideUndercount)
-                    } else if !matches!(
-                        source,
-                        TableCandidateSource::Line | TableCandidateSource::KeyValue
-                    ) && text_cluster_column_undercount(&matched, shape)
+                    } else if source != TableCandidateSource::Line
+                        && text_cluster_column_undercount(&matched, shape)
                     {
                         Some(TableCandidateIssue::TextColumnUndercount)
                     } else if prose_grid_fragment_needs_ocr(&md) {
@@ -884,16 +881,6 @@ pub fn extract_tables_in_regions_mem(
             {
                 candidates.push(candidate);
             }
-            if let Some(table) = tables::try_build_table_from_columns(&matched, page_1idx) {
-                if let Some(candidate) = evaluate(TableCandidateSource::Column, &table) {
-                    candidates.push(candidate);
-                }
-            }
-            if let Some(table) = tables::try_build_key_value_table_from_rows(&matched, page_1idx) {
-                if let Some(candidate) = evaluate(TableCandidateSource::KeyValue, &table) {
-                    candidates.push(candidate);
-                }
-            }
 
             match select_table_candidate(&candidates) {
                 Some(candidate) => page_results.push(RegionText {
@@ -3765,8 +3752,6 @@ enum TableCandidateSource {
     Rect,
     Line,
     Heuristic,
-    Column,
-    KeyValue,
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -3801,12 +3786,8 @@ fn select_table_candidate(candidates: &[TableCandidate]) -> Option<&TableCandida
     // serving a tidy-looking fragment.
     if first.issue == Some(TableCandidateIssue::LineRowUndercount) {
         return candidates.iter().find(|candidate| {
-            matches!(
-                candidate.source,
-                TableCandidateSource::Heuristic
-                    | TableCandidateSource::Column
-                    | TableCandidateSource::KeyValue
-            ) && candidate.issue.is_none()
+            candidate.source == TableCandidateSource::Heuristic
+                && candidate.issue.is_none()
                 && candidate.shape.cols * 10 >= first.shape.cols * 13
         });
     }
@@ -3824,31 +3805,14 @@ fn select_table_candidate(candidates: &[TableCandidate]) -> Option<&TableCandida
         TableCandidateSource::Rect | TableCandidateSource::Line
     ) {
         if let Some(heuristic) = candidates.iter().find(|candidate| {
-            matches!(
-                candidate.source,
-                TableCandidateSource::Heuristic
-                    | TableCandidateSource::Column
-                    | TableCandidateSource::KeyValue
-            ) && candidate.issue.is_none()
+            candidate.source == TableCandidateSource::Heuristic
+                && candidate.issue.is_none()
                 && heuristic_substantially_better(candidate.shape, accepted.shape)
         }) {
             accepted = heuristic;
         }
     }
 
-    if accepted.source == TableCandidateSource::Heuristic {
-        if let Some(layout_candidate) = candidates.iter().find(|candidate| {
-            matches!(
-                candidate.source,
-                TableCandidateSource::Column | TableCandidateSource::KeyValue
-            ) && candidate.issue.is_none()
-                && candidate.shape.cols >= accepted.shape.cols
-                && candidate.shape.rows > accepted.shape.rows
-        }) {
-            accepted = layout_candidate;
-        }
-    }
-
     Some(accepted)
 }
 
@@ -4350,9 +4314,7 @@ fn looks_like_partial_table_ex(markdown: &str, layout_assisted: bool) -> bool {
                         cell.trim().is_empty() && header_empty_indices.contains(&idx)
                     })
                     && layout_assisted_empty_header_has_dense_body(markdown, n_cols);
-                let sparse_row_is_section_label = layout_assisted
-                    && layout_assisted_sparse_section_row_is_ok(data_inner, markdown, n_cols);
-                if !sparse_row_shares_header_spacer && !sparse_row_is_section_label {
+                if !sparse_row_shares_header_spacer {
                     return true;
                 }
             }
@@ -4444,26 +4406,6 @@ fn layout_assisted_empty_header_has_dense_body(markdown: &str, n_cols: usize) ->
         && filled_cells * 100 >= total_cells * 45
 }
 
-fn layout_assisted_sparse_section_row_is_ok(row: &[&str], markdown: &str, n_cols: usize) -> bool {
-    let labels: Vec<&str> = row
-        .iter()
-        .map(|cell| cell.trim())
-        .filter(|cell| !cell.is_empty())
-        .collect();
-    if labels.len() != 1 {
-        return false;
-    }
-    let label = labels[0];
-    if label.len() > 40 || !label.chars().any(|ch| ch.is_alphabetic()) {
-        return false;
-    }
-    if label.ends_with('.') || label.ends_with('!') || label.ends_with('?') || label.ends_with(':')
-    {
-        return false;
-    }
-    layout_assisted_empty_header_has_dense_body(markdown, n_cols)
-}
-
 fn markdown_table_body_is_dense(markdown: &str) -> bool {
     let rows = markdown_pipe_rows(markdown);
     let data_rows: Vec<&Vec<&str>> = rows
@@ -4845,16 +4787,6 @@ mod table_candidate_selection_tests {
         assert_eq!(selected.source, TableCandidateSource::Heuristic);
     }
 
-    #[test]
-    fn prefers_clean_column_fallback_when_it_recovers_more_rows() {
-        let candidates = vec![
-            candidate(TableCandidateSource::Heuristic, 6, 5, None),
-            candidate(TableCandidateSource::Column, 7, 5, None),
-        ];
-        let selected = select_table_candidate(&candidates).unwrap();
-        assert_eq!(selected.source, TableCandidateSource::Column);
-    }
-
     #[test]
     fn line_candidate_collapsing_captured_y_clusters_is_suspicious() {
         let long = "value value value value value value value value value value value value";
@@ -5159,24 +5091,6 @@ mod looks_like_partial_table_tests {
         );
     }
 
-    #[test]
-    fn sparse_section_row_passes_when_layout_assisted_body_is_dense() {
-        let md = "|Properties|Conditions|Method|Typical values|Units|\n\
-                  |---|---|---|---|---|\n\
-                  |Rheology|||||\n\
-                  |Melt Flow Rate|230 C/2.16 kg|ASTM D1238|3.0|g/10 min|\n\
-                  |Tensile Stress at Yield|50 mm/min|ASTM D638|31|MPa|\n\
-                  |Elongation at Yield|50 mm/min|ASTM D638|8|%|";
-        assert!(
-            looks_like_partial_table(md),
-            "strict mode rejects the sparse first row"
-        );
-        assert!(
-            !looks_like_partial_table_ex(md, true),
-            "layout-assisted should allow a short section label above dense table rows"
-        );
-    }
-
     #[test]
     fn paragraph_still_rejected_when_layout_assisted() {
         // Paragraph detection is not relaxed — it's a genuine extraction issue.

src/markdown/convert.rs

@@ -149,79 +149,6 @@ fn find_isolated_lines(lines: &[TextLine], base_size: f32, para_threshold: f32)
     set
 }
 
-/// Pre-scan body-size all-bold runs that are too long to be headings.
-///
-/// Some academic PDFs use an all-bold abstract/summary paragraph immediately
-/// after the author block.  A line-local bold heading heuristic sees each
-/// wrapped visual line as "standalone" once the first line is misclassified,
-/// producing a stack of `##` headings.  Multi-line body-size bold runs with a
-/// paragraph-sized word count should stay paragraph text.
-fn find_wrapped_bold_paragraph_lines(
-    lines: &[TextLine],
-    base_size: f32,
-    para_threshold: f32,
-) -> HashSet<usize> {
-    let mut set = HashSet::new();
-    let mut i = 0usize;
-
-    while i < lines.len() {
-        if !is_body_size_all_bold_line(&lines[i], base_size) {
-            i += 1;
-            continue;
-        }
-
-        let start = i;
-        let mut end = i;
-        let mut word_count = lines[i].text().split_whitespace().count();
-
-        while end + 1 < lines.len()
-            && is_body_size_all_bold_line(&lines[end + 1], base_size)
-            && is_wrapped_same_style_line(&lines[end], &lines[end + 1], para_threshold)
-        {
-            end += 1;
-            word_count += lines[end].text().split_whitespace().count();
-        }
-
-        let line_count = end - start + 1;
-        if line_count >= 3 && word_count > 20 {
-            for idx in start..=end {
-                set.insert(idx);
-            }
-        }
-
-        i = end + 1;
-    }
-
-    set
-}
-
-fn is_body_size_all_bold_line(line: &TextLine, base_size: f32) -> bool {
-    let Some(first) = line.items.first() else {
-        return false;
-    };
-    first.font_size >= base_size * 0.95
-        && first.font_size < base_size * 1.2
-        && line
-            .items
-            .iter()
-            .all(|item| item.is_bold && (item.font_size - first.font_size).abs() < 0.5)
-}
-
-fn is_wrapped_same_style_line(prev: &TextLine, next: &TextLine, para_threshold: f32) -> bool {
-    if prev.page != next.page {
-        return false;
-    }
-
-    let y_gap = prev.y - next.y;
-    if !(y_gap > 0.0 && y_gap <= para_threshold) {
-        return false;
-    }
-
-    let prev_x = prev.items.first().map(|item| item.x).unwrap_or(0.0);
-    let next_x = next.items.first().map(|item| item.x).unwrap_or(0.0);
-    (prev_x - next_x).abs() <= 40.0
-}
-
 /// Resolve the dominant structure role for a text line by looking up its items' MCIDs.
 ///
 /// Returns the first non-container role found (skipping Document/Part/Sect/Div/NonStruct/Span).
@@ -470,8 +397,6 @@ pub(super) fn to_markdown_from_lines_with_tables_and_images(
     // between paragraphs at body font size. Inspired by opendataloader's
     // lookahead in HeadingProcessor (prevNode/nextNode context).
     let isolated_lines = find_isolated_lines(&lines, base_size, para_threshold);
-    let wrapped_bold_paragraph_lines =
-        find_wrapped_bold_paragraph_lines(&lines, base_size, para_threshold);
 
     // Detect struct heading levels that are overused (body text mistagged as headings)
     let overused_heading_levels = detect_overused_struct_heading_levels(&lines, struct_roles);
@@ -485,7 +410,6 @@ pub(super) fn to_markdown_from_lines_with_tables_and_images(
     let mut last_list_x: Option<f32> = None;
     let mut in_code_block = false;
     let mut prev_had_dot_leaders = false;
-    let mut paragraph_in_wrapped_bold_run = false;
     let mut inserted_tables: HashSet<(u32, usize)> = HashSet::new();
     let mut inserted_images: HashSet<(u32, usize)> = HashSet::new();
 
@@ -551,7 +475,6 @@ pub(super) fn to_markdown_from_lines_with_tables_and_images(
             current_page = line.page;
             prev_y = f32::MAX;
             prev_x = 0.0;
-            paragraph_in_wrapped_bold_run = false;
 
             if options.include_page_numbers {
                 output.push_str(&format!("<!-- Page {} -->\n\n", current_page));
@@ -566,7 +489,6 @@ pub(super) fn to_markdown_from_lines_with_tables_and_images(
                     if in_paragraph {
                         output.push_str("\n\n");
                         in_paragraph = false;
-                        paragraph_in_wrapped_bold_run = false;
                     }
                     output.push('\n');
                     output.push_str(table_md);
@@ -584,7 +506,6 @@ pub(super) fn to_markdown_from_lines_with_tables_and_images(
                     if in_paragraph {
                         output.push_str("\n\n");
                         in_paragraph = false;
-                        paragraph_in_wrapped_bold_run = false;
                     }
                     output.push('\n');
                     output.push_str(image_md);
@@ -606,18 +527,9 @@ pub(super) fn to_markdown_from_lines_with_tables_and_images(
             && y_gap.abs() <= para_threshold
             && (prev_x - line_x).abs() > 50.0
             && prev_y < f32::MAX;
-        let line_all_bold = !line.items.is_empty() && line.items.iter().all(|item| item.is_bold);
-        let line_in_wrapped_bold_run = wrapped_bold_paragraph_lines.contains(&line_idx);
-        let is_bold_to_regular_break = in_paragraph
-            && paragraph_in_wrapped_bold_run
-            && !line_in_wrapped_bold_run
-            && !line_all_bold
-            && y_gap > base_size * 1.2
-            && y_gap <= para_threshold;
-        if (is_para_break || is_band_switch || is_bold_to_regular_break) && in_paragraph {
+        if (is_para_break || is_band_switch) && in_paragraph {
             output.push_str("\n\n");
             in_paragraph = false;
-            paragraph_in_wrapped_bold_run = false;
         }
         // Don't immediately end list on paragraph break
         // Let the continuation check below decide if we're still in a list
@@ -660,7 +572,6 @@ pub(super) fn to_markdown_from_lines_with_tables_and_images(
             if in_paragraph {
                 output.push_str("\n\n");
                 in_paragraph = false;
-                paragraph_in_wrapped_bold_run = false;
             }
             output.push_str(trimmed);
             output.push_str("\n\n");
@@ -714,9 +625,6 @@ pub(super) fn to_markdown_from_lines_with_tables_and_images(
                 if !(1..=15).contains(&word_count) {
                     return None;
                 }
-                if wrapped_bold_paragraph_lines.contains(&line_idx) {
-                    return None;
-                }
                 let rarity = font_size_rarity(line_font_size, &font_stats);
                 let all_bold = !line.items.is_empty() && line.items.iter().all(|i| i.is_bold);
                 let standalone = !in_paragraph;
@@ -748,7 +656,6 @@ pub(super) fn to_markdown_from_lines_with_tables_and_images(
             if in_paragraph {
                 output.push_str("\n\n");
                 in_paragraph = false;
-                paragraph_in_wrapped_bold_run = false;
             }
             let prefix = "#".repeat(level);
             // Use plain text for headers to avoid redundant formatting
@@ -771,7 +678,6 @@ pub(super) fn to_markdown_from_lines_with_tables_and_images(
             if in_paragraph {
                 output.push_str("\n\n");
                 in_paragraph = false;
-                paragraph_in_wrapped_bold_run = false;
             }
             output.push_str(&format!("- {}", trimmed));
             output.push('\n');
@@ -785,7 +691,6 @@ pub(super) fn to_markdown_from_lines_with_tables_and_images(
             if in_paragraph {
                 output.push_str("\n\n");
                 in_paragraph = false;
-                paragraph_in_wrapped_bold_run = false;
             }
             let formatted = format_list_item(trimmed);
             output.push_str(&formatted);
@@ -832,7 +737,6 @@ pub(super) fn to_markdown_from_lines_with_tables_and_images(
             if in_paragraph {
                 output.push_str("\n\n");
                 in_paragraph = false;
-                paragraph_in_wrapped_bold_run = false;
             }
             output.push_str(&format!("> {}\n", trimmed));
             continue;
@@ -843,7 +747,6 @@ pub(super) fn to_markdown_from_lines_with_tables_and_images(
             if in_paragraph {
                 output.push_str("\n\n");
                 in_paragraph = false;
-                paragraph_in_wrapped_bold_run = false;
             }
             if !in_code_block {
                 output.push_str("```\n");
@@ -864,11 +767,6 @@ pub(super) fn to_markdown_from_lines_with_tables_and_images(
             }
         }
         output.push_str(trimmed);
-        paragraph_in_wrapped_bold_run = if in_paragraph {
-            paragraph_in_wrapped_bold_run || line_in_wrapped_bold_run
-        } else {
-            line_in_wrapped_bold_run
-        };
         in_paragraph = true;
         prev_had_dot_leaders = cur_dot_leaders;
     }
@@ -938,8 +836,6 @@ pub fn to_markdown_from_lines(lines: Vec<TextLine>, options: MarkdownOptions) ->
     let para_threshold = compute_paragraph_threshold(&lines, base_size);
 
     let isolated_lines = find_isolated_lines(&lines, base_size, para_threshold);
-    let wrapped_bold_paragraph_lines =
-        find_wrapped_bold_paragraph_lines(&lines, base_size, para_threshold);
 
     let mut output = String::new();
     let mut current_page = 0u32;
@@ -948,7 +844,6 @@ pub fn to_markdown_from_lines(lines: Vec<TextLine>, options: MarkdownOptions) ->
     let mut in_paragraph = false;
     let mut last_list_x: Option<f32> = None;
     let mut prev_had_dot_leaders = false;
-    let mut paragraph_in_wrapped_bold_run = false;
 
     for (line_idx, line) in lines.iter().enumerate() {
         // Page break
@@ -965,7 +860,6 @@ pub fn to_markdown_from_lines(lines: Vec<TextLine>, options: MarkdownOptions) ->
             in_list = false;
             last_list_x = None;
             prev_had_dot_leaders = false;
-            paragraph_in_wrapped_bold_run = false;
 
             if options.include_page_numbers {
                 output.push_str(&format!("<!-- Page {} -->\n\n", current_page));
@@ -976,18 +870,9 @@ pub fn to_markdown_from_lines(lines: Vec<TextLine>, options: MarkdownOptions) ->
         // (newspaper columns emitted sequentially on the same page).
         let y_gap = prev_y - line.y;
         let is_para_break = y_gap.abs() > para_threshold;
-        let line_all_bold = !line.items.is_empty() && line.items.iter().all(|item| item.is_bold);
-        let line_in_wrapped_bold_run = wrapped_bold_paragraph_lines.contains(&line_idx);
-        let is_bold_to_regular_break = in_paragraph
-            && paragraph_in_wrapped_bold_run
-            && !line_in_wrapped_bold_run
-            && !line_all_bold
-            && y_gap > base_size * 1.2
-            && y_gap <= para_threshold;
-        if (is_para_break || is_bold_to_regular_break) && in_paragraph {
+        if is_para_break && in_paragraph {
             output.push_str("\n\n");
             in_paragraph = false;
-            paragraph_in_wrapped_bold_run = false;
         }
         // Don't immediately end list on paragraph break
         // Let the continuation check below decide if we're still in a list
@@ -1011,7 +896,6 @@ pub fn to_markdown_from_lines(lines: Vec<TextLine>, options: MarkdownOptions) ->
             if in_paragraph {
                 output.push_str("\n\n");
                 in_paragraph = false;
-                paragraph_in_wrapped_bold_run = false;
             }
             output.push_str(trimmed);
             output.push_str("\n\n");
@@ -1034,9 +918,6 @@ pub fn to_markdown_from_lines(lines: Vec<TextLine>, options: MarkdownOptions) ->
                     if !(1..=15).contains(&word_count) {
                         return None;
                     }
-                    if wrapped_bold_paragraph_lines.contains(&line_idx) {
-                        return None;
-                    }
                     let rarity = font_size_rarity(line_font_size, &font_stats);
                     let all_bold = !line.items.is_empty() && line.items.iter().all(|i| i.is_bold);
                     let standalone = !in_paragraph;
@@ -1054,7 +935,6 @@ pub fn to_markdown_from_lines(lines: Vec<TextLine>, options: MarkdownOptions) ->
                 if in_paragraph {
                     output.push_str("\n\n");
                     in_paragraph = false;
-                    paragraph_in_wrapped_bold_run = false;
                 }
                 let prefix = "#".repeat(header_level);
                 // Use plain text for headers to avoid redundant formatting
@@ -1069,7 +949,6 @@ pub fn to_markdown_from_lines(lines: Vec<TextLine>, options: MarkdownOptions) ->
             if in_paragraph {
                 output.push_str("\n\n");
                 in_paragraph = false;
-                paragraph_in_wrapped_bold_run = false;
             }
             let formatted = format_list_item(trimmed);
             output.push_str(&formatted);
@@ -1114,7 +993,6 @@ pub fn to_markdown_from_lines(lines: Vec<TextLine>, options: MarkdownOptions) ->
                 if in_paragraph {
                     output.push_str("\n\n");
                     in_paragraph = false;
-                    paragraph_in_wrapped_bold_run = false;
                 }
                 // Use plain text for code blocks
                 output.push_str(&format!("```\n{}\n```\n", plain_trimmed));
@@ -1132,11 +1010,6 @@ pub fn to_markdown_from_lines(lines: Vec<TextLine>, options: MarkdownOptions) ->
             }
         }
         output.push_str(trimmed);
-        paragraph_in_wrapped_bold_run = if in_paragraph {
-            paragraph_in_wrapped_bold_run || line_in_wrapped_bold_run
-        } else {
-            line_in_wrapped_bold_run
-        };
         in_paragraph = true;
         prev_had_dot_leaders = cur_dot_leaders;
     }
@@ -1483,109 +1356,6 @@ mod tests {
         );
     }
 
-    #[test]
-    fn test_wrapped_bold_abstract_is_not_split_into_headings() {
-        // Regression for arXiv 1107.1353: the opening abstract paragraph is
-        // entirely bold at body size. The first wrapped lines used to become
-        // separate H2 headings, and the following body paragraph was joined to
-        // the bold abstract because the paragraph gap is modest.
-        let make = |text: &str, y: f32, font_size: f32, bold: bool| {
-            let mut item = make_item(text, 1, None);
-            item.y = y;
-            item.font_size = font_size;
-            item.height = font_size;
-            item.is_bold = bold;
-            item
-        };
-
-        let lines = vec![
-            make_line(vec![make(
-                "Quantum Nature of Light Measured With a Single Detector",
-                747.7,
-                25.0,
-                true,
-            )]),
-            make_line(vec![make(
-                "Gesine A. Steudle1*, Stefan Schietinger1, David Höckel1",
-                651.1,
-                11.0,
-                false,
-            )]),
-            make_line(vec![make(
-                "Zwiller2, and Oliver Benson1",
-                638.5,
-                11.0,
-                false,
-            )]),
-            make_line(vec![make(
-                "The introduction of light quanta by Einstein in 1905 triggered strong efforts to",
-                607.5,
-                11.0,
-                true,
-            )]),
-            make_line(vec![make(
-                "demonstrate the quantum properties of light directly, without involving matter",
-                594.8,
-                11.0,
-                true,
-            )]),
-            make_line(vec![make(
-                "quantization. It however took more than seven decades for the quantum granularity",
-                582.2,
-                11.0,
-                true,
-            )]),
-            make_line(vec![make(
-                "of light to be observed in the fluorescence of single atoms. Single atoms emit",
-                569.5,
-                11.0,
-                true,
-            )]),
-            make_line(vec![make(
-                "photons one at a time, this is typically demonstrated with a Hanbury-Brown-Twiss",
-                556.9,
-                11.0,
-                true,
-            )]),
-            make_line(vec![make(
-                "Our work significantly simplifies a widely used photon-correlation technique.",
-                544.2,
-                11.0,
-                true,
-            )]),
-            make_line(vec![make(
-                "A photon is a single excitation of a mode of the electromagnetic field.",
-                528.7,
-                11.0,
-                false,
-            )]),
-        ];
-
-        let md = to_markdown_from_lines_with_tables_and_images(
-            lines,
-            MarkdownOptions::default(),
-            HashMap::new(),
-            HashMap::new(),
-            &std::collections::HashSet::new(),
-            None,
-        );
-
-        assert!(
-            md.contains("# Quantum Nature of Light Measured With a Single Detector"),
-            "title should remain a heading: {md}"
-        );
-        assert!(
-            !md.contains("## The introduction")
-                && !md.contains("## demonstrate")
-                && !md.contains("## quantization"),
-            "bold abstract lines should not become headings: {md}"
-        );
-        assert!(
-            md.contains("technique.**\n\nA photon is a single excitation"),
-            "body paragraph should be separated from bold abstract: {md}"
-        );
-    }
-
     #[test]
     fn test_struct_role_code_multiline_accumulation() {
         let mut line1 = make_item("fn main() {", 1, Some(0));

src/tables/format.rs

@@ -208,24 +208,6 @@ fn looks_like_compact_entry_label(cell: &str) -> bool {
     (1..=6).contains(&words)
 }
 
-fn looks_like_plain_section_label(cell: &str) -> bool {
-    let trimmed = cell.trim();
-    if trimmed.len() < 4 || trimmed.len() > 40 {
-        return false;
-    }
-    if trimmed.ends_with(['.', ',', ';', ':']) || trimmed.contains(|ch: char| ch.is_ascii_digit()) {
-        return false;
-    }
-    if trimmed.len() <= 4 && trimmed.chars().all(|ch| !ch.is_lowercase()) {
-        return false;
-    }
-    trimmed
-        .chars()
-        .all(|ch| ch.is_alphabetic() || ch.is_whitespace() || matches!(ch, '&' | '/' | '-'))
-        && starts_with_uppercase_alpha(trimmed)
-        && (1..=4).contains(&alpha_word_count(trimmed))
-}
-
 fn ends_like_incomplete_phrase(cell: &str) -> bool {
     let lower = cell.trim_end().to_ascii_lowercase();
     lower.ends_with(" and")
@@ -323,10 +305,6 @@ fn clean_table_cells(cells: &[Vec<String>]) -> (Vec<Vec<String>>, Vec<String>) {
             .and_then(|r| r.first())
             .map(|c| c.trim())
             .unwrap_or("");
-        let header_filled = cleaned
-            .first()
-            .map(|r| r.iter().filter(|c| !c.trim().is_empty()).count())
-            .unwrap_or(num_cols);
         let looks_like_spanning_first_column_row = first_cell.is_empty()
             && row.len() >= 4
             && non_first_cells.len() == row.len().saturating_sub(1)
@@ -350,10 +328,6 @@ fn clean_table_cells(cells: &[Vec<String>]) -> (Vec<Vec<String>>, Vec<String>) {
             && non_first_cells
                 .iter()
                 .any(|cell| looks_like_compact_entry_label(cell));
-        let looks_like_section_label_row = !first_cell.is_empty()
-            && filled_cells == 1
-            && header_filled >= 3
-            && looks_like_plain_section_label(first_cell);
         // Classic continuation: first cell empty, content in other cells
         let is_classic_continuation = first_cell.is_empty()
             && !non_first_cells.is_empty()
@@ -370,6 +344,10 @@ fn clean_table_cells(cells: &[Vec<String>]) -> (Vec<Vec<String>>, Vec<String>) {
             .last()
             .map(|r| r.iter().filter(|c| !c.trim().is_empty()).count())
             .unwrap_or(0);
+        let header_filled = cleaned
+            .first()
+            .map(|r| r.iter().filter(|c| !c.trim().is_empty()).count())
+            .unwrap_or(num_cols);
         // Merge when the row has significantly fewer filled cells than header.
         // For wide tables (5+ cols), require ≤50% of header cells.
         // For narrow tables (2-4 cols), require fewer than header cells.
@@ -391,7 +369,6 @@ fn clean_table_cells(cells: &[Vec<String>]) -> (Vec<Vec<String>>, Vec<String>) {
             && !looks_like_spanning_first_column_row
             && !looks_like_hierarchical_subrow
             && !looks_like_new_first_column_entry
-            && !looks_like_section_label_row
             && !is_short_subheader;
 
         let is_continuation = is_classic_continuation || is_wrapped_continuation;
@@ -537,44 +514,6 @@ mod tests {
         assert!(cleaned[1][1].contains("continued text here"));
     }
 
-    #[test]
-    fn test_clean_table_cells_first_column_section_label_not_merged() {
-        let cells = vec![
-            vec![
-                "Properties".into(),
-                "Conditions".into(),
-                "Method".into(),
-                "Typical values".into(),
-                "Units".into(),
-            ],
-            vec![
-                "Melt Flow Rate".into(),
-                "230 C/2.16 kg".into(),
-                "ASTM D1238".into(),
-                "3.0".into(),
-                "g/10 min".into(),
-            ],
-            vec![
-                "Mechanical".into(),
-                "".into(),
-                "".into(),
-                "".into(),
-                "".into(),
-            ],
-            vec![
-                "Tensile Stress at Yield".into(),
-                "50 mm/min".into(),
-                "ASTM D638".into(),
-                "31".into(),
-                "MPa".into(),
-            ],
-        ];
-        let (cleaned, _) = clean_table_cells(&cells);
-
-        assert_eq!(cleaned.len(), 4);
-        assert_eq!(cleaned[2][0], "Mechanical");
-    }
-
     #[test]
     fn test_clean_table_cells_short_subheader_not_merged() {
         let cells = vec![