bump npm package version to 1.6.1

Made-with: Cursor

napi/package.json

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

napi/src/lib.rs

@@ -422,52 +422,6 @@ pub fn extract_tables_with_structure_cells(
     })
 }
 
-/// One result from `extractTablesWithStructureAuto` — markdown plus a
-/// diagnostic flag identifying which path produced it.
-///
-/// `fallbackReason` is `null` when the TSR-hybrid path produced the
-/// markdown directly. When stage 1's quality check fires (the cells
-/// look like a SLANet detection pathology — phantom rows or multi-row
-/// content in a single cell), the heuristic table extractor is run on
-/// the same region instead, and `fallbackReason` carries the diagnostic
-/// label (`"phantom_empty_row"`, `"multi_row_in_cell"`).
-#[napi(object)]
-pub struct TableExtractionResultJs {
-    pub markdown: String,
-    pub fallback_reason: Option<String>,
-}
-
-/// Auto-fallback variant of [`extractTablesWithStructure`].
-///
-/// Runs the TSR-hybrid path, checks the resulting cells for known
-/// SLANet detection pathologies, and falls back to the heuristic
-/// `extractTablesInRegions` for any input where the TSR path looks
-/// compromised.
-///
-/// On clean inputs this returns identical markdown to
-/// `extractTablesWithStructure`; on flagged inputs the heuristic
-/// markdown replaces the TSR markdown and `fallbackReason` is set.
-#[napi]
-pub fn extract_tables_with_structure_auto(
-    buffer: Buffer,
-    inputs: Vec<TsrTableInputJs>,
-) -> Result<Vec<TableExtractionResultJs>> {
-    let bytes: Vec<u8> = buffer.to_vec();
-    let parsed = parse_tsr_inputs(&inputs);
-
-    catch_panic("extract_tables_with_structure_auto", move || {
-        let result = pdf_inspector::extract_tables_with_structure_auto_mem(&bytes, &parsed)
-            .map_err(|e| to_napi_err(e, "extract_tables_with_structure_auto"))?;
-        Ok(result
-            .into_iter()
-            .map(|r| TableExtractionResultJs {
-                markdown: r.markdown,
-                fallback_reason: r.fallback_reason,
-            })
-            .collect())
-    })
-}
-
 fn parse_tsr_inputs(inputs: &[TsrTableInputJs]) -> Vec<pdf_inspector::TsrTableInput> {
     inputs
         .iter()

src/bin/detect_pdf.rs

@@ -1,12 +1,8 @@
 //! CLI tool for detecting PDF type (text-based vs scanned)
 
-use pdf_inspector::{
-    detect_pdf_type, detector::estimate_page_count_from_bytes, process_pdf_with_options,
-    PdfOptions, PdfType, ProcessMode,
-};
+use pdf_inspector::{detect_pdf_type, process_pdf_with_options, PdfOptions, PdfType, ProcessMode};
 use std::env;
 use std::fmt::Write;
-use std::fs;
 use std::process;
 use std::time::Instant;
 
@@ -68,32 +64,6 @@ fn pdf_type_str(pdf_type: &PdfType) -> &'static str {
     }
 }
 
-fn page_count_hint(pdf_path: &str) -> Option<u32> {
-    fs::read(pdf_path)
-        .ok()
-        .map(|bytes| estimate_page_count_from_bytes(&bytes))
-        .filter(|&count| count > 0)
-}
-
-fn print_error(e: &pdf_inspector::PdfError, pdf_path: &str, json_output: bool) {
-    if json_output {
-        if let Some(count) = page_count_hint(pdf_path) {
-            println!(
-                r#"{{"error":"{}","page_count_hint":{}}}"#,
-                json_escape(&e.to_string()),
-                count
-            );
-        } else {
-            println!(r#"{{"error":"{}"}}"#, json_escape(&e.to_string()));
-        }
-    } else {
-        eprintln!("Error: {}", e);
-        if let Some(count) = page_count_hint(pdf_path) {
-            eprintln!("Page count hint: {}", count);
-        }
-    }
-}
-
 fn run_analyze(pdf_path: &str, json_output: bool, start: Instant) {
     match process_pdf_with_options(pdf_path, PdfOptions::new().mode(ProcessMode::Analyze)) {
         Ok(result) => {
@@ -165,7 +135,11 @@ fn run_analyze(pdf_path: &str, json_output: bool, start: Instant) {
             }
         }
         Err(e) => {
-            print_error(&e, pdf_path, json_output);
+            if json_output {
+                println!(r#"{{"error":"{}"}}"#, e);
+            } else {
+                eprintln!("Error: {}", e);
+            }
             process::exit(1);
         }
     }
@@ -262,7 +236,11 @@ fn run_detect_only(pdf_path: &str, json_output: bool, start: Instant) {
             }
         }
         Err(e) => {
-            print_error(&e, pdf_path, json_output);
+            if json_output {
+                println!(r#"{{"error":"{}"}}"#, e);
+            } else {
+                eprintln!("Error: {}", e);
+            }
             process::exit(1);
         }
     }

src/detector.rs

@@ -97,9 +97,26 @@ pub fn detect_pdf_type_with_config<P: AsRef<Path>>(
 ) -> Result<PdfTypeResult, PdfError> {
     crate::validate_pdf_file(&path)?;
 
-    let (doc, page_count) = crate::load_document_from_path(&path)?;
+    // First, load metadata only (fast operation)
+    let metadata = match Document::load_metadata(&path) {
+        Ok(m) => m,
+        Err(ref e) if crate::is_encrypted_lopdf_error(e) => {
+            Document::load_metadata_with_password(&path, "")?
+        }
+        Err(e) => return Err(e.into()),
+    };
 
-    detect_from_document(&doc, page_count, &config)
+    // Then load the full document for content inspection
+    // We use filtered loading to skip heavy objects we don't need
+    let doc = match Document::load(&path) {
+        Ok(d) => d,
+        Err(ref e) if crate::is_encrypted_lopdf_error(e) => {
+            Document::load_with_password(&path, "")?
+        }
+        Err(e) => return Err(e.into()),
+    };
+
+    detect_from_document(&doc, metadata.page_count, &config)
 }
 
 /// Detect PDF type from memory buffer
@@ -114,64 +131,25 @@ pub fn detect_pdf_type_mem_with_config(
 ) -> Result<PdfTypeResult, PdfError> {
     crate::validate_pdf_bytes(buffer)?;
 
-    let (doc, page_count) = crate::load_document_from_mem(buffer)?;
-
-    detect_from_document(&doc, page_count, &config)
-}
-
-/// Heuristic page-count fallback for malformed PDFs that cannot be parsed.
-///
-/// This scans raw bytes for page dictionaries (`/Type /Page`) while excluding
-/// the page tree node (`/Type /Pages`). It is intended as a low-confidence hint
-/// for diagnostics; parsed page-tree counts remain authoritative.
-pub fn estimate_page_count_from_bytes(buffer: &[u8]) -> u32 {
-    let mut count = 0u32;
-    let mut pos = 0usize;
-
-    while let Some(rel_idx) = find_bytes(&buffer[pos..], b"/Type") {
-        let mut value_pos = pos + rel_idx + b"/Type".len();
-        value_pos = skip_pdf_whitespace(buffer, value_pos);
-
-        if buffer.get(value_pos) == Some(&b'/') {
-            let name_start = value_pos + 1;
-            let name_end = name_start + b"Page".len();
-            if name_end <= buffer.len()
-                && &buffer[name_start..name_end] == b"Page"
-                && buffer
-                    .get(name_end)
-                    .is_none_or(|b| is_pdf_name_delimiter(*b))
-            {
-                count += 1;
-            }
+    // Load metadata first (fast)
+    let metadata = match Document::load_metadata_mem(buffer) {
+        Ok(m) => m,
+        Err(ref e) if crate::is_encrypted_lopdf_error(e) => {
+            Document::load_metadata_mem_with_password(buffer, "")?
         }
+        Err(e) => return Err(e.into()),
+    };
 
-        pos += rel_idx + b"/Type".len();
-    }
+    // Load document for inspection
+    let doc = match Document::load_mem(buffer) {
+        Ok(d) => d,
+        Err(ref e) if crate::is_encrypted_lopdf_error(e) => {
+            Document::load_mem_with_options(buffer, lopdf::LoadOptions::with_password(""))?
+        }
+        Err(e) => return Err(e.into()),
+    };
 
-    count
-}
-
-fn find_bytes(haystack: &[u8], needle: &[u8]) -> Option<usize> {
-    haystack.windows(needle.len()).position(|w| w == needle)
-}
-
-fn skip_pdf_whitespace(buffer: &[u8], mut pos: usize) -> usize {
-    while pos < buffer.len() && is_pdf_whitespace(buffer[pos]) {
-        pos += 1;
-    }
-    pos
-}
-
-fn is_pdf_whitespace(byte: u8) -> bool {
-    matches!(byte, b'\0' | b'\t' | b'\n' | 0x0C | b'\r' | b' ')
-}
-
-fn is_pdf_name_delimiter(byte: u8) -> bool {
-    is_pdf_whitespace(byte)
-        || matches!(
-            byte,
-            b'(' | b')' | b'<' | b'>' | b'[' | b']' | b'{' | b'}' | b'/' | b'%'
-        )
+    detect_from_document(&doc, metadata.page_count, &config)
 }
 
 /// Detection logic on a pre-loaded document.

src/extractor/mod.rs

@@ -36,14 +36,26 @@ pub(crate) use layout::ColumnRegion;
 /// Extract text from PDF file as plain string
 pub fn extract_text<P: AsRef<Path>>(path: P) -> Result<String, PdfError> {
     crate::validate_pdf_file(&path)?;
-    let (doc, _) = crate::load_document_from_path(&path)?;
+    let doc = match Document::load(&path) {
+        Ok(d) => d,
+        Err(ref e) if crate::is_encrypted_lopdf_error(e) => {
+            Document::load_with_password(&path, "")?
+        }
+        Err(e) => return Err(e.into()),
+    };
     extract_text_from_doc(&doc)
 }
 
 /// Extract text from PDF memory buffer
 pub fn extract_text_mem(buffer: &[u8]) -> Result<String, PdfError> {
     crate::validate_pdf_bytes(buffer)?;
-    let (doc, _) = crate::load_document_from_mem(buffer)?;
+    let doc = match Document::load_mem(buffer) {
+        Ok(d) => d,
+        Err(ref e) if crate::is_encrypted_lopdf_error(e) => {
+            Document::load_mem_with_options(buffer, lopdf::LoadOptions::with_password(""))?
+        }
+        Err(e) => return Err(e.into()),
+    };
     extract_text_from_doc(&doc)
 }
 
@@ -79,7 +91,13 @@ pub(crate) fn extract_text_with_positions_and_rects<P: AsRef<Path>>(
     page_filter: Option<&HashSet<u32>>,
 ) -> Result<PageExtraction, PdfError> {
     crate::validate_pdf_file(&path)?;
-    let (doc, _) = crate::load_document_from_path(&path)?;
+    let doc = match Document::load(&path) {
+        Ok(d) => d,
+        Err(ref e) if crate::is_encrypted_lopdf_error(e) => {
+            Document::load_with_password(&path, "")?
+        }
+        Err(e) => return Err(e.into()),
+    };
     let font_cmaps = FontCMaps::from_doc(&doc);
     let (extraction, _thresholds, _gid_pages) =
         extract_positioned_text_from_doc(&doc, &font_cmaps, page_filter)?;
@@ -106,7 +124,13 @@ pub(crate) fn extract_text_with_positions_mem_and_rects(
     page_filter: Option<&HashSet<u32>>,
 ) -> Result<PageExtraction, PdfError> {
     crate::validate_pdf_bytes(buffer)?;
-    let (doc, _) = crate::load_document_from_mem(buffer)?;
+    let doc = match Document::load_mem(buffer) {
+        Ok(d) => d,
+        Err(ref e) if crate::is_encrypted_lopdf_error(e) => {
+            Document::load_mem_with_options(buffer, lopdf::LoadOptions::with_password(""))?
+        }
+        Err(e) => return Err(e.into()),
+    };
     let font_cmaps = FontCMaps::from_doc(&doc);
     let (extraction, _thresholds, _gid_pages) =
         extract_positioned_text_from_doc(&doc, &font_cmaps, page_filter)?;

tests/integration_tests.rs

@@ -1,6 +1,6 @@
 //! Integration tests for pdf-to-markdown library
 
-use pdf_inspector::detector::{estimate_page_count_from_bytes, DetectionConfig, ScanStrategy};
+use pdf_inspector::detector::{DetectionConfig, ScanStrategy};
 use pdf_inspector::extractor::group_into_lines;
 use pdf_inspector::types::TextLine;
 use pdf_inspector::{
@@ -11,83 +11,6 @@ use pdf_inspector::{
 };
 use std::collections::HashSet;
 
-fn make_minimal_text_pdf() -> Vec<u8> {
-    let mut pdf = b"%PDF-1.4\n".to_vec();
-    let mut offsets = vec![0usize];
-
-    fn add_object(pdf: &mut Vec<u8>, offsets: &mut Vec<usize>, id: usize, body: &str) {
-        offsets.push(pdf.len());
-        pdf.extend_from_slice(format!("{id} 0 obj\n").as_bytes());
-        pdf.extend_from_slice(body.as_bytes());
-        pdf.extend_from_slice(b"\nendobj\n");
-    }
-
-    add_object(
-        &mut pdf,
-        &mut offsets,
-        1,
-        "<< /Type /Catalog /Pages 2 0 R >>",
-    );
-    add_object(
-        &mut pdf,
-        &mut offsets,
-        2,
-        "<< /Type /Pages /Kids [3 0 R] /Count 1 >>",
-    );
-    add_object(
-        &mut pdf,
-        &mut offsets,
-        3,
-        "<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] /Resources << /Font << /F1 5 0 R >> >> /Contents 4 0 R >>",
-    );
-
-    let content = "BT /F1 12 Tf 100 700 Td (Hello World) Tj 0 -14 Td (Second Line) Tj 0 -14 Td (Third Line) Tj ET";
-    add_object(
-        &mut pdf,
-        &mut offsets,
-        4,
-        &format!(
-            "<< /Length {} >>\nstream\n{}\nendstream",
-            content.len(),
-            content
-        ),
-    );
-    add_object(
-        &mut pdf,
-        &mut offsets,
-        5,
-        "<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica >>",
-    );
-
-    let xref_start = pdf.len();
-    pdf.extend_from_slice(format!("xref\n0 {}\n", offsets.len()).as_bytes());
-    pdf.extend_from_slice(b"0000000000 65535 f \n");
-    for offset in offsets.iter().skip(1) {
-        pdf.extend_from_slice(format!("{offset:010} 00000 n \n").as_bytes());
-    }
-    pdf.extend_from_slice(
-        format!(
-            "trailer\n<< /Size {} /Root 1 0 R >>\nstartxref\n{}\n%%EOF",
-            offsets.len(),
-            xref_start
-        )
-        .as_bytes(),
-    );
-
-    pdf
-}
-
-fn truncate_eof_marker(mut pdf: Vec<u8>) -> Vec<u8> {
-    assert!(pdf.ends_with(b"%%EOF"));
-    pdf.pop();
-    pdf
-}
-
-fn add_leading_tab(mut pdf: Vec<u8>) -> Vec<u8> {
-    pdf.insert(0, b'\t');
-    pdf
-}
-
 // Helper to create test TextItems
 fn make_text_item(text: &str, x: f32, y: f32, font_size: f32, page: u32) -> TextItem {
     use pdf_inspector::types::ItemType;
@@ -903,73 +826,6 @@ fn test_bom_prefixed_pdf_header_not_rejected() {
     }
 }
 
-#[test]
-fn test_process_pdf_mem_repairs_truncated_eof_marker() {
-    let pdf = truncate_eof_marker(make_minimal_text_pdf());
-
-    let result = process_pdf_mem(&pdf).expect("truncated %%EO marker should be repaired");
-
-    assert_eq!(result.pdf_type, PdfType::TextBased);
-    assert_eq!(result.page_count, 1);
-    assert!(
-        result
-            .markdown
-            .as_deref()
-            .unwrap_or_default()
-            .contains("Hello World"),
-        "repaired PDF should still extract text"
-    );
-}
-
-#[test]
-fn test_process_pdf_mem_repairs_leading_tab_and_truncated_eof() {
-    let pdf = add_leading_tab(truncate_eof_marker(make_minimal_text_pdf()));
-
-    let result = process_pdf_mem(&pdf).expect("leading whitespace + %%EO should be repaired");
-
-    assert_eq!(result.pdf_type, PdfType::TextBased);
-    assert_eq!(result.page_count, 1);
-    assert!(
-        result
-            .markdown
-            .as_deref()
-            .unwrap_or_default()
-            .contains("Hello World"),
-        "repaired PDF should still extract text"
-    );
-}
-
-#[test]
-fn test_detect_pdf_type_repairs_container_from_path() {
-    let pdf = add_leading_tab(truncate_eof_marker(make_minimal_text_pdf()));
-    let dir = tempfile::tempdir().unwrap();
-    let path = dir.path().join("broken-container.pdf");
-    std::fs::write(&path, pdf).unwrap();
-
-    let result = detect_pdf_type(&path).expect("detector should use shared repair loader");
-
-    assert_eq!(result.pdf_type, PdfType::TextBased);
-    assert_eq!(result.page_count, 1);
-    assert_eq!(result.pages_with_text, 1);
-}
-
-#[test]
-fn test_extract_text_mem_uses_container_repair() {
-    let pdf = truncate_eof_marker(make_minimal_text_pdf());
-
-    let text = pdf_inspector::extractor::extract_text_mem(&pdf)
-        .expect("plain text extraction should use shared repair loader");
-
-    assert!(text.contains("Hello World"));
-}
-
-#[test]
-fn test_estimate_page_count_from_bytes_excludes_pages_tree() {
-    let pdf = add_leading_tab(truncate_eof_marker(make_minimal_text_pdf()));
-
-    assert_eq!(estimate_page_count_from_bytes(&pdf), 1);
-}
-
 #[test]
 fn test_not_a_pdf_detect_pdf_type_mem() {
     // Verify detect_pdf_type_mem is also guarded
@@ -2052,357 +1908,6 @@ fn test_extract_tables_with_structure_separator_after_thead() {
     assert_eq!(mds[0], "|Department|Core Courses|\n|---|---|\n|BIO|8.23|\n");
 }
 
-// =========================================================================
-// extract_tables_with_structure_auto_mem tests (TSR + heuristic fallback)
-// =========================================================================
-
-#[test]
-fn test_auto_passes_through_clean_tsr_output() {
-    use pdf_inspector::{extract_tables_with_structure_auto_mem, TsrTableInput};
-
-    let buf = synthetic_dense_table_pdf();
-    let tokens: Vec<String> = [
-        "<table>",
-        "<thead>",
-        "<tr>",
-        "<th></th>",
-        "<th></th>",
-        "</tr>",
-        "</thead>",
-        "<tbody>",
-        "<tr>",
-        "<td></td>",
-        "<td></td>",
-        "</tr>",
-        "<tr>",
-        "<td></td>",
-        "<td></td>",
-        "</tr>",
-        "</tbody>",
-        "</table>",
-    ]
-    .into_iter()
-    .map(String::from)
-    .collect();
-    // Cells fit each visible row cleanly. Same shape as the existing
-    // dense-overlap regression test — TSR should produce clean output
-    // and the auto wrapper should pass through with no fallback.
-    let cell_bboxes = vec![
-        poly(10.0, 72.0, 100.0, 112.0),
-        poly(90.0, 72.0, 180.0, 112.0),
-        poly(10.0, 88.8, 100.0, 128.8),
-        poly(90.0, 88.8, 180.0, 128.8),
-        poly(10.0, 105.6, 100.0, 145.6),
-        poly(90.0, 105.6, 180.0, 145.6),
-    ];
-
-    let results = extract_tables_with_structure_auto_mem(
-        &buf,
-        &[TsrTableInput {
-            page: 0,
-            crop_pdf_pt_bbox: [0.0, 0.0, 200.0, 800.0],
-            render_dpi: 72.0,
-            structure_tokens: tokens,
-            cell_bboxes,
-        }],
-    )
-    .unwrap();
-    assert_eq!(results.len(), 1);
-    assert!(
-        results[0].fallback_reason.is_none(),
-        "expected no fallback, got {:?}",
-        results[0].fallback_reason
-    );
-    assert!(results[0].markdown.contains("Oak Street"));
-    assert!(results[0].markdown.contains("Boardwalk"));
-    assert!(!results[0].markdown.contains("Oak Street Boardwalk"));
-}
-
-#[test]
-fn test_auto_falls_back_on_multi_row_in_cell() {
-    use pdf_inspector::{extract_tables_with_structure_auto_mem, TsrTableInput};
-
-    let buf = synthetic_dense_table_pdf();
-    // TSR returns only 2 rows for what's actually 3 visible PDF rows.
-    // Row 1's cells are tall enough to encompass both Oak Street and
-    // Boardwalk text — the FNBO row-undercount pattern.
-    let tokens: Vec<String> = [
-        "<table>",
-        "<thead>",
-        "<tr>",
-        "<th></th>",
-        "<th></th>",
-        "</tr>",
-        "</thead>",
-        "<tbody>",
-        "<tr>",
-        "<td></td>",
-        "<td></td>",
-        "</tr>",
-        "</tbody>",
-        "</table>",
-    ]
-    .into_iter()
-    .map(String::from)
-    .collect();
-    // Header row at top-left y=[88, 105] (covers "Branch Name"/"Deposits"
-    // at native y=700, top-left y≈92-103). The "data" row at top-left
-    // y=[105, 145] is intentionally tall — covers BOTH the Oak Street
-    // line (top-left y≈108-119) AND the Boardwalk line (y≈124-135).
-    let cell_bboxes = vec![
-        poly(10.0, 88.0, 100.0, 105.0),
-        poly(90.0, 88.0, 180.0, 105.0),
-        poly(10.0, 105.0, 100.0, 145.0),
-        poly(90.0, 105.0, 180.0, 145.0),
-    ];
-
-    let results = extract_tables_with_structure_auto_mem(
-        &buf,
-        &[TsrTableInput {
-            page: 0,
-            crop_pdf_pt_bbox: [0.0, 0.0, 200.0, 800.0],
-            render_dpi: 72.0,
-            structure_tokens: tokens,
-            cell_bboxes,
-        }],
-    )
-    .unwrap();
-    assert_eq!(results.len(), 1);
-    assert_eq!(
-        results[0].fallback_reason.as_deref(),
-        Some("multi_row_in_cell"),
-        "expected multi_row_in_cell fallback, got {:?}",
-        results[0].fallback_reason
-    );
-    // The heuristic-fallback markdown should preserve all three PDF rows.
-    let md = &results[0].markdown;
-    assert!(md.contains("Oak Street"), "missing Oak Street: {md}");
-    assert!(md.contains("Boardwalk"), "missing Boardwalk: {md}");
-    assert!(md.contains("100"), "missing 100: {md}");
-    assert!(md.contains("200"), "missing 200: {md}");
-}
-
-#[test]
-fn test_auto_returns_empty_inputs() {
-    use pdf_inspector::extract_tables_with_structure_auto_mem;
-    let buf = synthetic_dense_table_pdf();
-    let results = extract_tables_with_structure_auto_mem(&buf, &[]).unwrap();
-    assert!(results.is_empty());
-}
-
-#[test]
-fn test_auto_does_not_fire_on_legit_rowspan_cell() {
-    use pdf_inspector::{extract_tables_with_structure_auto_mem, TsrTableInput};
-
-    let buf = synthetic_dense_table_pdf();
-    // 2 columns, 3 rows in the visible PDF. SLANet emits a 2-row table
-    // where the LEFT cell of row 1 is a rowspan=2 cell that legitimately
-    // covers Oak Street + Boardwalk on two visual lines. The right
-    // column has two normal rows. multi_row_in_cell must NOT fire on
-    // the rowspan=2 cell.
-    let tokens: Vec<String> = [
-        "<table>",
-        "<thead>",
-        "<tr>",
-        "<th></th>",
-        "<th></th>",
-        "</tr>",
-        "</thead>",
-        "<tbody>",
-        "<tr>",
-        // First data cell explicitly declares rowspan=2.
-        "<td",
-        " rowspan=\"2\"",
-        ">",
-        "</td>",
-        "<td></td>",
-        "</tr>",
-        "<tr>",
-        "<td></td>",
-        "</tr>",
-        "</tbody>",
-        "</table>",
-    ]
-    .into_iter()
-    .map(String::from)
-    .collect();
-    // Header row, then a tall left cell covering both data lines, plus
-    // two narrow right cells (one per line).
-    let cell_bboxes = vec![
-        poly(10.0, 88.0, 100.0, 105.0),
-        poly(90.0, 88.0, 180.0, 105.0),
-        poly(10.0, 105.0, 100.0, 145.0), // rowspan=2 — covers both lines
-        poly(90.0, 105.0, 180.0, 122.0), // row 1 only
-        poly(90.0, 122.0, 180.0, 145.0), // row 2 only
-    ];
-
-    let results = extract_tables_with_structure_auto_mem(
-        &buf,
-        &[TsrTableInput {
-            page: 0,
-            crop_pdf_pt_bbox: [0.0, 0.0, 200.0, 800.0],
-            render_dpi: 72.0,
-            structure_tokens: tokens,
-            cell_bboxes,
-        }],
-    )
-    .unwrap();
-    assert_eq!(results.len(), 1);
-    assert!(
-        results[0].fallback_reason.is_none(),
-        "rowspan=2 cell containing 2 visual lines should not trip multi_row_in_cell, got reason={:?}",
-        results[0].fallback_reason,
-    );
-}
-
-#[test]
-fn test_auto_keeps_tsr_markdown_when_heuristic_returns_empty() {
-    use pdf_inspector::{extract_tables_with_structure_auto_mem, TsrTableInput};
-
-    let buf = synthetic_dense_table_pdf();
-    // Same shape as the multi_row_in_cell regression — a tall data cell
-    // that catches Oak Street + Boardwalk. But the crop bbox we pass
-    // points at a strip of the page that has NO text items, so the
-    // heuristic's region will be empty when it tries to extract there.
-    // The auto wrapper must keep the TSR markdown rather than ship "".
-    let tokens: Vec<String> = [
-        "<table>",
-        "<thead>",
-        "<tr>",
-        "<th></th>",
-        "<th></th>",
-        "</tr>",
-        "</thead>",
-        "<tbody>",
-        "<tr>",
-        "<td></td>",
-        "<td></td>",
-        "</tr>",
-        "</tbody>",
-        "</table>",
-    ]
-    .into_iter()
-    .map(String::from)
-    .collect();
-    // Cell bboxes overlap the actual PDF text (so multi_row_in_cell
-    // fires) — but the crop_pdf_pt_bbox we hand to the heuristic is a
-    // wholly-empty region of the page. The heuristic should return "".
-    let cell_bboxes = vec![
-        poly(10.0, 88.0, 100.0, 105.0),
-        poly(90.0, 88.0, 180.0, 105.0),
-        poly(10.0, 105.0, 100.0, 145.0),
-        poly(90.0, 105.0, 180.0, 145.0),
-    ];
-
-    let results = extract_tables_with_structure_auto_mem(
-        &buf,
-        &[TsrTableInput {
-            page: 0,
-            // Crop is at the BOTTOM of the page where there's no text.
-            crop_pdf_pt_bbox: [0.0, 0.0, 200.0, 50.0],
-            render_dpi: 72.0,
-            structure_tokens: tokens,
-            cell_bboxes,
-        }],
-    )
-    .unwrap();
-    assert_eq!(results.len(), 1);
-    let r = &results[0];
-    assert_eq!(
-        r.fallback_reason.as_deref(),
-        Some("multi_row_in_cell_heuristic_empty"),
-        "expected _heuristic_empty suffix, got {:?}",
-        r.fallback_reason,
-    );
-    // TSR markdown should be preserved — non-empty, contains the cell
-    // text we know was assigned by the TSR path.
-    assert!(
-        !r.markdown.trim().is_empty(),
-        "expected TSR markdown to be preserved, got empty",
-    );
-    assert!(
-        r.markdown.contains("Oak Street") || r.markdown.contains("Boardwalk"),
-        "expected TSR markdown to contain at least one row, got: {}",
-        r.markdown,
-    );
-}
-
-#[test]
-fn test_auto_isolates_per_input_failures() {
-    use pdf_inspector::{extract_tables_with_structure_auto_mem, TsrTableInput};
-
-    let buf = synthetic_dense_table_pdf();
-    let good_tokens: Vec<String> = [
-        "<table>",
-        "<thead>",
-        "<tr>",
-        "<th></th>",
-        "<th></th>",
-        "</tr>",
-        "</thead>",
-        "<tbody>",
-        "<tr>",
-        "<td></td>",
-        "<td></td>",
-        "</tr>",
-        "<tr>",
-        "<td></td>",
-        "<td></td>",
-        "</tr>",
-        "</tbody>",
-        "</table>",
-    ]
-    .into_iter()
-    .map(String::from)
-    .collect();
-    // A clean input that should pass through with no fallback.
-    let good_input = TsrTableInput {
-        page: 0,
-        crop_pdf_pt_bbox: [0.0, 0.0, 200.0, 800.0],
-        render_dpi: 72.0,
-        structure_tokens: good_tokens,
-        cell_bboxes: vec![
-            poly(10.0, 72.0, 100.0, 112.0),
-            poly(90.0, 72.0, 180.0, 112.0),
-            poly(10.0, 88.8, 100.0, 128.8),
-            poly(90.0, 88.8, 180.0, 128.8),
-            poly(10.0, 105.6, 100.0, 145.6),
-            poly(90.0, 105.6, 180.0, 145.6),
-        ],
-    };
-    // A bad input that targets a non-existent page. The detection
-    // helper short-circuits on missing pages with Ok(None), so this
-    // shouldn't itself crash, but pairing it with a flagged input
-    // exercises the per-input control flow regardless. The point of
-    // this test is that one input's outcome doesn't poison the other.
-    let bad_input = TsrTableInput {
-        page: 9999,
-        crop_pdf_pt_bbox: [0.0, 0.0, 100.0, 100.0],
-        render_dpi: 72.0,
-        structure_tokens: vec![
-            "<table>".into(),
-            "<tr>".into(),
-            "<td></td>".into(),
-            "</tr>".into(),
-            "</table>".into(),
-        ],
-        cell_bboxes: vec![poly(0.0, 0.0, 50.0, 50.0)],
-    };
-
-    let results = extract_tables_with_structure_auto_mem(&buf, &[good_input, bad_input]).unwrap();
-    assert_eq!(results.len(), 2);
-    // Good input still produces non-empty TSR markdown with no fallback.
-    assert!(
-        results[0].fallback_reason.is_none(),
-        "good input should pass through, got reason={:?}",
-        results[0].fallback_reason,
-    );
-    assert!(results[0].markdown.contains("Oak Street"));
-    // Bad input collapses to empty markdown but doesn't take the
-    // batch down with it.
-    assert_eq!(results[1].markdown, "");
-}
-
 // =========================================================================
 // extract_pages_markdown_mem tests
 // =========================================================================