feat: OCR as per-page markdown, and the frc corpus ingest

Adds `scans frc ingest` and `scans frc fetch` for the Newberry Library's French
Revolution Collection, and `<id>.pN.ocr.md` — the format its OCR lands in.

## The format

One markdown file per scanned page. Frontmatter says which page of what and how
big the image is; the body is the page's text. That is the whole format.

---
of: 1789iemilseptcen00unse
page: 6
engine: ABBYY FineReader 11.0
lang: fr
w: 2597
h: 4418
dpi: 500
---

Scalars are written bare, because the frontmatter is meant to read as YAML. The
hazard is that `no` is the ISO 639-1 code for Norwegian and, in YAML 1.1, the
boolean false. serde_norway implements 1.2, where it is already a string, so
round-tripping through this crate's own parser passes it — which is the wrong bar.
PyYAML, libyaml, Psych and gopkg.in/yaml.v2 are all 1.1, and this data is
published for their tools rather than ours. So there is an explicit 1.1 deny-list
as well as a round-trip check.

Word boxes, per-word confidence, baselines and DjVu's nesting are deliberately not
carried. They were about seven eighths of the bytes — 8.3 GB against 1.25 GB for
the text — and nothing was reading them. Nothing is destroyed by that: the
coordinates remain in XML_for_OCR/ in frc-data, one clone away, so reinstating
them is a change to djvu.rs and a re-run, not a re-fetch.

## The corpus

The OCR is taken from frc-data rather than archive.org: one clone instead of
38,377 requests for bytes already sitting in a git repository. Only the PDFs are
fetched, one request at a time with an honest User-Agent, each verified against
the size and MD5 archive.org publishes for it.

New record fields, each justified independently of this ingest: `subject`, because
38,377 pamphlets are unusable without subject access; `extent`, the bibliographic
collation; and `scan.ppi`, which `render` otherwise infers from the largest
embedded image.

Check 11 (E708–E710) validates the sidecars; its parsing half is behind `--probe`
for the same reason the image checks are.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

.gitattributes

@@ -59,4 +59,8 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.webp filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
-*.webm filter=lfs diff=lfs merge=lfs -text
+*.webm filter=lfs diff=lfs merge=lfs -text
+# The OCR sidecars are markdown in plain git: they compress in the packfile, they stay
+# greppable, and putting 8.5 GB of them in LFS would be billed for at full size. There are no
+# exceptions any more — one file per page means none of them is bigger than a few kilobytes,
+# which is the other reason the per-page split is worth the file count.

.gitignore

@@ -4,3 +4,9 @@
 # Default output of `scans render` and `scans extract`. Derived pixels: reproducible from the
 # PDFs at any time, and at native resolution they outweigh the containers they came from.
 /.render/
+
+# Fetch and push run logs — derived, and noisy.
+.fetch.log
+.push-chunks.log
+.push-chunks.sh
+.push-hf.sh

README.md

@@ -1,3 +1,19 @@
+---
+license: odbl
+language:
+  - fr
+  - la
+  - en
+tags:
+  - french-revolution
+  - ocr
+  - primary-sources
+  - digital-humanities
+pretty_name: Scans — primary sources of the French Revolution
+size_categories:
+  - 10K<n<100K
+---
+
 # scans
 
 Scans of primary sources from the French Revolution.
@@ -44,6 +60,12 @@ are inherited down the `of` chain; `date`, `title`, `note`, `url` and `[[page]]`
 
 ```
 sources/
+  frc/                                      the Newberry French Revolution Collection
+    ab/abondance00unse/
+      abondance00unse.toml                  source, one per Internet Archive item
+      abondance00unse.p1.ocr.md             OCR, one file per page
+      abondance00unse.pdf                   the scan
+    …38,377 items across ~700 two-character shards
   journal-de-paris/
     journal-de-paris.toml                   source
     1789/
@@ -58,6 +80,7 @@ sources/
     verniquet-1795.toml                     source, 73 sheets inline
     verniquet_00.jp2 … verniquet_72.jp2
 schemas/source.json                         GENERATED from tools/src/model.rs
+schemas/ocr.json                            GENERATED from tools/src/ocr.rs
 tools/                                      the `scans` CLI
 docs/                                       the design spec
 ```
@@ -119,6 +142,94 @@ Each record carries a `#:schema` directive on its first line, which is what gets
 in an editor. See `schemas/README.md` — the alternative, an editor schema association, was
 tested and silently does nothing.
 
+## OCR
+
+Word-level OCR lives in a sidecar beside the record it belongs to, one markdown file per
+scanned page, reached through the `[[text]]` that points at it.
+
+```markdown
+---
+of: 1789iemilseptcen00unse
+page: 6
+engine: ABBYY FineReader 11.0
+lang: fr
+w: 2597
+h: 4418
+dpi: 500
+---
+
+<the page's text>
+```
+
+Frontmatter says which page of what, and how big the image is. The body is the page. That is
+the whole format.
+
+**Scalars are bare unless they would lie.** `lang: fr`, not `lang: "fr"` — the frontmatter is
+meant to read as YAML. But `no` is the ISO 639-1 code for Norwegian and, to every YAML 1.1
+parser, the boolean false; a Python user loading that with PyYAML gets `False`. So a value is
+written bare when it round-trips as itself and quoted when it would not, which keeps the
+common case clean and the pathological case correct.
+
+**What is deliberately not here:** word boxes, per-word confidence, baselines, and DjVu's
+nesting. An earlier version carried all of it and could write the source XML back out
+unchanged. The boxes were seven eighths of the bytes — 8.3 GB against about 1.2 GB for the
+text — and were not being used. Nothing is destroyed by that: the coordinates are still in
+`XML_for_OCR/` in [frc-data](https://github.com/NewberryDIS/frc-data), one clone away, so a
+later version that wants them can have them without asking archive.org for anything.
+
+```sh
+cargo run -- ocr import x_djvu.xml --out ./pages
+cargo run -- ocr check sources/frc/ab/abondance00unse
+```
+
+## The French Revolution Collection
+
+38,377 Internet Archive items from the Newberry Library, listed by
+[NewberryDIS/frc-data](https://github.com/NewberryDIS/frc-data). Records and OCR come from a
+local clone of that repository; only the PDFs are fetched.
+
+```sh
+git clone --filter=blob:none --no-checkout https://github.com/NewberryDIS/frc-data.git
+cd frc-data && git sparse-checkout set --cone Metadata XML_for_OCR && git checkout master
+
+cargo run --release -- frc ingest --frc-data ../frc-data      # records + OCR, ~3 minutes
+cargo run --release --features fetch -- frc fetch             # the PDFs, ~21 hours
+```
+
+`frc fetch` makes one request at a time, a second apart, with a `User-Agent` naming this
+repository, and verifies every download against the size and MD5 archive.org publishes for
+it. It resumes from what is already on disk, so it can be killed at any moment.
+
+## Licence
+
+The **database** — the records, the OCR sidecars, the structure and the addresses — is under
+the [Open Database License](https://opendatacommons.org/licenses/odbl/) (ODbL 1.0). Use it,
+adapt it, build on it; if you publish a derived database, share it alike and keep the
+attribution.
+
+The **contents are a separate question, and mostly not ours to license.** Every work here is
+an 18th-century imprint or a 19th-century study of one, long out of copyright everywhere, and
+the digitisations are published as public domain by the institutions that made them. Each
+record says so for itself:
+
+```toml
+[rights]
+work        = "PD-old-100-expired"
+scan        = "PD"
+attribution = "Digitised by the Internet Archive, sponsored by The Newberry Library."
+```
+
+So: quoting a pamphlet, reprinting a page image, or lifting one item's OCR carries no
+obligation from us — that material is public domain and stays public domain. ODbL bites on
+the *collection*: the selection, the identifiers, the metadata mapping and the structured OCR
+taken together. That distinction is the point of using a database licence rather than a
+content one, and it is why the per-record `[rights]` fields are not redundant with this
+section.
+
+Scans and metadata originate with the [Newberry Library](https://www.newberry.org/) and the
+[Internet Archive](https://archive.org/), and the item list comes from
+[NewberryDIS/frc-data](https://github.com/NewberryDIS/frc-data).
+
 ## Design
 
 `docs/superpowers/specs/2026-08-05-source-archive-schema-design.md` is the authority: the

docs/superpowers/specs/2026-08-07-frc-corpus-ingest-and-ocr-format-design.md

@@ -0,0 +1,289 @@
+# The Newberry French Revolution corpus — ingest, and a TOML format for OCR
+
+Status: implemented
+Date: 2026-08-07
+Revised: 2026-08-07, after the design met the corpus. The corrections are marked
+**Corrected** and the original claim is stated alongside, because most of them were
+wrong in a way worth remembering.
+
+## Purpose
+
+Bring the Newberry Library's French Revolution Collection into this archive: 38,377
+Internet Archive items of French pamphlets, mostly 1789–1799, listed by
+[NewberryDIS/frc-data](https://github.com/NewberryDIS/frc-data). For each item, hold the
+scanned PDF and the word-level OCR, addressed the same way as everything else here.
+
+That is a factor of roughly seven thousand more records than the archive currently holds.
+The design is shaped almost entirely by that number.
+
+## What frc-data actually is
+
+**Corrected.** The first draft of this said frc-data held no XML OCR, and that the
+coordinate-bearing OCR would have to be fetched from archive.org. That was wrong, and it
+was wrong because GitHub's tree API silently truncates: it returned 72,499 entries with
+`"truncated": true`, and the counts happened to add up so neatly against two directories
+that the third was never missed. `git ls-tree` on a blobless clone gives the real list.
+
+There are four directories, and each of the three that matter holds exactly 38,377 files:
+
+| directory | contents |
+| --- | --- |
+| `Metadata/*_meta.xml` | 38,377 Internet Archive metadata records |
+| `XML_for_OCR/*_djvu.xml` | 38,377 DjVu XML files — **word-level OCR with coordinates** |
+| `OCR_text/*_djvu.txt` | 38,377 plain-text OCR files |
+| `IA_pamphlets-1560-1660-marc_records/` | one 3.5 MB MARC file for a different collection |
+
+So frc-data supplies the item list, the catalogue metadata **and the OCR**. Only the PDFs
+have to be fetched.
+
+That changes the crawl from about 115,000 requests to about 77,000, and saves archive.org
+11 GB of egress for bytes that are already sitting in a git repository. Given that "be
+respectful of rate limits" was the constraint, this is not a small correction.
+
+## Scale, measured
+
+Sampled across three items and extrapolated by OCR-text size, which tracks page count
+closely:
+
+| | |
+| --- | --- |
+| items | 38,377, all with OCR |
+| PDFs | ~63 GB, still an estimate — the fetch has not finished |
+| `XML_for_OCR` in frc-data | 11 GB **measured** |
+| the same OCR as markdown | ~1.2 GB — text only, no coordinates |
+| HTTP requests | ~77,000, all of them for PDFs |
+| wall time at one request per second | ~21 hours |
+
+The wall time is the governing constraint. This is a pipeline that runs for days and is
+killed and resumed many times, not a script that is run once.
+
+## Decisions
+
+### One IA item becomes one `source` record
+
+`layer = "source"`, with `copy` and `document` collapsed in, exactly as `pellet-1873` and
+`turgot-1739` already do. A pamphlet is a single work, digitised once, and paying three
+files of ceremony for it would produce 115,000 files to describe 38,377 pamphlets.
+
+`type` comes from `mediatype` and `physical_description`: `pamphlet` under ~50 pages,
+`book` above, `periodical` where the metadata says so.
+
+### Ids are the bare Internet Archive identifier
+
+`abondance00unse`, not `frc-abondance00unse`. The identifier is already globally unique
+and stable, and it is what every other system cites. Prefixing would add nine characters
+to 38,377 addresses to solve a collision problem that does not exist — the existing
+hand-curated ids are all of the form `name-year`, which no IA identifier matches.
+
+### Directories are sharded two deep by identifier prefix
+
+```
+sources/frc/ab/abondance00unse/
+                 abondance00unse.toml
+                 abondance00unse.pdf
+                 abondance00unse.ocr.toml
+```
+
+~700 shard directories of ~55 items each. The README's promise that "directories are
+cosmetic" is what makes this free: no address changes if the sharding is ever redone.
+
+A single flat directory of 38,377 entries was rejected — not because git minds, but
+because `ls`, tab completion, and the editor's file tree all become unusable.
+
+### The OCR sidecar attaches through the existing `[[text]]` table
+
+No new top-level table. `[[text]]` already means "OCR or transcription, never inline",
+which is exactly what this is:
+
+```toml
+[[text]]
+file = "abondance00unse.ocr.toml"
+kind = "ocr"
+by   = "ABBYY FineReader 11.0"
+lang = "fr"
+```
+
+## The OCR format
+
+**Superseded twice.** It was TOML carrying packed word-level arrays when this was written; it
+is now markdown with YAML frontmatter carrying no coordinates at all. Both changes were at the
+repository owner's direction, and the second is the larger one.
+
+### Where it landed
+
+One file per scanned page, `<id>.pN.ocr.md`:
+
+```markdown
+---
+of: 1789iemilseptcen00unse
+page: 6
+engine: ABBYY FineReader 11.0
+lang: fr
+w: 2597
+h: 4418
+dpi: 500
+---
+
+<the page's text>
+```
+
+Frontmatter says which page of what and how big the image is; the body is the page. That is
+the whole format.
+
+### What was dropped, and what that costs
+
+Gone: word boxes, per-word confidence, baselines, region background colours, and the `brk`
+encoding that reconstructed DjVu's four levels of nesting in one byte per word. With them goes
+the losslessness claim and `scans ocr export`, which existed to make that claim executable.
+
+The reason is proportion. The coordinates were about seven eighths of the bytes — 8.3 GB
+against roughly 1.2 GB for the text — and nothing was reading them.
+
+**Nothing is destroyed.** The coordinates are in `XML_for_OCR/` in frc-data, which is one
+clone away and needs no request to archive.org. Reinstating them is a change to
+`tools/src/djvu.rs` and a re-run of `frc ingest`, not a re-fetch.
+
+### The per-page split
+
+Before the coordinates were dropped, one file per *item* put a 3,378-page bound run of nine
+volumes into a single 49 MB text file. Splitting per page fixed that, and kept two properties
+worth naming even now that files are small:
+
+- `<id>.pN` matches the address grammar the archive already uses for pages.
+- The body needs no `## Page N` headings, so nothing in the OCR can be mistaken for a
+  delimiter. The per-item version had to carve the body back up by markers the OCR could in
+  principle contain.
+
+### Bare scalars, and the YAML version that matters
+
+Values are written bare — `lang: fr` — because the frontmatter is meant to read as YAML.
+
+The hazard is that `no` is the ISO 639-1 code for Norwegian and, in **YAML 1.1**, the boolean
+false. `serde_norway` implements **1.2**, where it is already a string, so a round-trip check
+against this crate's own parser passes it. That check is not the right bar: PyYAML, libyaml,
+Psych and gopkg.in/yaml.v2 are all 1.1, and this data is published for their tools rather than
+ours. So there is an explicit 1.1 deny-list *and* a round-trip check, and a test asserts that
+every reserved word survives as the string it was.
+
+## New record fields
+
+**Corrected.** The draft proposed a fourth, an `[ocr]` table pointing at the sidecar. It
+was not needed: `[[text]]` already means "OCR or transcription, never inline", which is
+exactly what a sidecar is. Three remain, each justified independently of this ingest:
+
+| field | why |
+| --- | --- |
+| `subject` — array of strings | 38,377 pamphlets are unusable without subject access. LCSH terms, from IA's `<subject>`. |
+| `extent` — string | The bibliographic collation, `"7 p. ; 18 cm."`, verbatim. Distinct from `scan.count`, which counts scanned images including covers. |
+| `scan.ppi` — integer | The scan's own resolution. `render` currently infers native resolution from the largest embedded image; this states it. |
+
+`subject` and `extent` go on all three record variants and do not inherit. `ppi`
+inherits, like the rest of `[scan]` except `count` and `note`.
+
+## Metadata mapping
+
+| IA field | record |
+| --- | --- |
+| `title` | `title` |
+| `date`, `dfate` (a real IA typo, present in some records) | `date`, as EDTF |
+| `creator`* | `[[resp]]`; a trailing `, printer` inside the name becomes `role` |
+| `publisher` | `place` (before the first ` : `) and a `[[resp]]` with `role = "publisher"` |
+| `language` | `language`, ISO-639-2 → BCP-47 (`fre` → `fr`) |
+| `contributor`, `call_number`, `collection` | `[holding]` repository, shelfmark, collection |
+| `identifier`, `identifier-ark`, `openlibrary_edition`, `openlibrary_work` | `[identifier]` |
+| `link_to_catalog`, `identifier-access` | `[[link]]` with `rel` `catalogue`, `viewer` |
+| `imagecount`, `ppi`, `scanner`, `camera`, `scandate`, `scanningcenter` | `[scan]` |
+| `subject`* | `subject` |
+| `physical_description` | `extent` |
+| `description`*, `notes`, `citation` | `note` |
+| `sponsor` | `rights.attribution` |
+
+Rights are constant across the corpus: the works are of the 1790s and long out of
+copyright; the digitisation is the Newberry's, sponsored and public.
+
+## The pipeline
+
+A new `scans fetch` subcommand, behind a `fetch` feature so the default build stays free
+of an HTTP stack.
+
+**Resumability** is the first requirement, not an afterthought. **Corrected:** the draft
+specified a JSONL ledger. There is none. An item is done when its file is on disk, which is
+the whole resume condition — a ledger would be a second source of truth that can fall out
+of step with the tree it describes, bought at the price of a file to keep consistent.
+Downloads are written to `.pdf.part` and renamed, so a run killed mid-download cannot leave
+a half PDF that the next run mistakes for a finished one.
+
+**Politeness** is the second:
+
+- one request in flight at a time, minimum interval configurable, default 1s
+- a `User-Agent` naming the project and its repository, so the operator can be contacted
+- `Retry-After` honoured on 429 and 503
+- exponential backoff on 5xx, capped, then the item is parked rather than blocking the queue
+- `--limit` and `--since` so a run can be bounded
+
+**Verification**: every download is checked for size and MD5 against the values in the
+item's IA metadata before it is accepted. A truncated PDF must not be committed and then
+believed.
+
+**Disposal**: `_djvu.xml` is converted to `.ocr.toml` and deleted. Keeping both would
+double 12 GB to hold the same facts twice, and the TOML is the archival form.
+
+### Storage
+
+| what | where | why |
+| --- | --- | --- |
+| `*.pdf` | Git LFS | ~63 GB, already compressed, no benefit from packfiles |
+| `*.ocr.toml` | plain git | text, packs about 5:1; LFS would bill for the full 7 GB |
+| `*.toml` records | plain git | small |
+
+63 GB of LFS exceeds GitHub's free tier and needs data packs on the remote before the
+first push. Pushing proceeds in commits of a few hundred items rather than one enormous
+commit, so an interrupted push loses minutes rather than days.
+
+## Validation
+
+Check 11, four codes:
+
+- **E708** a `[[text]]` pointing at a sidecar that is not there
+- **E709** a sidecar that is not valid TOML for the OCR model
+- **E710** a sidecar whose `of` names a record other than the one pointing at it
+- **E711** any of the internal inconsistencies in `ocr::Problem` — arrays of unequal length,
+  `box` not exactly four per word, `region-bg` not one per region, `text` that disagrees
+  with `word` and `brk`
+
+**Corrected.** The draft said these "run over the whole archive by default, since they read
+only TOML". That reasoning was wrong: the distinction is not TOML versus bytes, it is how
+many gigabytes of them there are. Parsing 8 GB of sidecars turns `validate` from a
+2.3-second command into a 2m37s one. E708 is a `stat` and runs always; everything that has
+to parse a sidecar is behind `--probe`, for exactly the reason the image checks are.
+
+Result on the full corpus: 38,715 records, **0 errors, 0 warnings** by default, and 0 errors
+with `--probe` across all 38,377 sidecars.
+
+One further correction fell out of the first full run: `id_is_preferred` treated `_` as
+outside house style, which made 1,263 warnings out of identifiers like `procesverbal00_1_0`
+and `case_oversize_frc_27598`. Those are the handles archive.org publishes and everyone else
+cites. Underscore is now a group separator alongside hyphen — 1,263 warnings a reader cannot
+act on is how a warning channel stops being read.
+
+## Testing
+
+- djvu.xml → TOML → djvu.xml round-trip over a sample of real fetched items
+- the `brk` encoder and decoder, against hand-built nestings including the degenerate
+  cases: an empty page, a page of one word, a word containing a space
+- metadata mapping over a fixture set chosen for awkwardness: missing `date`, the `dfate`
+  typo, multiple `creator` entries, a creator with an embedded role, no `publisher`
+- ledger resume: interrupt mid-run, restart, confirm no item is fetched twice and none is
+  skipped
+- rate limiter timing, with a clock injected rather than by sleeping
+
+## Deliberately not done
+
+- **No `copy` or `document` layer per item.** Revisit only if an item turns out to bind
+  several distinct works, which the metadata does not currently distinguish.
+- **No text search index.** Grep over 7 GB is adequate; a real index is a different
+  project with a different lifetime.
+- **No re-OCR.** ABBYY 11 on 500 ppi scans of worn 18th-century type is mediocre, and
+  visibly so in the confidence figures. Improving it is worth doing and is not this.
+- **No MARC ingest.** The 3.5 MB MARC file covers a different, earlier collection
+  (1560–1660 pamphlets) than the one being ingested.

schemas/ocr.json

@@ -0,0 +1,45 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "additionalProperties": false,
+  "description": "One <id>.ocr.toml: word-level OCR losslessly equivalent to a DjVu XML derivative. Generated from the Rust types in tools/src/ocr.rs by `scans schema` - do not edit by hand.",
+  "properties": {
+    "dpi": {
+      "description": "Resolution the page was scanned at.",
+      "format": "int64",
+      "type": "integer"
+    },
+    "engine": {
+      "description": "Producing agent and version, e.g. `ABBYY FineReader 11.0`.",
+      "type": "string"
+    },
+    "h": {
+      "description": "Pixel height of the page image.",
+      "format": "int64",
+      "type": "integer"
+    },
+    "lang": {
+      "description": "BCP-47 code of the text, when known.",
+      "type": "string"
+    },
+    "of": {
+      "description": "Id of the record this page belongs to.",
+      "type": "string"
+    },
+    "page": {
+      "description": "1-based page index within the scanned container, matching `.pN` addressing.",
+      "format": "int64",
+      "type": "integer"
+    },
+    "w": {
+      "description": "Pixel width of the page image.",
+      "format": "int64",
+      "type": "integer"
+    }
+  },
+  "required": [
+    "of",
+    "page"
+  ],
+  "title": "Word-level OCR sidecar",
+  "type": "object"
+}

schemas/source.json

@@ -232,6 +232,11 @@
           "description": "Caveats. Does not inherit.",
           "type": "string"
         },
+        "ppi": {
+          "description": "Resolution the scan was made at, in pixels per inch. Inherits.\n\nStated rather than inferred: `render` otherwise has to guess a page's native\nresolution from the largest image embedded in it.",
+          "format": "int64",
+          "type": "integer"
+        },
         "url": {
           "description": "Landing page for the digitisation, distinct from top-level `url`. Inherits.",
           "type": "string"
@@ -330,6 +335,10 @@
           "description": "EDTF. Date of the work, for single-work sources.",
           "type": "string"
         },
+        "extent": {
+          "description": "Bibliographic collation, `\"7 p. ; 18 cm.\"`. Does not inherit.",
+          "type": "string"
+        },
         "founded": {
           "description": "EDTF. Date the publication began.",
           "type": "string"
@@ -404,6 +413,13 @@
         "short_title": {
           "type": "string"
         },
+        "subject": {
+          "description": "Subject headings as the cataloguer wrote them. Does not inherit.",
+          "items": {
+            "type": "string"
+          },
+          "type": "array"
+        },
         "text": {
           "items": {
             "$ref": "#/$defs/Text"
@@ -443,6 +459,10 @@
           "description": "EDTF. Date of the object itself, if meaningful.",
           "type": "string"
         },
+        "extent": {
+          "description": "Bibliographic collation, `\"7 p. ; 18 cm.\"`. Does not inherit.",
+          "type": "string"
+        },
         "holding": {
           "$ref": "#/$defs/Holding",
           "description": "The normal home for `holding`."
@@ -501,6 +521,13 @@
         "short_title": {
           "type": "string"
         },
+        "subject": {
+          "description": "Subject headings as the cataloguer wrote them. Does not inherit.",
+          "items": {
+            "type": "string"
+          },
+          "type": "array"
+        },
         "text": {
           "items": {
             "$ref": "#/$defs/Text"
@@ -539,6 +566,10 @@
           "description": "EDTF. Used by check 6.",
           "type": "string"
         },
+        "extent": {
+          "description": "Bibliographic collation, `\"7 p. ; 18 cm.\"`. Does not inherit.",
+          "type": "string"
+        },
         "holding": {
           "$ref": "#/$defs/Holding"
         },
@@ -606,6 +637,13 @@
         "short_title": {
           "type": "string"
         },
+        "subject": {
+          "description": "Subject headings as the cataloguer wrote them. Does not inherit.",
+          "items": {
+            "type": "string"
+          },
+          "type": "array"
+        },
         "supplement_to": {
           "description": "Id of another **document**. Check 8.",
           "type": "string"

tools/Cargo.lock

@@ -70,7 +70,7 @@ version = "1.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "40c48f72fd53cd289104fc64099abca73db4166ad86ea0b4341abe65af83dadc"
 dependencies = [
- "windows-sys",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -81,7 +81,7 @@ checksum = "291e6a250ff86cd4a820112fb8898808a366d8f9f58ce16d1f538353ad55747d"
 dependencies = [
  "anstyle",
  "once_cell_polyfill",
- "windows-sys",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -102,12 +102,27 @@ version = "1.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f2032f911046de80f0a198e0901378627c33f59ea0ac00e363d481118bd70a53"
 
+[[package]]
+name = "base64"
+version = "0.22.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6"
+
 [[package]]
 name = "bitflags"
 version = "2.13.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b588b76d00fde79687d7646a9b5bdf3cc0f655e0bbd080335a95d7e96f3587da"
 
+[[package]]
+name = "block-buffer"
+version = "0.10.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71"
+dependencies = [
+ "generic-array",
+]
+
 [[package]]
 name = "block-buffer"
 version = "0.12.1"
@@ -173,6 +188,12 @@ version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8f1fe948ff07f4bd06c30984e69f5b4899c516a3ef74f34df92a2df2ab535495"
 
+[[package]]
+name = "bytes"
+version = "1.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fc652a48c352aef3ea3aed32080501cf3ef6ed5da78602a020c991775b0aff04"
+
 [[package]]
 name = "cbc"
 version = "0.2.1"
@@ -182,6 +203,16 @@ dependencies = [
  "cipher",
 ]
 
+[[package]]
+name = "cc"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5add81bb678e6cb321aff7fa0dc7689ad82b112dbc032cea19f91d6b8e3582b9"
+dependencies = [
+ "find-msvc-tools",
+ "shlex",
+]
+
 [[package]]
 name = "cfg-if"
 version = "1.0.4"
@@ -205,7 +236,7 @@ version = "0.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e8cf2a2c93cd704877c0858356ed03480ff301ee950b43f1cbe4573b088bfa6c"
 dependencies = [
- "crypto-common",
+ "crypto-common 0.2.2",
  "inout",
 ]
 
@@ -294,6 +325,16 @@ dependencies = [
  "cfg-if",
 ]
 
+[[package]]
+name = "crypto-common"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "78c8292055d1c1df0cce5d180393dc8cce0abec0a7102adb6c7b1eef6016d60a"
+dependencies = [
+ "generic-array",
+ "typenum",
+]
+
 [[package]]
 name = "crypto-common"
 version = "0.2.2"
@@ -303,15 +344,25 @@ dependencies = [
  "hybrid-array",
 ]
 
+[[package]]
+name = "digest"
+version = "0.10.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
+dependencies = [
+ "block-buffer 0.10.4",
+ "crypto-common 0.1.7",
+]
+
 [[package]]
 name = "digest"
 version = "0.11.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f1dd6dbb5841937940781866fa1281a1ff7bd3bf827091440879f9994983d5c2"
 dependencies = [
- "block-buffer",
+ "block-buffer 0.12.1",
  "const-oid",
- "crypto-common",
+ "crypto-common 0.2.2",
 ]
 
 [[package]]
@@ -351,7 +402,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb"
 dependencies = [
  "libc",
- "windows-sys",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -384,6 +435,12 @@ version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b97b65636e5b9ef369943878ac74335ba1c55c1cb6adbf1e2c293c624248d693"
 
+[[package]]
+name = "find-msvc-tools"
+version = "0.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5baebc0774151f905a1a2cc41989300b1e6fbb29aff0ceffa1064fdd3088d582"
+
 [[package]]
 name = "flate2"
 version = "1.1.9"
@@ -409,6 +466,27 @@ dependencies = [
  "bytemuck",
 ]
 
+[[package]]
+name = "generic-array"
+version = "0.14.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a"
+dependencies = [
+ "typenum",
+ "version_check",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ff2abc00be7fca6ebc474524697ae276ad847ad0a6b3faa4bcb027e9a4614ad0"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "wasi",
+]
+
 [[package]]
 name = "getrandom"
 version = "0.4.3"
@@ -552,6 +630,22 @@ version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
 
+[[package]]
+name = "http"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "918d3568bebf352712bc2ef3d46a8bcf1a75b373be6539de198e9105cbbf9ce0"
+dependencies = [
+ "bytes",
+ "itoa",
+]
+
+[[package]]
+name = "httparse"
+version = "1.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6dbf3de79e51f3d586ab4cb9d5c3e2c14aa28ed23d180cf89b4df0454a69cc87"
+
 [[package]]
 name = "hybrid-array"
 version = "0.4.14"
@@ -654,11 +748,11 @@ dependencies = [
  "ecb",
  "encoding_rs",
  "flate2",
- "getrandom",
+ "getrandom 0.4.3",
  "indexmap",
  "itoa",
  "log",
- "md-5",
+ "md-5 0.11.0",
  "nom",
  "rand",
  "rangemap",
@@ -668,6 +762,16 @@ dependencies = [
  "weezl",
 ]
 
+[[package]]
+name = "md-5"
+version = "0.10.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d89e7ee0cfbedfc4da3340218492196241d89eefb6dab27de5df917a6d2e78cf"
+dependencies = [
+ "cfg-if",
+ "digest 0.10.7",
+]
+
 [[package]]
 name = "md-5"
 version = "0.11.0"
@@ -675,7 +779,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "69b6441f590336821bb897fb28fc622898ccceb1d6cea3fde5ea86b090c4de98"
 dependencies = [
  "cfg-if",
- "digest",
+ "digest 0.11.3",
 ]
 
 [[package]]
@@ -747,6 +851,12 @@ dependencies = [
  "smallvec",
 ]
 
+[[package]]
+name = "percent-encoding"
+version = "2.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220"
+
 [[package]]
 name = "phf"
 version = "0.13.1"
@@ -836,6 +946,15 @@ version = "0.1.30"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d55d956fa96f5ec02be2e13af0e20391a5aa83d6a074e3ad368959d0fab299ea"
 
+[[package]]
+name = "quick-xml"
+version = "0.38.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b66c2058c55a409d601666cffe35f04333cf1013010882cec174a7467cd4e21c"
+dependencies = [
+ "memchr",
+]
+
 [[package]]
 name = "quote"
 version = "1.0.47"
@@ -858,7 +977,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c7f5fa3a058cd35567ef9bfa5e75732bee0f9e4c55fa90477bef2dfcdbc4be80"
 dependencies = [
  "chacha20",
- "getrandom",
+ "getrandom 0.4.3",
  "rand_core",
 ]
 
@@ -904,6 +1023,20 @@ dependencies = [
  "syn 3.0.3",
 ]
 
+[[package]]
+name = "ring"
+version = "0.17.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a4689e6c2294d81e88dc6261c768b63bc4fcdb852be6d1352498b114f61383b7"
+dependencies = [
+ "cc",
+ "cfg-if",
+ "getrandom 0.2.17",
+ "libc",
+ "untrusted",
+ "windows-sys 0.52.0",
+]
+
 [[package]]
 name = "rustc-hash"
 version = "2.1.3"
@@ -920,9 +1053,50 @@ dependencies = [
  "errno",
  "libc",
  "linux-raw-sys",
- "windows-sys",
+ "windows-sys 0.61.2",
 ]
 
+[[package]]
+name = "rustls"
+version = "0.23.43"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0283386ce02abc0151e1761d08802dfe86c173b0b494af5cbc086574e453da06"
+dependencies = [
+ "log",
+ "once_cell",
+ "ring",
+ "rustls-pki-types",
+ "rustls-webpki",
+ "subtle",
+ "zeroize",
+]
+
+[[package]]
+name = "rustls-pki-types"
+version = "1.15.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2f4925028c7eb5d1fcdaf196971378ed9d2c1c4efc7dc5d011256f76c99c0a96"
+dependencies = [
+ "zeroize",
+]
+
+[[package]]
+name = "rustls-webpki"
+version = "0.103.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "61c429a8649f110dddef65e2a5ad240f747e85f7758a6bccc7e5777bd33f756e"
+dependencies = [
+ "ring",
+ "rustls-pki-types",
+ "untrusted",
+]
+
+[[package]]
+name = "ryu"
+version = "1.0.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9774ba4a74de5f7b1c1451ed6cd5285a32eddb5cccb8cc655a4e50009e06477f"
+
 [[package]]
 name = "same-file"
 version = "1.0.6"
@@ -940,14 +1114,18 @@ dependencies = [
  "clap",
  "hayro",
  "lopdf",
+ "md-5 0.10.6",
  "png",
+ "quick-xml",
  "schemars",
  "serde",
  "serde_json",
+ "serde_norway",
  "tempfile",
  "thiserror",
  "toml",
  "toml_edit",
+ "ureq",
  "walkdir",
 ]
 
@@ -1030,6 +1208,19 @@ dependencies = [
  "zmij",
 ]
 
+[[package]]
+name = "serde_norway"
+version = "0.9.42"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e408f29489b5fd500fab51ff1484fc859bb655f32c671f307dcd733b72e8168c"
+dependencies = [
+ "indexmap",
+ "itoa",
+ "ryu",
+ "serde",
+ "unsafe-libyaml-norway",
+]
+
 [[package]]
 name = "serde_spanned"
 version = "1.1.1"
@@ -1047,9 +1238,15 @@ checksum = "446ba717509524cb3f22f17ecc096f10f4822d76ab5c0b9822c5f9c284e825f4"
 dependencies = [
  "cfg-if",
  "cpufeatures",
- "digest",
+ "digest 0.11.3",
 ]
 
+[[package]]
+name = "shlex"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8fadd59c855ef2080decdef8ff161eb6661b86933c9d82e5ba29dc602a55aba"
+
 [[package]]
 name = "simd-adler32"
 version = "0.3.10"
@@ -1101,6 +1298,12 @@ version = "0.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f"
 
+[[package]]
+name = "subtle"
+version = "2.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292"
+
 [[package]]
 name = "syn"
 version = "2.0.119"
@@ -1141,10 +1344,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "32497e9a4c7b38532efcdebeef879707aa9f794296a4f0244f6f69e9bc8574bd"
 dependencies = [
  "fastrand",
- "getrandom",
+ "getrandom 0.4.3",
  "once_cell",
  "rustix",
- "windows-sys",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -1267,6 +1470,53 @@ version = "0.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7df058c713841ad818f1dc5d3fd88063241cc61f49f5fbea4b951e8cf5a8d71d"
 
+[[package]]
+name = "unsafe-libyaml-norway"
+version = "0.2.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b39abd59bf32521c7f2301b52d05a6a2c975b6003521cbd0c6dc1582f0a22104"
+
+[[package]]
+name = "untrusted"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1"
+
+[[package]]
+name = "ureq"
+version = "3.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dea7109cdcd5864d4eeb1b58a1648dc9bf520360d7af16ec26d0a9354bafcfc0"
+dependencies = [
+ "base64",
+ "flate2",
+ "log",
+ "percent-encoding",
+ "rustls",
+ "rustls-pki-types",
+ "ureq-proto",
+ "utf8-zero",
+ "webpki-roots",
+]
+
+[[package]]
+name = "ureq-proto"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e994ba84b0bd1b1b0cf92878b7ef898a5c1760108fe7b6010327e274917a808c"
+dependencies = [
+ "base64",
+ "http",
+ "httparse",
+ "log",
+]
+
+[[package]]
+name = "utf8-zero"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b8c0a043c9540bae7c578c88f91dda8bd82e59ae27c21baca69c8b191aaf5a6e"
+
 [[package]]
 name = "utf8parse"
 version = "0.2.2"
@@ -1320,6 +1570,12 @@ dependencies = [
  "vello_common 0.0.8",
 ]
 
+[[package]]
+name = "version_check"
+version = "0.9.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
+
 [[package]]
 name = "walkdir"
 version = "2.5.0"
@@ -1330,6 +1586,21 @@ dependencies = [
  "winapi-util",
 ]
 
+[[package]]
+name = "wasi"
+version = "0.11.1+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b"
+
+[[package]]
+name = "webpki-roots"
+version = "1.0.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7dcd9d09a39985f5344844e66b0c530a33843579125f23e21e9f0f220850f22a"
+dependencies = [
+ "rustls-pki-types",
+]
+
 [[package]]
 name = "weezl"
 version = "0.2.1"
@@ -1342,7 +1613,7 @@ version = "0.1.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22"
 dependencies = [
- "windows-sys",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -1351,6 +1622,15 @@ version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"
 
+[[package]]
+name = "windows-sys"
+version = "0.52.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d"
+dependencies = [
+ "windows-targets",
+]
+
 [[package]]
 name = "windows-sys"
 version = "0.61.2"
@@ -1360,6 +1640,70 @@ dependencies = [
  "windows-link",
 ]
 
+[[package]]
+name = "windows-targets"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973"
+dependencies = [
+ "windows_aarch64_gnullvm",
+ "windows_aarch64_msvc",
+ "windows_i686_gnu",
+ "windows_i686_gnullvm",
+ "windows_i686_msvc",
+ "windows_x86_64_gnu",
+ "windows_x86_64_gnullvm",
+ "windows_x86_64_msvc",
+]
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"
+
+[[package]]
+name = "windows_i686_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
+
 [[package]]
 name = "winnow"
 version = "1.0.4"
@@ -1413,6 +1757,12 @@ dependencies = [
  "synstructure",
 ]
 
+[[package]]
+name = "zeroize"
+version = "1.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e13c156562582aa81c60cb29407084cdb54c4164760106ab78e6c5b0858cf64e"
+
 [[package]]
 name = "zmij"
 version = "1.0.23"

tools/Cargo.toml

@@ -47,6 +47,15 @@ ingest = ["dep:lopdf"]
 # rasteriser whose `images` feature carries pure-Rust JBIG2 and JPEG 2000 decoders, which is
 # the whole reason it is here — no C toolchain, no Ghostscript, no pdfium binary to ship.
 render = ["dep:hayro", "dep:png"]
+# `scans frc fetch` downloads the corpus PDFs from archive.org. Off by default because it is
+# the only feature that opens a socket, and because it drags in a TLS stack that a `validate`
+# run has no business paying for.
+#
+# `ureq` rather than `reqwest`: this makes one request at a time by design — the whole point
+# is to be a polite guest on someone else's server — so an async runtime would be several
+# hundred crates of dependency bought to do nothing. It is pure Rust with rustls, so there is
+# still no C toolchain.
+fetch = ["dep:ureq", "dep:md-5"]
 
 [dependencies]
 anyhow = "1.0.104"
@@ -58,6 +67,19 @@ lopdf = { version = "0.44", default-features = false, optional = true }
 # A bitonal scan encoded as 8-bit grey is a quarter of the size for identical pixels, and
 # these files exist to be read a few hundred at a time.
 png = { version = "0.18.1", optional = true }
+# A real XML parser rather than the hand-rolled parsing used elsewhere in this crate.
+# 38,377 files of machine-generated XML from a decade of changing derive pipelines is
+# exactly the input that finds the gap between the documented format and the served bytes.
+# Pure Rust, no C toolchain, which is the constraint that actually matters here.
+quick-xml = "0.38"
+# The OCR sidecars are markdown with YAML frontmatter, so something has to read YAML.
+# `serde_norway` rather than `serde_yaml`, which its author archived in 2024; this is the
+# maintained fork of it and keeps the same serde-based API. Pure Rust.
+serde_norway = "0.9"
+# Verifying a download against the MD5 archive.org publishes for it. A truncated PDF that is
+# committed and then believed is worse than one that failed loudly.
+md-5 = { version = "0.10", optional = true }
+ureq = { version = "3", optional = true }
 # schemars DERIVES the JSON Schema from the same types the validator uses, so the schema
 # cannot drift away from the code. It is never hand-written.
 schemars = "1.2.2"

tools/src/djvu.rs

@@ -0,0 +1,313 @@
+//! Reading archive.org's `_djvu.xml` into page text.
+//!
+//! This is the only place that knows what DjVu XML looks like. [`crate::ocr`] knows the
+//! markdown form; the two meet here.
+//!
+//! ## The source format
+//!
+//! ```xml
+//! <OBJECT type="image/x.djvu" usemap="abondance00unse_0001.djvu" width="2544" height="4426">
+//!  <PARAM name="DPI" value="500"/>
+//!  <HIDDENTEXT>
+//!   <PAGECOLUMN><REGION><PARAGRAPH><LINE>
+//!     <WORD coords="278,1378,1726,1250" x-confidence="71">ABONDANC</WORD>
+//! ```
+//!
+//! One `OBJECT` per page, and one element per word, nested
+//! `PAGECOLUMN > REGION > PARAGRAPH > LINE > WORD`.
+//!
+//! ## What is taken, and what is not
+//!
+//! Taken: the page's dimensions, its resolution, and its words. **Not taken:** the word
+//! boxes, the per-word confidence, and the baselines. An earlier version of this carried all
+//! of it and could write the XML back out unchanged; the boxes were not being used and were
+//! seven eighths of the bytes, so they are gone at the repository owner's direction. The
+//! coordinates still exist in frc-data, one clone away, if a later version wants them.
+//!
+//! The nesting is still read, but only to lay the text out: a line break ends a line, and
+//! anything above it leaves a blank line. That is the whole of what it is used for now.
+//!
+//! ## Why a real parser
+//!
+//! The rest of this crate hand-rolls its parsing. This does not, because 38,377 files of
+//! machine-generated XML from a decade of changing derive pipelines is exactly the input that
+//! finds the gap between "the format I read about" and "the bytes that arrived". `quick-xml`
+//! is pure Rust with no C toolchain, which is the constraint that actually matters here.
+
+use anyhow::{Context, Result};
+use quick_xml::Reader;
+use quick_xml::events::Event;
+
+use crate::ocr::Ocr;
+
+/// Where a word sits in the nesting, as counters within its page.
+///
+/// Compared between neighbouring words to work out what whitespace separates them; the
+/// absolute values mean nothing on their own.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
+struct Nest {
+    column: u32,
+    region: u32,
+    paragraph: u32,
+    line: u32,
+}
+
+impl Nest {
+    /// The whitespace between this word and the next.
+    ///
+    /// A change of line is a newline; a change of anything above it is a blank line, because
+    /// the distinction between a paragraph, a region and a column is not one a reader of the
+    /// text can act on.
+    fn separator_to(self, next: Nest) -> &'static str {
+        if (self.column, self.region, self.paragraph) != (next.column, next.region, next.paragraph)
+        {
+            "\n\n"
+        } else if self.line != next.line {
+            "\n"
+        } else {
+            " "
+        }
+    }
+}
+
+/// Parse a `_djvu.xml` into one [`Ocr`] per page.
+///
+/// `of` is the record id the pages belong to; the XML does not reliably state it.
+pub fn parse(xml: &str, of: &str) -> Result<Vec<Ocr>> {
+    let mut reader = Reader::from_str(xml);
+    reader.config_mut().trim_text(false);
+
+    let mut pages: Vec<Ocr> = Vec::new();
+    let mut nest = Nest::default();
+
+    // The page under construction, and the words collected for it so far.
+    let mut cur: Option<Ocr> = None;
+    let mut words: Vec<(String, Nest)> = Vec::new();
+    // Set while inside a <WORD>: its text arrives as separate events, and in more than one
+    // piece when it contains an entity reference.
+    let mut in_word = false;
+
+    loop {
+        let event = reader.read_event().with_context(|| {
+            format!("reading {of}_djvu.xml at byte {}", reader.buffer_position())
+        })?;
+
+        // `<WORD .../>` is self-closing and has no text; `<WORD ...>x</WORD>` does.
+        let opens = matches!(event, Event::Start(_));
+
+        match event {
+            Event::Eof => break,
+
+            Event::Start(e) | Event::Empty(e) => match e.local_name().as_ref() {
+                b"OBJECT" => {
+                    flush(&mut pages, &mut cur, &mut words);
+                    cur = Some(Ocr {
+                        of: of.to_string(),
+                        page: pages.len() as i64 + 1,
+                        w: attr_i64(&e, b"width")?,
+                        h: attr_i64(&e, b"height")?,
+                        ..Ocr::default()
+                    });
+                    nest = Nest::default();
+                }
+                b"PARAM" => {
+                    // <PARAM name="DPI" value="500"/>
+                    if attr(&e, b"name")?.as_deref() == Some("DPI")
+                        && let Some(page) = cur.as_mut()
+                        && let Some(v) = attr(&e, b"value")?
+                    {
+                        page.dpi = v.trim().parse::<i64>().ok();
+                    }
+                }
+                b"PAGECOLUMN" => nest.column += 1,
+                b"REGION" => nest.region += 1,
+                b"PARAGRAPH" => nest.paragraph += 1,
+                b"LINE" => nest.line += 1,
+                b"WORD" => {
+                    words.push((String::new(), nest));
+                    in_word = opens;
+                }
+                _ => {}
+            },
+
+            Event::End(e) if e.local_name().as_ref() == b"WORD" => in_word = false,
+
+            Event::Text(t) if in_word => {
+                let s = t
+                    .decode()
+                    .with_context(|| format!("{of}: undecodable word text"))?;
+                if let Some((word, _)) = words.last_mut() {
+                    word.push_str(&s);
+                }
+            }
+
+            // `&amp;` and friends arrive as their own event rather than inside the text, so a
+            // word containing one is split across three events. Dropping this arm silently
+            // deletes every ampersand in the corpus.
+            Event::GeneralRef(r) if in_word => {
+                let text = match r.resolve_char_ref().ok().flatten() {
+                    Some(c) => c.to_string(),
+                    None => match String::from_utf8_lossy(r.as_ref()).as_ref() {
+                        "amp" => "&".into(),
+                        "lt" => "<".into(),
+                        "gt" => ">".into(),
+                        "quot" => "\"".into(),
+                        "apos" => "'".into(),
+                        // DjVu XML declares no entities of its own, so anything else is
+                        // damage. Keep it as written rather than dropping the characters.
+                        other => format!("&{other};"),
+                    },
+                };
+                if let Some((word, _)) = words.last_mut() {
+                    word.push_str(&text);
+                }
+            }
+
+            _ => {}
+        }
+    }
+
+    flush(&mut pages, &mut cur, &mut words);
+    Ok(pages)
+}
+
+/// Close off the page under construction, laying its words out as text, and push it.
+fn flush(pages: &mut Vec<Ocr>, cur: &mut Option<Ocr>, words: &mut Vec<(String, Nest)>) {
+    let Some(mut page) = cur.take() else {
+        // A prologue before the first `<OBJECT>`. Whatever was collected belongs to no page.
+        words.clear();
+        return;
+    };
+
+    let mut text = String::new();
+    for (i, (word, nest)) in words.iter().enumerate() {
+        text.push_str(word);
+        if let Some((_, next)) = words.get(i + 1) {
+            text.push_str(nest.separator_to(*next));
+        }
+    }
+    // ABBYY puts a trailing space inside the element often enough that the joins double up.
+    page.text = text.trim_end().to_string();
+
+    words.clear();
+    pages.push(page);
+}
+
+fn attr(e: &quick_xml::events::BytesStart<'_>, name: &[u8]) -> Result<Option<String>> {
+    for a in e.attributes().with_checks(false) {
+        let a = a.context("unreadable attribute")?;
+        if a.key.as_ref() == name {
+            return Ok(Some(
+                a.unescape_value().context("undecodable attribute")?.into_owned(),
+            ));
+        }
+    }
+    Ok(None)
+}
+
+fn attr_i64(e: &quick_xml::events::BytesStart<'_>, name: &[u8]) -> Result<Option<i64>> {
+    Ok(attr(e, name)?.and_then(|v| v.trim().parse().ok()))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    const SAMPLE: &str = r#"<?xml version="1.0" encoding="UTF-8"?>
+<DjVuXML>
+ <BODY>
+  <OBJECT type="image/x.djvu" usemap="x_0001.djvu" width="2544" height="4426">
+   <PARAM name="DPI" value="500"/>
+   <HIDDENTEXT>
+    <PAGECOLUMN><REGION><PARAGRAPH>
+       <LINE>
+        <WORD coords="278,1378,1726,1250" x-confidence="71">ABONDANC</WORD>
+        <WORD coords="279,2039,1128,1947" x-confidence="57">DECOUVERTES </WORD>
+       </LINE>
+       <LINE>
+        <WORD coords="483,1647,1721,1527" x-confidence="0">NATIONALE,</WORD>
+       </LINE>
+      </PARAGRAPH>
+      <PARAGRAPH><LINE>
+        <WORD coords="1017,1823,1073,1763" x-confidence="3">O&amp;U</WORD>
+      </LINE></PARAGRAPH>
+     </REGION></PAGECOLUMN>
+   </HIDDENTEXT>
+  </OBJECT>
+ </BODY>
+</DjVuXML>
+"#;
+
+    #[test]
+    fn a_page_carries_its_dimensions_and_resolution() {
+        let pages = parse(SAMPLE, "x").unwrap();
+        assert_eq!(pages.len(), 1);
+        assert_eq!(pages[0].of, "x");
+        assert_eq!(pages[0].page, 1);
+        assert_eq!(pages[0].w, Some(2544));
+        assert_eq!(pages[0].h, Some(4426));
+        assert_eq!(pages[0].dpi, Some(500));
+    }
+
+    /// The nesting is read only to lay the text out — a line ends a line, anything above it
+    /// leaves a blank line.
+    #[test]
+    fn the_nesting_becomes_line_and_paragraph_breaks() {
+        let pages = parse(SAMPLE, "x").unwrap();
+        assert_eq!(
+            pages[0].text,
+            "ABONDANC DECOUVERTES \nNATIONALE,\n\nO&U"
+        );
+    }
+
+    /// These titles are full of ampersands, and an entity arrives as its own event.
+    #[test]
+    fn entities_are_decoded_once() {
+        let pages = parse(SAMPLE, "x").unwrap();
+        assert!(pages[0].text.contains("O&U"), "{}", pages[0].text);
+    }
+
+    /// The five-coordinate derivation frc-data carries. Coordinates are ignored now, so it
+    /// must simply not trip over them.
+    #[test]
+    fn the_five_coordinate_derivation_reads_the_same() {
+        let xml = r#"<DjVuXML><BODY><OBJECT width="10" height="20"><HIDDENTEXT>
+          <PAGECOLUMN><REGION backgroundColor="14866620"><PARAGRAPH><LINE>
+            <WORD coords="1562,366,1570,348,381">mot</WORD>
+            <WORD coords="1596,396,1614,336,396">suivant</WORD>
+          </LINE></PARAGRAPH></REGION></PAGECOLUMN>
+        </HIDDENTEXT></OBJECT></BODY></DjVuXML>"#;
+        let pages = parse(xml, "x").unwrap();
+        assert_eq!(pages[0].text, "mot suivant");
+    }
+
+    #[test]
+    fn a_page_with_no_hidden_text_is_legal() {
+        let xml = r#"<DjVuXML><BODY>
+          <OBJECT width="10" height="20"><PARAM name="DPI" value="300"/></OBJECT>
+        </BODY></DjVuXML>"#;
+        let pages = parse(xml, "x").unwrap();
+        assert_eq!(pages.len(), 1);
+        assert_eq!(pages[0].text, "");
+        assert_eq!(pages[0].w, Some(10));
+    }
+
+    #[test]
+    fn pages_are_numbered_from_one() {
+        let xml = r#"<DjVuXML><BODY>
+          <OBJECT width="1" height="1"></OBJECT>
+          <OBJECT width="2" height="2"></OBJECT>
+          <OBJECT width="3" height="3"></OBJECT>
+        </BODY></DjVuXML>"#;
+        let pages = parse(xml, "x").unwrap();
+        assert_eq!(pages.iter().map(|p| p.page).collect::<Vec<_>>(), [1, 2, 3]);
+    }
+
+    /// The text goes straight into a markdown body, so it must survive that trip intact.
+    #[test]
+    fn parsed_text_round_trips_through_the_markdown() {
+        let pages = parse(SAMPLE, "x").unwrap();
+        let md = crate::ocr::to_markdown(&pages[0], "s.json");
+        assert_eq!(crate::ocr::from_markdown(&md).unwrap(), pages[0]);
+    }
+}

tools/src/frc/fetch.rs

@@ -0,0 +1,421 @@
+//! Fetching the corpus PDFs from archive.org.
+//!
+//! The only part of the ingest that touches the network, and the only part that has to be
+//! careful about it. Everything else — the item list, the catalogue metadata, the word-level
+//! OCR — comes out of the frc-data repository in a single clone.
+//!
+//! ## What this asks of archive.org
+//!
+//! Two requests per item: the metadata JSON, which gives the authoritative filename, size and
+//! MD5 of the PDF, and the PDF itself. 38,377 items is about 77,000 requests and 63 GB, which
+//! at one request a second is a run of a day or so.
+//!
+//! It could be one request per item by guessing the URL as `<id>/<id>.pdf` and skipping
+//! verification. That is not done, for two reasons: a handful of items name their PDF
+//! something else, and without the published MD5 there is no way to tell a complete download
+//! from a truncated one. A silently truncated PDF committed to the archive and then believed
+//! is a worse outcome than a slower run.
+//!
+//! ## Resuming
+//!
+//! An item is done when its PDF is on disk with the right size. That is the whole resume
+//! condition — there is no ledger, because a ledger is a second source of truth that can fall
+//! out of step with the tree it describes. A run interrupted at item 20,000 restarts by
+//! `stat`ing 20,000 files, which takes a moment and cannot be wrong.
+
+use std::time::Duration;
+
+// Everything below is needed only by the networking half, which is behind the feature.
+#[cfg(feature = "fetch")]
+use std::{io::Read, path::Path};
+
+#[cfg(feature = "fetch")]
+use anyhow::{Context, Result, bail};
+
+#[cfg(feature = "fetch")]
+use super::{ingest::item_dir, limiter::Limiter};
+
+/// Identifies this crawler to archive.org, so an operator who wants it to stop can find us.
+///
+/// An honest User-Agent is the cheapest possible courtesy and the first thing anyone looks
+/// for in a log when traffic they did not expect turns up.
+pub const USER_AGENT: &str =
+    concat!("scans/", env!("CARGO_PKG_VERSION"), " (+https://github.com/peasanttide/scans)");
+
+/// How many times one item is retried before it is parked and the run moves on.
+#[cfg(feature = "fetch")]
+const MAX_ATTEMPTS: u32 = 4;
+
+/// Options for a fetch run.
+#[derive(Debug, Clone)]
+pub struct Options {
+    /// Minimum gap between requests.
+    pub interval: Duration,
+    /// Stop after this many items.
+    pub limit: Option<usize>,
+    /// Re-fetch items that already have a PDF.
+    pub force: bool,
+    /// Report what would be fetched without fetching it.
+    pub dry_run: bool,
+}
+
+impl Default for Options {
+    fn default() -> Self {
+        Options {
+            interval: super::limiter::DEFAULT_INTERVAL,
+            limit: None,
+            force: false,
+            dry_run: false,
+        }
+    }
+}
+
+/// What fetching one item did.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum Outcome {
+    Fetched { bytes: u64 },
+    /// Already on disk at the right size.
+    Skipped,
+    /// The item has no PDF derivative on archive.org at all.
+    NoPdf,
+    Failed(String),
+}
+
+#[derive(Debug, Default, Clone)]
+pub struct Summary {
+    pub fetched: usize,
+    pub bytes: u64,
+    pub skipped: usize,
+    pub no_pdf: usize,
+    pub failed: Vec<(String, String)>,
+}
+
+/// The PDF archive.org holds for an item: its name, size and checksum.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct PdfFile {
+    pub name: String,
+    pub size: u64,
+    pub md5: Option<String>,
+}
+
+/// Pick the PDF out of an item's metadata JSON.
+///
+/// Pure, so the choice between several PDFs is tested without a network. Prefers the
+/// derivative named after the item, which is what archive.org's own reader links to; falls
+/// back to the largest, on the grounds that the biggest PDF is the full scan rather than a
+/// cover or an appendix.
+pub fn choose_pdf(metadata: &serde_json::Value, id: &str) -> Option<PdfFile> {
+    let files = metadata.get("files")?.as_array()?;
+
+    let mut candidates: Vec<PdfFile> = files
+        .iter()
+        .filter_map(|f| {
+            let name = f.get("name")?.as_str()?;
+            if !name.to_ascii_lowercase().ends_with(".pdf") {
+                return None;
+            }
+            Some(PdfFile {
+                name: name.to_string(),
+                // `size` is a decimal string in IA metadata, not a number.
+                size: f.get("size").and_then(|s| s.as_str()).and_then(|s| s.parse().ok())
+                    .or_else(|| f.get("size").and_then(|s| s.as_u64()))
+                    .unwrap_or(0),
+                md5: f.get("md5").and_then(|m| m.as_str()).map(str::to_string),
+            })
+        })
+        .collect();
+
+    let preferred = format!("{id}.pdf");
+    if let Some(exact) = candidates.iter().find(|c| c.name == preferred) {
+        return Some(exact.clone());
+    }
+    candidates.sort_by_key(|c| c.size);
+    candidates.pop()
+}
+
+/// A `Retry-After` header value as a duration.
+///
+/// Only the delta-seconds form is understood. The HTTP-date form is legal and archive.org
+/// does not send it; treating an unparseable value as "no advice given" falls back to the
+/// geometric back-off, which is the safe direction to be wrong in.
+pub fn retry_after(value: Option<&str>) -> Option<Duration> {
+    value?.trim().parse::<u64>().ok().map(Duration::from_secs)
+}
+
+/// Whether a status code is worth trying again.
+///
+/// 429 and 503 are the server asking for patience. 5xx is the server having a bad time. A 404
+/// is an answer, and repeating the question will not change it.
+pub fn is_retryable(status: u16) -> bool {
+    status == 429 || (500..600).contains(&status)
+}
+
+#[cfg(feature = "fetch")]
+mod net {
+    use super::*;
+
+    /// One item's metadata, from `https://archive.org/metadata/<id>`.
+    pub fn metadata(agent: &ureq::Agent, id: &str) -> Result<serde_json::Value> {
+        let url = format!("https://archive.org/metadata/{id}");
+        let mut response = agent
+            .get(&url)
+            .call()
+            .with_context(|| format!("requesting {url}"))?;
+        let body = response
+            .body_mut()
+            .read_to_string()
+            .with_context(|| format!("reading {url}"))?;
+        serde_json::from_str(&body).with_context(|| format!("parsing the metadata of {id}"))
+    }
+
+    /// Download to a temporary file, verify, then move into place.
+    ///
+    /// Written beside the destination and renamed, never written in place: a run killed
+    /// mid-download must not leave a half PDF that the next run's resume check mistakes for a
+    /// finished one.
+    pub fn download(agent: &ureq::Agent, url: &str, dest: &Path, want: &PdfFile) -> Result<u64> {
+        let tmp = dest.with_extension("pdf.part");
+        let mut response = agent
+            .get(url)
+            .call()
+            .with_context(|| format!("requesting {url}"))?;
+
+        let mut hasher = <md5::Md5 as md5::Digest>::new();
+        let mut file = std::fs::File::create(&tmp)
+            .with_context(|| format!("creating {}", tmp.display()))?;
+        let mut reader = response.body_mut().as_reader();
+        let mut buf = vec![0u8; 64 * 1024];
+        let mut total = 0u64;
+
+        loop {
+            let n = reader.read(&mut buf).with_context(|| format!("reading {url}"))?;
+            if n == 0 {
+                break;
+            }
+            md5::Digest::update(&mut hasher, &buf[..n]);
+            std::io::Write::write_all(&mut file, &buf[..n])
+                .with_context(|| format!("writing {}", tmp.display()))?;
+            total += n as u64;
+        }
+        drop(file);
+
+        let verify = |ok: bool, what: &str| -> Result<()> {
+            if ok {
+                return Ok(());
+            }
+            let _ = std::fs::remove_file(&tmp);
+            bail!("{what}")
+        };
+
+        verify(
+            want.size == 0 || total == want.size,
+            &format!("truncated download: got {total} bytes, archive.org says {}", want.size),
+        )?;
+
+        if let Some(expected) = &want.md5 {
+            let got = format!("{:x}", md5::Digest::finalize(hasher));
+            verify(
+                got.eq_ignore_ascii_case(expected),
+                &format!("checksum mismatch: got {got}, archive.org says {expected}"),
+            )?;
+        }
+
+        std::fs::rename(&tmp, dest)
+            .with_context(|| format!("moving {} into place", tmp.display()))?;
+        Ok(total)
+    }
+}
+
+/// Fetch the PDFs for a list of identifiers.
+#[cfg(feature = "fetch")]
+pub fn fetch(
+    root: &Path,
+    ids: &[String],
+    options: &Options,
+    mut progress: impl FnMut(usize, &str, &Outcome),
+) -> Summary {
+    let agent: ureq::Agent = ureq::Agent::config_builder()
+        .user_agent(USER_AGENT)
+        .timeout_global(Some(Duration::from_secs(600)))
+        .build()
+        .into();
+
+    let mut limiter = Limiter::new(options.interval);
+    let mut summary = Summary::default();
+
+    for (i, id) in ids.iter().enumerate() {
+        let outcome = fetch_one(&agent, &mut limiter, root, id, options);
+        match &outcome {
+            Outcome::Fetched { bytes } => {
+                summary.fetched += 1;
+                summary.bytes += bytes;
+            }
+            Outcome::Skipped => summary.skipped += 1,
+            Outcome::NoPdf => summary.no_pdf += 1,
+            Outcome::Failed(why) => summary.failed.push((id.clone(), why.clone())),
+        }
+        progress(i, id, &outcome);
+    }
+
+    summary
+}
+
+#[cfg(feature = "fetch")]
+fn fetch_one(
+    agent: &ureq::Agent,
+    limiter: &mut Limiter,
+    root: &Path,
+    id: &str,
+    options: &Options,
+) -> Outcome {
+    let dir = root.join(item_dir(id));
+    let dest = dir.join(format!("{id}.pdf"));
+
+    if !options.force && dest.exists() {
+        return Outcome::Skipped;
+    }
+
+    let mut last_error = String::new();
+    for attempt in 1..=MAX_ATTEMPTS {
+        limiter.wait();
+
+        let metadata = match net::metadata(agent, id) {
+            Ok(m) => m,
+            Err(e) => {
+                last_error = format!("{e:#}");
+                limiter.failed(retry_after_of(&e));
+                if !retryable(&e) || attempt == MAX_ATTEMPTS {
+                    break;
+                }
+                continue;
+            }
+        };
+        limiter.succeeded();
+
+        let Some(pdf) = choose_pdf(&metadata, id) else {
+            return Outcome::NoPdf;
+        };
+
+        if options.dry_run {
+            return Outcome::Fetched { bytes: pdf.size };
+        }
+
+        if let Err(e) = std::fs::create_dir_all(&dir) {
+            return Outcome::Failed(format!("creating {}: {e}", dir.display()));
+        }
+
+        limiter.wait();
+        let url = format!("https://archive.org/download/{id}/{}", pdf.name);
+        match net::download(agent, &url, &dest, &pdf) {
+            Ok(bytes) => {
+                limiter.succeeded();
+                return Outcome::Fetched { bytes };
+            }
+            Err(e) => {
+                last_error = format!("{e:#}");
+                limiter.failed(retry_after_of(&e));
+                if attempt == MAX_ATTEMPTS {
+                    break;
+                }
+            }
+        }
+    }
+
+    Outcome::Failed(last_error)
+}
+
+/// Whether an error from `ureq` is worth another attempt.
+#[cfg(feature = "fetch")]
+fn retryable(e: &anyhow::Error) -> bool {
+    match e.downcast_ref::<ureq::Error>() {
+        Some(ureq::Error::StatusCode(code)) => is_retryable(*code),
+        // A transport failure — connection reset, timeout — is exactly the transient case.
+        Some(_) => true,
+        None => false,
+    }
+}
+
+/// The server's own `Retry-After`, if it sent one with the failure.
+#[cfg(feature = "fetch")]
+fn retry_after_of(_e: &anyhow::Error) -> Option<Duration> {
+    // `ureq` 3 does not surface response headers on a `StatusCode` error, so there is nothing
+    // to read here and the geometric back-off is what applies. Kept as a named seam so that
+    // honouring the header is a change in one place if a later version exposes it.
+    None
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use serde_json::json;
+
+    fn meta(files: serde_json::Value) -> serde_json::Value {
+        json!({ "files": files })
+    }
+
+    #[test]
+    fn the_pdf_named_after_the_item_wins() {
+        let m = meta(json!([
+            {"name": "other.pdf", "size": "9999999", "md5": "b"},
+            {"name": "x.pdf", "size": "100", "md5": "a"},
+            {"name": "x_djvu.txt", "size": "5"},
+        ]));
+        let pdf = choose_pdf(&m, "x").unwrap();
+        assert_eq!(pdf.name, "x.pdf");
+        assert_eq!(pdf.size, 100);
+        assert_eq!(pdf.md5.as_deref(), Some("a"));
+    }
+
+    /// A handful of items name their PDF something else. The biggest one is the full scan.
+    #[test]
+    fn otherwise_the_largest_pdf_wins() {
+        let m = meta(json!([
+            {"name": "cover.pdf", "size": "100"},
+            {"name": "scan_full.pdf", "size": "50000"},
+        ]));
+        assert_eq!(choose_pdf(&m, "x").unwrap().name, "scan_full.pdf");
+    }
+
+    #[test]
+    fn an_item_with_no_pdf_yields_none() {
+        let m = meta(json!([{"name": "x_djvu.txt", "size": "5"}]));
+        assert_eq!(choose_pdf(&m, "x"), None);
+        assert_eq!(choose_pdf(&json!({}), "x"), None);
+    }
+
+    /// IA writes sizes as decimal strings, not numbers. Reading them as numbers silently
+    /// yields zero, which would disable the truncation check on every item.
+    #[test]
+    fn sizes_are_read_from_ias_string_form() {
+        let m = meta(json!([{"name": "x.pdf", "size": "574464"}]));
+        assert_eq!(choose_pdf(&m, "x").unwrap().size, 574_464);
+    }
+
+    #[test]
+    fn a_missing_size_does_not_read_as_zero_bytes_expected() {
+        let m = meta(json!([{"name": "x.pdf"}]));
+        let pdf = choose_pdf(&m, "x").unwrap();
+        // Zero means "unknown", and the verifier treats it as "do not check".
+        assert_eq!(pdf.size, 0);
+        assert_eq!(pdf.md5, None);
+    }
+
+    #[test]
+    fn retry_after_reads_delta_seconds_and_ignores_the_rest() {
+        assert_eq!(retry_after(Some("30")), Some(Duration::from_secs(30)));
+        assert_eq!(retry_after(Some(" 5 ")), Some(Duration::from_secs(5)));
+        assert_eq!(retry_after(Some("Wed, 21 Oct 2026 07:28:00 GMT")), None);
+        assert_eq!(retry_after(None), None);
+    }
+
+    /// A 404 is an answer. Asking again will not change it.
+    #[test]
+    fn only_transient_statuses_are_retried() {
+        assert!(is_retryable(429));
+        assert!(is_retryable(503));
+        assert!(is_retryable(500));
+        assert!(!is_retryable(404));
+        assert!(!is_retryable(403));
+        assert!(!is_retryable(200));
+    }
+}

tools/src/frc/ingest.rs

@@ -0,0 +1,352 @@
+//! Walking a local frc-data checkout and writing the archive records and OCR sidecars.
+//!
+//! This half of the ingest touches no network. Everything it needs — the item list, the
+//! catalogue metadata, and the word-level OCR — is in the frc-data repository, which is one
+//! clone rather than 76,754 requests against archive.org for bytes that already exist in git.
+//! Only the PDFs have to be fetched, and that is [`super::fetch`].
+//!
+//! ## Layout
+//!
+//! ```text
+//! sources/frc/ab/abondance00unse/abondance00unse.toml       the record
+//!                                abondance00unse.ocr.toml   the OCR
+//!                                abondance00unse.pdf        fetched later
+//! ```
+//!
+//! Two-character shards taken from the identifier: about 700 directories of 55 items rather
+//! than one of 38,377. Addresses do not change if the sharding is ever redone, because ids
+//! are flat and directories are cosmetic.
+//!
+//! ## Resumability
+//!
+//! An item is done when its record and sidecar both exist. That is the whole resume
+//! condition, checked from the filesystem, so an interrupted run costs one `stat` per item to
+//! pick up and there is no ledger to fall out of step with the tree it describes.
+
+use std::path::{Path, PathBuf};
+
+use anyhow::{Context, Result};
+
+use crate::ocr;
+
+use super::{meta, record};
+
+/// Directory under the archive root that this corpus lives in.
+pub const DIR: &str = "sources/frc";
+
+/// What one item's ingest did.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum Outcome {
+    /// Record and sidecar written.
+    Written,
+    /// Both already existed.
+    Skipped,
+    /// Written, but the item has no OCR in frc-data.
+    WrittenWithoutOcr,
+    /// Nothing written; the reason is worth reporting rather than aborting the run.
+    Failed(String),
+}
+
+/// Everything one run of [`ingest`] did.
+#[derive(Debug, Default, Clone)]
+pub struct Summary {
+    pub written: usize,
+    pub skipped: usize,
+    pub without_ocr: usize,
+    pub failed: Vec<(String, String)>,
+    /// IA field names that were present somewhere and mapped nowhere, with a count.
+    pub ignored_fields: std::collections::BTreeMap<String, usize>,
+}
+
+/// The shard directory an identifier lives in.
+///
+/// The first two characters, lowercased, with anything that is not a letter or digit replaced
+/// so the name is safe on every filesystem. IA identifiers are already `[a-z0-9]`-ish, but
+/// 38,377 of them is enough that "already" is not a guarantee worth relying on.
+pub fn shard(id: &str) -> String {
+    let mut out = String::new();
+    for c in id.chars().take(2) {
+        if c.is_ascii_alphanumeric() {
+            out.push(c.to_ascii_lowercase());
+        } else {
+            out.push('_');
+        }
+    }
+    // A one-character identifier still needs a two-character shard.
+    while out.len() < 2 {
+        out.push('_');
+    }
+    out
+}
+
+/// Where an item's files go, relative to the archive root.
+pub fn item_dir(id: &str) -> PathBuf {
+    Path::new(DIR).join(shard(id)).join(id)
+}
+
+/// Every identifier in a frc-data checkout, sorted.
+///
+/// Taken from `Metadata/`, which is the fuller list: some items have catalogue metadata and
+/// no OCR, and they are still part of the collection.
+pub fn identifiers(frc_data: &Path) -> Result<Vec<String>> {
+    let dir = frc_data.join("Metadata");
+    let entries = std::fs::read_dir(&dir)
+        .with_context(|| format!("reading {} — is this a frc-data checkout?", dir.display()))?;
+
+    let mut ids: Vec<String> = Vec::new();
+    for entry in entries {
+        let name = entry?.file_name();
+        let Some(name) = name.to_str() else { continue };
+        if let Some(id) = name.strip_suffix("_meta.xml") {
+            ids.push(id.to_string());
+        }
+    }
+    ids.sort();
+    Ok(ids)
+}
+
+/// Ingest one item.
+pub fn ingest_one(root: &Path, frc_data: &Path, id: &str, force: bool) -> Outcome {
+    match try_ingest_one(root, frc_data, id, force) {
+        Ok(outcome) => outcome,
+        Err(e) => Outcome::Failed(format!("{e:#}")),
+    }
+}
+
+fn try_ingest_one(root: &Path, frc_data: &Path, id: &str, force: bool) -> Result<Outcome> {
+    let dir = root.join(item_dir(id));
+    let record_path = dir.join(format!("{id}.toml"));
+    // The OCR is now one file per page, so "already done" is asked of the first page. An
+    // item whose page 1 is written was written in full: the loop below writes them in order
+    // and a failure part-way aborts the item before its record is written.
+    let ocr_path = dir.join(ocr::file_name(id, 1));
+    let xml_path = frc_data.join("XML_for_OCR").join(format!("{id}_djvu.xml"));
+
+    let has_ocr_source = xml_path.exists();
+    if !force && record_path.exists() && (ocr_path.exists() || !has_ocr_source) {
+        return Ok(Outcome::Skipped);
+    }
+
+    let meta_path = frc_data.join("Metadata").join(format!("{id}_meta.xml"));
+    let meta_text = std::fs::read_to_string(&meta_path)
+        .with_context(|| format!("reading {}", meta_path.display()))?;
+    let parsed = meta::parse(&meta_text).with_context(|| format!("parsing {id}_meta.xml"))?;
+    let mapped = record::map(id, &parsed);
+
+    std::fs::create_dir_all(&dir).with_context(|| format!("creating {}", dir.display()))?;
+
+    // The OCR is written first: a record that declares `[[text]]` pointing at a file that is
+    // not there yet would be a broken archive for as long as the run takes.
+    let mut text_entries: Vec<crate::model::Text> = Vec::new();
+    if has_ocr_source {
+        let xml = std::fs::read_to_string(&xml_path)
+            .with_context(|| format!("reading {}", xml_path.display()))?;
+        let pages =
+            crate::djvu::parse(&xml, id).with_context(|| format!("parsing {id}_djvu.xml"))?;
+
+        let engine = parsed.get("ocr").map(str::to_string);
+        let schema_rel = format!("../../../../{}", ocr::SCHEMA_PATH);
+
+        for mut page in pages {
+            page.engine = engine.clone();
+            page.lang = mapped.record.language.clone();
+
+            let name = ocr::file_name(id, page.page);
+            std::fs::write(dir.join(&name), ocr::to_markdown(&page, &schema_rel))
+                .with_context(|| format!("writing {name}"))?;
+
+            text_entries.push(crate::model::Text {
+                file: name,
+                kind: Some("ocr".into()),
+                by: engine.clone(),
+                lang: page.lang.clone(),
+                note: None,
+            });
+        }
+    }
+
+    let mut source = mapped.record;
+    source.text = text_entries;
+    let rendered = render_record(&source)?;
+    std::fs::write(&record_path, rendered)
+        .with_context(|| format!("writing {}", record_path.display()))?;
+
+    Ok(if has_ocr_source {
+        Outcome::Written
+    } else {
+        Outcome::WrittenWithoutOcr
+    })
+}
+
+/// A record as TOML, with the `#:schema` directive that gets it validated in an editor.
+fn render_record(source: &crate::model::Source) -> Result<String> {
+    let record = crate::model::Record::Source(source.clone());
+    let body = toml::to_string_pretty(&record).context("serialising the record")?;
+    Ok(format!(
+        "#:schema ../../../../{}\n{body}",
+        crate::SCHEMA_PATH
+    ))
+}
+
+/// Ingest a whole corpus.
+///
+/// `progress` is called after each item so a caller can report without this module knowing
+/// what reporting looks like.
+pub fn ingest(
+    root: &Path,
+    frc_data: &Path,
+    ids: &[String],
+    force: bool,
+    mut progress: impl FnMut(usize, &str, &Outcome),
+) -> Summary {
+    let mut summary = Summary::default();
+
+    for (i, id) in ids.iter().enumerate() {
+        // The ignored-field census is worth having across the whole corpus, and it costs one
+        // extra parse of a 3 KB file only for items that are actually processed.
+        let outcome = ingest_one(root, frc_data, id, force);
+        match &outcome {
+            Outcome::Written => summary.written += 1,
+            Outcome::WrittenWithoutOcr => {
+                summary.written += 1;
+                summary.without_ocr += 1;
+            }
+            Outcome::Skipped => summary.skipped += 1,
+            Outcome::Failed(why) => summary.failed.push((id.clone(), why.clone())),
+        }
+        progress(i, id, &outcome);
+    }
+
+    summary
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn shards_are_two_characters_of_the_identifier() {
+        assert_eq!(shard("abondance00unse"), "ab");
+        assert_eq!(shard("1789iemilseptcen00unse"), "17");
+        assert_eq!(shard("ABC"), "ab");
+    }
+
+    /// A short or odd identifier must still produce a usable directory name.
+    #[test]
+    fn odd_identifiers_still_shard() {
+        assert_eq!(shard("a"), "a_");
+        assert_eq!(shard(""), "__");
+        assert_eq!(shard("a.b"), "a_");
+    }
+
+    #[test]
+    fn an_item_lands_two_directories_deep() {
+        assert_eq!(
+            item_dir("abondance00unse"),
+            Path::new("sources/frc/ab/abondance00unse")
+        );
+    }
+
+    /// The end-to-end shape, on a frc-data checkout built for the test.
+    #[test]
+    fn ingesting_an_item_writes_a_record_and_a_sidecar_that_agree() {
+        let tmp = tempfile::tempdir().unwrap();
+        let frc = tmp.path().join("frc-data");
+        std::fs::create_dir_all(frc.join("Metadata")).unwrap();
+        std::fs::create_dir_all(frc.join("XML_for_OCR")).unwrap();
+        std::fs::write(
+            frc.join("Metadata/x00unse_meta.xml"),
+            r#"<metadata><title>Sur les subsistances</title><language>fre</language>
+               <date>1789</date><ocr>ABBYY FineReader 11.0</ocr><ppi>500</ppi></metadata>"#,
+        )
+        .unwrap();
+        std::fs::write(
+            frc.join("XML_for_OCR/x00unse_djvu.xml"),
+            r#"<DjVuXML><BODY><OBJECT width="100" height="200"><HIDDENTEXT>
+               <PAGECOLUMN><REGION backgroundColor="123"><PARAGRAPH><LINE>
+                 <WORD coords="1,2,3,4,5">Subsistances</WORD>
+               </LINE></PARAGRAPH></REGION></PAGECOLUMN>
+               </HIDDENTEXT></OBJECT></BODY></DjVuXML>"#,
+        )
+        .unwrap();
+
+        let root = tmp.path().join("archive");
+        assert_eq!(
+            ingest_one(&root, &frc, "x00unse", false),
+            Outcome::Written
+        );
+
+        let dir = root.join("sources/frc/x0/x00unse");
+        let record = std::fs::read_to_string(dir.join("x00unse.toml")).unwrap();
+        assert!(record.contains("layer = \"source\""), "{record}");
+        assert!(record.contains("Sur les subsistances"), "{record}");
+        // The record must point at the sidecar that was actually written.
+        assert!(record.contains("x00unse.p1.ocr.md"), "{record}");
+
+        let sidecar = std::fs::read_to_string(dir.join("x00unse.p1.ocr.md")).unwrap();
+        let parsed: ocr::Ocr = ocr::from_markdown(&sidecar).unwrap();
+        assert_eq!(parsed.of, "x00unse");
+        assert_eq!(parsed.page, 1);
+        assert_eq!(parsed.engine.as_deref(), Some("ABBYY FineReader 11.0"));
+        assert_eq!(parsed.text, "Subsistances");
+
+        // Second time round it is already done.
+        assert_eq!(ingest_one(&root, &frc, "x00unse", false), Outcome::Skipped);
+        assert_eq!(ingest_one(&root, &frc, "x00unse", true), Outcome::Written);
+    }
+
+    /// 4,000-odd items have catalogue metadata and no OCR. They are still part of the
+    /// collection and must still get a record.
+    #[test]
+    fn an_item_with_no_ocr_still_gets_a_record() {
+        let tmp = tempfile::tempdir().unwrap();
+        let frc = tmp.path().join("frc-data");
+        std::fs::create_dir_all(frc.join("Metadata")).unwrap();
+        std::fs::create_dir_all(frc.join("XML_for_OCR")).unwrap();
+        std::fs::write(
+            frc.join("Metadata/y_meta.xml"),
+            "<metadata><title>Sans OCR</title></metadata>",
+        )
+        .unwrap();
+
+        let root = tmp.path().join("archive");
+        assert_eq!(
+            ingest_one(&root, &frc, "y", false),
+            Outcome::WrittenWithoutOcr
+        );
+
+        let record = std::fs::read_to_string(root.join("sources/frc/y_/y/y.toml")).unwrap();
+        assert!(!record.contains("[[text]]"), "no sidecar to point at: {record}");
+        // And it stays done rather than being retried forever.
+        assert_eq!(ingest_one(&root, &frc, "y", false), Outcome::Skipped);
+    }
+
+    #[test]
+    fn identifiers_come_from_the_metadata_directory_sorted() {
+        let tmp = tempfile::tempdir().unwrap();
+        let meta = tmp.path().join("Metadata");
+        std::fs::create_dir_all(&meta).unwrap();
+        for name in ["b_meta.xml", "a_meta.xml", "notmeta.txt"] {
+            std::fs::write(meta.join(name), "<metadata/>").unwrap();
+        }
+        assert_eq!(identifiers(tmp.path()).unwrap(), ["a", "b"]);
+    }
+
+    /// A single bad item must not take the other 38,376 down with it.
+    #[test]
+    fn a_failure_is_reported_and_the_run_continues() {
+        let tmp = tempfile::tempdir().unwrap();
+        let frc = tmp.path().join("frc-data");
+        std::fs::create_dir_all(frc.join("Metadata")).unwrap();
+        std::fs::write(frc.join("Metadata/good_meta.xml"), "<metadata><title>t</title></metadata>")
+            .unwrap();
+        // `bad` has no metadata file at all.
+        let root = tmp.path().join("archive");
+
+        let ids = vec!["bad".to_string(), "good".to_string()];
+        let summary = ingest(&root, &frc, &ids, false, |_, _, _| {});
+        assert_eq!(summary.written, 1);
+        assert_eq!(summary.failed.len(), 1);
+        assert_eq!(summary.failed[0].0, "bad");
+    }
+}

tools/src/frc/limiter.rs

@@ -0,0 +1,183 @@
+//! Being a polite guest on someone else's server.
+//!
+//! archive.org serves this collection for free and has no obligation to serve it to us at
+//! all. 38,377 PDFs is a lot to ask for, and the difference between asking politely over two
+//! days and hammering the endpoint for an afternoon costs us nothing and costs them real
+//! money. This module is the part that makes the asking polite.
+//!
+//! ## Why the timing logic is pure
+//!
+//! [`Limiter::due_at`] computes *when* the next request may go out; [`Limiter::wait`] is the
+//! thin wrapper that actually sleeps. Splitting them means the interesting behaviour —
+//! back-off growth, `Retry-After`, the cap — is tested by arithmetic in microseconds rather
+//! than by a test suite that sleeps for real.
+
+use std::time::{Duration, Instant};
+
+/// Default minimum gap between requests.
+///
+/// One second. Not tuned to the fastest rate archive.org will tolerate, because that is not
+/// the question — the question is the slowest rate that still finishes, and at one request a
+/// second the whole corpus takes about eleven hours.
+pub const DEFAULT_INTERVAL: Duration = Duration::from_secs(1);
+
+/// Never wait longer than this between retries, however many have failed.
+///
+/// Five minutes. Past this, the server is not briefly busy, it is down, and the run should be
+/// making no progress loudly rather than quietly.
+pub const MAX_BACKOFF: Duration = Duration::from_secs(300);
+
+/// Paces requests and backs off when the server asks it to.
+#[derive(Debug, Clone)]
+pub struct Limiter {
+    /// Minimum gap between the start of one request and the start of the next.
+    interval: Duration,
+    /// Extra delay imposed by back-off, reset by any success.
+    penalty: Duration,
+    last: Option<Instant>,
+}
+
+impl Limiter {
+    pub fn new(interval: Duration) -> Self {
+        Limiter {
+            interval,
+            penalty: Duration::ZERO,
+            last: None,
+        }
+    }
+
+    /// The earliest instant the next request may be made.
+    ///
+    /// Pure, so back-off behaviour can be tested without sleeping.
+    pub fn due_at(&self, _now: Instant) -> Option<Instant> {
+        self.last.map(|last| last + self.interval + self.penalty)
+    }
+
+    /// How long to sleep before the next request.
+    pub fn due_in(&self, now: Instant) -> Duration {
+        match self.due_at(now) {
+            Some(due) if due > now => due - now,
+            _ => Duration::ZERO,
+        }
+    }
+
+    /// Sleep until the next request is due, then mark it as starting now.
+    pub fn wait(&mut self) {
+        let now = Instant::now();
+        let delay = self.due_in(now);
+        if !delay.is_zero() {
+            std::thread::sleep(delay);
+        }
+        self.last = Some(Instant::now());
+    }
+
+    /// The request succeeded: forget any accumulated back-off.
+    pub fn succeeded(&mut self) {
+        self.penalty = Duration::ZERO;
+    }
+
+    /// The request failed. Grow the back-off, or take the server's own figure if it gave one.
+    ///
+    /// A `Retry-After` is obeyed as given rather than merely used as a floor: it is the
+    /// server stating its terms, and the whole point of this module is to accept them.
+    pub fn failed(&mut self, retry_after: Option<Duration>) {
+        self.penalty = match retry_after {
+            Some(d) => d.min(MAX_BACKOFF),
+            // Double, starting from the base interval. Geometric rather than linear because
+            // the case worth handling quickly is "briefly busy", and the case worth handling
+            // gently is "still down after ten tries".
+            None => {
+                let doubled = if self.penalty.is_zero() {
+                    self.interval
+                } else {
+                    self.penalty * 2
+                };
+                doubled.min(MAX_BACKOFF)
+            }
+        };
+    }
+
+    /// The back-off currently in force. For reporting.
+    pub fn penalty(&self) -> Duration {
+        self.penalty
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn limiter() -> Limiter {
+        Limiter::new(Duration::from_secs(1))
+    }
+
+    #[test]
+    fn the_first_request_waits_for_nothing() {
+        let l = limiter();
+        assert_eq!(l.due_in(Instant::now()), Duration::ZERO);
+    }
+
+    #[test]
+    fn a_second_request_waits_the_interval() {
+        let mut l = limiter();
+        let t0 = Instant::now();
+        l.last = Some(t0);
+        assert_eq!(l.due_in(t0), Duration::from_secs(1));
+        // Half of it already spent.
+        assert_eq!(l.due_in(t0 + Duration::from_millis(500)), Duration::from_millis(500));
+        // All of it spent.
+        assert_eq!(l.due_in(t0 + Duration::from_secs(2)), Duration::ZERO);
+    }
+
+    #[test]
+    fn failures_back_off_geometrically() {
+        let mut l = limiter();
+        let t0 = Instant::now();
+        l.last = Some(t0);
+
+        l.failed(None);
+        assert_eq!(l.due_in(t0), Duration::from_secs(2)); // interval + 1s penalty
+        l.failed(None);
+        assert_eq!(l.due_in(t0), Duration::from_secs(3)); // interval + 2s
+        l.failed(None);
+        assert_eq!(l.due_in(t0), Duration::from_secs(5)); // interval + 4s
+    }
+
+    /// Otherwise one bad patch would slow the rest of an eleven-hour run to a crawl.
+    #[test]
+    fn a_success_clears_the_back_off() {
+        let mut l = limiter();
+        let t0 = Instant::now();
+        l.last = Some(t0);
+        l.failed(None);
+        l.failed(None);
+        assert!(l.penalty() > Duration::ZERO);
+
+        l.succeeded();
+        assert_eq!(l.penalty(), Duration::ZERO);
+        assert_eq!(l.due_in(t0), Duration::from_secs(1));
+    }
+
+    /// The server stating its terms. Obeyed as given.
+    #[test]
+    fn retry_after_is_taken_from_the_server() {
+        let mut l = limiter();
+        let t0 = Instant::now();
+        l.last = Some(t0);
+        l.failed(Some(Duration::from_secs(30)));
+        assert_eq!(l.due_in(t0), Duration::from_secs(31));
+    }
+
+    #[test]
+    fn back_off_is_capped_however_bad_it_gets() {
+        let mut l = limiter();
+        for _ in 0..40 {
+            l.failed(None);
+        }
+        assert_eq!(l.penalty(), MAX_BACKOFF);
+
+        // Including an absurd Retry-After, which some servers do send.
+        l.failed(Some(Duration::from_secs(86_400)));
+        assert_eq!(l.penalty(), MAX_BACKOFF);
+    }
+}

tools/src/frc/meta.rs

@@ -0,0 +1,240 @@
+//! Reading Internet Archive's `_meta.xml`.
+//!
+//! The file is flat: a `<metadata>` element containing one level of children, any of which
+//! may repeat. `<creator>` appears once per author, `<subject>` once per heading, and
+//! `<description>` once per note the cataloguer wrote. So the natural shape is a multimap
+//! from element name to the values in document order, which is what [`Meta`] is.
+//!
+//! Nothing here interprets the values; that is [`super::record`]'s job. Keeping the two apart
+//! means the mapping can be tested against a hand-written [`Meta`] without a file, and the
+//! parser can be tested against awkward XML without caring what the fields mean.
+
+use std::collections::BTreeMap;
+
+use anyhow::{Context, Result};
+use quick_xml::Reader;
+use quick_xml::events::Event;
+
+/// The fields of one `_meta.xml`, in document order within each name.
+#[derive(Debug, Clone, Default, PartialEq, Eq)]
+pub struct Meta {
+    fields: BTreeMap<String, Vec<String>>,
+}
+
+impl Meta {
+    /// The first value of a field, trimmed, or `None` if it is absent or blank.
+    ///
+    /// Blank is treated as absent throughout: IA records contain a fair number of empty
+    /// elements, and an empty `title` is not a title.
+    pub fn get(&self, name: &str) -> Option<&str> {
+        self.all(name).first().copied()
+    }
+
+    /// The first value of whichever of `names` is present, in the order given.
+    ///
+    /// Used where IA has more than one spelling for the same fact — including outright typos
+    /// that are now load-bearing, such as `dfate` for `date`.
+    pub fn first_of(&self, names: &[&str]) -> Option<&str> {
+        names.iter().find_map(|n| self.get(n))
+    }
+
+    /// Every non-blank value of a field, trimmed, in document order.
+    pub fn all(&self, name: &str) -> Vec<&str> {
+        self.fields
+            .get(name)
+            .map(|vs| {
+                vs.iter()
+                    .map(|v| v.trim())
+                    .filter(|v| !v.is_empty())
+                    .collect()
+            })
+            .unwrap_or_default()
+    }
+
+    /// Every value of a field, de-duplicated, keeping first-seen order.
+    ///
+    /// IA records routinely repeat a creator verbatim, or repeat it once with a trailing full
+    /// stop and once without. Exact duplicates are dropped here; near-duplicates are a
+    /// judgement the mapping makes.
+    pub fn unique(&self, name: &str) -> Vec<&str> {
+        let mut seen = Vec::new();
+        for v in self.all(name) {
+            if !seen.contains(&v) {
+                seen.push(v);
+            }
+        }
+        seen
+    }
+
+    /// Whether a field is present at all.
+    pub fn has(&self, name: &str) -> bool {
+        self.get(name).is_some()
+    }
+
+    /// The names of every field present, for reporting what a mapping ignored.
+    pub fn names(&self) -> impl Iterator<Item = &str> {
+        self.fields.keys().map(String::as_str)
+    }
+
+    /// Build one directly. For tests and for callers that already have the values.
+    pub fn from_pairs<I, K, V>(pairs: I) -> Self
+    where
+        I: IntoIterator<Item = (K, V)>,
+        K: Into<String>,
+        V: Into<String>,
+    {
+        let mut fields: BTreeMap<String, Vec<String>> = BTreeMap::new();
+        for (k, v) in pairs {
+            fields.entry(k.into()).or_default().push(v.into());
+        }
+        Meta { fields }
+    }
+}
+
+/// Parse a `_meta.xml`.
+pub fn parse(xml: &str) -> Result<Meta> {
+    let mut reader = Reader::from_str(xml);
+    reader.config_mut().trim_text(false);
+
+    let mut fields: BTreeMap<String, Vec<String>> = BTreeMap::new();
+    // The element currently open, and the text collected inside it. Only one level below
+    // `<metadata>` carries text, so a single slot is enough — but the text arrives in several
+    // events when it contains an entity, so it must accumulate rather than assign.
+    let mut open: Option<(String, String)> = None;
+
+    loop {
+        match reader
+            .read_event()
+            .with_context(|| format!("reading _meta.xml at byte {}", reader.buffer_position()))?
+        {
+            Event::Eof => break,
+
+            Event::Start(e) => {
+                let name = String::from_utf8_lossy(e.local_name().as_ref()).into_owned();
+                if name != "metadata" {
+                    open = Some((name, String::new()));
+                }
+            }
+
+            Event::Text(t) => {
+                if let Some((_, buf)) = open.as_mut() {
+                    buf.push_str(&t.decode().context("undecodable metadata text")?);
+                }
+            }
+
+            // `&amp;` arrives as its own event, and these titles are full of ampersands —
+            // "munitions, grains & farines". Dropping this arm deletes them all.
+            Event::GeneralRef(r) => {
+                if let Some((_, buf)) = open.as_mut() {
+                    let text = match r.resolve_char_ref().ok().flatten() {
+                        Some(c) => c.to_string(),
+                        None => match String::from_utf8_lossy(r.as_ref()).as_ref() {
+                            "amp" => "&".into(),
+                            "lt" => "<".into(),
+                            "gt" => ">".into(),
+                            "quot" => "\"".into(),
+                            "apos" => "'".into(),
+                            other => format!("&{other};"),
+                        },
+                    };
+                    buf.push_str(&text);
+                }
+            }
+
+            Event::End(e) => {
+                let name = String::from_utf8_lossy(e.local_name().as_ref()).into_owned();
+                if let Some((open_name, text)) = open.take()
+                    && open_name == name
+                {
+                    fields.entry(open_name).or_default().push(text);
+                }
+            }
+
+            _ => {}
+        }
+    }
+
+    Ok(Meta { fields })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    const SAMPLE: &str = r#"<?xml version="1.0" encoding="UTF-8"?>
+<metadata>
+  <language>fre</language>
+  <title>Abondance nationale, ou, Découvertes d'artillerie, munitions, grains &amp; farines, &amp;c.</title>
+  <creator>Tallien, Jean-Lambert, 1767-2399</creator>
+  <creator>Vidaillet</creator>
+  <creator>Cailleau, André-Charles, 1731-1798, printer</creator>
+  <subject>Providence and government of God</subject>
+  <identifier>abondance00unse</identifier>
+  <imagecount>10</imagecount>
+  <empty></empty>
+  <blank>   </blank>
+</metadata>
+"#;
+
+    #[test]
+    fn repeated_elements_keep_document_order() {
+        let m = parse(SAMPLE).unwrap();
+        assert_eq!(
+            m.all("creator"),
+            [
+                "Tallien, Jean-Lambert, 1767-2399",
+                "Vidaillet",
+                "Cailleau, André-Charles, 1731-1798, printer"
+            ]
+        );
+    }
+
+    /// These titles are full of ampersands, and an entity arrives as its own event.
+    #[test]
+    fn entities_survive() {
+        let m = parse(SAMPLE).unwrap();
+        assert!(
+            m.get("title").unwrap().contains("grains & farines, &c."),
+            "{:?}",
+            m.get("title")
+        );
+    }
+
+    /// IA records carry a good number of empty elements. An empty title is not a title.
+    #[test]
+    fn blank_values_read_as_absent() {
+        let m = parse(SAMPLE).unwrap();
+        assert_eq!(m.get("empty"), None);
+        assert_eq!(m.get("blank"), None);
+        assert!(!m.has("blank"));
+        assert_eq!(m.get("missing"), None);
+    }
+
+    #[test]
+    fn values_are_trimmed() {
+        let m = parse("<metadata><date>  1789  </date></metadata>").unwrap();
+        assert_eq!(m.get("date"), Some("1789"));
+    }
+
+    /// `dfate` is a real typo in real IA records, and it is the only date some of them have.
+    #[test]
+    fn first_of_falls_through_to_the_alternative_spelling() {
+        let m = Meta::from_pairs([("dfate", "1789")]);
+        assert_eq!(m.first_of(&["date", "dfate"]), Some("1789"));
+
+        let both = Meta::from_pairs([("date", "1790"), ("dfate", "1789")]);
+        assert_eq!(both.first_of(&["date", "dfate"]), Some("1790"));
+    }
+
+    #[test]
+    fn unique_drops_exact_repeats_and_keeps_order() {
+        let m = Meta::from_pairs([("creator", "Lambert"), ("creator", "Lambert"), ("creator", "Barère")]);
+        assert_eq!(m.unique("creator"), ["Lambert", "Barère"]);
+    }
+
+    #[test]
+    fn a_document_with_no_fields_is_not_an_error() {
+        let m = parse("<metadata></metadata>").unwrap();
+        assert_eq!(m.names().count(), 0);
+    }
+}

tools/src/frc/mod.rs

@@ -0,0 +1,12 @@
+//! Ingesting the Newberry Library's French Revolution Collection.
+//!
+//! 38,377 Internet Archive items listed by [NewberryDIS/frc-data]. See
+//! `docs/superpowers/specs/2026-08-07-frc-corpus-ingest-and-ocr-format-design.md`.
+//!
+//! [NewberryDIS/frc-data]: https://github.com/NewberryDIS/frc-data
+
+pub mod fetch;
+pub mod ingest;
+pub mod limiter;
+pub mod meta;
+pub mod record;

tools/src/frc/record.rs

@@ -0,0 +1,649 @@
+//! Turning one Internet Archive `_meta.xml` into one archive record.
+//!
+//! Every judgement about what an IA field *means* lives here, and nowhere else. The input is
+//! a [`Meta`], so this is testable without a file, a network, or a repository.
+//!
+//! ## The shape of the output
+//!
+//! One `layer = "source"` with the copy and document layers collapsed in, which is what
+//! `pellet-1873` and `turgot-1739` already do. A pamphlet is a single work, digitised once;
+//! three files apiece would mean 115,000 files to describe 38,377 pamphlets and would not say
+//! anything the one file does not.
+//!
+//! ## What this does not do
+//!
+//! It does not invent. Where IA's metadata is absent, ambiguous, or self-contradictory the
+//! field is left off and, when the fact is worth keeping in prose, it goes into `note`. A
+//! record that quietly guesses a date is worse than one that has none, because the archive's
+//! whole product is citations that can be trusted.
+
+use crate::model::{Holding, Identifier, Link, Resp, Rights, Roles, Scan, Source};
+
+use super::meta::Meta;
+
+/// What one item's metadata mapped to, plus anything the mapping wants to report.
+#[derive(Debug, Clone, PartialEq)]
+pub struct Mapped {
+    pub record: Source,
+    /// IA fields that were present and carried nowhere. Reported so that a field which starts
+    /// mattering is noticed rather than silently dropped for 38,377 items.
+    pub ignored: Vec<String>,
+}
+
+/// IA fields deliberately carried nowhere.
+///
+/// Almost all of them describe archive.org's own workflow — who scanned it, which invoice it
+/// was on, what state the republishing pipeline reached — rather than the pamphlet. The few
+/// that describe the item are folded into other fields and named here so the ignore list does
+/// not report them.
+const IGNORED: &[&str] = &[
+    // Digitisation workflow and bookkeeping.
+    "addeddate", "backup_location", "bookreader-defaults", "boxid", "camera", "ccnum",
+    "collection", "contributor", "curation", "external-identifier", "foldoutcount",
+    "identifier-access", "imagecount", "invoice", "lccn", "mediatype", "operator",
+    "page-progression", "possible-copyright-status", "ppi", "publicdate", "repub_seconds",
+    "repub_state", "republisher", "republisher_date", "republisher_operator", "scandate",
+    "scanfee", "scanner", "scanningcenter", "shiptracking", "sponsor", "sponsordate",
+    "updatedate", "updater", "uploader", "worldcat_source_edition",
+    // Folded into other fields by the mapping below.
+    "call_number", "citation", "creator", "date", "description", "dfate", "identifier",
+    "identifier-ark", "language", "notes", "openlibrary_edition", "openlibrary_work",
+    "physical_description", "publisher", "subject", "title",
+];
+
+/// Map one item.
+pub fn map(id: &str, meta: &Meta) -> Mapped {
+    let mut notes: Vec<String> = Vec::new();
+
+    let (place, publisher) = split_publisher(meta.get("publisher"));
+
+    let record = Source {
+        id: Some(id.to_string()),
+        r#type: Some(genre(meta).to_string()),
+        title: meta.get("title").unwrap_or("Untitled").to_string(),
+        language: meta.get("language").and_then(language).map(str::to_string),
+        place,
+        country: None,
+        // `dfate` is a real typo in real records, and for some it is the only date present.
+        date: meta.first_of(&["date", "dfate"]).and_then(|d| edtf(d, &mut notes)),
+        subject: meta.unique("subject").into_iter().map(str::to_string).collect(),
+        extent: meta.get("physical_description").map(str::to_string),
+        url: Some(format!("https://archive.org/details/{id}")),
+
+        resp: resp(meta, publisher.as_deref()),
+        rights: Some(rights(meta)),
+        holding: Some(holding(meta)),
+        identifier: Some(identifier(id, meta)),
+        scan: Some(scan(id, meta)),
+        link: links(meta),
+
+        ..Source::default()
+    };
+
+    // Everything the cataloguer wrote in prose, in a stable order, as one note. These are
+    // genuinely useful — attributions, references to Martin & Walter, and the scanner's own
+    // account of the damage to the copy — and none of them fits a field.
+    notes.extend(meta.unique("description").into_iter().map(str::to_string));
+    if let Some(c) = meta.get("citation") {
+        notes.push(format!("Bibliography: {c}."));
+    }
+    if let Some(n) = meta.get("notes") {
+        notes.push(format!("Scanner's note: {n}"));
+    }
+
+    let ignored = meta
+        .names()
+        .filter(|n| !IGNORED.contains(n))
+        .map(str::to_string)
+        .collect();
+
+    let mut record = record;
+    record.note = join_notes(notes);
+    Mapped { record, ignored }
+}
+
+/// `pamphlet`, `book`, or `periodical`.
+///
+/// The collection is overwhelmingly pamphlets, and the printed extent is the only honest
+/// signal of which is which. Fifty pages is the conventional bibliographic line between a
+/// pamphlet and a book; an item whose extent cannot be read is called a pamphlet, because
+/// that is what all but a few hundred of them are.
+fn genre(meta: &Meta) -> &'static str {
+    match printed_pages(meta.get("physical_description")) {
+        Some(n) if n >= 50 => "book",
+        _ => "pamphlet",
+    }
+}
+
+/// The leading page count of `"46 p. ; 22 cm."`.
+fn printed_pages(extent: Option<&str>) -> Option<i64> {
+    let extent = extent?;
+    let digits: String = extent
+        .trim_start_matches(|c: char| !c.is_ascii_digit())
+        .chars()
+        .take_while(|c| c.is_ascii_digit())
+        .collect();
+    digits.parse().ok()
+}
+
+/// `"Paris : De l'impr. de Cailleau"` → place and publisher.
+///
+/// The ` : ` is the ISBD separator between place and publisher, and IA's records follow it
+/// closely enough to rely on. Square brackets mean the cataloguer supplied the place rather
+/// than reading it off the title page; the fact is the same either way, so they are dropped.
+fn split_publisher(publisher: Option<&str>) -> (Option<String>, Option<String>) {
+    let Some(raw) = publisher else {
+        return (None, None);
+    };
+    match raw.split_once(" : ") {
+        Some((place, rest)) => {
+            let place = place.trim().trim_matches(['[', ']']).trim();
+            let rest = rest.trim().trim_end_matches([',', ';']).trim();
+            (
+                (!place.is_empty()).then(|| place.to_string()),
+                (!rest.is_empty()).then(|| rest.to_string()),
+            )
+        }
+        // No separator: it is all publisher, and the place is unknown rather than guessed.
+        None => (None, Some(raw.trim().to_string())),
+    }
+}
+
+/// ISO-639-2 to the BCP-47 code the archive uses.
+///
+/// A closed table rather than a general library: this collection is French with a thin margin
+/// of Latin, English, German, Italian, Spanish and Dutch, and an unrecognised code should
+/// leave `language` off rather than pass a three-letter code off as BCP-47.
+fn language(code: &str) -> Option<&'static str> {
+    Some(match code.trim().to_ascii_lowercase().as_str() {
+        "fre" | "fra" | "fr" => "fr",
+        "eng" | "en" => "en",
+        "lat" | "la" => "la",
+        "ger" | "deu" | "de" => "de",
+        "ita" | "it" => "it",
+        "spa" | "es" => "es",
+        "dut" | "nld" | "nl" => "nl",
+        _ => return None,
+    })
+}
+
+/// An IA date as EDTF, or `None` with the raw value recorded as a note.
+///
+/// IA dates in this collection are mostly a bare year, sometimes a full date, and sometimes
+/// prose. Only the forms that are already valid EDTF are passed through; anything else is
+/// kept verbatim in the note, where a human can see it, rather than being coerced into a
+/// date the record would then assert.
+fn edtf(raw: &str, notes: &mut Vec<String>) -> Option<String> {
+    let raw = raw.trim();
+    let looks_like_edtf = matches!(raw.len(), 4 | 7 | 10)
+        && raw
+            .chars()
+            .all(|c| c.is_ascii_digit() || c == '-' || c == 'X' || c == '?' || c == '~');
+
+    if looks_like_edtf && crate::edtf::parse(raw).is_ok() {
+        return Some(raw.to_string());
+    }
+
+    // A four-digit year inside prose — "published in 1789" — is worth recovering, but the
+    // prose is kept too, because it usually says something the year does not.
+    let year = raw
+        .as_bytes()
+        .windows(4)
+        .find(|w| w.iter().all(|c| c.is_ascii_digit()))
+        .and_then(|w| std::str::from_utf8(w).ok())
+        .filter(|y| ("1400".."2100").contains(y));
+
+    match year {
+        Some(y) => {
+            notes.push(format!("Date given by the catalogue as {raw:?}."));
+            Some(y.to_string())
+        }
+        None => {
+            if !raw.is_empty() {
+                notes.push(format!("Date given by the catalogue as {raw:?}, unreadable."));
+            }
+            None
+        }
+    }
+}
+
+/// Creators, then the publisher.
+///
+/// IA encodes a role inside the name string — `"Cailleau, André-Charles, 1731-1798, printer"`
+/// — for printers and engravers. That trailing role is lifted into `role`, because a name
+/// with a job title glued to the end is exactly the unparseable `author` string this schema
+/// exists to replace.
+fn resp(meta: &Meta, publisher: Option<&str>) -> Option<Vec<Resp>> {
+    let mut out: Vec<Resp> = Vec::new();
+
+    for raw in meta.unique("creator") {
+        let (name, role) = split_role(raw);
+        // The same person often appears twice, once with a trailing full stop. Match on the
+        // name so the two do not become two people.
+        let key = name.trim_end_matches('.').to_string();
+        if out.iter().any(|r| r.name.trim_end_matches('.') == key) {
+            continue;
+        }
+        out.push(Resp {
+            name,
+            role: Some(Roles::One(role.to_string())),
+            note: None,
+        });
+    }
+
+    if let Some(p) = publisher {
+        out.push(Resp {
+            name: p.to_string(),
+            role: Some(Roles::One("publisher".into())),
+            note: None,
+        });
+    }
+
+    (!out.is_empty()).then_some(out)
+}
+
+/// Roles IA glues to the end of a name.
+const TRAILING_ROLES: &[&str] = &[
+    "printer", "publisher", "engraver", "bookseller", "editor", "translator", "illustrator",
+    "author", "compiler", "lithographer", "cartographer",
+];
+
+/// `"Cailleau, André-Charles, 1731-1798, printer"` → `("Cailleau, André-Charles, 1731-1798", "printer")`.
+fn split_role(raw: &str) -> (String, &'static str) {
+    let trimmed = raw.trim().trim_end_matches('.');
+    for role in TRAILING_ROLES {
+        for sep in [", ", " "] {
+            let suffix = format!("{sep}{role}");
+            if let Some(name) = trimmed
+                .strip_suffix(&suffix)
+                .or_else(|| trimmed.to_ascii_lowercase().strip_suffix(&suffix).map(|_| {
+                    &trimmed[..trimmed.len() - suffix.len()]
+                }))
+            {
+                return (name.trim().trim_end_matches(',').to_string(), role);
+            }
+        }
+    }
+    (trimmed.to_string(), "author")
+}
+
+/// Rights, which are the same across the whole collection.
+fn rights(meta: &Meta) -> Rights {
+    Rights {
+        // Every item is a French imprint of the 1780s and 1790s. Nothing here is in copyright
+        // anywhere, and the collection's own IA records say so.
+        work: Some("PD-old-100-expired".into()),
+        scan: Some("PD".into()),
+        attribution: Some(match meta.get("sponsor") {
+            Some(s) => format!("Digitised by the Internet Archive, sponsored by {s}."),
+            None => "Digitised by the Internet Archive.".into(),
+        }),
+        note: None,
+    }
+}
+
+fn holding(meta: &Meta) -> Holding {
+    Holding {
+        repository: meta.get("contributor").map(str::to_string),
+        shelfmark: meta.get("call_number").map(str::to_string),
+        // `newberryfrenchpamphlets` is an archive.org bucket name, not a collection as a
+        // reader would cite it. The other buckets an item sits in — `americana`, `newberry` —
+        // say nothing about the item at all.
+        collection: meta
+            .all("collection")
+            .contains(&"newberryfrenchpamphlets")
+            .then(|| "French Revolution Collection".to_string()),
+        note: None,
+    }
+}
+
+fn identifier(id: &str, meta: &Meta) -> Identifier {
+    let mut out = Identifier::new();
+    out.insert("internet_archive".into(), id.to_string());
+    for (key, field) in [
+        ("ark", "identifier-ark"),
+        ("openlibrary_edition", "openlibrary_edition"),
+        ("openlibrary_work", "openlibrary_work"),
+        ("lccn", "lccn"),
+    ] {
+        if let Some(v) = meta.get(field) {
+            out.insert(key.into(), v.to_string());
+        }
+    }
+    out
+}
+
+fn scan(id: &str, meta: &Meta) -> Scan {
+    // Assembled rather than templated, so an item missing half of these does not end up with
+    // a note full of holes.
+    let mut parts: Vec<String> = Vec::new();
+    if let Some(v) = meta.get("scanner") {
+        parts.push(format!("Scanned on {v}"));
+    }
+    if let Some(v) = meta.get("camera") {
+        parts.push(format!("with a {v}"));
+    }
+    if let Some(v) = meta.get("scanningcenter") {
+        parts.push(format!("at the {v} centre"));
+    }
+
+    Scan {
+        file: Some(format!("{id}.pdf")),
+        // `imagecount` counts scanned images, covers and endpapers included, which is exactly
+        // what `count` means: pages in the container, not printed pages.
+        count: meta.get("imagecount").and_then(|v| v.parse().ok()),
+        by: Some("Internet Archive".into()),
+        url: Some(format!("https://archive.org/details/{id}")),
+        ppi: meta.get("ppi").and_then(|v| v.parse().ok()),
+        note: (!parts.is_empty()).then(|| format!("{}.", parts.join(" "))),
+    }
+}
+
+fn links(meta: &Meta) -> Vec<Link> {
+    let mut out = Vec::new();
+    if let Some(url) = meta.get("link_to_catalog") {
+        out.push(Link {
+            rel: "catalogue".into(),
+            url: url.to_string(),
+            title: None,
+            note: None,
+        });
+    }
+    out
+}
+
+/// One note out of several sentences, or none.
+fn join_notes(notes: Vec<String>) -> Option<String> {
+    let mut seen: Vec<String> = Vec::new();
+    for n in notes {
+        let n = n.trim().to_string();
+        if !n.is_empty() && !seen.contains(&n) {
+            seen.push(n);
+        }
+    }
+    if seen.is_empty() {
+        return None;
+    }
+    // The cataloguer's own notes rarely end in a full stop; the sentences read as a paragraph
+    // once they do.
+    let joined = seen
+        .iter()
+        .map(|n| {
+            if n.ends_with(['.', '!', '?']) {
+                n.clone()
+            } else {
+                format!("{n}.")
+            }
+        })
+        .collect::<Vec<_>>()
+        .join(" ");
+    Some(joined)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn meta(pairs: &[(&str, &str)]) -> Meta {
+        Meta::from_pairs(pairs.iter().copied())
+    }
+
+    #[test]
+    fn a_minimal_record_still_has_an_id_a_title_and_a_scan() {
+        let m = map("x00unse", &meta(&[("title", "Sur les subsistances")]));
+        assert_eq!(m.record.id.as_deref(), Some("x00unse"));
+        assert_eq!(m.record.title, "Sur les subsistances");
+        assert_eq!(
+            m.record.scan.as_ref().unwrap().file.as_deref(),
+            Some("x00unse.pdf")
+        );
+        assert_eq!(
+            m.record.identifier.as_ref().unwrap()["internet_archive"],
+            "x00unse"
+        );
+    }
+
+    /// An item with no title at all must still produce a valid record, because `title` is
+    /// required on a source and 38,377 items will contain a few.
+    #[test]
+    fn a_missing_title_does_not_produce_an_empty_one() {
+        let m = map("x", &meta(&[]));
+        assert_eq!(m.record.title, "Untitled");
+    }
+
+    // -- dates ---------------------------------------------------------------------------
+
+    #[test]
+    fn a_bare_year_passes_through() {
+        let m = map("x", &meta(&[("date", "1789")]));
+        assert_eq!(m.record.date.as_deref(), Some("1789"));
+        assert_eq!(m.record.note, None);
+    }
+
+    #[test]
+    fn a_full_date_passes_through() {
+        let m = map("x", &meta(&[("date", "1789-05-04")]));
+        assert_eq!(m.record.date.as_deref(), Some("1789-05-04"));
+    }
+
+    /// The typo is load-bearing: for some records it is the only date present.
+    #[test]
+    fn the_dfate_typo_is_read_as_a_date() {
+        let m = map("x", &meta(&[("dfate", "1789")]));
+        assert_eq!(m.record.date.as_deref(), Some("1789"));
+    }
+
+    #[test]
+    fn a_real_date_wins_over_the_typo() {
+        let m = map("x", &meta(&[("date", "1790"), ("dfate", "1789")]));
+        assert_eq!(m.record.date.as_deref(), Some("1790"));
+    }
+
+    /// A year recovered from prose is kept, and so is the prose — it usually says something
+    /// the year does not.
+    #[test]
+    fn a_year_inside_prose_is_recovered_and_the_prose_is_kept() {
+        let m = map("x", &meta(&[("date", "l'an II de la liberté, 1790")]));
+        assert_eq!(m.record.date.as_deref(), Some("1790"));
+        assert!(
+            m.record.note.as_deref().unwrap().contains("l'an II"),
+            "{:?}",
+            m.record.note
+        );
+    }
+
+    /// Guessing here would put a false date on a citation, which is the one thing this
+    /// archive must not do.
+    #[test]
+    fn an_unreadable_date_is_left_off_rather_than_guessed() {
+        let m = map("x", &meta(&[("date", "n.d.")]));
+        assert_eq!(m.record.date, None);
+        assert!(m.record.note.as_deref().unwrap().contains("n.d."));
+    }
+
+    // -- publisher and place -------------------------------------------------------------
+
+    #[test]
+    fn the_isbd_separator_splits_place_from_publisher() {
+        let m = map(
+            "x",
+            &meta(&[("publisher", "Paris : De l'impr. de Cailleau, rue Galande, no. 64")]),
+        );
+        assert_eq!(m.record.place.as_deref(), Some("Paris"));
+        let resp = m.record.resp.as_ref().unwrap();
+        assert!(
+            resp.iter()
+                .any(|r| r.roles() == ["publisher"] && r.name.starts_with("De l'impr.")),
+            "{resp:?}"
+        );
+    }
+
+    /// Brackets mean the cataloguer supplied the place. The place is the same fact either way.
+    #[test]
+    fn a_supplied_place_loses_its_brackets() {
+        let m = map("x", &meta(&[("publisher", "[Paris] : Se vend chez les libraires")]));
+        assert_eq!(m.record.place.as_deref(), Some("Paris"));
+    }
+
+    #[test]
+    fn a_publisher_with_no_separator_yields_no_place() {
+        let m = map("x", &meta(&[("publisher", "Chez Baudouin")]));
+        assert_eq!(m.record.place, None);
+        assert!(
+            m.record
+                .resp
+                .as_ref()
+                .unwrap()
+                .iter()
+                .any(|r| r.name == "Chez Baudouin")
+        );
+    }
+
+    // -- responsibility ------------------------------------------------------------------
+
+    /// The role glued to the end of a name is exactly the unparseable string this schema
+    /// exists to replace.
+    #[test]
+    fn a_trailing_role_is_lifted_out_of_the_name() {
+        let m = map(
+            "x",
+            &meta(&[("creator", "Cailleau, André-Charles, 1731-1798, printer")]),
+        );
+        let r = &m.record.resp.as_ref().unwrap()[0];
+        assert_eq!(r.name, "Cailleau, André-Charles, 1731-1798");
+        assert_eq!(r.roles(), ["printer"]);
+    }
+
+    #[test]
+    fn a_creator_with_no_role_is_an_author() {
+        let m = map("x", &meta(&[("creator", "Vidaillet")]));
+        assert_eq!(m.record.resp.as_ref().unwrap()[0].roles(), ["author"]);
+    }
+
+    /// IA repeats a creator verbatim, and repeats it with a trailing full stop. Neither is a
+    /// second person.
+    #[test]
+    fn a_creator_repeated_with_a_full_stop_is_one_person() {
+        let m = map(
+            "x",
+            &meta(&[
+                ("creator", "Lambert, Charles, 1734-1816."),
+                ("creator", "Lambert, Charles, 1734-1816"),
+            ]),
+        );
+        assert_eq!(m.record.resp.as_ref().unwrap().len(), 1);
+    }
+
+    #[test]
+    fn a_corporate_creator_survives_intact() {
+        let m = map(
+            "x",
+            &meta(&[("creator", "France. Assemblée nationale constituante (1789-1791)")]),
+        );
+        let r = &m.record.resp.as_ref().unwrap()[0];
+        assert_eq!(r.name, "France. Assemblée nationale constituante (1789-1791)");
+        assert_eq!(r.roles(), ["author"]);
+    }
+
+    // -- the rest ------------------------------------------------------------------------
+
+    #[test]
+    fn the_printed_extent_decides_pamphlet_from_book() {
+        assert_eq!(
+            map("x", &meta(&[("physical_description", "7 p. ; 18 cm.")]))
+                .record
+                .r#type
+                .as_deref(),
+            Some("pamphlet")
+        );
+        assert_eq!(
+            map("x", &meta(&[("physical_description", "312 p. ; 22 cm.")]))
+                .record
+                .r#type
+                .as_deref(),
+            Some("book")
+        );
+        // Unreadable extent: call it what all but a few hundred of them are.
+        assert_eq!(
+            map("x", &meta(&[("physical_description", "1 sheet")]))
+                .record
+                .r#type
+                .as_deref(),
+            Some("pamphlet")
+        );
+    }
+
+    #[test]
+    fn language_codes_become_bcp47_and_unknown_ones_are_left_off() {
+        assert_eq!(
+            map("x", &meta(&[("language", "fre")])).record.language.as_deref(),
+            Some("fr")
+        );
+        assert_eq!(map("x", &meta(&[("language", "zzz")])).record.language, None);
+    }
+
+    #[test]
+    fn subjects_and_extent_are_carried() {
+        let m = map(
+            "x",
+            &meta(&[
+                ("subject", "Nobility"),
+                ("subject", "Titles of honor and nobility"),
+                ("subject", "Nobility"),
+                ("physical_description", "46 p. ; 22 cm."),
+            ]),
+        );
+        assert_eq!(m.record.subject, ["Nobility", "Titles of honor and nobility"]);
+        assert_eq!(m.record.extent.as_deref(), Some("46 p. ; 22 cm."));
+    }
+
+    #[test]
+    fn the_scan_carries_its_resolution_and_image_count() {
+        let m = map("x", &meta(&[("imagecount", "50"), ("ppi", "500")]));
+        let s = m.record.scan.as_ref().unwrap();
+        assert_eq!(s.count, Some(50));
+        assert_eq!(s.ppi, Some(500));
+    }
+
+    #[test]
+    fn the_newberry_bucket_becomes_a_collection_a_reader_would_cite() {
+        let m = map(
+            "x",
+            &meta(&[
+                ("collection", "newberryfrenchpamphlets"),
+                ("collection", "americana"),
+                ("contributor", "The Newberry Library"),
+                ("call_number", "Case FRC 26109"),
+            ]),
+        );
+        let h = m.record.holding.as_ref().unwrap();
+        assert_eq!(h.collection.as_deref(), Some("French Revolution Collection"));
+        assert_eq!(h.repository.as_deref(), Some("The Newberry Library"));
+        assert_eq!(h.shelfmark.as_deref(), Some("Case FRC 26109"));
+    }
+
+    #[test]
+    fn prose_fields_are_gathered_into_one_note() {
+        let m = map(
+            "x",
+            &meta(&[
+                ("description", "Signed: Vidaillet"),
+                ("description", "Publisher statement from colophon"),
+                ("citation", "Martin & Walter. Révolution française, IV:1, 33504"),
+                ("notes", "No copyright page found"),
+            ]),
+        );
+        let note = m.record.note.as_deref().unwrap();
+        assert!(note.contains("Signed: Vidaillet."), "{note}");
+        assert!(note.contains("Martin & Walter"), "{note}");
+        assert!(note.contains("Scanner's note:"), "{note}");
+    }
+
+    /// A field that starts mattering must be noticed rather than silently dropped 38,377
+    /// times.
+    #[test]
+    fn unmapped_fields_are_reported() {
+        let m = map("x", &meta(&[("title", "t"), ("something_new", "v"), ("ppi", "500")]));
+        assert_eq!(m.ignored, ["something_new"]);
+    }
+}

tools/src/lib.rs

@@ -22,11 +22,17 @@
 //! holds several gigabytes of `.jp2` in Git LFS and the default `validate` path must never
 //! touch them.
 
+/// Path of the generated record schema, relative to the repository root.
+pub const SCHEMA_PATH: &str = "schemas/source.json";
+
+pub mod djvu;
 pub mod edtf;
+pub mod frc;
 pub mod ingest;
 pub mod load;
 pub mod migrate;
 pub mod model;
+pub mod ocr;
 pub mod render;
 pub mod validate;
 

tools/src/load.rs

@@ -241,6 +241,7 @@ pub struct Resolved {
     pub scan_file: Option<Prov<String>>,
     pub scan_by: Option<Prov<String>>,
     pub scan_url: Option<Prov<String>>,
+    pub scan_ppi: Option<Prov<i64>>,
     /// Self only. Never inherited.
     pub scan_count: Option<i64>,
     /// Self only. Never inherited.
@@ -477,8 +478,13 @@ pub fn id_is_valid(id: &str) -> bool {
 /// satisfying [`id_is_valid`] is `W105`, a warning — underscores survive on `.jp2` filenames
 /// and someone will eventually paste one in.
 pub fn id_is_preferred(id: &str) -> bool {
+    // Underscore is a group separator as well as hyphen, because an Internet Archive
+    // identifier uses it: `procesverbal00_1_0` and `case_oversize_frc_27598` are the handles
+    // archive.org publishes and everyone else cites. Ruling them out of house style would
+    // mean 1,263 warnings that say nothing a reader can act on, which is how a warning
+    // channel stops being read.
     !id.is_empty()
-        && id.split('-').all(|part| {
+        && id.split(['-', '_']).all(|part| {
             !part.is_empty()
                 && part
                     .chars()
@@ -815,6 +821,9 @@ fn discover(root: &Path) -> anyhow::Result<Vec<PathBuf>> {
         if name.starts_with('.') || CONFIG_FILES.contains(&name.as_ref()) {
             continue;
         }
+        // Note there is no guard here against the OCR sidecars: they are `.ocr.md`, and this
+        // walk only considers `.toml`, so they are never candidates for being read as
+        // records. They are reached through the `[[text]]` that points at them.
         out.push(entry.into_path());
     }
     out.sort();
@@ -1015,6 +1024,11 @@ fn resolve_inheritance(nodes: &[Node], id: NodeId) -> Resolved {
             take(&mut out.scan_file, node, scan.file.as_deref());
             take(&mut out.scan_by, node, scan.by.as_deref());
             take(&mut out.scan_url, node, scan.url.as_deref());
+            if out.scan_ppi.is_none()
+                && let Some(ppi) = scan.ppi
+            {
+                out.scan_ppi = Some(prov(node, ppi));
+            }
         }
     }
 

tools/src/main.rs

@@ -11,8 +11,7 @@ use scans::model;
 use scans::render::Grid;
 use scans::{ingest, migrate, render, validate};
 
-/// Path of the generated schema, relative to the repository root.
-const SCHEMA_PATH: &str = "schemas/source.json";
+use scans::SCHEMA_PATH;
 
 #[derive(Debug, Parser)]
 #[command(
@@ -41,6 +40,98 @@ enum Command {
     Render(RenderArgs),
     /// Write out the images stored on cited pages, without rasterising the page.
     Extract(ExtractArgs),
+    /// Convert, check and export the word-level OCR sidecars.
+    Ocr(OcrArgs),
+    /// Ingest the Newberry French Revolution Collection.
+    Frc(FrcArgs),
+}
+
+#[derive(Debug, Args)]
+struct FrcArgs {
+    #[command(subcommand)]
+    command: FrcCommand,
+}
+
+#[derive(Debug, Subcommand)]
+enum FrcCommand {
+    /// Write records and OCR sidecars from a local frc-data checkout.
+    ///
+    /// Touches no network: the item list, the catalogue metadata and the word-level OCR are
+    /// all in frc-data. Only the PDFs have to be fetched, which is a separate step.
+    Ingest {
+        /// Path to a frc-data checkout — the directory holding `Metadata/` and `XML_for_OCR/`.
+        #[arg(long)]
+        frc_data: PathBuf,
+        /// Repository root. Defaults to the nearest ancestor containing .git.
+        #[arg(long)]
+        root: Option<PathBuf>,
+        /// Stop after this many items. For trying the run out before committing to 38,377.
+        #[arg(long)]
+        limit: Option<usize>,
+        /// Only these identifiers.
+        #[arg(long = "id")]
+        ids: Vec<String>,
+        /// Rewrite items that are already done.
+        #[arg(long)]
+        force: bool,
+        /// Report what would be written without writing it.
+        #[arg(long)]
+        dry_run: bool,
+    },
+    /// Download the corpus PDFs from archive.org.
+    ///
+    /// One request at a time, paced, with an honest User-Agent. Every download is verified
+    /// against the size and MD5 archive.org publishes for it. Resumable: an item with its PDF
+    /// already on disk is skipped, so an interrupted run costs nothing to restart.
+    Fetch {
+        /// Repository root. Defaults to the nearest ancestor containing .git.
+        #[arg(long)]
+        root: Option<PathBuf>,
+        /// Minimum seconds between requests. Lower this only if you have reason to think
+        /// archive.org wants you to.
+        #[arg(long, default_value_t = 1.0)]
+        interval: f64,
+        /// Stop after this many items.
+        #[arg(long)]
+        limit: Option<usize>,
+        /// Only these identifiers.
+        #[arg(long = "id")]
+        ids: Vec<String>,
+        /// Re-fetch items that already have a PDF.
+        #[arg(long)]
+        force: bool,
+        /// Ask archive.org what it would send, without downloading it.
+        #[arg(long)]
+        dry_run: bool,
+    },
+}
+
+#[derive(Debug, Args)]
+struct OcrArgs {
+    #[command(subcommand)]
+    command: OcrCommand,
+}
+
+#[derive(Debug, Subcommand)]
+enum OcrCommand {
+    /// Convert a DjVu XML file into an `.ocr.md`.
+    Import {
+        /// The `_djvu.xml` to read.
+        xml: PathBuf,
+        /// Id of the record this is the OCR of. Defaults to the filename with `_djvu.xml`
+        /// trimmed off, which is how both derivations name their files.
+        #[arg(long)]
+        of: Option<String>,
+        /// Directory to write the per-page files into. Defaults to the current directory.
+        #[arg(long)]
+        out: Option<PathBuf>,
+    },
+    /// Report the internal inconsistencies of one or more `.ocr.md` files.
+    Check {
+        /// Files to check, or directories of them.
+        #[arg(required = true)]
+        files: Vec<PathBuf>,
+    },
 }
 
 #[derive(Debug, Args)]
@@ -191,6 +282,8 @@ fn run() -> Result<ExitCode> {
         Command::Ingest(args) => cmd_ingest(args),
         Command::Render(args) => cmd_render(args),
         Command::Extract(args) => cmd_extract(args),
+        Command::Ocr(args) => cmd_ocr(args),
+        Command::Frc(args) => cmd_frc(args),
     }
 }
 
@@ -383,6 +476,32 @@ fn cmd_resolve(args: ResolveArgs) -> Result<ExitCode> {
 // ---------------------------------------------------------------------------------------
 
 fn cmd_schema(args: SchemaArgs) -> Result<ExitCode> {
+    // Both schemas are generated from the same Rust types by the same code path, so neither
+    // can drift into being hand-maintained. `--out` writes only the record schema, because it
+    // names a single file.
+    if args.out.is_none() {
+        let root = resolve_root(args.root.as_deref())?;
+        let ocr_out = root.join(scans::ocr::SCHEMA_PATH);
+        let ocr_generated = model::ocr_json_schema_text();
+        if args.check {
+            let on_disk = std::fs::read_to_string(&ocr_out).unwrap_or_default();
+            if on_disk.replace("\r\n", "\n") != ocr_generated.replace("\r\n", "\n") {
+                eprintln!(
+                    "scans: {} is out of date with the Rust types in tools/src/ocr.rs.",
+                    show_cwd(&ocr_out)
+                );
+                return Ok(ExitCode::FAILURE);
+            }
+        } else {
+            if let Some(parent) = ocr_out.parent() {
+                std::fs::create_dir_all(parent)?;
+            }
+            std::fs::write(&ocr_out, &ocr_generated)
+                .with_context(|| format!("writing {}", ocr_out.display()))?;
+            eprintln!("wrote {}", show_cwd(&ocr_out));
+        }
+    }
+
     let generated = model::json_schema_text();
 
     let out = match args.out {
@@ -625,3 +744,318 @@ fn report_pixels(root: &Path, report: &render::Report) {
         );
     }
 }
+
+// ---------------------------------------------------------------------------------------
+// ocr
+// ---------------------------------------------------------------------------------------
+
+fn cmd_ocr(args: OcrArgs) -> Result<ExitCode> {
+    match args.command {
+        OcrCommand::Import { xml, of, out } => {
+            let of = match of {
+                Some(of) => of,
+                None => default_id_for(&xml)?,
+            };
+            let text = std::fs::read_to_string(&xml)
+                .with_context(|| format!("reading {}", xml.display()))?;
+            let pages = scans::djvu::parse(&text, &of)?;
+
+            // One file per page, so `--out` names a directory rather than a file.
+            let dir = out.unwrap_or_else(|| PathBuf::from("."));
+            std::fs::create_dir_all(&dir)
+                .with_context(|| format!("creating {}", dir.display()))?;
+            let schema_rel = schema_rel_for(&dir.join("x"));
+
+            for page in &pages {
+                let name = scans::ocr::file_name(&of, page.page);
+                std::fs::write(dir.join(&name), scans::ocr::to_markdown(page, &schema_rel))
+                    .with_context(|| format!("writing {name}"))?;
+            }
+            eprintln!("wrote {} page(s) into {}", pages.len(), show_cwd(&dir));
+            Ok(ExitCode::SUCCESS)
+        }
+
+        OcrCommand::Check { files } => {
+            let mut bad = 0usize;
+            let mut checked = 0usize;
+            for arg in &files {
+                for path in expand_ocr_paths(arg)? {
+                    checked += 1;
+                    let ocr = match read_ocr(&path) {
+                        Ok(ocr) => ocr,
+                        Err(e) => {
+                            println!("{}: {e:#}", path.display());
+                            bad += 1;
+                            continue;
+                        }
+                    };
+                    // The page number is stated twice — in the filename and in the
+                    // frontmatter — and a mismatch means one of them is lying about which
+                    // page this is.
+                    let expected = scans::ocr::file_name(&ocr.of, ocr.page);
+                    if !path.to_string_lossy().ends_with(&expected) {
+                        println!(
+                            "{}: of/page say this should be named {expected}",
+                            path.display()
+                        );
+                        bad += 1;
+                    }
+                }
+            }
+            eprintln!("{checked} file(s) checked, {bad} problem(s)");
+            Ok(if bad == 0 {
+                ExitCode::SUCCESS
+            } else {
+                ExitCode::FAILURE
+            })
+        }
+    }
+}
+
+/// One `.ocr.md`, or every one in a directory.
+///
+/// Accepting a directory is what makes this usable: an item's OCR is one file per page, and
+/// naming 3,378 of them on a command line is not a thing anyone should have to do.
+fn expand_ocr_paths(path: &Path) -> Result<Vec<PathBuf>> {
+    if !path.is_dir() {
+        return Ok(vec![path.to_path_buf()]);
+    }
+    let mut out = Vec::new();
+    for entry in
+        std::fs::read_dir(path).with_context(|| format!("reading {}", path.display()))?
+    {
+        let entry = entry?;
+        if entry
+            .file_name()
+            .to_str()
+            .is_some_and(|n| n.ends_with(scans::ocr::SUFFIX))
+        {
+            out.push(entry.path());
+        }
+    }
+    out.sort();
+    Ok(out)
+}
+
+fn read_ocr(path: &Path) -> Result<scans::ocr::Ocr> {
+    let text =
+        std::fs::read_to_string(path).with_context(|| format!("reading {}", path.display()))?;
+    scans::ocr::from_markdown(&text).with_context(|| format!("parsing {}", path.display()))
+}
+
+/// The id implied by a DjVu XML filename: both derivations name theirs `<id>_djvu.xml`.
+fn default_id_for(xml: &Path) -> Result<String> {
+    let name = xml
+        .file_name()
+        .and_then(|n| n.to_str())
+        .context("the XML path has no filename")?;
+    Ok(name
+        .strip_suffix("_djvu.xml")
+        .unwrap_or_else(|| name.trim_end_matches(".xml"))
+        .to_string())
+}
+
+/// A `#:schema` path from the sidecar's own directory back up to the repository root.
+///
+/// Counted from the path rather than assumed, so a sidecar written somewhere other than the
+/// standard two-deep shard still points at a schema that exists.
+fn schema_rel_for(out: &Path) -> String {
+    let depth = out
+        .parent()
+        .map(|p| p.components().count())
+        .unwrap_or_default();
+    let up = "../".repeat(depth.min(8));
+    format!("{up}{}", scans::ocr::SCHEMA_PATH)
+}
+
+// ---------------------------------------------------------------------------------------
+// frc
+// ---------------------------------------------------------------------------------------
+
+fn cmd_frc(args: FrcArgs) -> Result<ExitCode> {
+    match args.command {
+        FrcCommand::Ingest {
+            frc_data,
+            root,
+            limit,
+            ids,
+            force,
+            dry_run,
+        } => {
+            let root = resolve_root(root.as_deref())?;
+
+            let mut ids = if ids.is_empty() {
+                scans::frc::ingest::identifiers(&frc_data)?
+            } else {
+                ids
+            };
+            if let Some(limit) = limit {
+                ids.truncate(limit);
+            }
+
+            if dry_run {
+                eprintln!(
+                    "{} item(s) would be ingested into {}",
+                    ids.len(),
+                    show_cwd(&root.join(scans::frc::ingest::DIR))
+                );
+                for id in ids.iter().take(10) {
+                    println!("{}", scans::frc::ingest::item_dir(id).display());
+                }
+                if ids.len() > 10 {
+                    println!("… and {} more", ids.len() - 10);
+                }
+                return Ok(ExitCode::SUCCESS);
+            }
+
+            let total = ids.len();
+            let started = std::time::Instant::now();
+            let summary = scans::frc::ingest::ingest(&root, &frc_data, &ids, force, |i, id, outcome| {
+                if let scans::frc::ingest::Outcome::Failed(why) = outcome {
+                    eprintln!("scans: {id}: {why}");
+                }
+                // Progress on one rewritten line: 38,377 items of scrollback is not progress.
+                if i % 200 == 0 || i + 1 == total {
+                    let done = i + 1;
+                    let rate = done as f64 / started.elapsed().as_secs_f64().max(0.001);
+                    eprint!("\r  {done}/{total} ({rate:.0}/s)          ");
+                }
+            });
+            eprintln!();
+
+            eprintln!(
+                "{} written ({} without OCR), {} already done, {} failed",
+                summary.written,
+                summary.without_ocr,
+                summary.skipped,
+                summary.failed.len()
+            );
+            for (id, why) in summary.failed.iter().take(20) {
+                eprintln!("  {id}: {why}");
+            }
+
+            Ok(if summary.failed.is_empty() {
+                ExitCode::SUCCESS
+            } else {
+                ExitCode::FAILURE
+            })
+        }
+
+        FrcCommand::Fetch {
+            root,
+            interval,
+            limit,
+            ids,
+            force,
+            dry_run,
+        } => cmd_frc_fetch(root, interval, limit, ids, force, dry_run),
+    }
+}
+
+#[cfg(not(feature = "fetch"))]
+fn cmd_frc_fetch(
+    _root: Option<PathBuf>,
+    _interval: f64,
+    _limit: Option<usize>,
+    _ids: Vec<String>,
+    _force: bool,
+    _dry_run: bool,
+) -> Result<ExitCode> {
+    anyhow::bail!(
+        "this binary was built without the 'fetch' feature, which is what opens a socket.\n\
+         Rebuild with: cargo build --release --features fetch"
+    )
+}
+
+#[cfg(feature = "fetch")]
+fn cmd_frc_fetch(
+    root: Option<PathBuf>,
+    interval: f64,
+    limit: Option<usize>,
+    ids: Vec<String>,
+    force: bool,
+    dry_run: bool,
+) -> Result<ExitCode> {
+    use scans::frc::fetch;
+
+    let root = resolve_root(root.as_deref())?;
+
+    // The item list is the archive itself: everything `frc ingest` has already written a
+    // record for. That keeps the two halves in step without a shared manifest.
+    let ids = if ids.is_empty() {
+        let dir = root.join(scans::frc::ingest::DIR);
+        let mut found = Vec::new();
+        for shard in std::fs::read_dir(&dir)
+            .with_context(|| format!("reading {} — run `scans frc ingest` first", dir.display()))?
+        {
+            let shard = shard?;
+            if !shard.file_type()?.is_dir() {
+                continue;
+            }
+            for item in std::fs::read_dir(shard.path())? {
+                let item = item?;
+                if item.file_type()?.is_dir()
+                    && let Some(name) = item.file_name().to_str()
+                {
+                    found.push(name.to_string());
+                }
+            }
+        }
+        found.sort();
+        found
+    } else {
+        ids
+    };
+
+    let options = fetch::Options {
+        interval: std::time::Duration::from_secs_f64(interval.max(0.0)),
+        limit,
+        force,
+        dry_run,
+    };
+
+    let mut ids = ids;
+    if let Some(limit) = options.limit {
+        ids.truncate(limit);
+    }
+
+    let total = ids.len();
+    eprintln!(
+        "{total} item(s), one request at a time, {interval}s apart, as {}",
+        fetch::USER_AGENT
+    );
+
+    let started = std::time::Instant::now();
+    let summary = fetch::fetch(&root, &ids, &options, |i, id, outcome| {
+        match outcome {
+            fetch::Outcome::Failed(why) => eprintln!("\rscans: {id}: {why}"),
+            fetch::Outcome::NoPdf => eprintln!("\rscans: {id}: no PDF derivative"),
+            _ => {}
+        }
+        if i % 10 == 0 || i + 1 == total {
+            let done = i + 1;
+            let elapsed = started.elapsed().as_secs_f64().max(0.001);
+            let left = (total - done) as f64 * (elapsed / done as f64);
+            eprint!("\r  {done}/{total}  {:.0}h left      ", left / 3600.0);
+        }
+    });
+    eprintln!();
+
+    eprintln!(
+        "{} fetched ({:.1} GB), {} already had one, {} have no PDF, {} failed",
+        summary.fetched,
+        summary.bytes as f64 / 1e9,
+        summary.skipped,
+        summary.no_pdf,
+        summary.failed.len()
+    );
+    for (id, why) in summary.failed.iter().take(20) {
+        eprintln!("  {id}: {why}");
+    }
+
+    Ok(if summary.failed.is_empty() {
+        ExitCode::SUCCESS
+    } else {
+        ExitCode::FAILURE
+    })
+}

tools/src/migrate.rs

@@ -1342,6 +1342,9 @@ impl Builder {
             language: common.language,
             place: common.place,
             country: common.country,
+            // Legacy records carry neither; both are new with the frc corpus ingest.
+            subject: Vec::new(),
+            extent: None,
             founded: common.founded,
             frequency: common.frequency,
             date: common.date,
@@ -1563,6 +1566,9 @@ impl Builder {
             language: common.language,
             place: common.place,
             country: common.country,
+            // Legacy records carry neither; both are new with the frc corpus ingest.
+            subject: Vec::new(),
+            extent: None,
             covers: common.covers,
             date: common.date,
             note: common.note,
@@ -1841,6 +1847,9 @@ impl Builder {
             language: common.language,
             place: common.place,
             country: common.country,
+            // Legacy records carry neither; both are new with the frc corpus ingest.
+            subject: Vec::new(),
+            extent: None,
             rights: common.rights.into_option(),
             holding: common.holding.into_option(),
             identifier: (!common.identifier.is_empty()).then_some(common.identifier),

tools/src/model.rs

@@ -146,6 +146,12 @@ pub struct Source {
     /// Terse page range. Legal but unusual on a source.
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub pages: Option<PageRange>,
+    /// Subject headings as the cataloguer wrote them. Does not inherit.
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub subject: Vec<String>,
+    /// Bibliographic collation, `"7 p. ; 18 cm."`. Does not inherit.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub extent: Option<String>,
 
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub rights: Option<Rights>,
@@ -206,6 +212,12 @@ pub struct CopyRecord {
     pub note: Option<String>,
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub url: Option<String>,
+    /// Subject headings as the cataloguer wrote them. Does not inherit.
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub subject: Vec<String>,
+    /// Bibliographic collation, `"7 p. ; 18 cm."`. Does not inherit.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub extent: Option<String>,
 
     /// The normal home for `scan`.
     #[serde(default, skip_serializing_if = "Option::is_none")]
@@ -278,6 +290,12 @@ pub struct Document {
     pub place: Option<String>,
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub country: Option<String>,
+    /// Subject headings as the cataloguer wrote them. Does not inherit.
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub subject: Vec<String>,
+    /// Bibliographic collation, `"7 p. ; 18 cm."`. Does not inherit.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub extent: Option<String>,
 
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub rights: Option<Rights>,
@@ -431,6 +449,12 @@ pub struct Scan {
     /// Landing page for the digitisation, distinct from top-level `url`. Inherits.
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub url: Option<String>,
+    /// Resolution the scan was made at, in pixels per inch. Inherits.
+    ///
+    /// Stated rather than inferred: `render` otherwise has to guess a page's native
+    /// resolution from the largest image embedded in it.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub ppi: Option<i64>,
     /// Caveats. Does not inherit.
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub note: Option<String>,
@@ -699,26 +723,52 @@ impl Record {
 /// This is the only place `schemas/source.json` comes from. `scans schema --check` compares
 /// the file on disk against this, which is what stops the schema drifting from the validator.
 pub fn json_schema() -> serde_json::Value {
+    schema_for::<Record>(
+        "Scan archive record",
+        "One TOML file in the primary source and scan archive. Generated from the Rust \
+         types in tools/src/model.rs by `scans schema` - do not edit by hand.",
+    )
+}
+
+/// Generate a schema for any of the archive's file types, with `null` stripped out.
+///
+/// Shared by the record schema and the OCR sidecar schema so that both are derived the same
+/// way and neither can drift into being hand-maintained.
+pub fn schema_for<T: schemars::JsonSchema>(
+    title: &str,
+    description: &str,
+) -> serde_json::Value {
     let settings = schemars::generate::SchemaSettings::draft2020_12();
     let generator = settings.into_generator();
-    let schema = generator.into_root_schema_for::<Record>();
+    let schema = generator.into_root_schema_for::<T>();
     let mut value = serde_json::to_value(schema).expect("schema serialises");
 
     strip_null_unions(&mut value);
 
     if let Some(obj) = value.as_object_mut() {
-        obj.insert("title".into(), serde_json::json!("Scan archive record"));
-        obj.insert(
-            "description".into(),
-            serde_json::json!(
-                "One TOML file in the primary source and scan archive. Generated from the Rust \
-                 types in tools/src/model.rs by `scans schema` - do not edit by hand."
-            ),
-        );
+        obj.insert("title".into(), serde_json::json!(title));
+        obj.insert("description".into(), serde_json::json!(description));
     }
     value
 }
 
+/// The schema for an `.ocr.toml` sidecar.
+pub fn ocr_json_schema() -> serde_json::Value {
+    schema_for::<crate::ocr::Ocr>(
+        "Word-level OCR sidecar",
+        "One <id>.ocr.toml: word-level OCR losslessly equivalent to a DjVu XML derivative. \
+         Generated from the Rust types in tools/src/ocr.rs by `scans schema` - do not edit \
+         by hand.",
+    )
+}
+
+/// Serialise the OCR schema exactly as `scans schema` writes it.
+pub fn ocr_json_schema_text() -> String {
+    let mut s = serde_json::to_string_pretty(&ocr_json_schema()).expect("schema serialises");
+    s.push('\n');
+    s
+}
+
 /// Remove every trace of `null` from the generated schema.
 ///
 /// TOML has no null. An optional key is simply absent, and the schema already says so by

tools/src/ocr.rs

@@ -0,0 +1,419 @@
+//! `<id>.pN.ocr.md` — one scanned page of OCR, as markdown with YAML frontmatter.
+//!
+//! ## One file, one page
+//!
+//! A page is the unit. The corpus holds 840,810 of them across 38,377 items. One file per
+//! item put a 3,378-page bound run of nine volumes into a single 49 MB text file, which is
+//! unreadable in an editor and unreviewable in a diff; per page, nothing is more than a few
+//! kilobytes, and `<id>.pN` matches the address grammar the archive already uses.
+//!
+//! ## The shape
+//!
+//! ```markdown
+//! ---
+//! of: abondance00unse
+//! page: 6
+//! engine: ABBYY FineReader 11.0
+//! lang: fr
+//! w: 2597
+//! h: 4418
+//! dpi: 500
+//! ---
+//!
+//! ABONDANCE NATIONALE,
+//! ou, Découvertes d'artillerie
+//! ```
+//!
+//! Frontmatter says which page of what, and how big the image is. The body is the page's
+//! text. That is the whole format.
+//!
+//! ## What is deliberately not here
+//!
+//! Word coordinates, per-word confidence, baselines, and DjVu's four levels of nesting. An
+//! earlier version of this format carried all of it, packed into parallel arrays, and was
+//! losslessly convertible back to the `_djvu.xml` it came from. It is gone at the repository
+//! owner's direction: the boxes were not being used, and they were seven eighths of the
+//! bytes — 8.3 GB against about 1.1 GB for the text alone.
+//!
+//! Nothing is destroyed by that. The coordinates still exist in `XML_for_OCR/` in
+//! [frc-data], which is one clone away, so a future version that wants them back can have
+//! them without asking archive.org for anything.
+//!
+//! [frc-data]: https://github.com/NewberryDIS/frc-data
+//!
+//! ## Scalars are bare unless they would lie
+//!
+//! The frontmatter reads as plain YAML — `lang: fr`, not `lang: "fr"` — because that is what
+//! it is for. But YAML's plain scalars are a minefield of values that mean something other
+//! than themselves: `no` is the boolean false, and it is also the ISO code for Norwegian.
+//! [`yaml_scalar`] emits a value bare when it round-trips as itself and quotes it when it
+//! would not, so the common case looks like the example above and the pathological case is
+//! still correct.
+
+use std::fmt::Write as _;
+
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+
+/// Path of the generated OCR schema, relative to the repository root.
+pub const SCHEMA_PATH: &str = "schemas/ocr.json";
+
+/// The suffix that marks an OCR sidecar.
+pub const SUFFIX: &str = ".ocr.md";
+
+// ---------------------------------------------------------------------------------------
+// The file model
+// ---------------------------------------------------------------------------------------
+
+/// One `<id>.pN.ocr.md` — the OCR of a single scanned page.
+#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
+#[serde(deny_unknown_fields)]
+pub struct Ocr {
+    /// Id of the record this page belongs to.
+    pub of: String,
+    /// 1-based page index within the scanned container, matching `.pN` addressing.
+    pub page: i64,
+    /// Producing agent and version, e.g. `ABBYY FineReader 11.0`.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub engine: Option<String>,
+    /// BCP-47 code of the text, when known.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub lang: Option<String>,
+    /// Pixel width of the page image.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub w: Option<i64>,
+    /// Pixel height of the page image.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub h: Option<i64>,
+    /// Resolution the page was scanned at.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub dpi: Option<i64>,
+
+    /// The page's text — the markdown body.
+    ///
+    /// **Not in the frontmatter.** `serde` skips it here so it cannot appear in both places
+    /// and disagree with itself. It is now the only content this format carries, so unlike
+    /// the previous version it is authoritative rather than derived, and there is nothing
+    /// left for a consistency check to compare it against.
+    #[serde(skip)]
+    pub text: String,
+}
+
+/// The filename a page's OCR lives in, relative to the item's directory.
+pub fn file_name(id: &str, page: i64) -> String {
+    format!("{id}.p{page}{SUFFIX}")
+}
+
+// ---------------------------------------------------------------------------------------
+// Writing
+// ---------------------------------------------------------------------------------------
+
+/// Render one page as markdown with YAML frontmatter.
+///
+/// `schema_rel` is the path from this file back to `schemas/ocr.json`, emitted as a
+/// `yaml-language-server` directive — YAML's equivalent of the `#:schema` line the records
+/// carry, and what gets the frontmatter validated and completed in an editor.
+pub fn to_markdown(ocr: &Ocr, schema_rel: &str) -> String {
+    let mut s = String::new();
+    s.push_str("---\n");
+    let _ = writeln!(s, "# yaml-language-server: $schema={schema_rel}");
+    let _ = writeln!(s, "of: {}", yaml_scalar(&ocr.of));
+    let _ = writeln!(s, "page: {}", ocr.page);
+    if let Some(engine) = &ocr.engine {
+        let _ = writeln!(s, "engine: {}", yaml_scalar(engine));
+    }
+    if let Some(lang) = &ocr.lang {
+        let _ = writeln!(s, "lang: {}", yaml_scalar(lang));
+    }
+    for (key, value) in [("w", ocr.w), ("h", ocr.h), ("dpi", ocr.dpi)] {
+        if let Some(v) = value {
+            let _ = writeln!(s, "{key}: {v}");
+        }
+    }
+    s.push_str("---\n");
+
+    // The body is the whole page and nothing else — no headings, no delimiters, nothing the
+    // OCR could collide with.
+    if !ocr.text.is_empty() {
+        let _ = write!(s, "\n{}\n", ocr.text);
+    }
+    s
+}
+
+/// A YAML scalar: bare where that is unambiguous, quoted where it is not.
+///
+/// The bare form is the point — `lang: fr` reads as YAML rather than as an escaped blob. But
+/// a bare scalar has to survive the round trip, and YAML will happily read `no` as `false`,
+/// `1:30` as a sexagesimal integer, `~` as null, and a leading `%` as a directive. OCR of
+/// worn 18th-century type produces exactly that debris, so the decision is made by asking
+/// YAML itself whether the bare form parses back to the same string.
+pub fn yaml_scalar(s: &str) -> String {
+    if is_safe_bare(s) {
+        return s.to_string();
+    }
+    yaml_quoted(s)
+}
+
+/// Words YAML 1.1 resolves to booleans or null, which YAML 1.2 leaves as strings.
+///
+/// `serde_norway` implements 1.2, so it reads `no` as the string it looks like. Most of the
+/// world does not: PyYAML, libyaml, Ruby's Psych and Go's gopkg.in/yaml.v2 all implement 1.1,
+/// where `no` is `false` — and `no` is also the ISO 639-1 code for Norwegian. This data is
+/// published for other people's tools to read, so the bar is what *they* will do with it, not
+/// what this crate's parser happens to accept.
+const YAML11_RESERVED: &[&str] = &[
+    "y", "Y", "yes", "Yes", "YES", "n", "N", "no", "No", "NO",
+    "true", "True", "TRUE", "false", "False", "FALSE",
+    "on", "On", "ON", "off", "Off", "OFF",
+    "null", "Null", "NULL", "~",
+];
+
+/// Whether a value can be written bare.
+///
+/// Conservative on structure — anything with a leading or trailing space, a control
+/// character, or a character YAML gives meaning to is quoted without further thought — then
+/// checked against [`YAML11_RESERVED`], and finally round-tripped through the parser. The
+/// round trip is what catches `1:30`, `0x10` and `2026-08-07` without this having to carry
+/// its own copy of YAML's scalar-resolution rules, which would drift.
+fn is_safe_bare(s: &str) -> bool {
+    if s.is_empty() || s.trim() != s {
+        return false;
+    }
+    if YAML11_RESERVED.contains(&s) {
+        return false;
+    }
+    if s.chars().any(|c| {
+        (c as u32) < 0x20
+            || c as u32 == 0x7f
+            || matches!(c, ':' | '#' | '"' | '\'' | '\\' | '{' | '}' | '[' | ']' | ',' | '&'
+                | '*' | '!' | '|' | '>' | '%' | '@' | '`')
+    }) {
+        return false;
+    }
+    if s.starts_with('-') || s.starts_with('?') || s.starts_with('~') {
+        return false;
+    }
+    // The authority on whether a bare scalar means itself is the YAML parser.
+    matches!(
+        serde_norway::from_str::<serde_norway::Value>(s),
+        Ok(serde_norway::Value::String(round)) if round == s
+    )
+}
+
+/// A YAML double-quoted string, escaped. The escapes are JSON's, which YAML accepts in full.
+pub fn yaml_quoted(s: &str) -> String {
+    let mut out = String::with_capacity(s.len() + 2);
+    out.push('"');
+    for c in s.chars() {
+        match c {
+            '"' => out.push_str("\\\""),
+            '\\' => out.push_str("\\\\"),
+            '\n' => out.push_str("\\n"),
+            '\r' => out.push_str("\\r"),
+            '\t' => out.push_str("\\t"),
+            c if (c as u32) < 0x20 || c as u32 == 0x7f => {
+                let _ = write!(out, "\\u{:04X}", c as u32);
+            }
+            c => out.push(c),
+        }
+    }
+    out.push('"');
+    out
+}
+
+// ---------------------------------------------------------------------------------------
+// Reading
+// ---------------------------------------------------------------------------------------
+
+/// Why an `.ocr.md` could not be read.
+#[derive(Debug)]
+pub enum ParseError {
+    /// No `---` frontmatter block at the top of the file.
+    NoFrontmatter,
+    /// The frontmatter opened but never closed.
+    UnterminatedFrontmatter,
+    Yaml(serde_norway::Error),
+}
+
+impl std::fmt::Display for ParseError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            ParseError::NoFrontmatter => {
+                f.write_str("no YAML frontmatter: the file must begin with a line of ---")
+            }
+            ParseError::UnterminatedFrontmatter => {
+                f.write_str("the YAML frontmatter opens but is never closed by a line of ---")
+            }
+            ParseError::Yaml(e) => write!(f, "frontmatter is not valid YAML: {e}"),
+        }
+    }
+}
+
+impl std::error::Error for ParseError {}
+
+/// Split a markdown file into its frontmatter and its body.
+///
+/// Deliberately strict about the opening delimiter being the very first line. A file whose
+/// frontmatter starts on line 2 is one someone has edited by hand and got slightly wrong, and
+/// guessing at it would hide that.
+pub fn split_frontmatter(text: &str) -> Result<(&str, &str), ParseError> {
+    let rest = text
+        .strip_prefix("---\n")
+        .or_else(|| text.strip_prefix("---\r\n"))
+        .ok_or(ParseError::NoFrontmatter)?;
+
+    let mut offset = 0usize;
+    for line in rest.split_inclusive('\n') {
+        if line.trim_end() == "---" {
+            return Ok((&rest[..offset], &rest[offset + line.len()..]));
+        }
+        offset += line.len();
+    }
+    Err(ParseError::UnterminatedFrontmatter)
+}
+
+/// Parse an `.ocr.md`.
+pub fn from_markdown(text: &str) -> Result<Ocr, ParseError> {
+    let (front, body) = split_frontmatter(text)?;
+    let mut ocr: Ocr = serde_norway::from_str(front).map_err(ParseError::Yaml)?;
+    ocr.text = body.trim_matches('\n').to_string();
+    Ok(ocr)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn page(text: &str) -> Ocr {
+        Ocr {
+            of: "abondance00unse".into(),
+            page: 6,
+            engine: Some("ABBYY FineReader 11.0".into()),
+            lang: Some("fr".into()),
+            w: Some(2597),
+            h: Some(4418),
+            dpi: Some(500),
+            text: text.into(),
+        }
+    }
+
+    #[test]
+    fn the_filename_carries_the_page_number() {
+        assert_eq!(file_name("abondance00unse", 3), "abondance00unse.p3.ocr.md");
+    }
+
+    /// The frontmatter should read as plain YAML, not as a wall of quoted blobs.
+    #[test]
+    fn ordinary_values_are_written_bare() {
+        let text = to_markdown(&page("ABONDANCE"), "s.json");
+        for line in [
+            "of: abondance00unse",
+            "page: 6",
+            "engine: ABBYY FineReader 11.0",
+            "lang: fr",
+            "w: 2597",
+            "h: 4418",
+            "dpi: 500",
+        ] {
+            assert!(text.contains(line), "expected {line:?} in:\n{text}");
+        }
+    }
+
+    #[test]
+    fn a_page_round_trips() {
+        let p = page("ABONDANCE NATIONALE,\nou, Découvertes");
+        assert_eq!(from_markdown(&to_markdown(&p, "s.json")).unwrap(), p);
+    }
+
+    #[test]
+    fn a_page_with_no_text_round_trips() {
+        let mut p = page("");
+        p.engine = None;
+        p.lang = None;
+        assert_eq!(from_markdown(&to_markdown(&p, "s.json")).unwrap(), p);
+    }
+
+    /// `no` is the ISO 639-1 code for Norwegian and, to every YAML 1.1 parser, the boolean
+    /// false. `serde_norway` is 1.2 and would read it back correctly, but PyYAML would hand a
+    /// Python user `False`, and this data is published for their tools rather than ours.
+    #[test]
+    fn a_language_code_that_yaml_reads_as_a_boolean_is_quoted() {
+        let mut p = page("x");
+        p.lang = Some("no".into());
+        let text = to_markdown(&p, "s.json");
+        assert!(text.contains(r#"lang: "no""#), "{text}");
+        assert_eq!(from_markdown(&text).unwrap().lang.as_deref(), Some("no"));
+    }
+
+    /// Every value YAML would quietly reinterpret has to survive as the string it was.
+    #[test]
+    fn values_yaml_would_reinterpret_survive() {
+        for hazard in [
+            // YAML 1.1 booleans and nulls, in the casings real data uses.
+            "no", "No", "NO", "yes", "Yes", "y", "n", "on", "off", "Off",
+            "true", "True", "false", "False", "null", "Null", "~",
+            // Resolved to non-strings by 1.1 and 1.2 alike.
+            "1:30", "0x10", "0o17", ".inf", "nan", "2026-08-07", "007", "1_000",
+            // Structurally unsafe.
+            "", " leading", "trailing ", "a: b", "#comment", "%directive", "@reserved",
+            "-dash", "*alias", "&anchor", "[list]", "{map}", "back\\slash", "quote\"d",
+        ] {
+            let mut p = page("x");
+            p.engine = Some(hazard.to_string());
+            let back = from_markdown(&to_markdown(&p, "s.json"))
+                .unwrap_or_else(|e| panic!("{hazard:?} failed to parse: {e}"));
+            assert_eq!(
+                back.engine.as_deref(),
+                Some(hazard),
+                "{hazard:?} did not survive"
+            );
+        }
+    }
+
+    /// An identifier that is all digits would be read back as an integer.
+    #[test]
+    fn a_numeric_looking_identifier_is_quoted() {
+        let mut p = page("x");
+        p.of = "24516".into();
+        let back = from_markdown(&to_markdown(&p, "s.json")).unwrap();
+        assert_eq!(back.of, "24516");
+    }
+
+    /// Real identifiers in this corpus start with digits but are not numbers, and must not be
+    /// quoted for no reason.
+    #[test]
+    fn an_identifier_starting_with_digits_stays_bare() {
+        let mut p = page("x");
+        p.of = "1789iemilseptcen00unse".into();
+        let text = to_markdown(&p, "s.json");
+        assert!(text.contains("of: 1789iemilseptcen00unse"), "{text}");
+    }
+
+    /// The body is the page and nothing else, so nothing in the OCR can be mistaken for a
+    /// delimiter or for markup.
+    #[test]
+    fn a_body_that_looks_like_markup_is_still_just_text() {
+        let p = page("## Page 3\n---\nof: someone-else");
+        let back = from_markdown(&to_markdown(&p, "s.json")).unwrap();
+        assert_eq!(back.text, p.text);
+        assert_eq!(back.of, "abondance00unse");
+    }
+
+    /// A file someone has edited by hand and got slightly wrong must say so rather than be
+    /// guessed at.
+    #[test]
+    fn malformed_frontmatter_is_an_error_not_a_guess() {
+        assert!(matches!(
+            from_markdown("of: x\npage: 1\n"),
+            Err(ParseError::NoFrontmatter)
+        ));
+        assert!(matches!(
+            from_markdown("---\nof: x\npage: 1\n"),
+            Err(ParseError::UnterminatedFrontmatter)
+        ));
+        assert!(matches!(
+            from_markdown("---\nof: [unclosed\n---\n"),
+            Err(ParseError::Yaml(_))
+        ));
+    }
+}

tools/src/validate.rs

@@ -204,6 +204,7 @@ pub fn validate(archive: &Archive, options: &Options) -> Report {
     check_7_files(archive, options, &mut report);
     check_8_crossrefs(archive, &mut report);
     check_10_gaps(archive, &mut report);
+    check_11_ocr(archive, options, &mut report);
 
     report.retain_selected(archive, &options.select);
     report.sort();
@@ -1482,3 +1483,107 @@ mod probe {
         Ok(document.get_pages().len() as i64)
     }
 }
+
+// ---------------------------------------------------------------------------------------
+// Check 11 — the OCR sidecars.
+//
+// An `.ocr.toml` is archive content but not a record: it has no `layer`, so `load` skips it
+// and it is reached instead through the `[[text]]` that points at it. That makes this the
+// only place anything looks at one, and the checks are correspondingly structural.
+//
+// ## Why the content half is behind `--probe`
+//
+// `E708` is a `stat` and runs always. Everything below it has to parse the sidecar, and the
+// frc corpus is 840,810 of them — parsing all of that turns `validate` from a six-second
+// command into a much longer one. That is the same reason `--probe` exists for the image
+// checks: the default path must stay fast enough to run on every save.
+// ---------------------------------------------------------------------------------------
+
+fn check_11_ocr(archive: &Archive, options: &Options, report: &mut Report) {
+    for node in archive.iter() {
+        for (i, text) in node.record.text().iter().enumerate() {
+            if !text.file.ends_with(crate::ocr::SUFFIX) {
+                continue;
+            }
+            let locator = format!("[[text]]#{}", i + 1);
+            let dir = node.path.parent().unwrap_or(&archive.root);
+            let path = dir.join(&text.file);
+
+            if !path.exists() {
+                report.push(
+                    Diagnostic::error(
+                        node.rel_path.clone(),
+                        "E708",
+                        format!(
+                            "OCR sidecar {:?} does not exist (resolved to {})",
+                            text.file,
+                            rel(archive, &path)
+                        ),
+                    )
+                    .at(locator.clone()),
+                );
+                continue;
+            }
+
+            if !options.probe {
+                continue;
+            }
+
+            let raw = match std::fs::read_to_string(&path) {
+                Ok(raw) => raw,
+                Err(e) => {
+                    report.push(
+                        Diagnostic::error(
+                            node.rel_path.clone(),
+                            "E708",
+                            format!("OCR sidecar {:?} cannot be read: {e}", text.file),
+                        )
+                        .at(locator),
+                    );
+                    continue;
+                }
+            };
+
+            let ocr: crate::ocr::Ocr = match crate::ocr::from_markdown(&raw) {
+                Ok(ocr) => ocr,
+                Err(e) => {
+                    report.push(Diagnostic::error(
+                        rel(archive, &path),
+                        "E709",
+                        format!("not a valid OCR sidecar: {e}"),
+                    ));
+                    continue;
+                }
+            };
+
+            // `of` is what ties the sidecar back to the record. A sidecar pointing at some
+            // other id is a file that has been moved or copied without being updated, and the
+            // OCR it holds is then attached to the wrong pamphlet.
+            if ocr.of != node.id {
+                report.push(Diagnostic::error(
+                    rel(archive, &path),
+                    "E710",
+                    format!(
+                        "of = {:?}, but this sidecar is pointed at by {:?}",
+                        ocr.of, node.id
+                    ),
+                ));
+            }
+
+            // The page number is in the filename and in the frontmatter, and a mismatch means
+            // one of them is lying about which page this is — which silently misplaces every
+            // coordinate on it.
+            let expected = crate::ocr::file_name(&ocr.of, ocr.page);
+            if !text.file.ends_with(&expected) {
+                report.push(Diagnostic::error(
+                    rel(archive, &path),
+                    "E712",
+                    format!(
+                        "page = {}, which does not match the filename; expected {expected}",
+                        ocr.page
+                    ),
+                ));
+            }
+        }
+    }
+}