docs: refresh benchmark table with current numbers

Re-ran opendataloader-bench on current main. pdf-inspector improved across the board since the last table: overall 0.78→0.83, tables 0.59→0.66, headings 0.57→0.74 (competitor rows unchanged). Updated the prose — heading detection no longer lags opendataloader, and overall is now within 0.01 of it at ~2.5× the speed. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-07-11 00:45:37 -07:00
33 changed files with 133 additions and 3137 deletions
@@ -1,36 +0,0 @@
-name: Deploy landing page
-
-on:
-  push:
-    branches: [main]
-    paths: ['site/**', '.github/workflows/pages.yml']
-  workflow_dispatch:
-
-permissions:
-  contents: read
-  pages: write
-  id-token: write
-
-# Allow one concurrent deployment; don't cancel an in-progress production deploy.
-concurrency:
-  group: pages
-  cancel-in-progress: false
-
-jobs:
-  deploy:
-    name: Build & deploy to GitHub Pages
-    runs-on: ubuntu-latest
-    environment:
-      name: github-pages
-      url: ${{ steps.deploy.outputs.page_url }}
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Upload site artifact
-        uses: actions/upload-pages-artifact@v3
-        with:
-          path: site
-
-      - name: Deploy to GitHub Pages
-        id: deploy
-        uses: actions/deploy-pages@v4
@@ -4,9 +4,6 @@ on:
  push:
    branches: [main]
    paths: ['Cargo.toml']
-  # Manual fallback: retry a publish that failed after the version was
-  # already merged (a plain re-push won't register as a version change).
-  workflow_dispatch:

 permissions:
  contents: read
@@ -17,10 +14,6 @@ env:
 jobs:
  check-version:
    name: Check version change
-    # Guard manual dispatches: crates.io trusted publishing matches
-    # repo+workflow+environment but NOT branch, so without this a
-    # workflow_dispatch from any branch could publish unmerged code.
-    if: github.ref == 'refs/heads/main'
    runs-on: ubuntu-latest
    outputs:
      changed: ${{ steps.check.outputs.changed }}
@@ -35,27 +28,18 @@ jobs:
        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 [ "${{ github.event_name }}" = "workflow_dispatch" ]; then
-            # Manual dispatch publishes the current version regardless of the
-            # previous commit; the crates.io check below still prevents
-            # double-publishing an already-released version.
-            echo "manual dispatch: publishing v$NEW_VERSION"
-            echo "changed=true" >> "$GITHUB_OUTPUT"
-          else
-            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"
-
-            if [ "$NEW_VERSION" = "$OLD_VERSION" ]; then
-              echo "changed=false" >> "$GITHUB_OUTPUT"
-              echo "published=false" >> "$GITHUB_OUTPUT"
-              exit 0
-            fi
-
-            echo "changed=true" >> "$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")
@@ -1,166 +0,0 @@
-name: Publish Python package
-
-on:
-  push:
-    branches: [main]
-    paths: ['pyproject.toml']
-  # Manual fallback: re-publish the current version without a version bump
-  # (e.g. first run after PyPI trusted publishing is configured).
-  workflow_dispatch:
-
-permissions:
-  contents: read
-
-jobs:
-  check-version:
-    name: Check version change
-    # Guard manual dispatches too: PyPI trusted publishing matches
-    # repo+workflow+environment but NOT branch, so without this a
-    # workflow_dispatch from any branch could publish unmerged code.
-    if: github.ref == 'refs/heads/main'
-    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("pyproject.toml").read_text())["project"]["version"])')
-          echo "version=$NEW_VERSION" >> "$GITHUB_OUTPUT"
-
-          if [ "${{ github.event_name }}" = "workflow_dispatch" ]; then
-            # Manual dispatch always rebuilds and publishes. Combined with
-            # skip-existing on the publish step, this repairs partial releases
-            # (PyPI's version endpoint returns 200 even when only some of the
-            # expected wheels were uploaded).
-            echo "manual dispatch: publishing v$NEW_VERSION (skip-existing handles uploaded files)"
-            echo "changed=true" >> "$GITHUB_OUTPUT"
-            echo "published=false" >> "$GITHUB_OUTPUT"
-            exit 0
-          fi
-
-          # .get(): the parent commit may predate the static version field
-          # (pyproject.toml used dynamic = ["version"]) — treat that as a change
-          # so the very first merge of this workflow publishes.
-          OLD_VERSION=$(git show HEAD~1:pyproject.toml | python3 -c 'import sys, tomllib; print(tomllib.loads(sys.stdin.read())["project"].get("version", ""))')
-          echo "old=$OLD_VERSION new=$NEW_VERSION"
-
-          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/pypi-version.json --write-out "%{http_code}" \
-            "https://pypi.org/pypi/pdf-inspector/$NEW_VERSION/json")
-
-          case "$HTTP_STATUS" in
-            200)
-              echo "published=true" >> "$GITHUB_OUTPUT"
-              echo "pdf-inspector v$NEW_VERSION is already published to PyPI"
-              ;;
-            404)
-              echo "published=false" >> "$GITHUB_OUTPUT"
-              ;;
-            *)
-              cat /tmp/pypi-version.json
-              echo "Unexpected PyPI response: $HTTP_STATUS" >&2
-              exit 1
-              ;;
-          esac
-
-  build:
-    needs: check-version
-    if: needs.check-version.outputs.changed == 'true' && needs.check-version.outputs.published == 'false'
-    name: Build ${{ matrix.target }}
-    runs-on: ${{ matrix.os }}
-    strategy:
-      matrix:
-        include:
-          - os: ubuntu-latest
-            target: x86_64-unknown-linux-gnu
-          - os: ubuntu-latest
-            target: aarch64-unknown-linux-gnu
-          # macos-13 was retired by GitHub; macos-15-intel is the remaining
-          # Intel runner label (available through 2027).
-          - os: macos-15-intel
-            target: x86_64-apple-darwin
-          - os: macos-14
-            target: aarch64-apple-darwin
-          - os: windows-latest
-            target: x86_64-pc-windows-msvc
-    steps:
-      - uses: actions/checkout@v4
-
-      - uses: actions/setup-python@v5
-        with:
-          python-version: '3.12'
-
-      - name: Build wheel
-        uses: PyO3/maturin-action@v1
-        with:
-          target: ${{ matrix.target }}
-          args: --release --out dist
-          manylinux: auto
-
-      - name: Upload wheel
-        uses: actions/upload-artifact@v4
-        with:
-          name: wheels-${{ matrix.target }}
-          path: dist/*.whl
-          if-no-files-found: error
-
-  sdist:
-    needs: check-version
-    if: needs.check-version.outputs.changed == 'true' && needs.check-version.outputs.published == 'false'
-    name: Build sdist
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Build sdist
-        uses: PyO3/maturin-action@v1
-        with:
-          command: sdist
-          args: --out dist
-
-      - name: Upload sdist
-        uses: actions/upload-artifact@v4
-        with:
-          name: sdist
-          path: dist/*.tar.gz
-          if-no-files-found: error
-
-  publish:
-    name: Publish to PyPI
-    needs: [check-version, build, sdist]
-    runs-on: ubuntu-latest
-    environment: pypi
-    permissions:
-      contents: read
-      id-token: write
-    steps:
-      - name: Download all artifacts
-        uses: actions/download-artifact@v4
-        with:
-          path: dist
-          merge-multiple: true
-
-      - name: List artifacts
-        run: ls -la dist/
-
-      - name: Publish to PyPI
-        uses: pypa/gh-action-pypi-publish@release/v1
-        with:
-          packages-dir: dist
-          # Tolerate already-uploaded files so a manual re-run can complete
-          # a release that previously failed partway through.
-          skip-existing: true
@@ -4,9 +4,6 @@ on:
  push:
    branches: [main]
    paths: ['napi/package.json']
-  # Manual fallback: retry a publish that failed partway (per-package
-  # already-published checks make re-runs idempotent).
-  workflow_dispatch:

 permissions:
  contents: read
@@ -15,10 +12,6 @@ permissions:
 jobs:
  check-version:
    name: Check version change
-    # Guard manual dispatches: npm trusted publishing matches
-    # repo+workflow+environment but NOT branch, so without this a
-    # workflow_dispatch from any branch could publish unmerged code.
-    if: github.ref == 'refs/heads/main'
    runs-on: ubuntu-latest
    outputs:
      changed: ${{ steps.check.outputs.changed }}
@@ -32,21 +25,11 @@ jobs:
        id: check
        run: |
          NEW_VERSION=$(node -p "require('./napi/package.json').version")
-          echo "version=$NEW_VERSION" >> "$GITHUB_OUTPUT"
-
-          if [ "${{ github.event_name }}" = "workflow_dispatch" ]; then
-            # Manual dispatch rebuilds and publishes the current version; the
-            # per-package already-published checks in the publish job skip
-            # anything that made it out in a previous partial run.
-            echo "manual dispatch: publishing v$NEW_VERSION"
-            echo "changed=true" >> "$GITHUB_OUTPUT"
-            exit 0
-          fi
-
          OLD_VERSION=$(git show HEAD~1:napi/package.json | node -p "JSON.parse(require('fs').readFileSync('/dev/stdin','utf8')).version")
          echo "old=$OLD_VERSION new=$NEW_VERSION"
          if [ "$NEW_VERSION" != "$OLD_VERSION" ]; then
            echo "changed=true" >> "$GITHUB_OUTPUT"
+            echo "version=$NEW_VERSION" >> "$GITHUB_OUTPUT"
          else
            echo "changed=false" >> "$GITHUB_OUTPUT"
          fi
@@ -132,81 +115,14 @@ jobs:
        with:
          path: napi/artifacts

-      - name: Publish platform packages
+      - name: Collect binaries and publish
        working-directory: napi
        run: |
-          VERSION="${{ needs.check-version.outputs.version }}"
-
-          for node_file in artifacts/bindings-*/pdf-inspector.*.node; do
-            base=$(basename "$node_file")
-            suffix=${base#pdf-inspector.}
-            suffix=${suffix%.node}
-            pkg="@firecrawl/pdf-inspector-$suffix"
-
-            if npm view "$pkg@$VERSION" version >/dev/null 2>&1; then
-              echo "$pkg@$VERSION already published — skipping"
-              continue
-            fi
-
-            dir="npm-dist/$suffix"
-            mkdir -p "$dir"
-            cp "$node_file" "$dir/"
-            node -e '
-              const [suffix, version] = process.argv.slice(1)
-              const meta = {
-                "linux-x64-gnu":  { os: ["linux"],  cpu: ["x64"], libc: ["glibc"] },
-                "darwin-arm64":   { os: ["darwin"], cpu: ["arm64"] },
-                "win32-x64-msvc": { os: ["win32"],  cpu: ["x64"] },
-              }[suffix]
-              if (!meta) {
-                console.error(`unknown platform suffix: ${suffix} — add it to the meta map`)
-                process.exit(1)
-              }
-              const pkg = {
-                name: `@firecrawl/pdf-inspector-${suffix}`,
-                version,
-                description: `Prebuilt ${suffix} binary for @firecrawl/pdf-inspector`,
-                main: `pdf-inspector.${suffix}.node`,
-                files: [`pdf-inspector.${suffix}.node`],
-                license: "MIT",
-                engines: { node: ">= 10" },
-                repository: { type: "git", url: "https://github.com/firecrawl/pdf-inspector" },
-                publishConfig: { access: "public" },
-                ...meta,
-              }
-              require("fs").writeFileSync(`npm-dist/${suffix}/package.json`, JSON.stringify(pkg, null, 2) + "\n")
-            ' "$suffix" "$VERSION"
-
-            echo "=== $pkg@$VERSION ==="
-            ls -la "$dir"
-            (cd "$dir" && npm publish --provenance --access public)
-          done
-
-      - name: Publish main package
-        working-directory: napi
-        run: |
-          VERSION="${{ needs.check-version.outputs.version }}"
-
-          if npm view "@firecrawl/pdf-inspector@$VERSION" version >/dev/null 2>&1; then
-            echo "@firecrawl/pdf-inspector@$VERSION already published — skipping"
-            exit 0
-          fi
-
+          cp artifacts/bindings-*/*.node .
          cp artifacts/js-bindings/index.js .
          cp artifacts/js-bindings/index.d.ts .

-          # Stamp optionalDependencies to this exact version so the platform
-          # pins can never drift from the main package version.
-          node -e '
-            const fs = require("fs")
-            const pkg = JSON.parse(fs.readFileSync("package.json", "utf8"))
-            for (const dep of Object.keys(pkg.optionalDependencies ?? {})) {
-              pkg.optionalDependencies[dep] = pkg.version
-            }
-            fs.writeFileSync("package.json", JSON.stringify(pkg, null, 2) + "\n")
-          '
-
-          echo "=== Main package contents ==="
-          npm pack --dry-run
+          echo "=== Package contents ==="
+          ls -la *.node index.js index.d.ts

          npm publish --provenance --access public
@@ -1,25 +1,12 @@
 [package]
 name = "pdf-inspector"
-version = "0.1.6"
+version = "0.1.4"
 edition = "2021"
 autobins = false
 authors = ["Firecrawl Team"]
 description = "Fast PDF inspection, classification, and text extraction with smart scanned vs text-based detection"
 license = "MIT"
 repository = "https://github.com/firecrawl/pdf-inspector"
-readme = "docs/rust-api.md"
-# Explicit allowlist: crates.io caps uploads at 10 MiB and tests/fixtures
-# alone exceeds that. external/bcmaps ships in the crate — tounicode.rs
-# loads it at runtime relative to CARGO_MANIFEST_DIR.
-include = [
-    "src/**",
-    "external/bcmaps/**",
-    "docs/rust-api.md",
-    "LICENSE",
-    # maturin derives the sdist file list from this allowlist; the stub must
-    # ship so wheels built from the sdist keep their type hints.
-    "pdf_inspector.pyi",
-]

 [lib]
 name = "pdf_inspector"
@@ -27,7 +14,7 @@ crate-type = ["lib", "cdylib"]

 [dependencies]
 # Python bindings
-pyo3 = { version = "0.25", features = ["extension-module", "abi3-py38"], optional = true }
+pyo3 = { version = "0.25", features = ["extension-module"], optional = true }

 # PDF parsing
 lopdf = { version = "0.41.0", features = ["rayon"] }
@@ -2,7 +2,6 @@

 [![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)
-[![PyPI](https://img.shields.io/pypi/v/pdf-inspector.svg)](https://pypi.org/project/pdf-inspector/)
 [![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)

 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).
@@ -27,7 +26,7 @@ Evaluated on the [opendataloader-bench](https://github.com/opendataloader-projec

 | Engine | Overall | Reading Order (NID) | Tables (TEDS) | Headings (MHS) | Speed (200 docs) |
 |---|---|---|---|---|---|
-| pdf-inspector | 0.83 | 0.89 | 0.66 | 0.74 | 4s |
+| pdf-inspector | 0.83 | 0.88 | 0.66 | 0.74 | 4s |
 | opendataloader | 0.84 | 0.91 | 0.49 | 0.74 | 11s |
 | pymupdf4llm | 0.73 | 0.89 | 0.40 | 0.41 | 18s |
 | markitdown | 0.58 | 0.88 | 0.00 | 0.00 | 8s |
@@ -1,37 +1,9 @@
-# pdf-inspector
+# Python API

-Fast 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. Python bindings via [PyO3](https://pyo3.rs) for the [pdf-inspector](https://github.com/firecrawl/pdf-inspector) Rust library.
-
-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.
-
-## Features
-
- **Smart classification** — `text_based` / `scanned` / `image_based` / `mixed` in ~10–50ms, with a confidence score and per-page OCR routing.
- **Markdown conversion** — headings, lists, code blocks, bold/italic, URL linking, and dual-mode table detection (PDF drawing ops + text-alignment heuristics).
- **Layout-aware extraction** — multi-column reading order, position and font info per text item, RTL support.
- **Robust text decoding** — CID/Type0 fonts via ToUnicode CMaps, plus automatic flagging of broken encodings so callers can fall back to OCR.
- **Lightweight** — native Rust core, no ML models, no external services; ships type stubs.
-
-## Benchmark
-
-[opendataloader-bench](https://github.com/opendataloader-project/opendataloader-bench) corpus (200 PDFs), direct-extraction engines only — no OCR, no ML. Scores 0–1, higher is better:
-
-| Engine | Overall | Reading order | Tables (TEDS) | Headings | Speed |
-|---|---|---|---|---|---|
-| **pdf-inspector** | 0.83 | 0.88 | **0.66** | 0.74 | **4s** |
-| opendataloader | 0.84 | 0.91 | 0.49 | 0.74 | 11s |
-| pymupdf4llm | 0.73 | 0.89 | 0.40 | 0.41 | 18s |
-
-OCR/ML engines (docling, marker, mineru) score 0.83–0.88 overall but take 2–180 minutes on the same corpus. Full numbers in the [repo README](https://github.com/firecrawl/pdf-inspector#benchmark).
+Python bindings via [PyO3](https://pyo3.rs). Requires Rust toolchain for building from source.

 ## Install

-```bash
-pip install pdf-inspector
-```
-
-Prebuilt wheels cover CPython ≥3.8 on Linux (x86_64, aarch64), macOS (Intel, Apple Silicon), and Windows (x64). Other platforms build from source, which requires a Rust toolchain. For local development in a repo checkout:
-
 ```bash
 pip install maturin
 maturin develop --release
@@ -101,51 +73,16 @@ result = pdf_inspector.extract_pages_markdown("document.pdf", pages=[0, 2])

 ## Types

-Type stubs (`pdf_inspector.pyi`) ship with the package. Result types at a glance:
+**`PdfResult` fields:** `pdf_type`, `markdown`, `page_count`, `processing_time_ms`, `pages_needing_ocr`, `title`, `confidence`, `is_complex_layout`, `pages_with_tables`, `pages_with_columns`, `has_encoding_issues`

-```python
-class PdfResult:                     # process_pdf / detect_pdf
-    pdf_type: str                    # "text_based" | "scanned" | "image_based" | "mixed"
-    markdown: str | None             # extracted Markdown (None for detect_pdf)
-    page_count: int
-    processing_time_ms: int
-    pages_needing_ocr: list[int]
-    title: str | None
-    confidence: float                # 0.0 - 1.0
-    is_complex_layout: bool
-    pages_with_tables: list[int]
-    pages_with_columns: list[int]
-    has_encoding_issues: bool        # broken font encodings — consider OCR fallback
+**`PdfClassification` fields:** `pdf_type`, `page_count`, `pages_needing_ocr` (0-indexed), `confidence`

-class PdfClassification:             # classify_pdf
-    pdf_type: str
-    page_count: int
-    pages_needing_ocr: list[int]     # 0-indexed
-    confidence: float
+**`TextItem` fields:** `text`, `x`, `y`, `width`, `height`, `font`, `font_size`, `page`, `is_bold`, `is_italic`, `item_type`

-class TextItem:                      # extract_text_with_positions
-    text: str
-    x: float
-    y: float
-    width: float
-    height: float
-    font: str
-    font_size: float
-    page: int
-    is_bold: bool
-    is_italic: bool
-    is_underline: bool
-    is_strikeout: bool
-    item_type: str
+**`RegionText` fields:** `text`, `needs_ocr`

-class PageRegionTexts:               # extract_text_in_regions
-    page: int                        # 0-indexed
-    regions: list[RegionText]        # RegionText: text: str, needs_ocr: bool
+**`PageRegionTexts` fields:** `page` (0-indexed), `regions` (list of RegionText)

-class PagesExtractionResult:         # extract_pages_markdown
-    pages: list[PageMarkdown]        # PageMarkdown: page (0-indexed), markdown, needs_ocr
-    pages_with_tables: list[int]     # 1-indexed
-    pages_with_columns: list[int]    # 1-indexed
-    pages_needing_ocr: list[int]     # 1-indexed
-    is_complex: bool                 # any page has tables or multi-column layout
-```
+**`PageMarkdown` fields:** `page` (0-indexed), `markdown`, `needs_ocr`
+
+**`PagesExtractionResult` fields:** `pages` (list of PageMarkdown), `pages_with_tables` (1-indexed), `pages_with_columns` (1-indexed), `pages_needing_ocr` (1-indexed), `is_complex`
@@ -1,48 +1,12 @@
-# pdf-inspector
+# Rust API

-Fast 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. Pure Rust, no ML models, no external services; the only PDF dependency is [lopdf](https://crates.io/crates/lopdf). Also available for [Python](https://pypi.org/project/pdf-inspector/) and [Node.js](https://www.npmjs.com/package/@firecrawl/pdf-inspector).
-
-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.
-
-## Features
-
- **Smart classification** — TextBased / Scanned / ImageBased / Mixed in ~10–50ms, with a confidence score and per-page OCR routing.
- **Markdown conversion** — headings, lists, code blocks, bold/italic, URL linking, and dual-mode table detection (PDF drawing ops + text-alignment heuristics).
- **Layout-aware extraction** — multi-column reading order, position and font info per text item, RTL support.
- **Robust text decoding** — CID/Type0 fonts via ToUnicode CMaps, plus automatic flagging of broken encodings so callers can fall back to OCR.
- **Lightweight** — pure Rust, no ML models, no external services; single PDF dependency ([lopdf](https://crates.io/crates/lopdf)).
-
-## Benchmark
-
-[opendataloader-bench](https://github.com/opendataloader-project/opendataloader-bench) corpus (200 PDFs), direct-extraction engines only — no OCR, no ML. Scores 0–1, higher is better:
-
-| Engine | Overall | Reading order | Tables (TEDS) | Headings | Speed |
-|---|---|---|---|---|---|
-| **pdf-inspector** | 0.83 | 0.88 | **0.66** | 0.74 | **4s** |
-| opendataloader | 0.84 | 0.91 | 0.49 | 0.74 | 11s |
-| pymupdf4llm | 0.73 | 0.89 | 0.40 | 0.41 | 18s |
-
-OCR/ML engines (docling, marker, mineru) score 0.83–0.88 overall but take 2–180 minutes on the same corpus. Full numbers in the [repo README](https://github.com/firecrawl/pdf-inspector#benchmark).
-
-## Install
-
-```bash
-cargo add pdf-inspector
-```
-
-For the latest unreleased changes, use the git dependency instead:
+Add to your `Cargo.toml`:

 ```toml
 [dependencies]
 pdf-inspector = { git = "https://github.com/firecrawl/pdf-inspector" }
 ```

-The crate also ships CLI binaries — `pdf2md` (PDF → Markdown, with `--json`, `--pages`, `--select-pages`) and `detect-pdf` (classification, with `--analyze --json`):
-
-```bash
-cargo install pdf-inspector
-```
-
 ## Usage

 Detect and extract in one call:
@@ -830,7 +830,7 @@ checksum = "384b8ab6d37215f3c5301a95a4accb5d64aa607f1fcb26a11b5303878451b4fe"

 [[package]]
 name = "pdf-inspector"
-version = "0.1.6"
+version = "0.1.4"
 dependencies = [
 "env_logger",
 "log",
@@ -4,26 +4,6 @@ Fast PDF classification and region-based text extraction for Node.js/Bun. Native

 Built by [Firecrawl](https://firecrawl.dev) for hybrid OCR pipelines — extract text from PDF structure where possible, fall back to OCR only when needed.

-## Features
-
- **Smart classification** — text-based / scanned / image-based / mixed in ~10–50ms, with a confidence score and per-page OCR routing.
- **Region-based extraction** — pull text from bounding boxes with per-region quality checks (`needsOcr`).
- **Layout-aware** — multi-column reading order, position and font info per text item, RTL support.
- **Robust text decoding** — CID/Type0 fonts via ToUnicode CMaps, plus automatic flagging of broken encodings so callers can fall back to OCR.
- **Lightweight** — native Rust core via napi-rs, no ML models, no external services; ~5–6 MB platform binary, TypeScript definitions included.
-
-## Benchmark
-
-[opendataloader-bench](https://github.com/opendataloader-project/opendataloader-bench) corpus (200 PDFs), direct-extraction engines only — no OCR, no ML. Scores 0–1, higher is better:
-
-| Engine | Overall | Reading order | Tables (TEDS) | Headings | Speed |
-|---|---|---|---|---|---|
-| **pdf-inspector** | 0.83 | 0.88 | **0.66** | 0.74 | **4s** |
-| opendataloader | 0.84 | 0.91 | 0.49 | 0.74 | 11s |
-| pymupdf4llm | 0.73 | 0.89 | 0.40 | 0.41 | 18s |
-
-OCR/ML engines (docling, marker, mineru) score 0.83–0.88 overall but take 2–180 minutes on the same corpus. Full numbers in the [repo README](https://github.com/firecrawl/pdf-inspector#benchmark).
-
 ## Install

 ```bash
@@ -32,7 +12,7 @@ npm install @firecrawl/pdf-inspector
 bun add @firecrawl/pdf-inspector
 ```

-Prebuilt binaries for **Linux x64**, **macOS ARM64**, and **Windows x64** — npm installs only the one matching your platform. No Rust toolchain needed.
+Prebuilt binaries included for **linux-x64** and **macOS ARM64**. No Rust toolchain needed.

 ## API

@@ -110,13 +90,10 @@ interface RegionText {

 ## Platforms

-Prebuilt binaries ship as platform-specific packages installed automatically via `optionalDependencies`:
-
-| Platform | Architecture | Package |
-|----------|-------------|---------|
-| Linux    | x64 (glibc) | `@firecrawl/pdf-inspector-linux-x64-gnu` |
-| macOS    | ARM64       | `@firecrawl/pdf-inspector-darwin-arm64` |
-| Windows  | x64         | `@firecrawl/pdf-inspector-win32-x64-msvc` |
+| Platform | Architecture | Supported |
+|----------|-------------|-----------|
+| Linux    | x64         | Yes       |
+| macOS    | ARM64       | Yes       |

 ## License

@@ -7,11 +7,6 @@
      "devDependencies": {
        "@napi-rs/cli": "^3.4.1",
      },
-      "optionalDependencies": {
-        "@firecrawl/pdf-inspector-darwin-arm64": "1.11.0",
-        "@firecrawl/pdf-inspector-linux-x64-gnu": "1.11.0",
-        "@firecrawl/pdf-inspector-win32-x64-msvc": "1.11.0",
-      },
    },
  },
  "packages": {
@@ -1,6 +1,6 @@
 {
  "name": "@firecrawl/pdf-inspector",
-  "version": "1.11.1",
+  "version": "1.10.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",
@@ -22,6 +22,7 @@
  "files": [
    "index.js",
    "index.d.ts",
+    "*.node",
    "bin/",
    "README.md"
  ],
@@ -39,7 +40,10 @@
      "x86_64-unknown-linux-gnu",
      "aarch64-apple-darwin",
      "x86_64-pc-windows-msvc"
-    ]
+    ],
+    "package": {
+      "name": "@firecrawl/pdf-inspector-js"
+    }
  },
  "scripts": {
    "build": "napi build --platform --release",
@@ -47,10 +51,5 @@
  },
  "devDependencies": {
    "@napi-rs/cli": "^3.4.1"
-  },
-  "optionalDependencies": {
-    "@firecrawl/pdf-inspector-linux-x64-gnu": "1.11.1",
-    "@firecrawl/pdf-inspector-darwin-arm64": "1.11.1",
-    "@firecrawl/pdf-inspector-win32-x64-msvc": "1.11.1"
  }
 }
@@ -4,11 +4,10 @@ build-backend = "maturin"

 [project]
 name = "pdf-inspector"
-# Bump this to publish to PyPI — CI publishes automatically when the version
-# changes on main (same flow as napi/package.json for npm).
-version = "0.2.5"
+# Version is sourced from Cargo.toml [package] version by maturin so the Python
+# artifact always tracks the crate release instead of drifting on its own.
+dynamic = ["version"]
 description = "Fast PDF inspection, classification, and text extraction with smart scanned vs text-based detection"
-readme = "docs/python.md"
 license = { text = "MIT" }
 requires-python = ">=3.8"
 classifiers = [
@@ -20,10 +19,5 @@ classifiers = [
    "Topic :: Text Processing",
 ]

-[project.urls]
-Homepage = "https://github.com/firecrawl/pdf-inspector"
-Repository = "https://github.com/firecrawl/pdf-inspector"
-Documentation = "https://github.com/firecrawl/pdf-inspector/blob/main/docs/python.md"
-
 [tool.maturin]
 features = ["python"]
@@ -1,3 +0,0 @@
-<svg width="200" height="284" viewBox="0 0 200 284" fill="none" xmlns="http://www.w3.org/2000/svg">
-<path d="M166.862 90.7716C155.812 94.0514 147.483 101.471 141.383 109.53C140.073 111.26 137.343 109.96 137.863 107.841C149.543 59.8136 134.113 19.896 86.0157 0.247269C83.5758 -0.752669 81.0359 1.43719 81.6759 3.99704C103.555 91.8416 11.5294 84.432 23.1588 184.016C23.3588 185.726 21.4389 186.896 20.039 185.896C15.6792 182.766 10.8095 176.236 7.46963 171.647C6.48968 170.297 4.36978 170.677 3.9198 172.287C1.25994 181.906 0 190.965 0 199.965C0 234.963 17.9891 265.771 45.2177 283.63C46.7777 284.65 48.7776 283.19 48.2476 281.4C46.8477 276.7 46.0577 271.74 45.9977 266.611C45.9977 263.461 46.1977 260.241 46.6877 257.241C47.8276 249.702 50.4475 242.522 54.8473 235.983C69.9365 213.334 100.185 191.455 95.3552 161.747C95.0453 159.867 97.2651 158.627 98.6651 159.917C119.974 179.386 124.194 205.575 120.694 229.063C120.394 231.103 122.954 232.193 124.244 230.593C127.504 226.513 131.483 222.933 135.813 220.244C136.893 219.574 138.333 220.084 138.743 221.284C141.153 228.293 144.733 234.873 148.113 241.452C152.152 249.362 154.302 258.391 153.962 267.951C153.792 272.6 153.022 277.1 151.732 281.38C151.182 283.19 153.162 284.7 154.752 283.66C182.001 265.801 200 234.993 200 199.975C200 187.806 197.87 175.876 193.84 164.697C185.391 141.248 163.952 123.64 169.372 93.0815C169.632 91.6216 168.282 90.3517 166.862 90.7716Z" fill="#FA5D19" style="fill:#FA5D19;fill:color(display-p3 0.9816 0.3634 0.0984);fill-opacity:1;"/>
-</svg>
@@ -1,12 +0,0 @@
-<svg width="172" height="40" viewBox="0 0 172 40" fill="none" xmlns="http://www.w3.org/2000/svg">
-<path d="M23.3606 12.8281C21.8137 13.2873 20.6476 14.3261 19.7936 15.4544C19.6102 15.6966 19.228 15.5146 19.3008 15.2178C20.936 8.49401 18.7759 2.90556 12.0422 0.154735C11.7006 0.0147436 11.345 0.321324 11.4346 0.679702C14.4977 12.9779 1.61412 11.9406 3.24224 25.8823C3.27024 26.1217 3.00145 26.2855 2.80546 26.1455C2.19509 25.7073 1.51332 24.7932 1.04575 24.1506C0.908555 23.9616 0.611769 24.0148 0.548773 24.2402C0.176391 25.5869 0 26.8553 0 28.1152C0 33.0149 2.51847 37.328 6.33048 39.8283C6.54887 39.9711 6.82886 39.7667 6.75466 39.5161C6.55867 38.8581 6.44808 38.1638 6.43968 37.4456C6.43968 37.0046 6.46768 36.5539 6.53627 36.1339C6.69587 35.0784 7.06265 34.0732 7.67862 33.1577C9.79111 29.9869 14.0259 26.9239 13.3497 22.7647C13.3063 22.5015 13.6171 22.328 13.8131 22.5085C16.7964 25.2342 17.3871 28.9005 16.8972 32.1889C16.8552 32.4745 17.2135 32.6271 17.3941 32.4031C17.8505 31.832 18.4077 31.3308 19.0138 30.9542C19.165 30.8604 19.3666 30.9318 19.424 31.0998C19.7614 32.0811 20.2626 33.0023 20.7358 33.9234C21.3013 35.0308 21.6023 36.2949 21.5547 37.6332C21.5309 38.2842 21.4231 38.9141 21.2425 39.5133C21.1655 39.7667 21.4427 39.9781 21.6653 39.8325C25.4801 37.3322 28 33.0191 28 28.1166C28 26.4129 27.7018 24.7428 27.1376 23.1777C25.9547 19.8949 22.9533 17.4297 23.712 13.1515C23.7484 12.9471 23.5594 12.7693 23.3606 12.8281Z" fill="#262626" style="fill:#262626;fill:color(display-p3 0.1500 0.1500 0.1500);fill-opacity:1;"/>
-<path d="M41 34.0521V10.9618H55.7586V14.3264H44.7969V21.0226H53.8436V24.2882H44.7969V34.0521H41Z" fill="#262626" style="fill:#262626;fill:color(display-p3 0.1500 0.1500 0.1500);fill-opacity:1;"/>
-<path d="M59.9569 14.7882C58.7352 14.7882 57.7777 13.8976 57.7777 12.6441C57.7777 11.3906 58.7352 10.5 59.9569 10.5C61.1785 10.5 62.136 11.3906 62.136 12.6441C62.136 13.8976 61.1785 14.7882 59.9569 14.7882ZM58.1409 34.0521V17.1632H61.7068V34.0521H58.1409Z" fill="#262626" style="fill:#262626;fill:color(display-p3 0.1500 0.1500 0.1500);fill-opacity:1;"/>
-<path d="M73.5885 17.1632H74.3809V20.4948H72.796C69.6264 20.4948 68.6029 22.9687 68.6029 25.5747V34.0521H65.0371V17.1632H68.2067L68.6029 19.7031C69.4613 18.2847 70.815 17.1632 73.5885 17.1632Z" fill="#262626" style="fill:#262626;fill:color(display-p3 0.1500 0.1500 0.1500);fill-opacity:1;"/>
-<path d="M83.632 34.25C78.3163 34.25 74.9816 30.8194 74.9816 25.6406C74.9816 20.4288 78.3163 16.9653 83.3019 16.9653C88.1884 16.9653 91.457 20.066 91.5561 25.0139C91.5561 25.4427 91.5231 25.9045 91.457 26.3663H78.7125V26.5972C78.8116 29.467 80.6275 31.3472 83.4339 31.3472C85.613 31.3472 87.1979 30.2587 87.6931 28.3785H91.2589C90.6646 31.7101 87.8252 34.25 83.632 34.25ZM78.8446 23.7604H87.8582C87.561 21.2535 85.8112 19.8351 83.3349 19.8351C81.0567 19.8351 79.1087 21.3524 78.8446 23.7604Z" fill="#262626" style="fill:#262626;fill:color(display-p3 0.1500 0.1500 0.1500);fill-opacity:1;"/>
-<path d="M102.033 34.25C96.9151 34.25 93.6465 30.9184 93.6465 25.6406C93.6465 20.4288 97.0142 16.9653 102.132 16.9653C106.49 16.9653 109.197 19.3733 109.891 23.1997H106.16C105.698 21.2205 104.278 20 102.066 20C99.1933 20 97.3113 22.309 97.3113 25.6406C97.3113 28.9392 99.1933 31.2153 102.066 31.2153C104.245 31.2153 105.698 29.9618 106.127 28.0156H109.891C109.23 31.842 106.358 34.25 102.033 34.25Z" fill="#262626" style="fill:#262626;fill:color(display-p3 0.1500 0.1500 0.1500);fill-opacity:1;"/>
-<path d="M121.006 17.1632H121.799V20.4948H120.214C117.044 20.4948 116.021 22.9687 116.021 25.5747V34.0521H112.455V17.1632H115.625L116.021 19.7031C116.879 18.2847 118.233 17.1632 121.006 17.1632Z" fill="#262626" style="fill:#262626;fill:color(display-p3 0.1500 0.1500 0.1500);fill-opacity:1;"/>
-<path d="M130.614 16.9653C135.104 16.9653 137.679 19.1094 137.679 23.1007V34.0521H134.576L134.279 31.6441C133.123 33.1615 131.505 34.25 128.831 34.25C125.133 34.25 122.657 32.4358 122.657 29.3021C122.657 25.8385 125.166 23.8924 129.92 23.8924H134.147V22.8698C134.147 20.9896 132.793 19.8351 130.449 19.8351C128.336 19.8351 126.916 20.8247 126.652 22.309H123.152C123.515 19.0104 126.355 16.9653 130.614 16.9653ZM129.425 31.4792C132.397 31.4792 134.114 29.7309 134.147 27.125V26.5312H129.722C127.51 26.5312 126.289 27.3559 126.289 29.0712C126.289 30.4896 127.477 31.4792 129.425 31.4792Z" fill="#262626" style="fill:#262626;fill:color(display-p3 0.1500 0.1500 0.1500);fill-opacity:1;"/>
-<path d="M144.653 34.0521L139.139 17.1632H142.903L146.766 30.0937L150.629 17.1632H153.897L157.595 30.0937L161.59 17.1632H165.222L159.609 34.0521H155.779L152.214 22.5729L148.516 34.0521H144.653Z" fill="#262626" style="fill:#262626;fill:color(display-p3 0.1500 0.1500 0.1500);fill-opacity:1;"/>
-<path d="M166.934 34.0521V10.9618H170.5V34.0521H166.934Z" fill="#262626" style="fill:#262626;fill:color(display-p3 0.1500 0.1500 0.1500);fill-opacity:1;"/>
-</svg>
@@ -1,428 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-<head>
-<meta charset="utf-8">
-<meta name="viewport" content="width=device-width, initial-scale=1">
-<title>pdf-inspector — PDF classification &amp; text extraction, no OCR</title>
-<meta name="description" content="Fast Rust library that classifies PDFs (text-based vs scanned) and extracts clean Markdown — no OCR, no ML models. Bindings for Rust, Python, and Node.js.">
-<meta property="og:title" content="pdf-inspector">
-<meta property="og:description" content="Classify PDFs and extract clean Markdown in milliseconds. No OCR. No ML. Pure Rust.">
-<meta property="og:type" content="website">
-<link rel="icon" href="data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 100 100'%3E%3Ctext y='.9em' font-size='90'%3E%F0%9F%93%84%3C/text%3E%3C/svg%3E">
-<link rel="preconnect" href="https://fonts.googleapis.com">
-<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
-<link href="https://fonts.googleapis.com/css2?family=Bricolage+Grotesque:opsz,wght@12..96,400;12..96,600;12..96,800&family=Hanken+Grotesk:wght@400;500;600&family=JetBrains+Mono:wght@400;500;700&display=swap" rel="stylesheet">
-<style>
-  :root {
-    --paper: #f4efe4;
-    --paper-2: #eee7d8;
-    --ink: #1b1712;
-    --ink-soft: #4a433a;
-    --muted: #8b8375;
-    --line: #d9cfbb;
-    --accent: #dd3f22;
-    --accent-deep: #b32d15;
-    --card: #faf6ec;
-    --display: "Bricolage Grotesque", serif;
-    --body: "Hanken Grotesk", sans-serif;
-    --mono: "JetBrains Mono", monospace;
-  }
-  * { box-sizing: border-box; margin: 0; padding: 0; }
-  html { scroll-behavior: smooth; }
-  body {
-    background: var(--paper);
-    color: var(--ink);
-    font-family: var(--body);
-    font-size: 17px;
-    line-height: 1.6;
-    -webkit-font-smoothing: antialiased;
-    overflow-x: hidden;
-    background-image:
-      radial-gradient(circle at 1px 1px, rgba(27,23,18,0.05) 1px, transparent 0);
-    background-size: 22px 22px;
-  }
-  ::selection { background: var(--accent); color: var(--paper); }
-  a { color: inherit; text-decoration: none; }
-
-  .wrap { max-width: 1120px; margin: 0 auto; padding: 0 28px; }
-
-  /* ── nav ── */
-  nav {
-    position: sticky; top: 0; z-index: 50;
-    background: rgba(244,239,228,0.82);
-    backdrop-filter: blur(10px);
-    border-bottom: 1px solid var(--line);
-  }
-  .nav-in { display: flex; align-items: center; gap: 22px; height: 60px; }
-  .brand { font-family: var(--mono); font-weight: 700; font-size: 15px; letter-spacing: -0.02em; display: flex; align-items: center; gap: 9px; }
-  .brand .dot { width: 9px; height: 9px; background: var(--accent); border-radius: 50%; box-shadow: 0 0 0 3px rgba(221,63,34,0.18); }
-  .nav-links { margin-left: auto; display: flex; gap: 24px; align-items: center; font-size: 14.5px; font-weight: 500; }
-  .nav-links a { color: var(--ink-soft); transition: color .15s; }
-  .nav-links a:hover { color: var(--accent); }
-  .nav-gh { border: 1px solid var(--ink); border-radius: 999px; padding: 6px 15px; color: var(--ink) !important; transition: all .15s; }
-  .nav-gh:hover { background: var(--ink); color: var(--paper) !important; }
-  @media (max-width: 680px) { .nav-links .hide-sm { display: none; } }
-
-  /* ── hero ── */
-  header { padding: 74px 0 40px; position: relative; }
-  .eyebrow { font-family: var(--mono); font-size: 12.5px; letter-spacing: 0.16em; text-transform: uppercase; color: var(--accent-deep); margin-bottom: 22px; }
-  h1 {
-    font-family: var(--display);
-    font-weight: 800;
-    font-size: clamp(2.9rem, 8vw, 6.1rem);
-    line-height: 0.96;
-    letter-spacing: -0.035em;
-    max-width: 15ch;
-  }
-  h1 .em { color: var(--accent); font-style: normal; position: relative; }
-  h1 .strike { position: relative; white-space: nowrap; }
-  h1 .strike::after { content: ""; position: absolute; left: -2%; right: -2%; top: 54%; height: 0.09em; background: var(--accent); transform: rotate(-3deg); }
-  .lede { margin-top: 28px; font-size: clamp(1.05rem, 2.2vw, 1.32rem); color: var(--ink-soft); max-width: 46ch; line-height: 1.5; }
-  .lede b { color: var(--ink); font-weight: 600; }
-
-  .hero-grid { display: grid; grid-template-columns: 1.15fr 0.85fr; gap: 48px; align-items: end; }
-  @media (max-width: 880px) { .hero-grid { grid-template-columns: 1fr; gap: 40px; } }
-
-  /* readout card */
-  .readout {
-    background: var(--ink); color: var(--paper);
-    border-radius: 14px; padding: 22px 22px 20px;
-    font-family: var(--mono); font-size: 13px;
-    box-shadow: 14px 14px 0 rgba(27,23,18,0.09);
-    position: relative;
-  }
-  .readout .rlabel { color: #b8ad98; font-size: 11px; letter-spacing: 0.14em; text-transform: uppercase; margin-bottom: 16px; display: flex; justify-content: space-between; }
-  .readout .rrow { display: flex; justify-content: space-between; align-items: center; padding: 9px 0; border-top: 1px solid rgba(255,255,255,0.09); }
-  .readout .rrow:first-of-type { border-top: none; }
-  .readout .k { color: #cfc6b3; }
-  .readout .v { font-weight: 700; }
-  .readout .v.hot { color: var(--accent); }
-  .bar { height: 6px; background: rgba(255,255,255,0.1); border-radius: 3px; overflow: hidden; margin-top: 3px; width: 96px; }
-  .bar > i { display: block; height: 100%; background: var(--accent); border-radius: 3px; }
-
-  /* ── install row ── */
-  .installs { display: grid; grid-template-columns: repeat(3,1fr); gap: 14px; margin-top: 54px; }
-  @media (max-width: 720px) { .installs { grid-template-columns: 1fr; } }
-  .inst {
-    background: var(--card); border: 1px solid var(--line); border-radius: 11px;
-    padding: 15px 17px; transition: transform .16s, border-color .16s, box-shadow .16s;
-    cursor: pointer;
-  }
-  .inst:hover { transform: translateY(-3px); border-color: var(--accent); box-shadow: 0 8px 22px rgba(27,23,18,0.07); }
-  .inst .reg { font-family: var(--mono); font-size: 11px; letter-spacing: 0.12em; text-transform: uppercase; color: var(--muted); margin-bottom: 8px; display: flex; justify-content: space-between; }
-  .inst code { font-family: var(--mono); font-size: 14px; color: var(--ink); font-weight: 500; }
-  .inst .arrow { color: var(--accent); opacity: 0; transition: opacity .16s; }
-  .inst:hover .arrow { opacity: 1; }
-
-  /* ── section scaffold ── */
-  section { padding: 66px 0; border-top: 1px solid var(--line); }
-  .sec-head { display: flex; align-items: baseline; gap: 16px; margin-bottom: 40px; flex-wrap: wrap; }
-  .sec-num { font-family: var(--mono); font-size: 13px; color: var(--accent); font-weight: 700; }
-  .sec-title { font-family: var(--display); font-weight: 600; font-size: clamp(1.7rem, 4vw, 2.6rem); letter-spacing: -0.025em; }
-  .sec-sub { color: var(--ink-soft); max-width: 52ch; font-size: 1.02rem; }
-
-  /* ── features ── */
-  .feat-grid { display: grid; grid-template-columns: repeat(4,1fr); gap: 1px; background: var(--line); border: 1px solid var(--line); border-radius: 14px; overflow: hidden; }
-  @media (max-width: 900px) { .feat-grid { grid-template-columns: repeat(2,1fr); } }
-  @media (max-width: 560px) { .feat-grid { grid-template-columns: 1fr; } }
-  .feat { background: var(--card); padding: 24px 22px; transition: background .16s; }
-  .feat:hover { background: #fff; }
-  .feat .fn { font-family: var(--mono); font-size: 12px; color: var(--accent); font-weight: 700; }
-  .feat h3 { font-family: var(--display); font-weight: 600; font-size: 1.16rem; margin: 12px 0 8px; letter-spacing: -0.01em; }
-  .feat p { font-size: 14.5px; color: var(--ink-soft); line-height: 1.5; }
-
-  /* ── benchmark ── */
-  .bench {
-    border: 1px solid var(--line); border-radius: 14px; overflow: hidden;
-    background: var(--card);
-  }
-  table { width: 100%; border-collapse: collapse; font-size: 15px; }
-  thead th { font-family: var(--mono); font-size: 11px; letter-spacing: 0.08em; text-transform: uppercase; color: var(--muted); text-align: right; padding: 15px 18px; background: var(--paper-2); border-bottom: 1px solid var(--line); font-weight: 500; }
-  thead th:first-child { text-align: left; }
-  tbody td { padding: 14px 18px; text-align: right; font-family: var(--mono); border-bottom: 1px solid var(--line); }
-  tbody td:first-child { text-align: left; font-family: var(--body); font-weight: 500; }
-  tbody tr:last-child td { border-bottom: none; }
-  tbody tr.us { background: rgba(221,63,34,0.06); }
-  tbody tr.us td:first-child { color: var(--accent-deep); font-weight: 700; }
-  tbody tr.us td:first-child::before { content: "▸ "; color: var(--accent); }
-  .bench-foot { padding: 15px 18px; font-size: 13.5px; color: var(--ink-soft); background: var(--paper-2); border-top: 1px solid var(--line); }
-  .bench-wrap { overflow-x: auto; }
-  .callouts { display: grid; grid-template-columns: 1fr 1fr; gap: 16px; margin-top: 22px; }
-  @media (max-width: 640px) { .callouts { grid-template-columns: 1fr; } }
-  .callout { border-left: 3px solid var(--accent); padding: 4px 0 4px 16px; }
-  .callout .ct { font-family: var(--mono); font-size: 11px; letter-spacing: 0.1em; text-transform: uppercase; color: var(--accent-deep); margin-bottom: 5px; }
-  .callout p { font-size: 14.5px; color: var(--ink-soft); }
-
-  /* ── quickstart tabs ── */
-  .tabs input { position: absolute; opacity: 0; pointer-events: none; }
-  .tablist { display: flex; gap: 6px; margin-bottom: 0; }
-  .tablist label {
-    font-family: var(--mono); font-size: 13px; font-weight: 500;
-    padding: 10px 18px; cursor: pointer; color: var(--muted);
-    border: 1px solid var(--line); border-bottom: none;
-    border-radius: 9px 9px 0 0; background: var(--paper-2); transition: all .15s;
-  }
-  .tablist label:hover { color: var(--ink); }
-  .panel { display: none; }
-  .code {
-    background: var(--ink); border-radius: 0 12px 12px 12px;
-    padding: 22px 24px; overflow-x: auto;
-    font-family: var(--mono); font-size: 13.5px; line-height: 1.7;
-    color: #e9e2d3;
-    box-shadow: 12px 12px 0 rgba(27,23,18,0.07);
-  }
-  .code .cm { color: #8a8069; }
-  .code .kw { color: #ff9f7a; }
-  .code .st { color: #cbb78a; }
-  .code .fn { color: #f4efe4; font-weight: 700; }
-  #t-rust:checked ~ .tablist label[for=t-rust],
-  #t-py:checked ~ .tablist label[for=t-py],
-  #t-node:checked ~ .tablist label[for=t-node],
-  #t-cli:checked ~ .tablist label[for=t-cli] {
-    background: var(--ink); color: var(--paper); border-color: var(--ink);
-  }
-  #t-rust:checked ~ .panels #p-rust,
-  #t-py:checked ~ .panels #p-py,
-  #t-node:checked ~ .panels #p-node,
-  #t-cli:checked ~ .panels #p-cli { display: block; }
-  .code a.ref { color: #ff9f7a; border-bottom: 1px dotted #ff9f7a; }
-
-  /* ── closing split (OSS vs hosted) ── */
-  .split { display: grid; grid-template-columns: 1fr 1fr; gap: 18px; }
-  @media (max-width: 780px) { .split { grid-template-columns: 1fr; } }
-  .path { border: 1px solid var(--line); border-radius: 16px; padding: 32px 30px; background: var(--card); display: flex; flex-direction: column; }
-  .path .ptag { font-family: var(--mono); font-size: 11px; letter-spacing: 0.12em; text-transform: uppercase; color: var(--muted); margin-bottom: 15px; }
-  .path h3 { font-family: var(--display); font-weight: 600; font-size: 1.5rem; letter-spacing: -0.02em; line-height: 1.05; margin-bottom: 12px; }
-  .path p { color: var(--ink-soft); font-size: 15px; line-height: 1.5; flex: 1; margin-bottom: 24px; }
-  .pbtns { display: flex; gap: 12px; flex-wrap: wrap; }
-  .path-pro { background: var(--ink); border-color: var(--ink); box-shadow: 14px 14px 0 rgba(27,23,18,0.09); }
-  .path-pro .ptag { color: #b8ad98; }
-  .path-pro .ptag b { color: var(--accent); font-weight: 700; }
-  .path-pro h3 { color: var(--paper); }
-  .path-pro p { color: #cfc6b3; }
-  .btn { font-family: var(--mono); font-size: 14px; font-weight: 500; padding: 13px 24px; border-radius: 999px; transition: all .15s; border: 1px solid var(--ink); }
-  .btn-p { background: var(--accent); border-color: var(--accent); color: var(--paper); }
-  .btn-p:hover { background: var(--accent-deep); border-color: var(--accent-deep); }
-  .btn-s:hover { background: var(--ink); color: var(--paper); }
-  .btn-pro { background: var(--accent); border-color: var(--accent); color: var(--paper); }
-  .btn-pro:hover { background: var(--accent-deep); border-color: var(--accent-deep); }
-  .btn-ghost { color: var(--paper); border-color: rgba(255,255,255,0.3); }
-  .btn-ghost:hover { border-color: var(--paper); background: rgba(255,255,255,0.08); }
-  .fc-mark { height: 34px; width: auto; display: block; margin-bottom: 20px; }
-  .fc-wordmark { height: 15px; width: auto; vertical-align: -2px; transition: opacity .15s; }
-  .fc-wordmark:hover { opacity: 0.65; }
-  footer { border-top: 1px solid var(--line); padding: 34px 0; font-size: 14px; color: var(--muted); }
-  .foot-in { display: flex; justify-content: space-between; align-items: center; gap: 18px; flex-wrap: wrap; }
-  .foot-in a { color: var(--ink-soft); }
-  .foot-in a:hover { color: var(--accent); }
-  .foot-links { display: flex; gap: 20px; font-family: var(--mono); font-size: 13px; }
-
-  /* ── load animation ── */
-  .reveal { opacity: 0; transform: translateY(14px); animation: rise .7s cubic-bezier(.2,.7,.3,1) forwards; }
-  @keyframes rise { to { opacity: 1; transform: none; } }
-  .d1 { animation-delay: .05s; } .d2 { animation-delay: .15s; } .d3 { animation-delay: .25s; }
-  .d4 { animation-delay: .35s; } .d5 { animation-delay: .45s; } .d6 { animation-delay: .55s; }
-  @media (prefers-reduced-motion: reduce) { .reveal { animation: none; opacity: 1; transform: none; } }
-</style>
-</head>
-<body>
-
-<nav>
-  <div class="wrap nav-in">
-    <a href="#top" class="brand"><span class="dot"></span>pdf-inspector</a>
-    <div class="nav-links">
-      <a href="#features" class="hide-sm">Features</a>
-      <a href="#benchmark" class="hide-sm">Benchmark</a>
-      <a href="#start">Quick start</a>
-      <a class="nav-gh" href="https://github.com/firecrawl/pdf-inspector">GitHub ↗</a>
-    </div>
-  </div>
-</nav>
-
-<header id="top">
-  <div class="wrap hero-grid">
-    <div>
-      <div class="eyebrow reveal d1">Rust · Python · Node · CLI</div>
-      <h1 class="reveal d2">Classify PDFs. Extract Markdown. <span class="strike">No OCR.</span></h1>
-      <p class="lede reveal d3">A fast Rust library that tells text-based PDFs from scanned ones, then extracts position-aware text and clean Markdown — <b>locally, in milliseconds</b>. Skip the OCR bill for the ~54% of PDFs that never needed it.</p>
-    </div>
-    <div class="readout reveal d4" aria-hidden="true">
-      <div class="rlabel"><span>classify_pdf()</span><span>~12ms</span></div>
-      <div class="rrow"><span class="k">type</span><span class="v hot">TextBased</span></div>
-      <div class="rrow"><span class="k">confidence</span><span class="v">0.98</span></div>
-      <div class="rrow"><span class="k">needs_ocr</span><span class="v">false</span></div>
-      <div class="rrow"><span class="k">route</span><span class="v">local&nbsp;→&nbsp;md</span></div>
-      <div class="rrow" style="border-top:1px solid rgba(255,255,255,.09);padding-top:13px">
-        <span class="k">signal</span>
-        <span class="bar"><i style="width:98%"></i></span>
-      </div>
-    </div>
-  </div>
-
-  <div class="wrap">
-    <div class="installs">
-      <a class="inst reveal d4" href="https://crates.io/crates/pdf-inspector">
-        <div class="reg"><span>crates.io</span><span class="arrow">↗</span></div>
-        <code>cargo add pdf-inspector</code>
-      </a>
-      <a class="inst reveal d5" href="https://pypi.org/project/pdf-inspector/">
-        <div class="reg"><span>PyPI</span><span class="arrow">↗</span></div>
-        <code>pip install pdf-inspector</code>
-      </a>
-      <a class="inst reveal d6" href="https://www.npmjs.com/package/@firecrawl/pdf-inspector">
-        <div class="reg"><span>npm</span><span class="arrow">↗</span></div>
-        <code>npm i @firecrawl/pdf-inspector</code>
-      </a>
-    </div>
-  </div>
-</header>
-
-<section id="features">
-  <div class="wrap">
-    <div class="sec-head">
-      <span class="sec-num">01</span>
-      <h2 class="sec-title">Built for routing, not just reading</h2>
-    </div>
-    <div class="feat-grid">
-      <div class="feat"><div class="fn">01</div><h3>Smart classification</h3><p>TextBased, Scanned, ImageBased, or Mixed in ~10–50ms by sampling content streams. Returns a confidence score and per-page OCR routing.</p></div>
-      <div class="feat"><div class="fn">02</div><h3>Position-aware text</h3><p>Extraction with font info, X/Y coordinates, and automatic multi-column reading order.</p></div>
-      <div class="feat"><div class="fn">03</div><h3>Markdown conversion</h3><p>Headings, bullet/numbered lists, code blocks, tables, bold/italic, URL linking, and page breaks.</p></div>
-      <div class="feat"><div class="fn">04</div><h3>Table detection</h3><p>Rectangle-based detection from drawing ops plus heuristic alignment detection. Financial tables, footnotes, and cross-page continuations.</p></div>
-      <div class="feat"><div class="fn">05</div><h3>CID font support</h3><p>ToUnicode CMap decoding for Type0/Identity-H fonts, with UTF-16BE, UTF-8, and Latin-1 encodings.</p></div>
-      <div class="feat"><div class="fn">06</div><h3>Multi-column layout</h3><p>Newspaper-style column detection, sequential reading order, and right-to-left text support.</p></div>
-      <div class="feat"><div class="fn">07</div><h3>Encoding checks</h3><p>Flags broken font encodings automatically so callers can fall back to OCR only when it's actually needed.</p></div>
-      <div class="feat"><div class="fn">08</div><h3>Lightweight</h3><p>Pure Rust. No ML models, no external services. A single parse shared between detection and extraction.</p></div>
-    </div>
-  </div>
-</section>
-
-<section id="benchmark">
-  <div class="wrap">
-    <div class="sec-head">
-      <span class="sec-num">02</span>
-      <h2 class="sec-title">Fastest of the direct-text engines</h2>
-      <p class="sec-sub">Evaluated on the <a href="https://github.com/opendataloader-project/opendataloader-bench" style="color:var(--accent-deep);border-bottom:1px solid var(--line)">opendataloader-bench</a> corpus (200 PDFs). Direct text-extraction engines only — no OCR, no ML. Higher is better.</p>
-    </div>
-    <div class="bench">
-      <div class="bench-wrap">
-      <table>
-        <thead>
-          <tr><th>Engine</th><th>Overall</th><th>Reading order</th><th>Tables</th><th>Headings</th><th>200 docs</th></tr>
-        </thead>
-        <tbody>
-          <tr class="us"><td>pdf-inspector</td><td>0.83</td><td>0.89</td><td>0.66</td><td>0.74</td><td>4s</td></tr>
-          <tr><td>opendataloader</td><td>0.84</td><td>0.91</td><td>0.49</td><td>0.74</td><td>11s</td></tr>
-          <tr><td>pymupdf4llm</td><td>0.73</td><td>0.89</td><td>0.40</td><td>0.41</td><td>18s</td></tr>
-          <tr><td>markitdown</td><td>0.58</td><td>0.88</td><td>0.00</td><td>0.00</td><td>8s</td></tr>
-        </tbody>
-      </table>
-      </div>
-      <div class="bench-foot">OCR/ML engines (docling, marker, mineru) score 0.83–0.88 overall — but take 2–180 minutes on the same corpus.</div>
-    </div>
-    <div class="callouts">
-      <div class="callout"><div class="ct">Where we win</div><p>Fastest engine measured, the best table detection of any engine here, and heading quality now on par with opendataloader — at ~2.5× its speed.</p></div>
-      <div class="callout"><div class="ct">Where we're working</div><p>Reading order still trails opendataloader slightly, and tables that need the visual structure only an OCR engine can see.</p></div>
-    </div>
-  </div>
-</section>
-
-<section id="start">
-  <div class="wrap">
-    <div class="sec-head">
-      <span class="sec-num">03</span>
-      <h2 class="sec-title">Three lines to Markdown</h2>
-    </div>
-    <div class="tabs">
-      <input type="radio" name="tab" id="t-rust" checked>
-      <input type="radio" name="tab" id="t-py">
-      <input type="radio" name="tab" id="t-node">
-      <input type="radio" name="tab" id="t-cli">
-      <div class="tablist">
-        <label for="t-rust">Rust</label>
-        <label for="t-py">Python</label>
-        <label for="t-node">Node.js</label>
-        <label for="t-cli">CLI</label>
-      </div>
-      <div class="panels">
-        <div class="panel" id="p-rust"><pre class="code"><span class="kw">use</span> pdf_inspector::process_pdf;
-
-<span class="kw">let</span> result = <span class="fn">process_pdf</span>(<span class="st">"document.pdf"</span>)?;
-<span class="fn">println!</span>(<span class="st">"Type: {:?}"</span>, result.pdf_type);
-<span class="kw">if let</span> <span class="kw">Some</span>(markdown) = &amp;result.markdown {
-    <span class="fn">println!</span>(<span class="st">"{}"</span>, markdown);
-}
-<span class="cm">// full reference → </span><a class="ref" href="https://github.com/firecrawl/pdf-inspector/blob/main/docs/rust-api.md">docs/rust-api.md</a></pre></div>
-        <div class="panel" id="p-py"><pre class="code"><span class="kw">import</span> pdf_inspector
-
-result = pdf_inspector.<span class="fn">process_pdf</span>(<span class="st">"document.pdf"</span>)
-<span class="fn">print</span>(result.pdf_type)   <span class="cm"># "text_based" | "scanned" | "image_based" | "mixed"</span>
-<span class="fn">print</span>(result.markdown)   <span class="cm"># Markdown string or None</span>
-<span class="cm"># full reference → </span><a class="ref" href="https://github.com/firecrawl/pdf-inspector/blob/main/docs/python.md">docs/python.md</a></pre></div>
-        <div class="panel" id="p-node"><pre class="code"><span class="kw">import</span> { readFileSync } <span class="kw">from</span> <span class="st">'fs'</span>;
-<span class="kw">import</span> { processPdf } <span class="kw">from</span> <span class="st">'@firecrawl/pdf-inspector'</span>;
-
-<span class="kw">const</span> result = <span class="fn">processPdf</span>(<span class="fn">readFileSync</span>(<span class="st">'document.pdf'</span>));
-console.<span class="fn">log</span>(result.pdfType);   <span class="cm">// "TextBased" | "Scanned" | ...</span>
-console.<span class="fn">log</span>(result.markdown);  <span class="cm">// Markdown string or null</span>
-<span class="cm">// full reference → </span><a class="ref" href="https://github.com/firecrawl/pdf-inspector/blob/main/napi/README.md">napi/README.md</a></pre></div>
-        <div class="panel" id="p-cli"><pre class="code"><span class="cm"># install the CLI tools</span>
-cargo <span class="fn">install</span> pdf-inspector
-
-<span class="cm"># convert a PDF to Markdown</span>
-<span class="fn">pdf2md</span> document.pdf
-
-<span class="cm"># classify only — is it scanned?</span>
-<span class="fn">detect-pdf</span> document.pdf --analyze --json
-
-<span class="cm"># structured output for pipelines</span>
-<span class="fn">pdf2md</span> document.pdf --json</pre></div>
-      </div>
-    </div>
-  </div>
-</section>
-
-<section class="close">
-  <div class="wrap">
-    <div class="sec-head">
-      <span class="sec-num">04</span>
-      <h2 class="sec-title">Two ways to parse</h2>
-      <p class="sec-sub">Run the classifier locally for text-based PDFs; hand the scanned, OCR, and at-scale work to Firecrawl.</p>
-    </div>
-    <div class="split">
-      <div class="path">
-        <div class="ptag">Open source · runs local</div>
-        <h3>Use pdf-inspector yourself</h3>
-        <p>Pure-Rust library and CLI. Classify and extract text-based PDFs on your own machine in milliseconds — no external calls, no OCR bill, MIT licensed.</p>
-        <div class="pbtns">
-          <a class="btn btn-p" href="https://github.com/firecrawl/pdf-inspector">Get started</a>
-          <a class="btn btn-s" href="https://crates.io/crates/pdf-inspector">crates.io</a>
-        </div>
-      </div>
-      <div class="path path-pro">
-        <img class="fc-mark" src="assets/firecrawl-mark.svg" alt="Firecrawl" width="24" height="34">
-        <div class="ptag"><b>Firecrawl Parse</b> · hosted API</div>
-        <h3>Or let Firecrawl handle the hard ones</h3>
-        <p>Scanned documents, OCR, DOCX / XLSX / HTML, and parsing at scale — clean, LLM-ready Markdown from one API call. The downstream route for everything local parsing can't reach.</p>
-        <div class="pbtns">
-          <a class="btn btn-pro" href="https://docs.firecrawl.dev/api-reference/endpoint/parse">Firecrawl Parse ↗</a>
-          <a class="btn btn-ghost" href="https://firecrawl.dev">firecrawl.dev</a>
-        </div>
-      </div>
-    </div>
-  </div>
-</section>
-
-<footer>
-  <div class="wrap foot-in">
-    <div style="display:flex;align-items:center;gap:7px">Built by <a href="https://firecrawl.dev"><img class="fc-wordmark" src="assets/firecrawl-wordmark.svg" alt="Firecrawl"></a> · MIT licensed</div>
-    <div class="foot-links">
-      <a href="https://github.com/firecrawl/pdf-inspector">GitHub</a>
-      <a href="https://crates.io/crates/pdf-inspector">crates.io</a>
-      <a href="https://pypi.org/project/pdf-inspector/">PyPI</a>
-      <a href="https://www.npmjs.com/package/@firecrawl/pdf-inspector">npm</a>
-    </div>
-  </div>
-</footer>
-
-</body>
-</html>
@@ -11,37 +11,6 @@ use std::process;
 use std::time::Instant;

 /// Escape a string for embedding in a JSON string value.
-fn format_detector_ocr_reasons(reasons: &std::collections::BTreeMap<u32, Vec<String>>) -> String {
-    reasons
-        .iter()
-        .map(|(page, page_reasons)| {
-            let reasons_json = page_reasons
-                .iter()
-                .map(|reason| format!(r#""{}""#, json_escape(reason)))
-                .collect::<Vec<_>>()
-                .join(",");
-            format!(r#"{{"page":{},"reasons":[{}]}}"#, page, reasons_json)
-        })
-        .collect::<Vec<_>>()
-        .join(",")
-}
-
-fn format_ocr_reasons_by_page(reasons: &[pdf_inspector::PageOcrReasons]) -> String {
-    reasons
-        .iter()
-        .map(|entry| {
-            let reasons_json = entry
-                .reasons
-                .iter()
-                .map(|reason| format!(r#""{}""#, json_escape(reason)))
-                .collect::<Vec<_>>()
-                .join(",");
-            format!(r#"{{"page":{},"reasons":[{}]}}"#, entry.page, reasons_json)
-        })
-        .collect::<Vec<_>>()
-        .join(",")
-}
-
 fn json_escape(s: &str) -> String {
    let mut out = String::with_capacity(s.len() + 16);
    for ch in s.chars() {
@@ -148,13 +117,11 @@ fn run_analyze(pdf_path: &str, json_output: bool, start: Instant) {
                    .iter()
                    .map(|p| p.to_string())
                    .collect();
-                let ocr_reasons = format_ocr_reasons_by_page(&result.ocr_reasons_by_page);
                println!(
-                    r#"{{"pdf_type":"{}","page_count":{},"pages_needing_ocr":[{}],"ocr_reasons_by_page":[{}],"is_complex":{},"pages_with_tables":[{}],"pages_with_columns":[{}],"detection_time_ms":{}}}"#,
+                    r#"{{"pdf_type":"{}","page_count":{},"pages_needing_ocr":[{}],"is_complex":{},"pages_with_tables":[{}],"pages_with_columns":[{}],"detection_time_ms":{}}}"#,
                    pdf_type_str(&result.pdf_type),
                    result.page_count,
                    ocr_pages.join(","),
-                    ocr_reasons,
                    result.layout.is_complex,
                    table_pages.join(","),
                    col_pages.join(","),
@@ -177,9 +144,6 @@ fn run_analyze(pdf_path: &str, json_output: bool, start: Instant) {
                println!("Page count: {}", result.page_count);
                if !result.pages_needing_ocr.is_empty() {
                    println!("Pages needing OCR: {:?}", result.pages_needing_ocr);
-                    for entry in &result.ocr_reasons_by_page {
-                        println!("  page {}: {}", entry.page, entry.reasons.join(", "));
-                    }
                }
                println!();
                if result.layout.is_complex {
@@ -220,9 +184,8 @@ fn run_detect_only(pdf_path: &str, json_output: bool, start: Instant) {
                    .iter()
                    .map(|p| p.to_string())
                    .collect();
-                let ocr_reasons = format_detector_ocr_reasons(&result.ocr_reasons_by_page);
                println!(
-                    r#"{{"pdf_type":"{}","page_count":{},"pages_sampled":{},"pages_with_text":{},"confidence":{:.2},"title":{},"ocr_recommended":{},"pages_needing_ocr":[{}],"ocr_reasons_by_page":[{}],"detection_time_ms":{}}}"#,
+                    r#"{{"pdf_type":"{}","page_count":{},"pages_sampled":{},"pages_with_text":{},"confidence":{:.2},"title":{},"ocr_recommended":{},"pages_needing_ocr":[{}],"detection_time_ms":{}}}"#,
                    pdf_type_str(&result.pdf_type),
                    result.page_count,
                    result.pages_sampled,
@@ -235,7 +198,6 @@ fn run_detect_only(pdf_path: &str, json_output: bool, start: Instant) {
                        .unwrap_or_else(|| "null".to_string()),
                    result.ocr_recommended,
                    ocr_pages.join(","),
-                    ocr_reasons,
                    elapsed.as_millis()
                );
            } else {
@@ -270,9 +232,6 @@ fn run_detect_only(pdf_path: &str, json_output: bool, start: Instant) {
                            result.pages_needing_ocr, result.page_count
                        );
                    }
-                    for (page, reasons) in &result.ocr_reasons_by_page {
-                        println!("  page {}: {}", page, reasons.join(", "));
-                    }
                }
                if let Some(title) = &result.title {
                    println!("Title: {}", title);
@@ -208,7 +208,6 @@ fn main() {
        eprintln!("  --raw               Output only markdown (no headers)");
        eprintln!("  --pages             Insert page break markers (<!-- Page N -->)");
        eprintln!("  --select-pages N    Only process specified pages (e.g. 1,3,5-10)");
-        eprintln!("  --password PW       Password for an encrypted PDF");
        eprintln!("  --detect-only       Only detect PDF type (no extraction)");
        eprintln!("  --analyze           Detect + extract + layout analysis (no markdown)");
        process::exit(1);
@@ -222,16 +221,6 @@ fn main() {
    let detect_only = args.iter().any(|a| a == "--detect-only");
    let analyze = args.iter().any(|a| a == "--analyze");

-    // Parse --password value
-    let password = args.iter().position(|a| a == "--password").map(|i| {
-        args.get(i + 1)
-            .unwrap_or_else(|| {
-                eprintln!("Error: --password requires a value");
-                process::exit(1);
-            })
-            .clone()
-    });
-
    // Parse --select-pages value
    let page_filter = args
        .iter()
@@ -280,7 +269,6 @@ fn main() {
    if let Some(pages) = page_filter {
        options.page_filter = Some(pages);
    }
-    options.password = password;

    match process_pdf_with_options(pdf_path, options) {
        Ok(result) => {
@@ -60,10 +60,6 @@ pub struct PdfTypeResult {
    /// 1-indexed page numbers that need OCR (image-only or insufficient text).
    /// Empty for TextBased. All pages for Scanned/ImageBased. Specific pages for Mixed.
    pub pages_needing_ocr: Vec<u32>,
-    /// Per-page explanation for `pages_needing_ocr`: 1-indexed page → reason
-    /// codes (`scanned`, `no_text`, `vector_text`, `suspected_garbled_text`).
-    /// Only contains pages that need OCR.
-    pub ocr_reasons_by_page: std::collections::BTreeMap<u32, Vec<String>>,
 }

 /// Configuration for PDF type detection
@@ -386,12 +382,7 @@ pub(crate) fn detect_from_document(
                let analysis = if let Some(cached) = analysis_cache.get(&page_num) {
                    cached.clone()
                } else if let Some(&page_id) = pages.get(&page_num) {
-                    // Cache the fresh analysis so the reason-classification pass
-                    // below sees the real signals (vector_text, etc.) instead of
-                    // defaulting to "scanned".
-                    let a = analyze_page_content(doc, page_id);
-                    analysis_cache.insert(page_num, a.clone());
-                    a
+                    analyze_page_content(doc, page_id)
                } else {
                    continue;
                };
@@ -438,9 +429,6 @@ pub(crate) fn detect_from_document(
                let analysis = analyze_page_content(doc, page_id);
                if analysis.has_identity_h_no_tounicode || analysis.has_only_type3_fonts {
                    pages_needing_ocr.push(page_num);
-                    // Cache so the reason pass reports suspected_garbled_text
-                    // rather than defaulting to "scanned".
-                    analysis_cache.insert(page_num, analysis);
                }
            }
        }
@@ -448,19 +436,6 @@ pub(crate) fn detect_from_document(
    pages_needing_ocr.sort();
    pages_needing_ocr.dedup();

-    // Explain each OCR-flagged page. Pages we analyzed get a signal-derived
-    // reason; pages flagged only by whole-document classification (unsampled
-    // pages of a Scanned/ImageBased doc) default to `scanned`.
-    let mut ocr_reasons_by_page: std::collections::BTreeMap<u32, Vec<String>> =
-        std::collections::BTreeMap::new();
-    for &page_num in &pages_needing_ocr {
-        let reasons = match analysis_cache.get(&page_num) {
-            Some(analysis) => page_ocr_reasons(analysis),
-            None => vec![crate::OCR_REASON_SCANNED],
-        };
-        ocr_reasons_by_page.insert(page_num, reasons.into_iter().map(String::from).collect());
-    }
-
    // Try to get title from metadata
    let title = get_document_title(doc);

@@ -473,7 +448,6 @@ pub(crate) fn detect_from_document(
        title,
        ocr_recommended,
        pages_needing_ocr,
-        ocr_reasons_by_page,
    })
 }

@@ -513,7 +487,7 @@ fn distribute_pages(n: u32, total: u32) -> Vec<u32> {
 }

 /// Page content analysis result
-#[derive(Clone, Default)]
+#[derive(Clone)]
 struct PageAnalysis {
    text_operator_count: u32,
    has_images: bool,
@@ -549,31 +523,6 @@ struct PageAnalysis {
    has_decodable_text_fonts: bool,
 }

-/// Explain *why* a page needs OCR, from its content analysis. Priority:
-/// undecodable fonts (`suspected_garbled_text`) and vector-outlined text
-/// (`vector_text`) come first because they persist even when a text layer is
-/// present; otherwise a page with no extractable text is `scanned` when an
-/// image backs it or `no_text` when nothing does.
-fn page_ocr_reasons(a: &PageAnalysis) -> Vec<&'static str> {
-    let mut reasons = Vec::new();
-    if a.has_identity_h_no_tounicode || a.has_only_type3_fonts {
-        reasons.push(crate::OCR_REASON_SUSPECTED_GARBLED_TEXT);
-    }
-    if a.has_vector_text {
-        reasons.push(crate::OCR_REASON_VECTOR_TEXT);
-    }
-    if reasons.is_empty() {
-        let has_extractable_text = a.text_operator_count > 0 && a.unique_text_chars > 0;
-        if !has_extractable_text && !a.has_images && !a.has_template_image {
-            reasons.push(crate::OCR_REASON_NO_TEXT);
-        } else {
-            // Image-backed with no usable text, or too little text to trust.
-            reasons.push(crate::OCR_REASON_SCANNED);
-        }
-    }
-    reasons
-}
-
 /// Extracted font information from a Resource dictionary entry.
 /// Stores the properties needed for decodability/identity-h checks
 /// without holding a reference to the document.
@@ -1860,64 +1809,6 @@ fn get_document_title(doc: &Document) -> Option<String> {
 mod tests {
    use super::*;

-    #[test]
-    fn page_ocr_reasons_classify() {
-        // Scanned: no text, full-page image.
-        let scanned = PageAnalysis {
-            has_template_image: true,
-            ..Default::default()
-        };
-        assert_eq!(page_ocr_reasons(&scanned), vec![crate::OCR_REASON_SCANNED]);
-
-        // Image-only page (no template flag, but has an image).
-        let image_only = PageAnalysis {
-            has_images: true,
-            ..Default::default()
-        };
-        assert_eq!(
-            page_ocr_reasons(&image_only),
-            vec![crate::OCR_REASON_SCANNED]
-        );
-
-        // No text, no image → no_text.
-        let blank = PageAnalysis::default();
-        assert_eq!(page_ocr_reasons(&blank), vec![crate::OCR_REASON_NO_TEXT]);
-
-        // Vector-outlined text.
-        let vector = PageAnalysis {
-            has_vector_text: true,
-            ..Default::default()
-        };
-        assert_eq!(
-            page_ocr_reasons(&vector),
-            vec![crate::OCR_REASON_VECTOR_TEXT]
-        );
-
-        // Undecodable fonts → garbled, and it wins over the fall-through.
-        let garbled = PageAnalysis {
-            has_identity_h_no_tounicode: true,
-            has_images: true,
-            ..Default::default()
-        };
-        assert_eq!(
-            page_ocr_reasons(&garbled),
-            vec![crate::OCR_REASON_SUSPECTED_GARBLED_TEXT]
-        );
-
-        // A page with real extractable text and an image is not flagged here
-        // as scanned/no_text (only reached for pages already needing OCR).
-        let text_with_image = PageAnalysis {
-            text_operator_count: 40,
-            unique_text_chars: 120,
-            has_images: true,
-            ..Default::default()
-        };
-        assert_eq!(
-            page_ocr_reasons(&text_with_image),
-            vec![crate::OCR_REASON_SCANNED]
-        );
-    }
-
    #[test]
    fn test_scan_content_operators() {
        let mut uchars = HashSet::new();
@@ -176,89 +176,14 @@ fn extract_positioned_text_impl(
                continue;
            }
        }
-        let ((mut items, mut rects, mut lines), has_gid_fonts, coords_rotated) =
-            extract_page_text_items(
-                doc,
-                page_id,
-                *page_num,
-                font_cmaps,
-                include_invisible,
-                &mut style_cache,
-            )?;
-        // Clip to the visible page box: single-page extracts and imposed
-        // spreads keep neighboring pages' content in the stream, positioned
-        // outside the CropBox. Extracting it interleaves invisible text into
-        // the page and poisons font statistics. Rotated pages are left alone
-        // — their item coordinates are already transformed out of box space.
-        let mut clipped_box: Option<(f32, f32, f32, f32)> = None;
-        if !coords_rotated {
-            if let Some((bx0, by0, bx1, by1)) = get_page_box(doc, page_id) {
-                const TOL: f32 = 6.0;
-                let outside = |it: &TextItem| {
-                    let cx = it.x + it.width / 2.0;
-                    !(cx >= bx0 - TOL && cx <= bx1 + TOL && it.y >= by0 - TOL && it.y <= by1 + TOL)
-                };
-                // Only clip when the off-page material reads as coherent text
-                // (neighboring-page paragraphs). Curved/rotated display text
-                // leaves short glyph fragments with artifact coordinates
-                // outside the box, and those must stay.
-                let off: Vec<&TextItem> = items.iter().filter(|it| outside(it)).collect();
-                // Judge by character mass: paragraphs are dominated by long
-                // word runs even when interleaved with short math fragments,
-                // while glyph-confetti is short items through and through.
-                let total_chars: usize = off.iter().map(|it| it.text.trim().chars().count()).sum();
-                let wordy_chars: usize = off
-                    .iter()
-                    .map(|it| it.text.trim().chars().count())
-                    .filter(|&n| n >= 4)
-                    .sum();
-                // Genuine neighboring-page content is cleanly separated from
-                // on-page text. When an off-page item continues an on-page
-                // line (same baseline, near-adjacent x), the coordinates are
-                // artifacts of transforms we mis-model — don't clip those.
-                let straddles = off.iter().any(|o| {
-                    items.iter().any(|i| {
-                        !outside(i)
-                            && (i.y - o.y).abs() <= 2.0
-                            && (o.x - (i.x + i.width)).abs() <= 10.0
-                    })
-                });
-                let coherent =
-                    off.len() >= 10 && wordy_chars * 2 >= total_chars.max(1) && !straddles;
-                if bx1 - bx0 >= 72.0 && by1 - by0 >= 72.0 && coherent {
-                    let before = items.len();
-                    items.retain(|it| !outside(it));
-                    if items.len() < before {
-                        debug!(
-                            "page {}: clipped {} items outside page box ({:.0},{:.0})-({:.0},{:.0})",
-                            page_num,
-                            before - items.len(),
-                            bx0,
-                            by0,
-                            bx1,
-                            by1
-                        );
-                        // Only prune off-page geometry when off-page text
-                        // existed — same neighboring-page content.
-                        let overlaps = |x: f32, y: f32, w: f32, h: f32| {
-                            let (x0, x1) = if w < 0.0 { (x + w, x) } else { (x, x + w) };
-                            let (y0, y1) = if h < 0.0 { (y + h, y) } else { (y, y + h) };
-                            x0 < bx1 + TOL && x1 > bx0 - TOL && y0 < by1 + TOL && y1 > by0 - TOL
-                        };
-                        rects.retain(|r| overlaps(r.x, r.y, r.width, r.height));
-                        clipped_box = Some((bx0, by0, bx1, by1));
-                        lines.retain(|l| {
-                            overlaps(
-                                l.x1.min(l.x2),
-                                l.y1.min(l.y2),
-                                (l.x2 - l.x1).abs(),
-                                (l.y2 - l.y1).abs(),
-                            )
-                        });
-                    }
-                }
-            }
-        }
+        let ((mut items, rects, lines), has_gid_fonts, _coords_rotated) = extract_page_text_items(
+            doc,
+            page_id,
+            *page_num,
+            font_cmaps,
+            include_invisible,
+            &mut style_cache,
+        )?;
        if has_gid_fonts {
            gid_encoded_pages.insert(*page_num);
        }
@@ -298,18 +223,7 @@ fn extract_positioned_text_impl(
        all_lines.extend(lines);

        // Extract hyperlinks from page annotations
-        let mut links = extract_page_links(doc, page_id, *page_num);
-        // Annotations from the neighboring page are off-box too.
-        if let Some((bx0, by0, bx1, by1)) = clipped_box {
-            links.retain(|it| {
-                let cx = it.x + it.width / 2.0;
-                // Center-y, not it.y: link items carry an annotation rect,
-                // so y is a box edge — unlike text items, where y is a
-                // baseline and testing it directly is the natural semantics.
-                let cy = it.y + it.height / 2.0;
-                cx >= bx0 - 6.0 && cx <= bx1 + 6.0 && cy >= by0 - 6.0 && cy <= by1 + 6.0
-            });
-        }
+        let links = extract_page_links(doc, page_id, *page_num);
        all_items.extend(links);
    }

@@ -338,47 +252,17 @@ fn suppress_table_underlines(
    }

    let mut table_item_indices: HashSet<usize> = HashSet::new();
-    // A detected "table" that swallows nearly every text item on the page
-    // is a detection artifact (prose pages with boxed callouts or stacked
-    // underline rules read as one giant grid), not a real table — letting
-    // it through here erased every legitimate underline on the page
-    // (text_dense__underline: rect detection claimed 52/52 items). Real
-    // ruled tables share the page with headings, captions, and body text.
-    let plausible = |table: &crate::tables::Table| {
-        // Content sanity gate: prose pages with boxed callouts and stacked
-        // underline rules can detect as a structurally rich "table" that
-        // swallows every item on the page (text_dense__underline: a 4x8
-        // grid claiming 52/52 items, one "cell" holding 806 chars of body
-        // text) — suppressing there erased every legitimate underline on
-        // the page. Real data-table cells are short values; a cell with
-        // hundreds of characters means the grid captured flowing prose.
-        let lens: Vec<usize> = table
-            .cells
-            .iter()
-            .flatten()
-            .filter(|cell| !cell.trim().is_empty())
-            .map(|cell| cell.chars().count())
-            .collect();
-        if lens.is_empty() {
-            return false;
-        }
-        let long = lens.iter().filter(|&&n| n > 100).count();
-        (long as f32) < (lens.len() as f32) * 0.3
-    };

    if !rects.is_empty() {
        let (rect_tables, _) = crate::tables::detect_tables_from_rects(items, rects, page);
-        for table in rect_tables.iter().filter(|t| plausible(t)) {
-            table_item_indices.extend(table.item_indices.iter().copied());
+        for table in rect_tables {
+            table_item_indices.extend(table.item_indices);
        }
    }

    if !lines.is_empty() {
-        for table in crate::tables::detect_tables_from_lines(items, lines, page)
-            .iter()
-            .filter(|t| plausible(t))
-        {
-            table_item_indices.extend(table.item_indices.iter().copied());
+        for table in crate::tables::detect_tables_from_lines(items, lines, page) {
+            table_item_indices.extend(table.item_indices);
        }
    }

@@ -989,17 +873,9 @@ pub(crate) fn merge_subscript_items(items: Vec<TextItem>) -> Vec<TextItem> {
                        .chars()
                        .last()
                        .is_some_and(|c| c.is_alphabetic());
-                    // Strikeout boundaries block the merge (a struck word
-                    // must not extend its strike over a live footnote digit,
-                    // and a struck digit must not lose its own mark). An
-                    // underlined parent with an unmarked digit DOES merge:
-                    // the drawn rule easily misses the tiny digit's overlap
-                    // window, and refusing costs the whole subscript token
-                    // ("b"+"2" staying split). Visually the rule spans both.
-                    let marks_ok = parent.is_strikeout == item.is_strikeout
-                        && (parent.is_underline == item.is_underline
-                            || (parent.is_underline && !item.is_underline));
-                    if parent.font_size >= sub_threshold && ends_with_letter && marks_ok {
+                    let same_marks = parent.is_underline == item.is_underline
+                        && parent.is_strikeout == item.is_strikeout;
+                    if parent.font_size >= sub_threshold && ends_with_letter && same_marks {
                        let parent_right = parent.x + parent.width;
                        let gap = item.x - parent_right;
                        // Subscripts must be tightly adjacent (within ~1pt)
@@ -1053,46 +929,6 @@ pub(crate) fn get_number(obj: &Object) -> Option<f32> {
    }
 }

-/// Visible page box: CropBox if present, else MediaBox, walking page-tree
-/// inheritance (both attributes are inheritable). Returns normalized
-/// (x0, y0, x1, y1) in PDF space.
-fn get_page_box(doc: &Document, page_id: ObjectId) -> Option<(f32, f32, f32, f32)> {
-    fn find_box(doc: &Document, page_id: ObjectId, key: &[u8]) -> Option<Vec<f32>> {
-        let mut id = page_id;
-        for _ in 0..32 {
-            let dict = doc.get_dictionary(id).ok()?;
-            if let Ok(obj) = dict.get(key) {
-                let arr = match obj {
-                    Object::Array(a) => Some(a.clone()),
-                    Object::Reference(r) => match doc.get_object(*r) {
-                        Ok(Object::Array(a)) => Some(a.clone()),
-                        _ => None,
-                    },
-                    _ => None,
-                };
-                if let Some(arr) = arr {
-                    let vals: Vec<f32> = arr.iter().filter_map(get_number).collect();
-                    if vals.len() >= 4 {
-                        return Some(vals);
-                    }
-                }
-            }
-            match dict.get(b"Parent") {
-                Ok(Object::Reference(p)) => id = *p,
-                _ => return None,
-            }
-        }
-        None
-    }
-    let v = find_box(doc, page_id, b"CropBox").or_else(|| find_box(doc, page_id, b"MediaBox"))?;
-    Some((
-        v[0].min(v[2]),
-        v[1].min(v[3]),
-        v[0].max(v[2]),
-        v[1].max(v[3]),
-    ))
-}
-
 #[cfg(test)]
 mod tests {
    use super::*;
@@ -115,13 +115,7 @@ fn rules_from_graphics(rects: &[PdfRect], lines: &[UnderlineLine], page: u32) ->
    rules
 }

-fn discard_repeated_ruling_rules(
-    rules: Vec<Rule>,
-    items: &[TextItem],
-    rects: &[PdfRect],
-    lines: &[UnderlineLine],
-    page: u32,
-) -> Vec<Rule> {
+fn discard_repeated_ruling_rules(rules: Vec<Rule>) -> Vec<Rule> {
    if rules.len() < MIN_REPEATED_RULE_LEVELS {
        return rules;
    }
@@ -129,142 +123,12 @@ fn discard_repeated_ruling_rules(
    rules
        .iter()
        .filter(|rule| {
-            // A rule snugly owned by one text line is an underline even when
-            // span-similar rules repeat down the page — documents that
-            // underline many full-width lines (dense CJK business docs) look
-            // exactly like table rulings to the repetition check, which used
-            // to discard every one of them. Table rulings fail snugness:
-            // row separators extend past their cells' text (or have no text
-            // on the baseline above), and multi-column matches are still
-            // culled by the tabular filter afterwards.
-            // Same-row segmented rules (column-header separators) are
-            // always rulings — each segment snugly owns its column label,
-            // so snugness must not override that check.
-            !is_segmented_row_ruling_rule(rule, &rules)
-                && ((has_snug_text_owner(rule, items)
-                    && !has_flanking_verticals(rule, rects, lines, page))
-                    || !is_repeated_ruling_rule(rule, &rules))
+            !is_repeated_ruling_rule(rule, &rules) && !is_segmented_row_ruling_rule(rule, &rules)
        })
        .cloned()
        .collect()
 }

-/// True when a single text item both matches the rule vertically (baseline
-/// window) and horizontally contains it: the rule may not extend past the
-/// item's span by more than ~0.75em on either side. Underlines are drawn to
-/// the width of the text they decorate; table/form rulings span cells or
-/// full table width and overshoot any single item.
-/// A rule flanked by vertical strokes at its ends is a table/box border
-/// row edge, not an underline — underlined text lines have no vertical
-/// rules rising from their ends. Checked against raw stroked lines: a
-/// near-vertical segment whose x sits at either end of the rule and whose
-/// y-range covers the rule's row.
-fn has_flanking_verticals(
-    rule: &Rule,
-    rects: &[PdfRect],
-    lines: &[UnderlineLine],
-    page: u32,
-) -> bool {
-    // A drawn rect that CONTAINS the rule vetoes rescue only with GRID
-    // EVIDENCE: another drawn rect abutting it vertically (cell rows tile).
-    // Height alone can't separate a table cell from a decorative callout
-    // panel — genuine underlines live inside isolated filled panels, and
-    // multiline table cells can be arbitrarily tall.
-    let norm = |r: &PdfRect| {
-        let (x_lo, x_hi) = if r.width >= 0.0 {
-            (r.x, r.x + r.width)
-        } else {
-            (r.x + r.width, r.x)
-        };
-        let (y_lo, y_hi) = if r.height >= 0.0 {
-            (r.y, r.y + r.height)
-        } else {
-            (r.y + r.height, r.y)
-        };
-        (x_lo, x_hi, y_lo, y_hi)
-    };
-    let page_rects: Vec<(f32, f32, f32, f32)> = rects
-        .iter()
-        .filter(|r| r.page == page && r.height.abs() > 6.0)
-        .map(norm)
-        .collect();
-    let rect_flank = page_rects.iter().any(|&(x_lo, x_hi, y_lo, y_hi)| {
-        let contains = x_lo <= rule.x1 + 2.0
-            && x_hi >= rule.x2 - 2.0
-            && y_lo <= rule.y + 2.0
-            && y_hi >= rule.y - 2.0;
-        if !contains {
-            return false;
-        }
-        // Grid evidence: a vertically abutting neighbor box with x-overlap.
-        page_rects.iter().any(|&(nx_lo, nx_hi, ny_lo, ny_hi)| {
-            let x_overlap = nx_hi.min(x_hi) - nx_lo.max(x_lo);
-            if x_overlap <= 10.0 {
-                return false;
-            }
-            (ny_lo - y_hi).abs() <= 3.0 || (y_lo - ny_hi).abs() <= 3.0
-        })
-    });
-    if rect_flank {
-        return true;
-    }
-    lines.iter().any(|l| {
-        if l.page != page || (l.x1 - l.x2).abs() > 2.0 {
-            return false;
-        }
-        let x = (l.x1 + l.x2) / 2.0;
-        let near_end = (x - rule.x1).abs() <= 6.0 || (x - rule.x2).abs() <= 6.0;
-        if !near_end {
-            return false;
-        }
-        let (y_lo, y_hi) = if l.y1 <= l.y2 {
-            (l.y1, l.y2)
-        } else {
-            (l.y2, l.y1)
-        };
-        y_lo <= rule.y + 2.0 && y_hi >= rule.y - 2.0
-    })
-}
-
-fn has_snug_text_owner(rule: &Rule, items: &[TextItem]) -> bool {
-    // Underlines are drawn to the width of the text they decorate, but the
-    // text may be split into several runs (CJK lines mix scripts and font
-    // switches) — so ownership is judged against the UNION of the runs on
-    // the rule's baseline row. Table/form rulings overshoot their row's
-    // text (row separators span cell padding and empty columns), so they
-    // fail either containment or coverage.
-    let matched: Vec<&TextItem> = items
-        .iter()
-        .filter(|item| is_underline_candidate(item) && rule_matches_item(rule, item))
-        .collect();
-    if matched.is_empty() {
-        return false;
-    }
-    let x1 = matched.iter().map(|i| i.x).fold(f32::INFINITY, f32::min);
-    let x2 = matched
-        .iter()
-        .map(|i| i.x + i.width)
-        .fold(f32::NEG_INFINITY, f32::max);
-    let max_fs = matched.iter().map(|i| i.font_size).fold(0.0, f32::max);
-    let pad = (max_fs * 0.75).max(4.0);
-    if rule.x1 < x1 - pad || rule.x2 > x2 + pad {
-        return false;
-    }
-    let covered: f32 = matched.iter().map(|i| i.width).sum();
-    if covered < rule.width() * 0.6 {
-        return false;
-    }
-    // A table row also unions to the rule's span — but its cells sit apart.
-    // An underlined text line is contiguous runs with word-sized gaps; any
-    // column-sized hole between matched runs means this is a row ruling.
-    let mut sorted = matched;
-    sorted.sort_by(|a, b| a.x.total_cmp(&b.x));
-    sorted.windows(2).all(|pair| {
-        let gap = pair[1].x - (pair[0].x + pair[0].width);
-        gap <= (max_fs * 2.0).max(12.0)
-    })
-}
-
 fn is_repeated_ruling_rule(rule: &Rule, rules: &[Rule]) -> bool {
    let mut y_levels: Vec<f32> = rules
        .iter()
@@ -351,11 +215,9 @@ fn is_underline_candidate(item: &TextItem) -> bool {

 fn rule_matches_item(rule: &Rule, item: &TextItem) -> bool {
    // Vertical window: underlines sit at or slightly below the baseline.
-    // Latin fonts draw them at roughly 5-15% of the em below; CJK layouts
-    // put them under the full em box, measured up to ~0.67em below the
-    // baseline (text_dense__underline). Allow 0.72em (min 3pt) below and
-    // 1pt above for rounding.
-    let below = (item.font_size * 0.72).max(3.0);
+    // Fonts draw them at roughly 5-15% of the em below; allow up to 35%
+    // (min 3pt) below and 1pt above for rounding.
+    let below = (item.font_size * 0.35).max(3.0);
    let y_min = item.y - below;
    let y_max = item.y + 1.0;
    if rule.y < y_min || rule.y > y_max {
@@ -398,48 +260,12 @@ pub(crate) fn mark_underlined_items(
    lines: &[UnderlineLine],
    page: u32,
 ) {
-    let rules = discard_repeated_ruling_rules(
-        rules_from_graphics(rects, lines, page),
-        items,
-        rects,
-        lines,
-        page,
-    );
+    let rules = discard_repeated_ruling_rules(rules_from_graphics(rects, lines, page));
    if rules.is_empty() {
        return;
    }
    let tabular_rules = tabular_row_separator_rule_indices(&rules, items);

-    // Math fraction bars are short horizontal lines with the numerator just
-    // above AND the denominator just below — underline geometry from above,
-    // but no underline has text hanging directly beneath it at fraction
-    // distance. Only narrow rules qualify: real underlines under short
-    // labels have their next text line a full line-pitch away.
-    let fraction_rules: HashSet<usize> = rules
-        .iter()
-        .enumerate()
-        .filter(|(_, rule)| {
-            rule.width() <= 60.0
-                && items.iter().any(|item| {
-                    if !is_underline_candidate(item) {
-                        return false;
-                    }
-                    // A denominator HUGS the bar (fraction typesetting
-                    // leaves ~0.1-0.2em) and is bar-sized. Both bounds
-                    // matter: a short last-line of a paragraph at normal
-                    // leading sits further below, and a full next text
-                    // line is far wider than the rule.
-                    let dy = rule.y - (item.y + item.height);
-                    let overlap = rule.x2.min(item.x + item.width) - rule.x1.max(item.x);
-                    dy > 0.0
-                        && dy <= item.font_size * 0.3
-                        && overlap > rule.width() * 0.5
-                        && item.width <= rule.width() * 1.5
-                })
-        })
-        .map(|(i, _)| i)
-        .collect();
-
    for item in items.iter_mut() {
        if !is_underline_candidate(item) {
            continue;
@@ -449,10 +275,7 @@ pub(crate) fn mark_underlined_items(
            if tabular_rules.contains(&rule_idx) {
                continue;
            }
-            // The fraction guard only gates UNDERLINE marking — a rule that
-            // reads as a fraction bar from below can still legitimately
-            // strike through a line above it.
-            if !fraction_rules.contains(&rule_idx) && rule_matches_item(rule, item) {
+            if rule_matches_item(rule, item) {
                item.is_underline = true;
            }
            if rule_strikes_item(rule, item) {
@@ -500,16 +323,6 @@ mod tests {
        }
    }

-    fn cell_rect(x: f32, y: f32, width: f32, height: f32) -> PdfRect {
-        PdfRect {
-            x,
-            y,
-            width,
-            height,
-            page: 1,
-        }
-    }
-
    fn thin_rect(x: f32, y: f32, width: f32) -> PdfRect {
        PdfRect {
            x,
@@ -730,100 +543,6 @@ mod tests {
        assert!(items.iter().all(|item| !item.is_underline));
    }

-    #[test]
-    fn repeated_snug_underlines_survive_ruling_filter() {
-        // Dense docs underline many full-width lines: span-similar rules at
-        // 3+ y-levels used to be discarded wholesale as table rulings.
-        // Each rule here snugly matches one text line, so all must mark.
-        let mut items = vec![
-            item("first underlined line of text", 50.0, 700.0, 300.0, 11.0),
-            item("second underlined line here", 50.0, 650.0, 300.0, 11.0),
-            item("third underlined line as well", 50.0, 600.0, 300.0, 11.0),
-        ];
-        let lines = vec![
-            hline(50.0, 350.0, 697.0),
-            hline(50.0, 350.0, 647.0),
-            hline(50.0, 350.0, 597.0),
-        ];
-
-        mark_underlined_items(&mut items, &[], &lines, 1);
-
-        assert!(items.iter().all(|item| item.is_underline));
-    }
-
-    #[test]
-    fn snug_rescue_spans_split_runs_on_one_line() {
-        // A single underlined line is often split into several runs (script
-        // or font switches). The union of touching runs owns the rule.
-        let mut items = vec![
-            item("run one", 50.0, 700.0, 100.0, 11.0),
-            item("run two", 150.5, 700.0, 100.0, 11.0),
-            item("run three", 251.0, 700.0, 99.0, 11.0),
-            item("other a", 50.0, 650.0, 300.0, 11.0),
-            item("other b", 50.0, 600.0, 300.0, 11.0),
-        ];
-        let lines = vec![
-            hline(50.0, 350.0, 697.0),
-            hline(50.0, 350.0, 647.0),
-            hline(50.0, 350.0, 597.0),
-        ];
-
-        mark_underlined_items(&mut items, &[], &lines, 1);
-
-        assert!(items[0].is_underline && items[1].is_underline && items[2].is_underline);
-    }
-
-    #[test]
-    fn snug_rescue_denied_for_row_with_cell_gaps() {
-        // A full-width rule whose baseline row is several items separated by
-        // column-sized gaps is a table row separator, not an underline —
-        // even when span-similar rules repeat down the page.
-        let mut items = vec![
-            item("cell a", 50.0, 700.0, 60.0, 11.0),
-            item("cell b", 190.0, 700.0, 60.0, 11.0),
-            item("cell c", 330.0, 700.0, 70.0, 11.0),
-            item("cell d", 50.0, 650.0, 60.0, 11.0),
-            item("cell e", 190.0, 650.0, 60.0, 11.0),
-            item("cell f", 330.0, 650.0, 70.0, 11.0),
-        ];
-        let lines = vec![
-            hline(50.0, 400.0, 697.0),
-            hline(50.0, 400.0, 647.0),
-            hline(50.0, 400.0, 597.0),
-        ];
-
-        mark_underlined_items(&mut items, &[], &lines, 1);
-
-        assert!(items.iter().all(|item| !item.is_underline));
-    }
-
-    #[test]
-    fn snug_rescue_denied_inside_cell_box() {
-        // A rule snugly under one text line but enclosed by a drawn cell
-        // box that TILES with vertical neighbors (grid evidence) is a row
-        // ruling of a rect-grid table. Isolated boxes (callout panels) do
-        // not veto — see repeated_snug_underlines_survive_ruling_filter.
-        let mut items = vec![
-            item("one wide cell row", 50.0, 700.0, 300.0, 11.0),
-            item("second wide cell", 50.0, 650.0, 300.0, 11.0),
-            item("third wide cell", 50.0, 600.0, 300.0, 11.0),
-        ];
-        let lines = vec![
-            hline(50.0, 350.0, 697.0),
-            hline(50.0, 350.0, 647.0),
-            hline(50.0, 350.0, 597.0),
-        ];
-        let boxes = vec![
-            cell_rect(45.0, 690.0, 320.0, 50.0),
-            cell_rect(45.0, 640.0, 320.0, 50.0),
-            cell_rect(45.0, 590.0, 320.0, 50.0),
-        ];
-
-        mark_underlined_items(&mut items, &boxes, &lines, 1);
-
-        assert!(items.iter().all(|item| !item.is_underline));
-    }
-
    #[test]
    fn same_row_spaced_rule_segments_do_not_mark_column_labels() {
        let mut items = vec![
@@ -71,18 +71,6 @@ use tounicode::FontCMaps;
 /// broken font decoding or mojibake.
 pub const OCR_REASON_SUSPECTED_GARBLED_TEXT: &str = "suspected_garbled_text";

-/// OCR reason: the page is a scanned image (a full-page raster / image-only
-/// page) with no usable text layer.
-pub const OCR_REASON_SCANNED: &str = "scanned";
-
-/// OCR reason: the page has no extractable text and no image to OCR — blank,
-/// or content the parser cannot reach.
-pub const OCR_REASON_NO_TEXT: &str = "no_text";
-
-/// OCR reason: the page's text is drawn as vector outlines (path operators)
-/// rather than real text operators, so it cannot be extracted as characters.
-pub const OCR_REASON_VECTOR_TEXT: &str = "vector_text";
-
 // =========================================================================
 // Result type
 // =========================================================================
@@ -137,7 +125,7 @@ pub struct PdfProcessResult {
 ///     .mode(ProcessMode::Analyze)
 ///     .pages([1, 3, 5]);
 /// ```
-#[derive(Clone)]
+#[derive(Debug, Clone)]
 pub struct PdfOptions {
    /// How far the pipeline should run (default: [`ProcessMode::Full`]).
    pub mode: ProcessMode,
@@ -147,23 +135,6 @@ pub struct PdfOptions {
    pub markdown: MarkdownOptions,
    /// Optional set of 1-indexed pages to process.  `None` = all pages.
    pub page_filter: Option<HashSet<u32>>,
-    /// Password for decrypting an encrypted PDF. `None` falls back to the
-    /// empty password (owner-only encryption).
-    pub password: Option<String>,
-}
-
-// Manual `Debug` so the password is never leaked through debug logging or a
-// panic that formats the options; it renders as `Some("[REDACTED]")`.
-impl std::fmt::Debug for PdfOptions {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("PdfOptions")
-            .field("mode", &self.mode)
-            .field("detection", &self.detection)
-            .field("markdown", &self.markdown)
-            .field("page_filter", &self.page_filter)
-            .field("password", &self.password.as_ref().map(|_| "[REDACTED]"))
-            .finish()
-    }
 }

 impl Default for PdfOptions {
@@ -173,7 +144,6 @@ impl Default for PdfOptions {
            detection: DetectionConfig::default(),
            markdown: MarkdownOptions::default(),
            page_filter: None,
-            password: None,
        }
    }
 }
@@ -215,12 +185,6 @@ impl PdfOptions {
        self.page_filter = Some(pages.into_iter().collect());
        self
    }
-
-    /// Set the password used to decrypt an encrypted PDF.
-    pub fn password(mut self, password: impl Into<String>) -> Self {
-        self.password = Some(password.into());
-        self
-    }
 }

 // =========================================================================
@@ -253,8 +217,7 @@ pub fn process_pdf_with_options<P: AsRef<Path>>(
    validate_pdf_file(&path)?;

    // Load the document once — shared by detection AND extraction.
-    let (doc, page_count) =
-        load_document_from_path_with_password(&path, options.password.as_deref())?;
+    let (doc, page_count) = load_document_from_path(&path)?;

    process_document(doc, page_count, options, start)
 }
@@ -279,8 +242,7 @@ pub fn process_pdf_mem_with_options(
    let start = std::time::Instant::now();
    validate_pdf_bytes(buffer)?;

-    let (doc, page_count) =
-        load_document_from_mem_with_password(buffer, options.password.as_deref())?;
+    let (doc, page_count) = load_document_from_mem(buffer)?;

    process_document(doc, page_count, options, start)
 }
@@ -673,51 +635,18 @@ pub fn extract_text_in_regions_mem(

        let mut page_results = Vec::with_capacity(regions.len());

-        // Exclusive item->region assignment: overlapping layout regions used
-        // to extract shared items into EVERY region they touched (the
-        // 1.5pt inclusion margin makes borders generous), duplicating whole
-        // lines in the final markdown on 21% of bench docs — and downstream
-        // duplicate-handling sometimes dropped the variant holding a
-        // sentence tail, turning duplication into content LOSS. Each item
-        // now belongs to the single region with the largest overlap area;
-        // items are partitioned, never suppressed, so no content can vanish.
-        let all_bounds: Vec<RegionBounds> = regions
-            .iter()
-            .map(|rect| {
-                let [rx1, ry1, rx2, ry2] = *rect;
-                region_bounds(rx1, ry1, rx2, ry2, page_h, coords)
-            })
-            .collect();
-        // Single pass over items: assign each to the best-overlap region and
-        // bucket the clone directly (review: avoid a second O(items x
-        // regions) traversal). `had_candidates` marks regions that touched
-        // at least one item even if every one was assigned elsewhere.
-        let mut region_items: Vec<Vec<TextItem>> = vec![Vec::new(); regions.len()];
-        let mut had_candidates: Vec<bool> = vec![false; regions.len()];
-        if let Some(items) = items {
-            for item in items {
-                let mut best: Option<usize> = None;
-                let mut best_area = 0.0_f32;
-                for (ri, b) in all_bounds.iter().enumerate() {
-                    if !region_overlaps_item(item, *b) {
-                        continue;
-                    }
-                    had_candidates[ri] = true;
-                    let area = region_item_overlap_area(item, *b);
-                    if area > best_area {
-                        best_area = area;
-                        best = Some(ri);
-                    }
-                }
-                if let Some(ri) = best {
-                    region_items[ri].push(item.clone());
-                }
-            }
-        }
+        for rect in regions {
+            let [rx1, ry1, rx2, ry2] = *rect;

-        for (region_idx, _rect) in regions.iter().enumerate() {
-            let matched: Vec<TextItem> = std::mem::take(&mut region_items[region_idx]);
-            let assigned_count = matched.len();
+            let bounds = region_bounds(rx1, ry1, rx2, ry2, page_h, coords);
+            let matched: Vec<TextItem> = match items {
+                Some(items) => items
+                    .iter()
+                    .filter(|item| region_overlaps_item(item, bounds))
+                    .cloned()
+                    .collect(),
+                None => Vec::new(),
+            };
            let has_text_quality_issue = region_items_have_decoding_issue(&matched);
            let text = collect_text_from_matched_items(matched, adaptive_threshold);
            let has_cid_issue = is_cid_garbage(&text);
@@ -731,21 +660,8 @@ pub fn extract_text_in_regions_mem(
            // Check per-region text quality instead of blanket page-level
            // GID rejection. A GID font in a logo elsewhere on the page
            // shouldn't force GPU OCR for clean text regions.
-            // A region whose ONLY overlapping items were assigned to a
-            // better-overlapping neighbor must not fall back to OCR: the
-            // pixels it would re-read belong to that neighbor, and OCR
-            // would reintroduce the duplication exclusivity removed.
-            // Before exclusive assignment these regions were non-empty
-            // native (no OCR), so this preserves the old OCR load too.
-            // Requires ZERO items assigned HERE: a region whose own
-            // assigned items materialize to empty text (whitespace-only,
-            // collector-filtered) keeps its OCR fallback.
-            let lost_to_neighbor = text.trim().is_empty()
-                && ocr_reason.is_none()
-                && assigned_count == 0
-                && had_candidates[region_idx];
-            let needs_ocr = !lost_to_neighbor
-                && (ocr_reason.is_some() || text.trim().is_empty() || is_garbage_text(&text));
+            let needs_ocr =
+                ocr_reason.is_some() || text.trim().is_empty() || is_garbage_text(&text);

            page_results.push(RegionText {
                text,
@@ -3261,26 +3177,8 @@ fn region_bounds(
    }
 }

-/// Inclusion margin shared by the region/item overlap predicates and the
-/// exclusive-assignment area score — these MUST stay in sync: an item that
-/// passes the boolean guard must always have positive overlap area.
-const REGION_MARGIN: f32 = 1.5;
-
-/// Overlap area between an item and region bounds (same margin as the
-/// boolean test) — the exclusive-assignment score.
-fn region_item_overlap_area(item: &TextItem, bounds: RegionBounds) -> f32 {
-    let item_x_max = item.x + text_utils::effective_width(item);
-    let item_y_max = item.y + item.height;
-    let x_overlap = (item_x_max.min(bounds.x_max + REGION_MARGIN)
-        - item.x.max(bounds.x_min - REGION_MARGIN))
-    .max(0.0);
-    let y_overlap = (item_y_max.min(bounds.y_max + REGION_MARGIN)
-        - item.y.max(bounds.y_min - REGION_MARGIN))
-    .max(0.0);
-    x_overlap * y_overlap
-}
-
 fn region_overlaps_item(item: &TextItem, bounds: RegionBounds) -> bool {
+    const REGION_MARGIN: f32 = 1.5;
    let item_x_min = item.x;
    let item_x_max = item.x + text_utils::effective_width(item);
    let item_y_min = item.y;
@@ -3296,6 +3194,7 @@ fn region_overlaps_item(item: &TextItem, bounds: RegionBounds) -> bool {
 }

 fn region_overlaps_rect(rect: &PdfRect, bounds: RegionBounds) -> bool {
+    const REGION_MARGIN: f32 = 1.5;
    let (x_min, y_min, x_max, y_max) = normalized_rect_edges(rect);
    ranges_overlap(
        x_min,
@@ -3311,6 +3210,7 @@ fn region_overlaps_rect(rect: &PdfRect, bounds: RegionBounds) -> bool {
 }

 fn region_overlaps_line(line: &PdfLine, bounds: RegionBounds) -> bool {
+    const REGION_MARGIN: f32 = 1.5;
    let x_min = line.x1.min(line.x2);
    let x_max = line.x1.max(line.x2);
    let y_min = line.y1.min(line.y2);
@@ -3367,40 +3267,24 @@ fn tsr_region_contains_item(item: &TextItem, bounds: RegionBounds) -> bool {
 /// page count from it directly to avoid the metadata-only round-trip.
 pub(crate) fn load_document_from_path<P: AsRef<Path>>(
    path: P,
-) -> Result<(Document, u32), PdfError> {
-    load_document_from_path_with_password(path, None)
-}
-
-/// Load a PDF file, decrypting with `password` if the file is encrypted.
-pub(crate) fn load_document_from_path_with_password<P: AsRef<Path>>(
-    path: P,
-    password: Option<&str>,
 ) -> Result<(Document, u32), PdfError> {
    let buffer = std::fs::read(&path)?;
-    load_document_from_mem_with_password(&buffer, password)
+    load_document_from_mem(&buffer)
 }

 /// Load a PDF from a memory buffer.
 pub(crate) fn load_document_from_mem(buffer: &[u8]) -> Result<(Document, u32), PdfError> {
-    load_document_from_mem_with_password(buffer, None)
-}
-
-/// Load a PDF from a memory buffer, decrypting with `password` if encrypted.
-pub(crate) fn load_document_from_mem_with_password(
-    buffer: &[u8],
-    password: Option<&str>,
-) -> Result<(Document, u32), PdfError> {
    // Fix malformed struct element names before parsing. Some PDF generators
    // write bare names (/S Code) instead of proper PDF names (/S /Code), which
    // causes lopdf to silently drop the entire object.
    let fixed = structure_tree::fix_bare_struct_names(buffer);
    let buf = fixed.as_ref();

-    let doc = match load_document_bytes(buf, password) {
+    let doc = match load_document_bytes(buf) {
        Ok(doc) => doc,
        Err(first_err) => {
            for repaired in repair_pdf_container_candidates(buf) {
-                match load_document_bytes(&repaired, password) {
+                match load_document_bytes(&repaired) {
                    Ok(doc) => {
                        log::debug!("loaded PDF after repairing malformed container bytes");
                        let page_count = doc.get_pages().len() as u32;
@@ -3420,31 +3304,13 @@ pub(crate) fn load_document_from_mem_with_password(
    Ok((doc, page_count))
 }

-fn load_document_bytes(buf: &[u8], password: Option<&str>) -> Result<Document, lopdf::Error> {
+fn load_document_bytes(buf: &[u8]) -> Result<Document, lopdf::Error> {
    match Document::load_mem(buf) {
-        // Some encrypted PDFs load structurally but leave their streams
-        // encrypted (`is_encrypted()` stays true); reading them yields garbage
-        // until we re-load with a password. Others fail load_mem outright with
-        // an encryption error. Handle both by re-loading with the password.
-        Ok(doc) if doc.is_encrypted() => decrypt_document_bytes(buf, password),
        Ok(doc) => Ok(doc),
-        Err(ref e) if is_encrypted_lopdf_error(e) => decrypt_document_bytes(buf, password),
-        Err(e) => Err(e),
-    }
-}
-
-/// Re-load an encrypted PDF, decrypting with `password`. Falls back to the
-/// empty password (owner-only encryption, the common "protected" case) when a
-/// non-empty password was supplied but rejected.
-fn decrypt_document_bytes(buf: &[u8], password: Option<&str>) -> Result<Document, lopdf::Error> {
-    let pw = password.unwrap_or("");
-    match Document::load_mem_with_options(buf, lopdf::LoadOptions::with_password(pw)) {
-        Ok(doc) => Ok(doc),
-        Err(inner) if !pw.is_empty() => {
+        Err(ref e) if is_encrypted_lopdf_error(e) => {
            Document::load_mem_with_options(buf, lopdf::LoadOptions::with_password(""))
-                .map_err(|_| inner)
        }
-        Err(inner) => Err(inner),
+        Err(e) => Err(e),
    }
 }

@@ -3539,7 +3405,6 @@ fn process_document(
    let pages_needing_ocr = detection.pages_needing_ocr;
    let title = detection.title;
    let confidence = detection.confidence;
-    let detection_ocr_reasons = detection.ocr_reasons_by_page;

    // DetectOnly → return immediately
    if options.mode == ProcessMode::DetectOnly {
@@ -3549,7 +3414,7 @@ fn process_document(
            page_count,
            processing_time_ms: start.elapsed().as_millis() as u64,
            pages_needing_ocr,
-            ocr_reasons_by_page: page_ocr_reasons_vec(detection_ocr_reasons),
+            ocr_reasons_by_page: Vec::new(),
            title,
            confidence,
            layout: LayoutComplexity::default(),
@@ -3565,7 +3430,7 @@ fn process_document(
            page_count,
            processing_time_ms: start.elapsed().as_millis() as u64,
            pages_needing_ocr,
-            ocr_reasons_by_page: page_ocr_reasons_vec(detection_ocr_reasons),
+            ocr_reasons_by_page: Vec::new(),
            title,
            confidence,
            layout: LayoutComplexity::default(),
@@ -3831,13 +3696,7 @@ fn process_document(
        page_count,
        processing_time_ms: start.elapsed().as_millis() as u64,
        pages_needing_ocr,
-        ocr_reasons_by_page: {
-            // Detector reasons (scanned / no_text / vector_text / garbled) merged
-            // with the markdown-stage garbled detection, deduped per page.
-            let mut merged = detection_ocr_reasons;
-            merge_ocr_reasons(&mut merged, text_quality_reasons_by_page);
-            page_ocr_reasons_vec(merged)
-        },
+        ocr_reasons_by_page: page_ocr_reasons_vec(text_quality_reasons_by_page),
        title,
        confidence,
        layout,
@@ -174,21 +174,6 @@ pub(crate) fn is_toc_marker_heading(text: &str) -> bool {
 pub(crate) fn is_heading_fragment(text: &str) -> bool {
    let t = text.trim_end();

-    // A lowercase-initial one-or-two-word "heading" is a mid-sentence
-    // fragment beside display math ("or inversely", "and therefore") —
-    // real headings that short start uppercase. Measured as spurious
-    // headings on academic docs (fire-pdf ENG-5029 / opendataloader MHS).
-    {
-        let words: Vec<&str> = t.split_whitespace().collect();
-        if words.len() <= 2 {
-            if let Some(first_alpha) = t.chars().find(|c| c.is_alphabetic()) {
-                if first_alpha.is_lowercase() {
-                    return true;
-                }
-            }
-        }
-    }
-
    fn is_equation_number(s: &str) -> bool {
        s.strip_prefix('(')
            .and_then(|r| r.strip_suffix(')'))
@@ -475,10 +460,6 @@ mod tests {
    #[test]
    fn heading_fragments() {
        // Equation lead-ins: colon ending + inline equation reference
-        assert!(is_heading_fragment("or inversely"));
-        assert!(is_heading_fragment("and therefore"));
-        assert!(!is_heading_fragment("Introduction"));
-        assert!(!is_heading_fragment("iPhone Sales Strategy Overview")); // 4 words, exempt
        assert!(is_heading_fragment("Rearranging Equation (8) gives:"));
        // Display-equation neighbours ending in an equation number
        assert!(is_heading_fragment("S = kB ln W, (2)"));
@@ -179,128 +179,6 @@ pub(crate) fn split_side_by_side(items: &[TextItem]) -> Vec<(f32, f32)> {
 /// zone layout (calendar months, form sections).  This function checks if hint
 /// regions pair up at the same Y bands and returns `[(x_min, split), (split,
 /// x_max)]` if a consistent split exists.
-/// True when a table-shaped rect cluster (≥6 rects) ends at an interior band
-/// boundary and its rows visibly continue on the far side: cell-like text
-/// across the boundary is y-aligned with most cluster rows, and nearly all
-/// far-side text in the cluster's y-range participates in that alignment.
-/// Tables often rule only their leading columns, so the text gap before the
-/// borderless columns masquerades as a page-layout gutter — a real second
-/// layout column would instead be dense prose that doesn't track table rows.
-fn rect_cluster_spans_band_boundary(
-    items: &[TextItem],
-    rects: &[PdfRect],
-    page: u32,
-    bands: &[(f32, f32)],
-) -> bool {
-    if bands.len() < 2 {
-        return false;
-    }
-    // Normalize: raw PDF rects can carry negative extents.
-    let page_rects: Vec<(f32, f32, f32, f32)> = rects
-        .iter()
-        .filter(|r| r.page == page)
-        .map(|r| {
-            let (x, w) = if r.width < 0.0 {
-                (r.x + r.width, -r.width)
-            } else {
-                (r.x, r.width)
-            };
-            let (y, h) = if r.height < 0.0 {
-                (r.y + r.height, -r.height)
-            } else {
-                (r.y, r.height)
-            };
-            (x, y, w, h)
-        })
-        .collect();
-    if page_rects.len() < 6 {
-        return false;
-    }
-    let clusters = crate::tables::detect_rects::cluster_rects(&page_rects, 3.0, 6);
-    let boundaries: Vec<f32> = bands[..bands.len() - 1].iter().map(|&(_, hi)| hi).collect();
-
-    boundaries.iter().any(|&b| {
-        // Y-ranges of clusters that individually indicate the split cuts a
-        // table: either ruled on both sides of the boundary, or ending at
-        // the boundary with cell-like text row-aligned beyond it.
-        let mut table_y_ranges: Vec<(f32, f32)> = Vec::new();
-        for cluster in &clusters {
-            let bbox = cluster.iter().fold(
-                (
-                    f32::INFINITY,
-                    f32::INFINITY,
-                    f32::NEG_INFINITY,
-                    f32::NEG_INFINITY,
-                ),
-                |(x0, y0, x1, y1), &i| {
-                    let (x, y, w, h) = page_rects[i];
-                    (x0.min(x), y0.min(y), x1.max(x + w), y1.max(y + h))
-                },
-            );
-            let spans = bbox.0 < b - 20.0 && bbox.2 > b + 20.0;
-            let ends_at = bbox.2 >= b - 60.0 && bbox.2 <= b + 10.0 && bbox.0 <= b;
-            if !spans && !ends_at {
-                continue;
-            }
-            // Distinct row baselines of items inside the cluster bbox.
-            let mut row_ys: Vec<f32> = Vec::new();
-            for it in items {
-                let cx = it.x + it.width / 2.0;
-                if it.page == page
-                    && cx > bbox.0
-                    && cx < bbox.2
-                    && it.y >= bbox.1 - 2.0
-                    && it.y <= bbox.3 + 2.0
-                    && !row_ys.iter().any(|&y| (y - it.y).abs() <= 2.0)
-                {
-                    row_ys.push(it.y);
-                }
-            }
-            if row_ys.len() < 2 {
-                continue;
-            }
-            // Cell-like far-side items row-aligned with the cluster.
-            let cell_like = |it: &&TextItem| it.width <= 150.0;
-            let far_aligned_rows = row_ys
-                .iter()
-                .filter(|&&y| {
-                    items.iter().any(|it| {
-                        it.page == page
-                            && it.x + it.width / 2.0 > b
-                            && cell_like(&it)
-                            && (it.y - y).abs() <= 2.0
-                    })
-                })
-                .count();
-            if far_aligned_rows >= 2 && far_aligned_rows * 2 >= row_ys.len() {
-                table_y_ranges.push((bbox.1, bbox.3));
-            }
-        }
-        if table_y_ranges.is_empty() {
-            return false;
-        }
-        // The split is only wrong if the table rows account for most of the
-        // far side. A figure legitimately spanning two text columns leaves
-        // the majority of far-side text (column prose) outside its y-range.
-        let far: Vec<&TextItem> = items
-            .iter()
-            .filter(|it| it.page == page && it.x + it.width / 2.0 > b)
-            .collect();
-        if far.is_empty() {
-            return false;
-        }
-        let inside = far
-            .iter()
-            .filter(|it| {
-                table_y_ranges
-                    .iter()
-                    .any(|&(lo, hi)| it.y >= lo - 2.0 && it.y <= hi + 2.0)
-            })
-            .count();
-        inside * 10 >= far.len() * 6
-    })
-}
-
 fn split_from_hint_regions(items: &[TextItem], rects: &[PdfRect], page: u32) -> Vec<(f32, f32)> {
    use crate::tables::{cluster_rects, RectHintRegion};

@@ -744,46 +622,8 @@ pub(crate) fn to_markdown_from_items_with_rects_and_lines(
            cols.len() >= 2
        };

-        // Chart-bar regions: bar charts drawn as filled rects read as cell
-        // rects or aligned text and get gridded into phantom tables. Their
-        // items are excluded from every table detector below and flow through
-        // as plain text instead.
-        let page_rect_vec: Vec<PdfRect> =
-            rects.iter().filter(|r| r.page == page).cloned().collect();
-        let chart_regions = crate::tables::detect_chart_regions(&page_items, &page_rect_vec, page);
-        // Pad the claim region: axis/category labels sit just outside the
-        // bar rects (below the axis, left of the scale) and belong to the
-        // chart as much as the bars do.
-        const CHART_PAD: f32 = 20.0;
-        let in_chart = |it: &TextItem| {
-            chart_regions.iter().any(|&(x0, y0, x1, y1)| {
-                let cx = it.x + it.width / 2.0;
-                cx >= x0 - CHART_PAD
-                    && cx <= x1 + CHART_PAD
-                    && it.y >= y0 - CHART_PAD
-                    && it.y <= y1 + CHART_PAD
-            })
-        };
-        if !chart_regions.is_empty() {
-            log::debug!(
-                "page {}: {} chart region(s) masked from table detection",
-                page,
-                chart_regions.len()
-            );
-        }
-
        // Check for side-by-side layout (e.g. two tables placed left and right)
        let mut bands = split_side_by_side(&page_items);
-        // A rect table crossing a proposed split boundary means the "gutter"
-        // is really the gap between ruled and borderless table columns —
-        // splitting there cleaves the table in half. Veto the split.
-        if !bands.is_empty() && rect_cluster_spans_band_boundary(&page_items, rects, page, &bands) {
-            log::debug!(
-                "page {}: side-by-side split vetoed by spanning rect cluster",
-                page
-            );
-            bands.clear();
-        }
        // Fallback: use rect hint regions to detect side-by-side layout
        // when the text gap is too narrow for split_side_by_side to detect
        // (e.g. calendars with left/right month columns ~10pt apart).
@@ -865,16 +705,6 @@ pub(crate) fn to_markdown_from_items_with_rects_and_lines(
            // Track which band-local indices are claimed by structural detection
            let mut rect_claimed: HashSet<usize> = HashSet::new();

-            // Pre-claim chart items: every detector below skips claimed
-            // indices, and unclaimed-by-tables text flows out as plain lines.
-            if !chart_regions.is_empty() {
-                for (idx, item) in band_items.iter().enumerate() {
-                    if in_chart(item) {
-                        rect_claimed.insert(idx);
-                    }
-                }
-            }
-
            // 0. Structure-tree detection (highest priority — semantic PDF tagging)
            //    Only use struct-tree tables when they capture a majority (≥50%) of
            //    band items.  Incomplete struct trees (partial tagging) should fall
@@ -1130,20 +960,15 @@ pub(crate) fn to_markdown_from_items_with_rects_and_lines(
                }
            }
            if synth_lines.len() >= 10 {
-                // Chart text stays out of the thin-rect fallback too — a
-                // chart's thin grid rules would otherwise re-grid it.
-                let (page_text, page_text_map): (Vec<TextItem>, Vec<usize>) = text_items
+                let page_text: Vec<TextItem> = text_items
                    .iter()
-                    .enumerate()
-                    .filter(|(_, i)| i.page == page && !in_chart(i))
-                    .map(|(idx, i)| (i.clone(), idx))
-                    .unzip();
+                    .filter(|i| i.page == page)
+                    .cloned()
+                    .collect();
                let line_tables = detect_tables_from_lines(&page_text, &synth_lines, page);
                for table in &line_tables {
                    for &idx in &table.item_indices {
-                        if let Some(&global_idx) = page_text_map.get(idx) {
-                            table_items.insert(global_idx);
-                        }
+                        table_items.insert(idx);
                    }
                    let table_y = table.rows.first().copied().unwrap_or(0.0);
                    let table_md = table_to_markdown(table);
@@ -1167,20 +992,10 @@ pub(crate) fn to_markdown_from_items_with_rects_and_lines(
                band_items.len(),
                was_split
            );
-            // Chart text stays out of the retry as well.
-            let (chart_free, chart_free_map): (Vec<TextItem>, Vec<usize>) = band_items
-                .iter()
-                .enumerate()
-                .filter(|(_, it)| !in_chart(it))
-                .map(|(i, it)| (it.clone(), i))
-                .unzip();
-            let heuristic_tables = detect_tables(&chart_free, base_size, page_has_columns);
+            let heuristic_tables = detect_tables(band_items, base_size, page_has_columns);
            for table in &heuristic_tables {
                for &idx in &table.item_indices {
-                    if let Some(&page_idx) = chart_free_map
-                        .get(idx)
-                        .and_then(|&band_idx| band_index_map.get(band_idx))
-                    {
+                    if let Some(&page_idx) = band_index_map.get(idx) {
                        if let Some(&(global_idx, _)) = group.get(page_idx) {
                            table_items.insert(global_idx);
                        }
@@ -1412,121 +1227,6 @@ mod tests {
        }
    }

-    fn make_item_w(x: f32, y: f32, width: f32, page: u32) -> TextItem {
-        let mut it = make_item(x, y, page);
-        it.width = width;
-        it
-    }
-
-    /// 4-row × 2-col ruled grid from x=100..300 (rows every 20pt from y=600).
-    fn ruled_cluster_rects() -> Vec<PdfRect> {
-        let mut rects = Vec::new();
-        for row in 0..4 {
-            for col in 0..2 {
-                rects.push(PdfRect {
-                    x: 100.0 + col as f32 * 100.0,
-                    y: 600.0 + row as f32 * 20.0,
-                    width: 100.0,
-                    height: 20.0,
-                    page: 1,
-                });
-            }
-        }
-        rects
-    }
-
-    #[test]
-    fn band_veto_cluster_ruled_across_boundary() {
-        // Rects on both sides of the boundary and cell text on both sides,
-        // row-aligned → the split cuts straight through a drawn table.
-        let mut rects = ruled_cluster_rects();
-        for r in &mut rects {
-            r.width = 150.0; // right column now spans 250..400, past b=320
-        }
-        let mut items = Vec::new();
-        for row in 0..4 {
-            let y = 610.0 + row as f32 * 20.0;
-            items.push(make_item_w(110.0, y, 80.0, 1)); // left cells
-            items.push(make_item_w(330.0, y, 30.0, 1)); // right cells past b
-        }
-        assert!(rect_cluster_spans_band_boundary(
-            &items,
-            &rects,
-            1,
-            &[(90.0, 320.0), (320.0, 500.0)]
-        ));
-    }
-
-    #[test]
-    fn band_veto_ignores_spanning_figure() {
-        // A figure's rects span the boundary at the top of the page, but the
-        // far side is dominated by column prose below it → keep the split.
-        let mut rects = ruled_cluster_rects(); // y 600..680
-        for r in &mut rects {
-            r.width = 150.0; // spans past b=320
-        }
-        let mut items = Vec::new();
-        // A few figure labels inside the cluster, aligned rows.
-        for row in 0..4 {
-            let y = 610.0 + row as f32 * 20.0;
-            items.push(make_item_w(110.0, y, 40.0, 1));
-            items.push(make_item_w(330.0, y, 20.0, 1));
-        }
-        // Dense prose column far below the figure (outside cluster y-range).
-        let mut y = 100.0;
-        while y < 560.0 {
-            items.push(make_item_w(330.0, y, 140.0, 1));
-            y += 12.0;
-        }
-        assert!(!rect_cluster_spans_band_boundary(
-            &items,
-            &rects,
-            1,
-            &[(90.0, 320.0), (320.0, 500.0)]
-        ));
-    }
-
-    #[test]
-    fn band_veto_borderless_columns_continue_rows() {
-        // Rects end at x=300 (just short of b=320); cell-like text at x=340
-        // aligns with every grid row → the "gutter" is inside the table.
-        let rects = ruled_cluster_rects();
-        let mut items = Vec::new();
-        for row in 0..4 {
-            let y = 610.0 + row as f32 * 20.0;
-            items.push(make_item_w(110.0, y, 80.0, 1)); // label cells
-            items.push(make_item_w(340.0, y, 30.0, 1)); // borderless column
-        }
-        assert!(rect_cluster_spans_band_boundary(
-            &items,
-            &rects,
-            1,
-            &[(90.0, 320.0), (320.0, 500.0)]
-        ));
-    }
-
-    #[test]
-    fn band_veto_ignores_prose_column() {
-        // Dense prose right of the boundary: wide lines, three per grid row,
-        // mostly not row-aligned → keep the side-by-side split.
-        let rects = ruled_cluster_rects();
-        let mut items = Vec::new();
-        for row in 0..4 {
-            items.push(make_item_w(110.0, 610.0 + row as f32 * 20.0, 80.0, 1));
-        }
-        let mut y = 602.0;
-        while y < 680.0 {
-            items.push(make_item_w(340.0, y, 200.0, 1)); // full-width prose lines
-            y += 7.0;
-        }
-        assert!(!rect_cluster_spans_band_boundary(
-            &items,
-            &rects,
-            1,
-            &[(90.0, 320.0), (320.0, 500.0)]
-        ));
-    }
-
    #[test]
    fn split_from_hint_regions_too_few_rects() {
        // Fewer than 60 rects → no split
@@ -914,126 +914,7 @@ fn looks_like_number(s: &str) -> bool {
 ///
 /// Used by format.rs to render TOCs as flat lists instead of markdown tables.
 pub fn is_table_of_contents(cells: &[Vec<String>]) -> bool {
-    is_dot_leader_toc(cells) || is_tabular_toc(cells) || is_page_number_toc(cells)
-}
-
-/// Parse a page-number-like token: a short arabic integer (≤4 digits) or a
-/// canonical roman numeral (front-matter pages: i, ii, …, xxxviii). Roman
-/// parsing is shared with the formatter via `super::canonical_roman_value` so
-/// the two stay in sync.
-fn page_number_value(token: &str) -> Option<u32> {
-    let t = token.trim();
-    if t.is_empty() {
-        return None;
-    }
-    if t.chars().all(|c| c.is_ascii_digit()) && t.len() <= 4 {
-        return t.parse().ok();
-    }
-    super::canonical_roman_value(t)
-}
-
-/// Page-number-column TOC: title-based contents with no dot leaders and no
-/// section numbers (e.g. "About the Publisher  vii", "Experiment #1 …  3").
-/// The signature is a text-title first column and a last column that is almost
-/// entirely page numbers whose values are *mostly non-decreasing* — the
-/// monotonic run is what separates a real TOC from an incidental 2-column
-/// numeric data table.
-pub(super) fn is_page_number_toc(cells: &[Vec<String>]) -> bool {
-    let num_cols = cells.first().map(|r| r.len()).unwrap_or(0);
-    // A page-number TOC is a narrow list (title + page, optionally a leader
-    // column). Wider grids are data tables, not contents.
-    if !(2..=3).contains(&num_cols) || cells.len() < 5 {
-        return false;
-    }
-    let last = num_cols - 1;
-
-    // No header row: a TOC's first row is already an entry, so its last cell is
-    // a page number. A data table's first row is a column header (non-numeric,
-    // or an empty units cell like "Category | ") — the tell that separates
-    // "Mineral | CEC" tables from real contents. Check the actual first row,
-    // not the first non-empty one, so a blank header cell still rejects.
-    let first_last = cells[0].get(last).map(|s| s.trim()).unwrap_or("");
-    if page_number_value(first_last).is_none() {
-        return false;
-    }
-
-    // Last column: page numbers on ≥70% of filled rows; collect their values.
-    let mut filled = 0u32;
-    let mut page_vals: Vec<u32> = Vec::new();
-    for row in cells {
-        let cell = row.get(last).map(|s| s.trim()).unwrap_or("");
-        if cell.is_empty() {
-            continue;
-        }
-        filled += 1;
-        if let Some(v) = page_number_value(cell) {
-            page_vals.push(v);
-        }
-    }
-    if filled < 4 || (page_vals.len() as f32) < 0.7 * filled as f32 {
-        return false;
-    }
-
-    // First column: mostly text titles (has alphabetic content). This rejects
-    // numeric-vs-numeric grids.
-    let text_first = cells
-        .iter()
-        .filter(|row| {
-            row.first()
-                .is_some_and(|c| c.chars().any(|ch| ch.is_alphabetic()))
-        })
-        .count();
-    if (text_first as f32) < 0.6 * cells.len() as f32 {
-        return false;
-    }
-
-    // Page numbers mostly ascend (allow front-matter→body resets and noise).
-    if page_vals.len() < 2 {
-        return false;
-    }
-    let non_decreasing = page_vals.windows(2).filter(|w| w[1] >= w[0]).count();
-    if (non_decreasing as f32) < 0.7 * (page_vals.len() - 1) as f32 {
-        return false;
-    }
-
-    // Stronger TOC signal. Real page numbers SPAN the document — entries skip
-    // (3, 6, 13, 24, …) so their range exceeds the entry count. A rank / ID /
-    // ordinal column is instead a *perfectly dense* consecutive run (1,2,3,… or
-    // 100,101,102,…). Accept anything with page gaps; for a dense run — which a
-    // one-page-per-entry TOC can also produce — fall back to a title signal:
-    // real contents entries are multi-word headings, rank labels are short.
-    let min = *page_vals.iter().min().unwrap();
-    let max = *page_vals.iter().max().unwrap();
-    let span = max.saturating_sub(min);
-    if span > page_vals.len() as u32 {
-        return true;
-    }
-    let dense_consecutive = (span as usize) + 1 == page_vals.len() && {
-        let mut sorted = page_vals.clone();
-        sorted.sort_unstable();
-        sorted.dedup();
-        sorted.len() == page_vals.len()
-    };
-    if !dense_consecutive {
-        // Narrow range but with a gap or repeat — still contents-like.
-        return true;
-    }
-    // Dense counter: only a TOC if the titles read like headings, not the
-    // short single-word labels typical of rank/leaderboard/ID tables.
-    let (total_words, titled_rows) = cells
-        .iter()
-        .filter_map(|row| row.first())
-        .filter(|c| c.chars().any(|ch| ch.is_alphabetic()))
-        .fold((0usize, 0usize), |(w, n), c| {
-            (
-                w + c
-                    .split_whitespace()
-                    .filter(|t| t.chars().any(|ch| ch.is_alphabetic()))
-                    .count(),
-                n + 1,
-            )
-        });
-    titled_rows > 0 && (total_words as f32) / titled_rows as f32 >= 1.8
+    is_dot_leader_toc(cells) || is_tabular_toc(cells)
 }

 /// Dot-leader TOC: any "Chapter 1 ........ 42" style with explicit leader
@@ -2005,166 +1886,4 @@ mod tests {
        assert!(!starts_with_section_number(""));
        assert!(!starts_with_section_number("Hello world"));
    }
-
-    #[test]
-    fn page_number_value_rejects_roman_lookalike_words() {
-        // Ordinary words made only of {i,v,x,l,c} are not page numbers.
-        assert!(page_number_value("civil").is_none());
-        assert!(page_number_value("mix").is_none());
-        assert!(page_number_value("ill").is_none());
-        assert!(page_number_value("lil").is_none());
-        // Canonical roman numerals still parse.
-        assert_eq!(page_number_value("vii"), Some(7));
-        assert_eq!(page_number_value("ix"), Some(9));
-        assert_eq!(page_number_value("xii"), Some(12));
-        assert_eq!(page_number_value("42"), Some(42));
-    }
-
-    #[test]
-    fn page_number_toc_matches_consecutive_pages_with_titles() {
-        // A short chapter-per-page contents: pages are a dense 1..n run, but
-        // the multi-word titles mark it as a real TOC (recovered by the title
-        // signal rather than rejected for lacking page gaps).
-        let cells: Vec<Vec<String>> = vec![
-            vec!["Introduction to the Study".into(), "1".into()],
-            vec!["Materials and Methods".into(), "2".into()],
-            vec!["Results and Discussion".into(), "3".into()],
-            vec!["Summary of Findings".into(), "4".into()],
-            vec!["References and Notes".into(), "5".into()],
-        ];
-        assert!(is_page_number_toc(&cells));
-    }
-
-    #[test]
-    fn page_number_toc_rejects_dense_ordinal_column() {
-        // Headerless title | rank table: values are a consecutive 1..n
-        // sequence (monotonic, no header, text first column) but their range
-        // ~= the row count, so it is data, not a table of contents.
-        let cells: Vec<Vec<String>> = vec![
-            vec!["Alice".into(), "1".into()],
-            vec!["Bob".into(), "2".into()],
-            vec!["Carol".into(), "3".into()],
-            vec!["Dave".into(), "4".into()],
-            vec!["Erin".into(), "5".into()],
-            vec!["Frank".into(), "6".into()],
-        ];
-        assert!(!is_page_number_toc(&cells));
-    }
-
-    #[test]
-    fn page_number_toc_rejects_blank_header_cell() {
-        // First row is a header whose last cell is blank ("Category | ");
-        // must not be flattened even though later rows look TOC-like.
-        let cells = vec![
-            vec!["Category".into(), "".into()],
-            vec!["Alpha".into(), "3".into()],
-            vec!["Beta".into(), "9".into()],
-            vec!["Gamma".into(), "14".into()],
-            vec!["Delta".into(), "20".into()],
-        ];
-        assert!(!is_page_number_toc(&cells));
-    }
-
-    #[test]
-    fn page_number_toc_matches_title_based_contents() {
-        // Title-left, page-number-right, no dot leaders, no section numbers.
-        let cells = vec![
-            vec!["About the Publisher".into(), "vii".into()],
-            vec!["About This Project".into(), "ix".into()],
-            vec!["Acknowledgments".into(), "xi".into()],
-            vec!["Experiment #1: Hydrostatic Pressure".into(), "3".into()],
-            vec!["Experiment #2: Bernoulli's Theorem".into(), "13".into()],
-            vec![
-                "Experiment #3: Energy Loss in Pipe Fittings".into(),
-                "24".into(),
-            ],
-        ];
-        assert!(is_page_number_toc(&cells));
-        assert!(is_table_of_contents(&cells));
-    }
-
-    #[test]
-    fn page_number_toc_rejects_numeric_data_table() {
-        // Real 2-col data table: numeric first column, non-monotonic values.
-        let cells = vec![
-            vec!["101".into(), "45".into()],
-            vec!["102".into(), "12".into()],
-            vec!["103".into(), "88".into()],
-            vec!["104".into(), "7".into()],
-            vec!["105".into(), "63".into()],
-        ];
-        assert!(!is_page_number_toc(&cells));
-    }
-
-    #[test]
-    fn page_number_toc_rejects_non_monotonic_pages() {
-        // Text labels but the "page" column jumps around — a small data table,
-        // not a contents listing. 5 rows so the row-count guard passes and the
-        // monotonicity check is what does the rejecting.
-        let cells: Vec<Vec<String>> = vec![
-            vec!["Apples".into(), "42".into()],
-            vec!["Oranges".into(), "7".into()],
-            vec!["Pears".into(), "91".into()],
-            vec!["Plums".into(), "3".into()],
-            vec!["Grapes".into(), "60".into()],
-        ];
-        // Sanity: this input clears the row-count and header guards, so a
-        // failure here is genuinely the monotonicity check.
-        assert!(cells.len() >= 5 && page_number_value(cells[0][1].trim()).is_some());
-        assert!(!is_page_number_toc(&cells));
-    }
-
-    #[test]
-    fn page_number_toc_rejects_header_row_data_table() {
-        // Real 2-col data table with a header row ("Mineral | CEC") and
-        // ascending values that mimic page numbers — the header tells us it
-        // is data, not contents.
-        let cells = vec![
-            vec![
-                "Mineral or colloid type".into(),
-                "CEC of pure colloid".into(),
-            ],
-            vec!["kaolinite".into(), "10".into()],
-            vec!["illite".into(), "30".into()],
-            vec!["montmorillonite".into(), "100".into()],
-            vec!["vermiculite".into(), "150".into()],
-        ];
-        assert!(!is_page_number_toc(&cells));
-    }
-
-    #[test]
-    fn page_number_toc_rejects_wide_data_grid() {
-        // A 4-column regional data table must not be read as a TOC even with a
-        // text first column and integer last column.
-        let cells = vec![
-            vec![
-                "REGIONS".into(),
-                "2007".into(),
-                "2010".into(),
-                "2016".into(),
-            ],
-            vec![
-                "National Capital Region".into(),
-                "9".into(),
-                "8".into(),
-                "5".into(),
-            ],
-            vec!["Cordillera".into(), "1".into(), "2".into(), "1".into()],
-            vec!["Ilocos Region".into(), "1".into(), "5".into(), "4".into()],
-            vec!["Cagayan Valley".into(), "1".into(), "3".into(), "5".into()],
-        ];
-        assert!(!is_page_number_toc(&cells));
-    }
-
-    #[test]
-    fn page_number_toc_needs_page_number_last_column() {
-        // Last column is prose, not page numbers.
-        let cells = vec![
-            vec!["Section A".into(), "see appendix".into()],
-            vec!["Section B".into(), "see notes".into()],
-            vec!["Section C".into(), "later".into()],
-            vec!["Section D".into(), "TBD".into()],
-        ];
-        assert!(!is_page_number_toc(&cells));
-    }
 }
@@ -226,67 +226,6 @@ pub struct RectHintRegion {
 /// Also returns hint regions: bounding boxes of cell-sized rects from clusters
 /// that failed full grid validation.  These can be used to scope heuristic
 /// detection and prevent unrelated items from being merged into tables.
-/// Bounding boxes of chart-bar clusters on the page. Text inside these
-/// regions (axis labels, data values, legends) belongs to a figure and must
-/// not be gridded into a table by any detection strategy.
-pub fn detect_chart_regions(
-    items: &[TextItem],
-    rects: &[PdfRect],
-    page: u32,
-) -> Vec<(f32, f32, f32, f32)> {
-    // Match detect_tables_from_rects: image placeholders are not text and
-    // would defeat the bar-content check.
-    let items_owned: Vec<TextItem> = items
-        .iter()
-        .filter(|i| crate::extractor::is_text_layout_item(i))
-        .cloned()
-        .collect();
-    let items = items_owned.as_slice();
-    let page_rects: Vec<(f32, f32, f32, f32)> = rects
-        .iter()
-        .filter(|r| r.page == page)
-        .map(|r| {
-            let (x, w) = if r.width < 0.0 {
-                (r.x + r.width, -r.width)
-            } else {
-                (r.x, r.width)
-            };
-            let (y, h) = if r.height < 0.0 {
-                (r.y + r.height, -r.height)
-            } else {
-                (r.y, r.height)
-            };
-            (x, y, w, h)
-        })
-        // Origin-anchored page backgrounds/clipping paths are never chart
-        // geometry, and letting one bridge into a bar cluster would inflate
-        // the region to the whole page.
-        .filter(|&(x, y, w, h)| w >= 5.0 && h >= 5.0 && !(x < 5.0 && y < 5.0))
-        .collect();
-    if page_rects.len() < 6 {
-        return Vec::new();
-    }
-    let mut regions = Vec::new();
-    for cluster in &cluster_rects(&page_rects, 3.0, 6) {
-        let group: Vec<(f32, f32, f32, f32)> = cluster.iter().map(|&i| page_rects[i]).collect();
-        if is_chart_bar_cluster(items, &group, page) {
-            let bbox = group.iter().fold(
-                (
-                    f32::INFINITY,
-                    f32::INFINITY,
-                    f32::NEG_INFINITY,
-                    f32::NEG_INFINITY,
-                ),
-                |(x0, y0, x1, y1), &(x, y, w, h)| {
-                    (x0.min(x), y0.min(y), x1.max(x + w), y1.max(y + h))
-                },
-            );
-            regions.push(bbox);
-        }
-    }
-    regions
-}
-
 pub fn detect_tables_from_rects(
    items: &[TextItem],
    rects: &[PdfRect],
@@ -440,29 +379,13 @@ pub fn detect_tables_from_rects(
            .collect();

        debug!("page {}: {} clusters with >= 6 rects", page, clusters.len());
-        let mut chart_cluster_ids: Vec<usize> = Vec::new();
-        for (cluster_id, cluster_indices) in clusters.iter().enumerate() {
+        for cluster_indices in &clusters {
            let group_rects: Vec<(f32, f32, f32, f32)> =
                cluster_indices.iter().map(|&i| page_rects[i]).collect();
-            // Chart bars are neither table cells nor a hint region — gridding
-            // a chart's axis labels scrambles the page. Skip the cluster
-            // entirely so it can't reach any detector, the merged fallback,
-            // or the hint fallback.
-            if is_chart_bar_cluster(items, &group_rects, page) {
-                debug!(
-                    "page {}: skipping chart-bar cluster ({} rects)",
-                    page,
-                    group_rects.len()
-                );
-                chart_cluster_ids.push(cluster_id);
-                continue;
-            }
            if let Some(table) = detect_table_from_rect_group(items, &group_rects, page) {
                tables.push(table);
            } else if let Some(table) = detect_row_stripe_table(items, &group_rects, page) {
                tables.push(table);
-            } else if let Some(table) = detect_stacked_box_table(items, &group_rects, page) {
-                tables.push(table);
            } else if let Some((left, right)) = split_wide_cluster(&group_rects, 15.0, 6) {
                // Cluster was too wide — retry each half independently
                debug!(
@@ -496,19 +419,12 @@ pub fn detect_tables_from_rects(
        // text-based column detection.
        let only_narrow = !tables.is_empty() && tables.iter().all(|t| t.columns.len() <= 3);
        if tables.is_empty() || only_narrow {
-            // Chart clusters stay out of the merge as well.
-            let table_clusters: Vec<&Vec<usize>> = clusters
-                .iter()
-                .enumerate()
-                .filter(|(id, _)| !chart_cluster_ids.contains(id))
-                .map(|(_, c)| c)
-                .collect();
-            let total_clustered: usize = table_clusters.iter().map(|c| c.len()).sum();
-            if table_clusters.len() >= 3 && total_clustered >= 50 {
+            let total_clustered: usize = clusters.iter().map(|c| c.len()).sum();
+            if clusters.len() >= 3 && total_clustered >= 50 {
                debug!(
                    "page {}: trying merged-cluster fallback ({} clusters, {} rects{})",
                    page,
-                    table_clusters.len(),
+                    clusters.len(),
                    total_clustered,
                    if only_narrow {
                        ", replacing narrow tables"
@@ -516,7 +432,7 @@ pub fn detect_tables_from_rects(
                        ""
                    }
                );
-                let all_cluster_rects: Vec<(f32, f32, f32, f32)> = table_clusters
+                let all_cluster_rects: Vec<(f32, f32, f32, f32)> = clusters
                    .iter()
                    .flat_map(|idxs| idxs.iter().map(|&i| page_rects[i]))
                    .collect();
@@ -575,14 +491,6 @@ pub fn detect_tables_from_rects(
        }
    }

-    // NOTE: 3-5 box stacks never reach detect_stacked_box_table — the main
-    // loop requires >=6-rect clusters (and a >=6-rect page). This is a
-    // deliberate precision gate: routing smaller clusters through the
-    // detector was tried and regressed four pdf-evals documents (striped
-    // bullet lists, wrapped regulation text, stats-table columns) while
-    // improving nothing — with so few boxes the anti-prose guards have too
-    // little signal to discriminate. See stacked_box_three_rows_below_
-    // cluster_minimum for the pinned behavior.
    if tables.is_empty() {
        // When no tables detected but clusters exist, generate XY hint regions
        // from cluster bounding boxes to scope heuristic table detection.
@@ -723,240 +631,6 @@ pub fn detect_tables_from_rects(
 /// overlap or are close (gap < 50pt).  This handles calendar-style layouts where a
 /// month zone's decorative rects split into 2-3 adjacent clusters with small X gaps.
 /// Runs iteratively until no more merges occur.
-/// Detect a single-column table drawn as a vertical stack of boxes, each
-/// holding one short line of text (framework/step lists on slide-style
-/// pages). The normal grid path rejects these — one column means only two
-/// x-edges — so the rows would otherwise flow into surrounding prose as a
-/// run-on paragraph.
-fn detect_stacked_box_table(
-    items: &[TextItem],
-    group_rects: &[(f32, f32, f32, f32)],
-    page: u32,
-) -> Option<Table> {
-    // Candidate row boxes: single-text-line height, substantial width.
-    let cands: Vec<(f32, f32, f32, f32)> = group_rects
-        .iter()
-        .copied()
-        .filter(|&(_, _, w, h)| w >= 100.0 && (8.0..=80.0).contains(&h))
-        .collect();
-    // The row boxes form the largest family of same-width, x-aligned rects
-    // (backgrounds and decor have their own geometry and stay out).
-    let mut boxes: Vec<(f32, f32, f32, f32)> = Vec::new();
-    for &anchor in &cands {
-        let family: Vec<(f32, f32, f32, f32)> = cands
-            .iter()
-            .copied()
-            .filter(|&(x, _, w, h)| {
-                (x - anchor.0).abs() <= 12.0
-                    && (w - anchor.2).abs() <= anchor.2 * 0.15
-                    && (h - anchor.3).abs() <= anchor.3 * 0.3
-            })
-            .collect();
-        if family.len() > boxes.len() {
-            boxes = family;
-        }
-    }
-    if boxes.len() < 3 {
-        return None;
-    }
-    // Boxes flanked at the same y-level — by other rects or by text outside
-    // the family's x-range — are one column of a wider structure. Leave
-    // those to the grid/cell-rect paths instead of collapsing to one column.
-    let flanked = boxes
-        .iter()
-        .filter(|&&(bx, by, bw, bh)| {
-            let rect_sibling = group_rects.iter().any(|&(ox, oy, ow, oh)| {
-                let y_overlap = (by + bh).min(oy + oh) - by.max(oy);
-                oh >= 8.0
-                    && y_overlap > bh * 0.5
-                    && (ox + ow <= bx + 2.0 || ox >= bx + bw - 2.0)
-                    && ow >= 30.0
-            });
-            let text_sibling = items.iter().any(|it| {
-                let cx = it.x + it.width / 2.0;
-                it.page == page
-                    && it.y >= by - 2.0
-                    && it.y <= by + bh + 2.0
-                    && (cx < bx - 5.0 || cx > bx + bw + 5.0)
-                    && it.width >= 10.0
-            });
-            rect_sibling || text_sibling
-        })
-        .count();
-    if flanked * 3 >= boxes.len() {
-        debug!(
-            "  stacked-box rejected: {}/{} boxes flanked by rects or text",
-            flanked,
-            boxes.len()
-        );
-        return None;
-    }
-    boxes.sort_by(|a, b| b.1.total_cmp(&a.1)); // top to bottom (descending y)
-
-    // Merge duplicates (border + fill pairs draw the same box twice), then
-    // require a clean vertical stack: no overlaps beyond a small tolerance.
-    boxes.dedup_by(|a, b| (a.1 - b.1).abs() <= 3.0 && (a.3 - b.3).abs() <= 6.0);
-    if boxes.len() < 3 {
-        return None;
-    }
-    for w in boxes.windows(2) {
-        let (upper, lower) = (w[0], w[1]);
-        let upper_bottom = upper.1;
-        let lower_top = lower.1 + lower.3;
-        if lower_top > upper_bottom + 4.0 {
-            return None; // vertical overlap — not a stack
-        }
-        if upper_bottom - lower_top > upper.3.max(lower.3) {
-            return None; // gap larger than a row — unrelated boxes
-        }
-    }
-
-    // Assign items to boxes; every box needs text and cells must stay short
-    // (prose paragraphs inside stacked frames are page decor, not a table).
-    let mut cells: Vec<Vec<String>> = Vec::with_capacity(boxes.len());
-    let mut item_indices: Vec<usize> = Vec::new();
-    let mut multi_run_boxes = 0usize;
-    for &(bx, by, bw, bh) in &boxes {
-        let mut in_box: Vec<(usize, &TextItem)> = items
-            .iter()
-            .enumerate()
-            .filter(|(_, it)| {
-                it.page == page
-                    && it.y >= by - 2.0
-                    && it.y <= by + bh + 2.0
-                    && it.x + it.width / 2.0 >= bx
-                    && it.x + it.width / 2.0 <= bx + bw
-            })
-            .collect();
-        if in_box.is_empty() {
-            return None;
-        }
-        in_box.sort_by(|a, b| {
-            b.1.y
-                .partial_cmp(&a.1.y)
-                .unwrap_or(std::cmp::Ordering::Equal)
-                .then_with(|| {
-                    a.1.x
-                        .partial_cmp(&b.1.x)
-                        .unwrap_or(std::cmp::Ordering::Equal)
-                })
-        });
-        // Count horizontally separated text runs inside the box. A single
-        // list row flows as one run; two-plus runs across most boxes means
-        // multi-column content (striped prose or a real grid) that must not
-        // collapse into a one-column table. Same-baseline only: boxed
-        // display/diagram rows legitimately scatter segments at mixed
-        // baselines, and those must stay one row.
-        let mut runs = 1usize;
-        for pair in in_box.windows(2) {
-            let (prev, item) = (pair[0].1, pair[1].1);
-            if (prev.y - item.y).abs() <= 2.0 && item.x - (prev.x + prev.width) > 15.0 {
-                runs += 1;
-            }
-        }
-        if runs >= 2 {
-            multi_run_boxes += 1;
-        }
-        let text = in_box
-            .iter()
-            .map(|(_, it)| it.text.trim())
-            .filter(|t| !t.is_empty())
-            .collect::<Vec<_>>()
-            .join(" ");
-        if text.is_empty() || text.chars().count() > 120 {
-            return None;
-        }
-        item_indices.extend(in_box.iter().map(|(i, _)| *i));
-        cells.push(vec![text]);
-    }
-    if multi_run_boxes * 2 >= boxes.len() {
-        debug!(
-            "  stacked-box rejected: {}/{} boxes hold multiple text runs",
-            multi_run_boxes,
-            boxes.len()
-        );
-        return None;
-    }
-
-    // Reject prose behind per-line stripe rects: sentence fragments flowing
-    // across rows read as long, function-word-dense cells, while genuine
-    // list-table rows are short labels/titles.
-    const PROSE_WORDS: &[&str] = &[
-        "a", "an", "the", "of", "to", "is", "was", "are", "were", "be", "been", "in", "on", "at",
-        "with", "for", "by", "as", "and", "or", "but", "this", "that", "these", "those", "from",
-        "into", "has", "have", "had", "not", "it", "its", "their", "such", "shall", "which",
-    ];
-    let total_chars: usize = cells.iter().map(|r| r[0].chars().count()).sum();
-    let mean_chars = total_chars / cells.len().max(1);
-    let prose_cells = cells
-        .iter()
-        .filter(|r| {
-            r[0].to_ascii_lowercase()
-                .split(|c: char| !c.is_ascii_alphabetic() && c != '\'')
-                .any(|w| PROSE_WORDS.contains(&w))
-        })
-        .count();
-    if mean_chars > 60 && prose_cells * 5 >= cells.len() * 2 {
-        debug!(
-            "  stacked-box rejected: prose rows (mean {} chars, prose words {}/{})",
-            mean_chars,
-            prose_cells,
-            cells.len()
-        );
-        return None;
-    }
-    // Sentences wrapping across stripe rects: a row ending with a comma, or
-    // a row without terminal punctuation followed by a row starting
-    // lowercase, is mid-sentence flow — not list rows. Genuine label/title
-    // rows produce none of these, so even a small share is disqualifying.
-    let continuations = cells
-        .windows(2)
-        .filter(|pair| {
-            let prev = pair[0][0].trim_end();
-            let next = pair[1][0].trim_start();
-            let prev_open = !prev.ends_with(['.', ':', ';', '!', '?', ')', '"', '%']);
-            let next_lower = next.chars().next().is_some_and(|c| c.is_lowercase());
-            prev.ends_with(',') || (prev_open && next_lower)
-        })
-        .count();
-    if cells.len() >= 2 && (continuations >= 2 || continuations * 4 >= cells.len() - 1) {
-        debug!(
-            "  stacked-box rejected: {}/{} row pairs continue a sentence",
-            continuations,
-            cells.len() - 1
-        );
-        return None;
-    }
-    // Numbered/lettered list items behind decorative stripes stay lists:
-    // "1) content..." / "(ii) content..." / "a. content...".
-    let list_marker = |t: &str| {
-        let t = t.trim_start().strip_prefix('(').unwrap_or(t.trim_start());
-        let marker_len = t.chars().take_while(|c| c.is_ascii_alphanumeric()).count();
-        (1..=3).contains(&marker_len)
-            && t.chars()
-                .nth(marker_len)
-                .is_some_and(|c| c == ')' || c == '.')
-    };
-    let list_rows = cells.iter().filter(|r| list_marker(&r[0])).count();
-    if list_rows * 2 >= cells.len() {
-        debug!(
-            "  stacked-box rejected: {}/{} rows are numbered list items",
-            list_rows,
-            cells.len()
-        );
-        return None;
-    }
-
-    debug!(
-        "page {}: stacked-box table: {} single-column rows",
-        page,
-        cells.len()
-    );
-    let columns = vec![boxes[0].0 + boxes[0].2 / 2.0];
-    let rows: Vec<f32> = boxes.iter().map(|b| b.1 + b.3 / 2.0).collect();
-    Some(Table::new(columns, rows, cells, item_indices))
-}
-
 fn merge_overlapping_hints(mut hints: Vec<RectHintRegion>) -> Vec<RectHintRegion> {
    if hints.len() <= 1 {
        return hints;
@@ -1909,118 +1583,6 @@ fn row_stripe_is_sparse_prose_outline(cells: &[Vec<String>]) -> bool {
 /// Uses rect Y-edges for row boundaries and text X-position clustering for
 /// columns.  Handles tables with cell backgrounds that don't form a clean
 /// X-edge grid (variable column widths, decorative fills).
-/// Chart-bar signature: ≥3 rects sharing an aligned bottom edge (the axis),
-/// with similar widths (bars) but strongly varying heights (data-driven),
-/// holding at most a single numeric data label each. Bar charts drawn as
-/// filled rects otherwise read as cell rects and grid their axis labels
-/// into a phantom table. The mirrored check catches horizontal bar charts.
-fn is_chart_bar_cluster(
-    items: &[TextItem],
-    group_rects: &[(f32, f32, f32, f32)],
-    page: u32,
-) -> bool {
-    let numeric_or_empty = |(rx, ry, rw, rh): (f32, f32, f32, f32)| {
-        let inside: Vec<&TextItem> = items
-            .iter()
-            .filter(|it| {
-                let cx = it.x + it.width / 2.0;
-                it.page == page && cx >= rx && cx <= rx + rw && it.y >= ry && it.y <= ry + rh
-            })
-            .collect();
-        // Any number of numeric data labels is chart-like; a single run of
-        // word text inside means a table cell.
-        inside.iter().all(|it| {
-            let t = it.text.trim();
-            let data = t
-                .chars()
-                .filter(|c| c.is_ascii_digit() || ",.%-".contains(*c))
-                .count();
-            t.is_empty() || data * 2 >= t.chars().count()
-        })
-    };
-
-    // Bars: the dominant equal-width family, arranged in >=2 spaced columns
-    // (inter-column gap >= half a bar width — table cell rects touch), with
-    // data-driven height variation (checkbox/cell grids are uniform).
-    // Mirrored predicate catches horizontal bar charts.
-    let bar_family = |pos: fn(&(f32, f32, f32, f32)) -> f32,
-                      breadth: fn(&(f32, f32, f32, f32)) -> f32,
-                      length: fn(&(f32, f32, f32, f32)) -> f32,
-                      along: fn(&(f32, f32, f32, f32)) -> f32| {
-        group_rects.iter().any(|anchor| {
-            let bw = breadth(anchor);
-            if bw <= 0.0 {
-                return false;
-            }
-            let family: Vec<&(f32, f32, f32, f32)> = group_rects
-                .iter()
-                .filter(|r| {
-                    (breadth(r) - bw).abs() <= (bw * 0.1).max(2.0)
-                        && length(r) > 0.0
-                        && length(r) < bw * 20.0
-                })
-                .collect();
-            if family.len() < 4 {
-                return false;
-            }
-            // Distinct positions along the axis (bar columns).
-            let mut positions: Vec<f32> = Vec::new();
-            for r in &family {
-                let p = pos(r);
-                if !positions.iter().any(|&q| (q - p).abs() <= 2.0) {
-                    positions.push(p);
-                }
-            }
-            if positions.len() < 2 {
-                return false;
-            }
-            positions.sort_by(|a, b| a.total_cmp(b));
-            let min_gap = positions
-                .windows(2)
-                .map(|w| w[1] - w[0] - bw)
-                .fold(f32::INFINITY, f32::min);
-            if min_gap < bw * 0.5 {
-                return false;
-            }
-            // Data-driven variation along the bar direction.
-            let len_min = family
-                .iter()
-                .map(|r| length(r))
-                .fold(f32::INFINITY, f32::min);
-            let len_max = family
-                .iter()
-                .map(|r| length(r))
-                .fold(f32::NEG_INFINITY, f32::max);
-            if len_max < len_min * 1.3 {
-                return false;
-            }
-            // Grid rows disguise as bars: a table's cell rects have same-y,
-            // same-height partners in other columns (uniform row heights).
-            // Chart segments start where the previous datum ended, so their
-            // extents rarely pair up across positions.
-            let matched = family
-                .iter()
-                .filter(|r| {
-                    family.iter().any(|s| {
-                        (pos(s) - pos(r)).abs() > 2.0
-                            && (along(s) - along(r)).abs() <= 3.0
-                            && (length(s) - length(r)).abs() <= 3.0
-                    })
-                })
-                .count();
-            if matched * 5 >= family.len() * 3 {
-                return false;
-            }
-            family.iter().filter(|r| numeric_or_empty(***r)).count() * 3 >= family.len() * 2
-        })
-    };
-
-    // vertical bars: position/breadth = x/width, length = height, along = y
-    bar_family(|r| r.0, |r| r.2, |r| r.3, |r| r.1)
-        // horizontal bars: position/breadth = y/height, length = width, along = x
-        || bar_family(|r| r.1, |r| r.3, |r| r.2, |r| r.0)
-}
-
 fn detect_row_stripe_table_from_cell_rects(
    items: &[TextItem],
    group_rects: &[(f32, f32, f32, f32)],
@@ -2805,29 +2367,7 @@ fn detect_merged_cluster_table(
 /// suitable for rect-backed tables where we already know tabular structure exists
 /// (no need for anti-paragraph safeguards).
 fn cluster_x_positions(items: &[(usize, &TextItem)], min_threshold: f32) -> Vec<f32> {
-    // Column edges come from where text STARTS. An item whose left edge hugs
-    // the previous item's right edge on the same line is a continuation run
-    // (style boundary, script change, underline split) — feeding its x-start
-    // in here fabricates a phantom column mid-cell.
-    let mut sorted: Vec<&TextItem> = items.iter().map(|&(_, i)| i).collect();
-    sorted.sort_by(|a, b| a.y.total_cmp(&b.y).then(a.x.total_cmp(&b.x)));
-    let mut x_positions: Vec<f32> = Vec::with_capacity(sorted.len());
-    for (idx, item) in sorted.iter().enumerate() {
-        let is_continuation = idx > 0 && {
-            let prev = sorted[idx - 1];
-            // Style/underline splits leave runs that TOUCH (gap ~0); real
-            // cell boundaries in even the tightest tables keep a visible
-            // gap. 2pt separates the two without eating dense-table columns.
-            // The negative side is bounded too: text overhanging from an
-            // adjacent cell overlaps by far more than italic kerning ever
-            // does, and must still start its own column.
-            let gap = item.x - (prev.x + prev.width);
-            (prev.y - item.y).abs() <= 2.0 && gap < 2.0 && gap > -4.0 && item.x >= prev.x
-        };
-        if !is_continuation {
-            x_positions.push(item.x);
-        }
-    }
+    let mut x_positions: Vec<f32> = items.iter().map(|(_, i)| i.x).collect();
    x_positions.sort_by(|a, b| a.total_cmp(b));

    if x_positions.is_empty() {
@@ -2896,173 +2436,6 @@ mod tests {
        }
    }

-    // --- is_chart_bar_cluster / detect_chart_regions ---
-
-    /// Stacked bar chart: frame + 3 columns of equal-width segments with
-    /// data-driven heights, holding numeric labels.
-    fn chart_rects() -> Vec<PdfRect> {
-        let mut rects = vec![PdfRect {
-            x: 126.0,
-            y: 548.0,
-            width: 396.0,
-            height: 216.0,
-            page: 1,
-        }];
-        let bars = [
-            (208.0, 618.0, 59.0),
-            (208.0, 661.0, 39.0),
-            (208.0, 696.0, 37.0),
-            (313.0, 618.0, 67.0),
-            (313.0, 670.0, 49.0),
-            (313.0, 691.0, 42.0),
-            (419.0, 618.0, 73.0),
-            (419.0, 684.0, 37.0),
-            (419.0, 708.0, 25.0),
-        ];
-        for (x, y, h) in bars {
-            rects.push(PdfRect {
-                x,
-                y,
-                width: 46.0,
-                height: h,
-                page: 1,
-            });
-        }
-        rects
-    }
-
-    #[test]
-    fn chart_bars_produce_region_not_table() {
-        let items: Vec<TextItem> = [
-            ("38", 228.0, 638.0),
-            ("30", 228.0, 676.0),
-            ("46", 333.0, 643.0),
-            ("17", 333.0, 679.0),
-            ("57", 438.0, 650.0),
-            ("20", 438.0, 694.0),
-        ]
-        .iter()
-        .map(|&(t, x, y)| make_item(t, x, y, 9.0))
-        .collect();
-        let rects = chart_rects();
-        let regions = detect_chart_regions(&items, &rects, 1);
-        assert_eq!(regions.len(), 1, "expected one chart region");
-        let (tables, hints) = detect_tables_from_rects(&items, &rects, 1);
-        assert!(tables.is_empty(), "chart bars must not become a table");
-        assert!(hints.is_empty(), "chart bars must not become a hint region");
-    }
-
-    #[test]
-    fn uniform_cell_grid_is_not_a_chart() {
-        // Touching, uniform-height cell rects (a real table) must not match:
-        // no inter-column gap and no bar-length variation.
-        let mut rects = Vec::new();
-        for row in 0..4 {
-            for col in 0..3 {
-                rects.push(PdfRect {
-                    x: 100.0 + col as f32 * 80.0,
-                    y: 600.0 - row as f32 * 20.0,
-                    width: 80.0,
-                    height: 20.0,
-                    page: 1,
-                });
-            }
-        }
-        let items: Vec<TextItem> = (0..4)
-            .flat_map(|r| {
-                (0..3).map(move |c| (100.0 + c as f32 * 80.0 + 10.0, 605.0 - r as f32 * 20.0))
-            })
-            .map(|(x, y)| make_item("42", x, y, 9.0))
-            .collect();
-        assert!(detect_chart_regions(&items, &rects, 1).is_empty());
-    }
-
-    // --- detect_stacked_box_table ---
-
-    /// N stacked boxes at x=100, w=300, h=22, top-to-bottom from y=600.
-    fn stacked_boxes(n: usize) -> Vec<(f32, f32, f32, f32)> {
-        (0..n)
-            .map(|i| (100.0, 600.0 - i as f32 * 22.0, 300.0, 22.0))
-            .collect()
-    }
-
-    #[test]
-    fn stacked_box_list_becomes_single_column_table() {
-        let rects = stacked_boxes(5);
-        let items: Vec<TextItem> = (0..5)
-            .map(|i| make_item("#1: Recycling Basics", 120.0, 605.0 - i as f32 * 22.0, 10.0))
-            .collect();
-        let table = detect_stacked_box_table(&items, &rects, 1).expect("stacked-box table");
-        assert_eq!(table.cells.len(), 5);
-        assert_eq!(table.cells[0].len(), 1);
-    }
-
-    #[test]
-    fn stacked_box_rejects_wrapped_sentences() {
-        // Line stripes behind flowing prose: rows continue mid-sentence.
-        let rects = stacked_boxes(4);
-        let texts = [
-            "the provisions of this section apply to",
-            "companies subject to tax under those",
-            "sections, except that the copy of the",
-            "annual statement must be retained.",
-        ];
-        let items: Vec<TextItem> = texts
-            .iter()
-            .enumerate()
-            .map(|(i, t)| make_item(t, 120.0, 605.0 - i as f32 * 22.0, 10.0))
-            .collect();
-        assert!(detect_stacked_box_table(&items, &rects, 1).is_none());
-    }
-
-    #[test]
-    fn stacked_box_rejects_flanking_text() {
-        // A ruled label column with plain-text data columns beside it is one
-        // column of a wider table, not a single-column list.
-        let rects = stacked_boxes(4);
-        let mut items = Vec::new();
-        for i in 0..4 {
-            let y = 605.0 - i as f32 * 22.0;
-            items.push(make_item("Section 1.382", 120.0, y, 10.0));
-            items.push(make_item("removed text", 450.0, y, 10.0)); // beside the box
-        }
-        assert!(detect_stacked_box_table(&items, &rects, 1).is_none());
-    }
-
-    #[test]
-    fn stacked_box_rejects_two_column_content() {
-        // Boxes holding two separated runs are striped multi-column content.
-        let rects = stacked_boxes(4);
-        let mut items = Vec::new();
-        for i in 0..4 {
-            let y = 605.0 - i as f32 * 22.0;
-            let mut left = make_item("left words", 110.0, y, 10.0);
-            left.width = 60.0;
-            let mut right = make_item("right words", 250.0, y, 10.0);
-            right.width = 60.0;
-            items.push(left);
-            items.push(right);
-        }
-        assert!(detect_stacked_box_table(&items, &rects, 1).is_none());
-    }
-
-    #[test]
-    fn stacked_box_rejects_mixed_height_stripes() {
-        // Mixed 13/27pt stripes (redline markup) — height uniformity splits
-        // the family and the gap check rejects the remainder.
-        let mut rects = Vec::new();
-        let mut y = 600.0;
-        for i in 0..8 {
-            let h = if i % 3 == 0 { 27.0 } else { 13.5 };
-            y -= h;
-            rects.push((100.0, y, 300.0, h));
-        }
-        let items: Vec<TextItem> = (0..8)
-            .map(|i| make_item("PART 602 OMB CONTROL", 120.0, 590.0 - i as f32 * 18.0, 10.0))
-            .collect();
-        assert!(detect_stacked_box_table(&items, &rects, 1).is_none());
-    }
-
    // --- has_dominant_prose_cell ---

    fn cells_of(rows: &[&[&str]]) -> Vec<Vec<String>> {
@@ -4085,49 +3458,6 @@ mod tests {
        assert!((merged[0].x_right - 340.0).abs() < 0.01);
    }

-    #[test]
-    fn stacked_box_three_rows_below_cluster_minimum() {
-        // Pins a deliberate precision gate: a 3-box stack stays below the
-        // main loop's 6-rect cluster minimum and is NOT detected end-to-end.
-        // Routing smaller clusters through detect_stacked_box_table was
-        // tried and regressed four pdf-evals documents (striped bullet
-        // lists, wrapped regulation text, stats-table columns) with no
-        // corpus gains — too few boxes for the anti-prose guards to work.
-        // If this ever becomes worth revisiting, the guards need stronger
-        // signals first; flipping this assertion is the entry point.
-        let mut rects: Vec<PdfRect> = (0..3)
-            .map(|i| PdfRect {
-                x: 100.0,
-                y: 600.0 - i as f32 * 22.0,
-                width: 300.0,
-                height: 22.0,
-                page: 1,
-            })
-            .collect();
-        // Unrelated scattered rects push the page past the 6-rect page gate
-        // so the run reaches clustering, while the 3-box stack itself stays
-        // below the 6-rect cluster minimum.
-        for i in 0..4 {
-            rects.push(PdfRect {
-                x: 100.0 + i as f32 * 120.0,
-                y: 100.0,
-                width: 40.0,
-                height: 15.0,
-                page: 1,
-            });
-        }
-        let items: Vec<TextItem> = ["Step One: Plan", "Step Two: Build", "Step Three: Ship"]
-            .iter()
-            .enumerate()
-            .map(|(i, t)| make_item(t, 120.0, 605.0 - i as f32 * 22.0, 10.0))
-            .collect();
-        let (tables, _) = detect_tables_from_rects(&items, &rects, 1);
-        assert!(
-            tables.is_empty(),
-            "3-box stacks are intentionally below the detection floor"
-        );
-    }
-
    #[test]
    fn failed_cluster_generates_hint_with_items() {
        // A cluster of rects forming an outer border (2 x-edges after snapping)
@@ -123,7 +123,6 @@ fn format_toc_as_list(cells: &[Vec<String>], footnotes: &[String]) -> String {

 /// True when the cell looks like a page number.  Accepts:
 ///   - plain digit tokens: "42", "86 86"
-///   - canonical roman numerals (front-matter pages): "vii", "ix", "xii"
 ///   - dashed section-page IDs: "5-21", "A-1", "B--3", "TC-2" (common in
 ///     technical manuals)
 fn is_page_number_cell(cell: &str) -> bool {
@@ -139,9 +138,6 @@ fn is_page_number_cell(cell: &str) -> bool {
        if all_digits {
            return t.len() <= 4;
        }
-        if super::canonical_roman_value(t).is_some() {
-            return true;
-        }
        // Section-page form: uppercase letters, digits, dashes; at least
        // one digit present.
        t.chars()
@@ -4,7 +4,7 @@

 mod detect_heuristic;
 mod detect_lines;
-pub(crate) mod detect_rects;
+mod detect_rects;
 mod detect_struct;
 mod financial;
 mod format;
@@ -15,7 +15,7 @@ pub use detect_heuristic::detect_tables;
 pub(crate) use detect_heuristic::is_table_of_contents;
 pub use detect_lines::detect_tables_from_lines;
 pub(crate) use detect_rects::cluster_rects;
-pub use detect_rects::{detect_chart_regions, detect_tables_from_rects, RectHintRegion};
+pub use detect_rects::{detect_tables_from_rects, RectHintRegion};
 pub use detect_struct::detect_tables_from_struct_tree;
 pub use format::table_to_markdown;
 pub use structured::{cells_to_markdown, StructuredCell};
@@ -177,60 +177,6 @@ pub(crate) fn try_build_rect_guided_table(
    ))
 }

-/// Canonical lowercase roman numeral for `n` (the i/v/x/l/c range).
-pub(super) fn to_roman_lower(mut n: u32) -> String {
-    const TABLE: [(u32, &str); 9] = [
-        (100, "c"),
-        (90, "xc"),
-        (50, "l"),
-        (40, "xl"),
-        (10, "x"),
-        (9, "ix"),
-        (5, "v"),
-        (4, "iv"),
-        (1, "i"),
-    ];
-    let mut out = String::new();
-    for (val, sym) in TABLE {
-        while n >= val {
-            out.push_str(sym);
-            n -= val;
-        }
-    }
-    out
-}
-
-/// Parse a *canonical* roman numeral (i/v/x/l/c range, ≤8 chars) to its value.
-/// Returns `None` for non-canonical strings, so ordinary words made of those
-/// letters — "civil", "mix", "ill" — are not mistaken for numbers. Shared by
-/// the TOC detector and the TOC formatter so the two stay in sync.
-pub(super) fn canonical_roman_value(token: &str) -> Option<u32> {
-    let lower = token.trim().to_ascii_lowercase();
-    if lower.is_empty() || lower.len() > 8 || !lower.chars().all(|c| "ivxlc".contains(c)) {
-        return None;
-    }
-    let mut total = 0i32;
-    let mut prev = 0i32;
-    for c in lower.chars().rev() {
-        let v = match c {
-            'i' => 1,
-            'v' => 5,
-            'x' => 10,
-            'l' => 50,
-            'c' => 100,
-            _ => return None,
-        };
-        if v < prev {
-            total -= v;
-        } else {
-            total += v;
-            prev = v;
-        }
-    }
-    let value = u32::try_from(total).ok().filter(|&n| n > 0)?;
-    (to_roman_lower(value) == lower).then_some(value)
-}
-
 /// Split a TextItem whose text contains multiple whitespace-separated tokens
 /// (like "10 11 12 ... 31") into individual TextItems, each assigned to the
 /// nearest column boundary.
@@ -1102,7 +1102,6 @@ fn test_pages_needing_ocr_field_accessible() {
        title: None,
        ocr_recommended: false,
        pages_needing_ocr: Vec::new(),
-        ocr_reasons_by_page: std::collections::BTreeMap::new(),
    };
    assert!(detection_result.pages_needing_ocr.is_empty());

@@ -3607,45 +3606,3 @@ fn test_markdown_options_default_has_include_images_false() {
    let opts = MarkdownOptions::default();
    assert!(!opts.include_images);
 }
-
-#[test]
-fn encrypted_pdf_decrypts_with_correct_password() {
-    let path = "tests/fixtures/encrypted-secret123.pdf";
-
-    // No password: the file is encrypted and can't be read.
-    let no_pw = process_pdf_with_options(path, PdfOptions::new());
-    assert!(
-        matches!(no_pw, Err(PdfError::Encrypted)),
-        "expected Encrypted without a password, got {no_pw:?}"
-    );
-
-    // Wrong password: still rejected.
-    let wrong = process_pdf_with_options(path, PdfOptions::new().password("wrong"));
-    assert!(
-        matches!(wrong, Err(PdfError::Encrypted)),
-        "expected Encrypted with a wrong password, got {wrong:?}"
-    );
-
-    // Correct password: decrypts and extracts real content.
-    let ok = process_pdf_with_options(path, PdfOptions::new().password("secret123"))
-        .expect("correct password should decrypt");
-    let md = ok.markdown.unwrap_or_default();
-    // Assert a stable fixture token so a garbled-but-long extraction (the
-    // encrypted-stream regression this guards) still fails the test.
-    assert!(
-        md.contains("Procurement"),
-        "decrypted markdown should contain the fixture's real text, got {} chars",
-        md.len()
-    );
-}
-
-#[test]
-fn pdf_options_debug_redacts_password() {
-    let opts = PdfOptions::new().password("secret123");
-    let dbg = format!("{opts:?}");
-    assert!(
-        !dbg.contains("secret123"),
-        "password leaked in Debug: {dbg}"
-    );
-    assert!(dbg.contains("REDACTED"), "expected redaction marker: {dbg}");
-}
@@ -72,11 +72,10 @@ Month or shorter period in which tips were received **4** Net tips (lines **1 +

 forms simpler, we would be happy to hear from you. You can write to the Tax Forms Committee, Western Area Distribution Center, Rancho Cordova, CA 95743-0001. **Purpose.—**Use this form to report tips you receive to your employer. This includes cash tips, tips you receive from other employees, and credit card tips. You must report tips every month regardless of your total wages and tips for the year. However, you do not have to report tips to your employer for any month you received less than $20 in tips while working for that employer. Report tips by the 10th day of the month following the month that you receive them. If the 10th day is a Saturday, Sunday, or legal holiday, report tips by the next day that is not a Saturday, Sunday, or legal holiday. See **Pub. 531**, Reporting Tip Income, for more information. You can get additional copies of **Pub. 1244**, Employee’s Daily Record of Tips and Report to Employer, which contains both Forms 4070A and 4070, by calling 1-800-TAX-FORM (1-800-829-3676).

-<u>Instructions (continued)</u>
+**Instructions** *(continued)*

 **Unreported Tips.—**If you received tips of $20 or more for any month while working for one employer but did not report them to your employer, you must figure and pay social security and Medicare taxes on the unreported tips when you file your tax return. If you have unreported tips, you **must** use Form 1040 and **Form 4137,** Social Security and Medicare Tax on Unreported Tip Income, to report them. You may **not** use Form 1040A or 1040EZ. Employees subject to the Railroad Retirement Tax Act **cannot** use Form 4137 to pay railroad retirement tax on unreported tips. To get railroad retirement credit, you must report tips to your employer. If you do not report tips to your employer as required, you may be charged a penalty of 50% of the social security and Medicare taxes (or railroad retirement tax) due on the unreported tips unless there was reasonable cause for not reporting them. **Additional Information.—**Get **Pub. 531,** Reporting Tip Income, and Form 4137 for more information on tips. If you are an employee of certain large food or beverage establishments, see Pub. 531 for tip allocation rules. **Recordkeeping.—**If you do not keep a daily record of tips, you must keep other reliable proof of the tip income you received. This proof includes copies of restaurant bills and credit card charges that show amounts customers added as tips. Keep your tip income records for as long as the information on them may be needed in the administration of any Internal Revenue law.

 ### Instructions (continued)

 Use this space to total your tips for the year
-
@@ -1,8 +1,17 @@
-||||(e) [Reserved]. For further guidance, see §1.1563-3T(e)(1). Par. 50. Section 1.1563-3T is added to read as follows: §1.1563-3T Rules for determining stock ownership (temporary). (a) through (d)(2)(iii) [Reserved]. For further guidance, see §1.1563-3(a)|
-|---|---|---|---|
-||through (d)(2)(iii).|||
-||(iv)|Statement|. If the application of paragraph (d)(2)(ii) or (iii) of §1.1563-3 does not result in a corporation being treated as a component member of only one controlled group of corporations on a December 31, then such corporation will be treated as a component member of only one such group on such date. Such corporation may elect the group in which it is to be included by including on or with its income tax return a statement entitled, “STATEMENT TO ELECT CONTROLLED GROUP PURSUANT TO §1.1563-3T(d)(2)(iv).” The statement must include-- (A) A description of each of the controlled groups in which the corporation could be included. The description must include the name and employer identification number of each component member of each such group and the stock ownership of the component members of each such group; and (B) The following representation: [INSERT NAME AND EMPLOYER IDENTIFICATION NUMBER OF CORPORATION] ELECTS TO BE TREATED AS A COMPONENT MEMBER OF THE [INSERT DESIGNATION OF GROUP].|
-||(v)|Election|-- (A) Election filed. An election filed under paragraph (d)(2)(iv) of this section is irrevocable and effective until paragraph (d)(2)(ii) or (iii) of §1.1563-3 applies or until a change in the stock ownership of the corporation results in|
+(e) [Reserved]. For further guidance, see §1.1563-3T(e)(1). Par. 50. Section 1.1563-3T is added to read as follows:
+<u>§1.1563-3T Rules for determining stock ownership (temporary)</u>.
+
+(a) through (d)(2)(iii) [Reserved]. For further guidance, see §1.1563-3(a)
+through (d)(2)(iii). (iv) <u>Statement</u>. If the application of paragraph (d)(2)(ii) or (iii) of §1.1563-3 does not result in a corporation being treated as a component member of only one controlled group of corporations on a December 31, then such corporation will be treated as a component member of only one such group on such date. Such corporation may elect the group in which it is to be included by including on or with its income tax return a statement entitled, “STATEMENT TO ELECT CONTROLLED GROUP PURSUANT TO §1.1563-3T(d)(2)(iv).” The statement must include--
+
+(A) A description of each of the controlled groups in which the corporation
+could be included. The description must include the name and employer identification number of each component member of each such group and the stock ownership of the component members of each such group; and
+
+(B) The following representation: [INSERT NAME AND EMPLOYER
+IDENTIFICATION NUMBER OF CORPORATION] ELECTS TO BE TREATED AS A COMPONENT MEMBER OF THE [INSERT DESIGNATION OF GROUP].
+
+(v) <u>Election</u>-- (A) <u>Election filed</u>. An election filed under paragraph (d)(2)(iv) of
+this section is irrevocable and effective until paragraph (d)(2)(ii) or (iii) of §1.1563-3 applies or until a change in the stock ownership of the corporation results in

 |termination of membership in the controlled group in which such corporation has||
 |---|---|
@@ -20,7 +29,7 @@
 Federal income tax return (including any amended return filed on or before the due date (including extensions) of such original return) timely filed on or after May 30,

 2006.
-(2) <u>Expiration date</u>. The applicability of this section will expire on May 26,
+(2) Expiration date. The applicability of this section will expire on May 26,
 2009. Par. 51. Section 1.6012-2 is amended by revising paragraph (c) and adding paragraph (k) to read as follows: <u>§1.6012-2 Corporations required to make returns of income</u>.
 * * * * *
 (c) [Reserved]. For further guidance, see §1.6012-2T(c).
@@ -43,9 +43,9 @@ l

 **Freon** **®** **12 Saturation Properties-Temperature Table**

-|Temp|Pressure||Volume||Density||Enthalpy|||Entropy|Temp|
-|---|---|---|---|---|---|---|---|---|---|---|---|
-|°C|[kPa]|[m³ Liquid v f|/kg] Vapour v g|[kg/m³ Liquid d f|] Vapour d g|Liquid H f|[kJ/kg] Latent H fg|Vapour H g|Liquid S f|[kJ/K-kg] Vapour S g|°C|
+|Temp|Pressure||Volume|||Density||Enthalpy|||Entropy|Temp|
+|---|---|---|---|---|---|---|---|---|---|---|---|---|
+|°C|[kPa]|[m³ Liquid v f|/kg]|Vapour v g|Liquid d f|[kg/m³] Vapour d g|Liquid H f|[kJ/kg] Latent H fg|Vapour H g|Liquid S f|[kJ/K-kg] Vapour S g|°C|

 |-100|1.2|0.0006|10.0000|1679.0|0.100|113.3|192.8|306.1|0.6077|1.7210|-100|
 |---|---|---|---|---|---|---|---|---|---|---|---|