refactor(vision): finalize OCR API

.gitattributes

@@ -1,2 +0,0 @@
-*.pdf binary
-tests/snapshots/*.md text eol=lf

.github/workflows/ci.yml

@@ -9,9 +9,6 @@ on:
 env:
   CARGO_TERM_COLOR: always
 
-permissions:
-  contents: read
-
 jobs:
   test:
     name: Test
@@ -71,12 +68,9 @@ jobs:
         with:
           key: clippy
 
-      - name: Run default clippy
+      - name: Run clippy
         run: cargo clippy -- -D warnings
 
-      - name: Run OCR clippy
-        run: cargo clippy --features ocr -- -D warnings
-
   build:
     name: Build
     runs-on: ${{ matrix.os }}
@@ -99,183 +93,6 @@ jobs:
       - name: Build
         run: cargo build --release --verbose
 
-  ocr:
-    name: OCR (${{ matrix.os }})
-    runs-on: ${{ matrix.os }}
-    strategy:
-      fail-fast: false
-      matrix:
-        os: [ubuntu-latest, macos-latest, windows-latest]
-    steps:
-      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
-
-      - name: Install Rust
-        uses: dtolnay/rust-toolchain@4cda84d5c5c54efe2404f9d843567869ab1699d4 # stable
-        with:
-          toolchain: stable
-
-      - name: Cache cargo
-        uses: Swatinem/rust-cache@c19371144df3bb44fab255c43d04cbc2ab54d1c4 # v2.9.1
-        with:
-          key: ocr-${{ matrix.os }}
-
-      - name: Test optional OCR feature
-        run: cargo test --features ocr
-
-  ocr-runtime:
-    name: OCR runtime smoke
-    runs-on: ubuntu-latest
-    timeout-minutes: 30
-    steps:
-      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
-
-      - name: Install Rust
-        uses: dtolnay/rust-toolchain@4cda84d5c5c54efe2404f9d843567869ab1699d4 # stable
-        with:
-          toolchain: stable
-
-      - uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7.0.0
-        with:
-          python-version: '3.12'
-
-      - uses: oven-sh/setup-bun@0c5077e51419868618aeaa5fe8019c62421857d6 # v2.2.0
-        with:
-          bun-version: latest
-
-      - name: Cache cargo
-        uses: Swatinem/rust-cache@c19371144df3bb44fab255c43d04cbc2ab54d1c4 # v2.9.1
-        with:
-          key: ocr-runtime
-          workspaces: |
-            . -> target
-            napi -> target
-
-      - name: Install PDFium
-        shell: bash
-        run: |
-          archive="$RUNNER_TEMP/firecrawl-pdfium-linux-x64.tgz"
-          directory="$RUNNER_TEMP/firecrawl-pdfium"
-          curl --fail --location --silent --show-error \
-            https://github.com/firecrawl/pdfium-rs/releases/download/native-v7988/firecrawl-pdfium-linux-x64.tgz \
-            --output "$archive"
-          echo "6248189e07bbc33cdeb31976c539a88614307c8a19f3276dbd018efbe5b4a2a2  $archive" | sha256sum --check
-          mkdir -p "$directory"
-          tar -xzf "$archive" -C "$directory"
-          pdfium_path="$(find "$directory" -type f -name 'libpdfium.so' -print -quit)"
-          test -n "$pdfium_path"
-          echo "PDFIUM_LIB_PATH=$pdfium_path" >> "$GITHUB_ENV"
-
-      - name: Install ONNX Runtime
-        shell: bash
-        run: |
-          archive="$RUNNER_TEMP/onnxruntime-linux-x64-1.27.0.tgz"
-          directory="$RUNNER_TEMP/onnxruntime"
-          curl --fail --location --silent --show-error \
-            https://github.com/microsoft/onnxruntime/releases/download/v1.27.0/onnxruntime-linux-x64-1.27.0.tgz \
-            --output "$archive"
-          echo "547e40a48f1fe73e3f812d7c88a948612c23f896b91e4e2ee1e232d7b468246f  $archive" | sha256sum --check
-          mkdir -p "$directory"
-          tar -xzf "$archive" -C "$directory"
-          ort_path="$(find "$directory" -type f -name 'libonnxruntime.so*' -print -quit)"
-          test -n "$ort_path"
-          echo "ORT_DYLIB_PATH=$ort_path" >> "$GITHUB_ENV"
-
-      - name: Configure isolated model cache
-        shell: bash
-        run: echo "PDF_INSPECTOR_MODEL_CACHE=$RUNNER_TEMP/pdf-inspector-models" >> "$GITHUB_ENV"
-
-      - name: Build OCR CLI
-        run: cargo build --features ocr --bin pdf2md
-
-      - name: Test PDFium runtime
-        run: cargo test --features ocr --test local_render_tests
-
-      - name: Provision OCR model cache
-        shell: bash
-        run: |
-          target/debug/pdf2md \
-            tests/fixtures/scan_with_native_header_text.pdf \
-            --ocr force \
-            --json > /dev/null
-
-      - name: Run OCR CLI
-        shell: bash
-        run: |
-          target/debug/pdf2md \
-            tests/fixtures/scan_with_native_header_text.pdf \
-            --ocr auto \
-            --ocr-offline \
-            --json > "$RUNNER_TEMP/ocr-result.json"
-
-      - name: Validate OCR JSON contract
-        shell: bash
-        run: |
-          python3 - <<'PY'
-          import json
-          import os
-          from pathlib import Path
-
-          result = json.loads(
-              (Path(os.environ["RUNNER_TEMP"]) / "ocr-result.json").read_text()
-          )
-          assert result["schema_version"] == 1
-          assert result["pages_routed_to_ocr"] == [1]
-          assert result["pages_recommending_hosted"] == []
-          assert result["pages"][0]["source"] in {"ocr", "fused"}
-          assert result["pages"][0]["markdown"].strip()
-          assert "layout_ms" not in result["pages"][0]["timings"]
-          PY
-
-      - name: Run OCR launch smoke set
-        shell: bash
-        run: |
-          export PDF_INSPECTOR_OCR_TEST_MODELS="$PDF_INSPECTOR_MODEL_CACHE/pp-ocrv6-small/oar-ocr-v0.7.0"
-          cargo test --features ocr --test ocr_tests -- --nocapture
-
-      - name: Build Node binding
-        working-directory: napi
-        run: |
-          bun install --frozen-lockfile
-          bunx napi build --platform --release
-
-      - name: Run Node OCR binding
-        shell: bash
-        run: |
-          node --input-type=module - <<'JS'
-          import { readFileSync } from 'node:fs'
-          import { processPdfWithOcr } from './napi/index.js'
-
-          const pdf = readFileSync('tests/fixtures/scan_with_native_header_text.pdf')
-          const result = await processPdfWithOcr(pdf, { offline: true })
-          if (JSON.stringify(result.pagesRoutedToOcr) !== '[1]') throw new Error('unexpected OCR route')
-          if (result.pagesRecommendingHosted.length !== 0) throw new Error('unexpected hosted recommendation')
-          if (!['Ocr', 'Fused'].includes(result.pages[0].provenance.source)) throw new Error('unexpected source')
-          if (!result.pages[0].markdown.trim()) throw new Error('empty OCR markdown')
-          JS
-
-      - name: Build and install Python binding
-        shell: bash
-        run: |
-          python -m pip install 'maturin>=1,<2'
-          maturin build --release --out "$RUNNER_TEMP/python-wheels"
-          python -m pip install "$RUNNER_TEMP"/python-wheels/*.whl
-
-      - name: Run Python OCR binding
-        shell: bash
-        run: |
-          python - <<'PY'
-          import pdf_inspector
-
-          result = pdf_inspector.process_pdf_with_ocr(
-              "tests/fixtures/scan_with_native_header_text.pdf",
-              offline=True,
-          )
-          assert result.pages_routed_to_ocr == [1]
-          assert result.pages_recommending_hosted == []
-          assert result.pages[0].provenance.source in {"ocr", "fused"}
-          assert result.pages[0].markdown.strip()
-          PY
-
   wasm:
     name: WebAssembly
     runs-on: ubuntu-latest

.github/workflows/publish-pypi.yml

@@ -86,14 +86,12 @@ jobs:
     name: Build ${{ matrix.target }}
     runs-on: ${{ matrix.os }}
     strategy:
-      fail-fast: false
       matrix:
         include:
           - os: ubuntu-latest
             target: x86_64-unknown-linux-gnu
           - os: ubuntu-latest
             target: aarch64-unknown-linux-gnu
-            docker-options: -e CFLAGS_aarch64_unknown_linux_gnu=-D__ARM_ARCH=8
           # macos-13 was retired by GitHub; macos-15-intel is the remaining
           # Intel runner label (available through 2027).
           - os: macos-15-intel
@@ -115,9 +113,6 @@ jobs:
           target: ${{ matrix.target }}
           args: --release --out dist
           manylinux: auto
-          # The manylinux AArch64 GCC omits this macro while preprocessing
-          # ring's assembly. AArch64 is ARMv8 by definition.
-          docker-options: ${{ matrix.docker-options }}
 
       - name: Upload wheel
         uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1

.github/workflows/publish.yml

@@ -60,7 +60,6 @@ jobs:
     name: Build ${{ matrix.target }}
     runs-on: ${{ matrix.os }}
     strategy:
-      fail-fast: false
       matrix:
         include:
           - os: ubuntu-latest
@@ -71,7 +70,6 @@ jobs:
           - os: ubuntu-latest
             target: aarch64-unknown-linux-gnu
             build-flags: --use-napi-cross
-            cflags: -D__ARM_ARCH=8
           - os: ubuntu-latest
             target: x86_64-unknown-linux-musl
             build-flags: -x
@@ -128,10 +126,6 @@ jobs:
 
       - name: Build native addon
         working-directory: napi
-        env:
-          # napi-cross's old AArch64 GCC omits this predefined macro while
-          # preprocessing ring's assembly. AArch64 is ARMv8 by definition.
-          CFLAGS_aarch64_unknown_linux_gnu: ${{ matrix.cflags }}
         run: bunx napi build --platform --release --target ${{ matrix.target }} ${{ matrix.build-flags }}
 
       - name: Upload native binary

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "pdf-inspector"
-version = "1.15.0"
+version = "1.14.2"
 edition = "2021"
 autobins = false
 authors = ["Firecrawl Team"]
@@ -80,7 +80,7 @@ tempfile = "3.3"
 
 [features]
 default = []
-python = ["pyo3", "ocr"]
+python = ["pyo3"]
 vision = []
 model-cache = ["vision", "dep:dirs", "dep:fs2", "dep:sha2", "dep:windows-sys"]
 model-download = ["model-cache", "dep:ureq"]

README.md

@@ -18,10 +18,10 @@ Built by [Firecrawl](https://firecrawl.dev) to handle text-based PDFs locally in
 - **CID font support** — ToUnicode CMap decoding for Type0/Identity-H fonts, UTF-16BE, UTF-8, and Latin-1 encodings.
 - **Multi-column layout** — Automatic detection of newspaper-style columns, sequential reading order, and RTL text support.
 - **Encoding issue detection** — Automatically flags broken font encodings so callers can fall back to OCR.
-- **Selective OCR** — Rust, CLI, Python, and Node can render only pages that need OCR, run PP-OCRv6 Small locally, and preserve per-page provenance and hosted-fallback recommendations.
+- **Optional OCR** — An opt-in Rust and CLI feature selectively renders only pages that need OCR, runs PP-OCRv6 Small locally, and preserves per-page provenance and hosted-fallback recommendations.
 - **Single document load** — The document is parsed once and shared between detection and extraction, avoiding redundant I/O.
 - **Browser WebAssembly** — Run the same Rust parser locally in browsers and Web Workers, with embedded CMaps and no server round trip.
-- **Lightweight by default** — The default Rust and browser builds remain pure extraction. Native Python and Node packages include the OCR integration, but PDFium, ONNX Runtime, and model files remain external and are touched only when a page is routed to OCR.
+- **Lightweight by default** — The default build is pure Rust with no ML models or external services. PDFium, ONNX Runtime, and OCR models are added only when the native `ocr` feature is selected and remain external runtime artifacts.
 
 ## Benchmark
 
@@ -48,7 +48,8 @@ Use the [paired benchmark harness](docs/benchmarking.md) to compare two local bu
 ### Python
 
 ```bash
-pip install pdf-inspector
+pip install maturin
+maturin develop --release
 ```
 
 ```python
@@ -57,10 +58,6 @@ import pdf_inspector
 result = pdf_inspector.process_pdf("document.pdf")
 print(result.pdf_type)   # "text_based", "scanned", "image_based", "mixed"
 print(result.markdown)   # Markdown string or None
-
-# Selective OCR; clean text PDFs do not load the external OCR runtime.
-ocr = pdf_inspector.process_pdf_with_ocr("document.pdf")
-print(ocr.pages_routed_to_ocr)
 ```
 
 > Full API reference: [docs/python.md](docs/python.md)
@@ -73,15 +70,11 @@ npm install @firecrawl/pdf-inspector
 
 ```javascript
 import { readFileSync } from 'fs';
-import { processPdf, processPdfWithOcr } from '@firecrawl/pdf-inspector';
+import { processPdf, classifyPdf } from '@firecrawl/pdf-inspector';
 
-const pdf = readFileSync('document.pdf');
-const result = processPdf(pdf);
+const result = processPdf(readFileSync('document.pdf'));
 console.log(result.pdfType);   // "TextBased", "Scanned", "ImageBased", "Mixed"
 console.log(result.markdown);  // Markdown string or null
-
-const ocr = await processPdfWithOcr(pdf); // selective OCR, off the event loop
-console.log(ocr.pagesRoutedToOcr);
 ```
 
 > Full API reference: [napi/README.md](napi/README.md)
@@ -168,7 +161,7 @@ detect-pdf document.pdf --json
 detect-pdf document.pdf --analyze --json
 ```
 
-Rust and CLI consumers opt into OCR at build time:
+OCR is a separate native CLI build and does not change the default package:
 
 ```bash
 cargo install pdf-inspector --features ocr --bin pdf2md
@@ -178,12 +171,8 @@ PDFIUM_LIB_PATH=/path/to/libpdfium ORT_DYLIB_PATH=/path/to/libonnxruntime \
 
 The OCR JSON envelope is versioned and reports routed pages, per-page source
 and confidence, warnings, and pages recommended for the hosted document
-pipeline. Native Python and Node packages expose the same pipeline without a
-source-build feature. All native entry points still require separately
-installed PDFium and ONNX Runtime libraries only when OCR is routed. See the
-[OCR runtime setup guide](docs/ocr-runtime.md) for pinned downloads, platform
-support, model-cache behavior, and hosted-fallback integration. See the
-[Rust API guide](docs/rust-api.md#complete-ocr-api) for lower-level controls.
+pipeline. See the [Rust API guide](docs/rust-api.md#complete-ocr-api) for model
+cache and offline configuration.
 
 From a source checkout, use `cargo run --bin pdf2md -- document.pdf` or `cargo run --bin detect-pdf -- document.pdf` instead.
 

docs/ocr-runtime.md

@@ -1,97 +0,0 @@
-# OCR runtime setup
-
-Selective OCR is available from the Rust library and CLI, Python, and Node.js.
-Clean native-text documents do not load an OCR dependency or download a model.
-When `auto` routes at least one page, the process needs PDFium, ONNX Runtime,
-and the pinned PP-OCRv6 Small model set.
-
-## Validated versions
-
-The reproducible runtime path uses these builds:
-
-- [Firecrawl PDFium `native-v7988`](https://github.com/firecrawl/pdfium-rs/releases/tag/native-v7988),
-  containing PDFium `153.0.7988.0`
-- [ONNX Runtime `1.27.0`](https://github.com/microsoft/onnxruntime/releases/tag/v1.27.0)
-- PP-OCRv6 Small artifact revision `oar-ocr-v0.7.0`
-
-Use these versions for the reproducible path. Other compatible shared-library
-builds may work, but are not part of the release smoke test.
-
-## Install the shared libraries
-
-Download and extract the matching archives:
-
-| Platform | PDFium asset | ONNX Runtime asset |
-|---|---|---|
-| Linux x64 | `firecrawl-pdfium-linux-x64.tgz` | `onnxruntime-linux-x64-1.27.0.tgz` |
-| Linux ARM64 | `firecrawl-pdfium-linux-arm64.tgz` | `onnxruntime-linux-aarch64-1.27.0.tgz` |
-| macOS Apple Silicon | `firecrawl-pdfium-mac-arm64.tgz` | `onnxruntime-osx-arm64-1.27.0.tgz` |
-| Windows x64 | `firecrawl-pdfium-win-x64.tgz` | `onnxruntime-win-x64-1.27.0.zip` |
-
-The PDFium release publishes `SHA256SUMS`, build provenance, license files,
-and an SPDX document for every platform archive. GitHub publishes a SHA-256
-digest with each ONNX Runtime asset.
-
-Point pdf-inspector at the extracted shared libraries when they are not on the
-platform library search path:
-
-```bash
-export PDFIUM_LIB_PATH=/absolute/path/to/libpdfium.so
-export ORT_DYLIB_PATH=/absolute/path/to/libonnxruntime.so
-pdf2md scan.pdf --ocr auto --json
-```
-
-On macOS the filenames end in `.dylib`. On Windows, use PowerShell and point
-the variables at `pdfium.dll` and `onnxruntime.dll`:
-
-```powershell
-$env:PDFIUM_LIB_PATH = "C:\absolute\path\to\pdfium.dll"
-$env:ORT_DYLIB_PATH = "C:\absolute\path\to\onnxruntime.dll"
-pdf2md scan.pdf --ocr auto --json
-```
-
-The native extraction packages also support platforms without these exact
-runtime assets. In particular, the Python package has an Intel macOS wheel,
-but ONNX Runtime 1.27.0 does not publish an Intel macOS archive; local OCR on
-that target requires a compatible custom ONNX Runtime build.
-
-The full OCR path is exercised end to end on Linux x64 in CI. macOS and
-Windows compile and run the feature's platform-independent tests, while their
-external-runtime paths should be treated as preview until equivalent smoke
-jobs are added.
-
-## Model cache and offline mode
-
-The first routed page downloads and SHA-256-verifies three pinned artifacts:
-the detection model, recognition model, and character dictionary. Together
-they are about 31 MB. They are stored below the platform cache directory.
-Set `PDF_INSPECTOR_MODEL_CACHE` to choose a managed cache root.
-
-For hermetic deployments, populate the model directory ahead of time and use
-the language-specific offline option:
-
-- CLI: `--ocr-offline --ocr-model-dir /models/pp-ocrv6-small`
-- Rust: `ModelDownloadPolicy::Offline` with `OcrOptions::model_directory`
-- Python: `offline=True, model_directory="/models/pp-ocrv6-small"`
-- Node.js: `offline: true, modelDirectory: "/models/pp-ocrv6-small"`
-
-The model artifacts come from
-[`GreatV/oar-ocr`](https://github.com/GreatV/oar-ocr/releases/tag/v0.7.0),
-whose OCR implementation and upstream PaddleOCR project use Apache-2.0
-licensing. Models are downloaded at runtime and are not embedded in any
-pdf-inspector package.
-
-## Hosted fallback boundary
-
-`pages_recommending_hosted` is available after the local pipeline completes.
-It marks pages whose completed OCR result is empty, low-confidence, or still
-appears incomplete.
-
-Setup and execution failures happen before that result exists. A missing or
-incompatible PDFium/ONNX Runtime library, failed model acquisition, or OCR
-execution error is returned as an error. A downstream integration that has a
-hosted parser should catch that error and route the document to the hosted
-path. This keeps deployment problems distinct from page-quality judgments.
-
-In `auto`, documents with no routed pages return successfully without touching
-PDFium, ONNX Runtime, the model cache, or the network.

docs/python.md

@@ -1,6 +1,6 @@
 # pdf-inspector
 
-Fast PDF classification, text extraction, and selective OCR. Detects whether a PDF is text-based or scanned, extracts text with position awareness, and converts clean native and OCR results to Markdown. Python bindings via [PyO3](https://pyo3.rs) for the [pdf-inspector](https://github.com/firecrawl/pdf-inspector) Rust library.
+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.
 
@@ -10,8 +10,7 @@ Built by [Firecrawl](https://firecrawl.dev) to handle text-based PDFs locally in
 - **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.
-- **Selective OCR** — `auto` routes only pages rejected by native extraction; `force` OCRs every selected page; `off` keeps the result/provenance contract without external runtime work.
-- **External artifacts** — the wheel embeds no OCR models, PDFium, or ONNX Runtime; clean `auto` requests never load or download them.
+- **Lightweight** — native Rust core, no ML models, no external services; ships type stubs.
 
 ## Benchmark
 
@@ -40,14 +39,6 @@ pip install maturin
 maturin develop --release
 ```
 
-OCR calls that route work require compatible PDFium and ONNX Runtime shared
-libraries. Set `PDFIUM_LIB_PATH` and `ORT_DYLIB_PATH` when they are not on the
-platform library search path. The pinned OCR model set is downloaded and
-checksum-verified on the first routed page; use `offline=True` with a warm
-cache or `model_directory` to prohibit network access. See the
-[OCR runtime setup guide](https://github.com/firecrawl/pdf-inspector/blob/main/docs/ocr-runtime.md)
-for pinned downloads, supported platforms, and hosted-fallback behavior.
-
 ## Usage
 
 ```python
@@ -90,19 +81,6 @@ for page in result.pages:
 # Restrict to specific 0-indexed pages (preserves caller order)
 result = pdf_inspector.extract_pages_markdown("document.pdf", pages=[0, 2])
 
-# One-call selective OCR. This releases the GIL while processing.
-ocr = pdf_inspector.process_pdf_with_ocr("document.pdf")
-for page in ocr.pages:
-    print(page.page_number, page.provenance.source)
-
-# Restrict OCR processing to 1-indexed PDF pages and prohibit downloads.
-ocr = pdf_inspector.process_pdf_with_ocr(
-    "document.pdf",
-    page_numbers=[1, 3],
-    model_directory="/opt/models/pp-ocrv6-small",
-    offline=True,
-)
-
 # Structure-tree elements from tagged PDFs (empty list when untagged).
 # Pages are 1-indexed to match TextItem.page, so (page, mcid) joins directly
 # against extract_text_with_positions — e.g. to recover real heading levels:
@@ -121,8 +99,6 @@ headings = [
 |---|---|
 | `process_pdf(path, pages=None)` | Full processing (detect + extract + markdown) |
 | `process_pdf_bytes(data, pages=None)` | Full processing from bytes |
-| `process_pdf_with_ocr(path, **options)` | Native extraction + selective OCR with provenance |
-| `process_pdf_with_ocr_bytes(data, **options)` | Native extraction + selective OCR from bytes |
 | `detect_pdf(path)` | Fast detection only (returns PdfResult) |
 | `detect_pdf_bytes(data)` | Fast detection from bytes |
 | `classify_pdf(path)` | Lightweight classification (returns PdfClassification) |
@@ -161,45 +137,6 @@ class PageOcrReasons:                # per-page OCR diagnostics
     page: int                        # 1-indexed
     reasons: list[str]               # machine-readable reason identifiers
 
-class OcrModelIdentity:
-    name: str                        # model family/name
-    revision: str                    # immutable artifact-set revision
-
-class OcrTimings:                    # per-page processing stages
-    render_ms: int
-    ocr_ms: int
-    assembly_ms: int
-
-class OcrPageProvenance:
-    page_number: int                 # 1-indexed
-    source: Literal["native", "ocr", "fused"]
-    ocr_model: OcrModelIdentity | None
-    render_dpi: float | None
-    ocr_confidence: float | None
-    timings: OcrTimings
-    warnings: list[str]
-    hosted_recommended: bool
-
-class OcrPageResult:
-    page_number: int                 # 1-indexed
-    markdown: str
-    provenance: OcrPageProvenance
-
-class OcrPdfResult:                  # process_pdf_with_ocr / bytes
-    markdown: str
-    pages: list[OcrPageResult]
-    page_count: int
-    pages_recommended_for_ocr: list[int]
-    pages_routed_to_ocr: list[int]
-    pages_recommending_hosted: list[int]
-    ocr_reasons_by_page: list[PageOcrReasons]
-    pages_with_tables: list[int]
-    pages_with_columns: list[int]
-    is_complex: bool
-    processing_time_ms: int
-    render_time_ms: int
-    ocr_time_ms: int
-
 class PdfClassification:             # classify_pdf
     pdf_type: str
     page_count: int

docs/rust-api.md

@@ -383,10 +383,6 @@ shape; `Force` renders every selected page. OCR uses the existing deterministic
 table, column, reading-order, and Markdown assembly path; no learned layout
 model is included.
 
-The [OCR runtime setup guide](https://github.com/firecrawl/pdf-inspector/blob/main/docs/ocr-runtime.md)
-lists the pinned PDFium and ONNX Runtime builds, environment variables, model
-cache behavior, and the error boundary downstream hosted fallbacks should use.
-
 For ambiguous mixed pages, `Auto` privately retains clean native fragments
 instead of discarding them when OCR is selected. After recognition it compares
 script-agnostic text quality, OCR confidence, character overlap, and material

napi/Cargo.toml

@@ -1,13 +1,13 @@
 [package]
 name = "pdf-inspector-napi"
-version = "1.15.0"
+version = "1.14.2"
 edition = "2021"
 
 [lib]
 crate-type = ["cdylib"]
 
 [dependencies]
-pdf-inspector = { path = "..", features = ["ocr"] }
+pdf-inspector = { path = ".." }
 napi = { version = "3.0.0", features = ["serde-json"] }
 napi-derive = "3.0.0"
 

napi/README.md

@@ -10,8 +10,7 @@ Built by [Firecrawl](https://firecrawl.dev) for hybrid OCR pipelines — extract
 - **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.
-- **Selective OCR** — `Auto` routes only pages rejected by native extraction and returns source/model provenance plus hosted-fallback recommendations.
-- **External artifacts** — the native package embeds no OCR models, PDFium, or ONNX Runtime; clean `Auto` requests never load or download them.
+- **Lightweight** — native Rust core via napi-rs, no ML models, no external services; ~5–6 MB platform binary, TypeScript definitions included.
 
 ## Benchmark
 
@@ -37,42 +36,8 @@ bun add @firecrawl/pdf-inspector
 
 Prebuilt binaries for **Linux x64/ARM64** (glibc and musl/Alpine), **macOS ARM64**, and **Windows x64** — npm installs only the one matching your platform. No Rust toolchain needed.
 
-OCR calls that route work require compatible PDFium and ONNX Runtime shared
-libraries. Set `PDFIUM_LIB_PATH` and `ORT_DYLIB_PATH` when they are not on the
-platform library search path. The pinned OCR model set is downloaded and
-checksum-verified on the first routed page; use `offline: true` with a warm
-cache or `modelDirectory` to prohibit network access. See the
-[OCR runtime setup guide](https://github.com/firecrawl/pdf-inspector/blob/main/docs/ocr-runtime.md)
-for pinned downloads, supported platforms, and hosted-fallback behavior.
-
 ## API
 
-### `processPdfWithOcr(buffer: Buffer, options?: OcrOptions): Promise<OcrPdfResult>`
-
-Run native extraction first and OCR only the pages selected by its quality
-signals. The default mode is `Auto`; `Off` returns the same detailed result
-shape without external runtime work, and `Force` OCRs every selected page.
-The work runs on the libuv thread pool and never blocks Node's event loop.
-
-```typescript
-import { OcrMode, processPdfWithOcr } from '@firecrawl/pdf-inspector'
-
-const result = await processPdfWithOcr(pdf, {
-  mode: OcrMode.Auto,
-  pageNumbers: [1, 3], // 1-indexed
-})
-
-for (const page of result.pages) {
-  console.log(page.pageNumber, page.provenance.source)
-}
-console.log(result.pagesRoutedToOcr)
-console.log(result.pagesRecommendingHosted)
-```
-
-For offline deployments, pass `modelDirectory` and `offline: true`. Other
-controls include `dpi`, `minimumConfidence`,
-`hostedRecommendationConfidence`, and `password`.
-
 ### `classifyPdf(buffer: Buffer): PdfClassification`
 
 Classify a PDF as TextBased, Scanned, Mixed, or ImageBased (~10-50ms). Returns which pages need OCR.
@@ -159,22 +124,6 @@ interface RegionText {
   needsOcr: boolean         // true when text is unreliable
   ocrReason?: string        // "suspected_garbled_text" when known
 }
-
-interface OcrPdfResult {
-  markdown: string
-  pages: OcrPageResult[]              // 1-indexed pages + provenance
-  pageCount: number
-  pagesRecommendedForOcr: number[]
-  pagesRoutedToOcr: number[]
-  pagesRecommendingHosted: number[]
-  ocrReasonsByPage: PageOcrReasons[]
-  pagesWithTables: number[]
-  pagesWithColumns: number[]
-  isComplex: boolean
-  processingTimeMs: number
-  renderTimeMs: number
-  ocrTimeMs: number
-}
 ```
 
 ## Platforms

napi/bun.lock

@@ -8,12 +8,12 @@
         "@napi-rs/cli": "^3.4.1",
       },
       "optionalDependencies": {
-        "@firecrawl/pdf-inspector-darwin-arm64": "1.15.0",
-        "@firecrawl/pdf-inspector-linux-arm64-gnu": "1.15.0",
-        "@firecrawl/pdf-inspector-linux-arm64-musl": "1.15.0",
-        "@firecrawl/pdf-inspector-linux-x64-gnu": "1.15.0",
-        "@firecrawl/pdf-inspector-linux-x64-musl": "1.15.0",
-        "@firecrawl/pdf-inspector-win32-x64-msvc": "1.15.0",
+        "@firecrawl/pdf-inspector-darwin-arm64": "1.14.2",
+        "@firecrawl/pdf-inspector-linux-arm64-gnu": "1.14.2",
+        "@firecrawl/pdf-inspector-linux-arm64-musl": "1.14.2",
+        "@firecrawl/pdf-inspector-linux-x64-gnu": "1.14.2",
+        "@firecrawl/pdf-inspector-linux-x64-musl": "1.14.2",
+        "@firecrawl/pdf-inspector-win32-x64-msvc": "1.14.2",
       },
     },
   },

napi/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@firecrawl/pdf-inspector",
-  "version": "1.15.0",
+  "version": "1.14.2",
   "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",
@@ -52,11 +52,11 @@
     "@napi-rs/cli": "^3.4.1"
   },
   "optionalDependencies": {
-    "@firecrawl/pdf-inspector-linux-x64-gnu": "1.15.0",
-    "@firecrawl/pdf-inspector-linux-x64-musl": "1.15.0",
-    "@firecrawl/pdf-inspector-linux-arm64-gnu": "1.15.0",
-    "@firecrawl/pdf-inspector-linux-arm64-musl": "1.15.0",
-    "@firecrawl/pdf-inspector-darwin-arm64": "1.15.0",
-    "@firecrawl/pdf-inspector-win32-x64-msvc": "1.15.0"
+    "@firecrawl/pdf-inspector-linux-x64-gnu": "1.14.2",
+    "@firecrawl/pdf-inspector-linux-x64-musl": "1.14.2",
+    "@firecrawl/pdf-inspector-linux-arm64-gnu": "1.14.2",
+    "@firecrawl/pdf-inspector-linux-arm64-musl": "1.14.2",
+    "@firecrawl/pdf-inspector-darwin-arm64": "1.14.2",
+    "@firecrawl/pdf-inspector-win32-x64-msvc": "1.14.2"
   }
 }

napi/src/lib.rs

@@ -27,26 +27,6 @@ pub enum ItemType {
     FormField,
 }
 
-/// Selects when OCR runs.
-#[napi(string_enum)]
-#[derive(Clone, Copy)]
-pub enum OcrMode {
-    /// Never run OCR; return the native extraction in the OCR result shape.
-    Off,
-    /// Run OCR only on pages selected by the native quality signals.
-    Auto,
-    /// Run OCR on every selected page.
-    Force,
-}
-
-/// How final page content was sourced.
-#[napi(string_enum)]
-pub enum PageContentSource {
-    Native,
-    Ocr,
-    Fused,
-}
-
 // ---------------------------------------------------------------------------
 // Result types
 // ---------------------------------------------------------------------------
@@ -148,84 +128,6 @@ pub struct VectorGridDetectionJs {
     pub cell_bboxes: Vec<Vec<f64>>,
 }
 
-/// Options for one-call native extraction with selective OCR.
-#[napi(object)]
-#[derive(Clone)]
-pub struct OcrOptions {
-    /// OCR routing behavior. Defaults to Auto.
-    pub mode: Option<OcrMode>,
-    /// Optional 1-indexed page selection.
-    pub page_numbers: Option<Vec<u32>>,
-    /// Password for an encrypted PDF.
-    pub password: Option<String>,
-    /// Page rasterization resolution. Defaults to 150 DPI.
-    pub dpi: Option<f64>,
-    /// Drop OCR spans below this inclusive 0-1 threshold.
-    pub minimum_confidence: Option<f64>,
-    /// Recommend hosted parsing below this inclusive 0-1 page confidence.
-    pub hosted_recommendation_confidence: Option<f64>,
-    /// Directory containing an offline OCR model set.
-    pub model_directory: Option<String>,
-    /// Disable model downloads and require a model directory or warm cache.
-    pub offline: Option<bool>,
-}
-
-/// Exact OCR model identity retained in page provenance.
-#[napi(object)]
-pub struct OcrModelIdentity {
-    pub name: String,
-    pub revision: String,
-}
-
-/// Per-page OCR processing timings.
-#[napi(object)]
-pub struct OcrTimings {
-    pub render_ms: u32,
-    pub ocr_ms: u32,
-    pub assembly_ms: u32,
-}
-
-/// Source, model, confidence, and fallback metadata for one page.
-#[napi(object)]
-pub struct OcrPageProvenance {
-    /// 1-indexed page number.
-    pub page_number: u32,
-    pub source: PageContentSource,
-    pub ocr_model: Option<OcrModelIdentity>,
-    pub render_dpi: Option<f64>,
-    pub ocr_confidence: Option<f64>,
-    pub timings: OcrTimings,
-    pub warnings: Vec<String>,
-    pub hosted_recommended: bool,
-}
-
-/// Final Markdown and provenance for one page.
-#[napi(object)]
-pub struct OcrPageResult {
-    /// 1-indexed page number.
-    pub page_number: u32,
-    pub markdown: String,
-    pub provenance: OcrPageProvenance,
-}
-
-/// Complete native/OCR Markdown output.
-#[napi(object)]
-pub struct OcrPdfResult {
-    pub markdown: String,
-    pub pages: Vec<OcrPageResult>,
-    pub page_count: u32,
-    pub pages_recommended_for_ocr: Vec<u32>,
-    pub pages_routed_to_ocr: Vec<u32>,
-    pub pages_recommending_hosted: Vec<u32>,
-    pub ocr_reasons_by_page: Vec<PageOcrReasons>,
-    pub pages_with_tables: Vec<u32>,
-    pub pages_with_columns: Vec<u32>,
-    pub is_complex: bool,
-    pub processing_time_ms: u32,
-    pub render_time_ms: u32,
-    pub ocr_time_ms: u32,
-}
-
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
@@ -266,103 +168,6 @@ fn to_napi_page_ocr_reasons(reasons: Vec<pdf_inspector::PageOcrReasons>) -> Vec<
         .collect()
 }
 
-fn to_core_ocr_options(options: Option<OcrOptions>) -> pdf_inspector::vision::OcrPdfOptions {
-    let mut result = pdf_inspector::vision::OcrPdfOptions::auto();
-    let Some(options) = options else {
-        return result;
-    };
-
-    if let Some(mode) = options.mode {
-        result.ocr.mode = match mode {
-            OcrMode::Off => pdf_inspector::vision::OcrMode::Off,
-            OcrMode::Auto => pdf_inspector::vision::OcrMode::Auto,
-            OcrMode::Force => pdf_inspector::vision::OcrMode::Force,
-        };
-    }
-    if let Some(pages) = options.page_numbers {
-        result = result.page_numbers(pages);
-    }
-    if let Some(password) = options.password {
-        result = result.password(password);
-    }
-    if let Some(dpi) = options.dpi {
-        result.render.dpi = dpi as f32;
-    }
-    if let Some(minimum_confidence) = options.minimum_confidence {
-        result.ocr.minimum_confidence = minimum_confidence as f32;
-    }
-    if let Some(confidence) = options.hosted_recommendation_confidence {
-        result.hosted_recommendation_confidence = confidence as f32;
-    }
-    if let Some(directory) = options.model_directory {
-        result.ocr.model_directory = Some(directory.into());
-    }
-    if options.offline.unwrap_or(false) {
-        result.ocr.model_downloads = pdf_inspector::vision::ModelDownloadPolicy::Offline;
-    }
-    result
-}
-
-fn convert_page_content_source(
-    source: pdf_inspector::vision::PageContentSource,
-) -> PageContentSource {
-    match source {
-        pdf_inspector::vision::PageContentSource::Native => PageContentSource::Native,
-        pdf_inspector::vision::PageContentSource::Ocr => PageContentSource::Ocr,
-        pdf_inspector::vision::PageContentSource::Fused => PageContentSource::Fused,
-        _ => PageContentSource::Native,
-    }
-}
-
-fn timing_ms(value: u64) -> u32 {
-    u32::try_from(value).unwrap_or(u32::MAX)
-}
-
-fn to_napi_ocr_result(result: pdf_inspector::vision::OcrPdfResult) -> OcrPdfResult {
-    OcrPdfResult {
-        markdown: result.markdown,
-        pages: result
-            .pages
-            .into_iter()
-            .map(|page| {
-                let provenance = page.provenance;
-                OcrPageResult {
-                    page_number: page.page_number,
-                    markdown: page.markdown,
-                    provenance: OcrPageProvenance {
-                        page_number: provenance.page_number,
-                        source: convert_page_content_source(provenance.source),
-                        ocr_model: provenance.ocr_model.map(|model| OcrModelIdentity {
-                            name: model.name,
-                            revision: model.revision,
-                        }),
-                        render_dpi: provenance.render_dpi.map(f64::from),
-                        ocr_confidence: provenance.ocr_confidence.map(f64::from),
-                        timings: OcrTimings {
-                            render_ms: timing_ms(provenance.timings.render_ms),
-                            ocr_ms: timing_ms(provenance.timings.ocr_ms),
-                            assembly_ms: timing_ms(provenance.timings.assembly_ms),
-                        },
-                        warnings: provenance.warnings,
-                        hosted_recommended: provenance.hosted_recommended,
-                    },
-                }
-            })
-            .collect(),
-        page_count: result.page_count,
-        pages_recommended_for_ocr: result.pages_recommended_for_ocr,
-        pages_routed_to_ocr: result.pages_routed_to_ocr,
-        pages_recommending_hosted: result.pages_recommending_hosted,
-        ocr_reasons_by_page: to_napi_page_ocr_reasons(result.ocr_reasons_by_page),
-        pages_with_tables: result.pages_with_tables,
-        pages_with_columns: result.pages_with_columns,
-        is_complex: result.is_complex,
-        processing_time_ms: timing_ms(result.processing_time_ms),
-        render_time_ms: timing_ms(result.render_time_ms),
-        ocr_time_ms: timing_ms(result.ocr_time_ms),
-    }
-}
-
 fn convert_item_type(t: &pdf_inspector::types::ItemType) -> (ItemType, Option<String>) {
     match t {
         pdf_inspector::types::ItemType::Text => (ItemType::Text, None),
@@ -414,13 +219,6 @@ fn process_pdf_impl(bytes: &[u8], pages: Option<Vec<u32>>) -> Result<PdfResult>
     Ok(to_napi_result(result))
 }
 
-fn process_pdf_with_ocr_impl(bytes: &[u8], options: Option<OcrOptions>) -> Result<OcrPdfResult> {
-    let options = to_core_ocr_options(options);
-    let result = pdf_inspector::vision::process_pdf_with_ocr_mem(bytes, options)
-        .map_err(|error| to_napi_err(error, "process_pdf_with_ocr"))?;
-    Ok(to_napi_ocr_result(result))
-}
-
 fn classify_pdf_impl(bytes: &[u8]) -> Result<PdfClassification> {
     let result =
         pdf_inspector::classify_pdf_mem(bytes).map_err(|e| to_napi_err(e, "classify_pdf"))?;
@@ -1020,45 +818,6 @@ pub fn process_pdf_async(buffer: Buffer, pages: Option<Vec<u32>>) -> AsyncTask<P
     })
 }
 
-pub struct ProcessPdfWithOcrTask {
-    bytes: Vec<u8>,
-    options: Option<OcrOptions>,
-}
-
-impl Task for ProcessPdfWithOcrTask {
-    type Output = OcrPdfResult;
-    type JsValue = OcrPdfResult;
-
-    fn compute(&mut self) -> Result<Self::Output> {
-        let bytes = std::mem::take(&mut self.bytes);
-        let options = self.options.take();
-        catch_panic(
-            "process_pdf_with_ocr",
-            panic::AssertUnwindSafe(move || process_pdf_with_ocr_impl(&bytes, options)),
-        )
-    }
-
-    fn resolve(&mut self, _env: Env, output: Self::Output) -> Result<Self::JsValue> {
-        Ok(output)
-    }
-}
-
-/// Process a PDF with selective OCR on the libuv thread pool.
-///
-/// OCR defaults to Auto, which only loads PDFium, ONNX Runtime, and the OCR
-/// model if native extraction routes at least one page. The input buffer is
-/// copied before the promise is returned and is safe to reuse immediately.
-#[napi(ts_return_type = "Promise<OcrPdfResult>")]
-pub fn process_pdf_with_ocr(
-    buffer: Buffer,
-    options: Option<OcrOptions>,
-) -> AsyncTask<ProcessPdfWithOcrTask> {
-    AsyncTask::new(ProcessPdfWithOcrTask {
-        bytes: buffer.to_vec(),
-        options,
-    })
-}
-
 pub struct ClassifyPdfTask {
     bytes: Vec<u8>,
 }

napi/test.mjs

@@ -3,7 +3,6 @@ import { strict as assert } from 'assert';
 import {
   processPdf,
   processPdfAsync,
-  processPdfWithOcr,
   detectPdf,
   classifyPdf,
   classifyPdfAsync,
@@ -221,37 +220,6 @@ const fromMutated = await inFlight;
 assert.equal(fromMutated.markdown, result.markdown);
 console.log('  processPdfAsync input copied at call time: OK');
 
-// --- Selective OCR ---
-console.log('Testing processPdfWithOcr...');
-
-// Off exercises the complete result/provenance contract without loading
-// external PDFium, ONNX Runtime, or model artifacts.
-const ocrOff = await processPdfWithOcr(fixture, { mode: 'Off' });
-assert.equal(ocrOff.pageCount, 3);
-assert.equal(ocrOff.pages.length, 3);
-assert.deepEqual(ocrOff.pagesRoutedToOcr, []);
-assert.ok(ocrOff.pages.every(page => page.provenance.source === 'Native'));
-assert.ok(ocrOff.pages.every(page => page.provenance.ocrModel === undefined));
-assert.ok(ocrOff.markdown.length > 0);
-
-// Auto must preserve the lightweight path for clean text PDFs.
-const ocrAuto = await processPdfWithOcr(fixture);
-assert.deepEqual(ocrAuto.pagesRoutedToOcr, []);
-assert.equal(ocrAuto.renderTimeMs, 0);
-assert.equal(ocrAuto.ocrTimeMs, 0);
-
-const ocrSelected = await processPdfWithOcr(fixture, {
-  mode: 'Off',
-  pageNumbers: [2],
-});
-assert.deepEqual(ocrSelected.pages.map(page => page.pageNumber), [2]);
-
-await assert.rejects(
-  processPdfWithOcr(fixture, { mode: 'Off', pageNumbers: [0] }),
-  /page 0/,
-);
-console.log('  processPdfWithOcr: OK');
-
 // concurrent async calls all settle
 const [c1, c2, c3] = await Promise.all([
   processPdfAsync(fixture),

pdf_inspector.pyi

@@ -1,6 +1,6 @@
 """Type stubs for pdf_inspector."""
 
-from typing import Literal, Optional
+from typing import Optional
 
 class PdfResult:
     """Result of processing a PDF file."""
@@ -27,53 +27,6 @@ class PageOcrReasons:
     reasons: list[str]
     """Machine-readable OCR reason identifiers."""
 
-class OcrModelIdentity:
-    """Exact OCR model identity retained in page provenance."""
-    name: str
-    revision: str
-
-class OcrTimings:
-    """Per-page OCR processing timings."""
-    render_ms: int
-    ocr_ms: int
-    assembly_ms: int
-
-class OcrPageProvenance:
-    """Source, model, confidence, and fallback metadata for one page."""
-    page_number: int
-    """1-indexed page number."""
-    source: Literal["native", "ocr", "fused"]
-    """'native', 'ocr', or 'fused'."""
-    ocr_model: Optional[OcrModelIdentity]
-    render_dpi: Optional[float]
-    ocr_confidence: Optional[float]
-    timings: OcrTimings
-    warnings: list[str]
-    hosted_recommended: bool
-
-class OcrPageResult:
-    """Final Markdown and provenance for one page."""
-    page_number: int
-    """1-indexed page number."""
-    markdown: str
-    provenance: OcrPageProvenance
-
-class OcrPdfResult:
-    """Complete native/OCR Markdown output."""
-    markdown: str
-    pages: list[OcrPageResult]
-    page_count: int
-    pages_recommended_for_ocr: list[int]
-    pages_routed_to_ocr: list[int]
-    pages_recommending_hosted: list[int]
-    ocr_reasons_by_page: list[PageOcrReasons]
-    pages_with_tables: list[int]
-    pages_with_columns: list[int]
-    is_complex: bool
-    processing_time_ms: int
-    render_time_ms: int
-    ocr_time_ms: int
-
 class PdfClassification:
     """Lightweight PDF classification result."""
     pdf_type: str
@@ -161,39 +114,6 @@ def process_pdf_bytes(data: bytes, pages: Optional[list[int]] = None) -> PdfResu
     """Process a PDF from bytes in memory."""
     ...
 
-def process_pdf_with_ocr(
-    path: str,
-    *,
-    mode: Literal["off", "auto", "force"] = "auto",
-    page_numbers: Optional[list[int]] = None,
-    password: Optional[str] = None,
-    dpi: float = 150.0,
-    minimum_confidence: float = 0.0,
-    hosted_recommendation_confidence: float = 0.5,
-    model_directory: Optional[str] = None,
-    offline: bool = False,
-) -> OcrPdfResult:
-    """Process a PDF through native extraction and selective OCR.
-
-    Page numbers are 1-indexed. OCR runs without holding the Python GIL.
-    """
-    ...
-
-def process_pdf_with_ocr_bytes(
-    data: bytes,
-    *,
-    mode: Literal["off", "auto", "force"] = "auto",
-    page_numbers: Optional[list[int]] = None,
-    password: Optional[str] = None,
-    dpi: float = 150.0,
-    minimum_confidence: float = 0.0,
-    hosted_recommendation_confidence: float = 0.5,
-    model_directory: Optional[str] = None,
-    offline: bool = False,
-) -> OcrPdfResult:
-    """Process PDF bytes through native extraction and selective OCR."""
-    ...
-
 def detect_pdf(path: str) -> PdfResult:
     """Fast detection only — no text extraction."""
     ...

pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "maturin"
 name = "pdf-inspector"
 # Keep package versions in sync with `python3 scripts/version.py <version>`.
 # CI publishes automatically when the synchronized change lands on main.
-version = "1.15.0"
+version = "1.14.2"
 description = "Fast PDF inspection, classification, and text extraction with smart scanned vs text-based detection"
 readme = "docs/python.md"
 license = { text = "MIT" }

site/index.html

@@ -975,7 +975,7 @@ result = pdf_inspector.<span class="fn">process_pdf</span>(<span class="str">"do
 <script>
   (() => {
     const MAX_FILE_SIZE = 25 * 1024 * 1024;
-    const WASM_MODULE_URL = "https://cdn.jsdelivr.net/npm/@firecrawl/pdf-inspector-wasm@1.15.0/pdf_inspector_wasm.js";
+    const WASM_MODULE_URL = "https://cdn.jsdelivr.net/npm/@firecrawl/pdf-inspector-wasm@1.14.2/pdf_inspector_wasm.js";
     const input = document.querySelector("#pdf-input");
     const dropZone = document.querySelector("#drop-zone");
     const filePanel = document.querySelector("#demo-file");

src/extractor/content_stream.rs

@@ -561,11 +561,7 @@ pub(crate) fn extract_page_text_items(
                                 y,
                                 width,
                                 height: rendered_size,
-                                font: crate::extractor::fonts::item_font_name(
-                                    &current_font,
-                                    base_font,
-                                )
-                                .to_string(),
+                                font: current_font.clone(),
                                 font_size: rendered_size,
                                 page: page_num,
                                 is_bold: is_bold_font(base_font) || desc_bold,
@@ -749,11 +745,7 @@ pub(crate) fn extract_page_text_items(
                                     y,
                                     width,
                                     height: rendered_size,
-                                    font: crate::extractor::fonts::item_font_name(
-                                        &current_font,
-                                        base_font,
-                                    )
-                                    .to_string(),
+                                    font: current_font.clone(),
                                     font_size: rendered_size,
                                     page: page_num,
                                     is_bold: is_bold_font(base_font) || desc_bold,
@@ -860,11 +852,7 @@ pub(crate) fn extract_page_text_items(
                                 y,
                                 width,
                                 height: rendered_size,
-                                font: crate::extractor::fonts::item_font_name(
-                                    &current_font,
-                                    base_font,
-                                )
-                                .to_string(),
+                                font: current_font.clone(),
                                 font_size: rendered_size,
                                 page: page_num,
                                 is_bold: is_bold_font(base_font) || desc_bold,
@@ -1017,11 +1005,7 @@ pub(crate) fn extract_page_text_items(
                                     y,
                                     width,
                                     height: rendered_size,
-                                    font: crate::extractor::fonts::item_font_name(
-                                        &current_font,
-                                        base_font,
-                                    )
-                                    .to_string(),
+                                    font: current_font.clone(),
                                     font_size: rendered_size,
                                     page: page_num,
                                     is_bold: is_bold_font(base_font) || desc_bold,

src/extractor/fonts.rs

@@ -225,26 +225,6 @@ pub(crate) fn build_type3_scales(
     scales
 }
 
-/// The name a `TextItem` carries for its font: the `/BaseFont` family name
-/// ("ABCDEF+CMMI10"), which identifies the actual face, rather than the
-/// arbitrary per-page resource tag ("F2").
-///
-/// Exception: resource names using Distiller's CID convention (`C2_0`,
-/// `C0_1`) are kept as-is — `text_utils::is_cid_font` keys on that prefix
-/// for micro-gap joining, and the family name carries no CID marker to
-/// replace it. This is a known, deliberate wart: `TextItem::font` is the
-/// face name except for this one producer convention. The clean fix is an
-/// explicit CID flag on `TextItem`, which touches its ~29 construction
-/// sites; do that migration when `TextItem` next changes shape, and delete
-/// this carve-out with it.
-pub(crate) fn item_font_name<'a>(resource_name: &'a str, base_font: &'a str) -> &'a str {
-    if crate::text_utils::is_cid_font(resource_name) {
-        resource_name
-    } else {
-        base_font
-    }
-}
-
 /// Parse font widths from a font dictionary, dispatching by Subtype
 pub(crate) fn parse_font_widths(
     doc: &Document,
@@ -1684,17 +1664,6 @@ fn score_text(text: &str) -> i32 {
 #[cfg(test)]
 mod tests {
 
-    #[test]
-    fn item_font_name_prefers_family_over_resource_tag() {
-        use super::item_font_name;
-        assert_eq!(item_font_name("F2", "ABCDEF+CMMI10"), "ABCDEF+CMMI10");
-        assert_eq!(item_font_name("T22", "Times-Roman"), "Times-Roman");
-        // Distiller CID-convention resources keep the resource name:
-        // is_cid_font keys on the C2_/C0_ prefix for micro-gap joining.
-        assert_eq!(item_font_name("C2_0", "ABCDEE+SimSun"), "C2_0");
-        assert_eq!(item_font_name("C0_1", "ABCDEE+MSMincho"), "C0_1");
-    }
-
     #[test]
     fn type3_scale_resolves_indirect_matrix_and_bbox_numbers() {
         use lopdf::{dictionary, Document, Object};

src/extractor/xobjects.rs

@@ -620,11 +620,7 @@ fn extract_form_xobject_text_inner(
                                 y,
                                 width,
                                 height: rendered_size,
-                                font: crate::extractor::fonts::item_font_name(
-                                    &current_font,
-                                    base_font,
-                                )
-                                .to_string(),
+                                font: current_font.clone(),
                                 font_size: rendered_size,
                                 page: page_num,
                                 is_bold: is_bold_font(base_font) || desc_bold,
@@ -779,11 +775,7 @@ fn extract_form_xobject_text_inner(
                                     y,
                                     width,
                                     height: rendered_size,
-                                    font: crate::extractor::fonts::item_font_name(
-                                        &current_font,
-                                        base_font,
-                                    )
-                                    .to_string(),
+                                    font: current_font.clone(),
                                     font_size: rendered_size,
                                     page: page_num,
                                     is_bold: is_bold_font(base_font) || desc_bold,

src/markdown/classify.rs

@@ -203,42 +203,9 @@ pub(crate) fn is_code_like(text: &str) -> bool {
     false
 }
 
-/// True when a line's text is essentially all monospace (≥90% by character
-/// count). Code lines are wholly monospace; anything less is prose carrying
-/// mono-styled fragments — a URL sidebar, or a sentence quoting an inline
-/// code literal — and fencing it would split paragraphs mid-sentence.
-/// Any-item matching was safe only while items carried opaque font resource
-/// names that never matched the monospace patterns; items now carry real
-/// family names.
-pub(crate) fn line_is_monospace(line: &crate::types::TextLine) -> bool {
-    let mut monospace_chars = 0usize;
-    let mut total_chars = 0usize;
-    for item in &line.items {
-        let text = item.text.trim();
-        let chars = text.chars().count();
-        total_chars += chars;
-        // Hyperlinks and underlined text set in a mono face are link
-        // styling, not code — a URL sidebar must not fence lyric lines.
-        let looks_like_link = item.is_underline
-            || matches!(item.item_type, crate::types::ItemType::Link(_))
-            || text.contains("://")
-            || text.starts_with("www.");
-        if is_monospace_font(&item.font) && !looks_like_link {
-            monospace_chars += chars;
-        }
-    }
-    total_chars > 0 && monospace_chars * 10 >= total_chars * 9
-}
-
 /// Check if font name indicates monospace
 pub(crate) fn is_monospace_font(font_name: &str) -> bool {
     let lower = font_name.to_lowercase();
-    // "Monotype" is a foundry prefix on proportional faces (Monotype
-    // Corsiva, Monotype Garamond) — it must not satisfy the generic "mono"
-    // token below.
-    if lower.contains("monotype") {
-        return false;
-    }
     let patterns = [
         "courier",
         "consolas",
@@ -263,17 +230,6 @@ pub(crate) fn is_monospace_font(font_name: &str) -> bool {
 mod tests {
     use super::*;
 
-    #[test]
-    fn monotype_foundry_faces_are_not_monospace() {
-        // "Monotype" is a foundry prefix on proportional faces; the generic
-        // "mono" token must not classify them as code fonts.
-        assert!(!is_monospace_font("MonotypeCorsiva"));
-        assert!(!is_monospace_font("ABCDEF+Monotype-Garamond"));
-        assert!(is_monospace_font("RobotoMono-Regular"));
-        assert!(is_monospace_font("PTMono"));
-        assert!(is_monospace_font("Courier"));
-    }
-
     #[test]
     fn format_list_item_plain_bullet() {
         assert_eq!(format_list_item("● Item"), "- Item");

src/markdown/convert.rs

@@ -11,7 +11,9 @@ use super::analysis::{
     detect_header_level, font_size_rarity, has_dot_leaders, is_heading_fragment, is_toc_entry_line,
     is_toc_marker_heading,
 };
-use super::classify::{format_list_item, is_caption_line, is_list_item, starts_with_bullet_marker};
+use super::classify::{
+    format_list_item, is_caption_line, is_list_item, is_monospace_font, starts_with_bullet_marker,
+};
 use super::heading::classify_heading_sequences;
 use super::postprocess::clean_markdown;
 use super::preprocess::{merge_drop_caps, merge_heading_lines};
@@ -769,27 +771,7 @@ pub(super) fn to_markdown_from_lines_with_tables_and_images(
     let mut in_list = false;
     let mut in_paragraph = false;
     let mut last_list_x: Option<f32> = None;
-    // Code lines accumulate here and the fence is emitted only when the
-    // block flushes with content — an empty ``` ``` pair can never appear.
-    fn flush_code_block(output: &mut String, pending_code: &mut String) {
-        let trimmed = pending_code.trim();
-        // A fragment too short to be code — a lone ® or stray glyph set in
-        // a mono face — reads better as plain text than as a fenced block.
-        if trimmed.chars().count() < 3 {
-            if !trimmed.is_empty() {
-                output.push_str(trimmed);
-                output.push_str("\n\n");
-            }
-        } else {
-            output.push_str("```\n");
-            output.push_str(pending_code);
-            output.push_str("```\n");
-        }
-        pending_code.clear();
-    }
-
     let mut in_code_block = false;
-    let mut pending_code = String::new();
     let mut prev_had_dot_leaders = false;
     let mut paragraph_in_wrapped_bold_run = false;
     let mut toc_suppress_page: Option<u32> = None;
@@ -823,7 +805,7 @@ pub(super) fn to_markdown_from_lines_with_tables_and_images(
             // Flush current page's remaining tables and images
             if current_page > 0 {
                 if in_code_block {
-                    flush_code_block(&mut output, &mut pending_code);
+                    output.push_str("```\n");
                     in_code_block = false;
                 }
                 flush_page_tables_and_images(
@@ -885,14 +867,6 @@ pub(super) fn to_markdown_from_lines_with_tables_and_images(
                     PositionedBlockKind::Image => inserted_images.contains(&(current_page, idx)),
                 };
                 if positioned_block_precedes_line(block, line) && !already_inserted {
-                    // Code lines buffer until their block closes; flush them
-                    // first so this block cannot jump ahead of code that
-                    // precedes it in reading order. A code line after the
-                    // block reopens a new fence naturally.
-                    if in_code_block {
-                        flush_code_block(&mut output, &mut pending_code);
-                        in_code_block = false;
-                    }
                     if in_paragraph {
                         output.push_str("\n\n");
                         in_paragraph = false;
@@ -963,22 +937,15 @@ pub(super) fn to_markdown_from_lines_with_tables_and_images(
         // These should be on their own line followed by a paragraph break
         let struct_role = struct_roles.and_then(|roles| resolve_line_struct_role(line, roles));
 
-        // Determine if this line is code (struct-tree or font-based) for
-        // block accumulation. Font-based detection only opens a block at a
-        // paragraph boundary: a mono-set line that continues an open prose
-        // paragraph is the producer smearing an inline code literal's style
-        // across a wrapped line (HTML-to-PDF exports do this), and fencing
-        // it would cut the sentence in three.
+        // Determine if this line is code (struct-tree or font-based) for block accumulation
         let is_code_line = struct_role
             .as_ref()
             .is_some_and(|r| matches!(r, StructRole::Code))
-            || (options.detect_code
-                && (in_code_block || !in_paragraph)
-                && super::classify::line_is_monospace(line));
+            || (options.detect_code && line.items.iter().any(|i| is_monospace_font(&i.font)));
 
         // Close code block when transitioning to non-code
         if in_code_block && !is_code_line {
-            flush_code_block(&mut output, &mut pending_code);
+            output.push_str("```\n");
             in_code_block = false;
         }
 
@@ -1212,9 +1179,12 @@ pub(super) fn to_markdown_from_lines_with_tables_and_images(
                 in_paragraph = false;
                 paragraph_in_wrapped_bold_run = false;
             }
-            in_code_block = true;
-            pending_code.push_str(plain_trimmed);
-            pending_code.push('\n');
+            if !in_code_block {
+                output.push_str("```\n");
+                in_code_block = true;
+            }
+            output.push_str(plain_trimmed);
+            output.push('\n');
             continue;
         }
 
@@ -1239,7 +1209,7 @@ pub(super) fn to_markdown_from_lines_with_tables_and_images(
 
     // Close any trailing code block
     if in_code_block {
-        flush_code_block(&mut output, &mut pending_code);
+        output.push_str("```\n");
     }
 
     // Flush current page and any remaining pages with tables/images
@@ -1400,7 +1370,7 @@ pub fn to_markdown_from_lines(lines: Vec<TextLine>, options: MarkdownOptions) ->
             && !is_toc_entry_line(plain_trimmed)
             && !is_heading_fragment(plain_trimmed)
             && toc_suppress_page != Some(line.page)
-            && !(options.detect_code && super::classify::line_is_monospace(line))
+            && !(options.detect_code && line.items.iter().any(|i| is_monospace_font(&i.font)))
         {
             let line_font_size = line.items.first().map(|i| i.font_size).unwrap_or(base_size);
             if let Some(header_level) = detect_header_level(
@@ -1501,13 +1471,19 @@ pub fn to_markdown_from_lines(lines: Vec<TextLine>, options: MarkdownOptions) ->
             }
         }
 
-        // Detect code blocks by font. Only at a paragraph boundary — a
-        // mono-set line continuing an open prose paragraph is an inline
-        // code literal's style smeared across a wrapped line, not code.
-        if options.detect_code && !in_paragraph && super::classify::line_is_monospace(line) {
-            // Use plain text for code blocks
-            output.push_str(&format!("```\n{}\n```\n", plain_trimmed));
-            continue;
+        // Detect code blocks by font
+        if options.detect_code {
+            let is_mono = line.items.iter().any(|i| is_monospace_font(&i.font));
+            if is_mono {
+                if in_paragraph {
+                    output.push_str("\n\n");
+                    in_paragraph = false;
+                    paragraph_in_wrapped_bold_run = false;
+                }
+                // Use plain text for code blocks
+                output.push_str(&format!("```\n{}\n```\n", plain_trimmed));
+                continue;
+            }
         }
 
         // Regular text - join lines within same paragraph with space

src/python.rs

@@ -85,107 +85,6 @@ impl PyPageOcrReasons {
     }
 }
 
-/// Exact OCR model identity retained in page provenance.
-#[pyclass(name = "OcrModelIdentity")]
-#[derive(Clone)]
-pub struct PyOcrModelIdentity {
-    #[pyo3(get)]
-    pub name: String,
-    #[pyo3(get)]
-    pub revision: String,
-}
-
-/// Per-page OCR processing timings.
-#[pyclass(name = "OcrTimings")]
-#[derive(Clone)]
-pub struct PyOcrTimings {
-    #[pyo3(get)]
-    pub render_ms: u64,
-    #[pyo3(get)]
-    pub ocr_ms: u64,
-    #[pyo3(get)]
-    pub assembly_ms: u64,
-}
-
-/// Source, model, confidence, and fallback metadata for one page.
-#[pyclass(name = "OcrPageProvenance")]
-#[derive(Clone)]
-pub struct PyOcrPageProvenance {
-    /// 1-indexed page number.
-    #[pyo3(get)]
-    pub page_number: u32,
-    /// "native", "ocr", or "fused".
-    #[pyo3(get)]
-    pub source: String,
-    #[pyo3(get)]
-    pub ocr_model: Option<PyOcrModelIdentity>,
-    #[pyo3(get)]
-    pub render_dpi: Option<f32>,
-    #[pyo3(get)]
-    pub ocr_confidence: Option<f32>,
-    #[pyo3(get)]
-    pub timings: PyOcrTimings,
-    #[pyo3(get)]
-    pub warnings: Vec<String>,
-    #[pyo3(get)]
-    pub hosted_recommended: bool,
-}
-
-/// Final Markdown and provenance for one page.
-#[pyclass(name = "OcrPageResult")]
-#[derive(Clone)]
-pub struct PyOcrPageResult {
-    /// 1-indexed page number.
-    #[pyo3(get)]
-    pub page_number: u32,
-    #[pyo3(get)]
-    pub markdown: String,
-    #[pyo3(get)]
-    pub provenance: PyOcrPageProvenance,
-}
-
-/// Complete native/OCR Markdown output.
-#[pyclass(name = "OcrPdfResult")]
-#[derive(Clone)]
-pub struct PyOcrPdfResult {
-    #[pyo3(get)]
-    pub markdown: String,
-    #[pyo3(get)]
-    pub pages: Vec<PyOcrPageResult>,
-    #[pyo3(get)]
-    pub page_count: u32,
-    #[pyo3(get)]
-    pub pages_recommended_for_ocr: Vec<u32>,
-    #[pyo3(get)]
-    pub pages_routed_to_ocr: Vec<u32>,
-    #[pyo3(get)]
-    pub pages_recommending_hosted: Vec<u32>,
-    #[pyo3(get)]
-    pub ocr_reasons_by_page: Vec<PyPageOcrReasons>,
-    #[pyo3(get)]
-    pub pages_with_tables: Vec<u32>,
-    #[pyo3(get)]
-    pub pages_with_columns: Vec<u32>,
-    #[pyo3(get)]
-    pub is_complex: bool,
-    #[pyo3(get)]
-    pub processing_time_ms: u64,
-    #[pyo3(get)]
-    pub render_time_ms: u64,
-    #[pyo3(get)]
-    pub ocr_time_ms: u64,
-}
-
-#[pymethods]
-impl PyOcrPdfResult {
-    fn __repr__(&self) -> String {
-        format!(
-            "OcrPdfResult(pages={}, routed_to_ocr={:?}, recommending_hosted={:?})",
-            self.page_count, self.pages_routed_to_ocr, self.pages_recommending_hosted
-        )
-    }
-}
-
 // ---------------------------------------------------------------------------
 // Classification wrapper (lightweight)
 // ---------------------------------------------------------------------------
@@ -463,101 +362,6 @@ fn to_py_err(e: crate::PdfError) -> PyErr {
     PyValueError::new_err(e.to_string())
 }
 
-struct PythonOcrOptions {
-    mode: String,
-    page_numbers: Option<Vec<u32>>,
-    password: Option<String>,
-    dpi: f32,
-    minimum_confidence: f32,
-    hosted_recommendation_confidence: f32,
-    model_directory: Option<String>,
-    offline: bool,
-}
-
-fn build_ocr_options(binding: PythonOcrOptions) -> PyResult<crate::vision::OcrPdfOptions> {
-    let mode = match binding.mode.trim().to_ascii_lowercase().as_str() {
-        "off" => crate::vision::OcrMode::Off,
-        "auto" => crate::vision::OcrMode::Auto,
-        "force" => crate::vision::OcrMode::Force,
-        _ => {
-            return Err(PyValueError::new_err(
-                "mode must be 'off', 'auto', or 'force'",
-            ));
-        }
-    };
-
-    let mut options = crate::vision::OcrPdfOptions::new().mode(mode);
-    options.render.dpi = binding.dpi;
-    options.ocr.minimum_confidence = binding.minimum_confidence;
-    options.hosted_recommendation_confidence = binding.hosted_recommendation_confidence;
-    if let Some(pages) = binding.page_numbers {
-        options = options.page_numbers(pages);
-    }
-    if let Some(password) = binding.password {
-        options = options.password(password);
-    }
-    if let Some(directory) = binding.model_directory {
-        options.ocr.model_directory = Some(directory.into());
-    }
-    if binding.offline {
-        options.ocr.model_downloads = crate::vision::ModelDownloadPolicy::Offline;
-    }
-    Ok(options)
-}
-
-fn page_content_source_str(source: crate::vision::PageContentSource) -> String {
-    match source {
-        crate::vision::PageContentSource::Native => "native".into(),
-        crate::vision::PageContentSource::Ocr => "ocr".into(),
-        crate::vision::PageContentSource::Fused => "fused".into(),
-    }
-}
-
-fn to_py_ocr_result(result: crate::vision::OcrPdfResult) -> PyOcrPdfResult {
-    PyOcrPdfResult {
-        markdown: result.markdown,
-        pages: result
-            .pages
-            .into_iter()
-            .map(|page| {
-                let provenance = page.provenance;
-                PyOcrPageResult {
-                    page_number: page.page_number,
-                    markdown: page.markdown,
-                    provenance: PyOcrPageProvenance {
-                        page_number: provenance.page_number,
-                        source: page_content_source_str(provenance.source),
-                        ocr_model: provenance.ocr_model.map(|model| PyOcrModelIdentity {
-                            name: model.name,
-                            revision: model.revision,
-                        }),
-                        render_dpi: provenance.render_dpi,
-                        ocr_confidence: provenance.ocr_confidence,
-                        timings: PyOcrTimings {
-                            render_ms: provenance.timings.render_ms,
-                            ocr_ms: provenance.timings.ocr_ms,
-                            assembly_ms: provenance.timings.assembly_ms,
-                        },
-                        warnings: provenance.warnings,
-                        hosted_recommended: provenance.hosted_recommended,
-                    },
-                }
-            })
-            .collect(),
-        page_count: result.page_count,
-        pages_recommended_for_ocr: result.pages_recommended_for_ocr,
-        pages_routed_to_ocr: result.pages_routed_to_ocr,
-        pages_recommending_hosted: result.pages_recommending_hosted,
-        ocr_reasons_by_page: to_py_page_ocr_reasons(result.ocr_reasons_by_page),
-        pages_with_tables: result.pages_with_tables,
-        pages_with_columns: result.pages_with_columns,
-        is_complex: result.is_complex,
-        processing_time_ms: result.processing_time_ms,
-        render_time_ms: result.render_time_ms,
-        ocr_time_ms: result.ocr_time_ms,
-    }
-}
-
 fn item_type_str(t: &ItemType) -> String {
     match t {
         ItemType::Text => "text".into(),
@@ -698,99 +502,6 @@ fn process_pdf_bytes(data: &[u8], pages: Option<Vec<u32>>) -> PyResult<PyPdfResu
     Ok(to_py_result(result))
 }
 
-/// Process a PDF file through native extraction and selective OCR.
-///
-/// OCR defaults to ``auto`` and only initializes its external runtime and
-/// model when native quality signals route at least one page. Page numbers
-/// are 1-indexed. The GIL is released for the complete processing call.
-#[pyfunction]
-#[pyo3(signature = (
-    path,
-    *,
-    mode="auto",
-    page_numbers=None,
-    password=None,
-    dpi=150.0,
-    minimum_confidence=0.0,
-    hosted_recommendation_confidence=0.5,
-    model_directory=None,
-    offline=false
-))]
-#[allow(clippy::too_many_arguments)]
-fn process_pdf_with_ocr(
-    py: Python<'_>,
-    path: String,
-    mode: &str,
-    page_numbers: Option<Vec<u32>>,
-    password: Option<String>,
-    dpi: f32,
-    minimum_confidence: f32,
-    hosted_recommendation_confidence: f32,
-    model_directory: Option<String>,
-    offline: bool,
-) -> PyResult<PyOcrPdfResult> {
-    let options = build_ocr_options(PythonOcrOptions {
-        mode: mode.to_string(),
-        page_numbers,
-        password,
-        dpi,
-        minimum_confidence,
-        hosted_recommendation_confidence,
-        model_directory,
-        offline,
-    })?;
-    let result = py
-        .allow_threads(move || crate::vision::process_pdf_with_ocr(path, options))
-        .map_err(|error| PyValueError::new_err(error.to_string()))?;
-    Ok(to_py_ocr_result(result))
-}
-
-/// Process PDF bytes through native extraction and selective OCR.
-///
-/// See [`process_pdf_with_ocr`] for options and result semantics.
-#[pyfunction]
-#[pyo3(signature = (
-    data,
-    *,
-    mode="auto",
-    page_numbers=None,
-    password=None,
-    dpi=150.0,
-    minimum_confidence=0.0,
-    hosted_recommendation_confidence=0.5,
-    model_directory=None,
-    offline=false
-))]
-#[allow(clippy::too_many_arguments)]
-fn process_pdf_with_ocr_bytes(
-    py: Python<'_>,
-    data: &[u8],
-    mode: &str,
-    page_numbers: Option<Vec<u32>>,
-    password: Option<String>,
-    dpi: f32,
-    minimum_confidence: f32,
-    hosted_recommendation_confidence: f32,
-    model_directory: Option<String>,
-    offline: bool,
-) -> PyResult<PyOcrPdfResult> {
-    let options = build_ocr_options(PythonOcrOptions {
-        mode: mode.to_string(),
-        page_numbers,
-        password,
-        dpi,
-        minimum_confidence,
-        hosted_recommendation_confidence,
-        model_directory,
-        offline,
-    })?;
-    let data = data.to_vec();
-    let result = py
-        .allow_threads(move || crate::vision::process_pdf_with_ocr_mem(&data, options))
-        .map_err(|error| PyValueError::new_err(error.to_string()))?;
-    Ok(to_py_ocr_result(result))
-}
-
 /// Fast detection only — no text extraction or markdown.
 #[pyfunction]
 fn detect_pdf(path: &str) -> PyResult<PyPdfResult> {
@@ -993,11 +704,6 @@ fn extract_structure_elements_bytes(
 fn pdf_inspector(m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_class::<PyPdfResult>()?;
     m.add_class::<PyPageOcrReasons>()?;
-    m.add_class::<PyOcrModelIdentity>()?;
-    m.add_class::<PyOcrTimings>()?;
-    m.add_class::<PyOcrPageProvenance>()?;
-    m.add_class::<PyOcrPageResult>()?;
-    m.add_class::<PyOcrPdfResult>()?;
     m.add_class::<PyPdfClassification>()?;
     m.add_class::<PyTextItem>()?;
     m.add_class::<PyStructureElement>()?;
@@ -1007,8 +713,6 @@ fn pdf_inspector(m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_class::<PyPagesExtractionResult>()?;
     m.add_function(wrap_pyfunction!(process_pdf, m)?)?;
     m.add_function(wrap_pyfunction!(process_pdf_bytes, m)?)?;
-    m.add_function(wrap_pyfunction!(process_pdf_with_ocr, m)?)?;
-    m.add_function(wrap_pyfunction!(process_pdf_with_ocr_bytes, m)?)?;
     m.add_function(wrap_pyfunction!(detect_pdf, m)?)?;
     m.add_function(wrap_pyfunction!(detect_pdf_bytes, m)?)?;
     m.add_function(wrap_pyfunction!(classify_pdf, m)?)?;

tests/test_python.py

@@ -77,50 +77,6 @@ class TestProcessPdfBytes:
         assert result.markdown is not None
 
 
-# ---------------------------------------------------------------------------
-# process_pdf_with_ocr / process_pdf_with_ocr_bytes
-# ---------------------------------------------------------------------------
-
-
-class TestProcessPdfWithOcr:
-    def test_off_mode_has_full_provenance_without_external_runtimes(self):
-        result = pdf_inspector.process_pdf_with_ocr(
-            fixture_path("thermo-freon12.pdf"), mode="off"
-        )
-        assert result.page_count == 3
-        assert len(result.pages) == 3
-        assert result.pages_routed_to_ocr == []
-        assert all(page.provenance.source == "native" for page in result.pages)
-        assert all(page.provenance.ocr_model is None for page in result.pages)
-        assert result.markdown
-        assert "OcrPdfResult" in repr(result)
-
-    def test_auto_mode_skips_external_runtimes_for_clean_text(self):
-        result = pdf_inspector.process_pdf_with_ocr_bytes(
-            fixture_bytes("thermo-freon12.pdf")
-        )
-        assert result.pages_routed_to_ocr == []
-        assert result.render_time_ms == 0
-        assert result.ocr_time_ms == 0
-
-    def test_selected_pages_are_one_indexed(self):
-        result = pdf_inspector.process_pdf_with_ocr(
-            fixture_path("thermo-freon12.pdf"), mode="off", page_numbers=[2]
-        )
-        assert [page.page_number for page in result.pages] == [2]
-
-    def test_rejects_invalid_options(self):
-        with pytest.raises(ValueError, match="mode must be"):
-            pdf_inspector.process_pdf_with_ocr(
-                fixture_path("thermo-freon12.pdf"), mode="sometimes"
-            )
-        with pytest.raises(ValueError, match="page 0"):
-            pdf_inspector.process_pdf_with_ocr(
-                fixture_path("thermo-freon12.pdf"),
-                mode="off",
-                page_numbers=[0],
-            )
-
 # ---------------------------------------------------------------------------
 # detect_pdf / detect_pdf_bytes
 # ---------------------------------------------------------------------------

wasm/Cargo.lock

@@ -724,7 +724,7 @@ checksum = "d6790f58c7ff633d8771f42965289203411a5e5c68388703c06e14f24770b41e"
 
 [[package]]
 name = "pdf-inspector"
-version = "1.15.0"
+version = "1.14.2"
 dependencies = [
  "env_logger",
  "include_dir",
@@ -740,7 +740,7 @@ dependencies = [
 
 [[package]]
 name = "pdf-inspector-wasm"
-version = "1.15.0"
+version = "1.14.2"
 dependencies = [
  "console_error_panic_hook",
  "js-sys",

wasm/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "pdf-inspector-wasm"
-version = "1.15.0"
+version = "1.14.2"
 edition = "2021"
 authors = ["Firecrawl Team"]
 description = "Browser WebAssembly bindings for pdf-inspector"