Sync from GitHub via hub-sync

CLAUDE.md

@@ -95,6 +95,7 @@ Legend: ✅ production-ready · ⚠️ works only with a required pinned image
 | `unlimited-ocr2.py` | ✅+image | SGLang (Baidu wheel) on `lmsysorg/sglang:v0.5.20-cu130` | rtx-pro-6000 | 16-page windows; ≥48 GB GPU |
 | `unlimited-ocr2-saturate.py` | 🧪+image | same | rtx-pro-6000 | tuned/experimental: repair pass, JP2 fast decode, PDFs |
 | `unlimited-ocr2-live.py` | 🧪+image | same | rtx-pro-6000 | experimental: minimal script + `--live-port` dashboard (streams the page being read) |
+| `minicpm-ocr.py` | 🧪+image | in-job vLLM nightly + minicpm-ocr SDK on `cr.hf.co/davanstrien/minicpm-ocr` | a10g-large | vendor pipeline; custom public image; dataset **or** bucket I/O (bucketbag), `markdown_status` |
 | `surya-ocr.py` | ✅+image | vLLM `:v0.20.1` | l4x1 | offline backend inject; site-packages PYTHONPATH |
 | `surya-ocr-bucket.py` | ✅+image | vLLM `:v0.20.1` | l4x1 | bucket I/O; pin `surya-ocr==0.20.0` |
 | `lift-extract.py` | ✅ | hf / vLLM | a100-large | schema-constrained extraction; naming gotcha |
@@ -169,6 +170,26 @@ hard scans) and belongs to **serving** — both engines read clean multi-page do
 robust on hard/degraded scans**. Serving setup (SGLang pin `lmsysorg/sglang:v0.5.10.post1`, a100+flashinfer
 — HF `h200` nodes fail with `CUDA error 802`) is in `serving-unlimited-ocr.md`.
 
+### `minicpm-ocr.py` — vendor SDK pipeline on a custom `cr.hf.co` image
+MiniCPM-OCR 1.0 is a region reader: OpenBMB's SDK runs PP-DocLayoutV3, crops regions, prompts each by
+type and assembles Markdown. The recipe runs that SDK unchanged (separate venv `/opt/sdk`, as OpenBMB
+require) against `vllm serve` started in the job. Measured/learned 2026-10-27:
+- `MiniCPMOcrForConditionalGeneration` is in vLLM main (18343393b4, 23 Oct) but not in v0.32.0, and
+  OpenBMB's install builds vLLM from source (~40 min). The image uses nightly 5d35ce3 pinned by digest
+  instead; Dockerfile + digest in `images/minicpm-ocr/`. Move to a stock tag when a release has the arch.
+- pip warns `transformers 5.21.0.dev0` (OpenBMB's pin 549e5b4) violates vLLM's `<5.21.0` (a pre-release
+  of 5.21.0 is excluded by `<5.21.0`); vLLM serves the model anyway.
+- The SDK's default layout path is `${ASSETS_DIR}/PP-DocLayoutV3`, not the docs' `models/PP-DocLayoutV3_infer`;
+  the recipe passes the baked path explicitly. The layout tar is sha256-checked at build time.
+- Built with kaniko on a `cpu-upgrade` Job (~20 min); container repo creation needed the stored `cli` token
+  (the OAuth login gets 403). `l4x1` had no capacity on 27 Oct; smoke ran on `a10g-large`.
+- The SDK reads a folder: the recipe writes each batch as `{i:06d}.png` and reads `output/{i:06d}.md` back.
+- The SDK writes a `.md` even when regions fail (empty for a failed text region); the page status lives in
+  `per_page_metrics.jsonl` (`ok` / `partial_failed` / `failed`). The recipe reads it: dataset mode keeps it in
+  `markdown_status`; bucket mode writes only `ok` pages so a re-run retries the rest (Codex review, 27 Oct).
+- vLLM runs in its own process group and is terminated → killed → reaped on every exit path; one bad
+  image or a failed SDK run marks its pages `error: ...` instead of losing finished batches.
+
 ### `unlimited-ocr2.py` / `unlimited-ocr2-saturate.py` — Baidu SGLang wheel, multi-page windows
 v2 has no vLLM support; Baidu ships a custom SGLang wheel in the model repo. Its pins (torch 2.13.0,
 transformers 5.12.1, flashinfer 0.6.18 cu13) match **`lmsysorg/sglang:v0.5.20`** exactly → `-cu130` image,
@@ -322,6 +343,9 @@ ARM wheels) — if a nightly-recipe install fails on resolution, wait and retry
 
 ## Change log
 
+- **2026-10-27** — added `minicpm-ocr.py` (experimental) for `openbmb/MiniCPM-OCR-1.0`: OpenBMB's SDK
+  pipeline on a public custom image `cr.hf.co/davanstrien/minicpm-ocr` (first recipe on the HF container
+  registry; Dockerfile in `images/minicpm-ocr/`).
 - **2026-10-27** — added `unlimited-ocr2.py` (minimal) and `unlimited-ocr2-saturate.py` (tuned, experimental)
   for `baidu/Unlimited-OCR-2`: whole-document OCR in 16-page windows on Baidu's SGLang build, driven by
   saturate (pinned `==0.2.0`). First recipes whose unit of work is a document, not a page; input is a

LANGUAGES.md

@@ -20,6 +20,7 @@ _Sorted by strength of evidence, then coverage:_
 | [Qianfan-OCR](https://huggingface.co/baidu/Qianfan-OCR) | 192 languages | Headline claim; no list or per-language numbers |
 | [PaddleOCR-VL](https://huggingface.co/PaddlePaddle/PaddleOCR-VL) / [1.5](https://huggingface.co/PaddlePaddle/PaddleOCR-VL-1.5) / [1.6](https://huggingface.co/PaddlePaddle/PaddleOCR-VL-1.6) | 109 languages; 1.5 adds Tibetan + Bengali | Names scripts (Cyrillic, Arabic, Devanagari, Thai) and claims handwriting + historical documents; no per-language numbers |
 | [PP-OCRv6](https://huggingface.co/collections/PaddlePaddle/pp-ocrv6) | 48 languages | Official card claim |
+| [MiniCPM-OCR 1.0](https://huggingface.co/openbmb/MiniCPM-OCR-1.0) | Chinese and English ("primary languages") | Card names two; no per-language numbers. Examples include historical scans |
 | [Nanonets-OCR2-3B](https://huggingface.co/nanonets/Nanonets-OCR2-3B) | 11 named + "many more" (incl. Arabic + CJK) | Illustrative list, no benchmark — but the only card claiming multilingual **handwriting** |
 | [LightOnOCR-2-1B](https://huggingface.co/lightonai/LightOnOCR-2-1B) | 11 (9 European + zh/ja) | Declared, not benchmarked. [v1](https://huggingface.co/lightonai/LightOnOCR-1B-1025) is explicitly European/Latin-script only (9) |
 | [GLM-OCR](https://huggingface.co/zai-org/GLM-OCR) | 8 (zh en fr es ru de ja ko) | Declared in card metadata only; no per-language evidence in the card body |

README.md

@@ -89,6 +89,7 @@ These are the maintained recipes. Each one has a tested `[tool.hf-jobs]` header,
 | [`ovis-ocr2.py`](https://huggingface.co/datasets/uv-scripts/ocr/blob/main/ovis-ocr2.py) | [OvisOCR2](https://huggingface.co/ATH-MaaS/OvisOCR2) | 0.9B | 96.58 OmniDocBench v1.6; LaTeX and HTML tables | Apache-2.0 | `a10g-small` |
 | [`lighton-ocr2.py`](https://huggingface.co/datasets/uv-scripts/ocr/blob/main/lighton-ocr2.py) | [LightOnOCR-2-1B](https://huggingface.co/lightonai/LightOnOCR-2-1B) | 1B | 83.2 olmOCR-Bench | Apache-2.0 | `a10g-small` |
 | [`hunyuan-ocr-1.5.py`](https://huggingface.co/datasets/uv-scripts/ocr/blob/main/hunyuan-ocr-1.5.py) | [HunyuanOCR-1.5](https://huggingface.co/tencent/HunyuanOCR) | 1B | 12 task types, including spotting, charts and translation | [Hunyuan Community](https://huggingface.co/tencent/HunyuanOCR/blob/main/LICENSE) (excludes EU, UK, South Korea) | `a10g-small` |
+| [`minicpm-ocr.py`](https://huggingface.co/datasets/uv-scripts/ocr/blob/main/minicpm-ocr.py) | [MiniCPM-OCR 1.0](https://huggingface.co/openbmb/MiniCPM-OCR-1.0) | 1.3B | OpenBMB's full pipeline: layout regions, per-region prompts, Markdown with HTML tables; Hub dataset or Bucket in/out; runs on a public [`cr.hf.co`](https://huggingface.co/containers/davanstrien/minicpm-ocr) image (experimental) | Apache-2.0 | `a10g-large` |
 | [`dots-ocr.py`](https://huggingface.co/datasets/uv-scripts/ocr/blob/main/dots-ocr.py) | [dots.ocr](https://huggingface.co/rednote-hilab/dots.ocr) | 1.7B | 100+ languages; layout modes | MIT | `a10g-small` |
 | [`dots-mocr.py`](https://huggingface.co/datasets/uv-scripts/ocr/blob/main/dots-mocr.py) | [dots.mocr](https://huggingface.co/rednote-hilab/dots.mocr) | 3B | Eight prompt modes, including SVG from charts | MIT | `a10g-small` |
 | [`deepseek-ocr2-vllm.py`](https://huggingface.co/datasets/uv-scripts/ocr/blob/main/deepseek-ocr2-vllm.py) | [DeepSeek-OCR-2](https://huggingface.co/deepseek-ai/DeepSeek-OCR-2) | 3B | Newer DeepSeek-OCR | Apache-2.0 | `a10g-small` |

images/minicpm-ocr/Dockerfile

@@ -0,0 +1,44 @@
+# MiniCPM-OCR 1.0 runtime for Hugging Face Jobs: cr.hf.co/davanstrien/minicpm-ocr
+#
+# - vLLM nightly 5d35ce3 (27 Oct 2026). MiniCPMOcrForConditionalGeneration landed in vLLM main on
+#   23 Oct (18343393b4, the commit OpenBMB's install.sh builds from source) and is not in a
+#   release yet; this nightly is newer and also has DSpark speculative decoding.
+# - transformers at OpenBMB's pin (549e5b4, "5.21.0.dev0"). pip reports it as outside the nightly's
+#   transformers>=5.16.1,<5.21.0 (a pre-release of 5.21.0 is excluded by <5.21.0); vLLM serves the
+#   model with it (smoke test, 27 Oct 2026).
+# - The minicpm-ocr SDK (layout, crops, assembly) in its own venv at /opt/sdk, as OpenBMB's docs
+#   require (SDK and inference service in separate environments), with PaddlePaddle GPU for the
+#   PP-DocLayoutV3 layout model.
+# - The layout model is baked in (sha256-checked) at $OCR_ASSETS_DIR, so a run never fetches it
+#   from Paddle's CDN. Model weights are not baked in: pull a pinned revision at run time.
+FROM vllm/vllm-openai:nightly-5d35ce3934a7804b298559d2d99eec33792e1eb9@sha256:3431ebee919296f7a5f3604db353f639e1474a4c7ef37595e31de6699fd831a7
+
+ARG TRANSFORMERS_COMMIT=549e5b410733fb50e8efbbe4aa585cb89f6478ea
+ARG LAYOUT_URL=https://paddle-model-ecology.bj.bcebos.com/paddlex/official_inference_model/paddle3.0.0/PP-DocLayoutV3_infer.tar
+ARG LAYOUT_SHA256=98b9bac88c80f6bc0fda7e0bfc2cae180020371c0b2edbb1eb498a70ace751b1
+
+RUN python3 -m pip install --no-cache-dir \
+      "transformers @ https://github.com/huggingface/transformers/archive/${TRANSFORMERS_COMMIT}.tar.gz"
+
+# sdk-requirements.lock is `uv pip freeze` of /opt/sdk in the published image (digest in README.md),
+# so a rebuild installs the tested SDK environment rather than resolving it afresh.
+COPY sdk-requirements.lock /tmp/sdk-requirements.lock
+RUN python3 -m pip install --no-cache-dir uv==0.13.6 \
+ && uv venv /opt/sdk --python 3.12 \
+ && uv pip install --python /opt/sdk/bin/python --no-cache \
+      --extra-index-url https://www.paddlepaddle.org.cn/packages/stable/cu129/ --index-strategy unsafe-best-match \
+      -r /tmp/sdk-requirements.lock
+
+ENV OCR_ASSETS_DIR=/opt/minicpm-ocr-assets
+RUN mkdir -p ${OCR_ASSETS_DIR}/models \
+ && curl -fsSL -o /tmp/layout.tar "${LAYOUT_URL}" \
+ && echo "${LAYOUT_SHA256}  /tmp/layout.tar" | sha256sum -c - \
+ && tar -xf /tmp/layout.tar -C ${OCR_ASSETS_DIR}/models \
+ && rm /tmp/layout.tar
+
+# The SDK CLI is on PATH as `minicpmvocr`; vLLM stays the image's `vllm`.
+RUN ln -s /opt/sdk/bin/minicpmvocr /usr/local/bin/minicpmvocr \
+ && minicpmvocr --help > /dev/null
+
+ENTRYPOINT []
+CMD ["bash"]

images/minicpm-ocr/README.md

@@ -0,0 +1,18 @@
+# cr.hf.co/davanstrien/minicpm-ocr
+
+Runtime image for [`../../minicpm-ocr.py`](../../minicpm-ocr.py), public on the Hugging Face
+container registry: https://huggingface.co/containers/davanstrien/minicpm-ocr
+
+| Tag | Digest |
+|---|---|
+| `1.0-vllm-5d35ce3` (also `latest`) | `sha256:2fb9a09980abecb3102b99b0685b57b4ecde22702b3a441c03fab22e30239aea` |
+
+Built with kaniko on an HF CPU Job (`cpu-upgrade`, about 20 minutes),
+pushed to `cr.hf.co`. The published digest was built before `sdk-requirements.lock` existed;
+the lock is that image's `/opt/sdk` environment (`uv pip freeze`), so a rebuild reproduces it. Why a custom image: MiniCPM-OCR's architecture is in vLLM main but not in a
+vLLM release yet, and the SDK needs PaddlePaddle in its own environment. Drop it for a stock
+`vllm/vllm-openai` tag plus a pip-installed SDK once a vLLM release has the architecture.
+
+Build note: pip warns that `transformers 5.21.0.dev0` does not satisfy vLLM's
+`transformers<5.21.0` (a pre-release of 5.21.0 is excluded by `<5.21.0`). This is OpenBMB's pin;
+vLLM serves the model with it (smoke test, 27 Oct 2026).

images/minicpm-ocr/sdk-requirements.lock

@@ -0,0 +1,90 @@
+aistudio-sdk==0.3.9
+annotated-types==0.8.0
+anyio==4.15.1
+bce-python-sdk==0.9.79
+beautifulsoup4==4.15.0
+certifi==2026.10.23
+cffi==2.1.1
+chardet==7.7.0
+charset-normalizer==3.5.2
+click==8.5.0
+colorlog==6.12.0
+crc32c==2.9.post0
+cryptography==50.0.2
+cuda-bindings==12.9.5
+cuda-pathfinder==1.3.3
+cuda-python==12.9.4
+filelock==4.2.4
+flatbuffers==25.12.19
+fsspec==2026.9.0
+future==1.0.0
+h11==0.16.0
+hf-xet==1.7.0
+httpcore==1.0.9
+httpcore2==2.16.0
+httpx==0.28.1
+httpx2==2.16.0
+huggingface-hub==2.3.0
+idna==3.20
+imagesize==2.0.1
+minicpm-ocr==1.0.1
+modelscope==1.40.2
+modelscope-hub==0.5.1
+networkx==3.7
+numpy==2.5.4
+nvidia-cublas-cu12==12.9.0.13
+nvidia-cuda-cccl-cu12==12.9.27
+nvidia-cuda-cupti-cu12==12.9.19
+nvidia-cuda-nvrtc-cu12==12.9.41
+nvidia-cuda-runtime-cu12==12.9.37
+nvidia-cudnn-cu12==9.9.0.52
+nvidia-cufft-cu12==11.4.0.6
+nvidia-cufile-cu12==1.14.0.30
+nvidia-curand-cu12==10.3.10.19
+nvidia-cusolver-cu12==11.7.4.40
+nvidia-cusparse-cu12==12.5.9.5
+nvidia-cusparselt-cu12==0.7.1
+nvidia-nccl-cu12==2.27.3
+nvidia-nvjitlink-cu12==12.9.41
+nvidia-nvtx-cu12==12.9.19
+onnxruntime==1.31.1
+opencv-contrib-python==4.10.0.84
+opt-einsum==3.3.0
+packaging==26.3
+paddleocr==3.4.1
+paddlepaddle-gpu==3.3.0
+paddlex==3.4.2
+pandas==3.1.0
+pillow==13.0.0
+prettytable==3.18.0
+protobuf==7.36.2
+psutil==7.2.2
+py-cpuinfo==9.0.0
+pyclipper==1.4.0
+pycparser==3.12
+pycryptodome==4.2.0
+pydantic==2.14.1
+pydantic-core==2.50.1
+pymupdf==2.0
+pymupdf-layout==2.0
+pymupdf4llm==2.0
+pypdfium2==5.14.0
+python-bidi==0.6.12
+python-dateutil==3.0.0
+pyyaml==6.0.2
+requests==2.34.2
+ruamel-yaml==0.19.1
+safetensors==0.7.0
+setuptools==84.2.1
+shapely==2.2.0
+six==1.17.0
+soupsieve==3.0.4
+tabulate==0.10.0
+tqdm==4.70.1
+truststore==0.10.5
+typing-extensions==4.16.0
+typing-inspection==0.4.4
+tzdata==2026.5
+ujson==6.0.0
+urllib3==2.8.0
+wcwidth==0.9.4

minicpm-ocr.py

@@ -0,0 +1,644 @@
+# /// script
+# requires-python = ">=3.11"
+# dependencies = [
+#     "datasets>=3.1.0",
+#     "huggingface-hub>=1.0",
+#     "pillow",
+#     "bucketbag @ https://github.com/davanstrien/bucketbag/archive/refs/tags/v0.3.1.tar.gz",
+# ]
+#
+# [tool.hf-jobs]
+# image = "cr.hf.co/davanstrien/minicpm-ocr:1.0-vllm-5d35ce3"
+# flavor = "a10g-large"
+# timeout = "2h"
+# secrets = ["HF_TOKEN"]
+# ///
+
+"""
+Convert document images to markdown with OpenBMB's MiniCPM-OCR 1.0 pipeline.
+
+MiniCPM-OCR 1.0 (1.3B, Apache-2.0) is a region reader: the official SDK finds layout regions
+with PP-DocLayoutV3, crops them, sends each crop to the model with the prompt for its type
+(`Text Recognition:`, `Table Recognition:`, `Formula Recognition:`, ...) and assembles the page
+as Markdown (tables as HTML, formulas as LaTeX). This script runs that pipeline unchanged.
+
+Two ways in and out:
+
+  # Hub dataset -> Hub dataset (adds `markdown` and `markdown_status` columns)
+  hf jobs uv run https://huggingface.co/datasets/uv-scripts/ocr/raw/main/minicpm-ocr.py \\
+      input-dataset output-dataset --max-samples 20
+
+  # Bucket (or folder) of page images -> one .md per image in a Bucket (or folder)
+  hf jobs uv run https://huggingface.co/datasets/uv-scripts/ocr/raw/main/minicpm-ocr.py \\
+      hf://buckets/<ns>/<bucket>/pages hf://buckets/<ns>/<bucket>/minicpm-ocr
+
+Bucket input is listed and downloaded in batches with bucketbag (no mount); `x/y.jp2` becomes
+`x/y.md` under the output prefix. A page whose regions all read cleanly is written; a page with
+failed regions is not, and is listed at the end, so re-running the same command retries it (pages
+with a `.md` already are skipped). In dataset mode every row gets a `markdown_status`: `ok`,
+`partial_failed` (some regions failed; the text is kept), `failed` or `error: ...` (no text).
+
+Runtime image (from the [tool.hf-jobs] header): cr.hf.co/davanstrien/minicpm-ocr, built from
+images/minicpm-ocr/Dockerfile. It holds:
+- vLLM nightly 5d35ce3. MiniCPMOcrForConditionalGeneration landed in vLLM main on 23 Oct 2026
+  and is not in a release yet. Drop the custom image for a stock vllm/vllm-openai tag once a
+  release has the architecture.
+- transformers at OpenBMB's pin (549e5b4).
+- The minicpm-ocr SDK 1.0.1 in its own venv (/opt/sdk) with PaddlePaddle GPU, as OpenBMB's docs
+  require (SDK and inference service in separate environments), and the PP-DocLayoutV3 layout
+  model baked in at /opt/minicpm-ocr-assets.
+
+Server settings follow OpenBMB's SDK tutorial (docs/minicpmvocr_tutorial_en.md): max-model-len
+40960, 32 sequences, image limit 36, `downsample_mode` 4x, thinking off, DSpark speculative
+decoding with the matching draft model (`--no-dspark` for plain decoding). The SDK's bundled
+config sets sampling and per-region prompts; nothing here overrides them. The SDK reads page
+numbers, headers, footers, footnotes and side notes but leaves them out of the Markdown;
+`--keep-labels footnote aside_text` puts those region types back.
+
+Model: https://huggingface.co/openbmb/MiniCPM-OCR-1.0
+SDK: https://github.com/OpenBMB/MiniCPM-OCR
+Image: https://huggingface.co/containers/davanstrien/minicpm-ocr
+"""
+
+import argparse
+import contextlib
+import json
+import logging
+import os
+import shlex
+import shutil
+import signal
+import subprocess
+import sys
+import tempfile
+import time
+import urllib.request
+from datetime import datetime
+from pathlib import Path
+
+logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")
+logger = logging.getLogger(__name__)
+
+SCRIPT_URL = "https://huggingface.co/datasets/uv-scripts/ocr/raw/main/minicpm-ocr.py"
+MODEL = "openbmb/MiniCPM-OCR-1.0"
+MODEL_REVISION = "a59a4acf215e34c6d73149e9eafdb88ed2086e39"
+DRAFT_MODEL = "openbmb/MiniCPM-OCR-1.0-DSpark"  # must come from the same release as MODEL
+DRAFT_REVISION = "31e3feaf80e0061cd6aa73db23480d2d691d6452"
+SERVED_NAME = "minicpm-ocr"
+PORT = 18499
+SDK_PYTHON = "/opt/sdk/bin/python"
+LAYOUT_MODEL_DIR = "/opt/minicpm-ocr-assets/models/PP-DocLayoutV3_infer"
+# minicpm-ocr SDK 1.0.1 markdown_assembly.ignore_labels: read by the model, left out of the Markdown
+SDK_IGNORED_LABELS = ["number", "footnote", "header", "footer", "aside_text"]
+IMAGE_TAG = "cr.hf.co/davanstrien/minicpm-ocr:1.0-vllm-5d35ce3"
+BUCKET_SCHEME = "hf://buckets/"
+IMAGE_EXTENSIONS = {".png", ".jpg", ".jpeg", ".tif", ".tiff", ".bmp", ".webp", ".jp2"}
+
+# Runs inside the SDK venv: the SDK's documented Python API (docs/minicpmvocr_api_en.md),
+# with the bundled config and only the input, server and layout path filled in.
+SDK_RUNNER = """
+import json, sys
+from importlib.resources import files
+from pathlib import Path
+from minicpmvocr import load_config, pipelined_run
+from minicpmvocr.prompts import DEFAULT_PROMPT_MAP
+args = json.loads(sys.argv[1])
+prompt = {}
+if args["keep_labels"]:
+    # A prompt-map file replaces whole top-level sections, so write the full assembly section.
+    assembly = dict(DEFAULT_PROMPT_MAP["markdown_assembly"])
+    assembly["ignore_labels"] = [l for l in assembly["ignore_labels"] if l not in args["keep_labels"]]
+    prompt_map = Path(args["run_root"]) / "prompt_map.json"
+    prompt_map.parent.mkdir(parents=True, exist_ok=True)
+    prompt_map.write_text(json.dumps({"markdown_assembly": assembly}))
+    prompt = {"prompt_map": str(prompt_map)}
+cfg = load_config(str(files("minicpmvocr").joinpath("configs/minicpmvocr.yaml")), overrides={
+    "input": {"image_dir": args["image_dir"]},
+    "run": {"run_root": args["run_root"], "run_tag": args["run_tag"]},
+    "engine": {"server_url": args["server_url"], "model_name": args["model_name"], "max_model_len": 40960},
+    "layout": {"model_dir": args["layout_dir"], "device": "cuda:0"},
+    "pipeline": {"overlap_layout": True},
+    "prompt": prompt,
+})
+pipelined_run(cfg)
+print(json.dumps({"run_dir": cfg["_meta"]["run_dir"]}))
+"""
+
+
+def image_python() -> str | None:
+    """The image's own python3 (the one with vLLM and torch), looking past this script's venv."""
+    own_bin = os.path.realpath(os.path.join(sys.prefix, "bin"))
+    path = os.pathsep.join(p for p in os.environ.get("PATH", "").split(os.pathsep)
+                           if os.path.realpath(p) != own_bin)
+    return shutil.which("python3", path=path)
+
+
+def check_runtime():
+    """Fail fast, naming the fix, when not on the MiniCPM-OCR image or without a CUDA GPU."""
+    py = image_python()
+    if not (py and shutil.which("vllm") and Path(SDK_PYTHON).exists() and Path(LAYOUT_MODEL_DIR).exists()):
+        logger.error("This script needs the %s image (vLLM with MiniCPM-OCR support, the "
+                     "minicpm-ocr SDK and the layout model).", IMAGE_TAG)
+        logger.error("Run it with `hf jobs uv run`, which reads the image from the script header, "
+                     "or pass --image %s.", IMAGE_TAG)
+        sys.exit(1)
+    probe = subprocess.run([py, "-c", "import torch; print(torch.cuda.is_available())"],
+                           capture_output=True, text=True)
+    if probe.stdout.strip() != "True":
+        logger.error("CUDA is not available to the image's torch. This script needs a GPU "
+                     "(e.g. --flavor a10g-large). %s", probe.stderr.strip()[-300:])
+        sys.exit(1)
+
+
+@contextlib.contextmanager
+def vllm_server(dspark: bool):
+    """Run vLLM with OpenBMB's tutorial settings for the duration of the block.
+
+    The server gets its own process group, and is terminated, then killed, then reaped, on every
+    exit path, including a failed or interrupted startup.
+    """
+    from huggingface_hub import snapshot_download
+
+    model_dir = snapshot_download(MODEL, revision=MODEL_REVISION)
+    cmd = [
+        "vllm", "serve", model_dir, "--served-model-name", SERVED_NAME,
+        "--host", "127.0.0.1", "--port", str(PORT),
+        "--max-model-len", "40960", "--max-num-batched-tokens", "40960", "--max-num-seqs", "32",
+        "--limit-mm-per-prompt", '{"image":36,"video":0}',
+        "--mm-processor-kwargs", '{"downsample_mode":"4x"}',
+        "--gpu-memory-utilization", "0.85", "--trust-request-mm-kwargs",
+        "--default-chat-template-kwargs", '{"enable_thinking":false}',
+    ]
+    if dspark:
+        draft_dir = snapshot_download(DRAFT_MODEL, revision=DRAFT_REVISION)
+        cmd += ["--speculative-config", json.dumps({
+            "method": "dspark", "model": draft_dir, "num_speculative_tokens": 15,
+            "enable_adaptive_verification": False})]
+    # This script's VIRTUAL_ENV must not leak into the image's vLLM.
+    env = {k: v for k, v in os.environ.items() if k != "VIRTUAL_ENV"}
+    logger.info("Starting vLLM: %s", shlex.join(cmd))
+    proc = subprocess.Popen(cmd, env=env, start_new_session=True)
+    try:
+        deadline = time.time() + 1800
+        while True:
+            if proc.poll() is not None:
+                sys.exit(f"vLLM exited during startup (code {proc.returncode})")
+            try:
+                with urllib.request.urlopen(f"http://127.0.0.1:{PORT}/v1/models", timeout=5) as r:
+                    if SERVED_NAME in r.read().decode():
+                        break
+            except OSError:
+                pass
+            if time.time() > deadline:
+                sys.exit("vLLM did not become ready within 30 minutes")
+            time.sleep(5)
+        logger.info("vLLM ready")
+        yield
+    finally:
+        stop_process_group(proc)
+
+
+def group_alive(pgid: int) -> bool:
+    try:
+        os.killpg(pgid, 0)
+        return True
+    except (ProcessLookupError, PermissionError):
+        return False
+
+
+def stop_process_group(proc: subprocess.Popen):
+    """SIGTERM the whole group, wait up to 60 s for it to empty, then SIGKILL; always reap the
+    parent. Checks the group, not just the parent, since vLLM's workers can outlive it."""
+    pgid = proc.pid  # start_new_session=True: the server leads its own group
+    for sig, wait in ((signal.SIGTERM, 60), (signal.SIGKILL, 30)):
+        if not group_alive(pgid):
+            break
+        with contextlib.suppress(ProcessLookupError):
+            os.killpg(pgid, sig)
+        deadline = time.time() + wait
+        while group_alive(pgid) and time.time() < deadline:
+            with contextlib.suppress(subprocess.TimeoutExpired):
+                proc.wait(timeout=1)
+    with contextlib.suppress(subprocess.TimeoutExpired):
+        proc.wait(timeout=5)
+
+
+def parse_batch(images: dict, work: Path, tag: str, keep_labels: list[str]) -> dict:
+    """OCR one batch of pages with the SDK.
+
+    `images` maps a key to a PIL image, a path, or an undecoded datasets image dict. Returns
+    key -> (status, markdown or None). A page that cannot be read gets an `error: ...` status and
+    does not stop the batch; if the SDK run itself fails, every page in the batch gets one.
+    """
+    from datasets import Image as ImageFeature
+    from PIL import Image, ImageOps
+
+    decoder = ImageFeature()
+    image_dir = work / tag / "images"
+    image_dir.mkdir(parents=True)
+    results, ids = {}, {}
+    for i, (key, source) in enumerate(images.items()):
+        try:
+            if isinstance(source, dict):
+                # datasets Image(decode=False): {"bytes", "path"}. The datasets decoder handles
+                # remote paths and auth, and turns EXIF-rotated photos upright.
+                img = decoder.decode_example(source)
+            else:
+                img = source if isinstance(source, Image.Image) else Image.open(source)
+                img = ImageOps.exif_transpose(img)
+            img.convert("RGB").save(image_dir / f"{i:06d}.png")
+            ids[f"{i:06d}"] = key
+        except Exception as e:  # one unreadable page must not lose the batch
+            logger.warning("Cannot read %s: %s", key, e)
+            results[key] = (f"error: unreadable image ({type(e).__name__})", None)
+    if ids:
+        args = {"image_dir": str(image_dir), "run_root": str(work / tag / "runs"), "run_tag": tag,
+                "server_url": f"http://127.0.0.1:{PORT}", "model_name": SERVED_NAME,
+                "layout_dir": LAYOUT_MODEL_DIR, "keep_labels": keep_labels}
+        run = subprocess.run([SDK_PYTHON, "-c", SDK_RUNNER, json.dumps(args)],
+                             capture_output=True, text=True)
+        if run.returncode != 0:
+            logger.error("SDK run failed for %s (exit %d):\n%s", tag, run.returncode, run.stderr[-3000:])
+            results.update({key: (f"error: SDK exit {run.returncode}", None) for key in ids.values()})
+        else:
+            run_dir = Path(json.loads(run.stdout.strip().splitlines()[-1])["run_dir"])
+            status = {}
+            metrics = run_dir / "per_page_metrics.jsonl"
+            if metrics.exists():
+                for line in metrics.read_text(encoding="utf-8").splitlines():
+                    row = json.loads(line)
+                    status[row["image_id"]] = row.get("status") or "unknown"
+            for image_id, key in ids.items():
+                md = run_dir / "output" / f"{image_id}.md"
+                page_status = status.get(image_id, "failed" if not md.exists() else "unknown")
+                text = md.read_text(encoding="utf-8").strip() if md.exists() else None
+                results[key] = (page_status, text if page_status in ("ok", "partial_failed") else None)
+    shutil.rmtree(work / tag, ignore_errors=True)
+    return results
+
+
+# --- Bucket / folder mode ------------------------------------------------------------------
+
+
+def is_bucket(location: str) -> bool:
+    return location.startswith(BUCKET_SCHEME)
+
+
+def as_bucket_dir(url: str) -> tuple[str, str]:
+    """Split a bucket URL into (bucket root URL, directory key prefix ending in "/").
+
+    The prefix goes to bucketbag explicitly: it matches prefixes as strings, so `.../vol`
+    would also list `.../vol2/...`.
+    """
+    parts = url[len(BUCKET_SCHEME):].strip("/").split("/", 2)
+    if len(parts) < 2:
+        raise ValueError(f"Not a bucket URL: {url} (expected hf://buckets/<ns>/<bucket>[/<prefix>])")
+    prefix = parts[2] + "/" if len(parts) == 3 else ""
+    return BUCKET_SCHEME + "/".join(parts[:2]), prefix
+
+
+def md_rel(rel: str) -> str:
+    return str(Path(rel).with_suffix(".md"))
+
+
+def list_rels(location: str) -> list[str]:
+    """Relative paths of every file under a bucket prefix or folder, sorted."""
+    if is_bucket(location):
+        from bucketbag import iter_keys
+
+        url, prefix = as_bucket_dir(location)
+        return sorted(k[len(prefix):] for k in iter_keys(url, prefix=prefix))
+    root = Path(location)
+    return sorted(str(p.relative_to(root)) for p in root.rglob("*") if p.is_file()) if root.is_dir() else []
+
+
+def iter_local_batches(source: str, rels: list[str], n: int):
+    """Yield batches of (rel, local path): from disk, or downloaded by bucketbag to scratch."""
+    if not is_bucket(source):
+        for i in range(0, len(rels), n):
+            yield [(rel, Path(source) / rel) for rel in rels[i: i + n]]
+        return
+    from bucketbag import batched_files
+
+    url, prefix = as_bucket_dir(source)
+    for batch in batched_files(url, keys=[prefix + rel for rel in rels], n=n, prefetch=2):
+        yield [(item.key[len(prefix):], item.path) for item in batch]
+
+
+def write_outputs(dest: str, pairs: list[tuple[str, str]]):
+    if not pairs:
+        return
+    if is_bucket(dest):
+        from bucketbag import put_files
+
+        url, prefix = as_bucket_dir(dest)
+        put_files([(prefix + rel, content) for rel, content in pairs], url)
+        return
+    for rel, content in pairs:
+        # Temp file + rename: a stopped job never leaves a partial .md that a re-run counts as done.
+        path = Path(dest) / rel
+        path.parent.mkdir(parents=True, exist_ok=True)
+        tmp = path.with_name(f".{path.name}.tmp")
+        tmp.write_text(content, encoding="utf-8")
+        os.replace(tmp, path)
+
+
+def run_files(args):
+    inputs = [r for r in list_rels(args.input) if Path(r).suffix.lower() in IMAGE_EXTENSIONS]
+    owners: dict[str, list[str]] = {}
+    for rel in inputs:
+        owners.setdefault(md_rel(rel), []).append(rel)
+    clashes = [" + ".join(group) for group in owners.values() if len(group) > 1]
+    if clashes:
+        sys.exit("These inputs would write the same .md file; rename or move them first:\n  "
+                 + "\n  ".join(clashes))
+    if args.max_samples:
+        inputs = inputs[: args.max_samples]  # the same pages on every run, so a re-run resumes them
+    done = {r for r in list_rels(args.output) if r.endswith(".md")}
+    todo = [r for r in inputs if args.overwrite or md_rel(r) not in done]
+    already = sum(md_rel(r) in done for r in inputs)
+    logger.info("%d images under %s, %d already have a .md, %d to OCR", len(inputs), args.input,
+                already, len(todo))
+    if not todo:
+        return
+    failed = []
+    with vllm_server(dspark=not args.no_dspark), tempfile.TemporaryDirectory() as work:
+        for b, batch in enumerate(iter_local_batches(args.input, todo, args.batch_size)):
+            results = parse_batch(dict(batch), Path(work), f"batch{b:06d}", args.keep_labels)
+            write_outputs(args.output, [(md_rel(rel), text) for rel, (status, text) in results.items()
+                                        if status == "ok"])
+            failed += [f"{rel} ({status})" for rel, (status, _) in results.items() if status != "ok"]
+            logger.info("%d/%d images", min((b + 1) * args.batch_size, len(todo)), len(todo))
+    if failed:
+        logger.warning("%d pages not written (re-run the same command to retry them):\n  %s",
+                       len(failed), "\n  ".join(failed))
+        stale = [f for f in failed if md_rel(f.rsplit(" (", 1)[0]) in done]
+        if args.overwrite and stale:
+            logger.warning("%d of them still have a .md from an earlier run, which a re-run without "
+                           "--overwrite will skip; delete those files to retry them:\n  %s",
+                           len(stale), "\n  ".join(stale))
+
+
+# --- Dataset mode ----------------------------------------------------------------------------
+
+
+def jobs_flavor() -> str:
+    """Return the HF Jobs hardware flavor this run is on, or "" when it cannot be told.
+
+    HF Jobs sets ACCELERATOR to "cpu" or "gpu", not the flavor name, so the flavor is looked up
+    in the public Jobs hardware list: first by GPU model and count, then by the CPU_CORES and
+    MEMORY values that Jobs sets in the container (to tell a10g-small from a10g-large, or
+    cpu-basic from cpu-upgrade). Any failure (no network, older huggingface_hub) returns "".
+    """
+    hardware = os.environ.get("ACCELERATOR") or ""
+    if "-" in hardware or any(character.isdigit() for character in hardware):
+        return hardware  # already a flavor name
+    try:
+        from huggingface_hub import HfApi
+
+        gpu_name, gpu_count = "", 0
+        try:
+            import torch
+
+            if torch.cuda.is_available():
+                gpu_name = torch.cuda.get_device_name(0)
+                gpu_count = torch.cuda.device_count()
+        except ImportError:
+            # Torch-free drivers (e.g. the -server recipes): ask nvidia-smi instead.
+            import subprocess
+
+            try:
+                listed = subprocess.run(
+                    ["nvidia-smi", "--query-gpu=name", "--format=csv,noheader"],
+                    capture_output=True, text=True, timeout=10, check=True,
+                ).stdout
+                names = [line.strip() for line in listed.splitlines() if line.strip()]
+                if names:
+                    gpu_name, gpu_count = names[0], len(names)
+            except (OSError, subprocess.SubprocessError):
+                pass
+        if gpu_count == 0 and hardware == "gpu":
+            return ""  # a GPU run whose GPU cannot be identified: do not guess a CPU flavor
+
+        # Whole-word match, so "L4" does not match "NVIDIA L40S" ("NVIDIA A100-SXM4-80GB" -> A100).
+        gpu_words = gpu_name.upper().replace("-", " ").split()
+        candidates = []
+        for flavor in HfApi(token=False).list_jobs_hardware():
+            accelerator = flavor.accelerator
+            if gpu_count == 0 and accelerator is None:
+                candidates.append(flavor)
+            elif (
+                gpu_count > 0
+                and accelerator is not None
+                and accelerator.model.upper() in gpu_words
+                and int(accelerator.quantity) == gpu_count
+            ):
+                candidates.append(flavor)
+        if not candidates:
+            return ""
+
+        cores = float(os.environ.get("CPU_CORES") or 0)
+        memory_gb = float((os.environ.get("MEMORY") or "0").upper().rstrip("GIB ") or 0)
+
+        def distance(flavor) -> float:
+            # Relative gap to the listed vCPUs and RAM; Jobs reports slightly different numbers.
+            listed_cores = float(flavor.cpu.split()[0])
+            listed_memory = float(flavor.ram.split()[0])
+            return abs(listed_cores - cores) / listed_cores + abs(listed_memory - memory_gb) / listed_memory
+
+        return min(candidates, key=distance).name
+    except Exception:
+        return ""
+
+
+def create_dataset_card(args, num_samples: int, counts: dict, processing_time: str) -> str:
+    # Canonical provenance stamp (see AGENTS.md): Jobs claim gated on JOB_ID, set by HF Jobs in-container.
+    on_jobs = os.environ.get("JOB_ID") is not None
+    hw = jobs_flavor()
+    origin = (
+        "Produced on [Hugging Face Jobs](https://huggingface.co/docs/huggingface_hub/guides/jobs)"
+        + (f" (`{hw}`)" if hw else "")
+    ) if on_jobs else "Generated"
+    jobs_tag = "\n- hf-jobs" if on_jobs else ""
+    status_col = f"{args.output_column}_status"
+    flags = [f"--flavor {hw or 'a10g-large'}"]
+    for flag, value, default in (("--split", args.split, "train"), ("--image-column", args.image_column, "image"),
+                                 ("--output-column", args.output_column, "markdown"),
+                                 ("--batch-size", args.batch_size, 64)):
+        if value != default:
+            flags.append(f"{flag} {shlex.quote(str(value))}")
+    if args.max_samples:
+        flags.append(f"--max-samples {args.max_samples}")
+    if args.shuffle:
+        flags.append(f"--shuffle --seed {args.seed}")
+    if args.no_dspark:
+        flags.append("--no-dspark")
+    if args.keep_labels:
+        flags.append("--keep-labels " + " ".join(args.keep_labels))
+    if args.overwrite:
+        flags.append("--overwrite")
+    command = f"hf jobs uv run {' '.join(flags[:1])} \\\n    {SCRIPT_URL} \\\n    {args.input} <output-dataset>"
+    if flags[1:]:
+        command += " \\\n    " + " ".join(flags[1:])
+    counts_line = ", ".join(f"`{k}` {v:,}" for k, v in sorted(counts.items()))
+    return f"""---
+tags:
+- ocr
+- document-processing
+- minicpm-ocr
+- markdown
+- uv-script
+- generated{jobs_tag}
+---
+
+# Document OCR using MiniCPM-OCR 1.0
+
+OCR of [{args.input}](https://huggingface.co/datasets/{args.input}) with OpenBMB's
+[MiniCPM-OCR 1.0](https://huggingface.co/{MODEL}) pipeline: PP-DocLayoutV3 layout regions, each
+region read by the model, assembled into Markdown by the official SDK.
+
+## Processing Details
+
+- **Source Dataset**: [{args.input}](https://huggingface.co/datasets/{args.input}) (split `{args.split}`, column `{args.image_column}`)
+- **Model**: [{MODEL}](https://huggingface.co/{MODEL}) @ `{MODEL_REVISION[:7]}`
+- **Decoding**: {"standard" if args.no_dspark else "DSpark speculative decoding"}
+- **Region types left out of the Markdown**: {", ".join(f"`{l}`" for l in SDK_IGNORED_LABELS if l not in args.keep_labels) or "none"}
+- **Number of Samples**: {num_samples:,}
+- **Page status**: {counts_line}
+- **Processing Time**: {processing_time}
+- **Processing Date**: {datetime.now().strftime("%Y-%m-%d %H:%M UTC")}
+
+## Columns
+
+- `{args.output_column}`: the SDK's Markdown for each page (tables as HTML, formulas as LaTeX); empty when
+  the page failed
+- `{status_col}`: `ok`, `partial_failed` (some regions failed; text kept), `failed` or `error: ...`
+- `inference_info`: JSON list tracking all OCR models applied to this dataset
+
+## Reproduction
+
+{origin} with the [`minicpm-ocr.py`]({SCRIPT_URL}) recipe from [uv-scripts](https://huggingface.co/uv-scripts). Run it yourself:
+
+```bash
+{command}
+```
+"""
+
+
+def run_dataset(args):
+    from datasets import load_dataset
+    from huggingface_hub import DatasetCard
+
+    status_col = f"{args.output_column}_status"
+    reserved = {"inference_info", args.image_column}
+    if args.output_column in reserved or status_col in reserved:
+        sys.exit(f"--output-column {args.output_column!r} clashes with {sorted(reserved)}; pick another name")
+
+    dataset = load_dataset(args.input, split=args.split)
+    if args.shuffle:
+        dataset = dataset.shuffle(seed=args.seed)
+    if args.max_samples:
+        dataset = dataset.select(range(min(args.max_samples, len(dataset))))
+    # Undecoded: a corrupt image then fails inside parse_batch's per-page guard, not in the slice.
+    from datasets import Image as ImageFeature
+
+    dataset = dataset.cast_column(args.image_column, ImageFeature(decode=False))
+    clash = [c for c in (args.output_column, status_col) if c in dataset.column_names]
+    if clash and not args.overwrite:
+        sys.exit(f"Output column(s) {clash} already exist; choose another --output-column or pass --overwrite")
+    if clash:
+        logger.warning("--overwrite: replacing existing column(s) %s", clash)
+        dataset = dataset.remove_columns(clash)
+    logger.info("%d pages from %s", len(dataset), args.input)
+
+    # Slice only the image column: slicing the full dataset would decode every other image
+    # column too, outside the per-page guard.
+    image_only = dataset.select_columns([args.image_column])
+    start = datetime.now()
+    texts, statuses = [], []
+    with vllm_server(dspark=not args.no_dspark), tempfile.TemporaryDirectory() as work:
+        for b in range(0, len(dataset), args.batch_size):
+            images = image_only[b: b + args.batch_size][args.image_column]
+            results = parse_batch(dict(enumerate(images)), Path(work), f"batch{b:08d}", args.keep_labels)
+            for i in range(len(images)):
+                status, text = results[i]
+                statuses.append(status)
+                texts.append(text or "")
+            logger.info("%d/%d pages", len(texts), len(dataset))
+    elapsed = datetime.now() - start
+
+    counts = {}
+    for s in statuses:
+        key = "error" if s.startswith("error") else s
+        counts[key] = counts.get(key, 0) + 1
+    logger.info("Page status: %s", counts)
+
+    dataset = dataset.cast_column(args.image_column, ImageFeature())
+    dataset = dataset.add_column(args.output_column, texts).add_column(status_col, statuses)
+    entry = {"model_id": MODEL, "model_name": "MiniCPM-OCR-1.0", "column_name": args.output_column,
+             "timestamp": datetime.now().isoformat(), "model_revision": MODEL_REVISION,
+             "pipeline": "minicpm-ocr SDK 1.0.1 (PP-DocLayoutV3)", "dspark": not args.no_dspark,
+             "keep_labels": args.keep_labels}
+    if "inference_info" in dataset.column_names:
+        def update(example):
+            try:
+                info = json.loads(example["inference_info"]) if example["inference_info"] else []
+            except (json.JSONDecodeError, TypeError):
+                info = []
+            return {"inference_info": json.dumps(info + [entry])}
+        dataset = dataset.map(update)
+    else:
+        dataset = dataset.add_column("inference_info", [json.dumps([entry])] * len(dataset))
+
+    dataset.push_to_hub(args.output, private=args.private)
+    card = create_dataset_card(args, len(dataset), counts, f"{elapsed.total_seconds() / 60:.1f} min")
+    DatasetCard(card).push_to_hub(args.output)
+    logger.info("Done: https://huggingface.co/datasets/%s (%.2f pages/s including startup)",
+                args.output, len(dataset) / elapsed.total_seconds())
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Document OCR with the MiniCPM-OCR 1.0 pipeline",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="Input/output: Hub dataset IDs (dataset mode), or hf://buckets/<ns>/<bucket>[/<prefix>] "
+               "URLs / folders (one .md per image).")
+    parser.add_argument("input", help="Hub dataset ID, or hf://buckets/... URL or folder of page images")
+    parser.add_argument("output", help="Hub dataset ID (dataset input), or hf://buckets/... URL or folder")
+    parser.add_argument("--image-column", default="image", help="Dataset mode: image column")
+    parser.add_argument("--output-column", default="markdown", help="Dataset mode: output column")
+    parser.add_argument("--split", default="train", help="Dataset mode: split")
+    parser.add_argument("--max-samples", type=int, help="Process only the first N pages (for testing)")
+    parser.add_argument("--shuffle", action="store_true", help="Dataset mode: shuffle before --max-samples")
+    parser.add_argument("--seed", type=int, default=42)
+    parser.add_argument("--batch-size", type=int, default=64,
+                        help="Pages handed to the SDK per run (it parallelises regions inside a run)")
+    parser.add_argument("--no-dspark", action="store_true", help="Standard decoding, no draft model")
+    parser.add_argument("--keep-labels", nargs="+", default=[], choices=SDK_IGNORED_LABELS,
+                        help="Region types to keep in the Markdown that the SDK leaves out by default")
+    parser.add_argument("--private", action="store_true", help="Dataset mode: private output dataset")
+    parser.add_argument("--overwrite", action="store_true",
+                        help="Replace an existing output column / re-OCR images that already have a .md")
+    parser.add_argument("--hf-token", help="Hugging Face token (default: HF_TOKEN env var)")
+    args = parser.parse_args()
+
+    if args.hf_token:
+        os.environ["HF_TOKEN"] = args.hf_token
+    if args.max_samples is not None and args.max_samples < 1:
+        sys.exit("--max-samples must be at least 1")
+    if args.batch_size < 1:
+        sys.exit("--batch-size must be at least 1")
+    # The input decides the mode: a Bucket or an existing folder means files, anything else is a
+    # Hub dataset ID. In file mode the output is a Bucket URL or a folder (created if new).
+    file_in = is_bucket(args.input) or Path(args.input).is_dir()
+    if not file_in and (is_bucket(args.output) or Path(args.output).is_dir()):
+        sys.exit("Dataset input writes a Hub dataset; for Bucket output, give a Bucket or folder as input.")
+    check_runtime()
+    if file_in:
+        run_files(args)
+    else:
+        run_dataset(args)
+
+
+if __name__ == "__main__":
+    main()

models.json

@@ -1,14 +1,14 @@
 {
   "_meta": {
     "description": "Machine-readable catalog of the OCR recipes in this directory: script -> model, params, backend, support level, the tested Jobs launch config (the script's [tool.hf-jobs] header), and what the model's own card claims about language coverage. Human-readable language notes: LANGUAGES.md. Language evidence levels, strongest first: per-language-benchmark | count-claim | named-list | multilingual-unspecified | english-only | not-stated | not-applicable. Claims come from model cards (compiled 2026-07-15) - treat as claims, not guarantees.",
-    "updated": "2026-10-22",
+    "updated": "2026-10-27",
     "run_pattern": "hf jobs uv run https://huggingface.co/datasets/uv-scripts/ocr/raw/main/<script> <input-dataset> <output-dataset>  (hf CLI >= 1.32 reads image/flavor/secrets from the script's [tool.hf-jobs] header; add --timeout for long runs. Scripts without a `jobs` entry need --flavor/-s HF_TOKEN (and any --image in their docstring).)",
     "support_levels": {
       "core": "Maintained. Smoke-tested flagless on HF Jobs on 2026-09-23/24 with the pinned launch config in `jobs`.",
       "tool": "Maintained companion (judge, layout, text extraction), not a page-OCR recipe.",
       "legacy": "Works (smoke-tested 2026-09-23) but superseded or little used; no header yet. See support_note for the alternative.",
       "unsupported": "Known broken as of 2026-09-23; kept in the repo for now. See support_note.",
-    "experimental": "Works in testing on HF Jobs with the launch config in `jobs`, but changes often and may break. See support_note for the stable alternative."
+      "experimental": "Works in testing on HF Jobs with the launch config in `jobs`, but changes often and may break. See support_note for the stable alternative."
     }
   },
   "tesseract-ocr.py": {
@@ -738,6 +738,34 @@
       ]
     }
   },
+  "minicpm-ocr.py": {
+    "model_id": "openbmb/MiniCPM-OCR-1.0",
+    "params": "1.3B",
+    "backend": "in-job vLLM (nightly) + OpenBMB's minicpm-ocr SDK (PP-DocLayoutV3 layout, per-region prompts, Markdown assembly)",
+    "image": "cr.hf.co/davanstrien/minicpm-ocr:1.0-vllm-5d35ce3",
+    "task": "ocr (page images -> Markdown; tables as HTML, formulas as LaTeX); Hub dataset or Bucket/folder I/O",
+    "output": "dataset mode: markdown + markdown_status columns; Bucket/folder mode: one .md per image (failed pages not written, re-run retries)",
+    "license": "apache-2.0",
+    "notes": "A region reader behind a layout model, run through the vendor SDK unchanged. Custom public image (Dockerfile in images/minicpm-ocr/): the architecture is in vLLM main but not a release, and the SDK needs PaddlePaddle in its own venv. DSpark speculative decoding on by default (--no-dspark). Bucket I/O via bucketbag v0.3.1 (no mount), resume-by-skip. Smoke-tested 2026-10-27 on BHL pages (dataset mode) and 1771 Britannica .jp2 (Bucket mode), a10g-large.",
+    "languages": {
+      "evidence": "named-list",
+      "count": 2,
+      "named": [
+        "zh",
+        "en"
+      ],
+      "notes": "Card: 'Primary languages: Chinese and English'; card metadata lists en, zh. Card examples include historical scans; fine-tuning guide uses French handwriting."
+    },
+    "support": "experimental",
+    "jobs": {
+      "image": "cr.hf.co/davanstrien/minicpm-ocr:1.0-vllm-5d35ce3",
+      "flavor": "a10g-large",
+      "timeout": "2h",
+      "secrets": [
+        "HF_TOKEN"
+      ]
+    }
+  },
   "unlimited-ocr-vllm.py": {
     "model_id": "baidu/Unlimited-OCR",
     "params": "3.3B",